Spring Security整合JWT的详细配置与实现-java教程-PHP中文网

spring security整合jwt的解决方案如下：1. 添加依赖：在pom.xml中添加spring-boot-starter-security和jjwt相关依赖，包括jjwt-api、jjwt-impl和jjwt-jackson；2. 配置spring security：创建securityconfig类继承websecurityconfigureradapter，禁用csrf，设置认证规则为除/authenticate外均需认证，并配置无状态会话管理；3. 创建jwtauthenticationentrypoint：实现authenticationentrypoint接口，用于处理未授权访问，返回401错误；4. 创建jwtrequestfilter：继承onceperrequestfilter，拦截请求提取jwt，验证有效性后设置认证信息到securitycontextholder；5. 创建jwtuserdetailsservice：实现userdetailsservice，根据用户名加载用户信息，实际项目中应从数据库获取；6. 创建jwttokenutil：负责生成、解析和验证jwt，包含生成token、提取用户名、判断过期等功能；7. 创建authenticationcontroller：提供认证接口，接收用户名密码并返回生成的jwt；8. 处理jwt过期问题：通过引入refresh token机制，在用户登录时同时颁发refresh token，并设置专门的刷新端点，验证有效后颁发新jwt；9. 保护jwt secret：避免硬编码，使用环境变量或配置文件存储，定期轮换，使用强密码生成器，限制访问权限并监控使用情况；10. 在微服务架构中使用jwt：可通过api网关统一验证jwt并将用户信息转发给微服务，或每个微服务独立验证jwt，推荐将验证逻辑封装为共享库，并通过配置中心统一管理secret。

Spring Security整合JWT的详细配置与实现

Spring Security整合JWT，简单来说，就是让你的应用能够安全地验证用户身份，并且让用户在一段时间内无需重复登录。 JWT就像一张通行证，用户拿着这张通行证就能访问受保护的资源。

直接输出解决方案即可）

添加依赖: 首先，需要在pom.xml中添加Spring Security和JWT相关的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

登录后复制

这里使用了jjwt库，它提供了JWT的生成和解析功能。版本号可以根据实际情况调整。

配置Spring Security: 创建一个配置类，继承WebSecurityConfigurerAdapter，并重写configure(HttpSecurity http)方法。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/authenticate").permitAll() // 允许/authenticate接口匿名访问
            .anyRequest().authenticated() // 其他所有请求都需要认证
            .and()
            .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint)
            .and().sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 使用JWT，不创建session

        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

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

登录后复制

这段代码禁用了CSRF，配置了哪些接口允许匿名访问，哪些需要认证，并设置了session管理策略为STATELESS，意味着我们不会使用session来存储用户信息。JwtRequestFilter是用于拦截请求并验证JWT的过滤器，后面会讲到。

创建JwtAuthenticationEntryPoint: 当用户尝试访问需要认证的资源，但未提供有效的凭证时，JwtAuthenticationEntryPoint会被调用。

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {

    private static final long serialVersionUID = -7858869558953243875L;

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {

        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
    }
}

登录后复制

这里简单地返回一个401未授权错误。

创建JwtRequestFilter: 这个过滤器负责拦截每个请求，从请求头中提取JWT，验证其有效性，并设置Spring Security的上下文。

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

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

        final String requestTokenHeader = request.getHeader("Authorization");

        String username = null;
        String jwtToken = null;

        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            jwtToken = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(jwtToken);
            } catch (IllegalArgumentException e) {
                System.out.println("Unable to get JWT Token");
            } catch (ExpiredJwtException e) {
                System.out.println("JWT Token has expired");
            }
        } else {
            logger.warn("JWT Token does not begin with Bearer String");
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

            UserDetails userDetails = this.jwtUserDetailsService.loadUserByUsername(username);

            if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {

                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }

        chain.doFilter(request, response);
    }

}

登录后复制

这个过滤器首先从Authorization请求头中获取JWT。如果JWT存在且有效，它会从JWT中提取用户名，然后从JwtUserDetailsService加载用户信息，并创建一个UsernamePasswordAuthenticationToken，最后将其设置到SecurityContextHolder中。

创建JwtUserDetailsService: 这个类负责根据用户名从数据库或其他数据源加载用户信息。

@Service
public class JwtUserDetailsService implements UserDetailsService {

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 假设从数据库获取用户信息
        if ("javahub".equals(username)) {
            return new User("javahub", passwordEncoder.encode("password"),
                    new ArrayList<>());
        } else {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
    }
}

登录后复制

这里为了简单起见，直接硬编码了一个用户。实际项目中，你需要从数据库或其他数据源加载用户信息。注意，密码需要使用PasswordEncoder进行加密。

创建JwtTokenUtil: 这个类负责生成和验证JWT。

@Component
public class JwtTokenUtil implements Serializable {

    private static final long serialVersionUID = -2550185165626007488L;

    public static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;

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

    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }

    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }

    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }

    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return doGenerateToken(claims, userDetails.getUsername());
    }

    private String doGenerateToken(Map<String, Object> claims, String subject) {

        return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))
                .signWith(SignatureAlgorithm.HS512, secret).compact();
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

登录后复制

这个类包含了生成JWT、从JWT中提取信息、验证JWT等方法。secret是用于签名JWT的密钥，应该保密。JWT_TOKEN_VALIDITY是JWT的有效期，这里设置为5小时。

创建AuthenticationController: 这个Controller负责处理用户认证请求，生成JWT并返回给用户。

@RestController
@CrossOrigin
public class AuthenticationController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private JwtUserDetailsService userDetailsService;

    @PostMapping("/authenticate")
    public ResponseEntity<?> createAuthenticationToken(@RequestBody AuthenticationRequest authenticationRequest) throws Exception {

        authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword());

        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());

        final String token = jwtTokenUtil.generateToken(userDetails);

        return ResponseEntity.ok(new AuthenticationResponse(token));
    }

    private void authenticate(String username, String password) throws Exception {
        try {
            authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
        } catch (DisabledException e) {
            throw new Exception("USER_DISABLED", e);
        } catch (BadCredentialsException e) {
            throw new Exception("INVALID_CREDENTIALS", e);
        }
    }
}

class AuthenticationRequest {
    private String username;
    private String password;

    // Getters and setters
}

class AuthenticationResponse {
    private final String jwt;

    public AuthenticationResponse(String jwt) {
        this.jwt = jwt;
    }

    // Getter
}

登录后复制

这个Controller接收用户名和密码，使用AuthenticationManager进行认证。如果认证成功，它会使用JwtTokenUtil生成JWT，并将其返回给用户。

如何处理JWT过期问题？

JWT过期是使用JWT认证时必须考虑的问题。一个常见的解决方案是使用refresh token。当用户的JWT即将过期时，可以使用refresh token来获取一个新的JWT，而无需用户重新登录。实现refresh token机制通常涉及以下步骤：

颁发Refresh Token： 在用户成功登录后，除了颁发JWT之外，还颁发一个refresh token。 Refresh token通常具有比JWT更长的有效期，并存储在数据库中，与用户关联。
存储Refresh Token： 将refresh token安全地存储在服务器端数据库中，并与用户ID关联。
Refresh Token Endpoint： 创建一个专门用于刷新JWT的API端点（例如，/refresh-token）。
验证Refresh Token： 当客户端的JWT过期或即将过期时，客户端将refresh token发送到/refresh-token端点。服务器验证refresh token是否有效（例如，检查它是否存在于数据库中，并且未被撤销）。
颁发新的JWT： 如果refresh token有效，服务器会颁发一个新的JWT，并将新的JWT和新的refresh token（可选）返回给客户端。同时，可以更新数据库中的refresh token。
撤销Refresh Token： 实现撤销refresh token的机制，例如，当用户注销时，可以从数据库中删除refresh token，使其失效。

此外，也可以考虑使用滑动过期策略，即每次用户访问受保护的资源时，都更新JWT的过期时间。

如何保护JWT的secret？

保护JWT的secret至关重要，因为如果secret泄露，攻击者可以伪造JWT，冒充任何用户。以下是一些保护JWT secret的最佳实践：

不要硬编码secret： 永远不要将secret硬编码到代码中。这样做会使secret容易被泄露，例如，通过源代码管理系统或反编译。
使用环境变量或配置文件： 将secret存储在环境变量或配置文件中。这样可以将secret与代码分离，并使其更容易管理。
使用强密码生成器： 使用强密码生成器生成一个随机且复杂的secret。避免使用容易猜测的字符串。
定期轮换secret： 定期轮换secret，例如，每隔几个月或一年。这样做可以降低secret泄露的风险。
使用硬件安全模块（HSM）： 对于高安全要求的应用，可以考虑使用HSM来存储和管理secret。 HSM是一种专门用于保护密钥的安全硬件设备。
限制访问权限： 限制对存储secret的服务器或配置文件的访问权限。只有授权人员才能访问secret。
监控secret的使用： 监控secret的使用情况，例如，记录谁访问了secret，以及何时访问了secret。这样可以及时发现secret泄露的迹象。

如何在微服务架构中使用JWT？

在微服务架构中使用JWT可以实现单点登录（SSO）和授权。一种常见的做法是使用API网关作为JWT的验证中心。

API网关验证JWT： 客户端将JWT发送到API网关。 API网关验证JWT的有效性。
转发请求到微服务： 如果JWT有效，API网关将请求转发到相应的微服务。 API网关可以将用户信息（例如，用户ID、角色）添加到请求头中，以便微服务可以使用这些信息进行授权。
微服务进行授权： 微服务根据请求头中的用户信息进行授权。例如，微服务可以检查用户是否具有访问特定资源的权限。

另一种做法是每个微服务都验证JWT。这种做法的优点是微服务可以独立地进行授权，缺点是每个微服务都需要维护JWT的验证逻辑。为了避免代码重复，可以将JWT的验证逻辑提取到一个共享库中。

无论使用哪种做法，都需要确保JWT的secret在所有微服务中都是一致的。可以使用配置中心来管理JWT的secret。

另外，可以考虑使用OAuth 2.0和OpenID Connect等标准协议来实现更安全和灵活的认证和授权。

以上就是Spring Security整合JWT的详细配置与实现的详细内容，更多请关注php中文网其它相关文章！