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

此前我已经写过一篇类似的教程,但那时候使用了投机的方法,没有尊重 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. <project 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. <modelVersion>4.0.0</modelVersion>
  5. <parent>
  6. <groupId>org.springframework.boot</groupId>
  7. <artifactId>spring-boot-starter-parent</artifactId>
  8. <version>2.1.7.RELEASE</version>
  9. <relativePath/> <!-- lookup parent from repository -->
  10. </parent>
  11. <groupId>org.inlighting</groupId>
  12. <artifactId>spring-boot-security-jwt</artifactId>
  13. <version>0.0.1-SNAPSHOT</version>
  14. <name>spring-boot-security-jwt</name>
  15. <description>Demo project for Spring Boot</description>
  16. <properties>
  17. <java.version>1.8</java.version>
  18. </properties>
  19. <dependencies>
  20. <dependency>
  21. <groupId>org.springframework.boot</groupId>
  22. <artifactId>spring-boot-starter-security</artifactId>
  23. </dependency>
  24. <dependency>
  25. <groupId>org.springframework.boot</groupId>
  26. <artifactId>spring-boot-starter-web</artifactId>
  27. </dependency>
  28. <!-- JWT 支持 -->
  29. <dependency>
  30. <groupId>com.auth0</groupId>
  31. <artifactId>java-jwt</artifactId>
  32. <version>3.8.2</version>
  33. </dependency>
  34. <!-- cache 支持 -->
  35. <dependency>
  36. <groupId>org.springframework.boot</groupId>
  37. <artifactId>spring-boot-starter-cache</artifactId>
  38. </dependency>
  39. <!-- cache 支持 -->
  40. <dependency>
  41. <groupId>org.ehcache</groupId>
  42. <artifactId>ehcache</artifactId>
  43. </dependency>
  44. <!-- cache 支持 -->
  45. <dependency>
  46. <groupId>javax.cache</groupId>
  47. <artifactId>cache-api</artifactId>
  48. </dependency>
  49. <dependency>
  50. <groupId>org.springframework.boot</groupId>
  51. <artifactId>spring-boot-starter-test</artifactId>
  52. <scope>test</scope>
  53. </dependency>
  54. <dependency>
  55. <groupId>org.springframework.security</groupId>
  56. <artifactId>spring-security-test</artifactId>
  57. <scope>test</scope>
  58. </dependency>
  59. <!-- ehcache 读取 xml 配置文件使用 -->
  60. <dependency>
  61. <groupId>javax.xml.bind</groupId>
  62. <artifactId>jaxb-api</artifactId>
  63. <version>2.3.0</version>
  64. </dependency>
  65. <!-- ehcache 读取 xml 配置文件使用 -->
  66. <dependency>
  67. <groupId>com.sun.xml.bind</groupId>
  68. <artifactId>jaxb-impl</artifactId>
  69. <version>2.3.0</version>
  70. </dependency>
  71. <!-- ehcache 读取 xml 配置文件使用 -->
  72. <dependency>
  73. <groupId>com.sun.xml.bind</groupId>
  74. <artifactId>jaxb-core</artifactId>
  75. <version>2.3.0</version>
  76. </dependency>
  77. <!-- ehcache 读取 xml 配置文件使用 -->
  78. <dependency>
  79. <groupId>javax.activation</groupId>
  80. <artifactId>activation</artifactId>
  81. <version>1.1.1</version>
  82. </dependency>
  83. </dependencies>
  84. <build>
  85. <plugins>
  86. <plugin>
  87. <groupId>org.springframework.boot</groupId>
  88. <artifactId>spring-boot-maven-plugin</artifactId>
  89. </plugin>
  90. </plugins>
  91. </build>
  92. </project>

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

基础工作准备

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

UserEntity.java

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

  1. public class UserEntity {
  2. public UserEntity(String username, String password, Collection<? extends GrantedAuthority> role) {
  3. this.username = username;
  4. this.password = password;
  5. this.role = role;
  6. }
  7. private String username;
  8. private String password;
  9. private Collection<? extends GrantedAuthority> role;
  10. public String getUsername() {
  11. return username;
  12. }
  13. public void setUsername(String username) {
  14. this.username = username;
  15. }
  16. public String getPassword() {
  17. return password;
  18. }
  19. public void setPassword(String password) {
  20. this.password = password;
  21. }
  22. public Collection<? extends GrantedAuthority> getRole() {
  23. return role;
  24. }
  25. public void setRole(Collection<? extends GrantedAuthority> role) {
  26. this.role = role;
  27. }
  28. }
ResponseEntity.java
前后端分离为了方便前端我们要统一 json 的返回格式,所以自定义一个 ResponseEntity.java。
  1. public class ResponseEntity {
  2. public ResponseEntity() {
  3. }
  4. public ResponseEntity(int status, String msg, Object data) {
  5. this.status = status;
  6. this.msg = msg;
  7. this.data = data;
  8. }
  9. private int status;
  10. private String msg;
  11. private Object data;
  12. public int getStatus() {
  13. return status;
  14. }
  15. public void setStatus(int status) {
  16. this.status = status;
  17. }
  18. public String getMsg() {
  19. return msg;
  20. }
  21. public void setMsg(String msg) {
  22. this.msg = msg;
  23. }
  24. public Object getData() {
  25. return data;
  26. }
  27. public void setData(Object data) {
  28. this.data = data;
  29. }
  30. }

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;
  4. public Map<String, UserEntity> getDatabase() {
  5. if (data == null) {
  6. data = new HashMap<>();
  7. UserEntity jack = new UserEntity(
  8. "jack",
  9. "$2a$10$AQol1A.LkxoJ5dEzS5o5E.QG9jD.hncoeCGdVaMQZaiYZ98V/JyRq",
  10. getGrants("ROLE_USER"));
  11. UserEntity danny = new UserEntity(
  12. "danny",
  13. "$2a$10$8nMJR6r7lvh9H2INtM2vtuA156dHTcQUyU.2Q2OK/7LwMd/I.HM12",
  14. getGrants("ROLE_EDITOR"));
  15. UserEntity smith = new UserEntity(
  16. "smith",
  17. "$2a$10$E86mKigOx1NeIr7D6CJM3OQnWdaPXOjWe4OoRqDqFgNgowvJW9nAi",
  18. getGrants("ROLE_ADMIN"));
  19. data.put("jack", jack);
  20. data.put("danny", danny);
  21. data.put("smith", smith);
  22. }
  23. return data;
  24. }
  25. private Collection<GrantedAuthority> getGrants(String role) {
  26. return AuthorityUtils.commaSeparatedStringToAuthorityList(role);
  27. }
  28. }

UserService.java

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

@Service
public class UserService {


@Autowired
private Database database;


public UserEntity getUserByUsername(String username) {
return database.getDatabase().get(username);
}
}

JwtUtil.java

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

public class JwtUtil {


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




* 生成签名,5min后过期
* @param username 用户名
* @param secret 用户的密码
* @return 加密的token
*/
public static String sign(String username, String secret) {
Date expireDate = new Date(System.currentTimeMillis() + EXPIRE_TIME);
try {
Algorithm algorithm = Algorithm.HMAC256(secret);
return JWT.create()
.withClaim("username", username)
.withExpiresAt(expireDate)
.sign(algorithm);
} catch (Exception e) {
return null;
}
}




* 校验token是否正确
* @param token 密钥
* @param secret 用户的密码
* @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 e) {
return false;
}
}




* 获得token中的信息无需secret解密也能获得
* @return token中包含的用户名
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim("username").asString();
} catch (JWTDecodeException e) {
return null;
}
}
}

Spring Security 改造

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

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

UserDetailsServiceImpl.java

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

  1. @Service
  2. public class UserDetailsServiceImpl implements UserDetailsService {
  3. @Autowired
  4. private UserService userService;
  5. @Override
  6. public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  7. UserEntity userEntity = userService.getUserByUsername(username);
  8. if (userEntity == null) {
  9. throw new UsernameNotFoundException("This username didn't exist.");
  10. }
  11. return new User(userEntity.getUsername(), userEntity.getPassword(), userEntity.getRole());
  12. }
  13. }

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

JwtAuthenticationFilter.java

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

  1. public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
  2. 过滤器一定要设置 AuthenticationManager,所以此处我们这么编写,这里的 AuthenticationManager
  3. 我会从 Security 配置的时候传入
  4. */
  5. public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
  6. 运行父类 UsernamePasswordAuthenticationFilter 的构造方法,能够设置此滤器指定
  7. 方法为 POST [\login]
  8. */
  9. super();
  10. setAuthenticationManager(authenticationManager);
  11. }
  12. @Override
  13. public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
  14. // 从请求的 POST 中拿取 username 和 password 两个字段进行登入
  15. String username = request.getParameter("username");
  16. String password = request.getParameter("password");
  17. UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);
  18. // 设置一些客户 IP 啥信息,后面想用的话可以用,虽然没啥用
  19. setDetails(request, token);
  20. // 交给 AuthenticationManager 进行鉴权
  21. return getAuthenticationManager().authenticate(token);
  22. }
  23. 鉴权成功进行的操作,我们这里设置返回加密后的 token
  24. */
  25. @Override
  26. protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
  27. handleResponse(request, response, authResult, null);
  28. }
  29. 鉴权失败进行的操作,我们这里就返回 用户名或密码错误 的信息
  30. */
  31. @Override
  32. protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
  33. handleResponse(request, response, null, failed);
  34. }
  35. private void handleResponse(HttpServletRequest request, HttpServletResponse response, Authentication authResult, AuthenticationException failed) throws IOException, ServletException {
  36. ObjectMapper mapper = new ObjectMapper();
  37. ResponseEntity responseEntity = new ResponseEntity();
  38. response.setHeader("Content-Type", "application/json;charset=UTF-8");
  39. if (authResult != null) {
  40. // 处理登入成功请求
  41. User user = (User) authResult.getPrincipal();
  42. String token = JwtUtil.sign(user.getUsername(), user.getPassword());
  43. responseEntity.setStatus(HttpStatus.OK.value());
  44. responseEntity.setMsg("登入成功");
  45. responseEntity.setData("Bearer " + token);
  46. response.setStatus(HttpStatus.OK.value());
  47. response.getWriter().write(mapper.writeValueAsString(responseEntity));
  48. } else {
  49. // 处理登入失败请求
  50. responseEntity.setStatus(HttpStatus.BAD_REQUEST.value());
  51. responseEntity.setMsg("用户名或密码错误");
  52. responseEntity.setData(null);
  53. response.setStatus(HttpStatus.BAD_REQUEST.value());
  54. response.getWriter().write(mapper.writeValueAsString(responseEntity));
  55. }
  56. }
  57. }

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

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

  1. public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
  2. private UserDetailsService userDetailsService;
  3. // 会从 Spring Security 配置文件那里传过来
  4. public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserDetailsService userDetailsService) {
  5. super(authenticationManager);
  6. this.userDetailsService = userDetailsService;
  7. }
  8. @Override
  9. protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
  10. // 判断是否有 token,并且进行认证
  11. Authentication token = getAuthentication(request);
  12. if (token == null) {
  13. chain.doFilter(request, response);
  14. return;
  15. }
  16. // 认证成功
  17. SecurityContextHolder.getContext().setAuthentication(token);
  18. chain.doFilter(request, response);
  19. }
  20. private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
  21. String header = request.getHeader("Authorization");
  22. if (header == null || ! header.startsWith("Bearer ")) {
  23. return null;
  24. }
  25. String token = header.split(" ")[1];
  26. String username = JwtUtil.getUsername(token);
  27. UserDetails userDetails = null;
  28. try {
  29. userDetails = userDetailsService.loadUserByUsername(username);
  30. } catch (UsernameNotFoundException e) {
  31. return null;
  32. }
  33. if (! JwtUtil.verify(token, username, userDetails.getPassword())) {
  34. return null;
  35. }
  36. return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
  37. }
  38. }

SecurityConfiguration.java

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

  1. // 开启 Security
  2. @EnableWebSecurity
  3. // 开启注解配置支持
  4. @EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
  5. public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
  6. @Autowired
  7. private UserDetailsServiceImpl userDetailsServiceImpl;
  8. // Spring Boot 的 CacheManager,这里我们使用 JCache
  9. @Autowired
  10. private CacheManager cacheManager;
  11. @Override
  12. protected void configure(HttpSecurity http) throws Exception {
  13. // 开启跨域
  14. http.cors()
  15. .and()
  16. // security 默认 csrf 是开启的,我们使用了 token ,这个也没有什么必要了
  17. .csrf().disable()
  18. .authorizeRequests()
  19. // 默认所有请求通过,但是我们要在需要权限的方法加上安全注解,这样比写死配置灵活很多
  20. .anyRequest().permitAll()
  21. .and()
  22. // 添加自己编写的两个过滤器
  23. .addFilter(new JwtAuthenticationFilter(authenticationManager()))
  24. .addFilter(new JwtAuthorizationFilter(authenticationManager(), cachingUserDetailsService(userDetailsServiceImpl)))
  25. // 前后端分离是 STATELESS,故 session 使用该策略
  26. .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
  27. }
  28. // 此处配置 AuthenticationManager,并且实现缓存
  29. @Override
  30. protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  31. // 对自己编写的 UserDetailsServiceImpl 进一步包装,实现缓存
  32. CachingUserDetailsService cachingUserDetailsService = cachingUserDetailsService(userDetailsServiceImpl);
  33. // jwt-cache 我们在 ehcache.xml 配置文件中有声明
  34. UserCache userCache = new SpringCacheBasedUserCache(cacheManager.getCache("jwt-cache"));
  35. cachingUserDetailsService.setUserCache(userCache);
  36. security 默认鉴权完成后会把密码抹除,但是这里我们使用用户的密码来作为 JWT 的生成密钥,
  37. 如果被抹除了,在对 JWT 进行签名的时候就拿不到用户密码了,故此处关闭了自动抹除密码。
  38. */
  39. auth.eraseCredentials(false);
  40. auth.userDetailsService(cachingUserDetailsService);
  41. }
  42. @Bean
  43. public PasswordEncoder passwordEncoder() {
  44. return new BCryptPasswordEncoder();
  45. }
  46. 此处我们实现缓存的时候,我们使用了官方现成的 CachingUserDetailsService ,但是这个类的构造方法不是 public 的,
  47. 我们不能够正常实例化,所以在这里进行曲线救国。
  48. */
  49. private CachingUserDetailsService cachingUserDetailsService(UserDetailsServiceImpl delegate) {
  50. Constructor<CachingUserDetailsService> ctor = null;
  51. try {
  52. ctor = CachingUserDetailsService.class.getDeclaredConstructor(UserDetailsService.class);
  53. } catch (NoSuchMethodException e) {
  54. e.printStackTrace();
  55. }
  56. Assert.notNull(ctor, "CachingUserDetailsService constructor is null");
  57. ctor.setAccessible(true);
  58. return BeanUtils.instantiateClass(ctor, delegate);
  59. }
  60. }

Ehcache 配置

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

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

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

  1. <ehcache:config
  2. xmlns:ehcache="http://www.ehcache.org/v3"
  3. xmlns:jcache="http://www.ehcache.org/v3/jsr107">
  4. <ehcache:cache alias="jwt-cache">
  5. <!-- 我们使用用户名作为缓存的 key,故使用 String -->
  6. <ehcache:key-type>java.lang.String</ehcache:key-type>
  7. <ehcache:value-type>org.springframework.security.core.userdetails.User</ehcache:value-type>
  8. <ehcache:expiry>
  9. <ehcache:ttl unit="days">1</ehcache:ttl>
  10. </ehcache:expiry>
  11. <!-- 缓存实体的数量 -->
  12. <ehcache:heap unit="entries">2000</ehcache:heap>
  13. </ehcache:cache>
  14. </ehcache:config>

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

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

统一全局异常

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

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

  1. @RestController
  2. public class CustomErrorController implements ErrorController {
  3. @Override
  4. public String getErrorPath() {
  5. return "/error";
  6. }
  7. @RequestMapping("/error")
  8. public ResponseEntity handleError(HttpServletRequest request, HttpServletResponse response) {
  9. return new ResponseEntity(response.getStatus(), (String) request.getAttribute("javax.servlet.error.message"), null);
  10. }
  11. }

测试

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

@RestController
public class MainController {


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


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


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

我这里还使用了 @IsAdmin 注解, @IsAdmin 注解如下:

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

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

FAQ

如何解决 JWT 过期问题?

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

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

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

发表评论

邮箱地址不会被公开。 必填项已用*标注