【SpringBoot教程 事件】1.SpringBoot应用容器七个生命周期回调和SpringBean的生命周期总结

SpringBoot容器七个生命周期回调

SpringBoot 容器有如下七种回调事件：

1.Starting：SpringApplication被初始化事件。
2.EnvironmentPrepared：Environment对象创建之后，Content创建之前。
3.ContextInitialized：ApplicationContext初始化后，bean还没初始化。
4.Prepared：bean被定义后，context对象刷新之前。
5.Started：Context被刷新之后，启动器被调用之前。
6.Ready：启动器调用后，整个SpringBoot启动成功。
7.Failed：应用启动出现异常。

实现方式：

1.实现ApplicationListener接口

2.实现SpringApplicationRunListener接口 + Spring SPI方式（推荐）。

3.实现ApplicationContextInitializer接口

实现ApplicationListener接口

如下定了6个事件类，分别实现类ApplicationListener接口。

import org.springframework.boot.context.event.*;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class TestListener {
    
    @Component
    public static class TestStartingListener implements ApplicationListener<ApplicationStartingEvent> {
        @Override
        public void onApplicationEvent(ApplicationStartingEvent applicationStartingEvent) {
            System.out.println("applicationStartingEvent");
        }

    }
    @Component
    public static class TestEnvListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {

        @Override
        public void onApplicationEvent(ApplicationEnvironmentPreparedEvent applicationEnvironmentPreparedEvent) {
            System.out.println("ApplicationEnvironmentPreparedEvent");
        }
    }
    @Component
    public static class TestInitListener implements ApplicationListener<ApplicationContextInitializedEvent> {

        @Override
        public void onApplicationEvent(ApplicationContextInitializedEvent applicationContextInitializedEvent) {
            System.out.println("ApplicationContextInitializedEvent");
        }
    }
    @Component
    public static class TestPreparedListener implements ApplicationListener<ApplicationPreparedEvent> {

        @Override
        public void onApplicationEvent(ApplicationPreparedEvent applicationPreparedEvent) {
            System.out.println("ApplicationPreparedEvent");
        }
    }
    @Component
    public static class TestStartedListener implements ApplicationListener<ApplicationStartedEvent> {

        @Override
        public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
            System.out.println("ApplicationStartedEvent");
        }
    }
    @Component
    public static class TestReadyListener implements ApplicationListener<ApplicationReadyEvent> {

        @Override
        public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
            System.out.println("ApplicationReadyEvent");
        }
    }
}

更改启动类

import com.terry.event.listener.TestListener;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * SpringBoot 事件
 * @author terry
 * @version 1.0
 * @date 2022/6/8 10:06
 */
@SpringBootApplication
public class App {

    public static void main(String[] args) {
        // SpringApplication.run(App.class, args);
        SpringApplication springApplication = new SpringApplication(App.class);
        springApplication.addListeners(new TestListener.TestEnvListener()
                , new TestListener.TestInitListener(), new TestListener.TestStartingListener()
                , new TestListener.TestStartedListener(), new TestListener.TestPreparedListener()
                , new TestListener.TestReadyListener());
        springApplication.run(args);
    }
}

启动打印如下：

Spring SPI的方式

实现SpringApplicationRunListener接口

import org.springframework.boot.ConfigurableBootstrapContext;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

public class TestRunListener implements SpringApplicationRunListener {

    public TestRunListener(SpringApplication application, String[] args) {

    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("starting");
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        System.out.println("environmentPrepared");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("contextPrepared");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("contextLoaded");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("started");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("running");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("failed");
    }
}

创建META-INF/spring.factories文件，内容如下：

org.springframework.boot.SpringApplicationRunListener=com.terry.event.listener.TestRunListener

启动打印如下：

实现ApplicationContextInitializer接口

创建ApplicationContextInitializer实现类

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.stereotype.Component;
/**
 * 容器初始化
 * @author terry
 * @version 1.0
 * @date 2022/6/8 14:05
 */
public class TestInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        System.out.println(" IOC initialize... ");
    }
}

添加META-INF/spring.factories内容，内容如下：

org.springframework.boot.SpringApplicationRunListener=com.terry.event.listener.TestRunListener

Spring Bean 的生命周期回调

Spring Bean 的生命周期：init（初始化回调）、destory（销毁回调），在Spring中提供了四种方式来设置bean生命周期的回调：

1.@Bean指定初始化和销毁方法

2.实现接口

3.使用JSR250

4.后置处理器接口

使用场景：

在Bean初始化之后主动触发事件。如配置类的参数。

1.@Bean指定初始化和销毁方法

public class Phone {
 
    private String name;
 
    private int money;
    //get set
    public Phone() {
        super();
        System.out.println("实例化phone");
    }
 
    public void init(){
        System.out.println("初始化方法");
    }
 
    public void destory(){
        System.out.println("销毁方法");
    }
}

@Bean(initMethod = "init",destroyMethod = "destory")
public Phone phone(){                              
    return new Phone();                            
}                      

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig5.class);
context.close();            

打印输出：

实例化phone
初始化方法
销毁方法

2.实现接口

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

public class Car implements InitializingBean, DisposableBean {
 
    public void afterPropertiesSet() throws Exception {
        System.out.println("对象初始化后");
    }
 
    public void destroy() throws Exception {
        System.out.println("对象销毁");
    }
 
    public Car(){
        System.out.println("对象初始化中");
    }
 
}
 

打印输出：

对象初始化中
对象初始化后
对象销毁

3.使用JSR250

通过在方法上定义@PostConstruct（对象初始化之后）和@PreDestroy（对象销毁）注解

public class Cat{
 
    public Cat(){
        System.out.println("对象初始化");
    }
 
    @PostConstruct
    public void init(){
        System.out.println("对象初始化之后");
    }
 
    @PreDestroy
    public void destory(){
        System.out.println("对象销毁");
    }
 
}

打印输出：

对象初始化
对象初始化之后
对象销毁

4.后置处理器接口

public class Dog implements BeanPostProcessor{
 
    public Dog(){
        System.out.println("对象初始化");
    }
 
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+"对象初始化之前");
        return bean;
    }
 
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+"对象初始化之后");
        return bean;
    }
 
}

对象初始化
org.springframework.context.event.internalEventListenerProcessor对象初始化之前
org.springframework.context.event.internalEventListenerProcessor对象初始化之后
org.springframework.context.event.internalEventListenerFactory对象初始化之前
org.springframework.context.event.internalEventListenerFactory对象初始化之后