什么是JWT？如何使用Spring Boot Security实现它？

在现代Web应用程序中，安全性和用户体验是至关重要的两个方面。JSON Web Token (JWT) 是一种开放标准 (RFC 7519)，用于在网络应用环境间安全地将信息作为JSON对象传输。JWT因其简单、紧凑且自包含的特性而被广泛应用于用户认证和授权场景。本文将详细介绍JWT的概念，并通过实例展示如何利用Spring Boot Security框架来实现基于JWT的安全机制。

什么是JWT？

基本概念

• Token：JWT本质上是一个经过签名的字符串，由三部分组成：头部（Header）、载荷（Payload）以及签名（Signature）。这些部分通过点号.连接。
• 头部：通常包含了令牌类型（即JWT）和所使用的签名算法（如HMAC SHA256或RSA）。
• 载荷：存放了声明（Claims），这些声明可以是预定义的标准名称，也可以是自定义的数据。
• 签名：确保消息传输过程中的完整性，防止数据被篡改。

工作原理

当用户登录时，服务器验证其身份后会生成一个JWT并返回给客户端。此后，客户端每次请求都需要携带这个JWT，服务器通过验证签名来确认请求者的身份。这种方式避免了传统的Session机制带来的状态管理问题，特别适合于分布式系统。

如何使用Spring Boot Security实现JWT

接下来，我们将分步骤介绍如何在Spring Boot项目中集成JWT进行用户认证。

添加依赖

首先，在pom.xml文件中添加必要的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

配置Spring Security

创建一个配置类继承自WebSecurityConfigurerAdapter，并重写相关方法以启用JWT支持：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/auth/**").permitAll() // 允许所有用户访问登录接口
                .anyRequest().authenticated() // 所有其他请求都需要认证
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()))
            .addFilter(new JwtAuthorizationFilter(authenticationManager()));
    }

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

创建JWT工具类

为了方便生成和解析JWT，我们可以创建一个工具类：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtUtil {
    private static final String SECRET = "your_secret_key"; // 应该存储在安全的地方

    public static String generateToken(String username, long expirationTime) {
        return Jwts.builder()
                .setSubject(username)
                .setExpiration(new Date(System.currentTimeMillis() + expirationTime))
                .signWith(SignatureAlgorithm.HS512, SECRET)
                .compact();
    }

    public static Claims extractClaims(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET)
                .parseClaimsJws(token)
                .getBody();
    }
}

编写过滤器

我们需要编写两个过滤器，一个是用于处理登录请求的JwtAuthenticationFilter，另一个是用于后续请求验证的JwtAuthorizationFilter。

登录过滤器

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        // 从请求中获取用户名和密码
        try {
            User user = new ObjectMapper().readValue(request.getInputStream(), User.class);
            
            return getAuthenticationManager().authenticate(
                    new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword())
            );
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
                                            Authentication authResult) throws IOException, ServletException {
        String token = JwtUtil.generateToken(((UserDetails) authResult.getPrincipal()).getUsername(), 3600000); // 有效期为1小时
        response.addHeader("Authorization", "Bearer " + token);
    }
}

授权过滤器

public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
    
    public JwtAuthorizationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        
        String header = request.getHeader("Authorization");
        
        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            return;
        }
        
        UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
        SecurityContextHolder.getContext().setAuthentication(authentication);
        chain.doFilter(request, response);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        if (token != null) {
            Claims claims = JwtUtil.extractClaims(token.replace("Bearer ", ""));
            if (claims != null) {
                String username = claims.getSubject();
                
                if (username != null) {
                    return new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>());
                }
            }
        }
        return null;
    }
}

用户详情服务

最后，我们需要提供一个用户详情服务来加载用户信息：

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    
    @Autowired
    private UserRepository userRepository; // 假设有一个用户仓库

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(),
                new ArrayList<>());
    }
}

结论

通过上述步骤，我们已经成功地在Spring Boot应用中实现了基于JWT的身份验证机制。这种方法不仅简化了传统的Session管理，还提供了良好的跨域支持。当然，在实际部署前，您还需要考虑更多安全细节，比如密钥的安全存储、更复杂的错误处理等。希望这篇文章能帮助您理解JWT的工作原理及其与Spring Boot Security结合的方法。随着技术的发展和个人经验的增长，不断优化您的安全策略是非常重要的。