Instanciation de plusieurs grains de la même classe avec le Printemps, les annotations

Oui, vous pouvez le faire avec une aide personnalisée BeanFactoryPostProcessor mise en œuvre.

Voici un exemple simple.

Supposons que nous avons deux composants. L'une est la dépendance de l'autre.

Première composante:

import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

 public class MyFirstComponent implements InitializingBean{

    private MySecondComponent asd;

    private MySecondComponent qwe;

    public void afterPropertiesSet() throws Exception {
        Assert.notNull(asd);
        Assert.notNull(qwe);
    }

    public void setAsd(MySecondComponent asd) {
        this.asd = asd;
    }

    public void setQwe(MySecondComponent qwe) {
        this.qwe = qwe;
    }
}

Comme vous avez pu le voir, il n'y a rien de spécial au sujet de ce composant. Il a une dépendance sur deux instances différentes de MySecondComponent.

Deuxième composante:

import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Qualifier;


@Qualifier(value = "qwe, asd")
public class MySecondComponent implements FactoryBean {

    public Object getObject() throws Exception {
        return new MySecondComponent();
    }

    public Class getObjectType() {
        return MySecondComponent.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

C'est un peu plus délicat. Voici deux choses à expliquer. Premier - @Qualifier - annotation qui contient des noms de MySecondComponent haricots. C'est un standard, mais vous êtes libre de mettre en place votre propre. Vous verrez un peu plus tard pourquoi.

Deuxième chose à mentionner est l'interface factorybean mise en œuvre. Si bean implémente cette interface, il est prévu de créer d'autres instances. Dans notre cas, il crée des instances avec MySecondComponent type.

La partie la plus délicate est BeanFactoryPostProcessor mise en œuvre:

import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;


public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        Map<String, Object> map =  configurableListableBeanFactory.getBeansWithAnnotation(Qualifier.class);
        for(Map.Entry<String,Object> entry : map.entrySet()){
            createInstances(configurableListableBeanFactory, entry.getKey(), entry.getValue());
        }

    }

    private void createInstances(
            ConfigurableListableBeanFactory configurableListableBeanFactory,
            String beanName,
            Object bean){
        Qualifier qualifier = bean.getClass().getAnnotation(Qualifier.class);
        for(String name : extractNames(qualifier)){
            Object newBean = configurableListableBeanFactory.getBean(beanName);
            configurableListableBeanFactory.registerSingleton(name.trim(), newBean);
        }
    }

    private String[] extractNames(Qualifier qualifier){
        return qualifier.value().split(",");
    }
}

Que fait-il? Il passe par tous les haricots annotée avec @Qualifier, extrait des noms à partir de l'annotation, puis crée manuellement les haricots de ce type avec des noms spécifiés.

Voici un Printemps config:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="MyBeanFactoryPostProcessor"/>

    <bean class="MySecondComponent"/>


    <bean name="test" class="MyFirstComponent">
        <property name="asd" ref="asd"/>
        <property name="qwe" ref="qwe"/>
    </bean>

</beans>

Dernière chose à noter ici est bien que vous peut ce faire, il vous ne devrait pas sauf si c'est un must, car ce n'est pas vraiment le moyen le plus naturel de configuration. Si vous avez plus d'une instance de la classe, il est préférable de coller avec XML de configuration.

J'ai juste eu à résoudre un cas similaire. Cela peut fonctionner si vous pouvez redéfinir la classe.

//This is not a @Component
public class Person {

}

@Component
public PersonOne extends Person {
   public PersonOne() {
       super("Joe", "Smith");
   }
}

@Component
public PersonTwo extends Person {
   public PersonTwo() {
    super("Mary","Williams");
   }
}

Alors utilisez simplement PersonOne ou PersonTwo chaque fois que vous devez autowire une instance spécifique, partout ailleurs suffit d'utiliser la Personne.

Si vous avez besoin d'injecter, dans le nouvel objet créé, des haricots ou des propriétés à partir du printemps, vous pouvez jeter un oeil à la section suivante de code dans lequel j'ai étendu la Espen répondre par l'injection d'un bean qui est créé à partir du printemps contexte:

@Configuration
public class PersonConfig {
@Autowired 
private OtherBean other;
@Bean
public Person personOne() {
return new Person("Joe", "Smith", other);
}
}

Jetez un oeil à cette l'article pour tous les scénarios possible.