Spring IOC Uso ultra detallado (2) los principiantes deben ver el uso de anotaciones para conectarse a la base de datos mediante ensamblaje automático Inyección de dependencia genérica Prueba de unidad de Spring

Uso de COI (2)

Spring uso ultra detallado (1), el contenido incluye varias formas de obtener componentes, asignar valores a diferentes tipos de atributos, uso de FactoryBean, etc., dirección de entrega: Spring IOC uso ultra detallado (1)

Uso de Spring AOP, dirección de entrega: Uso detallado de Spring AOP

Uno, archivos de propiedades externos de referencia

Utilice el grupo de conexiones de la base de datos C3P0 (la conexión es mysql8)

1. Paquete de guía
   

2. Cree un archivo c3p0.properties en el directorio src, donde el contenido es:

jdbc.username=root
jdbc.password=root
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone = GMT
jdbc.driverClass=com.mysql.jdbc.Driver
//以上key是自定义的，并不是C3P0标准的key

Nota:
(1) nombre de usuario es una palabra clave en Spring. Para evitar que la clave en el archivo de configuración tenga el mismo nombre, puede prefijar la clave en el archivo de configuración
(2) Cuando se conecte a mysql8,
i. Use mysql- connector-java-5.1 .49.jar y superior
ii. La dirección URL debe tener un sufijo

3. Escrito en xml

(1) Utilice el espacio de nombres de contexto para cargar archivos de configuración externos

(2) Escrito en xml

     <!-- location属性固定写法：classpath表示引用类路径下的资源-->
     <context:property-placeholder location="classpath:c3p0.properties"/>
    
     <!-- 创建一个数据库连接池 -->
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
       <!-- ${key}动态取出配置文件中某个key对应的值 -->
    
       <property name="user" value="${jdbc.username}"></property>
       <property name="password" value="${jdbc.password}"></property>
       <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
       <property name="driverClass" value="${jdbc.driverClass}"></property>
    
    </bean>

4. prueba

   @Test
   public void test() throws SQLException {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       DataSource dataSource = (DataSource)ioc.getBean("dataSource");
       System.out.println(dataSource.getConnection());
       //com.mchange.v2.c3p0.impl.NewProxyConnection@64c87930
   }

Dos, crea frijol a través de la anotación

Hay cuatro anotaciones en Spring
(1) @Controller: se recomienda agregar esta anotación a los componentes de la capa de control (Servlet)
(2) @Service: se recomienda agregar esta anotación a los componentes de la capa de lógica empresarial
(3) @Repository: se recomienda que los componentes de la capa de base de datos (capa Dao) agreguen esta anotación
(4) @Component: Se recomienda agregar esta anotación a los componentes que no pertenecen a los anteriores

Nota:
i. Agregue cualquier anotación a la clase del componente que se creará para agregar rápidamente este componente a la administración del contenedor ioc
ii. Use cualquiera de las cuatro anotaciones anteriores, pero intente usar las recomendadas

Pasos de uso:

(1) Importe el paquete aop para admitir el modo de anotación:

(2) Agregue las anotaciones anteriores a la clase del componente que se creará

import org.springframework.stereotype.Service;

    @Service
    public class BookService {
    
    
       //内容
    }

(3) Deje que Spring escanee automáticamente los componentes anotados y use el espacio de nombres de contexto en el archivo xml

<!-- context:component-scan：自动扫描组件 -->
<!-- base-package：指定扫描的包，会将此包下的所有包的所有加了注解的类，自动的扫描进ioc容器中 -->
   
<context:component-scan base-package="com.qizegao"></context:component-scan>
   
<!-- com.qizegao.test 与 com.qizegao.util包都会被扫描，扫描之后符合条件的类图标会加小s -->

Nota:

El comportamiento predeterminado de los componentes agregados al contenedor mediante anotaciones es coherente con el comportamiento predeterminado de los componentes agregados al contenedor mediante archivos de configuración:
i. La identificación predeterminada del componente es la primera letra del nombre de la clase en minúsculas
ii. El componente predeterminado es singleton

(4) Prueba

 public void test() {
    
    
    ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
    System.out.println(ioc.getBean("bookService") == ioc.getBean("bookService"));
    //true
  }

Nota:
i. La identificación del componente se puede modificar
ii. El componente se puede modificar a varias instancias, de la siguiente manera:

@Service("newName") // 修改id为newName
  @Scope(value="prototype") // 修改bean为多实例
  public class BookService {
    
    
       //内容
  }

prueba:

   public void test() {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       System.out.println(ioc.getBean("newName") == ioc.getBean("newName"));
       //false
   }

Tres, especifique los componentes que no están incluidos y solo se incluyen en el escaneo de Spring

//不包含
   <context:component-scan base-package="com.qizegao">
       <!-- 使用context:exclude-filter指定扫描时不包含的组件：
             1. type=annotation：按照注解进行排除，使用了expression中指定的注解(全类名)就不会被包含进来
             2. type=assignable：按照指定的类进行排除，expression中指定要排除的全类名
        -->
       <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
   </context:component-scan>

//只包含
    //Spring默认是把包中所有满足条件的组件全部扫描进来，故应当先禁用默认的扫描规则
   <!-- use-default-filters="false"：禁用默认的扫描规则 -->
   <context:component-scan base-package="com.qizegao" use-default-filters="false">
        <!-- 使用context:include-filter指定扫描时只包含的组件：用法与context:exclude-filter一致 -->
        <context:include-filter type="assignable" expression="com.qizegao.test.BookService"/>
   </context:component-scan>

En cuarto lugar, utilice la anotación @Autowired para realizar el ensamblaje automático según el tipo

Autoensamblaje: asigna automáticamente un valor a un determinado atributo. Se debe asignar al componente correspondiente a este atributo en el contenedor, lo que requiere que este componente esté en el contenedor, de lo contrario se reportará un error

1. Cree dos clases en el paquete com.qizegao.test

  @Repository
  public class BookDao {
    
    
     public void saveBook() {
    
    
         System.out.println("正在使用BookDao保存图书");
     }
  }

  @Service
  public class BookService {
    
    
   
      @Autowired
      //使用此注解自动的为其赋值，无需再new
      private BookDao bookDao;
   
      public void save() {
    
    
          System.out.println("调用BookDao保存图书");
          bookDao.saveBook();
      }
  }

2. Deje que Spring escanee componentes anotados en xml

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

3. prueba

public void test() {
    
    
   ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
   //BookService默认是单例的，使用class获取
   BookService bookService = ioc.getBean(BookService.class);
   bookService.save();
   /**
    * 调用BookDao保存图书
    * 正在使用BookDao保存图书
    */
}

Cinco, principio de ensamblaje automático de anotación @Autowired

   @Autowired
   private BookDao bookDao;

Primero vaya al contenedor para encontrar el componente correspondiente según el tipo (BookDao): getBean (BookDao.class):
(1) Encuentre uno, asigne
(2) No encuentre, arroje una excepción
(3) Encuentre múltiples (subclases de este se encontrará la clase) También se encuentra):

Utilice el nombre de la variable (bookDao) como identificación para continuar buscando el componente correspondiente en el contenedor:
i. La coincidencia es exitosa, el ensamblaje
ii. La coincidencia falla, se informa un error

Nota:
(1)
@Autowired
@Qualifier ("xxx") // El uso de esta anotación puede usar xxx como id para hacer coincidir, en lugar de usar el nombre de variable como id
private BookDao bookDao;

(2) Ensamblar si coincide y asignar un valor nulo si falla: @Autowired (obligatorio = falso)

Seis, use @Autowired en los métodos

1. Este método se ejecutará automáticamente cuando se cree el bean.
2. Cada parámetro de este método se inyectará automáticamente de acuerdo con lo anterior.

(1) Métodos en BookService

    //BookService与BookDao均已注册到ioc容器中
    @Service
    public class BookService {
    
    
       @Autowired(required=false)
       //参数的位置也可以使用@Qualifier注解
       public void method(@Qualifier("bookDao")BookDao bookDao) {
    
    
           System.out.println(bookDao); 
       }
    }

(2) Prueba

  @Test
   public void test() {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       //运行后输出：com.qizegao.test.BookDao@2bbaf4f0
   }

Siete, la diferencia entre @Autowired y @Resource

Los dos son intercambiables

@Autowired: la función más poderosa, es la anotación definida por Spring, pero solo es compatible con el marco Spring
@Resource: es extensible y es un estándar definido por Java, y también se puede usar si cambia a otro contenedor (no Primavera)

Ocho, inyección de dependencia genérica

Al registrar un componente, su tipo genérico también es el estándar de referencia, como se muestra a continuación:

Nota: Al registrar componentes con relación de herencia, solo necesita agregar anotaciones a la subclase, y la clase principal se inyectará automáticamente sin agregar

Nueve, prueba de unidad de primavera

(1) Paquete de guía:

(2) Use dos anotaciones en la clase de prueba:
① @ContextConfiguration (ubicaciones = "classpath: ioc.xml")
especifica la ubicación del archivo de configuración de Spring

② @RunWith (SpringJUnit4ClassRunner.class)
especifica qué controlador usar para las pruebas unitarias, el valor predeterminado es Junit

(3) Beneficios: No es necesario utilizar el método getBean para obtener componentes, agregue directamente la anotación @Autowired en los componentes que se obtendrán y Spring se ensamblará automáticamente

(4) Caso de uso:

 @ContextConfiguration(locations="classpath:ioc.xml")
    @RunWith(SpringJUnit4ClassRunner.class)
    public class test {
    
    
   
       @Autowired
       BookDao bookDao;
   
       @Test
       public void test() {
    
    
           System.out.println(bookDao);
           //com.qizegao.test.BookDao@62e136d3
       }
    }