Explicación detallada de Spring (súper completa)

1. Primavera

Spring es uno de los frameworks SSM (Spring, SpringMVC, Mybatis). El llamado framework es un diseño que extrae mucho código reutilizable y es muy versátil;

1. Información general

(1) Spring es un marco de código abierto;

(2) Spring nació para simplificar el desarrollo a nivel empresarial. Usando Spring, JavaBean puede hacer que el código sea muy elegante y conciso;

(3) Spring es un marco de contenedor IoC (DI) y AOP;

(4) Excelentes características de Spring

​ No intrusivo: es posible que los objetos de las aplicaciones desarrolladas en Spring no dependan de las API de Spring.

Inyección de dependencia: DI (Inyección de dependencia), la implementación más clásica de Inversion of Control (IoC);

Programación Orientada a Aspectos: AOP (Programación Orientada a Aspectos)

Contenedor: Spring es un contenedor porque contiene y gestiona el ciclo de vida de los objetos de la aplicación.

(5) Componentización: Spring realiza la combinación de configuraciones de componentes simples en una aplicación compleja. En Spring, las anotaciones XML y Java se pueden usar para combinar estos objetos;

(6) Ventanilla única: sobre la base de IoC y AOP, se pueden integrar marcos de código abierto y excelentes bibliotecas de clase de terceros de varias aplicaciones empresariales (de hecho, Spring también proporciona Spring MVC para la capa de presentación y Spring JDBC para capa de persistencia);

(7) Módulo de resorte

[Falló la transferencia de la imagen del enlace externo, el sitio de origen puede tener un mecanismo anti-leeching, se recomienda guardar la imagen y cargarla directamente (img-TE3J19zB-1682512561625) (C:\Users\admin\Desktop\ssm\spring componente imagen.png)]

explicar:

Cada cuadro verde representa un módulo funcional; el cuadro negro en el cuadro verde representa qué paquetes jar se requieren para usar este módulo funcional.

2. Por qué usar Spring

(1) Desacoplamiento conveniente y desarrollo simplificado

​ Spring es una gran fábrica, que puede entregar la creación de todos los objetos y el mantenimiento de las dependencias a la gestión de Spring.

(2) Integración conveniente de varios marcos excelentes

Spring no excluye varios marcos de trabajo de código abierto excelentes y proporciona soporte directo para varios marcos de trabajo excelentes (como Struts2, Hibernate, MyBatis, etc.).

(3) Reducir la dificultad de usar la API de Java EE

Spring proporciona paquetes para algunas API (JDBC, JavaMail, llamadas remotas, etc.) que son muy difíciles de usar en el desarrollo de Java EE, lo que reduce en gran medida la dificultad de aplicar estas API.

(4) Prueba de programa conveniente

​ Spring es compatible con JUnit4, lo que facilita la prueba de programas Spring a través de anotaciones.

(5) soporte de programación AOP

Spring proporciona programación orientada a aspectos, que puede implementar fácilmente funciones como la interceptación de permisos y la supervisión del funcionamiento de los programas.

(6) Soporte para transacciones declarativas

La gestión de transacciones se puede completar solo a través de la configuración, sin programación manual;

Como programador de Java, el grado de comprensión y dominio de Spring es básicamente la encarnación de la capacidad de programación.

3. Primera experiencia de primavera

1. Crear un proyecto Maven

   Marque Construir por arquetipo, seleccione maven-archetype-quickstart

2. importar dependencias

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

3. Crear interfaz y clase de implementación

public interface UserDao {
    
    
    void queryAll();
}

public class UserDaoImpl implements UserDao {
    
    
    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void queryAll() {
    
    
        System.out.println("查询了所有用户信息");
    }
}

4. Crear un archivo de configuración de primavera

Cree spring-config.xml en el directorio de recursos del proyecto. En la idea, puede usar el menú Nuevo–>Archivo de configuración XML–>Spring Config directamente en el directorio de recursos para crear.

<?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">
    <!--
        bean标签进行描述
        id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl"/>
</beans>

5. prueba

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        userDaoImpl.selectAll();
    }
}

dos, COI

1. Concepto

​IoC (Inversión de Control) es Inversión de Control. Antes de usar Spring, casi siempre usábamos el nuevo método para obtener objetos, pero después de usar Spring, ya no usamos el nuevo método para crear objetos, sino que dejamos que Spring los cree por nosotros. La transferencia de control se llama inversión de control.

2. Contenedor IoC

• El contenedor IoC es el núcleo de Spring y también puede llamarse contenedor Spring. Spring usa el contenedor IoC para administrar la creación de instancias y la inicialización de objetos, así como el ciclo de vida completo de los objetos desde la creación hasta la destrucción.

• Todos los objetos usados ​​en Spring son administrados por el contenedor IoC y no necesitamos usar manualmente el operador new para crear objetos. Los objetos administrados por el contenedor IoC se denominan Spring Beans, y Spring Beans son objetos Java, que no son diferentes de los objetos creados con el operador new.

• Spring obtiene qué objetos necesitan ser instanciados leyendo información en anotaciones XML o Java.

• Spring proporciona 2 tipos diferentes de contenedores IoC, contenedores BeanFactory y ApplicationContext.

2.1 fábrica de frijoles

​ El contenedor BeanFactory, la interfaz de nivel más bajo en Spring, proporciona las funciones de contenedor más simples y solo proporciona las funciones de crear instancias de objetos y tomar objetos; BeanFactory no creará instancias de beans cuando se inicie. Bean solo se instanciará;

BeanFactory ac = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

2.2 Contexto de aplicación

​ Application context, que hereda la interfaz BeanFactory, es un contenedor más avanzado de Spring y proporciona funciones más útiles; ApplicationContext agrega muchas funciones de nivel empresarial sobre la base de BeanFactory, como AOP, internacionalización, soporte de transacciones, etc.; ApplicationContext crea instancias todos los frijoles cuando comienza. También puede configurar lazy-init=true para que Bean retrase la creación de instancias de Bean; la interfaz ApplicationContext tiene dos clases de implementación de uso común:

2.2.1 ClassPathXmlApplicationContext

Esta clase busca el archivo de configuración XML especificado en la ruta de clase ClassPath y completa la creación de instancias de ApplicationContext, de la siguiente manera:

ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");

2.2.2 FileSystemXmlApplicationContext

Esta clase busca el archivo de configuración XML especificado en la ruta del sistema de archivos especificado y completa la creación de instancias de ApplicationContext, de la siguiente manera:

ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\workspace\\spring_demo\\src\\main\\resources\\spring-config.xml");

3. Creación de Spring Bean

​ Los objetos administrados por el contenedor Spring IoC se denominan beans, y los beans se crean en función de la información del archivo de configuración de Spring. En general, administramos beans en archivos de configuración de Spring.

En el archivo de configuración de Spring, está envuelto por un conjunto de <beans></beans>etiquetas, en las que <bean></bean>las etiquetas se usan para administrar cada objeto.

1. Sin creación de construcción de parámetros

Para crear un bean de esta manera, debe tener una estructura sin parámetros; de lo contrario, se informará un error en el archivo de configuración de Spring.

<?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">
    <!--
        bean标签进行描述
        id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.dao.impl.UserDaoImpl" lazy-init="true"/>
</beans>

1.1 atributos de etiqueta de frijol

Nombre del Atributo	describir
identificación	El identificador único del bean y la configuración y gestión del bean por parte del contenedor Spring se completan a través de esta propiedad. El valor de id debe comenzar con una letra y se pueden usar símbolos como letras, números y guiones bajos.
nombre	Se pueden especificar múltiples nombres para el Bean en el atributo de nombre, y cada nombre está separado por una coma o un punto y coma. El contenedor Spring puede configurar y administrar el Bean en el contenedor a través del atributo de nombre.
clase	Este atributo especifica la clase de implementación específica del Bean, que debe ser un nombre de clase completo, es decir, el nombre completo de la clase.
alcance	Se utiliza para establecer el alcance de la instancia de Bean, y el valor del atributo puede ser singleton (singleton), prototipo (prototipo), solicitud, sesión y sesión global. Su valor por defecto es singleton
constructor-arg	El elemento secundario del elemento, del que se puede crear una instancia pasando los parámetros de construcción de este elemento. El atributo de índice de este elemento especifica el número de serie del parámetro de construcción (a partir de 0), y el atributo de tipo especifica el tipo de parámetro de construcción
propiedad	El subelemento del elemento se usa para llamar al método setter en la instancia de Bean para asignar valores de propiedad, completando así la inyección de dependencia. El atributo de nombre de este elemento se usa para especificar el nombre de propiedad correspondiente en la instancia de Bean
árbitro	Los subelementos de elementos como y , el atributo de bean en este elemento se usa para especificar una referencia a una instancia de Bean
valor	Los elementos secundarios de elementos como y se utilizan para especificar directamente un valor constante
lista	Inyección de dependencia para encapsular tipos de lista o matriz
colocar	Inyección de dependencia para encapsular tipos de conjuntos
mapa	Inyección de dependencia para encapsular tipos de mapas
entrada
método de inicio	Este método se llama cuando el contenedor carga el bean, similar al método init() en Servlet
método de destrucción	Este método se llama cuando el contenedor elimina el bean, similar al método destroy() en el Servlet. Este método solo es válido cuando scope=singleton
lazy-init	Lazy loading, si el valor es verdadero, el contenedor creará una instancia de Bean en la primera solicitud; si el valor es falso, el contenedor creará una instancia de Bean cuando se inicie. Este método solo es válido cuando scope=singleton

2. Creación dinámica del modo de fábrica

1. Crear una fábrica UserDaoFactory

public class UserDaoFactory {
    
    
    public UserDao getUserDao(){
    
    
        return new UserDaoImpl();
    }
}

2. Archivo de configuración de primavera

<!-- 通过普通工厂创建bean-->
<!-- 第一步，将工厂类本身加入ioc容器-->
<bean id="userDaoFactory" class="com.hqyj.cl.dao.impl.UserDaoFactory"/>
<!-- 第二步，配置bean 
    factory-bean指定由ioc容器创建的工厂bean
    factory-method指定的该工程的工厂方法 -->
<bean id="userDaoImpl" factory-bean="userDaoFactory" factory-method="getUserDao"/>

3. Creación del modo de fábrica estática

1. Crear una fábrica UserDaoFactory

public class UserDaoFactory {
    
    
    public static UserDao getUserDao02(){
    
    
        return new UserDaoImpl();
    }
}	

2. Archivo de configuración de primavera

<!-- 第二步，配置bean 
	id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
	class指定创建对象的类的全类名
    factory-method指定的该工程的静态工厂方法 -->
<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoFactory" factory-method="getUserDao02"/>

Cuarto, el alcance de Spring Bean

Alcance	Descripción
único	(Predeterminado) Alcanza una sola definición de bean por contenedor Spring IoC a una sola instancia de objeto.
prototipo	Alcance una sola definición de bean a cualquier número de instancias de objetos.
pedido	El alcance de una definición de bean individual se aplica a la duración de una solicitud HTTP individual. Es decir, cada solicitud HTTP tiene una instancia de bean creada detrás de una única definición de bean. Solo disponible en Spring ApplicationContext con reconocimiento de red.
sesión	Ámbito de aplicación de una sola definición de bean al tiempo de vida de una sesión HTTP. Solo es válido en el contexto de un Spring ApplicationContext compatible con la red.
solicitud	8 Limite el alcance de una sola definición de bean al ciclo de vida del ServletContext. Solo es válido en el contexto de un Spring ApplicationContext compatible con la red.
enchufe web	Alcance una sola definición de bean para la vida útil de un WebSocket. Solo es válido en el contexto de un Spring ApplicationContext compatible con la red.

4.1 Código de ejemplo

4.1.1 único

1. Archivo de configuración de primavera

<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="singleton"/>

2. clase de prueba

public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

El resultado es verdadero. La declaración de salida de construcción sin argumentos escrita en la clase UserDaoImpl solo se generará una vez, lo que indica que el objeto solo se crea una vez.

4.1.2 prototipo

1. Archivo de configuración de primavera

<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"/>

2. clase de prueba

public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

El resultado del resultado es falso. La instrucción de salida de construcción sin argumentos escrita en la clase UserDaoImpl se emitirá dos veces, lo que indica que el objeto se ha creado dos veces.

Cinco, el ciclo de vida de Spring Bean

• En una aplicación Java tradicional, el ciclo de vida de un bean es muy simple. Se crea una instancia del bean usando la palabra clave new, y cuando el bean no es necesario, Java realiza automáticamente la recolección de basura.

• El ciclo de vida de Bean en Spring es más complicado, lo que se puede expresar como: Definición de Bean -> Inicialización de Bean -> Uso de Bean -> Destrucción de Bean.

• Spring elige el método de gestión según el alcance del bean. Para beans con alcance singleton, Spring puede saber exactamente cuándo se crea el bean, cuándo se inicializa y cuándo se destruye; para beans con alcance de prototipo, Spring solo es responsable de crear, cuando el contenedor crea una instancia del bean Después eso, la instancia de Bean se entrega a la administración del código del cliente, y el contenedor Spring ya no rastreará su ciclo de vida.

• Al configurar un bean en XML, puede usar el atributo init-method y el atributo destroy-method en la etiqueta Bean para definir el método de devolución de llamada de inicialización y el método de devolución de llamada de destrucción del bean, respectivamente.

5.1 Código de muestra

1. userDao

public class UserDaoImpl implements UserDao {
    
    

    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void selectAll() {
    
    
        System.out.println("执行了selectAll方法");
    }

    public void init(){
    
    
        System.out.println("init");
    }

    public void destroy(){
    
    
        System.out.println("destroy");
    }
}

2. Archivo de configuración de primavera

<bean id="userDaoImpl1" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"
      init-method="init" destroy-method="destroy"/>

3. clase de prueba

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        ac.registerShutdownHook();
    }
}

En el modo singleton de aplicaciones que no son web, cargue manualmente el contenedor Spring IoC, use la interfaz AbstractApplicationContext para heredar la interfaz ApplicationContext, y el método registerShutdownHook/close puede cerrar manualmente el contenedor y dejar que el método destroy ejecute el método correspondiente

六, MARTES

​ DI (Dependency Injection), es decir, "dependency injection": la dependencia entre componentes la determina el contenedor en tiempo de ejecución, es decir, el contenedor inyecta dinámicamente una determinada dependencia en el componente. El propósito de la inyección de dependencia no es traer más funciones al sistema de software, sino aumentar la frecuencia de reutilización de componentes y construir una plataforma flexible y escalable para el sistema. A través del mecanismo de inyección de dependencia, solo necesitamos especificar los recursos requeridos por el objetivo sin ningún código a través de una configuración simple y completar nuestra propia lógica comercial, sin importar de dónde provienen los recursos específicos y quién los implementa.

Hay dos implementaciones principales de inyección de dependencia, a saber, inyección de setter e inyección de constructor.

6.1 Inyección de incubadora

​ Se refiere al contenedor IoC usando el método setter para inyectar la instancia dependiente. La inyección de dependencia basada en setter se puede realizar llamando al método setter del bean después de instanciar el bean llamando al constructor sin argumentos o al método de fábrica estático sin argumentos.

En el proceso de creación de instancias de Bean en Spring, primero se llama al constructor predeterminado para crear una instancia del objeto Bean, y luego se llama al método setXxx() a través del mecanismo de reflexión de Java para inyectar propiedades. Por lo tanto, la inyección de setter requiere que la clase correspondiente del Bean cumpla con los siguientes dos requisitos:

• Se debe proporcionar un constructor predeterminado sin argumentos;

• Se deben proporcionar los métodos de establecimiento correspondientes para las propiedades que se deben inyectar.

  Al usar la inyección de setter, en el archivo de configuración de Spring, debe usar <bean>los elementos secundarios del elemento <property>para inyectar valores para cada atributo; use la inyección de construcción

, en el archivo de configuración, utiliza principalmente <constructor-arg>la etiqueta para definir los parámetros del método de construcción y utiliza su atributo de valor (o subelemento) para establecer el valor del parámetro.

6.1.1 Código de ejemplo

La etiqueta<property> contiene atributos como nombre, referencia y valor. name se usa para especificar el nombre del parámetro; el atributo value se usa para inyectar el valor del tipo de datos básico y el tipo de cadena; el atributo ref se usa para inyectar el Bean definido

1. Crear un usuario de clase Java

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

2. Archivo de configuración de primavera

<?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">
    <bean id="user" class="com.hqyj.cl.pojo.User">
        <property name="id" value="1"/>
        <property name="username" value="chenlei"/>
        <property name="password" value="111"/>
    </bean>
</beans>

3. clase de prueba

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = ac.getBean("user", User.class);
        System.out.println(user);
    }
}

6.2 Constructor

​ Se refiere al contenedor IoC que usa el constructor para inyectar la instancia dependiente. La inyección de dependencia se puede implementar llamando a un constructor con parámetros, cada parámetro representando una dependencia.

Hay tres formas de inyectar instancias dependientes mediante el uso de constructores: a través de la inyección de subíndices, a través de la inyección de atributos y a través de la inyección de nombres de parámetros.

6.2.1 Definir una clase de usuario

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

6.2.2 Inyección vía Subíndice

Cuando el constructor tiene varios parámetros, puede usar el atributo de índice para especificar la posición de los parámetros. El valor del atributo de índice comienza desde 0. Si no especifica el índice, la secuencia de etiquetas se usa de manera predeterminada.

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg index="0" value="1"/>
    <constructor-arg index="1" value="chenchen"/>
    <constructor-arg index="2" value="23"/>
</bean>

6.2.3 Inyección vía propiedades

​ El atributo name se inyecta especificando el nombre del parámetro en el método de construcción, es el más utilizado y debe ser dominado

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg type="int" value="2"/>
    <constructor-arg type="java.lang.String" value="chenchen"/>
    <constructor-arg type="java.lang.String" value="123"/>
</bean>

6.2.4 Inyección por nombre de parámetro

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg name="id" value="3"/>
    <constructor-arg name="username" value="chenchen"/>
    <constructor-arg name="password" value="123"/>
</bean>

6.3 Comparación de inyección de setter e inyección de constructor

Inyección de constructor:

Ventajas: todos los parámetros en el constructor deben especificarse en el momento de la creación antes de que se pueda crear el bean, lo que garantiza que después de crear el objeto, las variables miembro deben tener valores.

Desventaja: Se deben especificar todos los parámetros, de lo contrario no se puede crear el objeto Utilice este método para cambiar el proceso de creación del objeto.

inyección de setter:

Ventajas: al crear un objeto, no es necesario especificar parámetros y la creación de objetos no estará restringida.
Desventaja: cuando un objeto tiene múltiples propiedades que se pueden inyectar, no hay garantía de que se inyectarán todas o algunas propiedades.
El método de inyección de setter es más flexible y más cómodo de usar.

6.4 objeto de inyección setter

Hay varios casos: tipo común, colección de listas, colección de mapas, tipo de cadena, tipo de referencia de objeto, colección de conjuntos, matriz, propiedades, tipo nulo

1. clase de estudiante

public class Student {
    
    
    private String name;
    private Counselor counselor;
    private String[] courses;
    private List<String> books;
    private Map<String, String> idCard;
    private Set<String> studentNumber;
    private String wifeName;
    private Properties properties;

    public Student() {
    
    
    }

    public Student(String name, Counselor counselor, String[] courses, List<String> books, Map<String, String> idCard, Set<String> studentNumber, String wifeName, Properties properties) {
    
    
        this.name = name;
        this.counselor = counselor;
        this.courses = courses;
        this.books = books;
        this.idCard = idCard;
        this.studentNumber = studentNumber;
        this.wifeName = wifeName;
        this.properties = properties;
    }

    public String getName() {
    
    
        return name;
    }

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

    public Counselor getCounselor() {
    
    
        return counselor;
    }

    public void setCounselor(Counselor counselor) {
    
    
        this.counselor = counselor;
    }

    public String[] getCourses() {
    
    
        return courses;
    }

    public void setCourses(String[] courses) {
    
    
        this.courses = courses;
    }

    public List<String> getBooks() {
    
    
        return books;
    }

    public void setBooks(List<String> books) {
    
    
        this.books = books;
    }

    public Map<String, String> getIdCard() {
    
    
        return idCard;
    }

    public void setIdCard(Map<String, String> idCard) {
    
    
        this.idCard = idCard;
    }

    public Set<String> getStudentNumber() {
    
    
        return studentNumber;
    }

    public void setStudentNumber(Set<String> studentNumber) {
    
    
        this.studentNumber = studentNumber;
    }

    public String getWifeName() {
    
    
        return wifeName;
    }

    public void setWifeName(String wifeName) {
    
    
        this.wifeName = wifeName;
    }

    public Properties getProperties() {
    
    
        return properties;
    }

    public void setProperties(Properties properties) {
    
    
        this.properties = properties;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "name='" + name + '\'' +
                ", counselor=" + counselor +
                ", courses=" + Arrays.toString(courses) +
                ", books=" + books +
                ", idCard=" + idCard +
                ", studentNumber=" + studentNumber +
                ", wifeName='" + wifeName + '\'' +
                ", properties=" + properties +
                '}';
    }
}

2. clase de consejero

public class Counselor {
    
    
    private String name;

    public Counselor() {
    
    
    }

    public Counselor(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

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

    @Override
    public String toString() {
    
    
        return "Counselor{" +
                "name='" + name + '\'' +
                '}';
    }
}

3. Archivo de configuración de primavera

<!--引用注入-->
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师"/>
</bean>
<!--注入学生类-->
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <!--普通值注入-->
    <property name="name" value="chenchen"/>
    <!--引用注入-->
    <property name="counselor" ref="counselor"/>
    <!--数组注入-->
    <property name="courses">
        <array>
            <value>计算机组成原理</value>
            <value>计算机网络</value>
            <value>数据结构</value>
        </array>
    </property>
    <!--List集合注入-->
    <property name="books">
        <list>
            <value>Java入门到放弃</value>
            <value>Python大数据挖掘与分析</value>
        </list>
    </property>
    <!--Map集合注入-->
    <property name="idCard">
        <map>
            <entry key="idCard" value="29121821212"/>
            <entry key="phone" value="123121212121"/>
        </map>
    </property>
    <!--Set集合注入-->
    <property name="studentNumber">
        <set>
            <value>20200301123</value>
        </set>
    </property>
    <!--null注入-->
    <property name="wifeName">
        <null/>
    </property>
    <!--Properties注入-->
    <property name="properties">
        <props>
            <prop key="username">chenchen</prop>
            <prop key="password">112112</prop>
        </props>
    </property>
</bean>

4. clase de prueba

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Student student = ac.getBean("student", Student.class);
        System.out.println(student);
    }
}

7. Configuración basada en anotaciones

​ En Spring, aunque los archivos de configuración XML se pueden usar para implementar el ensamblado de Bean, si la cantidad de beans en la aplicación es grande, los archivos de configuración XML estarán demasiado hinchados, lo que traerá ciertas dificultades para el mantenimiento y las actualizaciones.

Java ha proporcionado la función de anotación desde JDK 5.0, y Spring 2.5 también ha brindado soporte completo para la tecnología de anotación Podemos usar anotaciones para configurar la inyección de dependencia.

Spring no usa anotaciones para ensamblar beans de forma predeterminada, por lo que debe agregar etiquetas en el archivo de configuración <context:annotation-config/>para habilitar el soporte de anotaciones;

​:<context:annotation-config/> Solo puede funcionar en beans que ya han sido registrados. No realiza ninguna operación sobre frijoles que no están registrados en el contenedor de primavera.

​:<context:component-scan/> Además de <context:annotation-config/la función >, también tiene la función de registrar automáticamente objetos con anotaciones como @component, @service, @Repositoryetc. en el contenedor de primavera

Anotaciones de escaneo del paquete de configuración:

​ <context:component-scan base-package=“com.hqyj”/>

1. Crear anotaciones relacionadas con Bean

1.1 @Componente

Esta anotación se puede usar para describir el Bean en Spring, pero es un concepto generalizado que solo representa un componente (Bean) y se puede usar en cualquier nivel. Al usarlo, solo necesita marcar la anotación en la clase correspondiente.

1.2 @Repositorio

​ Se utiliza para identificar la clase de la capa de acceso a datos (capa DAO) como un bean en Spring, y su función es la misma que la de @Component.

1.3 @Servicio

Usualmente actúa sobre la capa de negocios (capa de servicios), y se usa para identificar la clase de la capa de negocios como un bean en Spring, y su función es la misma que @Component.

1.4 @Controlador

Usualmente actúa sobre la capa de control (como Action of Struts2, Controller of SpringMVC), y se usa para identificar la clase de la capa de control como un bean en Spring, y su función es la misma que @Component.

2. Anotaciones relacionadas con el ciclo de vida del Bean

2.1 @Alcance

La anotación en el nombre de la clase se usa para especificar el alcance del bean, lo que equivale a usar el atributo de alcance al configurar el bean en el archivo xml. Valores comunes singleton, prototipo

2.2 @PostConstrucción

Nota sobre el método, especifique el método de devolución de llamada cuando se crea el bean. <bean>Es equivalente a la función de usar el atributo init-method en la etiqueta en el archivo de configuración xml .

2.3 @PreDestruir

Nota sobre el método, especificando el método de devolución de llamada cuando se destruye el bean. <bean>Es equivalente a la función de usar el atributo destroy-method en la etiqueta en el archivo de configuración xml .

2.4 @Configuración

Implementación de anotación completa, @Configuration es similar a la etiqueta de beans del archivo de configuración xml @bean es similar a la etiqueta de bean

import com.hqyj.pojo.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBean {  //方法返回值就是定义bean的类型 方法名就是id
    @Bean
    public Dog dog(){
        return new Dog("哈士奇","黑白色");
    }
}

public static void main(String[] args) {
    //通过注解Component
    ApplicationContext ac = new AnnotationConfigApplicationContext(MyBean.class);
    Dog dog = ac.getBean("dog", Dog.class);
    System.out.println(dog);
}

3. Anotaciones relacionadas con la inyección de dependencia

3.1 @Autocableado

Autocableado:

​ Ensamblaje automático significa que el contenedor Spring puede ensamblar automáticamente (autocablear) la relación entre los beans que cooperan sin usar <constructor-arg>etiquetas e inyectar un bean en la propiedad de otros beans.<property>

El cableado automático permite la inyección de dependencia con menos código. Sin embargo, los tipos de datos simples como int, boolean y String no se pueden ensamblar automáticamente. En comparación con el ensamblaje explícito, el programador no controla el ensamblaje automático.

La anotación @Autowired se puede aplicar a las variables de atributos de Bean, a los métodos de establecimiento de atributos, a los métodos y constructores que no establecen, etc., y cooperar con el procesador de anotaciones correspondiente para completar la configuración automática de Bean. Por defecto, se ensambla según el tipo de Bean. El montaje automático no requiere el método de ajuste correspondiente.

También hay un atributo autowired en la etiqueta del bean del archivo de configuración

byType: asegúrese de que la identificación del bean sea única y que el tipo del bean también sea único

byName: asegúrese de que la identificación del bean sea única y que la identificación del bean sea el nombre del método del método establecido correspondiente a este tipo de propiedad

clase de usuario

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    private Address address;
}

Clase de dirección

@Component
public class Address {
    @Value("chengdu")
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

Archivo de configuración bean.xml

<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
</bean>

clase de prueba

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user);
    }
}

3.2 @Recurso

​ La función es la misma que Autowired, la diferencia es que @Autowired se ensambla de acuerdo con el tipo de Bean de forma predeterminada, mientras que @Resource se ensambla de acuerdo con el nombre de la instancia de Bean de forma predeterminada.

​ Hay dos atributos importantes en @Resource: nombre y tipo.

Spring resuelve el atributo de nombre en el nombre de instancia del Bean y el atributo de tipo en el tipo de instancia del Bean. Si se especifica el atributo de nombre, se ensamblará por nombre de instancia; si se especifica el atributo de tipo, se ensamblará por tipo de Bean. Si no se especifica ninguno, ensamble primero de acuerdo con el nombre de la instancia de Bean y luego ensamble de acuerdo con el tipo de Bean si no pueden coincidir; si no pueden coincidir, se lanzará NoSuchBeanDefinitionException.

clase de usuario

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    /*@Autowired
    @Qualifier("address1")*/
    @Resource(name = "address1")  //相当于@Autowired+@Qualifier
    private Address address;
}

3.3 @Clasificador

​ Usado junto con la anotación @Autowired, el ensamblado predeterminado por tipo de Bean se modificará para ensamblarse por el nombre de instancia del Bean, y el nombre de instancia del Bean se especifica mediante el parámetro de la anotación @Qualifier. (puede especificar el bean inyectado)

Clase de dirección (eliminar la anotación @Component)

public class Address {
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

archivo de configuración

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

clase de usuario

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    @Qualifier("address1")  //指定要注入的bean
    private Address address;
}

clase de prueba

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user); //拿到haerbin
    }
}

Notas adicionales:

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byType">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<!--<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>-->

Puede eliminar la anotación @autowire en el usuario y agregarla en el archivo de configuración, y puede inyectar por tipo, pero el bean inyectado debe ser único.

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byName">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

autowire="byName" es para obtener el valor correspondiente de acuerdo con el nombre del parámetro de los métodos get y set en el pojo (puede escribir manualmente las pruebas del método getter y setter de la clase User)

Para inyectar el bean correspondiente, debe modificar el nombre del método del método establecido, por ejemplo:

public void setAddress1(Address address) {
    this.address = address;
}

3.4 @Valor

​ @Autowired inyecta otro bean, mientras que la anotación @Value inyecta el valor. Esta anotación se usa menos debido a problemas de codificación duros causados ​​por la inyección de valores constantes en el código fuente de Java.

4. Código de ejemplo

1. Servicio de usuario

public interface UserService {
    
    
    void selectAll();
}

2. UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    
    

    @Autowired
    private UserDao userDao;

    // 注入值
    @Value("张三")
    private String username;

    @Override
    public void selectAll() {
    
    
        System.out.println(username);
        userDao.selectAll();
    }
}

3. Archivo de configuración de primavera

<context:component-scan base-package="com.hqyj.cl" />
<bean id="man" class="com.hqyj.cl.pojo.Man" />
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="student1" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师" />
</bean>

4. clase de hombre

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class Man {
    
    

    @Value("张三")
    private String name;

/*    @Autowired
    @Qualifier("student1")*/
    @Resource(type = Student.class)
    private Student student;

    @Autowired
    private Counselor counselor;
}

5. clase de prueba

public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Man man = ac.getBean("man", Man.class);
        System.out.println(man);
    }
}