Comment AutoWire un objet sans Ressort XML fichier de contexte?

J'ai une Interface avec Component d'annotation et de certaines classes qui l'ont mis en œuvre comme suit:

@Component
public interface A {
}

public class B implements A {
}
public class C implements A {
}

Aussi, j'ai une classe avec un Autowired variable comme ceci:

public class Collector {
    @Autowired
    private Collection<A> objects;

    public Collection<A> getObjects() {
        return objects;
    }
}

Mon fichier de contexte se compose de ces définitions:

<context:component-scan base-package="org.iust.ce.me"></context:component-scan>

<bean id="objectCollector" class="org.iust.ce.me.Collector" autowire="byType"/>

<bean id="b" class="org.iust.ce.me.B"></bean>
<bean id="c" class="org.iust.ce.me.C"></bean>

Et dans la classe principale, j'ai quelques codes comme suit:

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
B b = (B) context.getBean("b");
C c = (C) context.getBean("c");
Collector objectCollector = (Collector) context.getBean("objectCollector");

for (A object : objectCollector.getObjects()) {
    System.out.println(object);
}

De sortie:

org.iust.ce.me.B@1142196
org.iust.ce.me.C@a9255c

Ces codes fonctionnent bien, mais pour certaines raisons, je ne suis pas prêt à utiliser xml fichier de contexte. En dehors de cela, je préfère créer les objets avec le new opérateur plutôt que d'utiliser le getBean() méthode. Néanmoins, depuis la AutoWiring est vraiment une bonne idée dans la programmation, je ne veux pas le perdre.

Maintenant, j'ai deux questions!!

  1. comment puis-je AutoWire classes qui implémente l' A Interface sans utiliser le xml fichier de contexte?
    Est-il possible?
  2. lorsque je change la scope d'un haricot de la singlton à
    prototype comme suit:

    <bean id="b" class="org.iust.ce.me.B" scope="prototype"></bean>

    et d'instancier plusieurs haricots, seul le haricot qui a été instancié lors de la création de context, est injected en AutoWired variable. Pourquoi?

Toute aide sera appréciée.

OriginalL'auteur faghani | 2012-10-08

  1. 9

    Pas sûr de la version de Printemps que vous utilisez. Mais actuellement, vous pouvez utiliser @Configuration à remplacer .xml. Jetez un oeil à @Configuration

    Ci-dessous est le code dans la documentation 

    @Configuration
public class ServiceConfig {
    private @Autowired RepositoryConfig repositoryConfig;
    public @Bean TransferService transferService() {
        return new TransferServiceImpl(repositoryConfig.accountRepository());
    }
}

@Configuration
public interface RepositoryConfig {
    @Bean AccountRepository accountRepository();
}

@Configuration
public class DefaultRepositoryConfig implements RepositoryConfig {
    public @Bean AccountRepository accountRepository() {
        return new JdbcAccountRepository(...);
    }
}

@Configuration
@Import({ServiceConfig.class, DefaultRepositoryConfig.class}) //import the concrete config!
public class SystemTestConfig {
    public @Bean DataSource dataSource() { /* return DataSource */ }
}
public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class);
    TransferService transferService = ctx.getBean(TransferService.class);
    transferService.transfer(100.00, "A123", "C456");
}
    Excellent! Souhaite que je pourrais donner plus de +1 pour ça. Merci pour la recherche et l'affichage du code - ne l'aurais jamais fait si loin dans le document... de Travail fantastique avec Neo4j (via ceci). Encore une fois, merci!

    OriginalL'auteur Willy

  2. 2

    Fourni les classes être gérés ont été correctement annoté, le Printemps peut analyser l'application, les fichiers pour obtenir les informations dont il a besoin, sans xml ou java fichiers de configuration. 

    AnnotationConfigApplicationContext  context = new AnnotationConfigApplicationContext();
context.scan("com.something.something.etc");
context.refresh();
...context.getBean("name_of_bean");

    Note AnnotationConfigApplicationContext est instancié sans aucun argument. context.scan("..."); prend une chaîne de caractères qui indique le Printemps où chercher. paquets

    com.quelque chose.quelque chose.etc.un 
com.comething.quelque chose.etc.deux

    seront analysés, et les classes à l'intérieur de ces paquets annoté avec @Component, @Autowired, etc. sera instatiated et injecté en cas de besoin.

    Cette approche ne semble pas à être bien documentés.

    Essayer de donner plus de commentaires si possible.

    OriginalL'auteur marcus

  3. 0

    1 - Vous devez écrire une autre classe qui va faire l'opération. écrire @Composante de B et de classe C.

    public static void main(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
    InitClass initClass = (InitClass) context.getBean("initClass");  
}


public class InitClass{  
   @Autowired 
   public B b;

   @Autowired 
   public C c;
}

    avec cela, vous obtiendrez B et C, sans l'aide de xml.

    2- http://static.springsource.org/spring/docs/3.0.0.M3/reference/html/ch04s04.html Bean étendues sont détaillées mentionnées ici. Si vous voulez toujours un nouvel objet, vous devez utiliser un prototype, mais la création d'un nouveau sera fait dans les différentes classes. Dans la même classe, vous devez ajouter une nouvelle référence.

    comme

    public class InitClass{
    @Autowired 
    public A a1;

    @Autowired 
    public A a2;

}
    +0.5! Bonne réponse, mais j'ai toujours utiliser XML fichier de contexte. Par ailleurs, dans votre code, les classes qui ont mis en œuvre A Interface ajoutés manuellement à InitClass. Dans mon projet il y a plusieurs classes qui ont mis en œuvre A Interface et je ne veux pas manuellement les gérer.
    Vous devez initialiser le xml au démarrage une fois d'utiliser le Printemps le premier Objet que vous allez accéder à partir de la méthode main doit se faire avec le contexte.getBean les autres seront injectés si @Autocâblés existe. Dynamique de création de nouveaux objets, vous devez utiliser contexte.getBean, je pense qu'il n'y a aucun autre moyen de printemps.
    Je pense que la création du Printemps des haricots avec new opérateur est possible, mais je ne sais pas comment il peut être fait. Un coup d'œil à cette question
    À cette question, il est aussi une réponse, vous devez utiliser des AOP et compiler vos projets avec maven ou ant. Je ne l'ai pas fait avant peut-être que vous devriez regarder pour le lien static.springsource.org/spring/docs/current/... et eclipse.org/aspectj/doc/released/devguide/ltw.html

    OriginalL'auteur sgpalit