动态注入spring bean

Question

在 java-spring web-app 中，我希望能够动态注入 bean。 例如，我有一个具有 2 个不同实现的接口：

在我的应用中，我使用一些属性文件来配置注入：

#Determines the interface type the app uses. Possible values: implA, implB
myinterface.type=implA

我的注入实际上是根据属性文件中的属性值有条件地加载的。例如，在这种情况下，myinterface.type=implA 无论我在哪里注入 MyInterface，将被注入的实现都是 ImplA（我通过扩展 Conditional annotation 实现了这一点）。

我希望在运行时 - 一旦更改属性，将发生以下情况（无需重新启动服务器）：

1. 将注入正确的实现。例如，当设置myinterface.type=implB时，ImplB 将被注入到任何使用 MyInterface 的地方
2. Spring Environment 应该用新值刷新并重新注入到 bean 中。

我想刷新我的上下文，但这会产生问题。 我想也许可以使用设置器进行注入，并在重新配置属性后重新使用这些设置器。有这种要求的工作实践吗？

有什么想法吗？

更新

正如一些人建议的那样，我可以使用一个工厂/注册表，它包含两个实现（ImplA 和 ImplB）并通过查询相关属性返回正确的一个。 如果我这样做了，我还有第二个挑战——环境。例如，如果我的注册表如下所示：

@Service
public class MyRegistry {

private String configurationValue;
private final MyInterface implA;
private final MyInterface implB;

@Inject
public MyRegistry(Environmant env, MyInterface implA, MyInterface ImplB) {
        this.implA = implA;
        this.implB = implB;
        this.configurationValue = env.getProperty("myinterface.type");
}

public MyInterface getMyInterface() {
        switch(configurationValue) {
        case "implA":
                return implA;
        case "implB":
                return implB;
        }
}
}

一旦属性发生变化，我应该重新注入我的环境。有什么建议吗？

我知道我可以在方法中查询该 env 而不是构造函数，但这会降低性能，而且我想考虑一个用于重新注入环境的 ider（再次，也许使用 setter 注入？）。

Answer 1

我会让这个任务尽可能简单。我不是在启动时有条件地加载MyInterface 接口的一个实现，然后触发一个触发同一接口的另一个实现的动态加载的事件，而是以不同的方式解决这个问题，这更容易实现和维护。

首先，我将加载所有可能的实现：

@Component
public class MyInterfaceImplementationsHolder {

    @Autowired
    private Map<String, MyInterface> implementations;

    public MyInterface get(String impl) {
        return this.implementations.get(impl);
    }
}

这个 bean 只是 MyInterface 接口的所有实现的持有者。这里没什么神奇的，只是常见的 Spring 自动装配行为。

现在，无论您需要在哪里注入 MyInterface 的特定实现，都可以借助接口来完成：

public interface MyInterfaceReloader {

    void changeImplementation(MyInterface impl);
}

然后，对于需要通知实现更改的每个类，只需使其实现MyInterfaceReloader 接口即可。例如：

@Component
public class SomeBean implements MyInterfaceReloader {

    // Do not autowire
    private MyInterface myInterface;

    @Override
    public void changeImplementation(MyInterface impl) {
        this.myInterface = impl;
    }
}

最后，您需要一个 bean 来实际更改每个具有 MyInterface 作为属性的 bean 中的实现：

@Component
public class MyInterfaceImplementationUpdater {

    @Autowired
    private Map<String, MyInterfaceReloader> reloaders;

    @Autowired
    private MyInterfaceImplementationsHolder holder;

    public void updateImplementations(String implBeanName) {
        this.reloaders.forEach((k, v) -> 
            v.changeImplementation(this.holder.get(implBeanName)));
    }
}

这只是自动装配所有实现MyInterfaceReloader 接口的bean，并使用新实现更新它们中的每一个，新实现从持有者中检索并作为参数传递。同样，常见的 Spring 自动装配规则。

当你想改变实现时，你应该只调用updateImplementations方法和新实现的bean的名字，这是类的小写驼峰式简单名称，即myImplA或@ 987654334@ 用于课程 MyImplA 和 MyImplB。

您还应该在启动时调用此方法，以便在每个实现 MyInterfaceReloader 接口的 bean 上设置初始实现。

Answer 2

我通过使用 org.apache.commons.configuration.PropertiesConfiguration 和 org.springframework.beans.factory.config.ServiceLocatorFactoryBean 解决了类似的问题：

让 VehicleRepairService 成为一个接口：

public interface VehicleRepairService {
    void repair();
}

以及实现它的 CarRepairService 和 TruckRepairService 两个类：

public class CarRepairService implements VehicleRepairService {
    @Override
    public void repair() {
        System.out.println("repair a car");
    }
}

public class TruckRepairService implements VehicleRepairService {
    @Override
    public void repair() {
        System.out.println("repair a truck");
    }
}

我为服务工厂创建一个接口：

public interface VehicleRepairServiceFactory {
    VehicleRepairService getRepairService(String serviceType);
}

让我们使用 Config 作为配置类：

@Configuration()
@ComponentScan(basePackages = "config.test")
public class Config {
    @Bean 
    public PropertiesConfiguration configuration(){
        try {
            PropertiesConfiguration configuration = new PropertiesConfiguration("example.properties");
            configuration
                    .setReloadingStrategy(new FileChangedReloadingStrategy());
            return configuration;
        } catch (ConfigurationException e) {
            throw new IllegalStateException(e);
        }
    }

    @Bean
    public ServiceLocatorFactoryBean serviceLocatorFactoryBean() {
        ServiceLocatorFactoryBean serviceLocatorFactoryBean = new ServiceLocatorFactoryBean();
        serviceLocatorFactoryBean
                .setServiceLocatorInterface(VehicleRepairServiceFactory.class);
        return serviceLocatorFactoryBean;
    }

    @Bean
    public CarRepairService carRepairService() {
        return new CarRepairService();
    }

    @Bean
    public TruckRepairService truckRepairService() {
        return new TruckRepairService();
    }

    @Bean
    public SomeService someService(){
        return new SomeService();
    }
}

通过使用 FileChangedReloadingStrategy，您的配置会在您更改属性文件时重新加载。

service=truckRepairService
#service=carRepairService

在你的服务中有配置和工厂，让你可以使用属性的当前值从工厂获取合适的服务。

@Service
public class SomeService  {

    @Autowired
    private VehicleRepairServiceFactory factory;

    @Autowired 
    private PropertiesConfiguration configuration;


    public void doSomething() {
        String service = configuration.getString("service");

        VehicleRepairService vehicleRepairService = factory.getRepairService(service);
        vehicleRepairService.repair();
    }
}

希望对你有帮助。

Answer 3

如果我理解正确，那么目标不是替换注入的对象实例，而是在接口方法调用期间使用不同的实现取决于运行时的某些条件。

如果是这样，那么您可以尝试结合ProxyFactoryBean 来查看Sring TargetSource 机制。重点是代理对象会被注入到使用你接口的bean中，所有的接口方法调用都会被发送到TargetSource目标。

我们称之为“多态代理”。

看看下面的例子：

ConditionalTargetSource.java

@Component
public class ConditionalTargetSource implements TargetSource {

    @Autowired
    private MyRegistry registry;

    @Override
    public Class<?> getTargetClass() {
        return MyInterface.class;
    }

    @Override
    public boolean isStatic() {
        return false;
    }

    @Override
    public Object getTarget() throws Exception {
        return registry.getMyInterface();
    }

    @Override
    public void releaseTarget(Object target) throws Exception {
        //Do some staff here if you want to release something related to interface instances that was created with MyRegistry.
    }

}

applicationContext.xml

<bean id="myInterfaceFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="MyInterface"/>
    <property name="targetSource" ref="conditionalTargetSource"/>
</bean>
<bean name="conditionalTargetSource" class="ConditionalTargetSource"/>

SomeService.java

@Service
public class SomeService {

  @Autowired
  private MyInterface myInterfaceBean;

  public void foo(){
      //Here we have `myInterfaceBean` proxy that will do `conditionalTargetSource.getTarget().bar()`
      myInterfaceBean.bar();
  }

}

此外，如果您希望将两个 MyInterface 实现都作为 Spring bean，并且 Spring 上下文不能同时包含两个实例，那么您可以尝试将 ServiceLocatorFactoryBean 与 prototype 目标 bean 范围和 @目标实现类上的 987654331@ 注释。可以使用这种方法代替MyRegistry。

附言 可能 Application Context 刷新操作也可以做你想做的，但它可能会导致其他问题，例如性能开销。

Answer 4

这可能是一个重复的问题，或者至少非常相似，无论如何我在这里回答了这类问题：Spring bean partial autowire prototype constructor

几乎当你想要在运行时为依赖项使用不同的 bean 时，你需要使用原型作用域。然后您可以使用配置返回原型 bean 的不同实现。您将需要处理返回自己的实现的逻辑，（他们甚至可以返回 2 个不同的单例 bean 没关系）但是假设您想要新的 bean，并且返回实现的逻辑在一个名为 @ 的 bean 中987654322@，那么就可以进行配置了：

@Configuration
public class SpringConfiguration
{

    @Bean
    @Autowired
    @Scope("prototype")
    public MyInterface createBean(SomeBeanWithLogic someBeanWithLogic )
    {
        if (someBeanWithLogic .isSomeBooleanExpression())
        {
            return new ImplA(); // I could be a singleton bean
        }
        else
        {
            return new ImplB();  // I could also be a singleton bean
        }
    }
}

永远不需要重新加载上下文。例如，如果您希望在运行时更改 bean 的实现，请使用上述方法。如果你真的需要重新加载你的应用程序，因为这个 bean 被用于单例 bean 的构造函数或一些奇怪的东西，那么你需要重新考虑你的设计，如果这些 bean 真的是单例 bean。您不应该重新加载上下文来重新创建单例 bean 来实现不同的运行时行为，这不是必需的。

编辑 这个答案的第一部分回答了关于动态注入 bean 的问题。如所问，但我认为问题更多的是：'如何在运行时更改单例 bean 的实现'。这可以通过代理设计模式来完成。

interface MyInterface 
{
    public String doStuff();
}

@Component
public class Bean implements MyInterface
{
    boolean todo = false; // change me as needed

    // autowire implementations or create instances within this class as needed
    @Qualifier("implA")
    @Autowired
    MyInterface implA;

    @Qualifier("implB")
    @Autowired
    MyInterface implB;

    public String doStuff()
    {
        if (todo)
        {
            return implA.doStuff();
        }
        else
        {
            return implB.doStuff();
        }
    }   
}

Answer 5

你可以使用@Resource注解注入原来回答here

例如

@Component("implA")
public class ImplA implements MyInterface {
  ...
}

@Component("implB")
public class ImplB implements MyInterface {
  ...
}

@Component
public class DependentClass {

  @Resource(name = "\${myinterface.type}") 
  private MyInterface impl;

}

然后将properties文件中的实现类型设置为-

myinterface.type=implA

Answer 6

请注意 - 如果有兴趣了解的话 - FileChangedReloadingStrategy 使您的项目高度依赖于部署条件：WAR/EAR 应该由容器展开，并且您应该可以直接访问文件系统，这些条件并不总是满足在所有情况和环境中。

Answer 7

您可以在属性值上使用 Spring @Conditional。给两个 Bean 赋予相同的名称，它应该可以工作，因为只会创建一个实例。

在这里查看如何在服务和组件上使用@Conditional： http://blog.codeleak.pl/2015/11/how-to-register-components-using.html