在运行时更改弹簧豆实现

Question

我有一个接口和多个实现。我正在自动将界面接线以供使用。我需要在运行时选择不同的实现。

public class Util {
  public void getClient();
}

。

public class UtilOne implements Util {
  public void getClient() {...}
}

public class UtilTwo implements Util {
  public void getClient() {...}
}

@Configuration
public class AppConfig {
  
  @Autowired
  @Bean
  @Primary
  public Util utilOne() {
    return new UtilOne();
  }

  @Autowired
  @Bean
  public Util utilTwo() {
    return new UtilTwo();
  }

}

@Component
public class DemoService {

  @Autowired
  private Util util;
}

由于某种原因，如果我们无法将客户端进入UTILONE，则我想在不重新启动应用程序的情况下切换到Utiltwo 我想将DemoService中的util对象更改为Utiltwo对象。 属性active.util将来自数据库，我们可以从UI更新。

Answer 1

它不起作用 - 如果您有一定的实现UTIRE的实现，例如，class sampleclass（这是单身人士），则不能真正将UTIT的实现更改为不同的事物，而无需重新启动应用程序上下文。

因此，我没有这样做，而是建议替代方案。您说，在某些条件下，在运行时评估您要切换实现。它是什么样的条件？是否可以提取此条件决策逻辑？

如果是这样，您可以自动使用特殊的DynamiCutil，该动态可以保留所有utils的参考，并根据条件将所需的UTIL调用：

// represents all possible business 'runtime' outcomes
enum ConditionOutcome {
   A, B, C 
}
interface ConditionEvaluator {
   ConditionOutcome evaluate(); // when called in runtime will evaluate a condition that currently exists in the system
}

interface Util {
   void foo();
   ConditionOutcome relevantOfOutcome();
}

class Utill1Impl implements Util {
   public void foo() {...}
   public ConditionOutcome relevantOfOutcome() {return ConditionOutcome.A;}
}
class Utill2Impl implements Util {
   public void foo() {...}
   public ConditionOutcome relevantOfOutcome() {return ConditionOutcome.B;}
}
class Utill3Impl implements Util {
   public void foo() {...}
   public ConditionOutcome relevantOfOutcome() {return ConditionOutcome.C;}
}

class DynamicUtil {
   private final Map<ConditionOutcome, Util> possibleImpls;
   private final ConditionEvaluator evaluator;

   public class DynamicUtil(List<Util> allImplementations, ConditionEvaluator evaluator) {
      // create a map by calling the 'relevantOfOutcome' per util impl in a loop
    this.evaluator = evaluator;
   }
   
   public void foo() {
      ConditionOutcome key = evaluator.evaluate();
      // pick the relevant implementation based on evaluated key
      possibleImpls.get(key).foo();
   }
}

现在，使用这样的设计，您可以动态地添加新的可能的结果（以及应该实现它们的utils。您在系统中的课程将必须自动dynamicutil，因此有效地您会引入一个额外的间接级别，但会获得灵活性

class SampleClass { // a business class that will need to work with util capable of being changed during the runtime 
   @Autowired
   private DynamicUtil util;
   ... 
}

Answer 2

您可以尝试使用委派代理进行接近。拥有一个主util bean，它只是围绕实际实现包装，并允许在运行时更改其内部代表。此外，您可以创建类似的经理/助手类，该类别持有对所有实际实现bean的参考，以简化它们之间的切换。

@Component
@Primary
public class DelegatingUtil implements Util {
  private Util delegate;

  public void setDelegate(Util delegate){ this.delegate = delegate; }
  public Util getDelegate(){ return delegate; }

  public void getClient() {
    return delegate.getClient();
  }
}

在适用切换逻辑的地方：

  // Use @Named or @Qualifier or any other way to obtain references to actual implementations 
  private Util defaultImpl;
  private Util fallbackImpl;

  @Autowired
  private DelegatingUtil switcher;

  public void switchToFallback(){
    this.switcher.setDelegate(this.fallbackImpl);
  }

请注意，这只是示意图的示例，您应该注意诸如豆类创建订单，预选器注入（也许是条件），初始化等细节。

Answer 3

这是根据您的情况进行的简单方法。主要想法是读取active.util propertyservice tb的属性，并将您的utils包装到route> outeutil：

@Component
public class RouteUtil {

    @Autowired
    private PropertyService propertyService;  

    @Qualifier("one")
    @Autowired
    private Util utilOne;

    @Qualifier("two")
    @Autowired
    private Util utilTwo;

    public void getClient() {
        if ("one".equals(propertyService.read("active.util"))) {
            utilOne.getClient();
        } else {
            utilTwo.getClient();
        }
    }
}

in demoService中：

@Service
public class DemoService {

  @Autowired
  private RouteUtil util;

  // RouteUtil.getClient() ...
}

您可以更改<<<<<<< ：代码> Active.util 要在不重新启动应用程序的情况下选择哪个UTIT在运行时使用。

Answer 4

春季为您提供了我个人不喜欢的解决方案。您可以做的是声明一个

@MyInterface
List<MyIntercase> myimpls

myinterface是您的接口，列表将包含所有实现。但是，我（由于我不喜欢这种解决方案）编写了自己的解决方案，在那里您可以拥有一个由所有实现的静态工厂。因此，您不必注入所有实现，而是按班级名称或自定义的名称从工厂中选择它们。另一个优势是，自定义的名称必须是每个工厂唯一的。因此，可以说您有一些分阶段的过程，在每个阶段，您都有自己的界面和自己的工厂。因此，您可以具有相同的自定义名称，以实现不同的接口。假设您使用文本格式XML，JSON和CSV，并为SAVE-1阶段2阶段3具有一个接口（和相关工厂）。因此，对于每个阶段-X iNteface，您可以使用命令命名JSON，XML和csv，因此您要做的就是具有一个称为<<的变量Code> CurrentType 将保存值之一 - JSON，XML和csv，对于每个阶段，您都可以使用工厂要获得适当的实现：

Stage1Handler handler = stage-1-factory.getInstance(currentValue);
Stage2Handler handler = stage-2-factory.getInstance(currentValue);
Stage3Handler handler = stage-3-factory.getInstance(currentValue);

其中阶段[x]处理程序是您的接口。但这只是一个额外的兴趣。我的解决方案可在开源Mgntutils库中获得。有关此特定锻炼的文章可以在此处找到：春季框架中对“孤儿”豆的非侵入式访问另外，我在图书馆中描述了此功能Javadoc 在这里。可以找到该库为 maven trifact “ https://github.com/michaelgantman/mgnt/releases” rel =“ nofollow noreferrer”> github 包括源代码和javadoc