Funciones avanzadas de los componentes SpringIoC

Tabla de contenido

1. Ciclo y alcance de los componentes de Bean.

1.1 Ciclo de vida de los componentes de Bean

¿Cuáles son los métodos periódicos de Bean?

¡Podemos definir métodos en la clase de componente y luego llamarlos cuando el contenedor de IoC crea una instancia y destruye el objeto del componente! ¡Estos dos métodos nos convertimos en métodos del ciclo de vida!

De manera similar al método init/service/destroy de Servlet, podemos completar la inicialización y liberar recursos en el método periódico.

Bean tiene solo dos ciclos, init y destroy, es decir, inicialización y destrucción.

1.2 Implementación del código del ciclo de vida del Bean
Crear clase de componente:

package com.alphamilk.Ioc5;

public class JavaBean {
    /*
    注意：使用周期方法时候，对应的方法必须满足以下几点
    1.无参
    2.返回值类型为void
     */
    public void init(){
        System.out.println("javaBean被初始化");
    }
    public  void destory(){
        System.out.println("JavaBean被正常销毁");
    }
}

Cree el archivo de configuración correspondiente 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">

<!--    组件创建前面都是一样的，但是需要加上对应的周期方法：
        1.init-method 初始化组件方法 
        2.destroy-method 销毁组件方法
-->
    <bean id="javaBean" class="com.alphamilk.Ioc5.JavaBean" init-method="init" destroy-method="destory"/>
</beans>

prueba:

package com.alphamilk.Ioc;


import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class newTest {
    @Test
    public void test(){
//        创建容器对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("springioc-5.xml");
        /*
        注意，如果没有使用close函数，则会出现destroy方法无法调用的情况
        因为没有close下，ioc容器会意外死亡，就不会调用destroy方法
         */
//        正常销毁组件对象
        applicationContext.close();
    }
}

2.1 Alcance de las etiquetas Bean

¿Cuál es el alcance de la etiqueta Bean?

En términos generales, el alcance de Bean corresponde a dos formas, instancia única y instancias múltiples. A continuación se explica en detalle la instancia única y las instancias múltiples.

Singleton: generalmente, el modo singleton se usa de forma predeterminada al crear beans, lo que significa que si solo hay una etiqueta de Bean correspondiente al obtenerBean en la clase de prueba, incluso si getBean regresa varias veces, el objeto devuelto será el mismo.

Múltiples instancias: se refiere a cuando se usa el método getBean en la clase de prueba, aunque solo hay una etiqueta, cada llamada generará un nuevo objeto componente Bean.

El número específico de objetos de instancia de Bean creados se especifica mediante la propiedad Scope del Bean! Generalmente se recomienda utilizar el modo singleton.

2.2 Valores opcionales de alcance

valor	significado	Cuando crear un objeto	valor por defecto
único	En el contenedor IOC, el objeto de este bean es siempre una instancia única	Cuando se inicializa el contenedor IOC	Sí
prototipo	Este bean tiene varias instancias en el contenedor IOC	Al conseguir un frijol	No

Es especial en WebApplicationContext, su alcance tiene dos valores más.

valor	significado	Cuando crear un objeto	valor por defecto
pedido	Una instancia válida dentro del alcance de la solicitud.	por solicitud	No
sesión	Instancias válidas dentro del alcance de la sesión.	por sección	No

2.3 Código de caso

Crear objeto de clase de componente

package com.alphamilk.Ioc5;

public class JavaBeanScope {
    public void doWork(){
        System.out.println("JavaBean is Working");
    }
}

Configuración correspondiente a caso único y casos múltiples.

No es necesario configurar scpoe de forma predeterminada

Código de prueba:

package com.alphamilk.Ioc;

import com.alphamilk.Ioc5.JavaBeanScope;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class newTest {
    @Test
    public void test(){
//        创建Ioc容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springioc-5.xml");
//        通过容器获取Bean对象
        JavaBeanScope bean = applicationContext.getBean(JavaBeanScope.class);
        JavaBeanScope bean2 = applicationContext.getBean(JavaBeanScope.class);

//        结果为False，因为采用多例模式下，每一次getBean，Ioc都会new一个新的JavaBeanScope对象
        System.out.println(bean==bean2);
    }
}

2. Interfaz FactoryBean

1.1 ¿Qué es FactoryBean?

Como mencionamos en nuestro artículo anterior, existen dos interfaces y cuatro clases de implementación para implementar SpringIoc. Factory es la interfaz principal de las dos interfaces.

Aunque el contenedor Ioc creará automáticamente un nuevo objeto, no todos los componentes se pueden crear de forma casual, como Mybatis. El último paso es construir el objeto de base de datos de operación de sesión, y para obtener el objeto, primero debe obtener la información de configuración getResource (archivo de configuración), luego construir SessionFactoryBuilder y luego llamar al generador de funciones SessionFactoryBuilder. necesita llamar al método openSession. Este complejo proceso de creación de objetos no puede ser implementado por un contenedor Ioc general. Entonces configuramos cómo crear una instancia del objeto directamente desde su raíz FactoryBean.

Modifique ideas complejas de creación de instancias:

1.2 Métodos comunes de la interfaz FactoryBean

nombre del método	Descripción del método
`T getObject()`	Devuelve una instancia de objeto creada por la fábrica. El valor de retorno se almacenará en el contenedor de IoC.
`boolean isSingleton()`	Devuelve si esto `FactoryBean`devuelve un objeto singleton `true`, en caso contrario `false`. Se devuelve la implementación predeterminada `true`(tenga en cuenta que el uso del complemento lombok puede afectar el efecto).
`Class<?> getObjectType()`	Devuelve `getObject()`El tipo de objeto devuelto por el método. Se devuelve si el tipo de objeto no se conoce antes de la creación `null`.

1.3 Implementar el código de caso FactoryBean

1. Cree una subclase de JavaBean que deba crearse una instancia

package com.alphamilk.Ioc6;

public class JavaBean {
    private String name;
    private int age;

//    组件方法
    public void PrintInfo(){
        System.out.println(name+"的年龄是"+age);
    }
}

2. Cree una clase de fábrica que JavaBean deba crear una instancia

package com.alphamilk.Ioc6;

import org.springframework.beans.factory.FactoryBean;

//泛型内容<>内填写返回的类型
public class JavaBeanFactory implements FactoryBean<JavaBean> {
//    如果子例对象需要DI（依赖注入）则需要进行桥梁连接

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

    public void setAge(int age) {
        this.age = age;
    }
    //    覆写如何实现实例化子类过程
    @Override
    public JavaBean getObject() throws Exception {
        JavaBean javaBean = new JavaBean();
        javaBean.setAge(age);
        javaBean.setName(name);
        return javaBean;
    }
// 设置返回的类全定符
    @Override
    public Class<?> getObjectType() {
        return JavaBean.class;
    }
}

3.XML de configuración

<?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="javaBeanFactory" class="com.alphamilk.Ioc6.JavaBeanFactory">
<!--    由于是setter注入，所以用对应的注入方法-->
    <property name="name" value="黄飞宏"/>
    <property name="age" value="99"/>
</bean>
</beans>

4. Prueba el código

package com.alphamilk.Ioc;

import com.alphamilk.Ioc5.JavaBeanScope;
import com.alphamilk.Ioc6.JavaBean;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class newTest {
    @Test
    public void test(){
//  创建Ioc容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("springioc-6.xml");
//        获取组件Bean
        JavaBean bean = (JavaBean) context.getBean("javaBeanFactory");
//        调用Bean方法测试是否有效
        bean.PrintInfo();
    }
}

Para resumir los escenarios de uso de FactoryBean:

Creación de clase de proxy

Integración de marcos de terceros

Creación de instancias de objetos complejos, etc.

Fácil de confundir: la diferencia entre las preguntas de la entrevista FactoryBean y BeanFactory

**FactoryBean ** es un bean especial en Spring. ¡Los beans se pueden crear con lógica personalizada en el método de fábrica getObject()! Es un Bean que puede producir otros Beans. FactoryBean se crea cuando se inicia el contenedor y, cuando realmente se usa, los beans que produce se obtienen llamando al método getObject(). Por lo tanto, FactoryBean puede personalizar cualquier lógica de inicialización requerida y producir algunos beans personalizados.

En circunstancias normales, la integración de marcos de terceros se logra definiendo FactoryBean. ! !

BeanFactory es la base del marco Spring. Como interfaz de nivel superior, define el comportamiento básico del contenedor, como la gestión del ciclo de vida de los beans, la carga y análisis de archivos de configuración, el ensamblaje de beans y la inyección de dependencias, etc. La interfaz BeanFactory proporciona formas de acceder a beans, como el método getBean() para obtener una instancia de bean específica. Puede obtener definiciones de beans de diferentes fuentes (como bases de datos Mysql, archivos XML, clases de configuración de Java, etc.) y convertirlas en instancias de beans. Al mismo tiempo, BeanFactory también contiene muchas subclases (por ejemplo, la interfaz ApplicationContext) que proporcionan potentes funciones adicionales.

En general, la principal diferencia entre FactoryBean y BeanFactory es que el primero es una interfaz para crear beans, que proporciona funciones de personalización de inicialización más flexibles, mientras que el segundo es una interfaz básica de marco para administrar beans, que proporciona funciones básicas de contenedor y gestión del ciclo de vida de Bean. .