java vs - Primavera:@Component versus @Bean




@configuration spring (8)

@Component y @Bean hacen dos cosas muy diferentes, y no deben confundirse.

@Component (y @Service y @Repository ) se utilizan para detectar automáticamente y configurar los beans mediante el escaneo de classpath. Existe una asignación uno a uno implícita entre la clase anotada y el bean (es decir, un bean por clase). El control del cableado es bastante limitado con este enfoque, ya que es puramente declarativo.

@Bean se utiliza para declarar explícitamente un solo bean, en lugar de dejar que Spring lo haga automáticamente como se @Bean arriba. Desacopla la declaración del bean de la definición de clase y le permite crear y configurar los beans exactamente como usted elija.

Para responder tu pregunta...

¿Habría sido posible reutilizar la anotación @Component lugar de introducir la anotación @Bean ?

Claro, probablemente; pero optaron por no hacerlo, ya que los dos son bastante diferentes. La primavera ya es lo suficientemente confusa sin enturbiar aún más las aguas.

Entiendo que la anotación @Component se introdujo en la primavera 2.5 para deshacerse de la definición de bean XML mediante el escaneo de classpath.

@Bean se introdujo en la primavera 3.0 y se puede usar con @Configuration para deshacerse completamente del archivo xml y usar la configuración de Java en su lugar.

¿ @Component sido posible reutilizar la anotación @Component lugar de introducir la anotación @Bean ? Mi entendimiento es que el objetivo final es crear frijoles en ambos casos.


Consideremos que quiero una implementación específica dependiendo de algún estado dinámico. @Bean es perfecto para ese caso.

@Bean
@Scope("prototype")
public SomeService someService() {
    switch (state) {
    case 1:
        return new Impl1();
    case 2:
        return new Impl2();
    case 3:
        return new Impl3();
    default:
        return new Impl();
    }
}

Sin embargo, no hay manera de hacer eso con @Component .


  1. @Component detecta y configura automáticamente los beans mediante la exploración de classpath, mientras que @Bean declara explícitamente un solo bean, en lugar de dejar que Spring lo haga automáticamente.
  2. @Component no desacopla la declaración del bean de la definición de la clase, mientras que como @Bean desacopla la declaración del bean de la definición de la clase.
  3. @Component es una anotación de nivel de clase donde as @Bean es una anotación de nivel de método y el nombre del método sirve como nombre de bean.
  4. No es necesario utilizar @Component con la anotación @Configuration , mientras que la anotación @Bean debe usarse dentro de la clase que se anota con @Configuration .
  5. No podemos crear un bean de una clase utilizando @Component, si la clase está fuera del contenedor de primavera, mientras que podemos crear un bean de una clase utilizando @Bean incluso si la clase está presente fuera del contenedor de spring .
  6. @Component tiene diferentes especializaciones como @Controller, @Repository y @Service, mientras que @Bean no tiene especializaciones .

  • @component y sus especializaciones (@Controller, @service, @repository) permiten la detección automática mediante el escaneo de classpath. Si vemos una clase de componente como @Controller, @service, @repository será escaneada automáticamente por el framework Spring usando la exploración de componente.
  • Por otro lado, @Bean solo se puede usar para declarar explícitamente un solo bean en una clase de configuración.
  • @Bean solía declarar explícitamente un solo bean, en lugar de dejar que Spring lo hiciera automáticamente. Se hace una declaración de frijol de la definición de clase.
  • En resumen, @Controller, @service, @repository son para autodetección y @Bean para crear un bean seprate desde la clase
    - @Controller
    public class LoginController 
    { --code-- }

    - @Configuration
    public class AppConfig {
    @Bean
    public SessionFactory sessionFactory() 
    {--code-- }

@Component Preferible para escaneo de componentes y cableado automático.

¿Cuándo debes usar @Bean ?

A veces la configuración automática no es una opción. ¿Cuando? Imaginemos que desea conectar componentes de bibliotecas de terceros (no tiene el código fuente, por lo que no puede anotar sus clases con @Component), por lo que la configuración automática no es posible.

La anotación @Bean devuelve un objeto que Spring debe registrar como bean en el contexto de la aplicación. El cuerpo del método lleva la lógica responsable de crear la instancia.


@Component Esta es una anotación genérica y se puede aplicar a cualquier clase de la aplicación para convertirla en un componente administrado por resorte (simplemente, el estereotipo genérico para cualquier componente administrado por resorte). cuando la ruta de clase se escanea con la función de exploración de componentes de Spring (@ComponentScan) , identificará las clases anotadas con la anotación @Component (dentro del paquete dado) y creará los beans de dichas clases y las registrará en el ApplicationContext. @Component es una anotación de nivel de clase y su propósito es hacer que la clase sea un componente administrado por resorte y un bean detectable automáticamente para la función de exploración de classpath.

Si desea saber más sobre @Component y otras anotaciones de estereotipos, se recomienda consultar este artículo.

@Bean se utiliza para declarar y registrar explícitamente un bean (como un bean de configuración) en el contenedor Spring IOC que se devuelve desde un método. @Bean es una anotación de nivel de método y se usa dentro de una clase que se anota con @Configuration . Simplemente, la anotación @Bean se utiliza para registrar el bean devuelto por un método como un bean de configuración de resorte en el contenedor IOC. @Bean es solo una anotación de nivel de método y no se puede usar con clases y declaración de objeto.

La anotación @ Bean indica que un método produce un bean que debe ser administrado por el contenedor Spring.

Para declarar un bean, simplemente anote un método con la anotación @Bean . Cuando JavaConfig encuentra un método de este tipo, ejecutará ese método y registrará el valor de retorno como un bean dentro de un ApplicationContext. Por defecto, el nombre del bean será el mismo que el nombre del método. El siguiente es un ejemplo simple de una declaración del método @Bean.

@Configuration
public class ApplicationConfig {

    @Bean
    public User adminUserProfile() {
        return new User("Rami","Nassar");
    }
}

En la clase ApplicationConfig, puede ver que primero usamos la anotación @Configuration para informar a Spring que este es un archivo de configuración basado en Java. Posteriormente, la anotación @Bean se utiliza para declarar un bean Spring y los requisitos de DI. La anotación @Bean es equivalente a la etiqueta, el nombre del método es equivalente al atributo id dentro de etiqueta. Espero que después de leer este artículo, tengas una idea clara sobre el propósito real y el uso de las anotaciones @Bean y @Component .


Cuando se utiliza la etiqueta @Component , es lo mismo que tener un POJO (objeto Java antiguo liso) con un método de declaración de vainilla (anotado con @Bean ). Por ejemplo, el siguiente método 1 y 2 dará el mismo resultado.

Método 1

@Component
public class SomeClass {

    private int number;

    public SomeClass(Integer theNumber){
        this.number = theNumber.intValue();
    }

    public int getNumber(){
        return this.number;
    }
}

con un bean para 'theNumber':

@Bean
Integer theNumber(){
    return new Integer(3456);
}

Método 2

//Note: no @Component tag
public class SomeClass {

    private int number;

    public SomeClass(Integer theNumber){
        this.number = theNumber.intValue();
    }

    public int getNumber(){
        return this.number;
    }
}

Con los frijoles para ambos:

@Bean
Integer theNumber(){
    return new Integer(3456);
}

@Bean
SomeClass someClass(Integer theNumber){
    return new SomeClass(theNumber);
}

El método 2 le permite mantener las declaraciones de los frijoles juntas, es un poco más flexible, etc. Es posible que incluso desee agregar otro frijol SomeClass que no sea de vainilla como el siguiente:

@Bean
SomeClass strawberryClass(){
    return new SomeClass(new Integer(1));
}

su controlador también necesita el ajuste de @Scope ("prototipo")

Me gusta esto:

@Controller
@Scope("prototype")
public class HomeController { 
 .....
 .....
 .....

}






java spring annotations autowired