Comment injecter des différents services lors de l'exécution basé sur une propriété avec un Printemps sans XML

Je suis à l'aide de Spring Boot pour Java application autonome. J'ai un haricot qui rend l'utilisation d'un service. Je veux injecter des implémentations différentes de ce service au moment de l'exécution, en fonction d'une propriété dans un fichier de propriétés à Ressort (4).

Cela sonne comme le modèle de Fabrique, mais le Printemps permet aussi d'utiliser des annotations pour résoudre le problème, comme cela.

@Autowired @Qualifier("selectorProperty") private MyService myService;

Puis dans le beans.xml je possède un alias, de sorte que je peux utiliser la propriété dans l' @Qualifier.

<alias name="${selector.property}" alias="selectorProperty" />

Et dans mes différentes implémentations j'aurais les différents qualificatifs.

@Component("Selector1")
public class MyServiceImpl1

@Component("Selector2")
public class MyServiceImpl2

application.propriétés

selector.property = Selector1

selector.property = Selector2

Alors que concernant le modèle de fabrique, au Printemps, vous pouvez utiliser ServiceLocatorFactoryBean pour créer une usine qui vous donnerait la même fonctionnalité.

<bean
  class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean"
  id="myServiceFactory">
  <property
    name="serviceLocatorInterface"
    value="my.company.MyServiceFactory">
  </property>
</bean>

public interface MyServiceFactory
{
    MyService getMyService(String selector);
}

Et puis dans votre bean, vous pouvez utiliser quelque chose comme cela pour obtenir la bonne mise en œuvre lors de l'exécution en fonction de la valeur de la propriété.

@Value("${selector.property}") private String selectorProperty;

@Autowired private MyServiceFactory myServiceFactory;

private MyService myService;

@PostConstruct
public void postConstruct()
{
    this.myService = myServiceFactory.getMyService(selectorProperty);
}

Mais le problème avec cette solution est que je ne pouvais pas trouver un moyen d'éviter l'utilisation de XML pour définir l'usine, et je voudrais utiliser uniquement les annotations.

Donc la question serait, est-il un moyen d'utiliser le ServiceLocatorFactoryBean (ou quelque chose d'équivalent) en utilisant uniquement des annotations, ou suis-je obligé d'utiliser le @Autocâblés @Qualifier façon, si je ne veux pas définir les haricots en XML? Ou est-il un autre moyen pour injecter des différents services lors de l'exécution basé sur une propriété avec Ressort 4 en évitant XML? Si votre réponse est juste utiliser le @Autowired @Qualifier avec l'alias, veuillez donner une raison pourquoi c'est mieux que d'utiliser un bien connu modèle de fabrique.

À l'aide de l'extra XML est en me forçant à utiliser @ImportResource("classpath:beans.xml") dans mon Lanceur de classe, je préfère ne pas l'utiliser.

Grâce.

Avez-vous essayé @Qualificatif("${sélecteur.propriété}")? Il est possible dynamiquement le nom de haricots, de sorte que peut-être il est possible de mettre en place les qualificatifs de cette façon... n'ai pas essayé moi-même mais..
J'ai essayé, mais ça ne fonctionne pas. @Autocâblés @Qualificatif("${sélecteur.propriété}") décide de la valeur null. Il a besoin de l'alias du milieu de l'étape. Merci pour la suggestion de toute façon.
Pas sûr, ce que vous essayez d'archive, avez-vous regardé le printemps de configuration de séparation avec des profils?
Je suis en essayant d'éviter XML à l'aide de la ServiceLocatorFactoryBean. J'ai trouvé un moyen d'obtenir un résultat similaire, mais de ne pas utiliser le modèle de Fabrique (la première moitié de la poste). À moins que quelqu'un me donne une raison de ne pas le faire, j'aimerais utiliser une Usine parce que je pense qu'il va mieux ici.

OriginalL'auteur Pedro Lopez | 2014-10-20

  1. 9

    En fait, vous pouvez utiliser ServiceLocatorFactory sans XML en déclarant comme un haricot dans votre fichier de configuration.

    @Bean
public ServiceLocatorFactoryBean myFactoryServiceLocatorFactoryBean()
{
    ServiceLocatorFactoryBean bean = new ServiceLocatorFactoryBean();
    bean.setServiceLocatorInterface(MyServiceFactory.class);
    return bean;
}

@Bean
public MyServiceFactory myServiceFactory()
{
    return (MyServiceFactory) myFactoryServiceLocatorFactoryBean().getObject();
}

    Alors vous pouvez toujours utiliser de l'usine comme à l'habitude, mais pas de XML est impliqué.

    @Value("${selector.property}") private String selectorProperty;

@Autowired @Qualifier("myServiceFactory") private MyServiceFactory myServiceFactory;

private MyService myService;

@PostConstruct
public void postConstruct()
{
    this.myService = myServiceFactory.getMyService(selectorProperty);
}
    Permettra à l'autowiring MyServiceFactory sans aucun Qualificatif fonctionne même sans créer de nouvelles bean myServiceFactory(). Je doute que le nom de la fonction et le nom de Qualificateur sont liés dans ce cas. Mais oui, dans l'ensemble de votre solution est la bonne.

    OriginalL'auteur Pedro Lopez

  2. 8

    Je suis en utilisant le Printemps profils

    Par exemple avec les sources de données
    En l'utilisant, vous pouvez définir autant de sources de données, comme vous le souhaitez

    @Configuration
@Profile("dev")
public class StandaloneDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }

}

@Configuration
@Profile("cloud")
public class CloudDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }

}

    Et dans l'exécution, en précisant

    -Dspring.les profils.active="mon profil"

    vous active l'une ou l'autre configuration (Tous doivent être importés dans votre Configuration principal, ils sont tout simplement ignorées basé sur le profil actif).

    Voici un bon article:
    http://spring.io/blog/2011/02/14/spring-3-1-m1-introducing-profile/

    J'aime bien cette solution. Bien que dans ce cas particulier, je n'ai pas de profils différents. Je pourrais utiliser quelque chose comme cela, mais alors j'aurais besoin d'un profil différent pour chaque mise en œuvre de mon interface. Si j'ai deux usines, puis il devient malpropre. Merci beaucoup pour la réponse, de toute façon, je pourrais le trouver utile pour une autre chose.
    Vous êtes les bienvenus:)

    OriginalL'auteur mavarazy