SpringSecurity Jwt Token 自动刷新有效期

Spring Security JWT Token 可以通过在 Token 中设置一个过期时间来实现自动刷新有效期。当 Token 过期前一段时间内，可以通过发送一个请求来触发 Token 的刷新，使其延长有效期。

具体实现可以通过在 Spring Security 的配置中添加一个 TokenRefreshFilter 来实现。该过滤器会检查 Token 的有效期，如果即将过期，则会发送一个请求到后端来刷新 Token。在 Token 刷新成功后，将新的 Token 返回给前端，并更新当前用户的 Token。

另外，为了保证 Token 的安全性，可以在 Token 中添加一个随机的 Salt 值，每次生成 Token 时都使用不同的 Salt 值，这样可以大大增加 Token 被破解的难度。

相关问题

springsecurity jwt自动刷新

Spring Security JWT自动刷新的实现可以通过使用定时任务和拦截器来实现。

首先，我们可以创建一个定时任务来发送请求，定期刷新JWT的过期时间。可以使用Spring自带的`@Scheduled`注解来实现定时任务的触发，通过注入`JwtTokenProvider`来操作JWT，并使用`HttpClient`发送请求来更新JWT的过期时间。

在`JwtTokenProvider`类中，我们可以添加一个`refreshToken`方法，该方法会自动刷新JWT的过期时间。在方法内，我们可以通过读取配置文件中的JWT过期时间设置来计算出新的过期时间，并更新JWT的过期时间。然后，可以使用`JwtTokenProvider`的方法来生成新的JWT，然后将新的JWT返回。

然后，我们需要创建一个拦截器来验证JWT的有效性。可以使用Spring的`HandlerInterceptor`接口来创建拦截器，并在`preHandle`方法中进行JWT验证。当JWT过期时，可以通过`JwtTokenProvider`的`refreshToken`方法来刷新JWT，并将新的JWT设置到响应的头部中。这样，下一次请求时，就会使用新的JWT。

在Spring Security的配置类中，我们可以将创建的拦截器添加到`WebMvcConfigurer`的`addInterceptors`方法中，从而将拦截器应用到所有请求中。

综上所述，通过使用定时任务和拦截器，我们可以实现Spring Security JWT的自动刷新。

spring security校验jwt token的代码

Spring Security校验JWT Token的代码可以参考如下：

首先，需要创建JWT Token的验证过滤器类。该类继承自OncePerRequestFilter，并在doFilterInternal()方法中实现了JWT Token的校验逻辑：

public class JwtTokenAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        String token = jwtTokenProvider.resolveToken(request);

        try {
            if (token != null && jwtTokenProvider.validateToken(token)) {

                Authentication auth = jwtTokenProvider.getAuthentication(token);

                if (auth != null) {
                    SecurityContextHolder.getContext().setAuthentication(auth);
                }
            }
        } catch (JwtException e) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());
            return;
        }

        filterChain.doFilter(request, response);
    }
}

然后，需要创建JWT Token的提供者类，该类负责创建Token并验证Token：

@Component
public class JwtTokenProvider {

    @Value("${jwt.secret}")
    private String secretKey;

    @Value("${jwt.token.validity}")
    private long validityInMilliseconds;

    private Key getSecretKey() {
        return Keys.hmacShaKeyFor(secretKey.getBytes());
    }

    public String createToken(String username, List<Role> roles) {

        Claims claims = Jwts.claims().setSubject(username);
        claims.put("auth", roles.stream().map(role -> new SimpleGrantedAuthority(role.getAuthority())).filter(Objects::nonNull).collect(Collectors.toList()));

        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(getSecretKey())
                .compact();
    }

    public Authentication getAuthentication(String token) {
        UserDetails userDetails = new User(getUsername(token), "", getAuthorities(token));
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }

    private String getUsername(String token) {
        return Jwts.parserBuilder().setSigningKey(getSecretKey()).build().parseClaimsJws(token).getBody().getSubject();
    }

    private List<GrantedAuthority> getAuthorities(String token) {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(getSecretKey())
                .build()
                .parseClaimsJws(token)
                .getBody();

        List<LinkedHashMap<String, String>> roles = (List<LinkedHashMap<String, String>>) claims.get("auth");

        return roles.stream().map(role -> new SimpleGrantedAuthority(role.get("authority"))).collect(Collectors.toList());
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(getSecretKey()).build().parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            e.printStackTrace();
            return false;
        }
    }

    public String resolveToken(HttpServletRequest req) {
        String bearerToken = req.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

最后，需要把上述过滤器类和提供者类添加到Spring Security的配置中：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/v1/auth/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JwtTokenAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    }

    @Bean
    public UserDetailsService userDetailsService() {
        return new UserServiceImpl();
    }

}

以上代码用来实现Spring Security校验JWT Token的功能，提供了创建Token、校验Token和获取Token中存储的用户和权限信息等相关方法。您可以根据您的实际需求进行修改和调整。