Spring Boot整合Shiro和JWT的无状态权限管理方案

public class JWTShiroRealm extends AuthorizingRealm {

   /**
     * 可供扩展的权限加载器，由应用程序负责实现
     */
    private JWTUserAuthService userAuthService;

    private JWTHelper jwtHelper;

    public JWTShiroRealm(JWTUserAuthService userAuthService, JWTHelper jwtHelper) {
        this.jwtHelper = jwtHelper;
        this.userAuthService = userAuthService;
    }

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JWTToken;
    }

    /**
     * 用于获取用户权限（role,permissions）,只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        JWTPrincipal principal = (JWTPrincipal) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo authInfo = new SimpleAuthorizationInfo();
        UserInfo up = userAuthService.getUserInfo(principal.getAccount());
        if (up != null && up.getPermissions() != null) {
            authInfo.addStringPermissions(up.getPermissions());
        }
        return authInfo;
    }

    /**
     * 调用subject.login时触发此方法，用于验证token的正确性
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        String token = (String) auth.getCredentials();
        // 从token中获取用户的唯一标识
        String account = jwtHelper.getAccount(token);
        if (account== null) {
            throw new AuthenticationException("无效的请求");
        }
        UserInfo user = userAuthService.getUserInfo(account);
        if (user == null) {
            throw new AuthenticationException("未找到用户信息");
        }
        DecodedJWT jwt = jwtHelper.verify(token, account, user.getSecret());
        if (jwt == null) {
            throw new AuthenticationException("token已经过期，请重新登录");
        }
        JWTPrincipal principal = new JWTPrincipal();
        principal.setAccount(user.getAccount());
        principal.setExpiresAt(jwt.getExpiresAt().getTime());
        //这里实际上会将AuthenticationToken.getCredentials()与传入的第二个参数credentials进行比较
        //第一个参数是登录成功后，可以通过subject.getPrincipal获取
        return new SimpleAuthenticationInfo(principal, token, this.getName());
    }

public interface JWTUserAuthService {

    /**
     * 根据用户的唯一标示对用户进行认证，并获取用户的权限等信息
     * 如果account对应的用户信息不存在，应返回null
     * @param account 用户的唯一标示
     * @return 该用户所拥有的权限信息
     */
    UserInfo getUserInfo(String account);

    /**
     * 自定义访问资源认证失败时的处理方式，例如返回json格式的错误信息
     * {\"code\":401,\"message\":\"用户认证失败！\")
     */
    void onAuthenticationFailed(HttpServletRequest req, HttpServletResponse res);

    /**
     * 自定义访问资源权限不足时的处理方式，例如返回json格式的错误信息
     * {\"code\":403,\"message\":\"permission denied！\")
     */
    void onAuthorizationFailed(HttpServletRequest req, HttpServletResponse res);}

public class UserInfo {

  /**
    * 用户的唯一标识
    */
   private String account;

   /**
     * accessToken的密钥，用于对accessToken进行加密和解密
     * 建议为每个用户配置不同的密钥（比如使用用户的password）
     */
   private String secret;

   /**
    * 用户权限集合，含义类似于Shiro中的perms
    */
   private Set<String> permissions;}

   @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        //从header或URL参数中查找token
        HttpServletRequest req = (HttpServletRequest) request;
        String authorization = req.getHeader(headerKeyOfToken);
        if (Strings.isNullOrEmpty(authorization)) {
            authorization = req.getParameter(headerKeyOfToken);
        }
        JWTToken token = new JWTToken(authorization);
        try {
            getSubject(request, response).login(token);
        } catch (Exception e) {
            logger.error("认证失败:" + e.getMessage());
            return false;
        }
        return true;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
        this.userAuthService.onAuthenticationFailed((HttpServletRequest) request, (HttpServletResponse) response);
        return false;
    }

<property name="filterChainDefinitions"> 
    <value>
      /static/** = anon
      /api/** = authc
      /api/user = perms["user"]    </value></property>

//执行这个方法，需要当前用户具有user:modify权限@RequiresPermissions("user:modify")public void modifyUserInfo(){}

@RestController@RequestMapping("/api/user")@RequiresPerms("user:basic")public class UserController {

    @AlowAnonymous
    @PostMapping("/login")
    public String login() {
       return "ok";
    }

    @GetMapping("/detail")
    public String getUserDetail() {
       return "ok";
    }

    @PostMapping("/modify")
    @RequiresPerms("user:modify")
    public String modifyUser() {
        return "ok";
    }

    @PostMapping("/delete")
    @RequiresPerms({"system","user:delete"})
    public String deleteUser() {
        return "ok";
    }

    @PostMapping("/modify-logs")
    @RequiresPerms(value={"system","user:logs"}, logical = Logical.OR)
    public String deleteUser() {
        return "ok";
    }}

/api/user/login     = anon
/api/user/detail    = perms[ user:basic ]
/api/user/modify  = perms[ user:modify ]
/api/user/delete   = perms[ system,user:delete ]
#默认的shiro配置并不支持配置OR的比较操作符，这里的anyPerms是自定义过滤器
/api/user/modify-logs= anyPerms[ system,user:logs ]