如何在Spring Boot中实现运行时深层注入不同实现类？

问题场景 #

我有一个MyInterface接口，包含多个实现类，该接口在应用调用链的深层被使用（调用链为Controller→Service2→Service1→MyInterface），希望在Controller层根据传入的参数（如"impl1"或"impl2"）选择对应的实现类，同时避免逐层传递参数。

现有代码结构如下：

interface MyInterface {
    void doSomething(); // 原do()为Java关键字，此处调整
}

@Component
class Impl1 implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("使用Impl1执行");
    }
}

@Component
class Impl2 implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("使用Impl2执行");
    }
}

@Component
class Service1 {
    private MyInterface myInt;

    public void doService() {
        this.myInt.doSomething();
    }
}

@Component
class Service2 {
    private Service1 service1;

    public void doService() {
        this.service1.doService();
    }
}

@Component
class MyController {
    private Service2 service2;

    public void handleRequest(String impl) {
        // TODO: 如何在这里绑定对应的MyInterface实现，让后续调用链自动使用？
        this.service2.doService();
    }
}

我不想通过逐层传递impl参数的方式实现，期望能在Controller层直接绑定实现，让深层的Service自动使用该实现，类似伪代码：

@Component
class MyController {
    private Provider<Service2> service2Provider;
    private MyInterfaceRegistry myInterfaceRegistry;

    public void handleRequest(String impl) {
        Service2 service2 = service2Provider
            .bind(MyInterface, myInterfaceRegistry.get(impl))
            .get();
        service2.doService();
    }
}

解决方案 #

以下是Spring Boot中可行的几种实现方式：

方式1：ThreadLocal + 工厂类（最简实现） #

核心思路：用ThreadLocal存储当前请求的实现类标识，通过工厂类动态获取对应实例，深层服务依赖工厂而非MyInterface本身。

1. 实现MyInterface工厂类

@Component
public class MyInterfaceFactory {
    private final Map<String, MyInterface> implMap;
    private final ThreadLocal<String> currentImpl = new ThreadLocal<>();

    // Spring自动注入所有MyInterface实现，按Bean名称（默认类名首字母小写）映射
    public MyInterfaceFactory(Map<String, MyInterface> implMap) {
        this.implMap = implMap;
    }

    public void setCurrentImpl(String implName) {
        currentImpl.set(implName);
    }

    public MyInterface getCurrentImpl() {
        String implName = currentImpl.get();
        if (implName == null) {
            throw new IllegalArgumentException("未指定MyInterface实现");
        }
        return implMap.get(implName);
    }

    // 清理ThreadLocal，避免内存泄漏
    public void clear() {
        currentImpl.remove();
    }
}

2. 修改深层服务依赖工厂类

@Component
class Service1 {
    private final MyInterfaceFactory factory;

    public Service1(MyInterfaceFactory factory) {
        this.factory = factory;
    }

    public void doService() {
        factory.getCurrentImpl().doSomething();
    }
}

3. Controller中设置并清理

@Component
class MyController {
    private final Service2 service2;
    private final MyInterfaceFactory factory;

    public MyController(Service2 service2, MyInterfaceFactory factory) {
        this.service2 = service2;
        this.factory = factory;
    }

    public void handleRequest(String impl) {
        try {
            factory.setCurrentImpl(impl);
            service2.doService();
        } finally {
            factory.clear();
        }
    }
}

方式2：RequestScope + 动态代理（贴合Spring容器） #

核心思路：将MyInterface实例设为请求作用域，请求开始时动态注入对应实现，整个请求链中的依赖自动使用该实例。

1. 定义请求作用域的代理Bean

@Component
@RequestScope
public class RequestScopedMyInterface implements MyInterface {
    private MyInterface delegate;

    public void setDelegate(MyInterface delegate) {
        this.delegate = delegate;
    }

    @Override
    public void doSomething() {
        if (delegate == null) {
            throw new IllegalStateException("未设置MyInterface委托实现");
        }
        delegate.doSomething();
    }
}

2. 实现MyInterface注册表（复用Spring BeanFactory）

@Component
public class MyInterfaceRegistry {
    private final BeanFactory beanFactory;

    public MyInterfaceRegistry(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public MyInterface getImpl(String implName) {
        return beanFactory.getBean(implName, MyInterface.class);
    }
}

3. 修改深层服务依赖请求作用域Bean

@Component
class Service1 {
    private final RequestScopedMyInterface myInt;

    public Service1(RequestScopedMyInterface myInt) {
        this.myInt = myInt;
    }

    public void doService() {
        myInt.doSomething();
    }
}

4. Controller中设置委托实现

@Component
class MyController {
    private final Service2 service2;
    private final RequestScopedMyInterface scopedMyInt;
    private final MyInterfaceRegistry registry;

    public MyController(Service2 service2, RequestScopedMyInterface scopedMyInt, MyInterfaceRegistry registry) {
        this.service2 = service2;
        this.scopedMyInt = scopedMyInt;
        this.registry = registry;
    }

    public void handleRequest(String impl) {
        MyInterface targetImpl = registry.getImpl(impl);
        scopedMyInt.setDelegate(targetImpl);
        service2.doService();
    }
}

注：RequestScope Bean由Spring自动管理生命周期，无需手动清理。

方式3：自定义作用域 + ObjectProvider（灵活高级用法） #

适用于非Web场景或需要自定义业务作用域的需求，通过自定义Spring作用域实现线程/业务流程级的实例隔离。

1. 自定义线程作用域

public class ThreadScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadScope = ThreadLocal.withInitial(HashMap::new);

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadScope.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }

    @Override
    public Object remove(String name) {
        return threadScope.get().remove(name);
    }

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

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

    @Override
    public String getConversationId() {
        return Thread.currentThread().getId();
    }

    public void clear() {
        threadScope.get().clear();
        threadScope.remove();
    }
}

2. 注册自定义作用域

@Configuration
public class ScopeConfig {
    @Bean
    public static CustomScopeConfigurer customScopeConfigurer() {
        CustomScopeConfigurer configurer = new CustomScopeConfigurer();
        configurer.addScope("thread", new ThreadScope());
        return configurer;
    }
}

3. 定义线程作用域的代理Bean

@Component
@Scope(value = "thread", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ThreadScopedMyInterface implements MyInterface {
    private MyInterface delegate;

    public void setDelegate(MyInterface delegate) {
        this.delegate = delegate;
    }

    @Override
    public void doSomething() {
        delegate.doSomething();
    }
}

4. Controller使用方式类似方式2，需手动调用ThreadScope.clear()清理作用域。

总结 #

• Web应用优先选择方式2（RequestScope），贴合Spring生态，无需手动清理。
• 非Web应用优先选择方式1（ThreadLocal+工厂），实现成本低，逻辑直接。
• 自定义作用域适合复杂业务场景，但实现和维护成本较高。

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