搜索

Spring Boot 2 + Spring Security 5 + JWT 的单页应用 Restful 解决方案

JAVA公众号

共 4000字，需浏览 8分钟

 ·

2020-10-31 18:16

点击上方“JAVA”，星标公众号

重磅干货，第一时间送达
此前我已经写过一篇类似的教程，但那时候使用了投机的方法，没有尊重 Spring Security 的官方设计，自己并不感到满意。这段时间比较空，故重新研究了一遍。

本项目 GitHub：https://github.com/Smith-Cruise/Spring-Boot-Security-JWT-SPA

老版本：https://github.com/Smith-Cruise/Spring-Boot-Security-JWT-SPA/blob/master/README_OLD.md

特性

  • 使用 JWT 进行鉴权，支持 token 过期

  • 使用 Ehcache 进行缓存，减少每次鉴权对数据库的压力

  • 尽可能贴合 Spring Security 的设计

  • 实现注解权限控制

准备

开始本教程的时候希望对下面知识点进行粗略的了解。

  • 知道 JWT 的基本概念

  • 了解过 Spring Security

我之前写过两篇关于安全框架的问题，大家可以大致看一看，打下基础。

Shiro+JWT+Spring Boot Restful 简易教程：https://github.com/Smith-Cruise/Spring-Boot-Shiro

Spring Boot+Spring Security+Thymeleaf 简单教程：https://github.com/Smith-Cruise/Spring-Boot-Security-Thymeleaf-Demo

本项目中 JWT 密钥是使用用户自己的登入密码，这样每一个 token 的密钥都不同，相对比较安全。

大体思路：

登入：

  1. POST 用户名密码到 \login

  2. 请求到达 JwtAuthenticationFilter 中的 attemptAuthentication() 方法，获取 request 中的 POST 参数，包装成一个 UsernamePasswordAuthenticationToken 交付给 AuthenticationManager 的 authenticate() 方法进行鉴权。

  3. AuthenticationManager 会从 CachingUserDetailsService 中查找用户信息，并且判断账号密码是否正确。

  4. 如果账号密码正确跳转到 JwtAuthenticationFilter 中的 successfulAuthentication() 方法，我们进行签名，生成 token 返回给用户。

  5. 账号密码错误则跳转到 JwtAuthenticationFilter 中的 unsuccessfulAuthentication() 方法，我们返回错误信息让用户重新登入。

请求鉴权：

请求鉴权的主要思路是我们会从请求中的 Authorization 字段拿取 token，如果不存在此字段的用户，Spring Security 会默认会用 AnonymousAuthenticationToken() 包装它，即代表匿名用户。

  1. 任意请求发起

  2. 到达 JwtAuthorizationFilter 中的 doFilterInternal() 方法，进行鉴权。

  3. 如果鉴权成功我们把生成的 Authentication 用 SecurityContextHolder.getContext().setAuthentication() 放入 Security，即代表鉴权完成。此处如何鉴权由我们自己代码编写，后序会详细说明。

准备 pom.xml

  1. xml version="1.0" encoding="UTF-8"?>
  2.      xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.              xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.         4.0.0
  5.         
  6.             org.springframework.boot
  7.             spring-boot-starter-parent
  8.             2.1.7.RELEASE
  9.              
  10.         
  11.         org.inlighting
  12.         spring-boot-security-jwt
  13.         0.0.1-SNAPSHOT
  14.         spring-boot-security-jwt
  15.         Demo project for Spring Boot

  17.         
  18.             1.8
  19.         

  21.         
  22.             
  23.                 org.springframework.boot
  24.                 spring-boot-starter-security
  25.             

  27.             
  28.                 org.springframework.boot
  29.                 spring-boot-starter-web
  30.             
  31.             
  32.             
  33.                 com.auth0
  34.                 java-jwt
  35.                 3.8.2
  36.             

  38.             
  39.             
  40.                 org.springframework.boot
  41.                 spring-boot-starter-cache
  42.             

  44.             
  45.             
  46.                 org.ehcache
  47.                 ehcache
  48.             

  50.             
  51.             
  52.                 javax.cache
  53.                 cache-api
  54.             

  56.             
  57.                 org.springframework.boot
  58.                 spring-boot-starter-test
  59.                 test
  60.             

  62.             
  63.                 org.springframework.security
  64.                 spring-security-test
  65.                 test
  66.             

  68.             
  69.             
  70.                 javax.xml.bind
  71.                 jaxb-api
  72.                 2.3.0
  73.             

  75.             
  76.             
  77.                 com.sun.xml.bind
  78.                 jaxb-impl
  79.                 2.3.0
  80.             

  82.             
  83.             
  84.                 com.sun.xml.bind
  85.                 jaxb-core
  86.                 2.3.0
  87.             

  89.             
  90.             
  91.                 javax.activation
  92.                 activation
  93.                 1.1.1
  94.             
  95.         

  97.         
  98.             
  99.                 
  100.                     org.springframework.boot
  101.                     spring-boot-maven-plugin
  102.                 
  103.             
  104.         

  106.

pom.xml 配置文件这块没有什么好说的，主要说明下面的几个依赖：

  2.     
  3.       javax.xml.bind
  4.       jaxb-api
  5.       2.3.0
  6.     

  8.     
  9.     
  10.       com.sun.xml.bind
  11.       jaxb-impl
  12.       2.3.0
  13.     

  15.     
  16.     
  17.       com.sun.xml.bind
  18.       jaxb-core
  19.       2.3.0
  20.     

  22.     
  23.     
  24.       javax.activation
  25.       activation
  26.       1.1.1
  27.

因为 ehcache 读取 xml 配置文件时使用了这几个依赖，而这几个依赖从 JDK 9 开始时是选配模块，所以高版本的用户需要添加这几个依赖才能正常使用。

基础工作准备

接下来准备下几个基础工作，就是新建个实体、模拟个数据库，写个 JWT 工具类这种基础操作。

UserEntity.java

关于 role 为什么使用 GrantedAuthority 说明下：其实是为了简化代码，直接用了 Security 现成的 role 类，实际项目中我们肯定要自己进行处理，将其转换为 Security 的 role 类。

  1. public class UserEntity {

  3.         public UserEntity(String username, String password, Collection extends GrantedAuthority> role) {
  4.             this.username = username;
  5.             this.password = password;
  6.             this.role = role;
  7.         }

  9.         private String username;

  11.         private String password;

  13.         private Collection extends GrantedAuthority> role;

  15.         public String getUsername() {
  16.             return username;
  17.         }

  19.         public void setUsername(String username) {
  20.             this.username = username;
  21.         }

  23.         public String getPassword() {
  24.             return password;
  25.         }

  27.         public void setPassword(String password) {
  28.             this.password = password;
  29.         }

  31.         public Collection extends GrantedAuthority> getRole() {
  32.             return role;
  33.         }

  35.         public void setRole(Collection extends GrantedAuthority> role) {
  36.             this.role = role;
  37.         }
  38.     }

ResponseEntity.java

前后端分离为了方便前端我们要统一 json 的返回格式，所以自定义一个 ResponseEntity.java。

  1. public class ResponseEntity {

  3.         public ResponseEntity() {
  4.         }

  6.         public ResponseEntity(int status, String msg, Object data) {
  7.             this.status = status;
  8.             this.msg = msg;
  9.             this.data = data;
  10.         }

  12.         private int status;

  14.         private String msg;

  16.         private Object data;

  18.         public int getStatus() {
  19.             return status;
  20.         }

  22.         public void setStatus(int status) {
  23.             this.status = status;
  24.         }

  26.         public String getMsg() {
  27.             return msg;
  28.         }

  30.         public void setMsg(String msg) {
  31.             this.msg = msg;
  32.         }

  34.         public Object getData() {
  35.             return data;
  36.         }

  38.         public void setData(Object data) {
  39.             this.data = data;
  40.         }
  41.     }

Database.java

这里我们使用一个 HashMap 模拟了一个数据库，密码我已经预先用 Bcrypt 加密过了，这也是 Spring Security 官方推荐的加密算法（MD5 加密已经在 Spring Security 5 中被移除了，不安全）。

用户名密码权限
jackjack123 存 Bcrypt 加密后ROLE_USER
dannydanny123 存 Bcrypt 加密后ROLE_EDITOR
smithsmith123 存 Bcrypt 加密后ROLE_ADMIN
  1. @Component
  2.     public class Database {
  3.         private Map<String, UserEntity> data = null;

  5.         public Map<String, UserEntity> getDatabase() {
  6.             if (data == null) {
  7.                 data = new HashMap<>();

  9.                 UserEntity jack = new UserEntity(
  10.                         "jack",
  11.                         "$2a$10$AQol1A.LkxoJ5dEzS5o5E.QG9jD.hncoeCGdVaMQZaiYZ98V/JyRq",
  12.                         getGrants("ROLE_USER"));
  13.                 UserEntity danny = new UserEntity(
  14.                         "danny",
  15.                         "$2a$10$8nMJR6r7lvh9H2INtM2vtuA156dHTcQUyU.2Q2OK/7LwMd/I.HM12",
  16.                         getGrants("ROLE_EDITOR"));
  17.                 UserEntity smith = new UserEntity(
  18.                         "smith",
  19.                         "$2a$10$E86mKigOx1NeIr7D6CJM3OQnWdaPXOjWe4OoRqDqFgNgowvJW9nAi",
  20.                         getGrants("ROLE_ADMIN"));
  21.                 data.put("jack", jack);
  22.                 data.put("danny", danny);
  23.                 data.put("smith", smith);
  24.             }
  25.             return data;
  26.         }

  28.         private Collection<GrantedAuthority> getGrants(String role) {
  29.             return AuthorityUtils.commaSeparatedStringToAuthorityList(role);
  30.         }
  31.     }

UserService.java

这里再模拟一个 service，主要就是模仿数据库的操作。

  1. @Service
  2.     public class UserService {

  4.         @Autowired
  5.         private Database database;

  7.         public UserEntity getUserByUsername(String username) {
  8.             return database.getDatabase().get(username);
  9.         }
  10.     }

JwtUtil.java

自己编写的一个工具类，主要负责 JWT 的签名和鉴权。

  1. public class JwtUtil {

  3.         // 过期时间5分钟
  4.         private final static long EXPIRE_TIME = 5 * 60 * 1000;


  7.          * 生成签名,5min后过期
  8.          * @param username 用户名
  9.          * @param secret 用户的密码
  10.          * @return 加密的token
  11.          */
  12.         public static String sign(String username, String secret) {
  13.             Date expireDate = new Date(System.currentTimeMillis() + EXPIRE_TIME);
  14.             try {
  15.                 Algorithm algorithm = Algorithm.HMAC256(secret);
  16.                 return JWT.create()
  17.                         .withClaim("username", username)
  18.                         .withExpiresAt(expireDate)
  19.                         .sign(algorithm);
  20.             } catch (Exception e) {
  21.                 return null;
  22.             }
  23.         }


  26.          * 校验token是否正确
  27.          * @param token 密钥
  28.          * @param secret 用户的密码
  29.          * @return 是否正确
  30.          */
  31.         public static boolean verify(String token, String username, String secret) {
  32.             try {
  33.                 Algorithm algorithm = Algorithm.HMAC256(secret);
  34.                 JWTVerifier verifier = JWT.require(algorithm)
  35.                         .withClaim("username", username)
  36.                         .build();
  37.                 DecodedJWT jwt = verifier.verify(token);
  38.                 return true;
  39.             } catch (Exception e) {
  40.                 return false;
  41.             }
  42.         }


  45.          * 获得token中的信息无需secret解密也能获得
  46.          * @return token中包含的用户名
  47.          */
  48.         public static String getUsername(String token) {
  49.             try {
  50.                 DecodedJWT jwt = JWT.decode(token);
  51.                 return jwt.getClaim("username").asString();
  52.             } catch (JWTDecodeException e) {
  53.                 return null;
  54.             }
  55.         }
  56.     }

Spring Security 改造

登入这块，我们使用自定义的 JwtAuthenticationFilter 来进行登入。

请求鉴权，我们使用自定义的 JwtAuthorizationFilter 来处理。

也许大家觉得两个单词长的有点像，?。

UserDetailsServiceImpl.java

我们首先实现官方的 UserDetailsService 接口，这里主要负责一个从数据库拿数据的操作。

  1. @Service
  2.     public class UserDetailsServiceImpl implements UserDetailsService {

  4.         @Autowired
  5.         private UserService userService;

  7.         @Override
  8.         public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  9.             UserEntity userEntity = userService.getUserByUsername(username);
  10.             if (userEntity == null) {
  11.                 throw new UsernameNotFoundException("This username didn't exist.");
  12.             }
  13.             return new User(userEntity.getUsername(), userEntity.getPassword(), userEntity.getRole());
  14.         }
  15.     }

后序我们还需要对其进行缓存改造，不然每次请求都要从数据库拿一次数据鉴权，对数据库压力太大了。

JwtAuthenticationFilter.java

这个过滤器主要处理登入操作，我们继承了 UsernamePasswordAuthenticationFilter，这样能大大简化我们的工作量。

  1. public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {


  4.         过滤器一定要设置 AuthenticationManager，所以此处我们这么编写，这里的 AuthenticationManager
  5.         我会从 Security 配置的时候传入
  6.         */
  7.         public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {

  9.             运行父类 UsernamePasswordAuthenticationFilter 的构造方法，能够设置此滤器指定
  10.             方法为 POST [\login]
  11.             */
  12.             super();
  13.             setAuthenticationManager(authenticationManager);
  14.         }

  16.         @Override
  17.         public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
  18.             // 从请求的 POST 中拿取 username 和 password 两个字段进行登入
  19.             String username = request.getParameter("username");
  20.             String password = request.getParameter("password");
  21.             UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);
  22.             // 设置一些客户 IP 啥信息，后面想用的话可以用，虽然没啥用
  23.             setDetails(request, token);
  24.             // 交给 AuthenticationManager 进行鉴权
  25.             return getAuthenticationManager().authenticate(token);
  26.         }


  29.         鉴权成功进行的操作，我们这里设置返回加密后的 token
  30.         */
  31.         @Override
  32.         protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
  33.             handleResponse(request, response, authResult, null);
  34.         }


  37.         鉴权失败进行的操作，我们这里就返回 用户名或密码错误 的信息
  38.         */
  39.         @Override
  40.         protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
  41.             handleResponse(request, response, null, failed);
  42.         }

  44.         private void handleResponse(HttpServletRequest request, HttpServletResponse response, Authentication authResult, AuthenticationException failed) throws IOException, ServletException {
  45.             ObjectMapper mapper = new ObjectMapper();
  46.             ResponseEntity responseEntity = new ResponseEntity();
  47.             response.setHeader("Content-Type", "application/json;charset=UTF-8");
  48.             if (authResult != null) {
  49.                 // 处理登入成功请求
  50.                 User user = (User) authResult.getPrincipal();
  51.                 String token = JwtUtil.sign(user.getUsername(), user.getPassword());
  52.                 responseEntity.setStatus(HttpStatus.OK.value());
  53.                 responseEntity.setMsg("登入成功");
  54.                 responseEntity.setData("Bearer " + token);
  55.                 response.setStatus(HttpStatus.OK.value());
  56.                 response.getWriter().write(mapper.writeValueAsString(responseEntity));
  57.             } else {
  58.                 // 处理登入失败请求
  59.                 responseEntity.setStatus(HttpStatus.BAD_REQUEST.value());
  60.                 responseEntity.setMsg("用户名或密码错误");
  61.                 responseEntity.setData(null);
  62.                 response.setStatus(HttpStatus.BAD_REQUEST.value());
  63.                 response.getWriter().write(mapper.writeValueAsString(responseEntity));
  64.             }
  65.         }
  66.     }

privatevoidhandleResponse() 此处处理的方法不是很好，我的想法是跳转到控制器中进行处理，但是这样鉴权成功的 token 带不过去，所以先这么写了，有点复杂。

这个过滤器处理每个请求鉴权，我们选择继承 BasicAuthenticationFilter ，考虑到 Basic 认证和 JWT 比较像，就选择了它。

  1. public class JwtAuthorizationFilter extends BasicAuthenticationFilter {

  3.         private UserDetailsService userDetailsService;

  5.         // 会从 Spring Security 配置文件那里传过来
  6.         public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserDetailsService userDetailsService) {
  7.             super(authenticationManager);
  8.             this.userDetailsService = userDetailsService;
  9.         }

  11.         @Override
  12.         protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
  13.             // 判断是否有 token，并且进行认证
  14.             Authentication token = getAuthentication(request);
  15.             if (token == null) {
  16.                 chain.doFilter(request, response);
  17.                 return;
  18.             }
  19.             // 认证成功
  20.             SecurityContextHolder.getContext().setAuthentication(token);
  21.             chain.doFilter(request, response);
  22.         }

  24.         private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
  25.             String header = request.getHeader("Authorization");
  26.             if (header == null || ! header.startsWith("Bearer ")) {
  27.                 return null;
  28.             }

  30.             String token = header.split(" ")[1];
  31.             String username = JwtUtil.getUsername(token);
  32.             UserDetails userDetails = null;
  33.             try {
  34.                 userDetails = userDetailsService.loadUserByUsername(username);
  35.             } catch (UsernameNotFoundException e) {
  36.                 return null;
  37.             }
  38.             if (! JwtUtil.verify(token, username, userDetails.getPassword())) {
  39.                 return null;
  40.             }
  41.             return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
  42.         }
  43.     }

SecurityConfiguration.java

此处我们进行 Security 的配置，并且实现缓存功能。缓存这块我们使用官方现成的 CachingUserDetailsService ，唯独的缺点就是它没有 public 方法，我们不能正常实例化，需要曲线救国，下面代码也有详细说明。

  1. // 开启 Security
  2.     @EnableWebSecurity
  3.     // 开启注解配置支持
  4.     @EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
  5.     public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

  7.         @Autowired
  8.         private UserDetailsServiceImpl userDetailsServiceImpl;

  10.         // Spring Boot 的 CacheManager，这里我们使用 JCache
  11.         @Autowired
  12.         private CacheManager cacheManager;

  14.         @Override
  15.         protected void configure(HttpSecurity http) throws Exception {
  16.             // 开启跨域
  17.             http.cors()
  18.                     .and()
  19.                     // security 默认 csrf 是开启的，我们使用了 token ，这个也没有什么必要了
  20.                     .csrf().disable()
  21.                     .authorizeRequests()
  22.                     // 默认所有请求通过，但是我们要在需要权限的方法加上安全注解，这样比写死配置灵活很多
  23.                     .anyRequest().permitAll()
  24.                     .and()
  25.                     // 添加自己编写的两个过滤器
  26.                     .addFilter(new JwtAuthenticationFilter(authenticationManager()))
  27.                     .addFilter(new JwtAuthorizationFilter(authenticationManager(), cachingUserDetailsService(userDetailsServiceImpl)))
  28.                     // 前后端分离是 STATELESS，故 session 使用该策略
  29.                     .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
  30.         }

  32.         // 此处配置 AuthenticationManager，并且实现缓存
  33.         @Override
  34.         protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  35.             // 对自己编写的 UserDetailsServiceImpl 进一步包装，实现缓存
  36.             CachingUserDetailsService cachingUserDetailsService = cachingUserDetailsService(userDetailsServiceImpl);
  37.             // jwt-cache 我们在 ehcache.xml 配置文件中有声明
  38.             UserCache userCache = new SpringCacheBasedUserCache(cacheManager.getCache("jwt-cache"));
  39.             cachingUserDetailsService.setUserCache(userCache);

  41.             security 默认鉴权完成后会把密码抹除，但是这里我们使用用户的密码来作为 JWT 的生成密钥，
  42.             如果被抹除了，在对 JWT 进行签名的时候就拿不到用户密码了，故此处关闭了自动抹除密码。
  43.              */
  44.             auth.eraseCredentials(false);
  45.             auth.userDetailsService(cachingUserDetailsService);
  46.         }

  48.         @Bean
  49.         public PasswordEncoder passwordEncoder() {
  50.             return new BCryptPasswordEncoder();
  51.         }


  54.         此处我们实现缓存的时候，我们使用了官方现成的 CachingUserDetailsService ，但是这个类的构造方法不是 public 的，
  55.         我们不能够正常实例化，所以在这里进行曲线救国。
  56.          */
  57.         private CachingUserDetailsService cachingUserDetailsService(UserDetailsServiceImpl delegate) {

  59.             Constructor<CachingUserDetailsService> ctor = null;
  60.             try {
  61.                 ctor = CachingUserDetailsService.class.getDeclaredConstructor(UserDetailsService.class);
  62.             } catch (NoSuchMethodException e) {
  63.                 e.printStackTrace();
  64.             }
  65.             Assert.notNull(ctor, "CachingUserDetailsService constructor is null");
  66.             ctor.setAccessible(true);
  67.             return BeanUtils.instantiateClass(ctor, delegate);
  68.         }
  69.     }

Ehcache 配置

Ehcache 3 开始，统一使用了 JCache，就是 JSR107 标准，网上很多教程都是基于 Ehcache 2 的，所以大家可能在参照网上的教程会遇到很多坑。

JSR107：emm，其实 JSR107 是一种缓存标准，各个框架只要遵守这个标准，就是现实大一统。差不多就是我不需要更改系统代码，也能随意更换底层的缓存系统。

在 resources 目录下创建 ehcache.xml 文件：

  2.             xmlns:ehcache="http://www.ehcache.org/v3"
  3.             xmlns:jcache="http://www.ehcache.org/v3/jsr107">

  5.          alias="jwt-cache">
  6.             
  7.             java.lang.String
  8.             org.springframework.security.core.userdetails.User
  9.             
  10.                  unit="days">1
  11.             
  12.             
  13.              unit="entries">2000
  14.         

  16.

在 application.properties 中开启缓存支持：

  1. spring.cache.type=jcache
  2.     spring.cache.jcache.config=classpath:ehcache.xml

统一全局异常

我们要把异常的返回形式也统一了，这样才能方便前端的调用。

我们平常会使用 @RestControllerAdvice 来统一异常，但是它只能管理 Controller 层面抛出的异常。Security 中抛出的异常不会抵达 Controller，无法被 @RestControllerAdvice 捕获，故我们还要改造 ErrorController 。

  1. @RestController
  2.     public class CustomErrorController implements ErrorController {

  4.         @Override
  5.         public String getErrorPath() {
  6.             return "/error";
  7.         }

  9.         @RequestMapping("/error")
  10.         public ResponseEntity handleError(HttpServletRequest request, HttpServletResponse response) {
  11.             return new ResponseEntity(response.getStatus(), (String) request.getAttribute("javax.servlet.error.message"), null);
  12.         }
  13.     }

测试

写个控制器试试，大家也可以参考我控制器里面获取用户信息的方式，推荐使用 @AuthenticationPrincipal 这个注解！！！

  1. @RestController
  2.     public class MainController {

  4.         // 任何人都可以访问，在方法中判断用户是否合法
  5.         @GetMapping("everyone")
  6.         public ResponseEntity everyone() {
  7.             Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  8.             if (! (authentication instanceof AnonymousAuthenticationToken)) {
  9.                 // 登入用户
  10.                 return new ResponseEntity(HttpStatus.OK.value(), "You are already login", authentication.getPrincipal());
  11.             } else {
  12.                 return new ResponseEntity(HttpStatus.OK.value(), "You are anonymous", null);
  13.             }
  14.         }

  16.         @GetMapping("user")
  17.         @PreAuthorize("hasAuthority('ROLE_USER')")
  18.         public ResponseEntity user(@AuthenticationPrincipal UsernamePasswordAuthenticationToken token) {
  19.             return new ResponseEntity(HttpStatus.OK.value(), "You are user", token);
  20.         }

  22.         @GetMapping("admin")
  23.         @IsAdmin
  24.         public ResponseEntity admin(@AuthenticationPrincipal UsernamePasswordAuthenticationToken token) {
  25.             return new ResponseEntity(HttpStatus.OK.value(), "You are admin", token);
  26.         }
  27.     }

我这里还使用了 @IsAdmin 注解， @IsAdmin 注解如下：

  1. @Target({ElementType.METHOD, ElementType.TYPE})
  2.     @Retention(RetentionPolicy.RUNTIME)
  3.     @PreAuthorize("hasAnyRole('ROLE_ADMIN')")
  4.     public @interface IsAdmin {
  5.     }

这样能省去每次编写一长串的 @PreAuthorize() ，而且更加直观。

FAQ

如何解决 JWT 过期问题？

我们可以在 JwtAuthorizationFilter 中加点料，如果用户快过期了，返回个特别的状态码，前端收到此状态码去访问 GET/re_authentication 携带老的 token 重新拿一个新的 token 即可。

如何作废已颁发未过期的 token？

我个人的想法是把每次生成的 token 放入缓存中，每次请求都从缓存里拿，如果没有则代表此缓存报废。

作者：Smith Cruise

原文链接：https://www.inlighting.org/archives/spring-boot-security-jwt-restful
更多精彩?

在公众号【程序员编程】对话框输入以下关键词
查看更多优质内容！

大数据 | Java | 1024 | 电子书 | 速查表 
Python进阶 | 面试 | 手册 | 成神 | 思想 | 小程序
命令行 | 人工智能 | 软件测试 | Web前端 | Python

扫码关注我们
获取更多学习资料
视频 | 面试 | 技术 | 电子书 
浏览 47
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
Spring Boot 2 + Spring Security 5 + JWT 的单页应用 Restful 解决方案
Java研发军团
0
Spring Boot 2 + Spring Security 5 + JWT 的 Restful简易教程！
JAVA小咖秀
0
Shiro + JWT + Spring Boot Restful 简易教程
Java研发军团
0
Shiro + JWT + Spring Boot Restful 简易教程
程序员私房菜
0
Shiro + JWT + Spring Boot Restful 简易教程
Java专栏
0
Shiro + JWT + Spring Boot Restful 简易教程
好好学java
0
Shiro + JWT + Spring Boot Restful 简易教程
JAVA小咖秀
0
Shiro + JWT + Spring Boot Restful 简易教程
程序员闪充宝
0
Spring Security OAuth Boot 2 Autoconfig集成 Spring Security OAuth2 和 Spring Boot 2
Spring Security OAuth Boot 2 Autoconfig项目为SpringBoot2和旧的SpringSecurityOAuth项目提供了自动配置，可用于集成SpringSecu
Spring Security OAuth Boot 2 Autoconfig集成 Spring Security OAuth2 和 Spring Boot 2
Spring Security OAuth Boot 2 Autoconfig 项目为 Spring
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报