Detailed explanation of spring life cycle

Detailed explanation of spring life cycle:

1. @Bean initialization and destruction

1.1 The life cycle of a bean:

The process of bean creation-----initialization-----destruction

1.2 The life cycle of a container-managed bean:

 We can customize the initialization and destruction methods: the container calls our custom initialization and destruction methods when the bean reaches the current life cycle.

Constructor:
Single instance: initialized when the container is created
Multi-instance: Create an object every time it is obtained

BeanPostProcessor.postProcessBeforeInitialization
Initialization:
 The object is created and assigned, and the initialization method is called. BeanPostProcessor.postProcessAfterInitialization
Destruction:
Single instance: When the container is closed
Multiple instances: The container will not manage this bean; the container will not call the destruction method;
1. Specify Initialization and destruction methods
 Specify init-method and destroy-method through @Bean;
2. Implement InitializingBean through Bean (define initialization logic)
 DisposableBean (define destruction logic)
3. You can use JSR250 Specification:
  @PostConstruct: After the bean is created and the attribute assignment is completed
  @PreDestroy: The cleanup work is called before the container is destroyed and the bean is destroyed

The code is as follows:
a. initMethod and The use of destroyMethod
MainConfig.java

@Configuration@ComponentScan("com.zero.life")public class MainConfig 
{//    @Scope("prototype")    @Bean(initMethod = "init",destroyMethod = "destroy")    
public  Phone phone(){        
return new Phone();    }}
Phone.java
public class Phone {    public Phone() {        
System.out.println("Phone初始化构造。。。");    }  
  public void init(){        
  System.out.println("Phone 初始化方法。。。。");    }    
  public void destroy(){       
   System.out.println("Phone 销毁方法。。。");    }}

b. The use of InitializingBean and DisposableBean

@Componentpublic class Android implements InitializingBean,DisposableBean {
    public Android() {
        System.out.println("android constructor.......");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("android destroy........");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("android afterPropertiesSet........");
    }}

c. The use of @PostConstruct and @PreDestroy Use

@Componentpublic class AIIphone {
    public AIIphone() {
        System.out.println("AIIphone.... contruct...");
    }
    @PostConstruct
    public void init(){
        System.out.println("AIIphone.....PostConstruct");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("AIIphone......PreDestroy");
    }}

2. BeanPostProcessor post-processor

BeanPostProcessor[interface]:
Bean’s post-processor:
In the bean Some processing is done before and after initialization.
  1. postProcessBeforeInitialization: Works before initialization
  2. postProcessAfterInitialization: Works after initialization

/** * 后置处理器，初始化前后进行处理工作 
*/@Componentpublic class MyBeanPostProcessor implements BeanPostProcessor 
{    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) 
throws BeansException {        
System.out.println("postProcessBeforeInitialization....."+beanName+"=>"+bean);    
    return bean;//可对bean进行包装后返回    }   
     @Override    
     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {   
           System.out.println("postProcessAfterInitialization....."+beanName+"=>"+bean); 
                  return bean;//可对bean进行包装后返回    }}

Recommended tutorial: "java video tutorial"

The above is the detailed content of Detailed explanation of spring life cycle. For more information, please follow other related articles on the PHP Chinese website!