【Shiro】Apache Shiro架构之自定义realm

曾经终败给现在 2022-09-22 11:44 423阅读 0赞

欢迎关注我新搭建的博客：http://www.itcodai.com/

Shiro系列文章：
【Shiro】Apache Shiro架构之身份认证（Authentication）
【Shiro】Apache Shiro架构之权限认证（Authorization）
【Shiro】Apache Shiro架构之集成web
【Shiro】Apache Shiro架构之实际运用（整合到Spring中)

　　
　　之前写的博客里都是使用.ini文件来获取信息的，包括用户信息，角色信息，权限信息等。进入系统时，都是从.ini文件这读取进入的。实际中除非这个系统特别特别简单，否则一般都不是这样干的，这些信息都是需要在数据库中进行维护的，所以就需要用到自定义realm了。

写在前面：这篇博文是基于上一篇Shiro集成web基础之上修改的。

1. 数据库建表

　　首先在数据库中新建三个表：t_user，t_role和t_permission，分别存储用户信息，角色信息和权限信息，建表语句如下：

  1. CREATE TABLE `t_role` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', `rolename` varchar(20) DEFAULT NULL COMMENT '角色名称', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 CREATE TABLE `t_user` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户主键', `username` varchar(20) NOT NULL COMMENT '用户名', `password` varchar(20) NOT NULL COMMENT '密码', `role_id` int(11) DEFAULT NULL COMMENT '外键关联role表', PRIMARY KEY (`id`), KEY `role_id` (`role_id`), CONSTRAINT `t_user_ibfk_1` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 CREATE TABLE `t_permission` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', `permissionname` varchar(50) NOT NULL COMMENT '权限名', `role_id` int(11) DEFAULT NULL COMMENT '外键关联role', PRIMARY KEY (`id`), KEY `role_id` (`role_id`), CONSTRAINT `t_permission_ibfk_1` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8

　　每个表中我添加了一些测试数据，如下：
user

role

permission

2. 自定义realm

　　自定义realm中需要操作数据库，所有首先得先写一个dao，使用的是原始的jdbc，主要是下面的自定义realm。

  1. public class UserDao { 
  3.     //根据用户名查找用户
  4.     public User getByUsername(Connection conn, String username) throws Exception {
  6.         User resultUser = null;
  7.         String sql = "select * from t_user where username=?";
  8.         PreparedStatement ps = conn.prepareStatement(sql);
  9.         ps.setString(1, username);
  10.         ResultSet rs = ps.executeQuery();
  11.         if(rs.next()) {
  12.             resultUser = new User();
  13.             resultUser.setId(rs.getInt("id"));
  14.             resultUser.setUsername(rs.getString("username"));
  15.             resultUser.setPassword(rs.getString("password"));
  16.         }
  17.         return resultUser;
  18.     }
  20.     //根据用户名查找改用户所拥有的角色
  21.     public Set<String> getRoles(Connection conn, String username) throws Exception {
  22.         Set<String> roles = new HashSet<String>();
  23.         String sql = "select * from t_user u, t_role r where u.role_id=r.id and u.username=?";
  24.         PreparedStatement ps = conn.prepareStatement(sql);
  25.         ps.setString(1, username);
  26.         ResultSet rs = ps.executeQuery();
  27.         while(rs.next()) {
  28.             roles.add(rs.getString("rolename"));
  29.         }
  30.         return roles;
  31.     }
  33.     //根据用户名查找该用户角色所拥有的权限
  34.     public Set<String> getPerms(Connection conn, String username) throws Exception {
  35.         Set<String> perms = new HashSet<String>();
  36.         String sql = "select * from t_user u, t_role r, t_permission p where u.role_id=r.id and p.role_id=r.id and u.username=?";
  37.         PreparedStatement ps = conn.prepareStatement(sql);
  38.         ps.setString(1, username);
  39.         ResultSet rs = ps.executeQuery();
  40.         while(rs.next()) {
  41.             perms.add(rs.getString("permissionname"));
  42.         }
  43.         return perms;
  44.     }
  45. }

　　有了dao了，接下来就可以写自定义的realm了，自定义realm需要继承AuthorizingRealm类，因为该类封装了很多方法，它也是一步步继承自Realm类的，继承了AuthorizingRealm类后，需要重写两个方法：

doGetAuthenticationInfo()方法：用来验证当前登录的用户，获取认证信息
doGetAuthorizationInfo()方法：用来为当前登陆成功的用户授予权限和角色（已经登陆成功了）

　　下面来看一下具体的实现：

  1. public class MyRealm extends AuthorizingRealm { 
  3.     private UserDao userDao = new UserDao();
  5.     // 为当前登陆成功的用户授予权限和角色，已经登陆成功了
  6.     @Override
  7.     protected AuthorizationInfo doGetAuthorizationInfo(
  8.             PrincipalCollection principals) {
  9.         String username = (String) principals.getPrimaryPrincipal(); //获取用户名
  10.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
  11.         Connection conn = null;
  12.         try {
  13.             conn = DbUtil.getConnection();
  14.             authorizationInfo.setRoles(userDao.getRoles(conn, username)); //设置角色
  15.             authorizationInfo.setStringPermissions(userDao.getPerms(conn, username)); //设置权限 
  16.         } catch (Exception e) {
  17.             // TODO Auto-generated catch block
  18.             e.printStackTrace();
  19.         } finally {
  20.             try {
  21.                 DbUtil.closeConnection(conn);
  22.             } catch (Exception e) {
  23.                 // TODO Auto-generated catch block
  24.                 e.printStackTrace();
  25.             }
  26.         }
  27.         return authorizationInfo;
  28.     }
  30.     // 验证当前登录的用户，获取认证信息
  31.     @Override
  32.     protected AuthenticationInfo doGetAuthenticationInfo(
  33.             AuthenticationToken token) throws AuthenticationException {
  34.         String username = (String) token.getPrincipal(); // 获取用户名
  35.         Connection conn = null;
  36.         try {
  37.             conn = DbUtil.getConnection();
  38.             User user = userDao.getByUsername(conn, username); // 仅仅是根据用户名查出的用户信息，不涉及到密码
  39.             if (user != null) {
  40.                 AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(
  41.                         user.getUsername(), user.getPassword(), "myrealm");
  42.                 return authcInfo;
  43.             } else {
  44.                 return null;
  45.             }
  46.         } catch (Exception e) {
  47.             // TODO Auto-generated catch block
  48.             e.printStackTrace();
  49.         } finally {
  50.             try {
  51.                 DbUtil.closeConnection(conn);
  52.             } catch (Exception e) {
  53.                 // TODO Auto-generated catch block
  54.                 e.printStackTrace();
  55.             }
  56.         }
  57.         return null;
  58.     }
  59. }

　　从上面两个方法中可以看出：验证身份的时候是根据用户输入的用户名先从数据库中查出该用户名对应的用户，这时候并没有涉及到密码，也就是说到这一步的时候，即使用户输入的密码不对，也是可以查出来该用户的，然后将该用户的正确信息封装到authcInfo 中返回给Shiro，接下来就是Shiro的事了，它会根据这里面的真实信息与用户前台输入的用户名和密码进行校验， 这个时候也要校验密码了，如果校验通过就让用户登录，否则跳转到指定页面。同理，权限验证的时候也是先根据用户名获取与该用户名有关的角色和权限，然后封装到authorizationInfo中返回给Shiro。

3. 修改ini文件

　　在该配置文件中，[users]和[roles]的信息就可以删掉了，因为这些信息都是从数据库中维护的，另外还要在文件中指定我们自定义的realm的完全限定名，并且指定securityManager的realm使用我们自定义的realm，如下：

  1. [main]
  2. authc.loginUrl=/login
  3. roles.unauthorizedUrl=/unauthorized.jsp
  4. perms.unauthorizedUrl=/unauthorized.jsp
  6. #定义自己的realm
  7. myRealm=demo.shiro.realm.MyRealm
  8. securityManager.realms=$myRealm
  10. #定义请求的地址需要做什么验证
  11. [urls]
  12. /login=anon 
  13. /admin=authc 
  14. /student=roles[teacher]
  15. /teacher=perms["user:create"]

　　这样我们自定义的realm就搞定了，根据配置文件，当我们请求…/admin的时候会进行身份认证，所以会进入LoginServlet中，当调用currentUser.login(token);的时候，就会进入我们自定义的realm中的doGetAuthenticationInfo方法进行身份初始化，然后交给Shiro去验证。当我们请求…./student的时候，也会先进行身份验证，就是上面的过程，然后验证通过，当我们再次请求…/student的时候，就会进入我们自定义的realm中的doGetAuthorizationInfo方法进行权限的初始化，然后交给Shiro去验证。
　　下一篇博文我将总结一下如何将Shiro运用到实际项目中，即如何将Shiro整合到Spring中。

文末福利：“程序员私房菜”，一个有温度的公众号~
程序员私房菜

—–乐于分享，共同进步！
—–我的博客主页：http://blog.csdn.net/eson_15

发表评论

表情：
评论列表 （有 0 条评论，423人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Shiro自定义Realms

    Shiro 的三个核心组件：Subject, SecurityManager 和 Realms. 来回顾一下这三个组件的关系 ![Shiro 的三个核心组件][Shiro]

    墨蓝墨蓝/ 0 赞/ 510 阅读