Spring3 注解 @ ComponentScan 、 @ Configuration 、 @ Bean 、 @ Scope

1. Anotación @ComponentScan

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
    <context:component-scan base-package=“com.mengma”/>
 
</beans>

Como aprendí en Spring 2.5, <context: component-scan> recorrerá todas las definiciones de tipo en la ruta com.mengma, buscará las clases marcadas con las anotaciones correspondientes y las agregará al contenedor IoC. <context: component-scan> Los tipos de anotación de escaneo son @Component y refinados @Contoller, @Service y @Repository, y <context: component-scan>, también registrará AutowiredAnnotationBeanPostProcessor y CommonAnnotationBeanPostProcessor en el contenedor, por lo que @Autowired y @Resource también pueden satisfacer la inyección de dependencia. 

1. @ComponentScan ("net.quickcodes. *") Es similar a esta línea en el archivo de configuración: <contexto: component-scan base-package = "com.mengma" />
2. ¿Qué es la anotación @ComponentScan? @ComponentScan es principalmente para definir la ruta de exploración y descubrir que la clase que se debe ensamblar se ensambla automáticamente en el contenedor de frijoles de primavera;
3. Los estudiantes que hayan realizado desarrollo web deben haber usado anotaciones @Controller , @Service , @Repository . Verifique su código fuente y encontrará que hay una anotación común @Component entre ellos . Sí, las anotaciones @ComponentScan se instalarán de manera predeterminada. , @Service, @Repository, @Autowired, @Resource, @Component anotó clases en el contenedor de muelles;
4. Parámetros anotados por @ComponentScan:

• valor: ruta de exploración;
• basePackages: igual que el atributo de valor;
• basePackageClasses: agrega múltiples clases en la matriz especificada al contenedor spring;
• includeFilters: 
• excludeFilters:

   Uso:   

• Bajo la ruta de escaneo automático, @Controller, @Service, @Repository, @Component se agregan anotaciones al contenedor de resortes;

• Agregue la clase que no tiene las anotaciones anteriores en la ruta de exploración al contenedor de resorte a través de includeFilters;

• Use excludeFilters para filtrar las clases que no necesitan agregarse a los contenedores de resorte;

• Personalice el método de anotación para agregar la anotación @Component;

Dos, anotación @Configuration 

       

1. Por definición, el  @Configuration comentario sobre la naturaleza o  @Component, por lo tanto  <context:component-scan/> , o  @ComponentScan puede manejar @Configuration clases anotadas.
2. @Configuration La clase marcada debe cumplir los siguientes requisitos:

•           La clase de configuración debe proporcionarse en forma de clase (no puede ser una instancia devuelta por un método de fábrica), que permite la mejora en tiempo de ejecución mediante la generación de subclases (proxy dinámico cglib);
•           La clase de configuración no puede ser una  final clase (sin proxy dinámico);
•           @Configuration no puede ser una clase anónima;
•           Las anotaciones de configuración se usan generalmente para @Bean generar clases administradas por contenedor Spring a través de  anotaciones;
•           La clase de configuración debe ser no local (es decir, no se puede declarar en un método y no puede ser privada);
•           Cualquier clase de configuración anidada debe declararse comostatic；
•     @Bean El método a su vez no puede crear más clases de configuración (es decir, si el bean devuelto viene con él  @Configuration, no será tratado especialmente, solo se usará como un bean ordinario);

   3. @ La configuración está marcada en la clase, lo que equivale a usar esta clase como el archivo de configuración xml de spring. Su <beans>función es configurar el contenedor de spring (contexto de la aplicación) 

package com.dxz.demo.configuration;
 
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class TestConfiguration {
    public TestConfiguration() {
        System.out.println("TestConfiguration容器启动初始化。。。");
    }
}

Equivalente a: 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd" default-lazy-init="false">
 
 
</beans>

En términos generales, en la clase de configuración, @Configuration y @Bean se usan al mismo tiempo; 

           

Además

(1) Introduzca @ComponentScan en la ruta de escaneo en @configuration 

 

(2) Introducir el archivo de configuración xml de spring en @configuration 

    

 (3) Introducir el archivo de configuración de propiedades de spring en @configuration

     

(4) Introducir otra configuración de anotación en @configuration 

       

(5) @configuration nesting (la configuración anidada debe ser una clase estática)

       Al anidar las clases de configuración de las clases de configuración, se logra el propósito de combinar varias clases de configuración. Pero tenga en cuenta que la clase interna debe ser una clase estática.

        

Tres, anotación de Bean 

   En la forma anterior de usar la configuración XML, el bean es así: 

<bean id="person" class="com.mengma.assembly.Person" />

El formulario de configuración basado en JavaConfig es este: 

@Configuration
public class Appconfig{
    @Bean
    public Person person(){
        return new Person();
    }
}

En xml, la relación de dependencia entre bean y bean se configura así: 

<!--DAO配置-->
	<bean id="userDAO" class="com.hisu.daoImpl.UserDAOImpl" scope="singleton">
		...
	</bean>
	<!--service配置-->
	<bean id="userService" class="com.hisu.serviceImpl.UserServiceImpl">
		<property name="userDAO">
			<ref bean="userDAO"/>
		</property>
	</bean>

Ahora, el formulario de configuración basado en JavaConfig es así: 

@Configuration
public class Appconfig{
    @Bean
    public UserDAO userDAO(){
        return new UserDAO();
    }

    @Bean
    public UserService userService(){
        return new UserService(userDAO());
    }
}

Nota: Creo que la mayoría de las personas  pensarán que el  método devuelto aquí  puede no ser el mismo objeto que el método   anterior cuando  ven la  mockService() llamada  anterior  , por lo que este método se puede usar en lugar de dependencyService()DependencyService@BeanDependencyService

@Autowired
private DependencyService  dependencyService;

De hecho, no es necesario hacerlo, el dependencyServicemétodo call () directo  devuelve la misma instancia.

1. Ámbito de uso: @Bean es una anotación a nivel de método (método que devuelve una instancia), que es equivalente al archivo de configuración xml en primavera <bean>, y su función es: registrar un objeto bean, utilizado principalmente en clases anotadas de @Configuration Se puede usar en las clases anotadas @Component.
2. @Bean sin parámetros: la identificación del bean agregado es el nombre del método, y el tipo es el tipo de valor de retorno del método;
3. @Bean (name = "testBean") toma parámetros: la identificación del bean agregado es testBean, y el tipo es el tipo de valor de retorno del método;
4. El alcance predeterminado de la anotación @Bean es el alcance singleton, que @Scope puede establecer como alcance prototipo ("prototipo"); 
5. Si la definición de un bean depende de otros beans, llame directamente al método de creación del bean dependiente en la clase JavaConfig correspondiente.

Cuarto, @Scope: soporte de atributo @Bean

@Scope establece cómo el contenedor Spring crea una nueva instancia de Bean (método, debe haber @Bean). 
Sus tipos de configuración incluyen:

Singleton (singleton, solo hay una instancia de bean en un contenedor Spring, modo predeterminado), 
Protetype (cada llamada crea un nuevo bean)