devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一文带你了解springboot3+jwt+security的使用_jwt security

作者：我家小花儿 | 2024-04-08 22:34:18

赞

踩

jwt security

Spring Security已经成为java后台权限校验的第一选择.今天就通过读代码的方式带大家深入了解一下Security,本文主要是基于开源项目spring-boot-3-jwt-security[1]来讲解Spring Security + JWT(Json Web Token).实现用户鉴权,以及权限校验. 所有代码基于jdk17+构建.现在让我们开始吧!

  1. Springboot 3.0

  2. Spring Security

  3. Json Web Token(JWT)

  4. BCrypt

  5. Maven

  6. 项目使用postgresql数据库来存储用户信息以及Token(为啥不用Redis?这个先挖个坑),可以按照自己的想法替换成mysql数据库

  7. 访问数据库使用的是jpa,对于一些简单的sql可以根据方法名自动映射,还是很方便的.没使用过的也没关系.不影响阅读今天的文章,后续可以根据自己的实际需求替换成mybatis-lpus等

  8. 本文使用了Lombok来生成固定的模版代码

  1. <parent>  
  2.     <groupId>org.springframework.boot</groupId>  
  3.     <artifactId>spring-boot-starter-parent</artifactId>  
  4.     <version>3.0.5</version>  
  5.     <relativePath/>   
  6. </parent>  
  7. <groupId>com.alibou</groupId>  
  8. <artifactId>security</artifactId>  
  9. <version>0.0.1-SNAPSHOT</version>  
  10. <name>security</name>  
  11. <description>Demo project for Spring Boot</description>  
  12. <properties>  
  13.     <java.version>17</java.version>  
  14. </properties>  
  15. <dependencies>  
  16.     
  17.     <dependency>  
  18.         <groupId>org.springframework.boot</groupId>  
  19.         <artifactId>spring-boot-starter-data-jpa</artifactId>  
  20.     </dependency>  
  21.     
  22.     <dependency>          
  23.         <groupId>org.springframework.boot</groupId>  
  24.         <artifactId>spring-boot-starter-security</artifactId>  
  25.     </dependency>  
  26.     
  27.     <dependency> 
  28.         <groupId>org.springframework.boot</groupId>  
  29.         <artifactId>spring-boot-starter-web</artifactId>  
  30.     </dependency>  
  31.     
  32.     <dependency>  
  33.         <groupId>org.postgresql</groupId>  
  34.         <artifactId>postgresql</artifactId>  
  35.         <scope>runtime</scope>  
  36.     </dependency>
  37.     
  38.     <dependency>  
  39.         <groupId>org.projectlombok</groupId>  
  40.         <artifactId>lombok</artifactId>  
  41.         <optional>true</optional>  
  42.     </dependency> 
  43.     
  44.     <dependency>  
  45.         <groupId>io.jsonwebtoken</groupId>  
  46.         <artifactId>jjwt-api</artifactId>  
  47.         <version>0.11.5</version>  
  48.     </dependency>  
  49.     <dependency>  
  50.         <groupId>io.jsonwebtoken</groupId>  
  51.         <artifactId>jjwt-impl</artifactId>  
  52.         <version>0.11.5</version>  
  53.     </dependency>  
  54.     <dependency>  
  55.         <groupId>io.jsonwebtoken</groupId>  
  56.         <artifactId>jjwt-jackson</artifactId>  
  57.         <version>0.11.5</version>  
  58.     </dependency>
  59.     
  60.     
  61.     <dependency>  
  62.         <groupId>org.springdoc</groupId>  
  63.         <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>  
  64.         <version>2.1.0</version>  
  65.     </dependency>
  66.     
  67.     <dependency>  
  68.         <groupId>org.springframework.boot</groupId>  
  69.         <artifactId>spring-boot-starter-validation</artifactId>  
  70.     </dependency>  
  71.  
  72.     <dependency>  
  73.         <groupId>org.springframework.boot</groupId>  
  74.         <artifactId>spring-boot-starter-test</artifactId>  
  75.         <scope>test</scope>  
  76.     </dependency>  
  77.     <dependency>  
  78.         <groupId>org.springframework.security</groupId>  
  79.         <artifactId>spring-security-test</artifactId>  
  80.         <scope>test</scope>  
  81.     </dependency>  
  82. </dependencies>  
  83.   
  84. <build>  
  85.     <plugins>  
  86.         <plugin>  
  87.             <groupId>org.springframework.boot</groupId>  
  88.             <artifactId>spring-boot-maven-plugin</artifactId>  
  89.             <configuration>  
  90.                 <excludes>  
  91.                     <exclude>  
  92.                         <groupId>org.projectlombok</groupId>  
  93.                         <artifactId>lombok</artifactId>  
  94.                     </exclude>  
  95.                 </excludes>  
  96.             </configuration>  
  97.         </plugin>  
  98.     </plugins>  
  99. </build>
  100.

鉴权配置

  1. 当项目引入Security依赖后,启动项目会生成一个随机的密码,当我们要访问资源的时候需要使用这个密码登录后才能使用.这会影响我们很多功能的正常使用,比如万恶的swagger.下面我们来详细了解如何配置我们需要鉴权的路径,以及需要放行的路径

  1. @Configuration  
  2. @EnableWebSecurity  
  3. @RequiredArgsConstructor  
  4. @EnableMethodSecurity  
  5. public class SecurityConfiguration {  
  6.   
  7. private final JwtAuthenticationFilter jwtAuthFilter;  
  8. private final AuthenticationProvider authenticationProvider;  
  9. private final LogoutHandler logoutHandler;  
  10.   
  11. @Bean  
  12. public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {  
  13.     http  
  14.     .csrf()  
  15.     .disable() 
  16.     .authorizeHttpRequests()  
  17.     
  18.     .requestMatchers(  
  19.     "/api/v1/auth/**",  
  20.     "/v2/api-docs",  
  21.     "/v3/api-docs",  
  22.     "/v3/api-docs/**",  
  23.     "/swagger-resources",  
  24.     "/swagger-resources/**",  
  25.     "/configuration/ui",  
  26.     "/configuration/security",  
  27.     "/swagger-ui/**",  
  28.     "/webjars/**",  
  29.     "/swagger-ui.html"  
  30.     )  
  31.     .permitAll() 
  32.   
  33.   
  34.     
  35.     * 权限校验(需要登录的用户有指定的权限才可以)  
  36.     * requestMatchers: 指定需要拦截的路径  
  37.     * hasAnyAuthority: 指定需要的权限  
  38.     */  
  39.     .requestMatchers("/api/v1/management/**").hasAnyRole(ADMIN.name(), MANAGER.name())  
  40.     .requestMatchers(GET, "/api/v1/management/**").hasAnyAuthority(ADMIN_READ.name(), MANAGER_READ.name())  
  41.     .requestMatchers(POST, "/api/v1/management/**").hasAnyAuthority(ADMIN_CREATE.name(), MANAGER_CREATE.name())  
  42.     .requestMatchers(PUT, "/api/v1/management/**").hasAnyAuthority(ADMIN_UPDATE.name(), MANAGER_UPDATE.name())  
  43.     .requestMatchers(DELETE, "/api/v1/management/**").hasAnyAuthority(ADMIN_DELETE.name(), MANAGER_DELETE.name())  
  44.     .anyRequest()  
  45.     .authenticated() 
  46.     .and()  
  47.     .sessionManagement()  
  48.     .sessionCreationPolicy(SessionCreationPolicy.STATELESS) 
  49.     .and()  
  50.     .authenticationProvider(authenticationProvider)  
  51.     
  52.     .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)  
  53.     
  54.     .logout()  
  55.     .logoutUrl("/api/v1/auth/logout")  
  56.     .addLogoutHandler(logoutHandler)  
  57.     .logoutSuccessHandler((request, response,authentication) -> SecurityContextHolder.clearContext())  
  58.     ;  
  59.  
  60.     return http.build();  
  61.     }  
  62. }
  63.
  1. 上述代码主要实现了四块功能分别是:

    • 放行不需要鉴权的路径(注册&登录,swagger)

    • 配置访问特定的接口用户需要的权限.(比如想要删除用户必须要有删除用户的权限)

    • 添加前置过滤器,用来从Token中判断用户是否合法和获取用户权限: jwtAuthFilter

    • 配置退出登录的Handler,以及监听的路径.当访问这个路径的时候会自动调用logoutHandler中的方法

登录配置

上面说到了权限和token校验,我们先来了解一下登录的逻辑是什么样的.在security中需要一个UserDetails类来定义用户账户的行为.这个是用户鉴权的关键.主要有账户,密码,权限,用户状态等等.在下面代码中有详细的注释

  1. @Data  
  2. @Builder  
  3. @NoArgsConstructor  
  4. @AllArgsConstructor  
  5. @Entity  
  6. @Table(name = "_user")  
  7. public class User implements UserDetails {  
  8.   
  9.     @Id  
  10.     @GeneratedValue  
  11.     private Integer id; 
  12.     private String firstname; 
  13.     private String lastname; 
  14.     private String email; 
  15.     private String password; 
  16.  
  17.     
  18.     * 角色枚举  
  19.     */  
  20.     @Enumerated(EnumType.STRING)  
  21.     private Role role;  
  22.  
  23.     
  24.     * 用户关联的Token  
  25.     * 这里面使用了jpa的一对多映射  
  26.     */  
  27.     @OneToMany(mappedBy = "user")  
  28.     private List<Token> tokens;  
  29.  
  30.     
  31.     * 获取用户的权限  
  32.     * 这里是根据角色枚举的权限来获取的(静态的而非从数据库动态读取)  
  33.     * @return 用户权限列表  
  34.     */  
  35.     @Override  
  36.     public Collection<? extends GrantedAuthority> getAuthorities() {  
  37.         return role.getAuthorities();  
  38.     }  
  39.  
  40.     
  41.     * 获取用户密码  
  42.     * 主要是用来指定你的password字段  
  43.     * @return 用户密码  
  44.     */  
  45.     @Override  
  46.     public String getPassword() {  
  47.         return password;  
  48.     }  
  49.  
  50.     
  51.     * 获取用户账号  
  52.     * 这里使用email做为账号  
  53.     * @return 用户账号  
  54.     */  
  55.     @Override  
  56.     public String getUsername() {  
  57.         return email;  
  58.     }  
  59.  
  60.     
  61.     * 账号是否未过期,下面的这个几个方法都是用来指定账号的状态的,因为该项目是一个Demo,所以这里全部返回true  
  62.     * @return true 未过期  
  63.     */  
  64.     @Override  
  65.     public boolean isAccountNonExpired() {  
  66.         return true;  
  67.     }  
  68.  
  69.     
  70.     * 账号是否未锁定  
  71.     * @return true 未锁定  
  72.     */  
  73.     @Override  
  74.     public boolean isAccountNonLocked() {  
  75.         return true;  
  76.     }  
  77.  
  78.     
  79.     * 密码是否未过期  
  80.     * @return true 未过期  
  81.     */  
  82.     @Override  
  83.     public boolean isCredentialsNonExpired() {  
  84.         return true;  
  85.     }  
  86.  
  87.     
  88.     * 账号是否激活  
  89.     * @return true 已激活  
  90.     */  
  91.     @Override  
  92.     public boolean isEnabled() {  
  93.         return true;  
  94.     }  
  95. }
  96.

在了解用户实体之后,我们来看一下是怎么来进行登录配置的.如何使用securty来帮我们管理用户密码的校验.下面我们来看一下security的整体配置

  1. @Configuration  
  2. @RequiredArgsConstructor  
  3. public class ApplicationConfig {  
  4.   
  5.     
  6.     * 访问用户数据表  
  7.     */  
  8.     private final UserRepository repository;  
  9.  
  10.     
  11.     * 获取用户详情Bean  
  12.     * 根据email查询是否存在用户,如果不存在throw用户未找到异常  
  13.     */  
  14.     @Bean  
  15.     public UserDetailsService userDetailsService() {  
  16.         
  17.         return username -> repository.findByEmail(username)  
  18.         
  19.         .orElseThrow(() -> new UsernameNotFoundException("User not found"));  
  20.     }  
  21.  
  22.     
  23.     * 身份验证Bean  
  24.     * 传入获取用户信息的bean & 密码加密器  
  25.     * 可以回看一下SecurityConfiguration中 AuthenticationProvider的配置,使用的就是这里注入到容器中的Bean  
  26.     * 这个bean 主要是用于用户登录时的身份验证,当我们登录的时候security会帮我们调用这个bean的authenticate方法  
  27.     */  
  28.     @Bean  
  29.     public AuthenticationProvider authenticationProvider() {  
  30.         DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();  
  31.         
  32.         authProvider.setUserDetailsService(userDetailsService());  
  33.         
  34.         authProvider.setPasswordEncoder(passwordEncoder());  
  35.         return authProvider;  
  36.     }  
  37.  
  38.     
  39.     * 身份验证管理器  
  40.     */  
  41.     @Bean  
  42.     public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {  
  43.         return config.getAuthenticationManager();  
  44.     }  
  45.  
  46.     
  47.     * 密码加密器  
  48.     * 主要是用来指定数据库中存储密码的加密方式,保证密码非明文存储  
  49.     * 当security需要进行密码校验时,会把请求传进来的密码进行加密,然后和数据库中的密码进行比对  
  50.     */  
  51.     @Bean  
  52.     public PasswordEncoder passwordEncoder() {  
  53.         return new BCryptPasswordEncoder();  
  54.     }  
  55.   
  56. }
  57.

上述代码主要做了两件事:

  • 指定我们如何从数据库中根据用户账号获取用户信息

  • 指定用户密码的加密器passwordEncoder

现在大家可能会存在一个疑问,security怎么知道User实体中那个字段是我的账户,那个字段是我的密码? 不知道大家是否记得UserDetails类,也就是我们的User类.其中有两个方法getPassword & getUsername.这两个方法返回的就是账号和密码.User类中的还有几个其他的方法,可以根据我们实际的业务需求来对账号进行禁用等操作.

Token如何生成

token的生成主要是使用工具包来实现,在本项目中Token中主要存储用户信息 & 用户权限,下面我们先看一下token工具包的代码.主要包括为: 生成token,从token中获取信息,以及验证token

  1. @Service  
  2. public class JwtService {  
  3.   
  4.     
  5.     * 加密盐值  
  6.     */  
  7.     @Value("${application.security.jwt.secret-key}")  
  8.     private String secretKey;  
  9.  
  10.     
  11.     * Token失效时间  
  12.     */  
  13.     @Value("${application.security.jwt.expiration}")  
  14.     private long jwtExpiration;  
  15.  
  16.     
  17.     * Token刷新时间  
  18.     */  
  19.     @Value("${application.security.jwt.refresh-token.expiration}")  
  20.     private long refreshExpiration;  
  21.  
  22.     
  23.     * 从Token中获取Username  
  24.     * @param token Token  
  25.     * @return String  
  26.     */  
  27.     public String extractUsername(String token) {  
  28.         return extractClaim(token, Claims::getSubject);  
  29.     }  
  30.  
  31.     
  32.     * 从Token中回去数据,根据传入不同的Function返回不同的数据  
  33.     * eg: String extractUsername(String token)  
  34.     */  
  35.     public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {  
  36.         final Claims claims = extractAllClaims(token);  
  37.         return claimsResolver.apply(claims);  
  38.     }  
  39.  
  40.     
  41.     * 生成Token无额外信息  
  42.     */  
  43.     public String generateToken(UserDetails userDetails) {  
  44.         return generateToken(new HashMap<>(), userDetails);  
  45.     }  
  46.  
  47.     
  48.     * 生成Token,有额外信息  
  49.     * @param extraClaims 额外的数据  
  50.     * @param userDetails 用户信息  
  51.     * @return String  
  52.     */  
  53.     public String generateToken(  
  54.     Map<String, Object> extraClaims,  
  55.     UserDetails userDetails  
  56.     ) {  
  57.         return buildToken(extraClaims, userDetails, jwtExpiration);  
  58.     }  
  59.  
  60.     
  61.     * 生成刷新用的Token  
  62.     * @param userDetails 用户信息  
  63.     * @return String  
  64.     */  
  65.     public String generateRefreshToken(  
  66.     UserDetails userDetails  
  67.     ) {  
  68.         return buildToken(new HashMap<>(), userDetails, refreshExpiration);  
  69.     }  
  70.  
  71.     
  72.     * 构建Token方法  
  73.     * @param extraClaims 额外信息  
  74.     * @param userDetails //用户信息  
  75.     * @param expiration //失效时间  
  76.     * @return String  
  77.     */  
  78.     private String buildToken(  
  79.         Map<String, Object> extraClaims,  
  80.         UserDetails userDetails,  
  81.         long expiration  
  82.         ) {  
  83.         return Jwts  
  84.         .builder()  
  85.         .setClaims(extraClaims) 
  86.         .setSubject(userDetails.getUsername()) 
  87.         .setIssuedAt(new Date(System.currentTimeMillis())) 
  88.         .setExpiration(new Date(System.currentTimeMillis() + expiration)) 
  89.         .signWith(getSignInKey(), SignatureAlgorithm.HS256) 
  90.         .compact();  
  91.     }  
  92.  
  93.     
  94.     * 验证Token是否有效  
  95.     * @param token Token  
  96.     * @param userDetails 用户信息  
  97.     * @return boolean  
  98.     */  
  99.     public boolean isTokenValid(String token, UserDetails userDetails) {  
  100.         final String username = extractUsername(token);  
  101.         return (username.equals(userDetails.getUsername())) && !isTokenExpired(token); 
  102.     }  
  103.  
  104.     
  105.     * 判断Token是否过去  
  106.     */  
  107.     private boolean isTokenExpired(String token) {  
  108.         return extractExpiration(token).before(new Date());  
  109.     }  
  110.  
  111.     
  112.     * 从Token中获取失效时间  
  113.     */  
  114.     private Date extractExpiration(String token) {  
  115.         
  116.         return extractClaim(token, Claims::getExpiration);  
  117.     }  
  118.  
  119.     
  120.     * 从Token中获取所有数据  
  121.     */  
  122.     private Claims extractAllClaims(String token) {  
  123.         return Jwts  
  124.         .parserBuilder()  
  125.         .setSigningKey(getSignInKey())  
  126.         .build()  
  127.         .parseClaimsJws(token)  
  128.         .getBody();  
  129.     }  
  130.  
  131.     
  132.     * 获取签名Key  
  133.     * Token 加密解密使用  
  134.     */  
  135.     private Key getSignInKey() {  
  136.         byte[] keyBytes = Decoders.BASE64.decode(secretKey);  
  137.         return Keys.hmacShaKeyFor(keyBytes);  
  138.     }  
  139. }
  140.

注册和登录

token的生成已经看过了,下面该进入最关键的环节了.用户注册 & 用户登录

  1. 用户注册: 接收到用户传递过来的信息,在数据库中生成用户信息(密码会通过passwordEncoder进行加密).用户信息保存成功后,会根据用户信息创建一个鉴权token和一个refreshToken

  2. 用户登录: 获取到用户传递的账号密码后,会创建一个UsernamePasswordAuthenticationToken对象.然后通过authenticationManager的authenticate方法进行校验,如果出现错误会根据错误的不同抛出不同的异常.在实际开发中可以通过捕获的异常类型不同来创建响应提示.

  1. @RestController  
  2. @RequestMapping("/api/v1/auth")  
  3. @RequiredArgsConstructor  
  4. public class AuthenticationController {  
  5.  
  6.     private final AuthenticationService service;  
  7.  
  8.     
  9.     * 注册方法  
  10.     * @param request 请求体  
  11.     * @return ResponseEntity  
  12.     */  
  13.     @PostMapping("/register")  
  14.     public ResponseEntity<AuthenticationResponse> register(  
  15.     @RequestBody RegisterRequest request  
  16.     ) {  
  17.         return ResponseEntity.ok(service.register(request));  
  18.     }  
  19.  
  20.     
  21.     * 鉴权(登录方法)  
  22.     * @param request 请求体  
  23.     * @return ResponseEntity  
  24.     */  
  25.     @PostMapping("/authenticate")  
  26.     public ResponseEntity<AuthenticationResponse> authenticate(  
  27.     @RequestBody AuthenticationRequest request  
  28.     ) {  
  29.         return ResponseEntity.ok(service.authenticate(request));  
  30.     }  
  31.  
  32.     
  33.     * 刷新token  
  34.     * @param request 请求体  
  35.     * @param response 响应体  
  36.     * @throws IOException 异常  
  37.     */  
  38.     @PostMapping("/refresh-token")  
  39.     public void refreshToken(  
  40.     HttpServletRequest request,  
  41.     HttpServletResponse response  
  42.     ) throws IOException {  
  43.         service.refreshToken(request, response);  
  44.     }  
  45. }
  46.

可以看出来controller中的方法都是对service方法的调用,我们现在看一下service中的代码

  1. @Service  
  2. @RequiredArgsConstructor  
  3. public class AuthenticationService {  
  4.   
  5.     private final UserRepository repository; 
  6.     private final TokenRepository tokenRepository; 
  7.     private final PasswordEncoder passwordEncoder; 
  8.     private final JwtService jwtService; 
  9.     private final AuthenticationManager authenticationManager; 
  10.  
  11.     
  12.     * 注册方法  
  13.     * @param request 请求体  
  14.     * @return AuthenticationResponse(自己封装的响应结构)  
  15.     */  
  16.     public AuthenticationResponse register(RegisterRequest request) {  
  17.     
  18.         var user = User.builder()  
  19.         .firstname(request.getFirstname())  
  20.         .lastname(request.getLastname())  
  21.         .email(request.getEmail())  
  22.         .password(passwordEncoder.encode(request.getPassword()))  
  23.         .role(request.getRole())  
  24.         .build();  
  25.  
  26.         
  27.         var savedUser = repository.save(user);  
  28.         
  29.         var jwtToken = jwtService.generateToken(user);  
  30.         
  31.         var refreshToken = jwtService.generateRefreshToken(user);  
  32.         
  33.         saveUserToken(savedUser, jwtToken);  
  34.         
  35.         return AuthenticationResponse.builder()  
  36.         .accessToken(jwtToken)  
  37.         .refreshToken(refreshToken)  
  38.         .build();  
  39.     }  
  40.  
  41.     
  42.     * 鉴权(登录)方法  
  43.     * @param request 请求体  
  44.     * @return AuthenticationResponse(自己封装的响应结构)  
  45.     */  
  46.     public AuthenticationResponse authenticate(AuthenticationRequest request) {  
  47.         
  48.         
  49.         authenticationManager.authenticate(  
  50.         new UsernamePasswordAuthenticationToken(  
  51.         request.getEmail(),  
  52.         request.getPassword()  
  53.         )  
  54.         );  
  55.         
  56.         var user = repository.findByEmail(request.getEmail())  
  57.         .orElseThrow();  
  58.         
  59.         var jwtToken = jwtService.generateToken(user);  
  60.         
  61.         var refreshToken = jwtService.generateRefreshToken(user);  
  62.         
  63.         revokeAllUserTokens(user);  
  64.         
  65.         saveUserToken(user, jwtToken);  
  66.         
  67.         return AuthenticationResponse.builder()  
  68.         .accessToken(jwtToken)  
  69.         .refreshToken(refreshToken)  
  70.         .build();  
  71.     }  
  72.  
  73.     
  74.     * 保存用户Token方法  
  75.     * 构建Token实体后保存到数据库  
  76.     * @param user 用户信息  
  77.     * @param jwtToken Token  
  78.     */  
  79.     private void saveUserToken(User user, String jwtToken) {  
  80.         var token = Token.builder()  
  81.         .user(user)  
  82.         .token(jwtToken)  
  83.         .tokenType(TokenType.BEARER)  
  84.         .expired(false)  
  85.         .revoked(false)  
  86.         .build();  
  87.         tokenRepository.save(token);  
  88.     }  
  89.  
  90.     
  91.     * 将用户所有Token变成失效状态  
  92.     * @param user 用户信息  
  93.     */  
  94.     private void revokeAllUserTokens(User user) {  
  95.         
  96.         var validUserTokens = tokenRepository.findAllValidTokenByUser(user.getId());  
  97.         if (validUserTokens.isEmpty()){  
  98.         return;  
  99.         }  
  100.         
  101.         validUserTokens.forEach(token -> {  
  102.         token.setExpired(true);  
  103.         token.setRevoked(true);  
  104.         });  
  105.         tokenRepository.saveAll(validUserTokens);  
  106.     }  
  107.  
  108.     
  109.     * 刷新token方法  
  110.     * @param request 请求体  
  111.     * @param response 响应体  
  112.     * @throws IOException 抛出IO异常  
  113.     */  
  114.     public void refreshToken(  
  115.     HttpServletRequest request,  
  116.     HttpServletResponse response  
  117.     ) throws IOException {  
  118.         
  119.         final String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);  
  120.         final String refreshToken;  
  121.         final String userEmail;  
  122.         
  123.         if (authHeader == null ||!authHeader.startsWith("Bearer ")) {  
  124.             return;  
  125.         }  
  126.         
  127.         refreshToken = authHeader.substring(7);  
  128.         
  129.         userEmail = jwtService.extractUsername(refreshToken);  
  130.         if (userEmail != null) {  
  131.             
  132.             var user = this.repository.findByEmail(userEmail)  
  133.             .orElseThrow();  
  134.  
  135.             
  136.             if (jwtService.isTokenValid(refreshToken, user)) {  
  137.                 
  138.                 var accessToken = jwtService.generateToken(user);  
  139.                 revokeAllUserTokens(user);  
  140.                 saveUserToken(user, accessToken);  
  141.                 
  142.                 var authResponse = AuthenticationResponse.builder()  
  143.                 .accessToken(accessToken)  
  144.                 .refreshToken(refreshToken)  
  145.                 .build();  
  146.                 new ObjectMapper().writeValue(response.getOutputStream(), authResponse);  
  147.             }  
  148.         }  
  149.     }  
  150. }
  151.

上述代码主要说明了,注册 & 登录后返回token的流程,当前项目中由于token & refreshToken有效期较长所以选择了将token保存到数据库(个人观点!!!).可以根据自己业务的实际需求来决定是否需要保存到redis

请求过滤

请求过滤主要是在每次请求的时候动态解析token来获取用户信息以及权限,来保证请求资源的安全性.防止越权访问等.

  1. @Component  
  2. @RequiredArgsConstructor  
  3. public class JwtAuthenticationFilter extends OncePerRequestFilter {  
  4.   
  5.     private final JwtService jwtService;  
  6.     private final UserDetailsService userDetailsService;  
  7.     private final TokenRepository tokenRepository;  
  8.  
  9.     @Override  
  10.     protected void doFilterInternal(  
  11.     @NonNull HttpServletRequest request,  
  12.     @NonNull HttpServletResponse response,  
  13.     @NonNull FilterChain filterChain  
  14.     ) throws ServletException, IOException {  
  15.         
  16.         if (request.getServletPath().contains("/api/v1/auth")) {  
  17.             filterChain.doFilter(request, response);  
  18.             return;  
  19.         }  
  20.         
  21.         final String authHeader = request.getHeader("Authorization");  
  22.         final String jwt;  
  23.         final String userEmail;  
  24.  
  25.         
  26.         if (authHeader == null ||!authHeader.startsWith("Bearer ")) {  
  27.             filterChain.doFilter(request, response);  
  28.             return;  
  29.         }  
  30.         
  31.         jwt = authHeader.substring(7);  
  32.         
  33.         userEmail = jwtService.extractUsername(jwt);  
  34.         
  35.         if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) {  
  36.             
  37.             UserDetails userDetails = this.userDetailsService.loadUserByUsername(userEmail);  
  38.  
  39.             
  40.             var isTokenValid = tokenRepository.findByToken(jwt)  
  41.                 .map(t -> !t.isExpired() && !t.isRevoked())  
  42.                 .orElse(false);  
  43.  
  44.             
  45.             if (jwtService.isTokenValid(jwt, userDetails) && isTokenValid) {  
  46.                 UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(  
  47.                 userDetails, 
  48.                 null,  
  49.                 userDetails.getAuthorities() 
  50.                 );  
  51.                 authToken.setDetails(  
  52.                     new WebAuthenticationDetailsSource().buildDetails(request) 
  53.                 );  
  54.                 
  55.                 
  56.                 SecurityContextHolder.getContext().setAuthentication(authToken);  
  57.             }  
  58.         }  
  59.         filterChain.doFilter(request, response);  
  60.     }  
  61. }
  62.

上述代码主要逻辑为: 从请求头中获取到token.验证token的有效性并解析token中的信息存储到SecurityContextHolder上下文中,方便后续的使用.

退出登录

登录以及token的校验已经说过了,现在就差一个退出登录了.大家是否还记得我们之前配置过一个退出登录的请求路径: /api/v1/auth/logout.当我们请求请求这个路径的时候,security会帮我们找到对应的LogoutHandler,然后调用logout方法实现退出登录.

  1. @Service  
  2. @RequiredArgsConstructor  
  3. public class LogoutService implements LogoutHandler {  
  4.  
  5.     private final TokenRepository tokenRepository;  
  6.  
  7.     @Override  
  8.     public void logout(  
  9.     HttpServletRequest request,  
  10.     HttpServletResponse response,  
  11.     Authentication authentication  
  12.     ) {  
  13.         
  14.         final String authHeader = request.getHeader("Authorization");  
  15.         final String jwt;  
  16.         if (authHeader == null ||!authHeader.startsWith("Bearer ")) {  
  17.         return;  
  18.         }  
  19.         
  20.         jwt = authHeader.substring(7);  
  21.         
  22.         var storedToken = tokenRepository.findByToken(jwt)  
  23.         .orElse(null);  
  24.         if (storedToken != null) {  
  25.             
  26.             storedToken.setExpired(true);  
  27.             storedToken.setRevoked(true);  
  28.             tokenRepository.save(storedToken);  
  29.             
  30.             SecurityContextHolder.clearContext();  
  31.         }  
  32.     }  
  33. }
  34.

security帮我们做了很多的事情,我们只需要把token置为失效状态,然后清除掉SecurityContextHolder上下文,就解决了全部的问题

下面通过几个例子,来讲解两种不同的鉴权配置方式

controller

  1. @RestController  
  2. @RequestMapping("/api/v1/admin")  
  3. @PreAuthorize("hasRole('ADMIN')") 
  4. public class AdminController {  
  5.   
  6.     @GetMapping  
  7.     @PreAuthorize("hasAuthority('admin:read')") 
  8.     public String get() {  
  9.         return "GET:: admin controller";  
  10.     }  
  11.     @PostMapping  
  12.     @PreAuthorize("hasAuthority('admin:create')") 
  13.     @Hidden  
  14.     public String post() {  
  15.         return "POST:: admin controller";  
  16.     }  
  17.     @PutMapping  
  18.     @PreAuthorize("hasAuthority('admin:update')")  
  19.     @Hidden  
  20.     public String put() {  
  21.         return "PUT:: admin controller";  
  22.     }  
  23.     @DeleteMapping  
  24.     @PreAuthorize("hasAuthority('admin:delete')")  
  25.     @Hidden  
  26.     public String delete() {  
  27.         return "DELETE:: admin controller";  
  28.     }  
  29. }
  30.

配置文件

下面贴出SecurityConfiguration配置类的部分代码

参考资料

[1]

https://github.com/ali-bouali/spring-boot-3-jwt-security: https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2Fali-bouali%2Fspring-boot-3-jwt-security

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/388647
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号