本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：本实战教程详细讲解了JWT认证机制的原理和流程，并展示了如何在Spring Boot框架中整合JWT实现用户认证。从JWT的三部分构成（Header、Payload、Signature）到认证流程的各个环节（用户登录、身份验证、Token返回与验证、授权决策），再到在Spring Boot中的整合应用（依赖添加、安全配置、Token生成与处理、过滤器实现、权限控制）都将被逐步展开。通过具体的应用场景，如用户实体创建、JWT工具类编写、登录接口实现、过滤器实现以及权限注解应用，学习者能够掌握将JWT认证机制应用于实际项目的能力，确保Web应用和API的安全性。

1. JWT认证机制原理

JSON Web Token（JWT）是目前流行的开放标准（RFC 7519），用于在网络应用环境间安全地传输声明。 JWT认证机制以其轻量级、跨平台的特性，在Web应用和微服务架构中得到了广泛应用。本章将简要介绍JWT的认证原理，为后续章节中对JWT的各个组成部分和工作流程的深入解析打下基础。

JWT的工作原理是，用户在进行身份验证成功后，服务器会生成一个Token，通常包含用户身份信息及一些附加数据，并对这部分信息进行签名。用户随后携带这个Token访问受保护的资源。服务器端接收到Token后，验证签名无误后，即可从中提取用户信息，完成认证过程。这种机制免去了传统的多次数据库查询和状态管理的需要，让Web应用和API服务可以保持无状态。

在本系列的文章中，我们将探究JWT的细节，从其核心组成部分到在实际开发中的整合使用，帮助读者构建一个安全、高效的身份认证系统。

2. JWT的Header、Payload、Signature结构解析

2.1 JWT的组成部分

2.1.1 Header的构成和作用

JWT由三部分构成，分别是Header（头部）、Payload（载荷）和Signature（签名）。其中，Header主要定义了使用的签名算法以及Token类型。 

// Header 示例
{
  "alg": "HS256",
  "typ": "JWT"
}

在上述JSON中， alg 表示加密算法，这里是HS256，表示使用HMAC SHA256算法， typ 表示Token的类型，这里是JWT。

代码块： 示例中描述的JSON Header可以使用以下代码生成： 

import java.util.HashMap;
import java.util.Map;

Map<String, Object> header = new HashMap<>();
header.put("alg", "HS256");
header.put("typ", "JWT");

// 将Map转换成JSON字符串
String headerJson = new ObjectMapper().writeValueAsString(header);

逻辑分析与参数说明： 这段代码首先创建了一个 header 变量，它是一个 HashMap 。然后往这个 header 中加入两个键值对，分别对应 alg 和 typ 。最后，我们使用Jackson的 ObjectMapper 类将 header Map转换为JSON字符串。

2.1.2 Payload的内容详解

Payload部分是存放有效信息的地方。这些信息包含三个部分：标准中已经定义的字段、公共的声明和私有的声明。 

// Payload 示例
{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

在示例中， sub 是标准字段表示主题， name 是公共声明，而 admin 是私有声明。其中私有声明是应用定义的，可以在其中添加业务相关的数据。

代码块： 生成带有自定义声明的Payload的Java代码： 

import com.fasterxml.jackson.databind.ObjectMapper;

Map<String, Object> payload = new HashMap<>();
payload.put("sub", "1234567890");
payload.put("name", "John Doe");
payload.put("admin", true);

ObjectMapper objectMapper = new ObjectMapper();
String payloadJson = objectMapper.writeValueAsString(payload);

逻辑分析与参数说明： 上述代码首先创建了一个 payload 变量，往其中添加了标准声明、公共声明和私有声明。之后使用Jackson的 ObjectMapper 将 payload Map转换为JSON字符串。

2.1.3 Signature的安全性分析

Signature部分是对前两部分的签名，用于验证消息的完整性和安全性。使用Header中指定的算法，以Header和Payload作为输入，使用密钥进行签名。 

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public String createSignature(String headerJson, String payloadJson, String secret) throws NoSuchAlgorithmException, InvalidKeyException {
    byte[] apiKeySecretBytes = secret.getBytes(StandardCharsets.UTF_8);
    SecretKeySpec keySpec = new SecretKeySpec(apiKeySecretBytes, "HmacSHA256");
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(keySpec);
    byte[] hash = mac.doFinal((headerJson + "." + payloadJson).getBytes(StandardCharsets.UTF_8));
    return Base64.getEncoder().encodeToString(hash);
}

逻辑分析与参数说明： 在这个代码示例中，我们首先获取了一个字节数组，代表了用于签名的密钥。我们使用了HmacSHA256算法和密钥创建了一个 Mac 实例。然后，我们通过输入Header和Payload的JSON字符串拼接结果进行签名，最后通过 Base64 编码器将签名结果转换成可打印的字符串。这个过程保证了生成的Token在传输过程中没有被篡改。

2.2 JWT编码与解码机制

2.2.1 编码过程中的Base64算法应用

JWT的编码过程简单而言就是将Header和Payload部分通过Base64URL安全编码进行编码，而Signature部分在生成之后不会被编码。

代码块： 使用Base64算法对JWT部分进行编码的Java代码示例： 

import java.util.Base64;

String encodedHeader = Base64.getEncoder().encodeToString(headerJson.getBytes(StandardCharsets.UTF_8));
String encodedPayload = Base64.getEncoder().encodeToString(payloadJson.getBytes(StandardCharsets.UTF_8));

// 用于构造JWT的字符串
String jwt = encodedHeader + "." + encodedPayload + "." + signature;

逻辑分析与参数说明： 在代码示例中，我们使用了Java内置的 Base64 类，通过 getEncoder() 方法获取编码器实例。然后，我们将Header和Payload的JSON字符串转换为字节序列，并对这些字节序列进行Base64编码。最后，编码后的字符串被用于JWT字符串的构造。

2.2.2 解码过程中的密钥验证机制

在解码JWT时，需要验证签名以确保Token的有效性。这需要使用与编码时相同的密钥和签名算法。 

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public boolean verifySignature(String token, String secret) throws NoSuchAlgorithmException, InvalidKeyException {
    String[] parts = token.split("\\.");
    String headerJson = parts[0];
    String payloadJson = parts[1];
    String signature = parts[2];

    String base64EncodedHeader = new String(Base64.getDecoder().decode(headerJson));
    String base64EncodedPayload = new String(Base64.getDecoder().decode(payloadJson));

    String signatureToVerify = createSignature(base64EncodedHeader, base64EncodedPayload, secret);
    return signature.equals(signatureToVerify);
}

逻辑分析与参数说明： 本代码段首先将JWT字符串分割为Header、Payload和Signature三部分。之后分别对Header和Payload进行Base64解码，得到原始的JSON字符串。然后，再次使用相同的方法生成待验证的Signature，最后将生成的Signature和JWT中的Signature进行比较。如果两者一致，则验证成功，表明JWT未被篡改且确实使用了预期的密钥生成。

通过上述的编码和验证过程，我们可以看到JWT的加密和验证机制是如何保证其安全性。在下一章节中，我们将进一步探讨如何在用户登录和Token验证过程中应用JWT。

3. JWT认证流程：用户登录、Token生成与验证、授权

3.1 用户登录与认证流程

3.1.1 用户名和密码的验证

在Web应用中，用户登录是常见的操作。当用户提交用户名和密码后，后端服务需要对这些凭据进行验证。这一过程通常由身份验证服务器处理，其目标是确认提交的凭据与数据库中存储的用户凭据是否匹配。

为了保证验证过程的安全性，通常会在传输凭据之前使用HTTPS协议加密数据。用户提交凭据后，服务器端会执行以下步骤： 1. 验证用户名是否存在。 2. 使用哈希算法（例如，SHA-256）比对密码。 3. 确认用户状态是否激活。 4. 根据需要检查其他安全要素，如二次验证。 

// 示例代码：用户名和密码的验证逻辑
public User authenticate(String username, String password) {
    // 1. 根据用户名查询用户实体
    User user = userRepository.findByUsername(username);
    if(user != null && passwordEncoder.matches(password, user.getPassword())) {
        // 2. 密码匹配
        return user;
    } else {
        // 3. 抛出异常，提示验证失败
        throw new BadCredentialsException("用户名或密码错误");
    }
}

在上述代码中， findByUsername 方法用于查询数据库中的用户， passwordEncoder.matches 用于比对密码的哈希值。

3.1.2 Token的生成机制

一旦用户成功登录，系统需要生成一个Token来标识用户的认证状态。通常使用JWT生成Token。Token生成过程涉及编码Header和Payload，并将它们与一个秘密签名相结合。以下是JWT Token生成的一般步骤：

  1. 创建一个Header对象，通常包含token类型（JWT）和所使用的签名算法（如HS256）。
  2. 创建一个Payload对象，包含用户信息（如用户ID、角色等）以及过期时间（exp）。
  3. 使用Base64URL算法对Header和Payload进行编码。
  4. 使用Header中指定的算法和一个密钥对编码后的Header和Payload进行签名。
  5. 将编码后的Header、编码后的Payload和签名值拼接成JWT Token。 
// 示例代码：JWT Token生成
public String generateToken(UserDetails userDetails) {
    Date now = new Date();
    Date expiryDate = new Date(now.getTime() + JWT_TOKEN_VALIDITY);

    // 1. 创建Header
    Map<String, Object> headerClaims = new HashMap<>();
    headerClaims.put("alg", "HS256");
    headerClaims.put("typ", "JWT");
    String header = Jwts.builder()
                       .setClaims(headerClaims)
                       .setIssuedAt(new Date())
                       .setExpiration(expiryDate)
                       .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                       .compact();

    // 2. 创建Payload
    Map<String, Object> payloadClaims = new HashMap<>();
    payloadClaims.put("sub", userDetails.getUsername());
    payloadClaims.put("iat", now);
    payloadClaims.put("exp", expiryDate);
    payloadClaims.put("roles", userDetails.getAuthorities());
    String payload = Jwts.builder()
                         .setClaims(payloadClaims)
                         .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                         .compact();

    // 3. 合并Header和Payload，生成Token
    return header + "." + payload;
}

在上述代码中， Jwts.builder().signWith(...) 用于生成签名， compact() 方法用于生成JWT字符串。

3.1.3 Token的存储和传输

生成的JWT Token需要存储在客户端，通常存放在HTTP请求的Authorization头部，并以Bearer模式进行传输。服务端接收到请求后，将解析Token并验证其有效性。

Token的存储方式对安全性有很大影响： - 如果将Token存储在Cookie中，需要设置合适的HttpOnly和Secure属性。 - 如果将Token存储在LocalStorage或SessionStorage中，需注意跨站脚本攻击（XSS）的风险。 - Token可以随每个请求发送，但较大的Token可能增加网络开销。 

// HTTP请求头示例：
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

3.2 Token的验证过程

3.2.1 客户端Token验证流程

客户端在每个请求中携带Token，主要是通过HTTP请求头中的Authorization字段进行的。客户端没有直接验证Token的能力，验证工作由服务端完成。客户端仅负责发送Token。

3.2.2 服务端Token验证实现

服务端接收到带有Token的请求后，需要解析并验证Token的有效性。这包括确认Token签名、检查Token是否过期、验证发行者等。如果Token验证失败，则拒绝请求；如果成功，则处理请求并返回相应数据。 

// 示例代码：服务端验证JWT Token
public Authentication authenticateRequest(HttpServletRequest request) {
    String token = getJwtFromRequest(request);
    try {
        // 解析并验证Token
        Jws<Claims> claims = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
        // 如果Token有效，则提取用户信息并创建认证对象
        String username = claims.getBody().getSubject();
        List<GrantedAuthority> authorities = extractAuthorities(claims.getBody());
        UserDetails userDetails = new org.springframework.security.core.userdetails.User(username, "", authorities);
        return new UsernamePasswordAuthenticationToken(userDetails, null, authorities);
    } catch (SignatureException | MalformedJwtException | ExpiredJwtException | IllegalArgumentException e) {
        // Token验证失败
        log.error("JWT Token validation failed: {}", e.getMessage());
    }
    return null;
}

private String getJwtFromRequest(HttpServletRequest request) {
    String bearerToken = request.getHeader("Authorization");
    if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
        return bearerToken.substring(7);
    }
    return null;
}

在此代码中， getJwtFromRequest 方法用于从HTTP请求头中提取Token， authenticateRequest 方法用于验证Token并创建Spring Security的认证对象。

3.3 基于JWT的授权机制

3.3.1 声明(claim)在授权中的应用

JWT中的声明(claim)是关于实体（通常是用户）和其他数据的声明。它们可以用来在用户和信息之间传递信息。在授权过程中，可以使用特定的声明来控制对资源的访问。

例如，角色信息可以作为JWT的一个声明进行传递。在服务端，通过解析Token的Payload部分，可以获取到用户的角色信息，并据此进行访问控制。

3.3.2 基于角色的访问控制实现

基于角色的访问控制（RBAC）是管理用户权限的常用方法。在JWT中，可以通过声明来实现RBAC。

服务端可以定义一系列的访问策略，这些策略根据用户的角色来决定用户是否具有访问某个资源的权限。在处理请求时，服务端会检查用户的角色是否满足权限规则。 

// 示例代码：基于角色的访问控制检查
public boolean hasPermission(Authentication authentication, String permission) {
    Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
    for (GrantedAuthority authority : authorities) {
        if (authority.getAuthority().equals(permission)) {
            return true;
        }
    }
    return false;
}

在上述代码中， authentication 对象包含了用户的角色信息， hasPermission 方法用于检查用户是否具有指定的权限。

在本章节的详细分析中，我们深入了解了JWT认证机制下的用户登录、Token生成与验证、授权流程。这些流程是Web安全认证的核心组成部分，对保证用户信息的安全性和系统的稳定性至关重要。通过实际的代码示例和逻辑分析，我们展现了这些概念在实际应用中的实现方法。在下一章节，我们将探讨如何在Spring Boot框架中整合JWT机制，进一步提升Web应用的安全性与开发效率。

4. Spring Boot与JWT整合步骤

4.1 添加依赖与配置安全

4.1.1 在Spring Boot中添加JWT依赖

在Spring Boot项目中整合JWT，首先需要添加对应的依赖库。借助Maven强大的依赖管理功能，可以快速将JWT库整合到项目中。具体操作如下： 

<!-- 添加JWT依赖 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

在上述依赖中，使用了 jjwt 库，这是一个广泛使用的Java库，用于处理JWT的生成和解析。选择合适的版本号以避免潜在的兼容性问题。添加依赖后，确保更新项目，使新的依赖生效。

4.1.2 配置Spring Security和JWT认证规则

整合JWT的第二步是配置Spring Security来实现基于JWT的安全认证。这涉及到设置认证过滤器、定义安全约束等步骤。以下是基础配置示例： 

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private UserDetailsService jwtUserDetailsService;

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @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(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }

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

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

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

在上述配置中，我们定义了一个 WebSecurityConfig 类，扩展了 WebSecurityConfigurerAdapter 。通过覆写 configure(HttpSecurity http) 方法，我们设置了：

  • 禁用跨站请求伪造保护（ csrf().disable() ）。
  • 允许匿名访问 /authenticate 端点。
  • 除 /authenticate 外的所有请求都必须经过身份验证。
  • 添加自定义的异常处理器 jwtAuthenticationEntryPoint 。
  • 添加无状态会话管理策略，表明不使用基于会话的认证机制。
  • 添加 jwtRequestFilter 作为前置过滤器。

我们还需要创建一个密码编码器（ passwordEncoder ），并提供认证管理器（ authenticationManager ），以确保Spring Security按照JWT的规则进行认证。

4.2 处理登录、过滤器实现

4.2.1 登录接口的实现

接下来，我们实现登录接口。登录接口需要接受用户名和密码，验证用户，生成JWT，并返回该Token给客户端。示例代码如下： 

@RestController
@RequestMapping("/api")
public class JwtAuthenticationController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @RequestMapping(value = "/authenticate", method = RequestMethod.POST)
    public ResponseEntity<?> createAuthenticationToken(@RequestBody UserDto userDto) throws Exception {
        authenticate(userDto.getUsername(), userDto.getPassword());

        final String token = jwtTokenUtil.generateToken(userDto.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);
        }
    }
}

在这个类中，我们定义了一个 /authenticate 的POST请求映射。客户端提交用户名和密码时，会触发 createAuthenticationToken 方法。这个方法首先调用 authenticate 方法校验用户身份。如果校验通过，将使用 JwtTokenUtil 生成JWT，并将JWT封装在 JwtResponse 中返回给客户端。

4.2.2 JWT认证过滤器的创建和应用

认证过滤器是Spring Security框架中用于拦截和处理HTTP请求的组件。我们需要创建一个认证过滤器，用于在每次HTTP请求中校验JWT的有效性。以下是过滤器的实现示例： 

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 ' prefix");
        }

        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);
    }
}

JwtRequestFilter 继承自 OncePerRequestFilter ，确保过滤器在每个请求中只运行一次。它首先检查请求头中是否包含带有“Bearer ”前缀的JWT Token。如果存在，它将验证Token的有效性，并从Token中提取用户名。然后，它将尝试从数据库中加载用户的详细信息，并使用 JwtTokenUtil 验证Token是否有效。如果用户验证成功，将创建 UsernamePasswordAuthenticationToken 并将其设置到 SecurityContextHolder 中。

4.3 权限控制与Token过期策略

4.3.1 基于JWT的权限控制实现

在Spring Boot应用中，我们通常使用Spring Security的注解来实现方法级别的安全性。JWT可以与Spring Security的认证机制无缝集成，来实现基于角色的访问控制。这里是一个使用 @PreAuthorize 注解进行权限控制的示例： 

@RestController
@RequestMapping("/api/private")
@PreAuthorize("hasRole('USER')")
public class PrivateController {

    @GetMapping("/user")
    public String user() {
        return "Welcome to User Section";
    }

    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/admin")
    public String admin() {
        return "Welcome to Admin Section";
    }
}

在上述代码中，我们有两个受保护的API端点。 /api/private/user 是所有用户都能访问的，因为所有用户都至少具有“USER”角色。而 /api/private/admin 端点仅限于具有“ADMIN”角色的用户访问。这通过 @PreAuthorize 注解来实现，其中的角色名必须与JWT中声明的 authorities 集合中的角色匹配。

4.3.2 Token过期处理和刷新机制

JWT的另一个重要特性是携带了Token的过期时间。这允许服务端在每次请求时检查Token是否有效，同时用户可以在Token即将过期时进行刷新。这里是一个Token过期处理和刷新策略的实现示例： 

@RestController
@RequestMapping("/api/refresh")
public class RefreshTokenController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @PostMapping
    public ResponseEntity<?> refreshAndGetAuthenticationToken(@RequestBody JwtRequest jwtRequest) {
        final String requestTokenHeader = jwtRequest.getJwtToken();
        String username = null;
        String token = null;
        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            token = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(token);
            } catch (IllegalArgumentException e) {
                System.out.println("Unable to get JWT Token");
            } catch (ExpiredJwtException e) {
                System.out.println("JWT Token has expired");
            }
        } else {
            System.out.println("JWT Token does not begin with 'Bearer ' prefix");
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            final Authentication authentication = authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>()));
            if (authentication != null && jwtTokenUtil.canTokenBeRefreshed(token, authentication)) {
                token = jwtTokenUtil.refreshToken(token);
            }
        }

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

在 RefreshTokenController 中，我们定义了一个 /refresh 端点，用于接收带有过期Token的请求并返回一个新的Token。首先，它检查请求头中是否存在有效的JWT Token，并尝试从中提取用户名。如果用户名存在，并且用户没有被认证，系统将使用 AuthenticationManager 重新验证用户的凭证，并且如果Token仍然有效，使用 JwtTokenUtil 生成一个新的JWT Token返回给用户。

这样，即使用户在使用应用过程中，JWT Token接近过期，也可以通过调用 /refresh 端点来获取一个新的Token，而无需重新登录。

5. 实战应用案例：用户实体创建、JWT工具类、登录接口、过滤器实现、权限注解应用

5.1 用户实体的创建和JWT的集成

5.1.1 用户模型的设计

在构建基于JWT认证的系统时，首先要设计用户模型，这通常涉及到数据库中用户信息的存储结构。设计一个用户模型时，需要包含基本的认证信息，如用户名、密码以及其它可能的用户资料信息。

下面是一个简单的用户模型的实现示例： 

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;

    // 其他用户信息，例如邮箱、电话等

    // getters and setters
}

在这个用户模型中， id 字段为用户的唯一标识， username 为用户名字段， password 为用户密码。这些基础字段满足了用户登录认证的需求。在实际应用中，可能还会有更多的字段来存储用户的其他信息。

5.1.2 用户服务中JWT的生成与解析

在用户成功认证后，服务端需要生成JWT Token并返回给客户端。这通常由一个服务（如 UserService ）来完成。同样地，当客户端需要访问受保护的资源时，服务端需要解析并验证Token的有效性。

这里是一个简化的JWT生成和验证的实现： 

public class JwtUtil {

    private String secret = "your-secret-key";

    public String generateToken(String username) {
        // JWT Token的构建
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60)) // Token有效期为1小时
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            // Token无效或者过期时会抛出异常
            return false;
        }
    }

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

在这个 JwtUtil 类中， generateToken 方法用于生成Token， validateToken 用于验证Token，而 getUsernameFromToken 用于从Token中解析出用户名。这些方法共同作用于用户认证的流程中，确保了Token的生成与解析逻辑的一致性和安全性。

5.2 JWT工具类的开发与应用

5.2.1 工具类的设计和封装

在实际应用中，为了提高代码的可维护性和复用性，常常将与JWT相关的操作封装成工具类。在本小节中，我们将进一步深入探讨JWT工具类的设计与封装。

首先，我们创建一个 JwtTokenUtil 类，它包含了与JWT操作相关的所有方法。这些方法包括但不限于：

  • createToken : 根据用户信息生成Token；
  • parseToken : 从请求中解析出Token；
  • validateToken : 验证Token是否有效；
  • getTokenBody : 获取Token负载内容；
  • isTokenExpired : 判断Token是否已过期。 
@Component
public class JwtTokenUtil {
    // ... (省略之前提到的方法实现)
}

通过使用 @Component 注解，这个工具类可以被Spring容器管理，从而在需要时进行注入并使用。

5.2.2 在业务逻辑中集成JWT工具类

接下来，我们需要在业务逻辑中集成这个JWT工具类。这通常涉及到登录认证成功后Token的生成，以及每个请求进来时Token的验证。

在Spring Boot的控制器中，我们可以使用 JwtTokenUtil 类来生成Token，并将其返回给客户端： 

@RestController
@RequestMapping("/api")
public class UserController {

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @PostMapping("/login")
    public ResponseEntity<?> createAuthenticationToken(@RequestBody LoginRequest authenticationRequest) throws Exception {
        // 验证用户名和密码
        authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword());

        // 生成Token
        final String token = jwtTokenUtil.generateToken(authenticationRequest.getUsername());
        return ResponseEntity.ok(new JwtResponse(token));
    }

    // ... 其他业务方法 ...
}

在这个 UserController 控制器中，我们通过调用 jwtTokenUtil.generateToken 方法来生成Token，并将它以 JwtResponse 的形式返回给客户端。

5.3 登录接口和过滤器的实战实现

5.3.1 登录接口的后端逻辑实现

登录接口是用户认证过程中非常关键的环节，后端逻辑需要正确处理用户提供的凭证，并在成功认证后生成并返回JWT Token。

登录接口的后端逻辑通常包括以下几个步骤：

  1. 接收用户提交的用户名和密码；
  2. 对用户身份进行验证，一般通过查询数据库来完成；
  3. 验证成功后，生成JWT Token；
  4. 返回Token给客户端。

代码实现示例如下： 

@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest, HttpServletResponse response) {
    // 这里的方法应调用服务层逻辑来处理用户的认证过程
    // 假设认证成功，接下来生成JWT Token并返回给客户端
    String token = jwtTokenUtil.generateToken(loginRequest.getUsername());
    // 例如将Token存储到Cookie中发送到客户端
    response.addHeader("Authorization", "Bearer " + token);

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

5.3.2 JWT验证过滤器的配置与测试

在Spring Boot应用中，过滤器是处理请求和响应的重要组件。为了确保每个请求在被处理前都已进行身份验证，我们通常会实现一个 Filter 来验证JWT Token的有效性。

下面是一个简单的JWT验证过滤器的实现和配置示例： 

public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 从请求中获取Token
        final String requestTokenHeader = request.getHeader("Authorization");
        String username = null;
        String jwtToken = null;

        // 检查请求中是否携带了Token，并符合格式
        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            jwtToken = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(jwtToken);
            } catch (IllegalArgumentException e) {
                // 记录错误日志，Token格式错误
            } catch (ExpiredJwtException e) {
                // 记录错误日志，Token已过期
            }
        }

        // 如果用户名不为空，说明Token有效，将用户名设置到请求属性中供后续使用
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 验证Token有效并设置认证信息到上下文中
            if (jwtTokenUtil.validateToken(jwtToken, username)) {
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

在Spring Security配置中注册这个过滤器： 

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

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

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

通过在 WebSecurityConfig 类中添加 jwtRequestFilter 到过滤器链中，每个请求在到达控制器之前都会经过这个过滤器进行JWT验证。

5.4 权限注解在控制器中的应用

5.4.1 自定义权限注解的开发

为了简化控制器方法的安全性控制，我们可以开发自定义的权限注解。这个注解可以用来标记需要进行用户认证或授权检查的方法。

下面是一个自定义权限注解 Secured 的实现： 

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Secured {
    String[] value() default {};
}

这个 Secured 注解可以使用在控制器的方法上，并可设置不同的角色权限值。然后，我们可以创建一个 SecuredAspect 类来实现切面逻辑，以处理 Secured 注解的行为： 

@Aspect
@Component
public class SecuredAspect {

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Around("@annotation(com.yourpackage.Secured)")
    public Object secure(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取请求中的Token，进行验证，并获取认证的用户信息
        // ...

        // 检查用户是否有权限访问这个方法
        // ...

        // 如果验证和权限检查通过，则执行实际的方法调用
        return joinPoint.proceed();
    }
}

5.4.2 注解在控制器方法中的应用案例

在控制器方法中使用上面定义的 Secured 注解，可以控制访问权限。例如，我们有一个管理用户的API端点，它应该只允许具有管理员角色的用户访问： 

@RestController
@RequestMapping("/api")
public class UserController {

    @Secured({"ROLE_USER", "ROLE_ADMIN"})
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        // 实现获取用户信息的逻辑
    }

    // ... 其他控制器方法 ...
}

5.4.3 权限控制的全局配置与测试

在Spring Security中，还可以通过实现 GlobalMethodSecurityConfiguration 类来全局配置方法级别的安全性。这个配置类允许定义默认的访问规则，以及如何解析和应用权限注解。 

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Override
    protected AccessDecisionManager accessDecisionManager() {
        // 配置访问决策管理器，例如使用AffirmativeBased策略
        return new AffirmativeBased(getAccessDecisionVoters());
    }

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        // 配置方法安全表达式处理程序
        return new OAuth2MethodSecurityExpressionHandler();
    }
}

通过这种方式，我们能够控制对特定方法的访问，并实现细粒度的权限控制，以确保应用的安全性。

这样，就完成了一个完整的实战应用案例，其中包括了用户实体的创建和JWT的集成、JWT工具类的开发与应用、登录接口和过滤器的实现，以及权限注解在控制器中的应用。通过这些步骤，我们确保了认证流程的安全性，并且为保护API接口提供了强大的保障。

6. JWT性能优化与安全性加固策略

6.1 JWT性能优化措施

性能优化是保障系统稳定运行和快速响应的关键。对于基于JWT的认证体系而言，优化可以从减少Token大小、优化Token生成速度、以及提升验证效率等方面入手。

6.1.1 Token压缩技术

由于JWT通常较大，我们可以采用压缩技术来减小Token的体积。例如，使用GZIP压缩Payload部分，这样可以减少网络传输的数据量，加快客户端与服务器之间的交互速度。

6.1.2 快速Token生成策略

JWT的生成是需要消耗一定资源的，尤其是当大量的用户同时登录时，生成JWT的性能瓶颈就会显现出来。通过优化算法、提升硬件配置或使用高效的第三方库来加速Token的生成是很有必要的。例如，在Java中可以使用 Java JWT 库来替代传统的Base64算法，以提高效率。

6.1.3 缓存机制的引入

在验证Token时，如果每次都进行完整的解码和校验，无疑会消耗较多的系统资源。对于已验证的有效Token，可以缓存其关键信息，比如用户的唯一标识符和角色信息，以减少重复校验，提高响应速度。

6.2 JWT安全性加固策略

安全性是任何认证机制都必须重视的问题，对于JWT来说，安全性加固尤为重要。

6.2.1 加强密钥管理

Signature是JWT安全性的关键，一个安全的密钥管理策略至关重要。定期更换密钥、使用更长的密钥长度、采用动态密钥等都是提升安全性的方式。还可以通过引入密钥管理服务，来实现密钥的自动轮换和集中管理。

6.2.2 防止Token泄露

对于存储在客户端的Token，必须采取措施防止泄露。比如，限制Token的跨域请求、为Token设置HttpOnly属性、限制Token的有效期等。此外，对于敏感操作，应实施二次验证机制。

6.2.3 实施CSRF保护

跨站请求伪造（CSRF）攻击是一种常见的Web攻击手段。为了防止CSRF攻击，可以在生成JWT时加入CSRF令牌，并在每次请求时校验这个令牌。这要求服务端和客户端都必须实现相应的逻辑。

6.3 JWT在分布式系统中的挑战与应对策略

在分布式系统中，由于系统组件的分散性，传统的集中式Token管理方式难以适应。因此，如何在分布式环境下管理JWT成为了一个需要解决的问题。

6.3.1 使用集中式认证服务

将认证服务独立出来，作为分布式系统中的一个微服务，可以统一处理Token的生成、验证以及撤销。例如，使用OAuth2.0协议，配合JWT作为访问令牌，能够很好地解决跨服务的认证问题。

6.3.2 Token存储的分布式解决方案

Token的存储是分布式系统中的另一个挑战。可以将Token存储在分布式缓存系统（如Redis）中，利用缓存的高可用性和分布式特性，实现快速的读写操作。还可以结合分布式锁，确保Token在多节点环境下的安全更新和撤销。

6.3.3 实现Token刷新机制

为了避免用户长时间使用同一Token导致的安全风险，可以引入Token刷新机制。即在Token即将过期时，自动或通过API调用延长Token的有效期。这样既保证了用户体验，也加强了安全性。

在上述章节中，我们从优化JWT性能和安全性出发，提供了一系列实用的策略和措施。同时，针对分布式系统的特点，提出了相应的解决方案。这些措施和方案能够帮助我们构建出更为高效和安全的基于JWT的认证体系。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：本实战教程详细讲解了JWT认证机制的原理和流程，并展示了如何在Spring Boot框架中整合JWT实现用户认证。从JWT的三部分构成（Header、Payload、Signature）到认证流程的各个环节（用户登录、身份验证、Token返回与验证、授权决策），再到在Spring Boot中的整合应用（依赖添加、安全配置、Token生成与处理、过滤器实现、权限控制）都将被逐步展开。通过具体的应用场景，如用户实体创建、JWT工具类编写、登录接口实现、过滤器实现以及权限注解应用，学习者能够掌握将JWT认证机制应用于实际项目的能力，确保Web应用和API的安全性。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

Logo
天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

graphify 视频音视频转写全流程解析：从 detect 结果到知识图谱文档的 Step 2.5

graphify 的核心能力是把任意语料（代码、文档、PDF、图片）转化为可查询的知识图谱，而视频与音频文件无法被直接阅读，必须先把它们转写成文本。本文围绕 `graphify` 运行手册中的转写参考文档 [transcribe.md](https://link.gitcode.com/i/d3285781588e0f1b84886dfdbc4fe7f6)，完整讲解 "Step 2.5 - Tra

avatar 天工造物局

ML-For-Beginners 终章：经典机器学习在金融、医疗、零售等八大行业中的真实落地场景

本篇技术指南基于开源课程仓库 ML-For-Beginners 的收尾课程《Postscript: Machine learning in the real world》（对应仓库目录 [9-Real-World/1-Applications](https://link.gitcode.com/i/6b23002df80861c20abf34d7db63ef41)）编写。该课此前 11 周的教学带

avatar 天工造物局

graphify 知识图谱查询实战：query / path / explain 与可审计的答案闭环

本指南以 graphify 的 Trae 版查询技能参考（[graphify/skills/trae/references/query.md](https://link.gitcode.com/i/72a7875d46ec6d3706d31791f3cdcbe0)）为主体，系统讲解如何针对**已构建好的知识图谱**执行三类查询：语义相关节点遍历（query）、两概念间最短路径（path）、单节点关

avatar 天工造物局