diferencia entre @Component y @Configuration en Spring 3

Question

Encontré dos anotaciones provistas por Spring 3 (@Component y @Configuration) Estoy un poco confundido entre estas.
Esto es lo que he leído sobre @Component

Poner este “contexto: el componente” en el archivo de configuración del frijol, que significa, activar la función de búsqueda automática en la primavera. El paquete base es donde están almacenados sus componentes, Spring escaneará esta carpeta y averiguará el bean (anotado con @Component) y lo registrará en el contenedor Spring.

Así que me pregunto ¿cuál es el uso de @Configuration entonces si @Controller registrará mis granos sin necesidad de declararlos en el archivo XML de configuración de la primavera

Answer 1

@Configuration es el corazón de la configuración basada en Java mecanismo que se introdujo en Spring 3. Proporciona una alternativa a la configuración basada en XML.

Así que los 2 siguientes fragmentos son idénticos:

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

y:

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

En ambos casos primavera escaneará en my.base.package y por debajo para las clases anotado con @Component o una de las otras anotaciones que están meta-anotados con @Component, como @Service.

Answer 2

De Book Pro Integración primavera

@Configuration clases son como @Components clases regulares, excepto que los métodos anotados con @Bean se utilizan para los granos de fábrica. Tenga en cuenta que una @Component con @Bean métodos anotados funciona de la misma manera, excepto que alcances no se respetan y los métodos @Bean se vuelven a invocar (sin almacenamiento en caché en el juego), por lo que se prefiere @Configuration, a pesar de que requiere CGLIB

Answer 3

Aquí está diferencia con pleno ejemplo: -

//@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) Aquí si la clase Config anotado con @configuration, que un método() método y b(), ambos se llamará una vez.

2) Aquí si la clase Config anotado con @component, que un método() será llamado una vez pero el método b() será llamado dos veces.

Problema en (2): - ya que hemos notado el problema con @compenent anotación. Esta segunda configuración (2) es totalmente incorrecta porque Spring creará un bean singleton de A, pero B obtendrá otra instancia de A que está fuera del control de contexto de primavera.

Solución: - podemos usar la anotación @autowired con la anotación @component dentro de la clase 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

Aunque esto es viejo, pero la elaboración de JavaBoy Y de Vijay respuestas, con un ejemplo:

@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()); 
    } 
}