springboot 组件的生命周期

bean的生命周期： bean创建--初始化--销毁的过程

构造（对象创建）

　　* 单实例：在每次容器启动的时候创建对象

　　* 多实例：在每次获取的时候创建对象

初始化：

　　 对象创建完成，并赋值好，调用初始化方法

 销毁：

　　单实例：容器关闭的时候

　　多实例：容器不会管理这个bean的销毁方法

springboot bean的生命周期的意义：可以自定义初始化和销毁方法，容器在bean进行到当前声明周期的时候来调用我们自定义的初始化和销毁方法

一、指定初始化和销毁方法 在@Bean注解里指定init方法和destroy方法

1、创建一个Dog类

public class Dog {
    
    public Dog() {
        System.out.println("Dog的构造方法执行了");
    }

    public void init() {
        System.out.println("Dog的初始化方法执行了");
    }
    
    public void destroy() {
        System.out.println("Dog的销毁方法执行了");
    }
}
           

2、在注入Dog时在@Bean中中指定初始和销毁方法 

//告诉Spring这是一个配置类
@Configuration
public class MainConfig {

    /*
     * 1、指定初始化和销毁方法
     *         通过@Bean指定initMethod和destroyMethod
     */
    @Bean(name="dog",initMethod="init",destroyMethod="destroy")
    public Dog dog() {
        return new Dog();
    }

}
           

3、创建测试方法进行测试 

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
//        Dog dog = (Dog)applicationContext.getBean("dog");
    }

}
           

得到结果： 

Dog的构造方法执行了

Dog的初始化方法执行了

Dog的销毁方法执行了

二、通过让bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）接口

1、创建一个Dog类

public class Dog implements InitializingBean, DisposableBean{
    
    public Dog() {
        System.out.println("Dog的构造方法执行了");
    }

    @Override
    public void destroy() {
        System.out.println("Dog的销毁方法执行了");
    }

    @Override
    public void afterPropertiesSet(){
        System.out.println("Dog的初始化方法执行了");
    }
}
           

2、定义配置类

//告诉Spring这是一个配置类
@Configuration
public class MainConfig {

    /*
     * 1、指定初始化和销毁方法
     *         通过@Bean指定initMethod和destroyMethod
     */
    @Bean(name="dog")
    public Dog dog() {
        return new Dog();
    }

}
           

 3、测试

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
//        Dog dog = (Dog)applicationContext.getBean("dog");
    }

}
           

得到结果： 

Dog的构造方法执行了

Dog的初始化方法执行了

Dog的销毁方法执行了

三、可以使用JSR250注解

@PostConstructor：在bean创建完成并且属性赋值完成，来执行初始化方法

@PreDestroy：在容器销毁bean之前通知我们进行清理工作 

1、修改dog类

package com.example.demo;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Dog {
    
    public Dog() {
        System.out.println("Dog的构造方法执行了");
    }

    //对象创建并赋值之后调用
    @PostConstruct
    public void afterConstruct() {
        System.out.println("Dog的初始化方法执行了");
    }

    //容器移除对象之前
    @PreDestroy
    public void beforeDestroy() {
        System.out.println("Dog的销毁方法执行了");
    }
}
           

2、定义配置类

//告诉Spring这是一个配置类
@Configuration
public class MainConfig {

    /*
     * 1、指定初始化和销毁方法
     *         通过@Bean指定initMethod和destroyMethod
     */
    @Bean(name="dog")
    public Dog dog() {
        return new Dog();
    }

}
           

 3、测试

SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
//        Dog dog = (Dog)applicationContext.getBean("dog");
    }

}
           

得到结果： 

Dog的构造方法执行了

Dog的初始化方法执行了

Dog的销毁方法执行了

 四、BeanPostProcessor【接口】：bean的后置处理器，

   在bean初始化（init）前后进行处理工作

• postProcessBeforeInitialization 在初始化之前进行一些工作
• 对象初始化
• postProcessAfterInitialization 在初始化之后进行一些工作

 1、创建后置处理器

package com.example.demo;

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

/*
 * 后置处理器，初始化前后进行处理
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    
    /*
     * 参数1为容器刚创建的bean，beanName为bean的名字
     */
    //初始化前所需要做的处理
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
        //返回的对象可以是原来初始化的bean，也可以是包装之后的bean
        return bean;
    }
    
    //初始化后所需要做的处理
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
        return bean;
    }

}
           

2、创建dog类

public class Dog {
    
    public Dog() {
        System.out.println("Dog的构造方法执行了");
    }

}
           

 3、创建配置类

//告诉Spring这是一个配置类
@Configuration
public class MainConfig {

    /*
     * 1、指定初始化和销毁方法
     *         通过@Bean指定initMethod和destroyMethod
     */
    @Bean(name="dog")
    public Dog dog() {
        return new Dog();
    }

}
           

4、测试

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
//        Dog dog = (Dog)applicationContext.getBean("dog");
    }

}
           

Dog的构造方法执行了
postProcessBeforeInitialization...dog=>[email protected]
postProcessAfterInitialization...dog=>[email protected]