Spring Boot非Web场景下如何实现类Request-Scope的上下文注入？

针对Spring Boot中同时支持HTTP请求和事件流等非HTTP入口的上下文传递需求，可通过自定义线程绑定的作用域实现类似Request-Scope的上下文隔离，无需手动传递元信息到业务层深层。

1. 自定义「EventMessage」作用域实现 #

基于ThreadLocal实现线程级别的上下文隔离，确保每个事件/方法调用拥有独立上下文，同时提供清理方法避免线程复用导致的上下文污染：

public class EventMessageScope implements Scope {
    private final ThreadLocal<Map<String, Object>> contextHolder = new ThreadLocal<>();

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> context = contextHolder.get();
        if (context == null) {
            context = new HashMap<>();
            contextHolder.set(context);
        }
        return context.computeIfAbsent(name, k -> objectFactory.getObject());
    }

    @Override
    public Object remove(String name) {
        Map<String, Object> context = contextHolder.get();
        return context != null ? context.remove(name) : null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {}

    @Override
    public Object resolveContextualObject(String key) { return null; }

    @Override
    public String getConversationId() {
        return Thread.currentThread().getId() + "-" + System.currentTimeMillis();
    }

    // 手动清理上下文，线程复用场景必须调用
    public void clear() {
        contextHolder.remove();
    }
}

2. 注册自定义作用域 #

通过配置类将自定义作用域注册到Spring容器：

@Configuration
public class CustomScopeConfig {
    @Bean
    public static BeanFactoryPostProcessor eventMessageScopeRegistrar() {
        return beanFactory -> beanFactory.registerScope("eventMessage", new EventMessageScope());
    }
}

3. 定义上下文载体类 #

创建包含业务元信息的上下文类，并指定使用自定义的eventMessage作用域，通过代理模式确保注入的是当前线程的上下文实例：

@Scope(value = "eventMessage", proxyMode = ScopedProxyMode.TARGET_CLASS)
@Component
public class EventContext {
    private String userId;
    private Locale locale;
    private Set<String> activeModules;

    // getter & setter
    public String getUserId() { return userId; }
    public void setUserId(String userId) { this.userId = userId; }
    public Locale getLocale() { return locale; }
    public void setLocale(Locale locale) { this.locale = locale; }
    public Set<String> getActiveModules() { return activeModules; }
    public void setActiveModules(Set<String> activeModules) { this.activeModules = activeModules; }
}

4. 不同入口的上下文初始化与清理 #

事件流入口（以Spring Event为例） #

在事件处理器中初始化上下文，执行完业务逻辑后强制清理，避免线程污染：

@Component
public class CustomEventListener {
    @Autowired
    private EventContext eventContext;
    @Autowired
    private EventMessageScope eventMessageScope;
    @Autowired
    private BusinessService businessService;

    @EventListener
    public void handleEvent(CustomBusinessEvent event) {
        try {
            // 从事件中提取元信息初始化上下文
            eventContext.setUserId(event.getUserId());
            eventContext.setLocale(event.getLocale());
            eventContext.setActiveModules(event.getActiveModules());
            // 执行业务逻辑
            businessService.processEventData(event.getData());
        } finally {
            // 必须清理上下文
            eventMessageScope.clear();
        }
    }
}

HTTP请求入口适配 #

通过拦截器将HTTP请求中的元信息同步到EventContext，复用原有Web上下文逻辑：

@Component
public class WebContextSyncInterceptor implements HandlerInterceptor {
    @Autowired
    private EventContext eventContext;
    @Autowired
    private EventMessageScope eventMessageScope;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从请求头/参数中提取元信息
        eventContext.setUserId(request.getHeader("X-User-Id"));
        eventContext.setLocale(request.getLocale());
        eventContext.setActiveModules(extractActiveModules(request));
        return true;
    }

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

    private Set<String> extractActiveModules(HttpServletRequest request) {
        // 自定义提取逻辑，示例从参数中获取
        return Collections.singleton(request.getParameter("activeModule"));
    }
}

记得在配置类中注册拦截器：

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private WebContextSyncInterceptor webContextSyncInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(webContextSyncInterceptor);
    }
}

5. 业务层直接注入使用 #

Service类无需修改原有逻辑，直接注入EventContext即可获取当前上下文的元信息：

@Service
public class BusinessService {
    @Autowired
    private EventContext eventContext;

    public void processEventData(String data) {
        String userId = eventContext.getUserId();
        Locale locale = eventContext.getLocale();
        Set<String> activeModules = eventContext.getActiveModules();
        // 基于元信息执行业务逻辑
    }
}

6. 异步/线程池场景适配 #

如果使用@Async或自定义线程池，需要包装任务以传递上下文并确保清理：

@Component
public class ContextAwareTaskExecutor implements TaskExecutor {
    @Autowired
    private TaskExecutor delegateExecutor;
    @Autowired
    private EventMessageScope eventMessageScope;

    @Override
    public void execute(Runnable task) {
        // 捕获当前线程的上下文快照
        Map<String, Object> currentContext = eventMessageScope.contextHolder.get();
        delegateExecutor.execute(() -> {
            try {
                // 将上下文设置到当前异步线程
                if (currentContext != null) {
                    eventMessageScope.contextHolder.set(new HashMap<>(currentContext));
                }
                task.run();
            } finally {
                eventMessageScope.clear();
            }
        });
    }
}

使用时将@Async的 executor 指定为这个自定义实例即可。

内容的提问来源于stack exchange，提问作者Norbert Koch