Sobre el ciclo de vida de los frijoles en primavera

1. Ciclo de vida de primavera

• El llamado ciclo de vida es el proceso de un objeto desde la inicialización hasta la destrucción.El ciclo de vida de un bean en el contenedor Spring se puede resumir como:

  1. inicializar (instanciar);
  2. Inyección de atributos (generalmente también establecemos atributos para nuevos objetos);
  3. Si el bean implementa la interfaz BeanNameAuthorware, ejecute el método setBeanName (la función es establecer una identificación única para el bean, obtenemos la instancia y la usamos);
  4. Si el bean implementa la interfaz BeanFactoryAware, Spring llamará al método setBeanFactory() para pasar el contenedor BeanFactory;
  5. Si el bean implementa la interfaz ApplicationContextAware, Spring llamará al método setApplication() para pasar la referencia del contexto de la aplicación donde se encuentra el bean;
  6. Si el bean implementa la interfaz BeanPostProcessor, Spring llamará al método postProcessBeforeInitialization() de todos los beans ;
  7. Si el bean implementa la interfaz InitializingBean, Spring llamará a su método afterPropertiesSet() De manera similar, si el bean usa el método init para declarar el método de inicialización, también se llamará al método, o usará la anotación @PostConstruct para tener el mismo efecto.
  8. En correspondencia con el Artículo 6 , la misma interfaz, llame al método postProcessAfterInitialization() de todos los beans
  9. Llame al método marcado por @PreDestroy;
  10. Si el bean implementa la interfaz de AvailableBean, se llamará a su método destroy()

• Diagrama
  
  Amway aquí hay un libro: la cuarta edición de spring combat, esta imagen es exactamente igual a la del libro, después de leerlo, personalmente siento que mi comprensión de spring es muy buena (personalmente siento que los capítulos anteriores están muy bien escritos)

2. Ciclo de vida del bean de demostración

• Cree un proyecto springboot (se pueden demostrar tanto spring como springboot, principalmente porque ya no querrá jugar con spring si usa springboot)
• Escribe tres clases:
  1. TestBean:

package com.example.demo.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import javax.annotation.PreDestroy;


public class TestBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    
    
        System.out.println("执行了:setBeanFactory");
    }

    @Override
    public void setBeanName(String s) {
    
    
        System.out.println("执行了:setBeanName");
    }

    @Override
    public void destroy() throws Exception {
    
    
        System.out.println("执行了:destroy");
    }
    @PreDestroy
    public void annodestroy(){
    
    
        System.out.println("执行了:@PreDestroy标注的方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
    
    
        System.out.println("执行了:afterPropertiesSet");
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    
    
        System.out.println("执行了:setApplicationContext");
    }
}
	

¿demasiado largo? De hecho, no necesita mirar la mayoría de ellos. Solo necesita mirar qué interfaz está implementada y compararla con la imagen. También es muy conveniente escribir y comprender por sí mismo.

2. TestPostProcessorBean:

package com.example.demo.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;


public class TestPostProcessorBean implements BeanPostProcessor {
    
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("执行了:postProcessBeforeInitialization");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("执行了:postProcessAfterInitialization");
        return null;
    }
}

Cabe señalar aquí que los dos métodos de la interfaz BeanPostProcessor serán ejecutados por todos los beans. ¿Por qué debería sacarse por separado aquí? La clase BeanPostProcessor es para permitir algunas operaciones antes y después de la creación al crear otras clases. Si está escrito en TestBean, generalmente no se llamará a los métodos postProcessBeforeInitialization() y postProcessAfterInitialization(). La razón es que antes de que se cree el bean definido por la inicialización del contenedor, el contenedor buscará todos los BeanPostProcessors para crear clases personalizadas. Dado que la interfaz BeanPostProcessor está implementada, el BeanPostProcessor se creará y registrará en este momento. En el código fuente, en el registro BeanPostProcessor realizará la operación getBean, es decir, creará un bean personalizado. Dado que el modo predeterminado es el modo singleton, los métodos postProcessBeforeInitialization() y postProcessAfterInitialization() no se volverán a llamar si la adquisición se vuelve a realizar más tarde, porque se colocaron en Spring Caché y se obtuvieron directamente sin una instancia, por lo que no hay llamar.

3. Configuración de prueba:

package com.example.demo.config;

import com.example.demo.bean.TestBean;
import com.example.demo.bean.TestPostProcessorBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TestConfig {
    
    
   @Bean("TestBean")
   public TestBean getTestBean(){
    
    
       return new TestBean();
   }

   @Bean("TestPostProcessorBean")
   public TestPostProcessorBean getPostProcessorBean(){
    
    
       return new TestPostProcessorBean();
   }
}

3. Prueba de código

package com.example.demo;

import com.example.demo.bean.TestBean;
import com.example.demo.config.TestConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


public class TestMain {
    
    
    public static void main(String[] args) {
    
    
        AnnotationConfigApplicationContext ap=new AnnotationConfigApplicationContext(TestConfig.class);
        ap.getBean("TestBean", TestBean.class);
        ap.close();
    }
}

Resultado:

tenga en cuenta que el método principal debe recordar destruir el contexto; de lo contrario, no se puede alcanzar el método de destrucción.