SpringBoot集成Shiro+Jwt+Redis

1. 概述

首先需要知道为什么使用 Shiro+Jwt+Redis 进行登录认证和权限控制。

1. 为什么用Shiro？
主要用的是 shiro 的登录认证、权限控制功能。
Shiro 参见本栏目文章 🍃《Shiro实战》

2. 为什么用JWT？
Shiro 默认的 Session 机制来帮助实现权限管理，用于维护用户的状态信息。而 JWT 是 token认证 的一种具体实现方式，相对于传统的 session认证方式，有如下优点：

• 跨域支持：cookie 是无法跨域的，而 token 由于没有用到 cookie（前提是将 token 放到请求头中），所以跨域后不会存在信息丢失问题。
• 无状态：token 机制在服务端不需要存储 session 信息，因为 token 自身包含了所有登录用户的信息，所以可以减轻服务端压力，节约服务器资源，并且可以很容易地分布式横向扩展应用。
• 更适用CDN：可以通过内容分发网络请求服务端的所有资料。
• 更适用于移动端：当客户端是非浏览器平台时，cookie 是不被支持的，此时采用 token 认证方式会简单很多。
• 无需考虑CSRF：由于不再依赖 cookie，所以采用 token 认证方式不会发生 CSRF，所以也就无需考虑 CSRF 防御。

JWT 参见本栏目文章 🍃《JWT详解》

3. 为什么用Redis？

1. JWT 本身不能续期，结合 Redis，可以实现 续期、主动登出。
2. Redis 可以 缓存用户信息，减少数据库压力。
3. 可以实现分布式环境下的会话共享。

2. Springboot整合Shiro+Jwt+Redis

🍂用户注册流程：

将密码加密后存入数据库中。

🍂用户登录流程：

主要是校验账号密码并生成 token。

🍂访问资源流程：

Shiro 整合 JWT 的系统中，关键就是通过 JwtFilter 过滤器 去校验请求头中是否包含 token，如果有 token，就交给自定义的 Realm。然后在 Realm 的认证方法里面校验 token 是否正确、是否过期、是否存在 Redis 中等。

🍂访问有权限资源流程：

相对于访问资源流程，碰到@RequiresRoles、@RequiresPermissions 等注解，增加调用 doGetAuthorizationInfo() 方法从数据源中获取用户的授权信息（如角色和权限），然后判断是否有访问权限。

2.1 JWT配置

2.1.1 依赖

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.19.0</version>
</dependency>

2.1.2 配置JWT

shiro:
  jwt:
    # 加密秘钥
    secret: kGgySFGcfQML4ZOvvlE7856YvSCsbjBf
    # token有效时长，1天，单位毫秒
    expire: 86400000
    header:
      # 加密算法
      alg: HS256
      # token类型
      typ: JWT

2.1.2 ✨JWT工具类

@Component
public class JwtUtil {

    @Value("${shiro.jwt.secret}")
    private String secret;
    @Value("${shiro.jwt.expire}")
    private Long expire;
    @Value("${shiro.jwt.header.alg}")
    private String headerAlg;
    @Value("${shiro.jwt.header.typ}")
    private String headerTyp;

    /**
     * 生成token
     */
    public String getToken(String account, long currentTimeMillis) {
        // 设置秘钥
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(account).append(secret);

        // 设置jwt头header
        Map<String, Object> headerClaims = new HashMap<>();
        headerClaims.put("alg", headerAlg); // 签名算法
        headerClaims.put("typ", headerTyp); // token 类型
        // 设置jwt的header，负载paload以及加密算法
        String token = JWT
                .create()
                .withHeader(headerClaims)
                .withClaim("account" ,account)
                .withClaim("expire", currentTimeMillis + expire)
                .sign(Algorithm.HMAC256(stringBuilder.toString()));
        return token;
    }

    /**
     * 无需秘钥就能获取其中的信息
     * 解析token.
     * {
     * "account": "account",
     * "timeStamp": "134143214"
     * }
     */
    public Map<String, String> parseToken(String token) {
        HashMap<String, String> map = new HashMap<String, String>();
        // 解码 JWT
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        Claim expire = decodedJwt.getClaim("expire");
        map.put("account", account.asString());
        map.put("expire", expire.asLong().toString());
        return map;
    }

    /**
     * 解析token获取账号.
     */
    public String getAccount(String token) {
        HashMap<String, String> map = new HashMap<String, String>();
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        return account.asString();
    }

    /**
     * 校验token是否正确
     * @param token Token
     * @return boolean 是否正确
     */
    public boolean verify(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        Claim expire = decodedJwt.getClaim("expire");
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(account.asString()).append(secret);
        // 验证JWT的签名和有效性
        Algorithm algorithm = Algorithm.HMAC256(stringBuilder.toString());
        JWTVerifier verifier = JWT.require(algorithm).build();
        try {
            verifier.verify(token);
            return true; // 验证通过
        } catch (JWTVerificationException e) {
            return false; // 验证失败
        }
    }


    /**
     * 校验token是否过期
     * @param token Token
     * @return boolean 是否正确
     */
    public boolean isExpired(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim expire = decodedJwt.getClaim("expire");
        // 验证过期时间
        Long expireTime = expire.asLong();
        if (System.currentTimeMillis() > expireTime) {
            return true;
        }
        return false;
    }


    /**
     * 获取token过期时间
     * @param token Token
     * @return boolean 是否正确
     */
    public long getExpiredTime(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim expire = decodedJwt.getClaim("expire");
        return expire.asLong();
    }

}

2.2 Redis配置

2.2.1 依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.2.2 配置 Redis 地址

spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0
    timeout: 5000
    lettuce:
      pool:
        max-idle: 16
        max-active: 32
        min-idle: 8

2.2.3 Redis序列化

/**
 * redis序列化
 */
@Configuration
public class RedisConfig {
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> getRedisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        // key序列化
        redisTemplate.setKeySerializer(stringSerializer);
        // value序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(stringSerializer);
        // Hash value序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

2.2.4 ✨Redis工具类

封装 RedisTemplate

/**
 * RedisUtil 工具类
 */
@Component
public class RedisUtil {
    // 使用jwt的过期时间毫秒
    private final long defaultTimeout = 1*24*60*60*1000;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 是否存在指定的key
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 删除指定的key
     *
     * @param key
     * @return
     */
    public boolean delete(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -
    /**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public void set(String key, String value) {
        set(key, value, defaultTimeout);
    }

    /**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value, defaultTimeout, TimeUnit.SECONDS);
        }
    }

    //- - - - - - - - - - - - - - - - - - - - -  object类型 - - - - - - - - - - - - - - - - - - - -
    /**
     * 根据key读取数据
     */
    public Object getObject(final String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 写入数据
     */
    public boolean setObject(final String key, Object value) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        try {
            setObject(key, value , defaultTimeout);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public boolean setObject(final String key, Object value, long time) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value, defaultTimeout, TimeUnit.SECONDS);
        }
        return true;
    }
}

2.2.5 Redis常量

public class RedisConstant {

    private RedisConstant() {}

    public static final String PREFIX_ACCESS_TOKEN = "access_token";

    public static final String PREFIX_SHIRO_JWT = "shiro:jwt:";
}

2.3 Shiro配置

🍃《Shiro实战》已经介绍 Shiro 基本用法，如果需要整合 JWT 进行 token 认证，主要涉及三块改动：

1. 关闭 Shiro 原有的 Session 功能，依赖于 Token 来进行认证。涉及 ShiroConfig 类改造。
2. 配置 Shiro 的 过滤器链 来指定哪些 URL 需要进行 JWT 认证。涉及 ShiroConfig 类改造。
3. 自定义 Realm 的认证方法主要用来校验 token 的合法性。涉及 CustomRealm 类改造。

2.3.1 ✨ShiroConfig

配置 SecurityManager 策略 、指定哪些 URL 需要认证。

@Configuration
public class ShiroConfig {
    @Bean
    public CustomRealm customRealm() {
        CustomRealm customRealm = new CustomRealm();
        return customRealm;
    }

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置自定义 Realm
        securityManager.setRealm(customRealm());
        // 禁用 Shiro 的 Session 存储，这样可以确保 shiro 不会创建或使用 Session，而是依赖于无状态的 Token 来进行认证。
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);
        return securityManager;
    }

    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 注入 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 添加自定义 Filter，并且取名为 jwt
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("jwt", new JwtFilter());
        shiroFilterFactoryBean.setFilters(filterMap);

        /*//登录
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首页
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //错误页面，认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/notRole");
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");*/

        // 设置 Shiro 的过滤器链来指定哪些 URL 需要进行 JWT 认证。
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // authc：所有url都必须认证通过才可以访问; anon：所有url都都可以匿名访问
        filterChainDefinitionMap.put("/sys/login", "anon");
        filterChainDefinitionMap.put("/api/**", "anon");
        // /** 必须放在所有权限设置的最后，表示对所有资源起作用，本例使用自定义 jwt
        filterChainDefinitionMap.put("/**", "jwt");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    /**
     * *
     *  开启 Shiro 的注解（如@RequiresRoles、@RequiresPermissions），需借助 SpringAOP 扫描使用 Shiro 注解的类，并在必要时进行安全逻辑验证
     * *
     *  配置以下两个 bean （DefaultAdvisorAutoProxyCreator（可选）和 AuthorizationAttributeSourceAdvisor）即可实现此功能
     * * @return
     */
    // 配置 DefaultAdvisorAutoProxyCreator，执行权限注解 @RequiresPermissions 会调用两次 doGetAuthorizationInfo() 方法。故不注入该配置。
    /*@Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }*/

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
        return authorizationAttributeSourceAdvisor;
    }
}

其中，

👉该配置将 禁用 Shiro 的 Session 存储，这样可以确保 shiro 不会创建或使用 Session，而是依赖于 无状态的 Token 来进行认证。

• filterMap.put("jwt", new JwtFilter()) 添加自定义 过滤器 Filter，并且取名为 jwt。
• filterChainDefinitionMap.put("/**", "jwt") 配置 Shiro 的过滤器链来指定哪些 URL 需要进行过滤器认证。

2.3.2 ✨自定义过滤器JwtFilter

自定义 JWT 过滤器类 JwtFilter，继承 BasicHttpAuthenticationFilter，主要作用就是 拦截请求，判断请求头中是否携带 token。如果携带，就交给 Realm 处理。

/**
 *  jwt过滤器，作为shiro的过滤器，对请求进行拦截并处理
 */
@Slf4j
@Component
public class JwtFilter extends BasicHttpAuthenticationFilter {
    private String errorMsg;

    /**
     * 过滤器拦截请求的入口方法
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        // 判断请求头是否带上token
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");
        // token不存在，禁止访问
        if (StringUtils.isEmpty(token)) {
            return false;
        }
        try {
            // 交给自定义 Realm
            // getSubject(request, response).login(new JwtToken(token));  //getSubject(request, response) 等同于 SecurityUtils.getSubject()
            SecurityUtils.getSubject().login(new JwtToken(token));
            return true;
        } catch (Exception e) {
            errorMsg = e.getMessage();
            e.printStackTrace();
            return false;
        }
    }

    /**
     * isAccessAllowed()方法返回false，即认证不通过时进入onAccessDenied方法
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setStatus(400);
        httpServletResponse.setContentType("application/json;charset=utf-8");
        PrintWriter out = httpServletResponse.getWriter();
        out.println(JSONUtil.toJsonStr(Result.error(errorMsg)));
        out.flush();
        out.close();
        return false;
    }

    /**
     * 对跨域访问提供支持
     *
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域发送一个option请求
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

}

• isAccessAllowed：过滤器拦截请求的入口方法。后续会交由自定义 Realm 处理。
• onAccessDenied：认证不通过时，需要做什么处理。
• preHandle：前置处理方法，此处放置对 跨域访问提供支持 OPTIONS 请求的代码，也可以自定义其他逻辑。

2.3.3 ✨自定义AuthenticationToken

JWTFilter 传递给 Realm 的 token 必须是 AuthenticationToken 的实现类，通过这个类将 string 的 token 转型成 AuthenticationToken，主要目的是在 Realm 的认证和授权的时候，能够获取到 token。

/*
 * 将 String 的 token 转型成 AuthenticationToken，供 Realm 认证和授权使用
 */
public class JwtToken implements AuthenticationToken {
    private String token;

    public JwtToken(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }
    @Override
    public Object getCredentials() {
        return token;
    }
}

✨注：需要重写 getPrincipal 和 getCredentials 方法。本例 principal（身份标识） 和credentials（凭证） 均赋值为 token。

2.3.4 ✨自定义Realm

自定义 Realm 的认证方法 doGetAuthenticationInfo() 主要用来校验 token 的合法性

public class CustomRealm extends AuthorizingRealm {
    public final static String GLOBE_SALT = "123456789abcdefg";

    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private JwtUtil jwtUtil;

    // 这个方法要重写，debug源码得知shiro会判断token的类型是不是自己支持的类型，不重写的话会报错
    @Override
    public boolean supports(AuthenticationToken authenticationToken) {
        return authenticationToken instanceof JwtToken;
    }

    /**
     * @MethodName doGetAuthenticationInfo
     * @Description 认证配置类，用于获取返回用户的凭证信息（用户名、密码）
     * @Param authenticationToken
     * @Return AuthenticationInfo
     * @return
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("enter doGetAuthenticationInfo");
        if (StringUtils.isEmpty((String) authenticationToken.getPrincipal())) {
            return null;
        }
        // JwtToken 中重写 getPrincipal 方法
        String token = authenticationToken.getPrincipal().toString();
        if (!jwtUtil.verify(token)){
            throw new AuthenticationException("token已失效，请重新登录");
        }
        // 从 Redis 读取用户信息
        SysUser user = (SysUser) redisUtil.get(RedisConstant.PREFIX_SHIRO_JWT + token);
        if (null == user) {
            throw new UnknownAccountException("用户在Redis不存在");
        }
        // SimpleAuthenticationInfo 是 Apache Shiro 中的一个核心类，用于封装认证信息。它主要用于在认证过程中传递用户的身份信息和凭证信息。
        // 查看源码，其实主要比对 credentials（凭证）。
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
                user,  // 身份标识  封装成 SimplePrincipalCollection，传递给 doGetAuthorizationInfo() 方法
                token, // 凭证
                this.getName()  // Realm 名称
        );
        return simpleAuthenticationInfo;
    }
	
    /**
     * @MethodName doGetAuthorizationInfo
     * @Description 权限配置类，用于获取返回用户配置的角色和权限
     * @Param principalCollection
     * @Return AuthorizationInfo
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("enter doGetAuthorizationInfo");
        // 获取身份标识
        // getPrimaryPrincipal() 获取的是 doGetAuthenticationInfo() 返回对象 SimpleAuthenticationInfo 的身份标识 SimplePrincipalCollection 对象。
        SysUser principal = (SysUser) principals.getPrimaryPrincipal();
        System.out.println(principal);

        // 通过用户名获取角色权限集合
        SysUser user = sysUserService.listRolePermByName(principal.getUserName());
        System.out.println(user);
        // 添加角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (SysRole role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //添加权限
            for (SysPermissions permissions : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permissions.getPermissionsName());
            }
        }
        return simpleAuthorizationInfo;
    }

    public static void main(String[] args) {
        String pwd = "123456";
        /*
         * SHA-256加密：
         * 使用SimpleHash类对原始密码进行加密。
         * 第一个参数代表使用 SHA-256 方式加密
         * 第二个参数为原始密码
         * 第三个参数为盐值
         * 第四个参数为加密次数
         * 最后用toHex()方法将加密后的密码转成String
         * */
        String shaPwd = new SimpleHash("SHA-256",
                pwd,
                ByteSource.Util.bytes(GLOBE_SALT),
                1024).toHex();
        System.out.println("shaPwd=" + shaPwd);
    }
}

详细方法讲解参见本栏目文章 🍃《Shiro实战》，现讲解 Shiro 结合 JWT 和 Redis 后的不同点。

• doGetAuthenticationInfo()：增加判断 JWT 的合法性、是否存储在 Redis 等逻辑。
  • 参数：AuthenticationToken，接收 JwtToken 类型。
    • getPrincipal()：身份标识（principal）为 JWT。
    • getCredentials()：凭证（credentials）为 JWT。
  • 返回值：AuthenticationInfo ，用于封装认证信息。
    • principal: 用户对象。
    • credentials: JWT。
  • ✨注1：返回对象 SimpleAuthenticationInfo 的凭证（credentials）和入参 JwtToken 的凭证比对。
  • ✨注2：principal（身份标识）封装成 SimplePrincipalCollection，传递给 doGetAuthorizationInfo() 方法。
• doGetAuthorizationInfo()： 用于从数据源（如数据库、LDAP 等）中获取用户的授权信息（如角色和权限）。
  • 参数：principals，包含 认证身份标识的集合，通常是从 AuthenticationInfo 中获取的。
    • getPrimaryPrincipal()：获取的是 doGetAuthenticationInfo() 返回对象 SimpleAuthenticationInfo 的身份标识 SimplePrincipalCollection 对象，即用户对象。

权限配置方法 doGetAuthorizationInfo ( PrincipalCollection principalCollection ) 中 PrincipalCollection 从何而来？

• PrincipalCollection 是 Shiro 用来存储一个或多个 principal（即身份标识）的对象。doGetAuthorizationInfo 方法通过传入的 PrincipalCollection 参数，可以访问到当前用户的全部已知身份信息。
• SimpleAuthenticationInfo 是一个封装了用户认证信息的对象，其中包含了 PrincipalCollection 作为用户的身份标识，以及用户的凭证（如密码）和 Realm 名称。SimplePrincipalCollection 类型的身份标识会传递给 doGetAuthorizationInfo() 方法。

2.4 Controller层-登录

登录流程：查询数据库，判断传入的用户名、密码是否正确。如果正确，生成 JWT，存储到 Redis，返回前端生成的 JWT；如果不正确，返回错误信息。

@Slf4j
@RestController
@RequestMapping("/sys")
public class LoginController {
    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public Result login(@RequestBody SysUser user) {
        System.out.println("login");
        if (StringUtils.isEmpty(user.getUserName()) || StringUtils.isEmpty(user.getPassword())) {
            return Result.error("请输入用户名和密码！");
        }
        // 通过用户名获取用户信息
        SysUser sysUser = sysUserService.getOne(new QueryWrapper<SysUser>().eq("user_name", user.getUserName()));
        if (user == null) {
            log.error("用户名不存在！");
            return Result.error("用户名不存在！");
        }
        // 传入密码进行 SHA-256 哈希后，和数据库密码进行对比
        String shaPwd = new SimpleHash("SHA-256",
                user.getPassword(),
                ByteSource.Util.bytes(GLOBE_SALT),
                1024).toHex();
        if (!sysUser.getPassword().equalsIgnoreCase(shaPwd)) {
            log.error("密码错误！");
            return Result.error("密码错误！");
        }
        // 验证成功，生成 JWT
        String token = jwtUtil.getToken(user.getUserName(), System.currentTimeMillis());
        redisUtil.setObject(RedisConstant.PREFIX_SHIRO_JWT + token, sysUser, 60 * 60);
        return Result.success(token);
    }

    @RequiresRoles("admin")
    @GetMapping("/admin")
    public String admin() {
        return "admin success!";
    }

    @RequiresPermissions("query")
    @GetMapping("/query")
    public String query() {
        return "query success!";
    }

    @RequiresPermissions("add")
    @GetMapping("/add")
    public String add() {
        return "add success!";
    }

    @GetMapping("/anon")
    public String anon(ServletRequest request) {
        return "anon enter!";
    }
}

2.5 测试

2.5.1 测试登录

📊 postman：http://localhost:9090/sys/login

登录成功，返回 JWT。

JWT：

Redis：

2.5.2 测试登录，访问资源

📊 postman：http://localhost:9090/sys/anon，请求头携带 JWT。

后台日志：

调用 doGetAuthenticationInfo() 方法校验 token 的合法性。

2.5.3 测试访问有权限的资源

📊 postman：http://localhost:9090/sys/query，请求头携带 JWT。

后台日志：

调用 doGetAuthorizationInfo() 方法从数据源中获取用户的授权信息（如角色和权限）。

2.5.4 测试访问无权限的资源

📊 postman：http://localhost:9090/sys/add，请求头携带 JWT。

后台日志：

无权限，限制访问。

2.5.5 测试Redis过期

📊 postman：http://localhost:9090/sys/anon，请求头携带 JWT。

后台日志：

---

参考文章：
📖 Shiro+Jwt+Redis
📖 手把手教你Shiro整合JWT实现登录认证