public class IdUtils {
    // 这样永远拿不到 Bean——IdUtils 自己都没被 Spring 管理，谁来注入？
    @Autowired
    private static SequenceService sequenceService;

    public static String genOrderId() {
        return sequenceService.nextVal("order"); // NPE! sequenceService == null
    }
}

// Spring 源码中的核心结构（简化）
// 文件: org.springframework.web.context.request.RequestContextHolder
public abstract class RequestContextHolder {
    // 每个线程一个独立副本
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder =
            new NamedThreadLocal<>("Request attributes");

    // 可继承的 ThreadLocal——子线程可继承父线程的值
    private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder =
            new NamedInheritableThreadLocal<>("Request context");

    // 获取当前线程绑定的请求属性
    public static RequestAttributes getRequestAttributes() {
        RequestAttributes attributes = requestAttributesHolder.get();
        if (attributes == null) {
            attributes = inheritableRequestAttributesHolder.get();
        }
        return attributes;
    }
}

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Objects;
import java.util.Optional;

public class WebUtils {

    /** 获取当前请求对象，非 Web 环境返回 null */
    public static HttpServletRequest getRequest() {
        return Optional.ofNullable(RequestContextHolder.getRequestAttributes())
                .filter(ServletRequestAttributes.class::isInstance)
                .map(ServletRequestAttributes.class::cast)
                .map(ServletRequestAttributes::getRequest)
                .orElse(null);
    }

    /** 获取当前响应对象 */
    public static HttpServletResponse getResponse() {
        return Optional.ofNullable(RequestContextHolder.getRequestAttributes())
                .filter(ServletRequestAttributes.class::isInstance)
                .map(ServletRequestAttributes.class::cast)
                .map(ServletRequestAttributes::getResponse)
                .orElse(null);
    }

    /** 获取客户端 IP，自动处理反向代理 */
    public static String getClientIp() {
        HttpServletRequest request = getRequest();
        if (request == null) return "unknown";

        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 多级代理取第一个非 unknown 的 IP
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0].trim();
        }
        return ip;
    }

    /** 获取完整请求路径（含 Query String） */
    public static String getFullRequestPath() {
        HttpServletRequest request = getRequest();
        if (request == null) return "";

        String uri = request.getRequestURI();
        String query = request.getQueryString();
        return query == null ? uri : uri + "?" + query;
    }
}

// 在任何 Controller、Service、Utils 中使用
@GetMapping("/order/{id}")
public String getOrder(@PathVariable Long id) {
    String clientIp = WebUtils.getClientIp();
    String fullPath = WebUtils.getFullRequestPath();
    log.info("请求来自 IP: {}，完整路径: {}", clientIp, fullPath);
    return orderService.findById(id);
}

import org.springframework.web.servlet.support.RequestContextUtils;
import org.springframework.web.servlet.FlashMap;

@GetMapping("/dashboard")
public String dashboard(HttpServletRequest request) {
    // 获取当前请求的语言环境（国际化）
    Locale locale = RequestContextUtils.getLocale(request);
    String greeting = messageSource.getMessage("welcome", null, locale);

    // 获取 Flash 属性（RedirectAttributes 带过来的数据）
    Map<String, ?> flashMap = RequestContextUtils.getInputFlashMap(request);
    String successMsg = null;
    if (flashMap != null) {
        successMsg = (String) flashMap.get("successMsg");
    }

    // 获取 WebApplicationContext
    WebApplicationContext ctx = RequestContextUtils.findWebApplicationContext(request);
    // 通过 ctx 可以拿到任何 Spring 管理的 Bean

    model.addAttribute("greeting", greeting);
    model.addAttribute("successMsg", successMsg);
    return "dashboard";
}

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;

public class CurrentUserUtils {

    /** 获取当前认证信息，非登录环境返回 null */
    public static Authentication getAuthentication() {
        return SecurityContextHolder.getContext().getAuthentication();
    }

    /** 获取当前用户 ID */
    public static Long getUserId() {
        Authentication auth = getAuthentication();
        if (auth == null || !auth.isAuthenticated()) {
            return null;
        }
        Object principal = auth.getPrincipal();
        if (principal instanceof UserDetails) {
            // 如果 UserDetails 中存储了用户 ID，解析返回
            // 这里以 username 为 ID 的简化示例
            String username = ((UserDetails) principal).getUsername();
            return Long.valueOf(username);
        }
        // principal 为 "anonymousUser" 或其他字符串时返回 null
        return null;
    }

    /** 获取当前用户名 */
    public static String getUsername() {
        Authentication auth = getAuthentication();
        if (auth == null) {
            return null;
        }
        return auth.getName(); // 通常返回 username
    }

    /** 判断当前用户是否拥有某个角色 */
    public static boolean hasRole(String role) {
        Authentication auth = getAuthentication();
        if (auth == null) return false;
        return auth.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_" + role));
    }
}

@PostMapping("/order/create")
public Result createOrder(OrderDTO dto) {
    Long userId = CurrentUserUtils.getUserId();
    if (userId == null) {
        throw new BizException("未登录");
    }
    orderService.create(userId, dto);
    return Result.success();
}

import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@Service
public class OrderService {

    @Transactional
    public void createOrder(OrderDTO dto) {
        // 1. 数据库操作
        orderDao.insert(order);
        inventoryDao.deduct(order.getItems());

        // 2. 注册事务提交后的回调——而不是直接发 MQ
        TransactionSynchronizationManager.registerSynchronization(
            new TransactionSynchronizationAdapter() {
                @Override
                public void afterCommit() {
                    // 事务提交成功后才发送消息
                    mqProducer.send(new OrderCreatedEvent(order.getId()));
                    // 或者发短信通知用户
                    smsService.send(order.getUserId(), "订单已创建");
                }
            }
        );
    }
}

// 某些场景需要确认当前操作是否被事务包裹
if (TransactionSynchronizationManager.isActualTransactionActive()) {
    log.info("当前在事务 [{}] 中, 只读={}",
        TransactionSynchronizationManager.getCurrentTransactionName(),
        TransactionSynchronizationManager.isCurrentTransactionReadOnly());
} else {
    log.warn("当前操作不在事务中, 可能存在数据一致性问题");
}

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        applicationContext = ctx;
    }

    /** 按类型获取单个 Bean */
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    /** 按名称和类型获取 Bean */
    public static <T> T getBean(String name, Class<T> clazz) {
        return applicationContext.getBean(name, clazz);
    }

    /** 获取指定类型的所有 Bean（包括子类），常用于策略模式 */
    public static <T> Map<String, T> getBeansOfType(Class<T> clazz) {
        return applicationContext.getBeansOfType(clazz);
    }

    /** 获取配置属性 */
    public static String getProperty(String key) {
        return applicationContext.getBean(Environment.class).getProperty(key);
    }

    /** 获取配置属性，带默认值 */
    public static String getProperty(String key, String defaultValue) {
        return applicationContext.getBean(Environment.class).getProperty(key, defaultValue);
    }

    /** 发布 Spring 事件 */
    public static void publishEvent(ApplicationEvent event) {
        applicationContext.publishEvent(event);
    }

    /** 获取 ApplicationContext 本身 */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /** 获取当前激活的 Profile */
    public static String[] getActiveProfiles() {
        return applicationContext.getBean(Environment.class).getActiveProfiles();
    }

    /** 判断某个 Profile 是否激活 */
    public static boolean isProfileActive(String profile) {
        return applicationContext.getBean(Environment.class)
                .acceptsProfiles(org.springframework.core.env.Profiles.of(profile));
    }
}

@Component
public class IdUtils {

    private static SequenceService sequenceService;

    /** 构造器注入——Spring 在创建 IdUtils 这个 Bean 时完成赋值 */
    public IdUtils(SequenceService sequenceService) {
        IdUtils.sequenceService = sequenceService;
    }

    public static String genOrderId() {
        // 序列号服务生成递增序号
        long seq = sequenceService.nextVal("order_seq");
        String datePart = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        return "ORD" + datePart + String.format("%08d", seq);
    }

    // 另一种方式：延迟获取，避免循环依赖
    public static String genOrderIdV2() {
        SequenceService service = SpringContextUtils.getBean(SequenceService.class);
        long seq = service.nextVal("order_seq");
        String datePart = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        return "ORD" + datePart + String.format("%08d", seq);
    }
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

public class OrderCreateRequest {

    @JsonDeserialize(using = ProductIdDeserializer.class)
    private Long productId;
    // ...
}

// Jackson 会 new ProductIdDeserializer()，不走 Spring，@Autowired 无效
public class ProductIdDeserializer extends JsonDeserializer<Long> {

    @Override
    public Long deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
        String productCode = p.getText(); // JSON 传的是 "SKU-20240001"

        // 直接用 SpringContextUtils 获取 Bean
        ProductService productService = SpringContextUtils.getBean(ProductService.class);
        return productService.resolveProductId(productCode);
    }
}

// 接口定义
public interface SmsProvider {
    void send(String phone, String content);
}

@Service("aliyunSms")
public class AliyunSmsProvider implements SmsProvider {
    public void send(String phone, String content) {
        // 调用阿里云短信 API
    }
}

@Service("tencentSms")
public class TencentSmsProvider implements SmsProvider {
    public void send(String phone, String content) {
        // 调用腾讯云短信 API
    }
}

// 工厂类——根据配置返回对应实现
@Component
public class SmsProviderFactory {

    public static SmsProvider get() {
        String provider = SpringContextUtils.getProperty("sms.provider", "aliyun");
        // 按名称获取 Bean
        return SpringContextUtils.getBean(provider + "Sms", SmsProvider.class);
    }
}

// 使用
@Service
public class NotificationService {
    public void sendVerifyCode(String phone, String code) {
        SmsProviderFactory.get().send(phone, "您的验证码是: " + code);
    }
}

@Component
public class SmsRouter {

    // 获取所有 SmsProvider 实现类，Key 为 Bean 名称
    private static final Map<String, SmsProvider> PROVIDERS =
            SpringContextUtils.getBeansOfType(SmsProvider.class);

    public static SmsProvider route() {
        String provider = SpringContextUtils.getProperty("sms.provider", "aliyun");
        return PROVIDERS.get(provider + "Sms");
    }
}

@Component
public class TokenAuthInterceptor implements HandlerInterceptor {

    private final JwtTokenService jwtTokenService;
    private final UserService userService;

    public TokenAuthInterceptor(JwtTokenService jwtTokenService, UserService userService) {
        this.jwtTokenService = jwtTokenService;
        this.userService = userService;
    }

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) {
        String token = request.getHeader("Authorization");
        if (token == null || !token.startsWith("Bearer ")) {
            // 放行，由 Security 或 Controller 层处理认证
            return true;
        }

        try {
            String jwt = token.substring(7);
            Long userId = jwtTokenService.parseUserId(jwt);
            UserDetails user = userService.loadUserById(userId);

            // 方式一：设置 Security 上下文
            UsernamePasswordAuthenticationToken auth =
                    new UsernamePasswordAuthenticationToken(
                            user, null, user.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(auth);

            // 方式二：将用户信息存入 Request 属性（如果不想依赖 Spring Security）
            request.setAttribute("currentUser", user);
            request.setAttribute("userId", userId);

        } catch (Exception e) {
            log.warn("Token 解析失败: {}", e.getMessage());
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler, Exception ex) {
        // 清理 ThreadLocal，防止内存泄漏
        SecurityContextHolder.clearContext();
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @PostMapping
    public Result create(OrderDTO dto) {
        Long userId = CurrentUserUtils.getUserId(); // 从 SecurityContextHolder 拿到
        if (userId == null) {
            throw new UnauthorizedException("请先登录");
        }
        orderService.create(userId, dto);
        return Result.success();
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handle(Exception ex) {
        // 通过 WebUtils 获取当前请求的完整信息
        String clientIp   = WebUtils.getClientIp();
        String requestUri = WebUtils.getFullRequestPath();
        Long   userId     = CurrentUserUtils.getUserId();

        // 将关键上下文随错误日志一起输出
        log.error("全局异常 | IP: {} | URI: {} | 用户ID: {} | 异常类型: {} | 详细信息: ",
                clientIp, requestUri, userId, ex.getClass().getSimpleName(), ex);

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse("SYSTEM_ERROR", "系统内部错误"));
    }
}

@Async
public CompletableFuture<String> asyncProcess() {
    // 在异步线程中，取不到任何 Web 请求信息
    HttpServletRequest req = WebUtils.getRequest();  // null!
    Long userId = CurrentUserUtils.getUserId();       // null!

    // 日志里记录的 IP 是 "N/A"，用户 ID 为空
    log.info("异步处理 | IP: {} | 用户: {}", WebUtils.getClientIp(), userId);
    return CompletableFuture.completedFuture("done");
}

import org.springframework.core.task.TaskDecorator;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

public class ContextCopyingTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 在主线程中捕获上下文（这是构造函数执行时的线程，即调用方线程）
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        SecurityContext    securityContext   = SecurityContextHolder.getContext();

        return () -> {
            try {
                // 在工作线程中恢复上下文
                RequestContextHolder.setRequestAttributes(requestAttributes);
                SecurityContextHolder.setContext(securityContext);

                runnable.run();

            } finally {
                // 清理，防止线程池复用时污染下一次任务
                RequestContextHolder.resetRequestAttributes();
                SecurityContextHolder.clearContext();
            }
        };
    }
}

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");

        // 注入自定义 TaskDecorator
        executor.setTaskDecorator(new ContextCopyingTaskDecorator());

        executor.initialize();
        return executor;
    }
}

@Async
public CompletableFuture<String> asyncProcess() {
    // 现在可以正常获取了
    HttpServletRequest req = WebUtils.getRequest();  // 有值！
    Long userId = CurrentUserUtils.getUserId();       // 有值！

    log.info("异步处理 | IP: {} | 用户: {}", WebUtils.getClientIp(), userId);
    // 输出: 异步处理 | IP: 192.168.1.100 | 用户: 10086
    return CompletableFuture.completedFuture("done");
}

// 正确：核心业务 Service 使用显式传参
@Service
public class OrderService {
    public void create(Long userId, OrderDTO dto) {  // userId 显式传入
        // ...
    }
}

// 正确：Controller 层使用隐式获取用户信息
@PostMapping("/order")
public Result create(OrderDTO dto) {
    Long userId = CurrentUserUtils.getUserId(); // 隐式获取
    orderService.create(userId, dto);           // 显式传递到 Service
    return Result.success();
}

// 错误：Service 层直接隐式获取
@Service
public class OrderService {
    public void create(OrderDTO dto) {
        Long userId = CurrentUserUtils.getUserId(); // 不要这样！
        // Service 的单测需要额外设置 SecurityContextHolder，
        // 而且调用方无法从方法签名看出 userId 的来源
    }
}

@Scheduled(cron = "0 0 2 * * ?") // 每天凌晨 2 点
public void nightlyReport() {
    // 定时任务不在 Web 请求线程中
    HttpServletRequest req = WebUtils.getRequest(); // null!

    log.info("客户端 IP: {}", WebUtils.getClientIp());
    // 输出: 客户端 IP: unknown —— 因为 getClientIp() 内部做了判空保护
}

public static String getClientIp() {
    HttpServletRequest request = getRequest();
    if (request == null) return "unknown"; // 这行判空救了定时任务
    // ...
}