Introducción detallada al ciclo de vida de Spring Bean

Como el marco liviano más popular y potente en Java, los programadores han recibido una calurosa bienvenida. Es muy necesario comprender con precisión el ciclo de vida del grano de primavera. Usualmente usamos ApplicationContext como contenedor de primavera. Aquí, también estamos hablando del ciclo de vida de los frijoles en ApplicationContext. De hecho, BeanFactory es similar, pero el procesador debe registrarse manualmente.

1. Gráfico de flujo del ciclo de vida:

El ciclo de vida completo de un frijol de primavera comienza con la creación de un contenedor de resorte hasta que el contenedor de primavera finalmente destruye el frijol, que contiene una serie de puntos clave.

Si el contenedor registra las diversas interfaces anteriores, el programa se llevará a cabo de acuerdo con el proceso anterior. Las funciones de cada interfaz se explicarán en detalle a continuación.

2. Clasificación de varios métodos de interfaz

El ciclo de vida completo de un frijol sufre varias llamadas de métodos, que se pueden dividir en las siguientes categorías:

1. Método propio de Bean: Esto incluye los métodos llamados por el propio Bean y los métodos especificados a través del método init y el método destruir en el archivo de configuración.

2.

3. Su clase de implementación generalmente se llama "postprocesador".

4. Método de interfaz postprocesador de fábrica: esto incluye SuppectJWeVeVingEnabler, ConfigurationClassPostProcessor, CustomAUTOWIRECONFIGURER y otros métodos de interfaz postprocesador de fábrica muy útiles. Los postprocesadores de fábrica también están a nivel de contenedor. Llamado inmediatamente después de aplicar el archivo de configuración de ensamblaje de contexto.

3. Demo

Demostremos el ciclo de vida del frijol de primavera con un simple frijol de primavera.

1. En primer lugar, es un simple frijol de primavera, que llama a los métodos de la frijol y los métodos de interfaz del ciclo de vida a nivel de bean. En aras de la conveniencia de la demostración, implementa cuatro interfaces: Beannameaware, BeanFactoryaware, Inicializando Bean y DiposableBean. Existen 2 métodos al mismo tiempo, correspondientes al método init y el método destruir de <reman> en el archivo de configuración. como sigue:

 paquete springBeAntest; import org.springframework.beans.beansexception; import org.springframework.beans.factory.beanfactory; import org.springframework.beanss.factory.beanFactoryaware; importar org.springfframeWork org.springframework.beans.factory.disposableBean; import org.springframework.beans.factory.initializingbean;/** * @author QSK */Public Class Person implementa BeanFactoryaware, Beannameaware, InitializingBean, DisposableBean {Nombre de cadena privada; dirección de cadena privada; Teléfono privado int; Beanfactory privado BeanFactory; String private BeanName; Public Person () {System.out.println ("【Constructor】 Llame a la instanciación del constructor de la persona"); } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {System.out.println ("【Atributo de inyección】 Nombre del atributo de inyección"); this.name = name; } public String getAddress () {Dirección de retorno; } public void setAddress (dirección de cadena) {System.out.println ("【Atributo de inyección】 Dirección de atributo de inyección"); this.address = dirección; } public int getPhone () {return Phone; } public void setphone (int phone) {System.out.println ("【Atributo de inyección】 Teléfono de atributo de inyección"); this.phone = teléfono; } @Override public string toString () {return "persona [dirección =" + dirección + ", name =" + name + ", phone =" + phone + "]"; } // Este es el método de la interfaz de BeanFactoryaware @Override public void setBeanFactory (BeanFactory Arg0) lanza BeanSexception {System.out .println ("【BeanFactoryaware Interface】 Llame a BeanFactoryaSe.SetBeanFactory ()"); this.beanFactory = arg0; } // Este es el método de la interfaz de BeanNameaware @Override public void setBeanName (String arg0) {System.out.println ("【Beannameaware Interface】 Llame a Beannameaware.setBeanName ()"); this.beanName = arg0; } // Este es el método de interfaz de InicializingBean @Override public void AfterPropertIesset () lanza la excepción {System.out .Println ("【Inicializadora de la interfaz de Bean】 Llame a InicializingBean.AfterPropertiesSet ()"); } // Este es el método de la interfaz DiposibleBean @Override public void Destroy () arroja excepción {System.out.println ("【Interfaz DiposibleBean】 Llame a DiposibleBean.Destory ()"); } // Método de inicialización especificado a través de la propiedad Init-Method de <Bean> public void myInit () {System.out.println ("【Init-Method】 Llame al método de inicialización especificado por la propiedad Init-Method de <Bean>"); } // Método de inicialización especificado por la propiedad Destroy-Method de <Bean> public void myDestory () {System.out.println ("【Destroy-Method】 Llame al método de inicialización especificado por la propiedad Destroy-Method de <Bean>"); }}

2. Lo siguiente es demostrar el método de la interfaz BeanPostProcessor, como sigue:

 paquete SpringBeAntest; import org.springframework.beanss.beansexception; import org.springframework.beans.factory.config.beanpostprocessor; public class myBeanPostProcessor implementa beanpostprocessor {public myBeanPostProcessor () {super (); System.out.println ("Este es el constructor de la clase de implementación de BeanPostProcessor!"); // TODO STUB AUTO GENERADO} @Override Public Object PostProcessAfterInitialization (Object Arg0, String Arg1) arroja Beansexception {System.out .Println ("BeanPostProcessor Interface Method PostProcessAfterInicialization hace cambios en la propiedad!"); regresar arg0; } @Override Public Object PostProcessBeForeinitialization (Object Arg0, String Arg1) arroja BeanSexception {System.out .Println ("BeanpostProcessor Interface Method PostProcessBeforeinitialization cambia la propiedad!"); regresar arg0; }}

Como se mencionó anteriormente, la interfaz BeanPostProcessor incluye dos métodos después de la procesalización y la posprocessbeinicialización. El primer parámetro de estos dos métodos es el objeto Bean que se procesará, y el segundo parámetro es el nombre del bean. El valor de retorno también es el objeto de frijoles a procesar. Presta atención aquí.

3. La interfaz InstanciatiationAweBeBeanPostProcessor es esencialmente una subinterfaz de BeanPostProcessor. En general, heredamos el adaptador de la clase de adaptador InstanciatiationAweBeBeAnpostProcessor proporcionado por Spring para usarlo, de la siguiente manera:

 paquete SpringBeAntest; import java.beans.propertyDescriptor; import org.springframework.beans.beansexception; import org.springframework.beans.propertyValues; importar org.springframework.beans.factory.config.contantiatiation seeBeandprossorAdapter; MyInstantiationAwarebeanPostProcessor extiende InstanciatiationAweBeBeAnPostProcessorAssorAdapter {public myInStantiatiationAweBeBeanPostProcessor () {super (); System.out .println ("¡Este es el InstanciatiationAweBeBeanPostProcessorAdapter Clase de implementación del constructor!"); } // llamar @Override Public Object PostProcessBeForeInstantiation (class BeanClass, String BeanName) arroja BeanSexception {System.out .Println ("InstanciatiationAweBeBeanPostProcessor llama al método de estantería postprocessbeforeinInstanciation"); regresar nulo; } // Método de interfaz, llame a @Override public Object PostProcessAfterInitialization (Object Bean, String BeanName) lanza BeanSexception {System.out .println ("InstanciatiationAweBeBeAnPostProcessor llama al método de PostProcessAfterInicialization"); Bean de regreso; } // Llame a @Override Public PropertyValues ​​PostProcessPropertyValues ​​(PropertyValues ​​PVS, PropertyDescriptor [] pds, object Bean, string beanName) lanza BeanSexception {System.out .Println ("InstanciatiatiationAareBeAnpostProcessor llama a PostProcessPropertyValues ​​método");; devolver PVS; }}

Existen 3 métodos para esto, y el segundo método, PostProcessafterinitialization, es reescribir el método de PostPostProcessor. El tercer método, PostProcessPropertyValues, se utiliza para operar propiedades, y el valor de retorno también debe ser un objeto PropertyValues.

4. Demuestre el método de interfaz postprocesador de fábrica, como sigue:

 paquete SpringBeAntest; import org.springframework.beans.beansexception; import org.springframework.beans.factory.config.beandefinition; importar org.springframework.beans.factory.config.beanfactorypostPostPost org.springframework.beans.factory.config.configurablelistableBeanFactory; public class myBeanFactoryPostProcessor implementa beanFactoryPostProcessor {public myBeanFactoryPostProcessor () {super (); System.out.println ("Este es el constructor de la clase de implementación de BeanFactoryPostProcessor!"); } @Override public void PostProcessBeanFactory (configuableListableBeanFactory arg0) arroja BeanSexception {System.out .Println ("BeanFactoryPostProcessor llama al método PostProcessBeanFactory"); Beandefinition bd = arg0.getBeanDefinition ("persona"); bd.getPropertyValues ​​(). addPropertyValue ("teléfono", "110"); }}

5. El archivo de configuración es el siguiente frijoles.xml, que es muy simple. Al usar ApplicationContext, el procesador no necesita registrarse manualmente:

 <? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.springframework.org/schema/tx" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.2.xsd"> <bean id = "beanpostProCesor"> </bean id = "instantiatiatiationaweN </bean> <bean id = "beanFactoryPostProcessor"> </bean> <bean id = "persona" init-method = "myInit" destruye-method = "myDestory" scope = "singleton" p: name = "zhang san" p: direccione = "Guangzhou" P: Phone = "1590000000000"/> </beans>

6. Pruebe lo siguiente:

 paquete SpringBeAntest; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlaPplicationContext; public class Beanlifecycle {public static void main (string [] args) {system.out.println ("inicialize el contenedor el contenedor que ahora ahora"); ");"); ");"); ApplicationContext Factory = new ClassPathXMLApPlicationContext ("SpringBeanTest/Beans.xml"); System.out.println ("Inicialización del contenedor con éxito"); // Obtener preson y usa persona persona = factory.getBean ("persona", persona.class); System.out.println (persona); System.out.println (persona); System.out.println ("¡Comience a cerrar el contenedor ahora!"); ((ClasspathxmLapPlicationContext) fábrica) .RegisterShutdownHook (); }}

Cierre el contenedor utilizando el método de gancho que en realidad es abstractAplicationContext.

Echemos un vistazo a los resultados:

 Comience a inicializar el contenedor ahora 2014-5-18 15:46:20 org.springframework.context.support.abstractapplicationContext Preparerefresh Información: Refreshing org.springframework.context.support.classpathxxlaPPlicationContext@19a0c7c: startup date [sun mayo 15:20 cst 20144] Root del contexto jerarquía2014-5-18 15:46:20 org.springframework.beans.factory.xml.xmlBeanDefinitionRition Reader LoadBeanDefinitions Información: Cargación de definiciones de clases XML de Bean de clases [SpringBeanTest/Beans.xml] ¡Este es el beanfactorypostpostPoCessing Classation Classation Constructor! ! BeanFactoryPostProcessor llama a PostProcessBeanFactory Método ¡Este es el constructor de la clase de implementación de BeanPostProcessor! ! ¡Este es el constructor de la clase de implementación de InstanciatiationAweBeBeAnPostProcessorsorSorsorAdapter! ! 2014-5-18 15:46:20 org.springframework.beans.factory.support.defaultListableBeanFactory preinstantiatesingletonsinformation: preinstantantes singletons en org.springframework.beans.factory.support.defaultListableBeanfactory@9934d4 Definiendo [BeanPostProcessor, InstanciatiationAweBeBeanPostProcessor, BeanFactoryPostProcessor, persona]; Root of Factory JerarchyinstantiationAwAweBeBeanPostProcessor llame a PostProcessBeForeinStantiation Method [Constructor] Llame al Instanciación de la persona Instanciación de la persona Beannameaware.setBeanName () [interfaz BeanFactoryaware] Llamando a BeanFactoryaware.setBeanFactory () BeanPostProcessor Interface Method PostProcessBeForeinitialization cambia el atributo! [InicializingBean Interface] Llame a InicializingBean.AfterPropertIesset () [Init-Method] Llame al método de inicialización especificado por la propiedad Init-Method de <Bean>, BeanPostProcessor Interface Method PostProcessAfterInitialization para cambiar la propiedad! InstanciationAwarebeanPostProcessor llama al método de posprocesación. El contenedor se inicializa con éxito. Persona [dirección = Guangzhou, nombre = Zhang San, teléfono = 110] ¡Ahora comience a cerrar el contenedor! 【Interfaz DostibleBean】 Llame a DiposibleBean.destory () 【Destroy Método】 Llame al método de inicialización especificado por la propiedad Destroy Method de <Bean>

Lo anterior es una compilación de la información sobre el ciclo de vida de Java Spring Bean. Continuaremos agregando información relevante en el futuro. ¡Gracias por su apoyo a este sitio!