Análisis de código fuente Spring5: comprensión de conocimientos básicos (1)

Directorio de proyectos

1. Comprensión de
Spring Spring Framework es el framework más utilizado para Java. Su éxito proviene de las ideas. Sus ideas incluyen ioc y aop (idea: la relación entre cada bean y bean se unifica a la gestión de contenedores SpringIOC).
El marco de Spring se compone principalmente de siete partes, a saber, Spring Core, Spring AOP, Spring ORM, Spring DAO, Spring Context, Spring Web y Spring Web MVC
2. La diferencia entre Spring y la administración de objetos
tradicional En la tradición, usamos objetos a través de New xxx () se usa para crear instancias de objetos. En el marco de Spring, los objetos generalmente se crean escaneando paquetes y anotaciones. En el proceso de creación de objetos, la mayoría de ellos usan mecanismos de reflexión.
3. Dos formas de Spring para inyectar frijoles
Primero escribimos un objeto (UserEntity.java)

package com.entity;

public class UserEntity {
    
    
    private String name;
    private String age;

    public void setName(String name) {
    
    
        this.name = name;
    }

    public void setAge(String age) {
    
    
        this.age = age;
    }

    @Override
    public String toString() {
    
    
        return "com.entity.UserEntity{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

E introducir dependencias en pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.20.RELEASE</version>
    </dependency>
</dependencies>

1. xml inyección
   crear directamente application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 注入对象，一般使用小驼峰命名法 使用property注入对象属性值-->
    <bean id="userEntity" class="com.spring.entity.UserEntity">
        <property name="name" value="小王"/>
        <property name="age" value="18"/>
    </bean>
</beans>

Cree Application.java en el paquete com.spring

public class Application {
    
    

    public static void main(String[] args) {
    
    
        // 解析xml配置，并指定xml文件，xml文件默认在resource根目录下
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("application.xml");
        // 获取对象
        UserEntity userEntity = classPathXmlApplicationContext.getBean("userEntity", UserEntity.class);
        System.out.println(userEntity.toString());
    }

}

Resultado de la operación:

así podemos encontrar que los datos inyectados en xml también se imprimen

2. Inyección de formulario de anotación
   Cree MyConfig.java en com.spring.config

package com.spring.config;

import com.spring.entity.UserEntity;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {
    
    
    //@Configuration 相当于创建了spring.xml
    @Bean
    public UserEntity userEntity(){
    
    
        return new UserEntity();
    }
}

Resultado de la operación: De

esta manera, también podemos ver que hemos creado exitosamente el objeto UserEntity.
Por supuesto, la anotación @Configuration tiene muchos usos. Por ejemplo, usar @ComponentScan ("com.spring") bajo esta anotación puede escanear externos paquetes, entonces podemos agregar ese fragmento de código a Application.java

// 获取在MyConfig中注入的所有bean
String[] beanDefinitionNames = annotationConfigApplicationContext.getBeanDefinitionNames();
for (int i = 0; i < beanDefinitionNames.length; i++) {
    
    
      System.out.println(beanDefinitionNames[i]);
}

resultado de la operación:

De esta forma, hemos implementado dos métodos de inyección, por supuesto que existen varios métodos de inyección en los dos métodos de inyección, y no se limitan al que se da por ejemplo.

4. ¿El objeto es singleton o múltiples instancias
por defecto? La respuesta es que es singleton por defecto.
Método de prueba (agregue el siguiente código en Application.java):

UserService userService1 = annotationConfigApplicationContext.getBean("userService", UserService.class);
UserService userService2 = annotationConfigApplicationContext.getBean("userService", UserService.class);
System.out.println(userService1 == userService2);

Devolver resultado:

entendamos aquí que el objeto es una sola instancia por defecto, entonces, ¿cómo nos damos cuenta de que el objeto se convierte en múltiples instancias?
Es muy simple. Agregue @Scope ("prototype") al objeto que debe configurarse en varias instancias

5. Cuando se crea el objeto, el hombre hambriento o el perezoso,
déjeme explicar primero, el hombre hambriento y el perezoso .
Estilo chino hambriento: durante el proceso de carga del archivo de configuración, se crean todos los objetos. Es por eso que iniciamos tomcat muy lentamente cada vez que lo iniciamos. Una vez que el inicio sea exitoso, pronto será
estilo perezoso: solo cuando el objeto sea utilizado Se creará
Principio del método de prueba: cuando se crea cada objeto, irá a un constructor sin parámetros
Método de prueba:
agregue un constructor sin parámetros en UserService.java

public UserService(){
    
    
   System.out.println("UserSerivce被创建");
}

Agregar código en Application.java

System.out.println("配置文件启动成功");
UserService userService1 = annotationConfigApplicationContext.getBean("userService", UserService.class);

Resultado de la operación:

Esto también demuestra que nuestros objetos se cargan en estilo hambriento de forma predeterminada, entonces, ¿cómo configuramos qué objetos queremos que se carguen en estilo perezoso?
Es muy simple, solo agregue una anotación @Lazy (value = true) al objeto.