【Spring MVC】拦截器、JWT 认证与 ThreadLocal 数据共享笔记

前言

在Spring MVC框架中，拦截器、JWT认证和ThreadLocal工具共同构建了强大的安全与请求处理机制。它们协同工作，确保了应用的安全性、高效性和线程安全。

拦截器（Interceptor）原理

拦截器是 Spring MVC 提供的一种面向切面编程（AOP）机制，用于在请求到达控制器（Controller）之前或之后执行特定的操作。这些操作可能包括但不限于身份验证、权限检查、日志记录、请求/响应修饰等。拦截器的实现遵循责任链模式，当一个请求到来时，它会按顺序经过一系列已配置的拦截器。

以下是一个简化的Spring MVC拦截器（Interceptor）实例，只包含了必要的preHandle和afterCompletion方法，用于在请求处理前后执行操作：

javaimport org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class SimpleInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 如果这里返回false，请求将不会被处理
        return true; // 表示请求应继续被处理
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        // 请求处理完成，但视图还未渲染，可以在此处进行一些处理，比如计算响应时间等
        System.out.println("Request handled, but before view rendering.");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 请求完全处理完毕，无论是否抛出异常，都可以在这里进行清理工作，如关闭资源等
        System.out.println("Request completed and cleaned up.");
        
        // 如果在处理过程中出现异常，ex将不为空
        if (ex != null) {
            System.err.println("An exception occurred during request processing: " + ex.getMessage());
        }
    }
}

为了使用这个拦截器，你需要在Spring MVC的配置中注册它。如果你使用的是Java配置，可以在配置类中添加如下代码：

javaimport org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private SimpleInterceptor simpleInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器，可以指定路径或者排除路径
        registry.addInterceptor(simpleInterceptor)
                .addPathPatterns("/**") // 匹配所有路径
                .excludePathPatterns("/no-intercept/**"); // 排除某些路径
    }
}

这个简单的拦截器会在每次请求到达控制器之前打印一条消息，请求处理完成后（不论是否有异常）打印另一条消息，以及在视图渲染后再次打印一条消息。你可以根据需要扩展这个例子，例如添加实际的日志记录、权限检查或其他业务逻辑。

---

以下是一个简单的Spring MVC拦截器（Interceptor）的示例，演示了如何注册、配置以及实现拦截器的preHandle和afterCompletion方法：

首先，创建一个自定义的拦截器类LoginInterceptor：

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从请求头中获取JWT Token
        String token = request.getHeader("Authorization");

        // 检查Token的有效性
        if (isValidToken(token)) {
            // 设置ThreadLocal中的用户信息
            ThreadLocalUtil.set(getUserInfoFromToken(token));
            return true; // 继续处理请求
        } else {
            // 清除ThreadLocal中的数据，防止泄露
            ThreadLocalUtil.remove();        
            return false; // 停止请求处理，返回401状态码
        }
    }

    private boolean isValidToken(String token) {
        // 这里进行Token有效性验证的逻辑，例如使用JwtUtil进行解析和验证
        return !StringUtils.isEmpty(token) && JwtUtil.validateToken(token);
    }

    private User getUserInfoFromToken(String token) {
        // 从JWT Token中获取用户信息，假设我们有这个方法
        return JwtUtil.getUserInfoFromToken(token);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 清理ThreadLocal中的数据，防止内存泄漏
        ThreadLocalUtil.remove();
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 可选：在目标方法执行后，视图渲染前执行的逻辑
    }
}

接下来，在Spring配置类（例如WebConfig）中注册拦截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器并指定匹配规则
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/api/**") // 匹配所有/api/开头的请求
                .excludePathPatterns("/api/login", "/api/register"); // 排除特定路径
    }
}

这个例子中，LoginInterceptor实现了HandlerInterceptor接口，定义了四个方法：

• preHandle：在请求到达控制器之前执行，用于验证JWT Token并设置ThreadLocal中的用户信息。
• afterCompletion：请求处理完成后，无论preHandle是否返回true，都会调用，用于清理ThreadLocal中的数据。
• postHandle：在目标方法执行后，视图渲染前执行，这里可以进行一些额外的处理。
• handleException：如果在处理请求过程中发生异常，Spring MVC会调用这个方法，但在这里并未实现。

通过上述配置，Spring MVC将在匹配的请求到达控制器之前调用LoginInterceptor，并根据preHandle的返回值决定是否继续处理请求。在请求处理结束后，无论结果如何，都会执行afterCompletion进行清理工作。

JWT（Json Web Token）原理

JWT 是一种开放标准（RFC 7519），用于在各方之间安全地传输信息作为 JSON 对象。

JWT 包含三个部分：头部（Header）、载荷（Payload）、签名（Signature），它们之间由.分隔。

• 头部：描述 JWT 的元数据，如使用的算法（如 HMAC SHA-256）。
• 载荷：携带实际要传递的信息，如用户 ID、用户名、过期时间等。这些信息是经过 Base64 编码的 JSON 对象。
• 签名：使用头部指定的算法，结合密钥，对头部和载荷进行加密运算，确保 JWT 数据的完整性和真实性。

使用场景：在登录过程中，服务器收到正确的用户名和密码后，生成一个包含用户信息的 JWT 并返回给客户端。客户端在后续请求中将此 JWT 放在请求头（如 Authorization 字段）中发送给服务器。服务器端拦截器通过验证 JWT 的签名来确认其有效性，并从载荷中提取用户信息。

---

以下是一个简化的JWT生成和验证的Java示例，使用了jjwt库，这是一个流行的Java库，用于处理JWT：

首先，确保你的项目已经添加了jjwt依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>4.4.0</version>
</dependency>

然后，你可以创建一个简单的JWT生成和验证服务类：

package com.spring.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

import java.util.Date;
import java.util.Map;

public class JwtUtil {

    private static final String KEY = "ajsbxi";

    //接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 4))
                .sign(Algorithm.HMAC256(KEY));
    }

    //接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

}

在这个示例中生成JWT Token (genToken方法):

• 接收一个包含自定义数据的Map<String, Object>作为参数。
• 使用com.auth0.jwt.JWT.create()初始化JWT构建器。
• 通过.withClaim("claims", claims)添加自定义数据到JWT的载荷中。
• 设置JWT的过期时间为当前时间后4小时。
• 使用Algorithm.HMAC256(KEY)指定签名算法及密钥，然后生成最终的JWT字符串。

解析JWT Token (parseToken方法):

• 接收JWT字符串作为输入。
• 使用JWT.require(Algorithm.HMAC256(KEY))设置验证要求，包括签名算法及密钥。
• 调用verify(token)验证JWT的有效性，包括签名是否正确以及是否过期。
• 从验证通过的JWT中提取之前存储的自定义数据，即"claims"对应的值，并转换为Map<String, Object>返回。

ThreadLocal 类与 ThreadLocalUtil 工具类原理

​ ThreadLocal 是 Java 提供的一个类，用于创建线程局部变量。每个线程都有自己的 ThreadLocal 变量副本，各线程之间的 ThreadLocal 变量互不影响。这有助于在多线程环境下实现线程安全的数据传递。

使用 ThreadLocal 的优点：

• 线程隔离：每个线程只能访问到自己的 ThreadLocal 变量副本，不会影响其他线程。
• 简化同步：无需使用 synchronized 关键字或其他同步机制，就能保证线程间数据的隔离性。

ThreadLocalUtil 类的作用：

• 提供了便捷的方法（如 set、get、remove）来操作 ThreadLocal 变量，隐藏了直接使用 ThreadLocal 类的细节。
• 在登录拦截器中，将解析 JWT 得到的用户信息（载荷）存储在 ThreadLocal 中，使得在当前请求的处理过程中（包括后续的过滤器、控制器、服务等），都可以通过 ThreadLocalUtil.get() 获取到这些信息，而无需显式传递参数。
• 在 afterCompletion 方法中清除 ThreadLocal 数据，避免内存泄漏。因为每个线程都有自己独立的 ThreadLocal 变量副本，如果不手动清除，这些副本可能会在请求处理完成后继续占用内存。

下面是一个ThreadLocalUtil工具类实现，以及一个简单的使用示例：

package com.spring.utils;

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

/**
 * ThreadLocal 工具类
 */
@SuppressWarnings("all")
public class ThreadLocalUtil {
    //提供ThreadLocal对象,
    private static final ThreadLocal THREAD_LOCAL = new ThreadLocal();

    //根据键获取值
    public static <T> T get(){
        return (T) THREAD_LOCAL.get();
    }
	
    //存储键值对
    public static void set(Object value){
        THREAD_LOCAL.set(value);
    }


    //清除ThreadLocal 防止内存泄漏
    public static void remove(){
        THREAD_LOCAL.remove();
    }
}

ThreadLocalUtil类：

• private static final ThreadLocal THREAD_LOCAL = new ThreadLocal();：这是全局唯一的ThreadLocal实例，用来存储线程局部变量。
• public static <T> T get(){}：返回ThreadLocal中存储的值，类型泛化为T，以便在不同场景下使用。
• public static void set(Object value){}：将给定的Object值存储到ThreadLocal中。
• public static void remove(){}：清除ThreadLocal中的值，防止内存泄漏，因为如果不清理，每个线程的副本可能会在生命周期结束后仍然占用内存。

使用示例：

package com.spring;

import org.junit.jupiter.api.Test;

/**
 * @author OceanStar
 * @create 2024-04-24 22:46
 */
public class ThreadLocalTest {

    @Test
    public void testThreadLocalSetAndGet(){
        //提供一个线程安全的ThreadLocal对象
        ThreadLocal tl = new ThreadLocal();
        //开启两个线程
        new Thread(()->{
            tl.set("萧炎");
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
        },"蓝色").start();
        new Thread(()->{
            tl.set("药尘");
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
            System.out.println(Thread.currentThread().getName()+"："+tl.get());
        },"绿色").start();
    }
}

ThreadLocalTest测试类：

• @Test注解表示这是一个JUnit测试方法。
• 在testThreadLocalSetAndGet方法中，创建了两个线程，每个线程都有自己的ThreadLocal变量副本。
• 每个线程内部，先设置自己的值（“萧炎"或"药尘”），然后连续获取三次，以证明每次获取到的值都是线程本地的副本。
• 输出结果会显示每个线程有自己的独立副本，不会相互干扰。

这个示例展示了ThreadLocal如何在并发环境中为每个线程提供独立的变量副本，以及如何使用ThreadLocalUtil工具类简化操作。在实际应用中，ThreadLocalUtil通常会封装更复杂的逻辑，例如存储和检索特定类型的对象，或者提供更丰富的操作，如设置默认值、检查是否存在值等。

总结

拦截器、JWT和ThreadLocal在Web开发中扮演关键角色，提供安全认证、请求预处理和线程局部数据管理，强化了应用的安全性、效率和维护性，是构建现代Web服务不可或缺的技术栈。理解和掌握这些技术，对于提升开发质量至关重要。