springboot集成jwt实现token

Spring Boot 集成 JWT 实现 token 验证可以使用第三方库来实现，比如jjwt。在项目中引入该库，然后在需要进行 token 验证的接口上添加注解即可。可以参考下面的步骤：
1. 在 pom.xml 中引入 jjwt 的依赖
2. 在配置类中配置 JWT 的相关参数，包括签名秘钥、过期时间等。
3. 创建一个过滤器，在过滤器中对 token 进行验证。
4. 在需要进行 token 验证的接口上添加注解，指定使用上述过滤器。
5. 在登录接口中生成 token，并将 token 返回给客户端。
6. 客户端每次请求时需要携带 token。

相关问题

SpringBoot集成jwt实现token认证

在Spring Boot中，可以使用以下步骤将JWT集成到应用程序中以实现token认证：

1. 添加依赖项

在pom.xml文件中添加以下依赖项：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 创建Token工具类

创建一个JwtTokenUtil工具类，该类将用于生成和验证JWT令牌。以下是一个基本的JwtTokenUtil类：

public class JwtTokenUtil {

    private static final String SECRET_KEY = "secret";

    public static String generateToken(String username) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + 3600000);

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public static String getUsernameFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    public static boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (SignatureException ex) {
            System.out.println("Invalid JWT signature");
        } catch (MalformedJwtException ex) {
            System.out.println("Invalid JWT token");
        } catch (ExpiredJwtException ex) {
            System.out.println("Expired JWT token");
        } catch (UnsupportedJwtException ex) {
            System.out.println("Unsupported JWT token");
        } catch (IllegalArgumentException ex) {
            System.out.println("JWT claims string is empty.");
        }
        return false;
    }
}

3. 创建安全配置类

创建一个SecurityConfig类，该类将用于配置Spring Security以使用JWT进行认证。以下是一个基本的SecurityConfig类：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;

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

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }

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

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests().antMatchers("/authenticate").permitAll()
                .anyRequest().authenticated().and()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

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

4. 创建用户详细信息服务类

创建一个JwtUserDetailsService类，该类将用于从数据库或其他存储中获取用户信息以进行身份验证。以下是一个基本的JwtUserDetailsService类：

@Service
public class JwtUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 在这里获取用户信息并返回UserDetails对象
        return null;
    }
}

5. 创建身份验证过滤器

创建一个JwtAuthenticationFilter类，该类将用于拦截所有请求，并进行JWT身份验证。以下是一个基本的JwtAuthenticationFilter类：

public class JwtAuthenticationFilter 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;

        // JWT Token is in the form "Bearer token". Remove Bearer word and get only the Token
        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");
        }

        // Once we get the token validate it.
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

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

            // if token is valid configure Spring Security to manually set authentication
            if (jwtTokenUtil.validateToken(jwtToken)) {
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                // After setting the Authentication in the context, we specify
                // that the current user is authenticated. So it passes the
                // Spring Security Configurations successfully.
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

6. 创建身份验证控制器

创建一个JwtAuthenticationController类，该类将用于处理身份验证请求，生成JWT令牌并返回给客户端。以下是一个基本的JwtAuthenticationController类：

@RestController
public class JwtAuthenticationController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;

    @RequestMapping(value = "/authenticate", method = RequestMethod.POST)
    public ResponseEntity<?> createAuthenticationToken(@RequestBody JwtRequest authenticationRequest) throws Exception {

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

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

        final String token = jwtTokenUtil.generateToken(userDetails.getUsername());

        return ResponseEntity.ok(new JwtResponse(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);
        }
    }
}

现在，您的Spring Boot应用程序已经集成了JWT以进行身份验证。

springboot集成jwt实现登录

对于Spring Boot集成JWT实现登录的步骤，可以按照以下几个步骤进行操作：

1. 添加依赖：在`pom.xml`文件中添加以下依赖，以引入JWT相关的库：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>

2. 创建JWT工具类：创建一个JWT工具类，用于生成和解析JWT。你可以使用`Jwts.builder()`来创建JWT，并设置相关的声明（例如，用户ID、角色等）和过期时间。

3. 创建登录接口：创建一个登录接口，用于验证用户名和密码，并生成相应的JWT。在验证通过后，可以使用JWT工具类生成JWT并返回给客户端。

4. 配置Spring Security：为了保护你的API，你需要进行Spring Security的配置。你可以创建一个继承`WebSecurityConfigurerAdapter`的类，并重写`configure()`方法来配置安全规则。在这个方法中，你可以配置哪些URL需要进行认证，哪些URL不需要认证（例如，登录接口）。

5. 创建Token过滤器：创建一个Token过滤器，用于验证请求中的JWT，并将用户信息存储到SecurityContext中，以便在后续的请求中使用。

6. 配置Token过滤器：在Spring Security配置类中，将Token过滤器添加到过滤器链中，以保证每个请求都会经过Token过滤器的验证。

通过以上步骤，你就可以实现Spring Boot集成JWT实现登录功能。当用户登录成功后，会生成一个JWT，并在后续的请求中使用该JWT进行身份验证。