Spring Boot (十四)： Spring Boot 整合 Shiro-登录认证和权限管理（下）

2022-04-07 07:33:12

配置文件

spring
:

    datasource
:

      url
:
 jdbc
:
mysql
:
//localhost:3306/test

      username
:
 root

      password
:
 root

      driver
-
class
-
name
:
 com
.
mysql
.
jdbc
.
Driver



    jpa
:

      database
:
 mysql

      show
-
sql
:
 
true

      hibernate
:

        ddl
-
auto
:
 update

        naming
:

          strategy
:
 org
.
hibernate
.
cfg
.
DefaultComponentSafeNamingStrategy

      properties
:

         hibernate
:

            dialect
:
 org
.
hibernate
.
dialect
.
MySQL5Dialect



    thymeleaf
:

       cache
:
 
false

       mode
:
 LEGACYHTML5

thymeleaf的配置是为了去掉html的校验

页面

我们新建了六个页面用来测试：

  • index.html ：首页
  • login.html ：登录页
  • userInfo.html ： 用户信息页面
  • userInfoAdd.html ：添加用户页面
  • userInfoDel.html ：删除用户页面
  • 403.html ： 没有权限的页面

除过登录页面其它都很简单，大概如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. <h1>index</h1>
  9. </body>
  10. </html>

RBAC

RBAC 是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

采用 Jpa 技术来自动生成基础表格，对应的实体如下：

用户信息

  1. @Entity
  2. public class UserInfo implements Serializable {
  3. @Id
  4. @GeneratedValue
  5. private Integer uid;
  6. @Column(unique =true)
  7. private String username;//帐号
  8. private String name;//名称（昵称或者真实姓名，不同系统不同定义）
  9. private String password; //密码;
  10. private String salt;//加密密码的盐
  11. private byte state;//用户状态,0:创建未认证（比如没有激活，没有输入验证码等等）--等待验证的用户 , 1:正常状态,2：用户被锁定.
  12. @ManyToMany(fetch= FetchType.EAGER)//立即从数据库中进行加载数据;
  13. @JoinTable(name = "SysUserRole", joinColumns = { @JoinColumn(name = "uid") }, inverseJoinColumns ={@JoinColumn(name = "roleId") })
  14. private List<SysRole> roleList;// 一个用户具有多个角色

  16. // 省略 get set 方法
  17. }

角色信息

  1. @Entity
  2. public class SysRole {
  3. @Id@GeneratedValue
  4. private Integer id; // 编号
  5. private String role; // 角色标识程序中判断使用,如"admin",这个是唯一的:
  6. private String description; // 角色描述,UI界面显示使用
  7. private Boolean available = Boolean.FALSE; // 是否可用,如果不可用将不会添加给用户

  9. //角色 -- 权限关系：多对多关系;
  10. @ManyToMany(fetch= FetchType.EAGER)
  11. @JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="permissionId")})
  12. private List<SysPermission> permissions;

  14. // 用户 - 角色关系定义;
  15. @ManyToMany
  16. @JoinTable(name="SysUserRole",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="uid")})
  17. private List<UserInfo> userInfos;// 一个角色对应多个用户

  19. // 省略 get set 方法
  20. }

权限信息

  1. @Entity
  2. public class SysPermission implements Serializable {
  3. @Id@GeneratedValue
  4. private Integer id;//主键.
  5. private String name;//名称.
  6. @Column(columnDefinition="enum('menu','button')")
  7. private String resourceType;//资源类型，[menu|button]
  8. private String url;//资源路径.
  9. private String permission; //权限字符串,menu例子：role:*，button例子：role:create,role:update,role:delete,role:view
  10. private Long parentId; //父编号
  11. private String parentIds; //父编号列表
  12. private Boolean available = Boolean.FALSE;
  13. @ManyToMany
  14. @JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="permissionId")},inverseJoinColumns={@JoinColumn(name="roleId")})
  15. private List<SysRole> roles;

  17. // 省略 get set 方法
  18. }

根据以上的代码会自动生成 userinfo（用户信息表）、sysrole（角色表）、syspermission（权限表）、sysuserrole（用户角色表）、sysrole_permission（角色权限表）这五张表，为了方便测试我们给这五张表插入一些初始化数据：

  1. INSERT INTO `user_info` (`uid`,`username`,`name`,`password`,`salt`,`state`) VALUES ('1', 'admin', '管理员', 'd3c59d25033dbf980d29554025c23a75', '8d78869f470951332959580424d4bf4f', 0);
  2. INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (1,0,'用户管理',0,'0/','userInfo:view','menu','userInfo/userList');
  3. INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (2,0,'用户添加',1,'0/1','userInfo:add','button','userInfo/userAdd');
  4. INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (3,0,'用户删除',1,'0/1','userInfo:del','button','userInfo/userDel');
  5. INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (1,0,'管理员','admin');
  6. INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (2,0,'VIP会员','vip');
  7. INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (3,1,'test','test');
  8. INSERT INTO `sys_role_permission` VALUES ('1', '1');
  9. INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (1,1);
  10. INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (2,1);
  11. INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (3,2);
  12. INSERT INTO `sys_user_role` (`role_id`,`uid`) VALUES (1,1);

Shiro 配置

首先要配置的是 ShiroConfig 类，Apache Shiro 核心通过 Filter 来实现，就好像 SpringMvc 通过 DispachServlet 来主控制一样。 既然是使用 Filter 一般也就能猜到，是通过 URL 规则来进行过滤和权限校验，所以我们需要定义一系列关于 URL 的规则和访问权限。

ShiroConfig

  1. @Configuration
  2. public class ShiroConfig {
  3. @Bean
  4. public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
  5. System.out.println("ShiroConfiguration.shirFilter()");
  6. ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  7. shiroFilterFactoryBean.setSecurityManager(securityManager);
  8. //拦截器.
  9. Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();
  10. // 配置不会被拦截的链接 顺序判断
  11. filterChainDefinitionMap.put("/static/**", "anon");
  12. //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了
  13. filterChainDefinitionMap.put("/logout", "logout");
  14. //<!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边 -->:这是一个坑呢，一不小心代码就不好使了;
  15. //<!-- authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
  16. filterChainDefinitionMap.put("/**", "authc");
  17. // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
  18. shiroFilterFactoryBean.setLoginUrl("/login");
  19. // 登录成功后要跳转的链接
  20. shiroFilterFactoryBean.setSuccessUrl("/index");

  22. //未授权界面;
  23. shiroFilterFactoryBean.setUnauthorizedUrl("/403");
  24. shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
  25. return shiroFilterFactoryBean;
  26. }

  28. @Bean
  29. public MyShiroRealm myShiroRealm(){
  30. MyShiroRealm myShiroRealm = new MyShiroRealm();
  31. return myShiroRealm;
  32. }


  35. @Bean
  36. public SecurityManager securityManager(){
  37. DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  38. securityManager.setRealm(myShiroRealm());
  39. return securityManager;
  40. }
  41. }

Filter Chain 定义说明：

  • 1、一个URL可以配置多个 Filter，使用逗号分隔
  • 2、当设置多个过滤器时，全部验证通过，才视为通过
  • 3、部分过滤器可指定参数，如 perms，roles

Shiro 内置的 FilterChain

Spring Boot (十四)： Spring Boot 整合 Shiro-登录认证和权限管理（下）

  • anon:所有 url 都都可以匿名访问
  • authc: 需要认证才能进行访问
  • user:配置记住我或认证通过可以访问


登录认证实现

在认证、授权内部实现机制中都有提到，最终处理都将交给Real进行处理。因为在 Shiro 中，最终是通过 Realm 来获取应用程序中的用户、角色及权限信息的。通常情况下，在 Realm 中会直接从我们的数据源中获取 Shiro 需要的验证信息。可以说，Realm 是专用于安全框架的 DAO. Shiro 的认证过程最终会交由 Realm 执行，这时会调用 Realm 的 getAuthenticationInfo(token)方法。

该方法主要执行以下操作:

  • 1、检查提交的进行认证的令牌信息
  • 2、根据令牌信息从数据源(通常为数据库)中获取用户信息
  • 3、对用户信息进行匹配验证。
  • 4、验证通过将返回一个封装了用户信息的 AuthenticationInfo实例。
  • 5、验证失败则抛出 AuthenticationException异常信息。

而在我们的应用程序中要做的就是自定义一个 Realm 类，继承AuthorizingRealm 抽象类，重载 doGetAuthenticationInfo()，重写获取用户信息的方法。

doGetAuthenticationInfo 的重写

  1. @Override
  2. protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
  3. throws AuthenticationException {
  4. System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
  5. //获取用户的输入的账号.
  6. String username = (String)token.getPrincipal();
  7. System.out.println(token.getCredentials());
  8. //通过username从数据库中查找 User对象，如果找到，没找到.
  9. //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
  10. UserInfo userInfo = userInfoService.findByUsername(username);
  11. System.out.println("----->>userInfo="+userInfo);
  12. if(userInfo == null){
  13. return null;
  14. }
  15. SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
  16. userInfo, //用户名
  17. userInfo.getPassword(), //密码
  18. ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt
  19. getName() //realm name
  20. );
  21. return authenticationInfo;
  22. }

链接权限的实现

Shiro 的权限授权是通过继承 AuthorizingRealm抽象类，重载 doGetAuthorizationInfo();当访问到页面的时候，链接配置了相应的权限或者 Shiro 标签才会执行此方法否则不会执行，所以如果只是简单的身份认证没有权限的控制的话，那么这个方法可以不进行实现，直接返回 null 即可。在这个方法中主要是使用类： SimpleAuthorizationInfo进行角色的添加和权限的添加。

  1. @Override
  2. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  3. System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()");
  4. SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
  5. UserInfo userInfo = (UserInfo)principals.getPrimaryPrincipal();
  6. for(SysRole role:userInfo.getRoleList()){
  7. authorizationInfo.addRole(role.getRole());
  8. for(SysPermission p:role.getPermissions()){
  9. authorizationInfo.addStringPermission(p.getPermission());
  10. }
  11. }
  12. return authorizationInfo;
  13. }

当然也可以添加 set 集合：roles 是从数据库查询的当前用户的角色，stringPermissions 是从数据库查询的当前用户对应的权限

  1. authorizationInfo.setRoles(roles);
  2. authorizationInfo.setStringPermissions(stringPermissions);

就是说如果在shiro配置文件中添加了 filterChainDefinitionMap.put(“/add”,“perms[权限添加]”);就说明访问/add这个链接必须要有“权限添加”这个权限才可以访问，如果在shiro配置文件中添加了 filterChainDefinitionMap.put(“/add”,“roles[100002]，perms[权限添加]”);就说明访问 /add这个链接必须要有“权限添加”这个权限和具有“100002”这个角色才可以访问。

登录实现

登录过程其实只是处理异常的相关信息，具体的登录验证交给 Shiro 来处理

  1. @RequestMapping("/login")
  2. public String login(HttpServletRequest request, Map<String, Object> map) throws Exception{
  3. System.out.println("HomeController.login()");
  4. // 登录失败从request中获取shiro处理的异常信息。
  5. // shiroLoginFailure:就是shiro异常类的全类名.
  6. String exception = (String) request.getAttribute("shiroLoginFailure");
  7. System.out.println("exception=" + exception);
  8. String msg = "";
  9. if (exception != null) {
  10. if (UnknownAccountException.class.getName().equals(exception)) {
  11. System.out.println("UnknownAccountException -- > 账号不存在：");
  12. msg = "UnknownAccountException -- > 账号不存在：";
  13. } else if (IncorrectCredentialsException.class.getName().equals(exception)) {
  14. System.out.println("IncorrectCredentialsException -- > 密码不正确：");
  15. msg = "IncorrectCredentialsException -- > 密码不正确：";
  16. } else if ("kaptchaValidateFailed".equals(exception)) {
  17. System.out.println("kaptchaValidateFailed -- > 验证码错误");
  18. msg = "kaptchaValidateFailed -- > 验证码错误";
  19. } else {
  20. msg = "else >> "+exception;
  21. System.out.println("else -- >" + exception);
  22. }
  23. }
  24. map.put("msg", msg);
  25. // 此方法不处理登录成功,由shiro进行处理
  26. return "/login";
  27. }

其它 Dao 层和 Service 的代码就不贴出来了大家直接看代码。

测试

1、编写好后就可以启动程序，访问 http://localhost:8080/userInfo/userList页面，由于没有登录就会跳转到 http://localhost:8080/login页面。登录之后就会跳转到 index 页面，登录后，直接在浏览器中输入 http://localhost:8080/userInfo/userList访问就会看到用户信息。上面这些操作时候触发 MyShiroRealm.doGetAuthenticationInfo()这个方法，也就是登录认证的方法。

2、登录admin账户，访问： http://127.0.0.1:8080/userInfo/userAdd显示 用户添加界面，访问 http://127.0.0.1:8080/userInfo/userDel显示 403没有权限。上面这些操作时候触发 MyShiroRealm.doGetAuthorizationInfo()这个方面，也就是权限校验的方法。

3、修改 admin不 同的权限进行测试

Shiro 很强大，这仅仅是完成了登录认证和权限管理这两个功能，更多内容以后有时间再做探讨。

上一篇：CorelDraw(CDR)设计制作立体文字海报教程


下一篇：寒假学习 第一天 （QT学习）