在 spring boot 单例 bean 场景下，直接通过 nextchain() 动态修改责任链结构会导致多线程间状态污染；本文提供一种基于不可变链、上下文传递与构造器注入的线程安全替代方案。
在 spring boot 单例 bean 场景下，直接通过 nextchain() 动态修改责任链结构会导致多线程间状态污染；本文提供一种基于不可变链、上下文传递与构造器注入的线程安全替代方案。
Spring Boot 默认将 @Service 类注册为单例（Singleton）Bean，这在多数场景下高效且合理。但当责任链（Chain of Responsibility）模式被用于动态构建处理流程时，若链节点本身持有可变的后继引用（如 nextTransactionChain 字段），就会引发严重的线程安全问题：多个线程共享同一组 Bean 实例，一个线程调用 nextChain(...) 修改了链路结构，会直接影响其他线程正在执行的流程——正如问题中 saveTransactionInChain() 与 saveChainTwo() 的冲突所示。
根本原因在于：ValidationChainOne 等实现类将链式关系（nextTransactionChain）作为实例字段维护，破坏了单例 Bean 的无状态性。试图改用 @Scope("request") 并不可行，因为 TransactionChainContext 是单例，它在初始化时就依赖注入了这些 request-scoped Bean，而此时 HTTP 请求上下文尚未建立，导致 No thread-bound request found 异常。
✅ 正确解法是回归责任链的本质设计原则：链结构应在使用时确定，而非运行时动态变更。我们应消除链节点的可变状态，转而通过组合方式静态定义不同链路，并利用轻量级上下文（ChainContext）在线程内安全地传递和转换数据。
✅ 推荐实现：不可变链 + 上下文驱动 + 构造器注入
首先，精简接口，移除危险的 nextChain() 方法：
public interface TransactionChain {
void processChain(ChainContext context);
}
定义线程安全的上下文容器（支持泛型值存取）：
public class ChainContext {
private final Map<string object> attributes = new ConcurrentHashMap();
public <t> T getValue(String name, Class<t> type) {
return type.cast(attributes.get(name));
}
public void setValue(String name, Object value) {
attributes.put(name, value);
}
}</t></t></string>
重构链处理器，封装固定顺序的执行逻辑：
public class ChainProcessor {
private final List<transactionchain> steps;
public ChainProcessor(TransactionChain... steps) {
this.steps = Arrays.asList(steps);
}
public void process(ChainContext context) {
steps.forEach(step -> step.processChain(context));
}
}</transactionchain>
采用构造器注入与 @PostConstruct（或更优的 @Bean 配置）预定义多条独立链：
@Service
public class TransactionChainContext {
private final TransactionChain validationChainOne;
private final TransactionChain validationChainTwo;
private final TransactionChain validationChainThree;
private final TransactionChain validationChainFour;
private final TransactionChain validationChainFive;
// 推荐：使用 final 字段 + 构造器注入（优于 @Autowired 字段注入）
public TransactionChainContext(
TransactionChain validationChainOne,
TransactionChain validationChainTwo,
TransactionChain validationChainThree,
TransactionChain validationChainFour,
TransactionChain validationChainFive) {
this.validationChainOne = validationChainOne;
this.validationChainTwo = validationChainTwo;
this.validationChainThree = validationChainThree;
this.validationChainFour = validationChainFour;
this.validationChainFive = validationChainFive;
}
private final ChainProcessor chainOneProcessor =
new ChainProcessor(validationChainOne, validationChainTwo, validationChainThree);
private final ChainProcessor chainTwoProcessor =
new ChainProcessor(validationChainThree, validationChainFour, validationChainFive);
public void saveTransactionInChain(List<transaction> txnList) {
ChainContext context = new ChainContext();
context.setValue("transactions", txnList);
chainOneProcessor.process(context);
List<transaction> result = context.getValue("transactions", List.class);
// 后续处理...
}
public void saveChainTwo(List<transaction> txnList) {
ChainContext context = new ChainContext();
context.setValue("transactions", txnList);
chainTwoProcessor.process(context);
List<transaction> result = context.getValue("transactions", List.class);
// 后续处理...
}
}</transaction></transaction></transaction></transaction>
链节点实现示例（纯函数式、无状态）：
@Service
public class ValidationChainOne implements TransactionChain {
@Override
public void processChain(ChainContext context) {
List<transaction> transactions = context.getValue("transactions", List.class);
List<transaction> filtered = transactions.stream()
.filter(t -> t.getAmount() > 0)
.collect(Collectors.toList());
context.setValue("transactions", filtered);
}
}</transaction></transaction>
⚠️ 关键注意事项：
- 所有 TransactionChain 实现必须无内部状态（不持任何非 final 实例变量），确保单例复用安全；
- ChainContext 使用 ConcurrentHashMap 或线程局部存储（如需更高性能）保障单次请求内属性隔离；
- 避免 @Autowired 字段注入，优先使用 final 字段 + 构造器注入，提升可测性与明确依赖关系；
- 若链路组合极其复杂，可进一步抽象为 @Configuration 类中声明 @Bean，实现配置化编排。
该方案彻底规避了运行时链结构篡改风险，每个线程拥有独立的 ChainContext 实例，所有链节点仅读写该上下文，天然支持高并发，同时保持代码清晰、可测试、易扩展。
