写在前面
本文的出现表示不再进行 Spring Security Oauth 实现的研究了，原因是原开源项目已经被废弃了不再更新了，而且 Oauth 实现的内容有些奇怪，新的项目 spring-authorization-server 目前才发布到 0.1.0，默认只提供了基于内存的实现，个人认为还不是很完善，不适合用到项目中。而且 Spring Security 的 Oauth 流程都实现了，要修改还得从新研究 spring-authorization-server 的实现逻辑，然后进行修改定制，太耗费精力了，不如使用 Shiro 自己实现 Oauth 的逻辑。
但是本文和 Oauth 无关，单纯是 Shiro + Springboot + JWT 的整合。
本文使用的依赖如下：
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.7.1</version>
</dependency>
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.11.0</version>
</dependency>
还有一点要说明的是，Shiro 有针对 SpringBoot 的默认配置，详细配置见官网：
- 与
Spring集成：http://shiro.apache.org/spring-framework.html - 与
SpringBoot集成：http://shiro.apache.org/spring-boot.html
但是在本文中并没有使用 SpringBoot 集成方式，也没有按官网的教程导入默认配置，因为 Shiro 要运行起来配置相对较于简单，需要配置的并不多，而且从本人的了解来看，Shiro 适合基于 Session 进行登录状态存储的模式，使用 Jwt 将状态存储在了 Token 里，这种模式对配置的逻辑需要做部分更改，而且还有些坑，所以没有基于默认配置进行配置，需要注意的地方以下会有说明。
记录贴，刚接触 Shiro，内容如有错误，望大佬指正。
1. 实现源码
示例项目已经上传到 Github 直接可用：https://github.com/nineya/framework-study/tree/v0.1.0/shiro-study
项目结构：
1.1 SpringBoot 程序入口
package com.nineya.shiro;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author 殇雪话诀别
* 2021/2/15
* 程序入口
*/
@SpringBootApplication
public class ShiroApplication {
public static void main(String[] args) {
SpringApplication.run(ShiroApplication.class);
}
}
1.2 实体类
简单自定义用户、角色和权限实体类，一个用户可以包含多个角色，一个角色可以包含多个权限。
package com.nineya.shiro.entity;
/**
* @author 殇雪话诀别
* 2021/2/15
* 权限
*/
public class Permissions {
private long id;
private String permissionsName;
public Permissions() {
}
public Permissions(long id, String permissionsName) {
this.id = id;
this.permissionsName = permissionsName;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getPermissionsName() {
return permissionsName;
}
public void setPermissionsName(String permissionsName) {
this.permissionsName = permissionsName;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("Permissions{");
sb.append("id=").append(id);
sb.append(", permissionsName='").append(permissionsName).append('\'');
sb.append('}');
return sb.toString();
}
}
package com.nineya.shiro.entity;
import java.util.Set;
/**
* @author 殇雪话诀别
* 2021/2/15
* 角色，包含权限集合
*/
public class Role {
private long id;
private String roleName;
/**
* 角色拥有的权限集合
*/
private Set<Permissions> permissions;
public Role() {
}
public Role(long id, String roleName, Set<Permissions> permissions) {
this.id = id;
this.roleName = roleName;
this.permissions = permissions;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Set<Permissions> getPermissions() {
return permissions;
}
public void setPermissions(Set<Permissions> permissions) {
this.permissions = permissions;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("Role{");
sb.append("id=").append(id);
sb.append(", roleName='").append(roleName).append('\'');
sb.append(", permissions=").append(permissions);
sb.append('}');
return sb.toString();
}
}
package com.nineya.shiro.entity;
import java.util.Set;
/**
* @author 殇雪话诀别
* 2021/2/15
* 用户，包含角色集合
*/
public class User {
private long uid;
private String userName;
private String password;
/**
* 用户对应的角色
*/
private Set<Role> roles;
public User() {
}
public User(long uid, String userName, String password, Set<Role> roles) {
this.uid = uid;
this.userName = userName;
this.password = password;
this.roles = roles;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("User{");
sb.append("uid=").append(uid);
sb.append(", userName='").append(userName).append('\'');
sb.append(", password='").append(password).append('\'');
sb.append(", roles=").append(roles);
sb.append('}');
return sb.toString();
}
}
1.3 服务层
创建 Login 服务层实现，能够取读取用户信息进行用户登录操作，在实际使用时此处修改为；连接数据库获取数据。
package com.nineya.shiro.service;
import com.nineya.shiro.entity.User;
/**
* @author 殇雪话诀别
* 2021/2/15
* 用户登录服务接口
*/
public interface LoginService {
/**
* 通过用户名取得用户
*
* @param name 用户名
* @return
*/
User getUserByName(String name);
}
package com.nineya.shiro.service.impl;
import com.nineya.shiro.entity.Permissions;
import com.nineya.shiro.entity.Role;
import com.nineya.shiro.entity.User;
import com.nineya.shiro.service.LoginService;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* @author 殇雪话诀别
* 2021/2/15
* 用户登录服务，使用Map<用户名, 用户信息> 的格式存储用户信息进行查询
* 在实际使用中将此处修改为连接数据库查询即可
*/
@Service
public class LoginServiceImpl implements LoginService {
private final Map<String, User> users = new HashMap<>();
public LoginServiceImpl() {
// 定义三个权限
Permissions permissions1 = new Permissions(1, "create");
Permissions permissions2 = new Permissions(2, "delete");
Permissions permissions3 = new Permissions(3, "select");
// 定义两个角色
Role role1 = new Role(1, "read", new HashSet<Permissions>(){{add(permissions3);}});
Role role2 = new Role(1, "write", new HashSet<Permissions>(){{add(permissions1);add(permissions2);}});
// 定义三个用户分别对应两个角色
users.put("observe", new User(1, "observe", "123456", Collections.singleton(role1)));
users.put("admin", new User(1, "admin", "123456", Collections.singleton(role2)));
users.put("user", new User(1, "user", "123456", new HashSet<Role>(){{add(role1); add(role2);}}));
}
@Override
public User getUserByName(String name) {
return users.get(name);
}
}
1.4 Token 工具类
token 工具类负责 Jwt 的创建和解析，在本文中将 username 加入到负载，实际使用中可以将角色等信息一起加入。但是不应该将大量数据和隐式数据加入到 jwt 中，因为 jwt 没有加密，大量的数据会导致 token 过长，加重网络负载。
package com.nineya.shiro.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
/**
* jwt处理类
*
* @author 殇雪话诀别
* 2020/11/29
*/
@Component
public class UserTokenUtil {
/**
* jwt 加密算法
*/
private Algorithm algorithm;
private JWTVerifier verifier;
public UserTokenUtil() {
algorithm = Algorithm.HMAC256("secret");
verifier = JWT.require(algorithm).build();
}
/**
* 创建用户token，并将token创建时间存入
*
* @param username 用户名称
* @return token字符串
*/
public String createToken(String username) {
Date expireTime = new Date(System.currentTimeMillis() + 60 * 60 * 1000);
return JWT.create()
.withClaim("username", username)
.withExpiresAt(expireTime)
.sign(algorithm);
}
/**
* 校验token合法性
*
* @param token
* @return
*/
public DecodedJWT verifyToken(String token) {
try {
return verifier.verify(token);
} catch (Exception e) {
throw new TokenExpiredException("token 解析失败");
}
}
/**
* 取得用户名
*
* @param token
* @return
*/
public String getUserName(String token) {
DecodedJWT jwt = verifyToken(token);
return jwt.getClaim("username").asString();
}
}
1.5 控制器（开始涉及Shiro）
添加 login 登录接口实现，添加几个简单接口作为后续的调用示例，此处开始设计上面所述的 jwt 逻辑不同的问题了。
package com.nineya.shiro.controller;
import com.nineya.shiro.entity.User;
import com.nineya.shiro.service.LoginService;
import com.nineya.shiro.util.UserTokenUtil;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.Date;
/**
* @author 殇雪话诀别
* 2021/2/15
*/
@RestController
public class LoginController {
@Resource
private LoginService loginService;
@Resource
private UserTokenUtil tokenUtil;
/**
* 使用 jwt 进行登录时此处逻辑将有些不同
* 如果没有使用Token，用户将在此方法中通过 subject.login(usernamePasswordToken) 进行登录。
* 使用 jwt 时，将不再使用 session 存储登录状态，subject.login(usernamePasswordToken) 逻辑将在 Filter 解析 token 时进行，并且
* 每次请求都需要进行 token 解析和登录操作。
* 也就是说认证、授权两个步骤，原本只要登录时进行认证，每次请求进行授权，使用 jwt 后每次请求都需要记性jwt解析、认证和授权三个步骤。
* @param userName 用户名
* @param password 密码
* @return
*/
@GetMapping("/login")
public String login(@RequestParam("userName") String userName, @RequestParam("password") String password) {
if (StringUtils.isEmpty(userName) || StringUtils.isEmpty(password)) {
return "请输入用户名和密码！";
}
User user = loginService.getUserByName(userName);
if (!user.getPassword().equals(password)) {
return "密码不正确！";
}
return tokenUtil.createToken(userName);
}
// 这是没有使用 jwt 时，基于 session 的实现方式
// @GetMapping("/login")
// public String login(User user) {
// if (StringUtils.isEmpty(user.getUserName()) || StringUtils.isEmpty(user.getPassword())) {
// return "请输入用户名和密码！";
// }
// //用户认证信息
// Subject subject = SecurityUtils.getSubject();
// UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(
// user.getUserName(),
// user.getPassword()
// );
// try {
// //进行验证，这里可以捕获异常，然后返回对应信息
// subject.login(usernamePasswordToken);
//// subject.checkRole("admin");
//// subject.checkPermissions("query", "add");
// } catch (UnknownAccountException e) {
// return "用户名不存在！";
// } catch (AuthenticationException e) {
// return "账号或密码错误！";
// } catch (AuthorizationException e) {
// return "没有权限";
// }
// return "login success";
// }
/**
* 允许角色为 read 且为 write 用户访问
* @return
*/
@RequiresRoles({"read", "write"})
@GetMapping("/admin")
public String admin() {
return "admin";
}
/**
* 允许拥有 select 权限的用户访问
* @return
*/
@RequiresPermissions("select")
@GetMapping("/select")
public String select() {
return "select";
}
/**
* 允许拥有 create 权限的用户访问
* @return
*/
@RequiresPermissions("create")
@GetMapping("/create")
public String create() {
return "create";
}
}
package com.nineya.shiro.controller;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* @author 殇雪话诀别
* 2021/2/15
* 对未通过权限认证的部分异常进行异常处理
*/
@ControllerAdvice
public class ExceptionController {
@ExceptionHandler
@ResponseBody
public String ErrorHandler(AuthorizationException e) {
return "没有通过权限验证！\n" + e.getMessage();
}
}
1.6 自定义 JWT 过滤器
检查请求头是否有 Authorization 字段，如果包含则进行 token 解析和登录操作。
package com.nineya.shiro.filter;
import com.nineya.shiro.controller.ExceptionController;
import org.apache.shiro.authc.BearerToken;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
/**
* @author 殇雪话诀别
* 2021/2/15
*/
public class TokenFilter extends BasicHttpAuthenticationFilter {
/**
* 判断用户是否想要登入。
* 检测header里面是否包含Authorization字段即可
*/
@Override
protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
HttpServletRequest req = (HttpServletRequest) request;
String authorization = req.getHeader(AUTHORIZATION_HEADER);
return authorization != null;
}
/**
* 该方法返回值表示是否跳过认证，这里如果返回 true，则不会再走一遍认证流程
* 如果返回 false，则会执行 isAccessAllowed 方法，再执行isLoginAttempt方法，如果为false继续执行executeLogin
* 方法，如果没有执行executeLogin或者执行结果也是false，则将执行sendChallenge方法，表示认证失败。
* 返回 true 时，则必须在postHandle配置退出登录，这个方法将在执行完业务逻辑后执行，否则将导致下次没有携带token时直接使用上次的登录
* 结果，从而非法访问接口。
* 默认返回 false 时，isLoginAttempt这些方法将重复调用，所以不建议。如果要返回 false，建议复写 sendChallenge 方法，因为其响应内容为空。
*
* 也可以将 isAccessAllowed 作为纯判断是否需要认证，或者不复写该方法，本文不提供实现，如果有问题欢迎留言
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
//判断请求的请求头是否带上 "Token"
if (isLoginAttempt(request, response)) {
//如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
try {
return executeLogin(request, response);
} catch (Exception e) {
//token 错误
e.printStackTrace();
return false;
}
}
//如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
return true;
}
/**
* 用户登录
* @param request
* @param response
* @return
*/
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader(AUTHORIZATION_HEADER);
BearerToken jwtToken = new BearerToken(token, request.getRemoteAddr());
getSubject(request, response).login(jwtToken);
return true;
}
/**
* 该方法将在过滤器执行完成后执行
* 当isAccessAllowed默认为true时必须实现该方法
* 在执行完请求后执行退出登录逻辑，否则下次请求时没有携带将可以直接访问接口，无须重新登录
* @param request
* @param response
* @throws Exception
*/
@Override
protected void postHandle(ServletRequest request, ServletResponse response) throws Exception {
SecurityUtils.getSubject().logout();
}
/**
* 当 isAccessAllowed 可能返回false时需要复写该接口，否则默认将返回空白界面
* @param request
* @param response
* @return
*/
@Override
protected boolean sendChallenge(ServletRequest request, ServletResponse response) {
super.sendChallenge(request, response);
HttpServletResponse httpResponse = WebUtils.toHttp(response);
httpResponse.setContentType("application/json; charset=utf-8");
try {
response.getWriter().write(
JSONObject.toJSONString(ResponseResult.failure(StatusCode.UNAUTHORIZED, "登录状态已失效！").toMap()));
} catch (IOException e) {
throw new UnauthenticatedException("登录状态已失效！");
}
return false;
}
/**
* 登录异常处理类，该方法将捕获所有在本过滤器中遇到的异常，默认将会进行登录重试，重试失败后执行 afterCompletion 方法进行善后处理，
* 后将异常封装为 ServletException。
* 建议复写本方法 jwt 登录失败，重试也是无果的。
* @param request
* @param response
* @param existing 异常信息，如果为 null表示没有异常，不需要进行处理
* @throws ServletException
* @throws IOException
*/
@Override
protected void cleanup(ServletRequest request, ServletResponse response, Exception existing) throws ServletException, IOException {
// 不管什么异常，全部抛出登录失败就是了
if (existing != null) {
sendChallenge(request, response);
}
}
}
1.7 自定义 Realm
Shiro 默认提供了 JdbcRealm、IniRealm 和 DefaultLdapRealm 等实现，但是并不是很符合我所需要的场景，也不能实现 jwt 的解析，所以采用继承 AuthorizingRealm 自定义 Realm 类，复写 doGetAuthorizationInfo（授权）和 doGetAuthenticationInfo（认证）两个接口。
此处其实有坑的，而且逻辑并不是很适合 jwt 的实现，但是没有好的方案进行修改，后续将详细说明。
-
此处只是示例，在授权和认证两次的
loginService.getUserByName(name)操作均可以想办法避免。 -
可以在认证步骤解析
JWT为中间对象，然后将中间对象作为Principal，能够避免重复解析JWT带来性能浪费。
package com.nineya.shiro.config;
import com.nineya.shiro.entity.Permissions;
import com.nineya.shiro.entity.Role;
import com.nineya.shiro.entity.User;
import com.nineya.shiro.service.LoginService;
import com.nineya.shiro.util.UserTokenUtil;
import org.apache.catalina.realm.AuthenticatedUserRealm;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthenticatingRealm;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.stream.Collectors;
/**
* 自定义 realm
*
* @author 殇雪话诀别
* 2021/2/15
*/
public class StudyRealm extends AuthorizingRealm {
@Resource
private LoginService loginService;
@Resource
private UserTokenUtil tokenUtil;
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof BearerToken;
}
/**
* 授权，在认证之后执行
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String token = (String) principals.getPrimaryPrincipal();
String name = tokenUtil.getUserName(token);
User user = loginService.getUserByName(name);
// 添加角色和权限
SimpleAuthorizationInfo simpleAuthenticationInfo = new SimpleAuthorizationInfo();
for (Role role : user.getRoles()) {
// 添加角色
simpleAuthenticationInfo.addRole(role.getRoleName());
// 添加权限
simpleAuthenticationInfo.addStringPermissions(role.getPermissions().stream()
.map(Permissions::getPermissionsName).collect(Collectors.toSet()));
}
return simpleAuthenticationInfo;
}
/**
* 认证
* @param token
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
if (StringUtils.isEmpty(token.getPrincipal())) {
return null;
}
String name = tokenUtil.getUserName((String) token.getPrincipal());
User user = loginService.getUserByName(name);
if (user == null) {
return null;
}
// 第一个参数是主体，将会在授权时封装成PrincipalCollection.getPrimaryPrincipal()进行使用，所以必须将jwt内容传回
// 第二个参数是认证信息，即密码，为后面验证可以通过，需要和token中的内容一样
// 第三个参数是领域名称
return new SimpleAuthenticationInfo(token.getPrincipal(), token.getCredentials(), user.getUserName());
}
}
1.8 Shiro 配置
package com.nineya.shiro.config;
import com.nineya.shiro.filter.TokenFilter;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.Map;
/**
* @author 殇雪话诀别
* 2021/2/15
* 配置类
*/
@Configuration
public class ShiroConfiguration {
/**
* 配置代理，没有配置将会导致注解不生效
* @return
*/
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
defaultAAP.setProxyTargetClass(true);
return defaultAAP;
}
/**
* 配置代理，没有配置将会导致注解不生效
* @return
*/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
/**
* 将自己的验证方式加入容器
* @return
*/
@Bean
public Realm studyRealm() {
StudyRealm studyRealm = new StudyRealm();
return studyRealm;
}
/**
* 不应该将过滤器的实现注册为bean，否则会导致Filter过滤器顺序混乱，导致抛出异常
* 如果一定要注册为 Bean，可以使用 Order 指定优先级，还未尝试过
* @return
*/
public TokenFilter tokenFilter() {
return new TokenFilter();
}
/**
* Filter工厂，设置对应的过滤条件和跳转条件
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean() {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager());
Map<String, String> map = new HashMap<>();
//登出
map.put("/logout", "logout");
// 使用我们自己创建的jwt过滤器名称
map.put("/**", "jwt");
//登录
shiroFilterFactoryBean.setLoginUrl("/login");
//首页
shiroFilterFactoryBean.setSuccessUrl("/select");
//错误页面，认证不通过跳转
shiroFilterFactoryBean.setUnauthorizedUrl("/error");
shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
shiroFilterFactoryBean.setFilters(new HashMap<String, Filter>(){{put("jwt", tokenFilter());}});
return shiroFilterFactoryBean;
}
/**
* 权限管理，配置主要是Realm的管理认证，同时可以配置缓存管理等
* @return
*/
@Bean
public DefaultWebSecurityManager securityManager() {
DefaultWebSecurityManager webSecurityManager = new DefaultWebSecurityManager();
//realm管理
webSecurityManager.setRealm(studyRealm());
return webSecurityManager;
}
}
2. 为什么说 Shiro 对 JWT支持不是很好？
本文一开始就说了 Shiro 对 Jwt 模式的支持不是很好，全部都是本人个人的理解，如果内容有误请留言提问。
2.1 认证/授权模式藏BUG
- 对性能的影响
Shiro 整体都是围绕着认证/授权模式展开的，该模式适用于 有状态 （即服务端存储登录信息）的系统，在登录时进行 认证，一旦登录完成后就不再需要进行认证步骤，直接根据权限配置进行认证。而 JWT 是 无状态的实现方式，所有的登录信息都存储在 Token 里，在过滤器中每次都需要根据 token 信息执行 getSubject(request, response).login(jwtToken) 方法，然后都会走一次 realm 的 doGetAuthenticationInfo 方法进行认证。
对于 JWT 来说，这个授权和认证步骤实际上是可以合并在一起作为授权步骤，登录账号密码校验才是认证步骤，但是不能在登录时调用 getSubject(request, response).login(jwtToken) 进行登录，必须在过滤器中根据 token 进行调用登录，这导致了性能的浪费，可以在认证步骤解析 JWT 为中间对象，然后将中间对象作为 Principal，能够避免重复解析 JWT 带来性能浪费，但是 Shiro 重复走认证流程的性能浪费不可避免。
- cache 藏 BUG
由于 JWT 的 Token 具有时效性，而 Token 又是作为认证步骤的凭证，如果开启了缓存，缓存将根据 Token 进行存储，导致后续对于该 Token 不会再进行认证流程，将会导致失效的 Token 还可以访问系统。
恶心的是 public final AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) 方法无法复写的，所以只能关闭缓存功能才能解决这个问题，或者手动实现这些内容。如果关闭缓存的话，授权步骤又是同样的缓存逻辑，授权步骤的缓存也将被一并关闭，对性能也会造成影响。
综上，Shiro 对 JWT 的支持并不是很好，但是也不是没办法解决，手动复写这些类就好，只是将会比较繁琐。