java - mvc - Diferencia entre<context: annotation-config> vs<context: component-scan>



mvc annotation driven spring 5 (9)

Estoy aprendiendo Spring 3 y parece que no entiendo la funcionalidad detrás de <context:annotation-config> y <context:component-scan> .

Por lo que he leído, parecen manejar diferentes anotaciones (@Required, @Autowired etc vs @Component, @Repository, @Service, etc.) pero también de lo que he leído, registran las mismas clases de posprocesadores.

Para confundirme aún más, hay un atributo annotation-config en <context:component-scan> .

¿Alguien puede arrojar algo de luz sobre estas etiquetas? Lo que es similar, lo que es diferente, es uno superado por el otro, se completan entre sí, ¿necesito uno de ellos, ambos?

https://code.i-harness.com


Encontré este buen summary de qué anotaciones son recogidas por qué declaraciones. Al estudiarlo, encontrará que <context:component-scan/> reconoce un superconjunto de anotaciones reconocidas por <context:annotation-config/> , a saber:

  • @Component , @Service , @Repository , @Controller , @Endpoint
  • @Configuration , @Bean , @Lazy , @Scope , @Order , @Primary , @Profile , @DependsOn , @Import , @ImportResource

Como puede ver, <context:component-scan/> extiende lógicamente <context:annotation-config/> con el escaneo de componentes CLASSPATH y las funciones Java @Configuration.


La diferencia entre los dos es realmente simple !.

<context:annotation-config /> 

Le permite usar anotaciones que están restringidas a cablear propiedades y constructores solo de beans.

Donde como

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

Habilita todo lo que <context:annotation-config /> puede hacer, además de usar estereotipos, por ejemplo .. @Component , @Service , @Repository . ¡Así que puedes conectar beans completos y no solo restringidos a constructores o propiedades!


La primavera te permite hacer dos cosas:

  1. Autowiring de frijoles
  2. Autodescubrimiento de habas

1. autowiring
Por lo general, en applicationContext.xml usted define los beans y otros beans se conectan usando métodos de construcción o de establecimiento. Puedes cablear beans usando XML o anotaciones. En caso de que use anotaciones, debe activar las anotaciones y agregar <context:annotation-config /> en applicationContext.xml . Esto simplificará la estructura de la etiqueta de applicationContext.xml , porque no tendrá que cablear manualmente los beans (constructor o definidor). Puede usar la anotación @Autowire y los beans se conectarán por tipo.

Un paso adelante para escapar de la configuración XML manual es

2. Autodiscovery
La detección automática está simplificando el XML un paso más, en el sentido de que ni siquiera es necesario agregar la etiqueta <bean> en applicationContext.xml . Simplemente marque los beans específicos con una de las siguientes anotaciones y Spring conectará automáticamente los beans marcados y sus dependencias al contenedor Spring. Las anotaciones son las siguientes: @Controller , @Service , @Component , @Repository . Al usar <context:component-scan> y apuntar al paquete base, Spring descubrirá automáticamente y conectará los componentes al contenedor Spring.

Como conclusión:

  • <context:annotation-config /> se utiliza para poder usar @Autowired nototation
  • <context:component-scan /> se utiliza para determinar la búsqueda de beans específicos y el intento de conexión automática.

Una etiqueta personalizada <context:component-scan/> registra el mismo conjunto de definiciones de beans que realiza, aparte de su responsabilidad principal de escanear los paquetes java y registrar definiciones de beans desde classpath.

Si, por alguna razón, se debe evitar este registro de definiciones de bean predeterminadas, la forma de hacerlo es especificar un atributo adicional "annotation-config" en la exploración de componentes, de esta manera:

<context:component-scan basePackages="" annotation-config="false"/>

Referencia: http://www.java-allandsundry.com/2012/12/contextcomponent-scan-contextannotation.html


<context:annotation-config> : escaneando y activando anotaciones para beans ya registrados en spring config xml.

<context:component-scan> : registro de Bean + <context:annotation-config>

@Autowired y @Required son objetivos de nivel de propiedad, por lo que el bean debe registrarse en el IOC de primavera antes de usar estas anotaciones. Para habilitar estas anotaciones, debe registrar los beans respectivos o incluir <context:annotation-config /> . es decir, <context:annotation-config /> funciona solo con beans registrados.

@Required habilita la herramienta de procesamiento RequiredAnnotationBeanPostProcessor
@Autowired habilita la herramienta de procesamiento AutowiredAnnotationBeanPostProcessor

Nota: la anotación en sí no tiene nada que ver, necesitamos una herramienta de procesamiento , que es una clase por debajo, responsable del proceso central.

@Repository, @Service y @Controller son @Component , y apuntan a nivel de clase .

<context:component-scan> escanea el paquete y encuentra y registra los beans, e incluye el trabajo realizado por <context:annotation-config /> .



<context:component-scan base-package="package name" /> :

Esto se utiliza para indicar al contenedor que hay clases de bean en mi paquete que analiza esas clases de bean. Para escanear las clases de bean por contenedor encima del bean, tenemos que escribir una de las anotaciones de tipo estéreo como las siguientes.

@Component , @Service , @Repository , @Controller

<context:annotation-config /> :

Si no queremos escribir la etiqueta del bean de forma explícita en XML, entonces, cómo sabe el contenedor si hay un cableado automático en el bean. Esto es posible utilizando la anotación @Autowired . Tenemos que informar al contenedor que hay un cableado automático en mi bean por context:annotation-config .


<context:annotation-config>

Solo resuelve las anotaciones @Autowired y @Qualifer, eso es todo, se trata de la inyección de dependencia . Hay otras anotaciones que hacen el mismo trabajo, creo que @Inject, pero todo a punto de resolver DI a través de anotaciones.

Tenga en cuenta que, incluso cuando haya declarado el elemento <context:annotation-config> , debe declarar a su clase como un Bean de todos modos, recuerde que tenemos tres opciones disponibles

  • XML: <bean>
  • @Annotaciones: @Component, @Service, @Repository, @Controller
  • JavaConfig: @Configuration, @Bean

Ahora con

<context:component-scan>

Hace dos cosas:

  • Escanea todas las clases anotadas con @Component, @Service, @Repository, @Controller y @Configuration y crea un Bean
  • Hace el mismo trabajo que <context:annotation-config> .

Por lo tanto, si declara <context:component-scan> , ya no es necesario declare <context:annotation-config> también.

Eso es todo

Un escenario común fue, por ejemplo, declarar solo un bean a través de XML y resolver el DI a través de anotaciones, por ejemplo

<bean id="serviceBeanA" class="com.something.CarServiceImpl" />
<bean id="serviceBeanB" class="com.something.PersonServiceImpl" />
<bean id="repositoryBeanA" class="com.something.CarRepository" />
<bean id="repositoryBeanB" class="com.something.PersonRepository" />

Solo hemos declarado los beans, nada sobre <constructor-arg> y <property> , el DI se configura en sus propias clases a través de @Autowired. Significa que los Servicios usan @Autowired para sus componentes de Repositories y los Repositories usan @Autowired para JdbcTemplate, DataSource, etc..components


<context:component-scan /> implicitly enables <context:annotation-config/>

intente con <context:component-scan base-package="..." annotation-config="false"/> , en su configuración @Service, @Repository, @Component funciona bien, pero @ Autowired, @ Resource and @Inject no funciona

Esto significa que AutowiredAnnotationBeanPostProcessor no estará habilitado y Spring Container no procesará las anotaciones de Autowiring.





spring-3