Java Web Spring Boot中`ThreadLocal`的常见用法

概念解释

ThreadLocal 是Java中的一个类，用于在多线程环境中为每个线程创建一个独立的变量副本。这意味着每个线程都可以独立地访问和修改自己的变量副本，而不会影响其他线程的变量副本。ThreadLocal常用于存储线程上下文信息，如用户身份、事务ID等，以确保线程安全。

在Spring Boot中，ThreadLocal常用于以下场景：

1. 用户身份管理：在Web应用中，每个请求都由一个线程处理，可以使用ThreadLocal存储当前用户的身份信息。
2. 事务管理：在事务处理中，可以使用ThreadLocal存储当前事务的上下文信息。
3. 日志跟踪：在日志记录中，可以使用ThreadLocal存储请求的唯一标识符，以便在日志中跟踪请求的处理过程。

常见用法

1. 用户身份管理

在Web应用中，可以使用ThreadLocal存储当前用户的身份信息，以便在处理请求时随时获取用户信息。

示例代码：

import org.springframework.stereotype.Component;

@Component
public class UserContextHolder {
    private static final ThreadLocal<User> userThreadLocal = new ThreadLocal<>();

    public static void setUser(User user) {
        userThreadLocal.set(user);
    }

    public static User getUser() {
        return userThreadLocal.get();
    }

    public static void clear() {
        userThreadLocal.remove();
    }
}

// 用户类
class User {
    private String id;
    private String name;

    // getters and setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

// 拦截器，用于在请求开始时设置用户信息
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 假设从请求头中获取用户信息
        String userId = request.getHeader("X-User-Id");
        String userName = request.getHeader("X-User-Name");

        User user = new User();
        user.setId(userId);
        user.setName(userName);

        UserContextHolder.setUser(user);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContextHolder.clear();
    }
}

// 注册拦截器
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 {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInterceptor());
    }
}

// 控制器中使用用户信息
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/user")
    public User getCurrentUser() {
        return UserContextHolder.getUser();
    }
}

2. 事务管理

在事务管理中，可以使用ThreadLocal存储当前事务的上下文信息。

示例代码：

import org.springframework.stereotype.Component;

@Component
public class TransactionContextHolder {
    private static final ThreadLocal<Transaction> transactionThreadLocal = new ThreadLocal<>();

    public static void setTransaction(Transaction transaction) {
        transactionThreadLocal.set(transaction);
    }

    public static Transaction getTransaction() {
        return transactionThreadLocal.get();
    }

    public static void clear() {
        transactionThreadLocal.remove();
    }
}

// 事务类
class Transaction {
    private String id;
    private String status;

    // getters and setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }
}

// 事务管理器
import org.springframework.stereotype.Service;

@Service
public class TransactionService {
    public void beginTransaction() {
        Transaction transaction = new Transaction();
        transaction.setId(UUID.randomUUID().toString());
        transaction.setStatus("ACTIVE");
        TransactionContextHolder.setTransaction(transaction);
    }

    public void commitTransaction() {
        Transaction transaction = TransactionContextHolder.getTransaction();
        if (transaction != null) {
            transaction.setStatus("COMMITTED");
            TransactionContextHolder.clear();
        }
    }

    public void rollbackTransaction() {
        Transaction transaction = TransactionContextHolder.getTransaction();
        if (transaction != null) {
            transaction.setStatus("ROLLED_BACK");
            TransactionContextHolder.clear();
        }
    }
}

// 控制器中使用事务管理
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TransactionController {
    @Autowired
    private TransactionService transactionService;

    @GetMapping("/transaction")
    public String performTransaction() {
        transactionService.beginTransaction();
        try {
            // 执行事务操作
            return "Transaction " + TransactionContextHolder.getTransaction().getId() + " completed successfully.";
        } catch (Exception e) {
            transactionService.rollbackTransaction();
            return "Transaction failed and rolled back.";
        } finally {
            transactionService.commitTransaction();
        }
    }
}

总结

通过以上示例，我们可以看到ThreadLocal在Spring Boot中的常见用法，包括用户身份管理、事务管理和日志跟踪。这些方法可以帮助开发者更好地管理线程上下文信息，确保线程安全，并提高代码的可维护性和可读性。希望这些示例和解释能帮助你更好地理解和使用ThreadLocal。