Personnalisé Autowire candidat haricots au Printemps 3

Source se référant à votre question lorsqu'ils ont créé le ServiceLocatorFactoryBean de retour en version 1.1.4. Pour l'utiliser, vous devez ajouter une interface similaire à celui ci-dessous:

public interface ServiceLocator {
    //ServiceInterface service name is the one 
      //set by @Component
    public ServiceInterface lookup(String serviceName);
}

Vous devez ajouter le code suivant à votre applicationContext.xml

<bean id="serviceLocatorFactoryBean"
    class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean">
    <property name="serviceLocatorInterface"
              value="org.haim.springframwork.stackoverflow.ServiceLocator" />
</bean>

Maintenant votre ServiceThatNeedsServiceInterface sera semblable à celui ci-dessous:

@Component
public class ServiceThatNeedsServiceInterface {
    //What to do here???
    // @Autowired
    // ServiceInterface service;

    /*
     * ServiceLocator lookup returns the desired implementation
     * (ProductAService or ProductBService) 
     */ 
 @Autowired
     private ServiceLocator serviceLocatorFactoryBean;

     //Let’s assume we got this from the web request 
     public RequestContext context;

     public void useService() {
        ServiceInterface service =  
        serviceLocatorFactoryBean.lookup(context.getQualifier());
        service.someMethod();         
      }
}

ServiceLocatorFactoryBean sera de retour le service basé sur le RequestContext qualificatif.
En dehors de printemps annotations votre code n'est pas en dépendait du Printemps.
J'ai exécuté la suite de test unitaire pour les ci-dessus

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:META-INF/spring/applicationContext.xml" })
public class ServiceThatNeedsServiceInterfaceTest {

    @Autowired
    ServiceThatNeedsServiceInterface serviceThatNeedsServiceInterface;

    @Test
    public void testUseService() {
    //As we are not running from a web container
    //so we set the context directly to the service 
        RequestContext context = new RequestContext();
        context.setQualifier("ProductAService");
        serviceThatNeedsServiceInterface.context = context;
        serviceThatNeedsServiceInterface.useService();

        context.setQualifier("ProductBService");
        serviceThatNeedsServiceInterface.context = context;
        serviceThatNeedsServiceInterface.useService();
    }

}

La console d'affichage

Bonjour, Un Service

Bonjour, B Service De

Un mot d'avertissement. La documentation de l'API états qui

“Ce service locators ... sera généralement utilisé pour le prototype de haricots, c'est à dire pour l'usine de méthodes qui sont censés renvoyer une nouvelle instance pour chaque appel... Pour singleton haricots, direct setter ou le constructeur de l'injection de la cible, la fève est préférable.”

Je ne comprends pas pourquoi cela peut causer un problème. Dans mon code il renvoie le même service sur deux séquences d'appels à serviceThatNeedsServiceInterface.useService();

Vous pouvez trouver le code source de mon exemple dans GitHub

Je suppose, que vous avez manqué l'annotation, qui dit printemps, que vous avez un service personnalisé.
Si votre solution est d'ajouter cette annotation avant le nom de la classe:

@Service("ProductAService")
public class ProductAService implements ServiceInterface {
@Override public void someMethod() { 
System.out.println("Hello, A Service"); 
}
}
@Service("ProductBService")
public class ProductBService implements ServiceInterface {
@Override public void someMethod() { 
System.out.println("Hello, B Service"); 
}
}

Et puis vous pouvez auto fil, mais pour utiliser le service, vous devez ajouter l'annotation Qualificatif() comme ceci:

  @Autowired
@Qualifier("ProductBService") //or ProductAService
ServiceInterface service;

Ou peut-être que vous avez à ajouter une annotation Qualificatif("nom de votre bean") 🙂

Je ne pense pas que vous pouvez le faire avec l'annotation, la raison en est, vous avez besoin d'un haricot qui est dynamique sur runtime(peut-être Un service ou B), donc @Autowire sera viré avant le bean est utilisé en tout lieu. Une solution est d'obtenir haricot de contexte lorsque vous en avez besoin.

    @Component
public class ServiceThatNeedsServiceInterface {
ServiceInterface service;
public void useService() {
if(something is something){
service = applicationContext.getBean("Abean", ServiceInterface.class);
}else{
service = applicationContext.getBean("Bbean", ServiceInterface.class);
}
service.someMethod();
}
}

Vous pouvez mettre d'autre logique quelque part dans la classe comme une autre fonction:

public void useService() {
service = findService();
service.someMethod();
}
public ServiceInterface findService() {
if(something is something){
return applicationContext.getBean("Abean", ServiceInterface.class);
}else{
return applicationContext.getBean("Bbean", ServiceInterface.class);
}
}

C'est dynamique, et ce pourrait être ce que vous voulez.