SpringBoot 集成 JWT 和 Apache Shiro任何后端管理系统软件都避免不了登录验证和权限管理，大多数

任何后端管理系统软件都避免不了登录验证和权限管理，大多数系统一开始就要设计登录认证以及权限管理模块。掌握登录认证以及权限管理的模块设计已经成为基础知识，本篇文章将采用 JWT 与 Apache Shiro 来讲解前后端分离中常用的认证与权限管理。

Shiro 简介

Apache Shiro是一个功能强大且易于使用的Java安全框架，可以执行身份验证、授权、加密和会话管理。

Shiro的体系结构有三个主要概念 Subject、SecurityManager 和 Realms。

Subject

在保护应用程序安全时，最关键的问题是：“当前用户是谁？是否允许当前用户执行X？” 。只有辨识用户后才能判断用户权限。Subject 表示“当前正在执行的主体”，该主体可以是另一个系统的调用，也可以是用户登录。

获取当前登录主体

import org.apache.shiro.subject.Subject;
import org.apache.shiro.SecurityUtils;
...
Subject currentUser = SecurityUtils.getSubject();

SecurityManager

Subject 代表用户的操作，SecurityManager 管理用户的操作。它是 Shiro 体系结构的核心，其内部有许多安全组件。每个应用程序一般只有一个 SecurityManager 实例，SecurityManager 的部分参数可以使用 .ini 文件进行配置。

使用 shiro.ini

[users]
jane.admin = password, admin
john.editor = password2, editor
zoe.author = password3, author
paul.reader = password4

[roles]
admin = /
editor = /articles
author = /articles/drafts

ini 配置文件的 [users] 部分定义了 SecurityManager 能够识别的用户凭据。格式为: principal (username) = password, role1, role2...。

[roles] 部分声明角色及其关联的权限。管理员角色被授予对应用程序的每个部分的权限和访问权。

使用 IniRealm 来从 shiro.ini 文件加载用户和角色定义，然后使用它来配置DefaultSecurityManager 对象

IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
SecurityManager securityManager = new DefaultSecurityManager(iniRealm);

SecurityUtils.setSecurityManager(securityManager);
Subject currentUser = SecurityUtils.getSubject();

Realms

当需要获取用户帐户数据执行身份验证(登录)和授权(访问控制)时，Shiro会从为应用程序配置的领域 Realm 中查找用户帐户数据内容。

常用的方式是在 Realm 实现对象中调用 DAO 方法获取用户账户信息。

public class MyCustomRealm extends AuthorizingRealm {

    /**
     * 认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        String username = token.getUsername();
        String password = this.shiroSampleDao.getPasswordByUsername(username);
        return new SimpleAuthenticationInfo(username, password, getName());
    }

    /**
     * 授权
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        String username = (String) super.getAvailablePrincipal(principalCollection);
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        Set<String> roles = shiroSampleDao.getRolesByUsername(username);
        authorizationInfo.setRoles(roles);
        roles.forEach(role -> {
            Set<String> permissions = this.shiroSampleDao.getPermissionsByRole(role);
            authorizationInfo.addStringPermissions(permissions);
        });
        return authorizationInfo;
    }

}

我们已经了解了 Shiro 的基本环境，如果想要定制化开发，我们还需要了解两个重要的概念，Authentication 和 Authorization。

Authentication 认证

身份验证是验证用户身份的过程。当用户通过应用程序进行身份验证时，他们在证明自己是他们所说的身份。有时也验证称为“登录”，通常分为三步：

收集用户的标识信息（称为身份 principals）和支持身份证明的凭证（也叫凭据 credentials）。
将身份 principals 和凭据 credentials 提交到系统。
如果提交的凭据 credentials 与系统对于该用户身份（principal）的期望匹配，则认为该用户已通过身份验证 authentication 。如果它们不匹配，则不认为用户已通过身份验证 authentication 。

每个人都熟悉的此过程的一个常见示例是 username/password 组合。当大多数用户登录软件应用程序时，通常会提供其 username （身份信息 principal）和 password （凭据 credential）。如果存储在系统中的密码与用户指定的密码匹配，则认为它们已通过身份验证。

你想通过 Shiro 做的所有事情都可以通过与调用 Subject 的 API 来实现。要实现登录，可以调用 Subject 的 login 方法，并传递一个 AuthenticationToken 实例，该实例代表提交的身份信息和凭据（在本例中为用户名和密码）。

Subject Login

//1. Acquire submitted principals and credentials:
AuthenticationToken token = new UsernamePasswordToken(username, password);

//2. Get the current Subject:
Subject currentUser = SecurityUtils.getSubject();

//3. Login:
currentUser.login(token);

处理登录失败，您可以选择捕获各种异常并对异常进行各种处理

//3. Login:
try {
    currentUser.login(token);
} catch (IncorrectCredentialsException ice) { …
} catch (LockedAccountException lae) { …
}
…
catch (AuthenticationException ae) {…
}

确定允许用户执行的操作称为授权

Authorization 授权

授权实质上是访问控制，控制用户可以在应用程序中访问的内容（例如资源，网页等）。大多数用户通过使用角色和权限等概念来执行访问控制。 Subject API 使您可以非常轻松地执行角色和权限检查。

检查 Subject 是否被分配了特定角色

if ( subject.hasRole(“administrator”) ) {
    //show the ‘Create User’ button
} else {
    //grey-out the button?
}

检查 Subject 是否被分配了特定权限

if ( subject.isPermitted(“user:create”) ) {
    //show the ‘Create User’ button
} else {
    //grey-out the button?
}

如上，任何角色或用户被赋予 “user:create” 权限就可以点击“创建用户”按钮。

Shiro 还支持更细力度的实例级权限检查

if ( subject.isPermitted(“user:delete:jsmith”) ) {
    //delete the ‘jsmith’ user
} else {
    //don’t delete ‘jsmith’
}

因为 JWT 是无状态的，所以本篇就不讲解 SessionManager 内容。接下来我们就来了解一下 JWT。

RESTful API 认证方式

一般来说，RESTful API 通过身份验证和授权来保证 API 的安全性。

认证（Authentication） vs 授权（Authorization）

认证是指用户的身份认证，授权是确认用户拥有的操作权限。

认证（Authentication）的方式

Basic Authentication 这意味着将用户名和密码直接放入HTTP请求标头中。这是最简单的方法，但不建议这样做。
TOKEN Authentication 这是将JWT令牌直接放入HTTP请求标头中的最常用方法。这是推荐的方法。
OAuth2.0 这是最安全的方法，也是最复杂的方法。如果没有必要，不要考虑这种方式。

通常，我们只在项目中使用JWT进行身份验证。

什么是 JWT

JSON Web Token （JWT）是基于 JSON 的开放标准（RFC 7519），用于创建声明的访问令牌，这些令牌 token 包含一系列声明 claims。例如，服务器可以生成令牌，该令牌声明持有者具有“以管理员身份登录”的权利，该令牌会提供给客户端。然后，客户端可以使用该令牌来证明它以管理员身份登录。

令牌一般是由服务器方的私钥进行签名，另一方已经通过可靠方式如 Post 请求获取了相应的公钥，双方能够验证令牌是否合法。令牌被设计为紧凑，URL 安全的，并且特别是在 Web 浏览器单点登录（SSO）上下文中可用。

JWT 声明（claims）通常可用于在身份提供者和服务提供者之间传递经过身份验证的用户的身份，官方网站：https ://jwt.io/ 。 JWT 由三部分组成，所有这些部分共同形成了 JWS 字符串，如下所示：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOixMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydhVgNF3FkTHFOF

JWT 的三部分

Header 头部
Payload 负载
Signature 签名

Header 头

头部有两部分

声明类型 Type ：通常是 JWT
声明加密算法 algorithm ：典型的加密算法有HMAC和SHA-256 (HS256)， RSA签名和SHA-256 (RS256)。JWA (JSON Web算法) RFC 7518 引入了更多关于身份验证和加密的内容。

Header 通常如下：

{
  'typ': 'JWT',
  'alg': 'HS256'
}

然后加密 Header ，如下：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

Payload 负载

Payload 包括三个部分

Registered Claim 注册声明
Public Claim 公共声明
Private Claim 私有声明

Registered Claim

CODE	NAME	DESCRIPTION
iss	Issuer	标识发行 JWT 的签发者
sub	Subject	标识 JWT 的主题
aud	Audience	标识 JWT 接收人。
exp	Expiration Time	标识过期时间。过期时间之后的 JWT 不会进行处理。
nbf	Not Before	确定开始接受处理 JWT 的时间
iat	Issued at	标识发布JWT的时间。NumericDate 类型
jti	JWT ID	区分大小写的令牌的唯一标识符，即使在不同发行方之间也是如此。

Registered Claim

Public Claim

一般来说，公开声明可以包含任何信息，但不建议在这里添加敏感信息，因为这些信息很容易被解密。

Private Claim

私有声明是客户端和服务器端的声明。敏感信息不建议在这里声称。

一个典型的 PayLoad 如下

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

进行 Base64 加密后我们得到了 JWT 的第二段

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

Signature 签名

Signature 部分对前两部分签名，防止数据篡改。

Signature 包含三部分

header （加密后的）
payload （加密后的）
secret

JWT 的第三部分是之前的几部分的组合

加密后的 header + 加密后的 payload + secret

这部分加密后就得到了 JWT 串

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

注意 secret 保存在服务端，不应该被泄露。

在应用程序中使用 JWT

通常，我们将这些 JWT 信息添加到 HTTP 请求头中

fetch('api/user/1', {
  headers: {
    'Authorization': 'Bearer ' + token
  }
})

服务器负责分析用于身份验证和授权的 HTTP 头

安全问题

JWT 协议本身没有安全传输功能，所以他必须依赖安全信道 SSL/TLS，所以推荐方式如下

敏感信息不能存储在 jwt 的 payload 部分，因为这部分客户端可以解密。
一定要保存好私钥，不外泄
如果可以的话使用 HTTPS 协议

与 SpringBoot 集成

我们想要实现完全的前后端分离，所以不可能使用 session, cookie 方式进行认证，我们使用 JWT。

程序逻辑

发送 Post 请求到 /login ，如果成功返回 Token 如果失败返回 UnauthorizedException 异常。
用户访问每个需要权限的 URL 请求时，必须在头部添加授权字段，如 Authorization: Token。
后端将会对请求进行验证，否则返回 401

我们将使用的安全框架：

Apache Shiro
java-jwt

首先添加 Maven 依赖

        <dependencies>
       
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-spring-boot-web-starter</artifactId>
			<version>1.7.1</version>
		</dependency>
		<dependency>
			<groupId>com.auth0</groupId>
			<artifactId>java-jwt</artifactId>
			<version>3.4.1</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
       </dependencies>

构建模拟数据源

为了专注于如何使用 JWT 而不是 DB，我伪造了一个如下所示的数据源

| username | password | role  | permission |
| -------- | -------- | ----- | ---------- |
| smith    | smith123 | user  | view       |
| danny    | danny123 | admin | view,edit  |

通常权限管理模块 RBAC 需要 5 张数据表，分别是用户表、角色表、权限表、用户_角色表、角色_权限表，此处直接伪造了一个关联查询后获取的记录。

接下来，构建一个 UserService 来模拟数据库查询，并将结果放入 UserBean 中。

UserService.java

@Component
public class UserService {
    public UserBean getUser(String username) {
        // If no such user return null
        if (! DataSource.getData().containsKey(username))
            return null;
        UserBean user = new UserBean();
        Map<String, String> detail = DataSource.getData().get(username);
        user.setUsername(username);
        user.setPassword(detail.get("password"));
        user.setRole(detail.get("role"));
        user.setPermission(detail.get("permission"));
        return user;
    }
}

UserBean.java

@Data
public class UserBean {
    private String username;
    private String password;
    private String role;
    private String permission;
}

配置 JWT

我们构建了一个简单的 JWT 加密工具，并将用户密码作为加密密码，从而确保令牌即使被窃取也无法破解。另外，我们把用户名放在令牌里，设置5分钟后令牌过期。

public class JWTUtil {
    // 5 分钟后过期
    private static final long EXPIRE_TIME = 5*60*1000;
    /**
     * Verify TOKEN
     * @param token 
     * @param secret User password
     * @return 
     */
    public static boolean verify(String token, String username, String secret) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .build();
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception exception) {
            return false;
        }
    }
    /**
     * Get username from TOKEN
     * @return token contains username information
     */
    public static String getUsername(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }
    /**
     * 生成 signature, signature 5 分钟后过期
     * @param username 
     * @param secret 
     * @return Encryted token
     */
    public static String sign(String username, String secret) {
         
  		Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
		Algorithm algorithm = Algorithm.HMAC256(secret);

		return JWT.create().withClaim("username", username).withExpiresAt(date).sign(algorithm);
    }
}

ResponseBean.java

@Data
@AllArgsConstructor
public class ResponseBean {
    private int code;
    private String msg;
    private Object data;
}

自定义异常

public class UnauthorizedException extends RuntimeException {
    public UnauthorizedException(String msg) {
        super(msg);
    }
    public UnauthorizedException() {
        super();
    }
}

URL

URL	FUNCTION
/login	登录
/article	每个人都可以访问，但是不同的角色会得到不同的内容
/require_auth	登录用户可访问
/require_role	管理员角色可以访问
/require_permission	查看和编辑角色可以访问

测试用的 URL

Controller

@RestController
public class WebController {
    
    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public ResponseBean login(@RequestParam("username") String username,
                              @RequestParam("password") String password) {
        UserBean userBean = userService.getUser(username);
        if (userBean.getPassword().equals(password)) {
            return new ResponseBean(200, "Login success", JWTUtil.sign(username, password));
        } else {
            throw new UnauthorizedException();
        }
    }

    @GetMapping("/article")
    public ResponseBean article() {
        Subject subject = SecurityUtils.getSubject();
        if (subject.isAuthenticated()) {
            return new ResponseBean(200, "You are already logged in", null);
        } else {
            return new ResponseBean(200, "You are guest", null);
        }
    }

    @GetMapping("/require_auth")
    @RequiresAuthentication
    public ResponseBean requireAuth() {
        return new ResponseBean(200, "You are authenticated", null);
    }

    @GetMapping("/require_role")
    @RequiresRoles("admin")
    public ResponseBean requireRole() {
        return new ResponseBean(200, "You are visiting require_role", null);
    }

    @GetMapping("/require_permission")
    @RequiresPermissions(logical = Logical.AND, value = {"view", "edit"})
    public ResponseBean requirePermission() {
        return new ResponseBean(200, "You are visiting permission require edit,view", null);
    }

    @RequestMapping(path = "/401")
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public ResponseBean unauthorized() {
        return new ResponseBean(401, "Unauthorized", null);
    }
}

异常处理

正如前面提到的，RESTFUL 需要统一的样式，所以我们需要处理 Spring Boot 异常。

我们可以使用 @RestControllerAdvice 来处理异常

@RestControllerAdvice
public class ExceptionController {

    // Catch Shiro Exception
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    @ExceptionHandler(ShiroException.class)
    public ResponseBean handle401(ShiroException e) {
        return new ResponseBean(401, e.getMessage(), null);
    }

    // Catch UnauthorizedException
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    @ExceptionHandler(UnauthorizedException.class)
    public ResponseBean handle401() {
        return new ResponseBean(401, "Unauthorized", null);
    }

    // Catch Other Exception
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ResponseBean globalException(HttpServletRequest request, Throwable ex) {
        return new ResponseBean(getStatus(request).value(), ex.getMessage(), null);
    }

    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        return HttpStatus.valueOf(statusCode);
    }
}

配置 Shiro

JWTToken

public class JWTToken implements AuthenticationToken {
    // TOKEN
    private String token;
    public JWTToken(String token) {
        this.token = token;
    }
    @Override
    public Object getPrincipal() {
        return token;
    }
    @Override
    public Object getCredentials() {
        return token;
    }
}

Realm

@Service
public class MyRealm extends AuthorizingRealm {
    
    @Autowired
    private UserService userService;
    
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JWTToken;
    }
   
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = JWTUtil.getUsername(principals.toString());
        UserBean user = userService.getUser(username);
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRole(user.getRole());
        Set<String> permission = new HashSet<>(Arrays.asList(user.getPermission().split(",")));
        simpleAuthorizationInfo.addStringPermissions(permission);
        return simpleAuthorizationInfo;
    }
   
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        String token = (String) auth.getCredentials();
        
        String username = JWTUtil.getUsername(token);
        if (username == null) {
            throw new AuthenticationException("token invalid");
        }
        UserBean userBean = userService.getUser(username);
        if (userBean == null) {
            throw new AuthenticationException("User didn't existed!");
        }
        if (! JWTUtil.verify(token, username, userBean.getPassword())) {
            throw new AuthenticationException("Username or password error");
        }
        return new SimpleAuthenticationInfo(token, token, "my_realm");
    }
}

定义 Filter

有的请求都将转发给 Filter，我们扩展 BasicHttpAuthenticationFilter 以覆盖一些方法

执行流程:preHandle - > isAccessAllowed - > isLoginAttempt - > executeLogin

public class JWTFilter extends BasicHttpAuthenticationFilter {
    
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        HttpServletRequest req = (HttpServletRequest) request;
        String authorization = req.getHeader("Authorization");
        return authorization != null;
    }
    
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String authorization = httpServletRequest.getHeader("Authorization");
        JWTToken token = new JWTToken(authorization);
        getSubject(request, response).login(token);
        return true;
    }
   
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        if (isLoginAttempt(request, response)) {
            try {
                executeLogin(request, response);
            } catch (Exception e) {
                response401(request, response);
            }
        }
        return true;
    }
    
    @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"));
        
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
    /**
     * Illege request foward to /401
     */
    private void response401(ServletRequest req, ServletResponse resp) {
        try {
            HttpServletResponse httpServletResponse = (HttpServletResponse) resp;
            httpServletResponse.sendRedirect("/401");
        } catch (IOException e) {
            LOGGER.error(e.getMessage());
        }
    }
}

配置 Shiro

@Configuration
public class ShiroConfig {

    @Bean("securityManager")
    public DefaultWebSecurityManager getManager(MyRealm realm) {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        
        manager.setRealm(realm);
       
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        manager.setSubjectDAO(subjectDAO);
        return manager;
    }

    @Bean("shiroFilterFactoryBean")
    public ShiroFilterFactoryBean factory(DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        // define your filter and name it as jwt
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("jwt", new JWTFilter());
        factoryBean.setFilters(filterMap);
        factoryBean.setSecurityManager(securityManager);
        factoryBean.setUnauthorizedUrl("/401");
        /*
         * difine custom URL rule
         * http://shiro.apache.org/web.html#urls-
         */
        Map<String, String> filterRuleMap = new HashMap<>();
        // All the request forword to JWT Filter
        filterRuleMap.put("/**", "jwt");
        // 401 and 404 page does not forward to our filter
        filterRuleMap.put("/401", "anon");
        factoryBean.setFilterChainDefinitionMap(filterRuleMap);
        return factoryBean;
    }
   
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

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

运行

源代码中有一个 PostMan 的 JSON 接口文件可以直接导入测试

通过发送 POST 请求获得令牌

在 HTTP 请求 header 中加入 Token 并获取返回结果

如果不加入 Token 或使用错误 Token 会出现错误

源代码

Git 仓库地址

https://github.com/wangqinggang/Shiro-JWT.git

Git 仓库页面链接，喜欢的话给个 Star

SpringBoot 集成 JWT 和 Apache Shiro

Shiro 简介

Subject

SecurityManager

Realms

Authentication 认证

Authorization 授权

RESTful API 认证方式

认证（Authentication） vs 授权（Authorization）

认证（Authentication）的方式

什么是 JWT

JWT 的三部分

Header 头

Payload 负载

Signature 签名

在应用程序中使用 JWT

安全问题

与 SpringBoot 集成

程序逻辑

构建模拟数据源

URL

Controller

异常处理

配置 Shiro

定义 Filter

配置 Shiro

运行

源代码

参考资料