Spring boot整合Shiro+Redis实现登录认证、权限管理以及分布式环境下的会话共享

应用安全的四要素：认证、授权、会话管理、加密。

一 什么是Shiro？

shiro是Java提供的一个安全框架，是Apache 的一个开源项目，为了解决应用安全四要素而诞生，shiro给我们提供了对用户登录请求拦截，进而进行身份验证、权限分配与校验、密码加密和会话管理等一系列功能。shiro给我们封装了一系列相关的API，可以较容易的实现我们想要实现的功能。
但是在使用前有关shiro的一些核心概念必须要掌握的。

二 关于Shiro你必须要掌握的知识

关于shiro的介绍网上有很多资源，这里也引用一些资源来介绍一些有关shiro的核心概念。
shiro整体框架：

shiro的三个核心组件为Subject、SecurityManager和Realm。其中SecurityManager中又包括Authenticatior、Authorizer、SessionManager、CacheManager、SessionDao等等。

Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是Shiro的“用户”概念。
Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。
SecurityManager：shiro中最最核心的组件，如果把shiro比作一个人的话，那么SecurityManager就是心脏，充当了一个对其他功能封装和调度的角色。相当于SpringMVC中的DispatcherServlet或者Struts2 中的FilterDispatcher。所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。
Realm：Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。可以认为是安全实体数据源，即用于获取安全实体的；可以是 JDBC 实现，也可以是 LDAP 实现，或者内存实现等等；由用户提供。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得 Shiro 默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了。
Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能。
SessionManager：如果写过 Servlet 就应该知道 Session 的概念，Session 呢需要有人去管理它的生命周期，这个组件就是 SessionManager；而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境、EJB 等环境；所有呢，Shiro 就抽象了一个自己的 Session来管理主体与应用之间交互的数据；这样的话，比如我们在 Web 环境用，刚开始是一台Web 服务器；接着又上了台 EJB 服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到 Memcached 服务器）。
SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的 SessionDAO，通过如 JDBC 写到数据库；比如想把Session 放到Memcached 中，可以实现自己的 Memcached SessionDAO；另外 SessionDAO中可以使用 Cache 进行缓存，以提高性能。
CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本
上很少去改变，放到缓存中后可以提高访问的性能。
Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密。

三 sprig boot + shiro +redis 实现登录拦截、身份认证、权限校验、会话管理

3.1 shiro配置

首先引入Shiro所需要的的相关依赖：

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.4.0</version>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.shiro</groupId>
                    <artifactId>shiro-quartz</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>2.4.2.1-RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>

部署Shiro需要做的配置主要包括包括SecurityManager（比如有一些功能我们想要按照自己的想法来做而不是使用Shiro默认提供的方式，还包括一些必备的配置等）、Filter配置、SessionManager配置以及Realm实现。
ShiroConfig.java：

/**
 * @author donglixiang
 * @date 2020/4/23 15:50
 * @description shiro 配置
 */
@Configuration
public class ShiroConfig {

    /**
     * shiro核心管理工具Manager：securityManager
     * */
    @Bean(name = "securityManager")
    public SecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        /**设置自定义realm*/
        securityManager.setRealm(realmCommon(hashedCredentialsMatcher()));
        /**配置自定义缓存 redis*/
        //securityManager.setCacheManager(cacheManager());
        /**配置自定义session管理，使用redis，代替默认的ConcurrentHashMap*/
        securityManager.setSessionManager(sessionManager());
        return securityManager;
    }

    /**
     * 自定义Realm
     * */
    @Bean(name = "realmCommon")
    public UserRealm realmCommon(@Qualifier("hashedCredentialsMatcher") HashedCredentialsMatcher matcher){
        UserRealm userRealm = new UserRealm();

        /**配置自定义密码比较器*/
        userRealm.setCredentialsMatcher(matcher);
        return new UserRealm();
    }

    /**
     * 密码加密方式
     * */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        //指定加密方式为MD5
        credentialsMatcher.setHashAlgorithmName("MD5");
        //加密次数
        credentialsMatcher.setHashIterations(1024);
        //true加密用的hex编码，false用的base64编码
        credentialsMatcher.setStoredCredentialsHexEncoded(true);

        return credentialsMatcher;
    }

    /**
     * Shiro Filter,拦截器配置
     * anon:不拦截的请求。
     * authc：必须进行认证的请求,会自动跳转到'/login'请求下，如果路径不存在就会报异常。
     * */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        /**登录成功后访问的地址，登录地址，认证失败地址*/
        shiroFilterFactoryBean.setSuccessUrl("/main");
        shiroFilterFactoryBean.setLoginUrl("/api/loginErr");
        shiroFilterFactoryBean.setUnauthorizedUrl("/error/unAuth");

        Map<String,String> filterMap = new HashMap<>();
        filterMap.put("/login","anon");
        filterMap.put("/**","authc");
        filterMap.put("/api/logoutt", "logout");

        /**取消对测试controller的拦截*/
        filterMap.put("/api/**","anon");
        filterMap.put("/test","anon");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

        return shiroFilterFactoryBean;
    }

    /**
     * sessionManager
     * */
    @Bean
    public SessionManager sessionManager(){
        DefaultWebSessionManager defaultWebSessionManager = new DefaultWebSessionManager();
        Collection<SessionListener> listeners = new ArrayList<SessionListener>();
        listeners.add(new MySessionListener());
        defaultWebSessionManager.setSessionListeners(listeners);
        /**TODO:shiro配置redis*/
        defaultWebSessionManager.setSessionDAO(sessionDAO());
        defaultWebSessionManager.setCacheManager(cacheManager());
        /**设置session超时时间，单位毫秒，每次调用认证或者授权方法时会刷新session的超时时间*/
        defaultWebSessionManager.setGlobalSessionTimeout(3000000);

        return defaultWebSessionManager;
    }

    /**
     * 配置SessionDao使用redis作为缓存
     * */
    @Bean
    public SessionDAO sessionDAO(){
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * 配置CacheManager使用Redis
     * */
    @Bean
    public RedisCacheManager cacheManager(){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

    /**
     * @description redis配置
     */
    @Bean
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setHost("127.0.0.1");
        redisManager.setPort(6379);
        redisManager.setTimeout(10000);
        redisManager.setPassword("");
        /**设置session在redis中的过期时间，单位S，要大于等于session本身过期时间*/
        redisManager.setExpire(300);
        return redisManager;
    }

    /**
     *  开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    /**
     * 开启aop注解支持
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

这里自定义了Session的存储方式，配置是否开启缓存，自定义SessionDao,通过redis来存储，方便在分布式环境下实现session共享。

拦截器配置，Shiro默认的一些拦截器如下：

默认拦截器名	拦截器类	说明
身份验证相关
authc	org.apache.shiro.web.filter.authc.FormAuthenticationFilter	基于表单的拦截器；如 “/**=authc”，如果没有登录会跳到相应的登录页面登录；主要属性：usernameParam：表单提交的用户名参数名（ username）； passwordParam：表单提交的密码参数名（password）； rememberMeParam：表单提交的密码参数名（rememberMe）； loginUrl：登录页面地址（/login.jsp）；successUrl：登录成功后的默认重定向地址； failureKeyAttribute：登录失败后错误信息存储 key（shiroLoginFailure）；
authcBasic	org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter	Basic HTTP 身份验证拦截器，主要属性： applicationName：弹出登录框显示的信息（application）；
logout	org.apache.shiro.web.filter.authc.LogoutFilter	退出拦截器，主要属性：redirectUrl：退出成功后重定向的地址（/）; 示例 “/logout=logout”
user	org.apache.shiro.web.filter.authc.UserFilter	用户拦截器，用户已经身份验证 / 记住我登录的都可；示例 “/**=user”
anon	org.apache.shiro.web.filter.authc.AnonymousFilter	匿名拦截器，即不需要登录即可访问；一般用于静态资源过滤；示例 “/static/**=anon”
授权相关的
roles	org.apache.shiro.web.filter.authz.RolesAuthorizationFilter	角色授权拦截器，验证用户是否拥有所有角色；主要属性： loginUrl：登录页面地址（/login.jsp）；unauthorizedUrl：未授权后重定向的地址；示例 “/admin/**=roles[admin]”
perms	org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter	权限授权拦截器，验证用户是否拥有所有权限；属性和 roles 一样；示例 “/user/**=perms[“user:create”]”
port	org.apache.shiro.web.filter.authz.PortFilter	端口拦截器，主要属性：port（80）：可以通过的端口；示例 “/test= port[80]”，如果用户访问该页面是非 80，将自动将请求端口改为 80 并重定向到该 80 端口，其他路径 / 参数等都一样
rest	org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter	rest 风格拦截器，自动根据请求方法构建权限字符串（GET=read, POST=create,PUT=update,DELETE=delete,HEAD=read,TRACE=read,OPTIONS=read, MKCOL=create）构建权限字符串；示例 “/users=rest[user]”，会自动拼出“user:read,user:create,user:update,user:delete” 权限字符串进行权限匹配（所有都得匹配，isPermittedAll）；
ssl	org.apache.shiro.web.filter.authz.SslFilter	SSL 拦截器，只有请求协议是 https 才能通过；否则自动跳转会 https 端口（443）；其他和 port 拦截器一样；
其他
noSessionCreation	org.apache.shiro.web.filter.session.NoSessionCreationFilter	不创建会话拦截器，调用 subject.getSession(false) 不会有什么问题，但是如果 subject.getSession(true) 将抛出 DisabledSessionException 异常；

介绍几个比较常用的吧：

authc:被authc标记的请求表示必须进行认证的请求，如果没有认证Shiro会自动将请求重定向为，查找SecurityManager中的loginUrl，默认为/login，可以通过setLoginUrl（）自定义，这里我自定义为/api/loginErr。
anon：被anon标记的请求表示不需要进行拦截，可以直接放行。
user：被user拦截器标注的请求，有两种情况下可以直接访问成功，1是认证成功的Subject，即authenticated为true ，2是Subject中reMemberMe为true。
什么是rememberMe？Subject中一个boolean类型的变量，当rememberMe为true时，SecurityManager中会有一个rememberMe的cache，如果为false，则rememberMeCache不存在，cache的默认有效时间是一年，会根据实际情况适当缩短。
什么情况下使用rememberMe？一些网站比如淘宝，当登录之后关闭了页面在重新打开，此时会默认用户登录，不用重新再走一遍登录流程，可以通过rememberMe实现。但是如果访问订单查看、订单支付页面的话就需要用户重新登录，确保此用户还是你，可以使用shiro的默认拦截器authc来实现。
rememberMe默认为false，可以在login()之前重新赋值true。

UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(userName,passWord);
usernamePasswordToken.setRememberMe(true);

接下来是Realm实现，UserRealm.java：

/**
 * @author donglixiang
 * @date 2020-04-22 15:05
 * @Description 自定义realm域
 * */
@Component
@Slf4j
public class UserRealm extends AuthorizingRealm {

    @Override
    public void setName(String name){
        super.setName(name);
    }

    @Autowired
    private AdminRolePermissionService adminRolePermissionService;

    @Autowired
    private AdminUserInfoService adminUserInfoService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection){
        log.info("**********授权开始**********");
        if(principalCollection==null){
            log.info("principalCollection is null");
            throw new AuthorizationException("PrincipalCollection method argument cannot be null");
        }
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        AdminUserInfo adminUserInfo = (AdminUserInfo) principalCollection.getPrimaryPrincipal();
        if(adminUserInfo == null){
            log.info("当前用户信息为null,return");
            return null;
        }
        Integer auid = adminUserInfo.getId();
        /**赋予Subject相关角色以及权限，从数据库中获取当前用户所属的角色以及拥有的权限*/
        simpleAuthorizationInfo.addRoles(adminRolePermissionService.getRoles(auid));
        simpleAuthorizationInfo.addStringPermissions(adminRolePermissionService.getPermission(auid));
        log.info("**********授权成功**********");
        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken){
        log.info("**********认证开始**********");
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
        String userName = usernamePasswordToken.getUsername();
        char[] passWord = usernamePasswordToken.getPassword();
        AdminUserInfo adminUserInfo = adminUserInfoService.getAdminUserInfoByUserName(userName);
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(adminUserInfo,adminUserInfo.getPassword(),getName());
        log.info("**********认证结束**********");
        return simpleAuthenticationInfo;
    }

AdminUserInfo为一个用户Bean，包含用户的一些相关信息

UserRealm继承Shiro框架下的AuthorizingRealm类，重写了doGetAuthenticationInfo()和doGetAuthorizationInfo()两个方法，分别对应用户的认证和授权操作。

doGetAuthenticationInfo()和doGetAuthorizationInfo()方法的触发时机分别为：
doGetAuthenticationInfo（）：调用Subject.login()方法时触发。

doGetAuthorizationInfo（）：有3中情况会触发此方法。
1：分别是调用Subject的hasRole()或者isPermitted()时，主动的来判断用户是否具备某个、某些角色或者权限时，返回true或者false。
2：当访问被注解@RequiresRoles(“xxx”)或者@RequiresPermissions(“xxx”)标注的方法时，如果当前Subject已经login()成功会继续检测已经注册的用户是否具有xxx角色或者权限，如果有的话会执行接下来的方法，如果没有则会抛出异常UnauthorizedException，对于还没有执行login的用户来说，当访问到这两个注解时会直接抛出一个用户未登录的异常-AuthorizationException。此注解的功能默认是关闭的，开启的话需要Spring AOP的支持，在上面的配置类中有定义。
3：[@shiro.hasPermission name = “admin”][/@shiro.hasPermission]：在页面上加shiro 标签的时候，即进这个页面的时候扫描到有这个标签的时候。没有使用过，感兴趣的可以自己测试下。

关于CacheManager：

CacheManager：shiro的缓存默认是关闭的。如果需要的话要手动开启，并且可以配置缓存到哪里。
CacheManager的作用：主要用于缓存用户的【授权】信息，而不缓存【认证】信息。这么设计的原因特主要是因为认证相关的信息比较少，而授权涉及的信息量比较多，每次都从数据库中取值的话效率会比较低，所以对授权信息进行了缓存。对应到代码里就是说只有当首次进行权限认证的时候会触发doGetAuthorizationInfo（）方法，而后续再进行权限认证就是从缓存中拿信息，而不是数据库。
需要关注的问题：当开启缓存时，如果此时用户的权限进行了修改，就会造成缓存中和数据库中的权限信息不一致，这种情况有两种解决办法以供参考：
1、执行AuthorizingRealm类下的clearCache方法

   /**
    * 清理缓存
   */
  public void clearCache() {
       PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
       super.clearCache(principals);
   }

2、通知用户主动退出重新登录。调用Subject.logout（）方法，当调用logout方法时Shiro会帮我们清理掉缓存，之后在重新登录即可

SecurityUtils.getSubject().logout();

logout源码：

   public void logout() {
       try {
           this.clearRunAsIdentitiesInternal();
           this.securityManager.logout(this);
       } finally {
           this.session = null;
           this.principals = null;
           this.authenticated = false;
       }
   }

3.2 认证

通俗一些来讲，对于web应用来说，用户认证就是一个登录的过程，这样说也许不够严谨，但事实确实如此。Shiro中用户登录认证的流程如下：

1、获取到登录用户信息组装成Token，调用login()方法实现subject的登录。
2、将用户信息提交给SecurityManager。
3、login()会触发认证器Authenticator来验证当前用户是否可以认证通过。我们可以自定义实现Authenticator，来定义认证通过的规则。

login()方法的实现：

/**根据用户登录信息组装token*/
UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(userName,passWord);
/**通过SecurityUtils获取到当前的subject,再调用login()方法*/
SecurityUtils.getSubject().login(usernamePasswordToken);

调用login（）后会触发realm中的doGetAuthenticationInfo（）方法，进行认证，如果token中的信息和从数据库中查询得到的信息不匹配的话则会认证失败，否则认证成功，SecurityManager中的Subject包含了当前的用户信息。

3.3 授权

Shiro中对用户的权限管理。当用户发起请求访问某个资源时，首先会校验是否具备访问该资源所需要的权限，如果没有对应的权限则无法访问。UserRealm中的doGetAuthorizationInfo（）方法就是来对Subject赋予权限。doGetAuthorizationInfo（）的触发时机已经在上面介绍过，这里就不再做介绍了。用户角色权限可以事先在数据库中做好配置，根据用户名来查询当前用户拥有的权限。

3.4 session共享

对于session共享的问题可以结合这张图来理解一下：

在单体结构的项目中，完全可以通过Subject来获取用户的信息，因为在单体项目中的任何地方都可以通过SecurityUtils获取到Subject，进而获取到session或者Principal（用户认证时返回SimpleAuthenticationInfo对象的第一个参数）。而在分布式环境下则需要通过一些介质来实现sessio的共享，这里采用的redis来实现。
Shiro内部封装好了对redis的基本操作，只需要将redis的host、port、password等基本信息配置好就可以，不需要我们自己实现RedisUtil，就可以对Session的存储和读取（但是读取非本模块存的session的时候就得需要自己实现咯，因为在分布式环境下每个模块的SecurityManager都不是同一个，操作的Subject必然不是一个了）。每个session生成的时候都会有一个唯一标识sessionId来区分，sessionId是一个随机生成的没有规律且不会重复的一个字符串，需要注意的是Shiro在向Redis中存session的时候key并不就完全是sessionId，而是做了一层拼装，加了一个*“shiro_redis_session:”*的前缀：

通过Shiro提供的API获取session的方式：

        SessionKey sessionKey = new SessionKey() {
            @Override
            public Serializable getSessionId() {
                return "627e29e2-1e1d-4155-8b22-38f723f94626";
            }
        };
        Session session = SecurityUtils.getSecurityManager().getSession(sessionKey);

如果不使用redis存储的话，默认使用什么作为存储介质呢？
ConcurrentHashMap
在将session存到redis里之前可以向session里设置一些我们需要属性，就像向HttpServerletRequest对象中setAttribute一样。这里可以把当前用户的角色和权限信息方法session里，这样其他模块在获取角色和权限时就不用每次都通过数据库取，可以从缓存中取到。

            SecurityUtils.getSubject().login(usernamePasswordToken);
            Session session = SecurityUtils.getSubject().getSession();
            sessionId = (String) session.getId();
            AdminUserInfo adminUserInfo = adminUserInfoService.getAdminUserInfoByUserName(userName);
            session.setAttribute(Constant.SHIRO_SESSION_USER_INFO,adminUserInfo);
            session.setAttribute(Constant.SHIRO_SESSION_USER_ROLE,adminRolePermissionService.getRoles(adminUserInfo.getId()));
            session.setAttribute(Constant.SHIRO_SESSION_USER_PERMISSION,adminRolePermissionService.getPermission(adminUserInfo.getId()));
            /**sessionId存到redis中*/
            StringBuilder stringBuilder = new StringBuilder("user_").append(adminUserInfo.getId()).append("_").append(adminUserInfo.getUserName());
            boolean isSuccess = redisUtil.setString(stringBuilder.toString(),(Constant.SHIRO_REDIS_KEY_PREFIX+sessionId),0);
            if(!isSuccess){
                return "redis set操作失败";
            }

另外sessionId是不会再不同模块之间进行传递，但是向不同模块发起请求的时候唯一相同的地方就是用户信息是已知的，所以可以考虑将sessionId同用户关联到一起存到Redis中，选定一个用户的唯一标识作为key。

从其他模块获取session：

/**
     * @description 获取session
     */
    @RequestMapping(value = "/getSession",method = RequestMethod.POST,produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String getSession(HttpServletRequest request){
		/**从request中获取userName*/
        String userName = request.getParameter(Constant.REQUEST_PARAM_USER_NAME);
        AdminUserInfo adminUserInfo = adminUserInfoService.getAdminUserInfoByUserName(userName);
        /**组装key*/
        String key = new StringBuilder("user_").append(adminUserInfo.getId()).append("_").append(adminUserInfo.getUserName()).toString();
        /**先获取sessionId*/
        String sessionId = redisUtil.getString(key);
        if(!redisUtil.exist(sessionId.getBytes())){
            return "此sessionId对应缓存不存在";
        }
        /**在获取session，因为存的时候将session进行了序列化，这里需要反序列化一下获取到session*/
        Session session = (Session) SerializerUtil.deserialize(redisUtil.getObject(sessionId.getBytes()));
        List<String> roleList = (List<String>) session.getAttribute(Constant.SHIRO_SESSION_USER_ROLE);
        for(String tole:roleList){
            /**TODO:判断是否拥有某个角色*/
        }
        List<String> permissionList = (List<String>) session.getAttribute(Constant.SHIRO_SESSION_USER_PERMISSION);
        for(String permission:permissionList){
            /**TODO：判断是否拥有某个权限*/
        }
        return adminUserInfo.toString();
    }

关于doGetAuthenticationInfo（）的触发时机、session的默认存储等都可以跟踪源码得到验证，这里就不附上源码的截图了(主要是需要跟的层数太多了，全放出来会占很多篇幅)，感兴趣的可以自己搭建好了跟一下。

四 测试

建表语句：

CREATE TABLE `shiro_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `username` varchar(255) DEFAULT '' COMMENT '登陆用户名',
  `password` varchar(255) DEFAULT '' COMMENT '登陆密码',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息表';

CREATE TABLE `shiro_user_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `auid` bigint(20) NOT NULL DEFAULT '0' COMMENT '用户id',
  `role_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '角色id',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户对应角色信息';


CREATE TABLE `shiro_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `name` varchar(255) NOT NULL DEFAULT '' COMMENT '角色名称',
  `description` varchar(255) NOT NULL DEFAULT '' COMMENT '角色描述°',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色信息';


CREATE TABLE `shiro_permission` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `role_id` bigint(20) NOT NULL COMMENT '角色id',
  `permission_name` varchar(255) NOT NULL  COMMENT '权限名称',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='权限信息';

初始化一些数据：

启动redis server和redis client：

整个项目结构：

shiro：shiro配置、实现模块
shiro-common：工具类模块，这里主要是RedisUtil和SerializerUtil
shiro-test：测试模块，主要用来模拟测试在不同的环境下获取Shiro Session。

同时启动两个模块：

启动成功后访问ApiController下login方法：
获取到当前Subject的sessionId

接下来从数据库查询出此用户的角色、权限存到session中，至此登陆成功。
通过key：【shiro_redis_session:79b7c8bd-9e6a-4d82-8e67-00fb2170b9a0】可以从redis中获取到session信息：

接下来在验证下在shiro-test模块中获取当前用户的session是否能够成功。
访问ShiroTestController下的getSession方法可以看到能够成功获取到session，并且可以取到其中的角色权限信息：

权限测试：
当去访问被注解@RequiresPermissions(“xxx”)标记的方法时，会验证用户是否有权限xxx。这里给donglixiang用户初始化了四个权限信息，权限1、2、3、4，当注解为@RequiresPermissions(“权限5”)时，就会有权限不足的提示，抛出UnauthorizedException异常。

最后附上GitHub代码地址：

https://github.com/23donglixiang/ShiroDemo.git