Spring Boot中如何优雅实现方法调用周期内的对象共享？

针对你遇到的「在process方法调用周期内共享SharedObject，避免参数传递冗余」的需求，推荐以下两种优雅实现方式：

方案一：使用ThreadLocal存储共享对象 #

通过ThreadLocal将SharedObject与当前线程绑定，实现方法调用链内的隐式共享，无需显式传递参数。为了解耦，建议将ThreadLocal封装为独立的Holder组件：

代码实现 #

// 共享对象的Holder组件，统一管理ThreadLocal
@Component
class SharedObjectHolder {
    private final ThreadLocal<SharedObject> holder = new ThreadLocal<>();

    public void set(SharedObject obj) {
        holder.set(obj);
    }

    public SharedObject get() {
        return holder.get();
    }

    public void clear() {
        holder.remove();
    }
}

// 原FirstServiceImpl改造
@Service
class FirstServiceImpl {

    @Autowired
    SecondServiceImpl second;
    @Autowired
    SharedObjectHolder sharedObjectHolder;

    public void process() {
        try {
            SharedObject obj = new SharedObject();
            sharedObjectHolder.set(obj);
            // 初始化SharedObject的业务逻辑
            process2();
        } finally {
            // 必须清理，避免线程池复用导致的对象泄漏或错误共享
            sharedObjectHolder.clear();
        }
    }

    private void process2() {
        SharedObject obj = sharedObjectHolder.get();
        // 使用obj的业务逻辑
        second.process();
    }
}

// 原SecondServiceImpl改造
@Service
class SecondServiceImpl {
    @Autowired
    private SharedObjectHolder sharedObjectHolder;

    public void process() {
        SharedObject obj = sharedObjectHolder.get();
        // 使用obj的业务逻辑
    }
}

优势 #

• 彻底消除参数传递的冗余代码，方法签名更简洁
• SharedObject的生命周期严格绑定process方法调用周期，调用结束后自动清理
• 通过独立Holder组件实现解耦，避免服务类之间的直接依赖

注意事项 #

• 必须在finally块中清理ThreadLocal，否则线程池复用线程时会导致对象被错误复用，引发内存泄漏或业务逻辑错误

方案二：封装上下文对象传递 #

如果希望保留显式依赖传递的可读性，可以将SharedObject（及未来可能新增的共享数据）封装到一个上下文对象中，仅传递该上下文：

代码实现 #

// 自定义上下文对象，封装所有需要共享的数据
class ProcessContext {
    private SharedObject sharedObject;
    // 可扩展添加其他共享字段
    // getters & setters
}

@Service
class FirstServiceImpl {

    @Autowired
    SecondServiceImpl second;

    public void process() {
        ProcessContext context = new ProcessContext();
        SharedObject obj = new SharedObject();
        context.setSharedObject(obj);
        // 初始化逻辑
        process2(context);
    }

    private void process2(ProcessContext context) {
        // 使用context中的SharedObject
        second.process(context);
    }
}

@Service
class SecondServiceImpl {
    public void process(ProcessContext context) {
        SharedObject obj = context.getSharedObject();
        // 业务逻辑
    }
}

优势 #

• 显式传递依赖，代码可读性更强，便于调试和维护
• 上下文对象可扩展，未来新增共享数据无需修改方法签名

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