differenza tra @Component e @Configuration nella primavera 3

Question

Mi sono imbattuto in due annotazioni fornite da Spring 3 (@Component e @Configuration) Sono un po 'confuso tra queste.
Ecco quello che ho letto su @Component

Mettere questo “contesto: componente” nel file di configurazione di fagioli, significa, attivare la funzione di scansione automatica in primavera. Il pacchetto base è dove sono memorizzati i componenti, Spring eseguirà la scansione di questa cartella e individuerà il bean (annotato con @Component) e lo registrerà nel contenitore Spring Spring.

Quindi mi chiedo che cosa è l'uso di @Configuration allora se @Controller registrerà i miei fagioli senza la necessità di dichiararli in configurazione primavera file xml

Answer 1

@Configuration è il cuore della configurazione basato su Java meccanismo introdotto nella primavera 3. Fornisce un'alternativa alla configurazione basata su XML.

Così i seguenti 2 frammenti sono identici:

<beans ...> 
    <context:component-scan base-package="my.base.package"/> 
    ... other configuration ... 
</beans> 

e:

@Configuration 
@ComponentScan(basePackages = "my.base.package") 
public class RootConfig { 
    ... other configuration ... 
} 

In entrambi i casi Spring scansionerà in my.base.package e sotto per classi annotate con @Component o una delle altre annotazioni che sono meta-annotati con @Component come @Service.

Answer 2

Da Book Pro Integrazione Primavera

@Configuration classi sono proprio come normali @Components classi, tranne che i metodi annotati con @Bean vengono utilizzati per i fagioli di fabbrica. Si noti che un @Component con @Bean metodi annotati funziona allo stesso modo, solo che gli ambiti non vengono rispettate ei metodi @Bean sono ri-invocati (senza caching in gioco), in modo @Configuration è preferito, anche se richiede CGLIB

Answer 3

Ecco differenza con piena esempio: -

//@Configuration or @Component 
public static class Config { 
    @Bean 
    public A a() { 
     return new A(); 
    } 
    //**please see a() method called inside b() method** 
    @Bean 
    public B b() { 
     return new B(a()); 
    } 
} 

1) Qui se la classe Config annotato con @configuration, che un metodo() e B(), entrambi si chiamerà volta.

2) Ora se classe Config annotato con @component, di un metodo() verrà chiamato volta ma il metodo b() sarà chiamato due volte.

Problema in (2): - poiché abbiamo notato il problema con l'annotazione @compenent. Questa seconda configurazione (2) è completamente errata perché la molla creerà un bean singleton di A, ma B otterrà un'altra istanza di A che è fuori dal controllo del contesto a molla.

Soluzione: - è possibile utilizzare l'annotazione @autowired con l'annotazione @component all'interno della classe Config.

@Component 
public static class Config { 
    @Autowired 
    A a; 

    @Bean 
    public A a() { 
     return new A(); 
    } 

    @Bean 
    public B b() { 
     return new B(a); 
    } 
} 

Answer 4

Anche se questo è vecchio, ma elaborando risposte JavaBoy e Vijay di, con un esempio:

@Configuration 
public class JavaConfig { 
    @Bean 
    public A getA() { 
     return new A(); 
    } 
} 

@Component 
@ComponentScan(basePackages="spring.example") 
public class Main() { 
    @Bean 
    public B getB() { 
     return new B(); 
    } 
    @Autowired 
    JavaConfig config; 

    public static void main(String[]a) { 
     Main m = new AnnotationConfigApplicationContext(Main.class) 
      .getBean(Main.class); 
     /* Different bean returned everytime on calling Main.getB() */ 
     System.out.println(m.getB()); 
     System.out.println(m.getB()); 
     /* Same bean returned everytime on calling JavaConfig.getA() */ 
     System.out.println(m.config.getA()); 
     System.out.println(m.config.getA()); 
    } 
}