Spring 在运行时选择 bean 实现

Question

我正在使用 Spring 个带有注释的 Bean，我需要在运行时选择不同的实现。

@Service
public class MyService {
   public void test(){...}
}

例如windows的平台我需要MyServiceWin extending MyService，linux的平台我需要MyServiceLnx extending MyService.

目前我只知道一个糟糕的解决方案：

@Service
public class MyService {

    private MyService impl;

   @PostInit
   public void init(){
        if(windows) impl=new MyServiceWin();
        else impl=new MyServiceLnx();
   }

   public void test(){
        impl.test();
   }
}

请考虑我只使用注释而不是 XML 配置。

Answer 1

您可以将 bean 注入移动到配置中，如：

@Configuration
public class AppConfig {

    @Bean
    public MyService getMyService() {
        if(windows) return new MyServiceWin();
        else return new MyServiceLnx();
    }
}

或者，您可以使用配置文件 windows 和 linux，然后使用 @Profile 注释对您的服务实现进行注释，例如 @Profile("linux") 或 @Profile("windows")，并为您的申请提供其中一份资料。

Answer 2

1。实施自定义 `Condition`

public class LinuxCondition implements Condition {
  @Override
  public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    return context.getEnvironment().getProperty("os.name").contains("Linux");  }
}

与 Windows 相同。

2。在 `Configuration` class

中使用 @Conditional

@Configuration
public class MyConfiguration {
   @Bean
   @Conditional(LinuxCondition.class)
   public MyService getMyLinuxService() {
      return new LinuxService();
   }

   @Bean
   @Conditional(WindowsCondition.class)
   public MyService getMyWindowsService() {
      return new WindowsService();
   }
}

3。照常使用`@Autowired`

@Service
public class SomeOtherServiceUsingMyService {

    @Autowired    
    private MyService impl;

    // ... 
}

Answer 3

使用 @Qualifier 注释将您的所有实现自动装配到工厂中，然后 return 您需要的服务 class 来自工厂。

public class MyService {
    private void doStuff();
}

我的 Windows 服务：

@Service("myWindowsService")
public class MyWindowsService implements MyService {

    @Override
    private void doStuff() {
        //Windows specific stuff happens here.
    }
}

我的 Mac 服务：

@Service("myMacService")
public class MyMacService implements MyService {

    @Override
    private void doStuff() {
        //Mac specific stuff happens here
    }
}

我的工厂：

@Component
public class MyFactory {
    @Autowired
    @Qualifier("myWindowsService")
    private MyService windowsService;

    @Autowired
    @Qualifier("myMacService")
    private MyService macService;

    public MyService getService(String serviceNeeded){
        //This logic is ugly
        if(serviceNeeded == "Windows"){
            return windowsService;
        } else {
            return macService;
        }
    }
}

如果你想变得非常棘手，你可以使用枚举来存储你的实现 class 类型，然后使用枚举值来选择你想要的实现 return。

public enum ServiceStore {
    MAC("myMacService", MyMacService.class),
    WINDOWS("myWindowsService", MyWindowsService.class);

    private String serviceName;
    private Class<?> clazz;

    private static final Map<Class<?>, ServiceStore> mapOfClassTypes = new HashMap<Class<?>, ServiceStore>();

    static {
        //This little bit of black magic, basically sets up your 
        //static map and allows you to get an enum value based on a classtype
        ServiceStore[] namesArray = ServiceStore.values();
        for(ServiceStore name : namesArray){
            mapOfClassTypes.put(name.getClassType, name);
        }
    }

    private ServiceStore(String serviceName, Class<?> clazz){
        this.serviceName = serviceName;
        this.clazz = clazz;
    }

    public String getServiceBeanName() {
        return serviceName;
    }

    public static <T> ServiceStore getOrdinalFromValue(Class<?> clazz) {
        return mapOfClassTypes.get(clazz);
    }
}

然后您的工厂可以利用应用程序上下文并将实例拉入它自己的映射中。当您添加新服务时 class，只需向枚举中添加另一个条目，这就是您所要做的。

 public class ServiceFactory implements ApplicationContextAware {

     private final Map<String, MyService> myServices = new Hashmap<String, MyService>();

     public MyService getInstance(Class<?> clazz) {
         return myServices.get(ServiceStore.getOrdinalFromValue(clazz).getServiceName());
     }

      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
          myServices.putAll(applicationContext.getBeansofType(MyService.class));
      }
 }

现在您只需将您想要的 class 类型传递给工厂，它就会为您提供所需的实例。非常有帮助，特别是如果您想使服务通用。

Answer 4

让我们创建漂亮的配置。

假设我们有 Animal 接口，我们有 Dog 和 Cat 实现。我们要写写：

@Autowired
Animal animal;

但是我们应该 return 执行哪个？

那么解决方案是什么？有很多方法可以解决问题。我将写如何一起使用 @Qualifier 和自定义条件。

所以首先让我们创建自定义注释：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
public @interface AnimalType {
    String value() default "";
}

和配置：

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class AnimalFactoryConfig {

    @Bean(name = "AnimalBean")
    @AnimalType("Dog")
    @Conditional(AnimalCondition.class)
    public Animal getDog() {
        return new Dog();
    }

    @Bean(name = "AnimalBean")
    @AnimalType("Cat")
    @Conditional(AnimalCondition.class)
    public Animal getCat() {
        return new Cat();
    }

}

注意我们的bean名字是AnimalBean。 为什么我们需要这个 bean？ 因为当我们注入 Animal 接口时，我们将只写 @Qualifier("AnimalBean")

我们还创建了 自定义注释 以将值传递给我们的 自定义条件 。

现在我们的条件看起来像这样（假设 "Dog" 名称来自配置文件或 JVM 参数或...）

   public class AnimalCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        if (annotatedTypeMetadata.isAnnotated(AnimalType.class.getCanonicalName())){
           return annotatedTypeMetadata.getAnnotationAttributes(AnimalType.class.getCanonicalName())
                   .entrySet().stream().anyMatch(f -> f.getValue().equals("Dog"));
        }
        return false;
    }
}

最后注入：

@Qualifier("AnimalBean")
@Autowired
Animal animal;

Answer 5

MyService.java:

public interface MyService {
  String message();
}

MyServiceConfig.java:

@Configuration
public class MyServiceConfig {

  @Value("${service-type}")
  MyServiceTypes myServiceType;

  @Bean
  public MyService getMyService() {
    if (myServiceType == MyServiceTypes.One) {
      return new MyServiceImp1();
    } else {
      return new MyServiceImp2();
    }
  }
}

application.properties:

service-type=one

MyServiceTypes.java

public enum MyServiceTypes {
  One,
  Two
}

在任何 Bean/Component/Service/etc 中使用。喜欢：

    @Autowired
    MyService myService;
    ...
    String message = myService.message()

Answer 6

简单地使 @Service 注释类成为条件： 仅此而已。 不需要其他显式 @Bean 方法。

public enum Implementation {
    FOO, BAR
}

@Configuration
public class FooCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Implementation implementation = Implementation.valueOf(context.getEnvironment().getProperty("implementation"));
        return Implementation.FOO == implementation;
    }
}

@Configuration
public class BarCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Implementation implementation = Implementation.valueOf(context.getEnvironment().getProperty("implementation"));
        return Implementation.BAR == implementation;
    }
}

魔法就在这里。条件就在它所属的位置：在执行类.

@Conditional(FooCondition.class)
@Service
class MyServiceFooImpl implements MyService {
    // ...
}

@Conditional(BarCondition.class)
@Service
class MyServiceBarImpl implements MyService {
    // ...
}

然后您可以照常使用 Dependency Injection，例如通过 Lombok 的 @RequiredArgsConstructor 或 @Autowired.

@Service
@RequiredArgsConstructor
public class MyApp {
    private final MyService myService;
    // ...
}

将此放入您的 application.yml:

implementation: FOO

只有用 FooCondition 注释的实现才会被实例化。没有幻影实例化。

Answer 7

只需将我的 2 美分加到这个问题上。请注意，不必像其他答案所示那样实施那么多 java 类。可以简单地使用 @ConditionalOnProperty。示例：

@Service
@ConditionalOnProperty(
  value="property.my.service", 
  havingValue = "foo", 
  matchIfMissing = true)
class MyServiceFooImpl implements MyService {
    // ...
}

@ConditionalOnProperty(
  value="property.my.service", 
  havingValue = "bar")
class MyServiceBarImpl implements MyService {
    // ...
}

将此放入您的 application.yml:

property.my.service: foo

Spring 在运行时选择 bean 实现

Spring choose bean implementation at runtime

java

spring

spring-bean

1。实施自定义 `Condition`

2。在 `Configuration` class

3。照常使用`@Autowired`

Spring 在运行时选择 bean 实现

Spring choose bean implementation at runtime

java

spring

spring-bean

1。实施自定义 Condition

2。在 Configuration class

3。照常使用@Autowired

1。实施自定义 `Condition`

2。在 `Configuration` class

3。照常使用`@Autowired`