• Shiro高级及SaaS-HRM的认证授权

    Shiro在SpringBoot工程的应用

    Apache Shiro是一个功能强大、灵活的，开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。越来越多的企业使用Shiro作为项目的安全框架，保证项目的平稳运行。

    在之前的讲解中只是单独的使用shiro，方便学员对shiro有一个直观且清晰的认知，我们今天就来看一下shiro在springBoot工程中如何使用以及其他特性

    案例说明

    使用springBoot构建应用程序，整合shiro框架完成用户认证与授权。

    数据库表

    基本工程结构

    导入资料中准备的基本工程代码，此工程中实现了基本用户角色权限的操作。我们只需要在此工程中添加Shiro相关的操作代码即可

    整合Shiro

    spring和shiro的整合依赖

    1. <dependency>
    2.     <groupId>org.apache.shiro</groupId>
    3.     <artifactId>shiro-spring</artifactId>
    4.     <version>1.3.2</version>
    5. </dependency>
    6. <dependency>
    7.      <groupId>org.apache.shiro</groupId>
    8.      <artifactId>shiro-core</artifactId>
    9.      <version>1.3.2</version>
    10. </dependency>

    修改登录方法

    认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，shiro需要采集到用户登录数据使用subject的login方法进入realm完成认证工作。

    1.     @RequestMapping(value="/login")
    2.     public String login(String username,String password) {
    3.         try{
    4.             Subject subject = SecurityUtils.getSubject();
    5.             UsernamePasswordToken uptoken = new UsernamePasswordToken(username,password);
    6.             subject.login(uptoken);
    7.             return "登录成功";
    8.        }catch (Exception e) {
    9.             return "用户名或密码错误";
    10.        }
    11.    }

    自定义realm

    Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么 它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源

    1. package cn.itcast.shiro.realm;
    2.  
    3. import cn.itcast.shiro.domain.Permission;
    4. import cn.itcast.shiro.domain.Role;
    5. import cn.itcast.shiro.domain.User;
    6. import cn.itcast.shiro.service.UserService;
    7. import org.apache.shiro.authc.*;
    8. import org.apache.shiro.authz.AuthorizationInfo;
    9. import org.apache.shiro.authz.SimpleAuthorizationInfo;
    10. import org.apache.shiro.crypto.hash.Md5Hash;
    11. import org.apache.shiro.realm.AuthorizingRealm;
    12. import org.apache.shiro.subject.PrincipalCollection;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14.  
    15. import java.util.HashSet;
    16. import java.util.Set;
    17.  
    18. /**
    19.  * 自定义的realm
    20.  */
    21. public class CustomRealm extends AuthorizingRealm {
    22.  
    23.     public void setName(String name) {
    24.         super.setName("customRealm");
    25.     }
    26.  
    27.     @Autowired
    28.     private UserService userService;
    29.  
    30.     /**
    31.      * 授权方法
    32.      *      操作的时候，判断用户是否具有响应的权限
    33.      *          先认证 -- 安全数据
    34.      *          再授权 -- 根据安全数据获取用户具有的所有操作权限
    35.      *
    36.      *
    37.      */
    38.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    39.         //1.获取已认证的用户数据
    40.         User user = (User) principalCollection.getPrimaryPrincipal();//得到唯一的安全数据
    41.         //2.根据用户数据获取用户的权限信息（所有角色，所有权限）
    42.         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    43.         Set<String> roles = new HashSet<>();//所有角色
    44.         Set<String> perms = new HashSet<>();//所有权限
    45.         for (Role role : user.getRoles()) {
    46.             roles.add(role.getName());
    47.             for (Permission perm : role.getPermissions()) {
    48.                 perms.add(perm.getCode());
    49.             }
    50.         }
    51.         info.setStringPermissions(perms);
    52.         info.setRoles(roles);
    53.         return info;
    54.     }
    55.  
    56.  
    57.     /**
    58.      * 认证方法
    59.      *  参数：传递的用户名密码
    60.      */
    61.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    62.         //1.获取登录的用户名密码（token）
    63.         UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
    64.         String username = upToken.getUsername();
    65.         String password = new String( upToken.getPassword());
    66.         //2.根据用户名查询数据库
    67.         User user = userService.findByName(username);
    68.         //3.判断用户是否存在或者密码是否一致
    69.         if(user != null && user.getPassword().equals(password)) {
    70.             //4.如果一致返回安全数据
    71.             //构造方法：安全数据，密码，realm域名
    72.             SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
    73.             return info;
    74.         }
    75.         //5.不一致，返回null（抛出异常）
    76.         return null;
    77.     }
    78.  
    79.  
    80.     public static void main(String[] args) {
    81.         System.out.println(new Md5Hash("123456","wangwu",3).toString());
    82.     }
    83. }

    Shiro的配置

    SecurityManager 是 Shiro 架构的心脏，用于协调内部的多个组件完成全部认证授权的过程。例如通过调用realm 完成认证与登录。使用基于springboot的配置方式完成SecurityManager，Realm的装配

    1. package cn.itcast.shiro;
    2.  
    3. import cn.itcast.shiro.realm.CustomRealm;
    4. import cn.itcast.shiro.session.CustomSessionManager;
    5. import org.apache.shiro.mgt.SecurityManager;
    6. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
    7. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    8. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    9. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    10. import org.crazycake.shiro.RedisCacheManager;
    11. import org.crazycake.shiro.RedisManager;
    12. import org.crazycake.shiro.RedisSessionDAO;
    13. import org.springframework.beans.factory.annotation.Value;
    14. import org.springframework.context.annotation.Bean;
    15. import org.springframework.context.annotation.Configuration;
    16.  
    17. import java.util.LinkedHashMap;
    18. import java.util.Map;
    19.  
    20. @Configuration
    21. public class ShiroConfiguration {
    22.  
    23.     //1.创建realm
    24.     @Bean
    25.     public CustomRealm getRealm() {
    26.         return new CustomRealm();
    27.     }
    28.  
    29.     //2.创建安全管理器
    30.     @Bean
    31.     public SecurityManager getSecurityManager(CustomRealm realm) {
    32.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    33.         securityManager.setRealm(realm);
    34.  
    35.         //将自定义的会话管理器注册到安全管理器中
    36.         securityManager.setSessionManager(sessionManager());
    37.         //将自定义的redis缓存管理器注册到安全管理器中
    38.         securityManager.setCacheManager(cacheManager());
    39.  
    40.         return securityManager;
    41.     }
    42.  
    43.     //3.配置shiro的过滤器工厂
    44.  
    45.     /**
    46.      * 再web程序中，shiro进行权限控制全部是通过一组过滤器集合进行控制
    47.      *
    48.      */
    49.     @Bean
    50.     public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
    51.         //1.创建过滤器工厂
    52.         ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
    53.         //2.设置安全管理器
    54.         filterFactory.setSecurityManager(securityManager);
    55.         //3.通用配置（跳转登录页面，为授权跳转的页面）
    56.         filterFactory.setLoginUrl("/autherror?code=1");//跳转url地址
    57.         filterFactory.setUnauthorizedUrl("/autherror?code=2");//未授权的url
    58.         //4.设置过滤器集合
    59.  
    60.         /**
    61.          * 设置所有的过滤器：有顺序map
    62.          *     key = 拦截的url地址
    63.          *     value = 过滤器类型
    64.          *
    65.          */
    66.         Map<String,String> filterMap = new LinkedHashMap<>();
    67.         //filterMap.put("/user/home","anon");//当前请求地址可以匿名访问
    68.  
    69.         //具有某中权限才能访问
    70.         //使用过滤器的形式配置请求地址的依赖权限
    71.         //filterMap.put("/user/home","perms[user-home]"); //不具备指定的权限，跳转到setUnauthorizedUrl地址
    72.  
    73.         //使用过滤器的形式配置请求地址的依赖角色
    74.         //filterMap.put("/user/home","roles[系统管理员]");
    75.  
    76.         filterMap.put("/user/**","authc");//当前请求地址必须认证之后可以访问
    77.  
    78.         filterFactory.setFilterChainDefinitionMap(filterMap);
    79.  
    80.         return filterFactory;
    81.     }
    82.  
    83.  
    84.     @Value("${spring.redis.host}")
    85.     private String host;
    86.     @Value("${spring.redis.port}")
    87.     private int port;
    88.  
    89.     /**
    90.      * 1.redis的控制器，操作redis
    91.      */
    92.     public RedisManager redisManager() {
    93.         RedisManager redisManager = new RedisManager();
    94.         redisManager.setHost(host);
    95.         redisManager.setPort(port);
    96.         return redisManager;
    97.     }
    98.  
    99.     /**
    100.      * 2.sessionDao
    101.      */
    102.     public RedisSessionDAO redisSessionDAO() {
    103.         RedisSessionDAO sessionDAO = new RedisSessionDAO();
    104.         sessionDAO.setRedisManager(redisManager());
    105.         return sessionDAO;
    106.     }
    107.  
    108.     /**
    109.      * 3.会话管理器
    110.      */
    111.     public DefaultWebSessionManager sessionManager() {
    112.         CustomSessionManager sessionManager = new CustomSessionManager();
    113.         sessionManager.setSessionDAO(redisSessionDAO());
    114.         return sessionManager;
    115.     }
    116.  
    117.     /**
    118.      * 4.缓存管理器
    119.      */
    120.     public RedisCacheManager cacheManager() {
    121.         RedisCacheManager redisCacheManager = new RedisCacheManager();
    122.         redisCacheManager.setRedisManager(redisManager());
    123.         return redisCacheManager;
    124.     }
    125.  
    126.  
    127.     //开启对shior注解的支持
    128.     @Bean
    129.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    130.         AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
    131.         advisor.setSecurityManager(securityManager);
    132.         return advisor;
    133.     }
    134. }

    shiro中的过滤器

    Filter

    解释

    anon

    无参，开放权限，可以理解为匿名用户或游客

    authc

    无参，需要认证

    logout

    无参，注销，执行后会直接跳转到 shiroFilterFactoryBean.setLoginUrl(); 设置的

    url

    authcBasic

    无参，表示 httpBasic 认证

    user

    无参，表示必须存在用户，当登入操作时不做检查

    ssl

    无参，表示安全的URL请求，协议为 https

    perms[user]

    参数可写多个，表示需要某个或某些权限才能通过，多个参数时写 perms[“user, admin”]，当有多个参数时必须每个参数都通过才算通过

    roles[admin]

    参数可写多个，表示是某个或某些角色才能通过，多个参数时写 roles[“admin，user”]， 当有多个参数时必须每个参数都通过才算通过

    rest[user]

    根据请求的方法，相当于 perms[user:method]，其中 method 为 post，get，delete 等

    port[8081]

    当请求的URL端口不是8081时，跳转到当前访问主机HOST的8081端口

    注意：anon, authc, authcBasic, user 是第一组认证过滤器，perms, port, rest, roles, ssl 是第二组授权过滤器，要通过授权过滤器，就先要完成登陆认证操作（即先要完成认证才能前去寻找授权) 才能走第二组授权器（例如访问需要 roles 权限的 url，如果还没有登陆的话，会直接跳转到shiroFilterFactoryBean.setLoginUrl(); 设置的 url ）

    骚戴理解：shiro的权限控制都是通过一大堆的过滤器来实现的，常用的过滤器就四个，分别是anon、authc、perms[user]、roles[admin]，anon就是公开的，没限制，authc就是必须登录，perms[user]就是权限里必须有user这个字符才可以访问，roles[admin]就是角色里必须有admin这个角色才可以访问

    授权

    授权：即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情

    shiro支持基于过滤器的授权方式也支持注解的授权方式

    基于配置的授权

    在shiro中可以使用过滤器的方式配置目标地址的请求权限

    1.         //配置请求连接过滤器配置
    2.         //匿名访问（所有人员可以使用）
    3.         filterMap.put("/user/home", "anon");
    4.         //具有指定权限访问
    5.         filterMap.put("/user/find", "perms[user-find]");
    6.         //认证之后访问（登录之后可以访问）
    7.         filterMap.put("/user/**", "authc");
    8.         //具有指定角色可以访问
    9.         filterMap.put("/user/**", "roles[系统管理员]");

    基于配置的方式进行授权，一旦操作用户不具备操作权限，目标地址不会被执行。会跳转到指定的url连接地址（也就是下面代码设置的路径）。所以需要在连接地址中更加友好的处理未授权的信息提示

    1. filterFactory.setLoginUrl("/autherror?code=1");//跳转url地址
    2. filterFactory.setUnauthorizedUrl("/autherror?code=2");//未授权的url

    基于注解的授权

    RequiresPermissions

    配置到方法上，表明执行此方法必须具有指定的权限

    1. //查询
    2. @RequiresPermissions(value = "user-find")
    3.  public String find() { 
    4.     return "查询用户成功";
    5. }

    RequiresRoles

    配置到方法上，表明执行此方法必须具有指定的角色

    1.     //查询
    2.     @RequiresRoles(value = "系统管理员")
    3.     public String find() {
    4.        return "查询用户成功";
    5.    }

    基于注解的配置方式进行授权，一旦操作用户不具备操作权限，目标方法不会被执行，而且会抛出

    AuthorizationException 异常。所以需要做好统一异常处理完成未授权处理

    • 使用注解的话要在配置类中配置一个Bean
    1.     //开启对shior注解的支持
    2.     @Bean
    3.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    4.         AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
    5.         advisor.setSecurityManager(securityManager);
    6.         return advisor;
    7.     }

    Shiro中的会话管理

    在shiro里所有的用户的会话信息都会由Shiro来进行控制，shiro提供的会话可以用于JavaSE/JavaEE环境，不依赖 于任何底层容器，可以独立使用，是完整的会话模块。通过Shiro的会话管理器（SessionManager）进行统一的会话管理

    什么是shiro的会话管理

    SessionManager（会话管理器）：管理所有Subject的session包括创建、维护、删除、失效、验证等工作。SessionManager是顶层组件，由SecurityManager管理

    shiro提供了三个默认实现：

    • DefaultSessionManager：用于JavaSE环境
    • ServletContainerSessionManager（默认）：用于Web环境，直接使用servlet容器的会话。
    • DefaultWebSessionManager（自定义）：用于web环境，自己维护会话（自己维护着会话，直接废弃了Servlet容器的会话管理）。

    在web程序中，通过shiro的Subject.login()方法登录成功后，用户的认证信息实际上是保存在HttpSession中的通过如下代码验证。

    1.     //登录成功后，打印所有session内容
    2.      @RequestMapping(value="/show")
    3.     public String show(HttpSession session) {
    4.         // 获取session中所有的键值
    5.         Enumeration<?> enumeration = session.getAttributeNames();
    6.         // 遍历enumeration中的
    7.         while (enumeration.hasMoreElements()) {
    8.             // 获取session键值
    9.             String name = enumeration.nextElement().toString();
    10.             // 根据键值取session中的值
    11.             Object value = session.getAttribute(name);
    12.             // 打印结果
    13.             System.out.println("" + name + "=" + value + "
      /n"      );
    14.        }
    15.         return "查看session成功";
    16.    }

    应用场景分析

    在分布式系统或者微服务架构下，都是通过统一的认证中心进行用户认证。如果使用默认会话管理，用户信息只会 保存到一台服务器上。那么其他服务就需要进行会话的同步。

    会话管理器可以指定sessionId的生成以及获取方式。通过sessionDao完成模拟session存入，取出等操作

    Shiro结合redis的统一会话管理

    步骤分析

    构建环境

    使用开源组件Shiro-Redis可以方便的构建shiro与redis的整合工程。

    1. <dependency>
    2.      <groupId>org.crazycake</groupId>
    3.      <artifactId>shiro-redis</artifactId>
    4.      <version>3.0.0</version>
    5. </dependency>

    在springboot配置文件中添加redis配置

    1.  redis:
    2.    host: 127.0.0.1
    3.    port: 6379

    自定义shiro会话管理器

    1. package cn.itcast.shiro.session;
    2.  
    3. import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
    4. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    5. import org.apache.shiro.web.util.WebUtils;
    6. import org.springframework.util.StringUtils;
    7.  
    8. import javax.servlet.ServletRequest;
    9. import javax.servlet.ServletResponse;
    10. import java.io.Serializable;
    11.  
    12. /**
    13.  * 自定义的sessionManager
    14.  */
    15. public class CustomSessionManager extends DefaultWebSessionManager {
    16.  
    17.  
    18.     /**
    19.      * 头信息中具有sessionid
    20.      *      请求头：Authorization： sessionid
    21.      *
    22.      * 指定sessionId的获取方式
    23.      */
    24.     protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
    25.  
    26.         //获取请求头Authorization中的数据
    27.         String id = WebUtils.toHttp(request).getHeader("Authorization");
    28.         if(StringUtils.isEmpty(id)) {
    29.             //如果没有携带，生成新的sessionId
    30.             return super.getSessionId(request,response);
    31.         }else{
    32.             //返回sessionId；
    33.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
    34.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
    35.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
    36.             return id;
    37.         }
    38.     }
    39. }

    配置Shiro基于redis的会话管理

    在Shiro配置类 配置cn.itcast.shiro.ShiroConfiguration

    • 配置shiro的RedisManager，通过shiro-redis包提供的RedisManager统一对redis操作
    1. @Value("${spring.redis.host}")
    2. private String host;
    3. @Value("${spring.redis.port}")
    4. private int port;
    5. //配置shiro redisManager
    6. public RedisManager redisManager() {
    7.     RedisManager redisManager = new RedisManager();
    8.     redisManager.setHost(host);
    9.     redisManager.setPort(port);
    10.     return redisManager;
    11. }
    • Shiro内部有自己的本地缓存机制，为了更加统一方便管理，全部替换redis实现
    1. //配置Shiro的缓存管理器
    2. //使用redis实现
    3. public RedisCacheManager cacheManager() {
    4.      RedisCacheManager redisCacheManager = new RedisCacheManager();
    5.      redisCacheManager.setRedisManager(redisManager());
    6.      return redisCacheManager;
    7. }
    • 配置SessionDao，使用shiro-redis实现的基于redis的sessionDao
    1. /**
    2. * RedisSessionDAO shiro sessionDao层的实现 通过redis
    3. * 使用的是shiro-redis开源插件
    4. */
    5. public RedisSessionDAO redisSessionDAO() {
    6.     RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
    7.     redisSessionDAO.setRedisManager(redisManager());
    8.     return redisSessionDAO;
    9. }
    • 配置会话管理器，指定sessionDao的依赖关系
    1.     /**
    2.      * 3.会话管理器
    3.      */
    4.     public DefaultWebSessionManager sessionManager() {
    5.         CustomSessionManager sessionManager = new CustomSessionManager();
    6.         sessionManager.setSessionDAO(redisSessionDAO());
    7.         return sessionManager;
    8.    }
    • 统一交给SecurityManager管理
    1.     //配置安全管理器
    2.     @Bean
    3.     public SecurityManager securityManager(CustomRealm realm) {
    4.         //使用默认的安全管理器
    5.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(realm);
    6.         // 自定义session管理 使用redis
    7.         securityManager.setSessionManager(sessionManager());
    8.         // 自定义缓存实现 使用redis
    9.         securityManager.setCacheManager(cacheManager());
    10.         //将自定义的realm交给安全管理器统一调度管理
    11.         securityManager.setRealm(realm);
    12.         return securityManager;
    13.    }

    SaaS-HRM中的认证授权

    需求分析

    实现基于Shiro的SaaS平台的统一权限管理。我们的SaaS-HRM系统是基于微服务构建，所以在使用Shiro鉴权的时候，就需要将认证信息保存到统一的redis服务器中完成。这样，每个微服务都可以通过指定cookie中的sessionid获取公共的认证信息。

    搭建环境

    导入依赖

    父工程导入Shiro的依赖

    1. <dependency>
    2.     <groupId>org.apache.shiro</groupId>
    3.     <artifactId>shiro-spring</artifactId>
    4.     <version>1.3.2</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>org.apache.shiro</groupId>
    8.     <artifactId>shiro-core</artifactId>
    9.     <version>1.3.2</version>
    10. </dependency>
    11. <dependency>
    12.     <groupId>org.crazycake</groupId>
    13.     <artifactId>shiro-redis</artifactId>
    14.     <version>3.0.0</version>
    15. </dependency>

    配置值对象

    不需要存入redis太多的用户数据，和获取用户信息的返回对象一致即可，需要实现AuthCachePrincipali接口

    1. @Setter
    2. @Getter
    3. public class ProfileResult implements Serializable,AuthCachePrincipal {
    4.     private String mobile;
    5.     private String username;
    6.     private String company;
    7.     private String companyId;
    8.     private Map<String,Object> roles = new HashMap<>();
    9.  //省略
    10. }

    骚戴理解：通过将authcacheprincipal接口的实现添加到profileresult类中，该类的实例对象可以用作身份验证系统的凭据，并缓存在身份验证高速缓存中，以提高身份验证效率。同时可序列化则表示它可以被网络传输或者持久化到数据库中。简单来说就是使用shiro认证，也就是登录校验的时候会传入一个安全数据存储到shiro的会话中，其实就是存在内存中，然后这个安全数据是对象的话要实现authcacheprincipal这个接口！！！看下面的代码就知道了ProfileResult就是这个安全数据！！！

    1.  //认证方法
    2.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    3.         //1.获取用户的手机号和密码
    4.         UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
    5.         String mobile = upToken.getUsername();
    6.         String password = new String( upToken.getPassword());
    7.         //2.根据手机号查询用户
    8.         User user = userService.findByMobile(mobile);
    9.         //3.判断用户是否存在，用户密码是否和输入密码一致
    10.         if(user != null && user.getPassword().equals(password)) {
    11.             //4.构造安全数据并返回（安全数据：用户基本数据，权限信息 profileResult）
    12.             ProfileResult result = null;
    13.             if("user".equals(user.getLevel())) {
    14.                 result = new ProfileResult(user);
    15.            }else {
    16.                 Map map = new HashMap();
    17.                 if("coAdmin".equals(user.getLevel())) {
    18.                     map.put("enVisible","1");
    19.                }
    20.                 List<Permission> list = permissionService.findAll(map);
    21.                 result = new ProfileResult(user,list);
    22.            }
    23.             //构造方法：安全数据，密码，realm域名
    24.             SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(result,user.getPassword(),this.getName());
    25.             return info;
    26.        }
    27.         //返回null，会抛出异常，标识用户名和密码不匹配
    28.         return null;
    29.    }
    30. }

    配置未认证controller

    为了在多个微服务中使用，配置公共的未认证未授权的Controller

    1. @RestController
    2. @CrossOrigin
    3. public class ErrorController {
    4.     //公共错误跳转
    5.     @RequestMapping(value="autherror")
    6.     public Result autherror(int code) {
    7.         return code ==1?new Result(ResultCode.UNAUTHENTICATED):new Result(ResultCode.UNAUTHORISE);
    8.    }
    9. }

    骚戴理解：上面这个控制器是跟下面配置类中的两行代码并肩作战的，也就是如果校验权限发现有权限就会跳转到/autherror?code=1，权限不足就跳到/autherror?code=2

    1. //3.通用配置（跳转登录页面，未授权跳转的页面）
    2. filterFactory.setLoginUrl("/autherror?code=1");//跳转url地址
    3. filterFactory.setUnauthorizedUrl("/autherror?code=2");//未授权的url

    自定义的公共异常处理器

    1. package com.ihrm.common.handler;
    2.  
    3. import com.ihrm.common.entity.Result;
    4. import com.ihrm.common.entity.ResultCode;
    5. import com.ihrm.common.exception.CommonException;
    6. import org.apache.shiro.authz.AuthorizationException;
    7. import org.springframework.web.bind.annotation.ControllerAdvice;
    8. import org.springframework.web.bind.annotation.ExceptionHandler;
    9. import org.springframework.web.bind.annotation.ResponseBody;
    10.  
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13.  
    14. /**
    15.  * 自定义的公共异常处理器
    16.  *      1.声明异常处理器
    17.  *      2.对异常统一处理
    18.  */
    19. @ControllerAdvice
    20. public class BaseExceptionHandler {
    21.  
    22.     @ExceptionHandler(value = Exception.class)
    23.     @ResponseBody
    24.     public Result error(HttpServletRequest request, HttpServletResponse response,Exception e) {
    25.         e.printStackTrace();
    26.         if(e.getClass() == CommonException.class) {
    27.             //类型转型
    28.             CommonException ce = (CommonException) e;
    29.             Result result = new Result(ce.getResultCode());
    30.             return result;
    31.         }else{
    32.             Result result = new Result(ResultCode.SERVER_ERROR);
    33.             return result;
    34.         }
    35.     }
    36.  
    37.     @ExceptionHandler(value = AuthorizationException.class)
    38.     @ResponseBody
    39.     public Result error(HttpServletRequest request, HttpServletResponse response,AuthorizationException e) {
    40.         return new Result(ResultCode.UNAUTHORISE);
    41.     }
    42. }

    骚戴理解：因为这里是用的Shiro注解鉴权，如果鉴权失败是会抛出异常的，所以需要通过这个异常处理器来统一处理这些异常

    自定义realm授权

    ihrm-common模块下创建公共的认证与授权realm，需要注意的是，此realm只处理授权数据即可，认证方法需要在登录模块中补全。

    1. package com.ihrm.common.shiro.realm;
    2.  
    3. import com.ihrm.domain.system.response.ProfileResult;
    4. import org.apache.shiro.authc.AuthenticationException;
    5. import org.apache.shiro.authc.AuthenticationInfo;
    6. import org.apache.shiro.authc.AuthenticationToken;
    7. import org.apache.shiro.authz.AuthorizationInfo;
    8. import org.apache.shiro.authz.SimpleAuthorizationInfo;
    9. import org.apache.shiro.realm.AuthorizingRealm;
    10. import org.apache.shiro.subject.PrincipalCollection;
    11.  
    12. import java.util.Set;
    13.  
    14. //公共的realm：获取安全数据，构造权限信息
    15. public class IhrmRealm  extends AuthorizingRealm {
    16.  
    17.     public void setName(String name) {
    18.         super.setName("ihrmRealm");
    19.     }
    20.  
    21.     //授权方法
    22.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    23.         //1.获取安全数据
    24.         ProfileResult result = (ProfileResult)principalCollection.getPrimaryPrincipal();
    25.         //2.获取权限信息
    26.         Set<String> apisPerms = (Set<String>)result.getRoles().get("apis");
    27.         //3.构造权限数据，返回值
    28.         SimpleAuthorizationInfo info = new  SimpleAuthorizationInfo();
    29.         info.setStringPermissions(apisPerms);
    30.         return info;
    31.     }
    32.  
    33.     //认证方法
    34.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    35.         return null;
    36.     }
    37. }

    骚戴理解：上面代码很容易漏掉setName这个方法。setname方法用于设置此authorizingrealm的名称。在该实现中，setname重写了父类的setname方法并强制将名称设置为"ihrmrealm"。该名称通常用于唯一标识该领域对象（realm）的身份，并在调用该对象时由框架使用。

    自定义会话管理器

    之前的程序使用jwt的方式进行用户认证，前端发送后端的是请求头中的token。为了适配之前的程序，在shiro中需要更改sessionId的获取方式。很好解决，在shiro的会话管理中，可以轻松的使用请求头中的内容作为sessionid

    1. package com.ihrm.common.shiro.session;
    2.  
    3. import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
    4. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    5. import org.apache.shiro.web.util.WebUtils;
    6. import org.springframework.util.StringUtils;
    7.  
    8. import javax.servlet.ServletRequest;
    9. import javax.servlet.ServletResponse;
    10. import java.io.Serializable;
    11.  
    12. public class CustomSessionManager extends DefaultWebSessionManager {
    13.  
    14.  
    15.     /**
    16.      * 头信息中具有sessionid
    17.      *      请求头：Authorization： sessionid
    18.      *
    19.      * 指定sessionId的获取方式
    20.      */
    21.     protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
    22.  
    23.         //获取请求头Authorization中的数据
    24.         String id = WebUtils.toHttp(request).getHeader("Authorization");
    25.         if(StringUtils.isEmpty(id)) {
    26.             //如果没有携带，生成新的sessionId
    27.             return super.getSessionId(request,response);
    28.         }else{
    29.             //请求头信息：bearer sessionid
    30.             id = id.replaceAll("Bearer ","");
    31.             //返回sessionId；
    32.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
    33.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
    34.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
    35.             return id;
    36.         }
    37.     }
    38. }

    用户认证

    配置用户登录

    1.     //用户名密码登录
    2.     @RequestMapping(value="/login",method = RequestMethod.POST)
    3.     public Result login(@RequestBody Map<String,String> loginMap) {
    4.         String mobile = loginMap.get("mobile");
    5.         String password = loginMap.get("password");
    6.         try {
    7.             //1.构造登录令牌 UsernamePasswordToken
    8.             //加密密码
    9.             password = new Md5Hash(password,mobile,3).toString();  //1.密码，盐，加密次数
    10.             UsernamePasswordToken upToken = new UsernamePasswordToken(mobile,password);
    11.             //2.获取subject
    12.             Subject subject = SecurityUtils.getSubject();
    13.             //3.调用login方法，进入realm完成认证
    14.             subject.login(upToken);
    15.             //4.获取sessionId
    16.             String sessionId = (String)subject.getSession().getId();
    17.             //5.构造返回结果
    18.             return new Result(ResultCode.SUCCESS,sessionId);
    19.        }catch (Exception e) {
    20.             return new Result(ResultCode.MOBILEORPASSWORDERROR);
    21.        }
    22.    }

    骚戴理解：new Md5Hash(password,mobile,3)里面的三个参数分别是密码，盐（通过是用用户名作为盐值），加密次数。所谓的盐其实就是字符串，md5加盐就是数字和字符串组成的密文

    修改profile方法

    1.  
    2.     /**
    3.      * 用户登录成功之后，获取用户信息
    4.      *      1.获取用户id
    5.      *      2.根据用户id查询用户
    6.      *      3.构建返回值对象
    7.      *      4.响应
    8.      */
    9.     @RequestMapping(value="/profile",method = RequestMethod.POST)
    10.     public Result profile(HttpServletRequest request) throws Exception {
    11.         //获取session中的安全数据
    12.         Subject subject = SecurityUtils.getSubject();
    13.         //1.subject获取所有的安全数据集合
    14.         PrincipalCollection principals = subject.getPrincipals();
    15.         //2.获取安全数据
    16.         ProfileResult result = (ProfileResult)principals.getPrimaryPrincipal();
    17.  
    18. //        String userid = claims.getId();
    19. //        //获取用户信息
    20. //        User user = userService.findById(userid);
    21. //        //根据不同的用户级别获取用户权限
    22. //
    23. //        ProfileResult result = null;
    24. //
    25. //        if("user".equals(user.getLevel())) {
    26. //            result = new ProfileResult(user);
    27. //        }else {
    28. //            Map map = new HashMap();
    29. //            if("coAdmin".equals(user.getLevel())) {
    30. //                map.put("enVisible","1");
    31. //            }
    32. //            List<Permission> list = permissionService.findAll(map);
    33. //            result = new ProfileResult(user,list);
    34. //        }
    35.         return new Result(ResultCode.SUCCESS,result);
    36.     }

    骚戴理解：之前profile方法是用来授权的，由于这个操作已经在UserRealm里实现了，并且把授权后的ProfileResult放到了SimpleAuthenticationInfo里面，所以这里只需要直接取出来返回给前端即可

    shiro认证

    配置用户登录认证的realm域，只需要继承公共的IhrmRealm补充其中的认证方法即可

    1. public class UserIhrmRealm extends IhrmRealm {
    2.     @Override
    3.     public void setName(String name) {
    4.         super.setName("customRealm");
    5.    }
    6.     @Autowired
    7.     private UserService userService;
    8.     
    9.     //认证方法
    10.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    11.         //1.获取用户的手机号和密码
    12.         UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
    13.         String mobile = upToken.getUsername();
    14.         String password = new String( upToken.getPassword());
    15.         //2.根据手机号查询用户
    16.         User user = userService.findByMobile(mobile);
    17.         //3.判断用户是否存在，用户密码是否和输入密码一致
    18.         if(user != null && user.getPassword().equals(password)) {
    19.             //4.构造安全数据并返回（安全数据：用户基本数据，权限信息 profileResult）
    20.             ProfileResult result = null;
    21.             if("user".equals(user.getLevel())) {
    22.                 result = new ProfileResult(user);
    23.            }else {
    24.                 Map map = new HashMap();
    25.                 if("coAdmin".equals(user.getLevel())) {
    26.                     map.put("enVisible","1");
    27.                }
    28.                 List<Permission> list = permissionService.findAll(map);
    29.                 result = new ProfileResult(user,list);
    30.            }
    31.             //构造方法：安全数据，密码，realm域名
    32.             SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(result,user.getPassword(),this.getName());
    33.             return info;
    34.        }
    35.         //返回null，会抛出异常，标识用户名和密码不匹配
    36.         return null;
    37.    }
    38. }

    骚戴理解：认证即是登录校验，通过查询数据库校验用户账号信息，然后封装该用户的所有权限，也就是安全数据ProfileResult对象，SimpleAuthenticationInfo的三个参数分别是安全数据，密码，realm域名

     SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(result,user.getPassword(),this.getName());

    骚戴理解：simpleauthenticationinfo 类用于表示身份验证信息。 在构造时，它接受三个参数：

    • result: 身份验证的有效用户对象。可以是来自数据库或其他数据源中的实际对象。
    • user.getpassword(): 表示有效用户对象密码的字符串。这通常来自数据库或其他数据源。
    • this.getname(): 是一个字符串，表示realm的名称（在shiro中具有定义）。该字符串在配置文件中指定，并被用于登录认证和授权过程中。

    因此，语句simpleauthenticationinfo info = new simpleauthenticationinfo(result, user.getpassword(), this.getname()); 的作用是创建一个包含三个参数值的 simpleauthenticationinfo 对象 info，用于表示用户的身份验证信息。其中，result 代表已验证的用户的身份，user.getpassword() 代表已验证用户的密码，this.getname()代表realm的名称。这个对象可以由shiro框架的其他组件、方法或类进行使用或处理。

    获取session数据

    baseController中使用shiro从redis中获取认证数据

    1.     //使用shiro获取
    2.     @ModelAttribute
    3.     public void setResAnReq(HttpServletRequest request,HttpServletResponse response) {
    4.         this.request = request;
    5.         this.response = response;
    6.         //获取session中的安全数据
    7.         Subject subject = SecurityUtils.getSubject();
    8.         //1.subject获取所有的安全数据集合
    9.         PrincipalCollection principals = subject.getPrincipals();
    10.         if(principals != null && !principals.isEmpty()){
    11.             //2.获取安全数据
    12.             ProfileResult result = (ProfileResult)principals.getPrimaryPrincipal();
    13.             this.companyId = result.getCompanyId();
    14.             this.companyName = result.getCompany();
    15.        }
    16.    }

    用户授权

    在需要使用的接口上配置@RequiresPermissions("API-USER-DELETE")

    配置

    构造shiro的配置类

    1. package com.ihrm.system;
    2.  
    3. import com.ihrm.common.shiro.realm.IhrmRealm;
    4. import com.ihrm.common.shiro.session.CustomSessionManager;
    5. import com.ihrm.system.shiro.realm.UserRealm;
    6. import org.apache.shiro.mgt.SecurityManager;
    7. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
    8. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    9. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    10. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    11. import org.crazycake.shiro.RedisCacheManager;
    12. import org.crazycake.shiro.RedisManager;
    13. import org.crazycake.shiro.RedisSessionDAO;
    14. import org.springframework.beans.factory.annotation.Value;
    15. import org.springframework.context.annotation.Bean;
    16. import org.springframework.context.annotation.Configuration;
    17.  
    18. import java.util.LinkedHashMap;
    19. import java.util.Map;
    20.  
    21. @Configuration
    22. public class ShiroConfiguration {
    23.  
    24.     //1.创建realm
    25.     @Bean
    26.     public IhrmRealm getRealm() {
    27.         return new UserRealm();
    28.     }
    29.  
    30.     //2.创建安全管理器
    31.     @Bean
    32.     public SecurityManager getSecurityManager(IhrmRealm realm) {
    33.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    34.         securityManager.setRealm(realm);
    35.  
    36.         //将自定义的会话管理器注册到安全管理器中
    37.         securityManager.setSessionManager(sessionManager());
    38.         //将自定义的redis缓存管理器注册到安全管理器中
    39.         securityManager.setCacheManager(cacheManager());
    40.  
    41.         return securityManager;
    42.     }
    43.  
    44.     //3.配置shiro的过滤器工厂
    45.  
    46.     /**
    47.      * 再web程序中，shiro进行权限控制全部是通过一组过滤器集合进行控制
    48.      *
    49.      */
    50.     @Bean
    51.     public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
    52.         //1.创建过滤器工厂
    53.         ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
    54.         //2.设置安全管理器
    55.         filterFactory.setSecurityManager(securityManager);
    56.         //3.通用配置（跳转登录页面，未授权跳转的页面）
    57.         filterFactory.setLoginUrl("/autherror?code=1");//跳转url地址
    58.         filterFactory.setUnauthorizedUrl("/autherror?code=2");//未授权的url
    59.         //4.设置过滤器集合
    60.         Map<String,String> filterMap = new LinkedHashMap<>();
    61.         //anon -- 匿名访问
    62.         filterMap.put("/sys/login","anon");
    63.         filterMap.put("/autherror","anon");
    64.         //注册
    65.         //authc -- 认证之后访问（登录）
    66.         filterMap.put("/**","authc");
    67.         //perms -- 具有某中权限 (使用注解配置授权)
    68.         filterFactory.setFilterChainDefinitionMap(filterMap);
    69.  
    70.         return filterFactory;
    71.     }
    72.  
    73.  
    74.     @Value("${spring.redis.host}")
    75.     private String host;
    76.     @Value("${spring.redis.port}")
    77.     private int port;
    78.  
    79.     /**
    80.      * 1.redis的控制器，操作redis
    81.      */
    82.     public RedisManager redisManager() {
    83.         RedisManager redisManager = new RedisManager();
    84.         redisManager.setHost(host);
    85.         redisManager.setPort(port);
    86.         return redisManager;
    87.     }
    88.  
    89.     /**
    90.      * 2.sessionDao
    91.      */
    92.     public RedisSessionDAO redisSessionDAO() {
    93.         RedisSessionDAO sessionDAO = new RedisSessionDAO();
    94.         sessionDAO.setRedisManager(redisManager());
    95.         return sessionDAO;
    96.     }
    97.  
    98.     /**
    99.      * 3.会话管理器
    100.      */
    101.     public DefaultWebSessionManager sessionManager() {
    102.         CustomSessionManager sessionManager = new CustomSessionManager();
    103.         sessionManager.setSessionDAO(redisSessionDAO());
    104.         //禁用cookie
    105.         sessionManager.setSessionIdCookieEnabled(false);
    106.         //禁用url重写   url;jsessionid=id
    107.         sessionManager.setSessionIdUrlRewritingEnabled(false);
    108.         return sessionManager;
    109.     }
    110.  
    111.     /**
    112.      * 4.缓存管理器
    113.      */
    114.     public RedisCacheManager cacheManager() {
    115.         RedisCacheManager redisCacheManager = new RedisCacheManager();
    116.         redisCacheManager.setRedisManager(redisManager());
    117.         return redisCacheManager;
    118.     }
    119.  
    120.  
    121.  
    122.  
    123.     //开启对shior注解的支持
    124.     @Bean
    125.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    126.         AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
    127.         advisor.setSecurityManager(securityManager);
    128.         return advisor;
    129.     }
    130. }

    骚戴理解：以下代码是向上转型，如果UserRealm没有这个方法就调用父类的，有的话就会调用UserRealm自己的方法，这样的写应该是为了把这个Realm拆开，一个用来认证，一个用来授权

    1.     @Bean
    2.     public IhrmRealm getRealm() {
    3.         return new UserRealm();
    4.     }

    这里要把之前的Jwt的拦截器配置文件给注释掉！注释@Configuration就好

  • 相关阅读:
    java社区疫情防控微信小程序源码
    ZZNUOJ_C语言1089：阶乘的最高位(完整代码)
    【Unity】Unity寻路系统讲解及Navigation实际应用
    长安汽车董事长下场宣传原力技术 全擎引领电动化出行普及时代
    GIT使用（踩坑）
    计算Qt中的QAudioOutput缓冲区未播放的音频字节数对应时长
    提取log文件中的数据，画图
    11月30日（第二天）
    [AUTOSAR][诊断管理][ECU][$22] 读取相关的数据
    数据挖掘实践（金融风控）：金融风控之贷款违约预测挑战赛（上篇）[xgboots/lightgbm/Catboost等模型]--模型融合：stacking、blending
  • 原文地址：https://blog.csdn.net/qq_50954361/article/details/131367516