public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
         // 準備Bean初始化相關(guān)的環(huán)境信息，其內(nèi)部提供了一個空實現(xiàn)的initPropertySources()方法用于提供給用戶一個更改相關(guān)環(huán)境信息的機會
        this.prepareRefresh();
        // 創(chuàng)建BeanFactory實例，并且注冊相關(guān)的bean信息
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        // 注冊Aware和Processor實例，并且注冊了后續(xù)處理請求所需的一些Editor信息
        this.prepareBeanFactory(beanFactory);

        try {
            // 提供的一個空方法，用于供給子類對已經(jīng)生成的BeanFactory的一些信息進行定制
            this.postProcessBeanFactory(beanFactory);
            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // 調(diào)用BeanFactoryPostProcessor及其子接口的相關(guān)方法，這些接口提供了一個入口，提供給了調(diào)用方一個修改已經(jīng)生成的BeanDefinition的入口
            this.invokeBeanFactoryPostProcessors(beanFactory);
            // 對BeanPostProcessor進行注冊
            this.registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();
            // 初始化國際化所需的bean信息
            this.initMessageSource();
            // 初始化事件廣播器的bean信息
            this.initApplicationEventMulticaster();
            // 提供的一個空方法，供給子類用于提供自定義的bean信息，或者修改已有的bean信息
            this.onRefresh();
            // 注冊事件監(jiān)聽器
            this.registerListeners();
             // 對已經(jīng)注冊的非延遲（配置文件指定）bean的實例化
            this.finishBeanFactoryInitialization(beanFactory);
            // 清除緩存的資源信息，初始化一些聲明周期相關(guān)的bean，并且發(fā)布Context已被初始化的事件
            this.finishRefresh();
        } catch (BeansException var10) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
            }
             // 發(fā)生異常則銷毀已經(jīng)生成的bean
            this.destroyBeans();
            // 重置refresh字段信息
            this.cancelRefresh(var10);
            throw var10;
        } finally {
            // 初始化一些緩存信息
            this.resetCommonCaches();
            contextRefresh.end();
        }

    }
}

//位置：AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }

    if (instanceWrapper == null) {
    	// 實例化階段
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    ...

    Object exposedObject = bean;

    try {
    	// 依賴注入，屬性賦值階段
        this.populateBean(beanName, mbd, instanceWrapper);
        // 初始化階段
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable var18) {
        ...
    }

    ...
}

@Configuration
public class BeanInitAndDestroyConfig {

    /**
     * @return 這里沒有指定bean名字，默認是方法名
     */
    @Description("測試bean的生命周期")
    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public MyService myServiceBeanName() {//入?yún)?shù)可注入其他依賴
        return new MyService();
    }
}

/**
 * @Description: bean生命周期測試：這些接口只針對當(dāng)前bean
 * @Author: jianweil
 * @date: 2021/12/8 9:46
 */
public class MyService implements Person, BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {

    private Animal animal = null;

    private ApplicationContext applicationContext;

    /**
     *接口規(guī)定方法
     */
    @Override
    public void service() {
        this.animal.use();
    }

    public MyService() {
        System.out.println("2. [bean實例化]："+this.getClass().getSimpleName()+"----------構(gòu)造方法");
    }
    /**
     *接口規(guī)定方法：注入依賴
     */
    @Override
    @Autowired
    @Qualifier("dog")
    public void setAnimal(Animal animal) {
        System.out.println("5. [bean屬性賦值]：dog----依賴注入");
        this.animal = animal;
    }


    @Override
    public void setBeanName(String s) {
        System.out.println("6. 調(diào)用【BeanNameAware】--setBeanName:"+s);

    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("7. 調(diào)用【BeanFactoryAware】--setBeanFactory");
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("8. 調(diào)用【ApplicationContextAware】--setApplicationContext");

    }

    /**
     * 初始化1
     */
    @PostConstruct
    public void myInit() {
        System.out.println("10. [初始化] 注解@PostConstruct自定義初始化方法[myInit]");
    }

    /**
     * 初始化2
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("11. [初始化] 接口InitializingBean方法[afterPropertiesSet]");

    }

    /**
     * 初始化3
     */
    public void initMethod() {
        System.out.println("12. [初始化] 注解@Bean自定義初始化方法[initMethod]");
    }

    /**
     * 銷毀1
     */
    @PreDestroy
    public void myDestroy() {
        System.out.println("14. [銷毀] 注解@PreDestroy自定義銷毀方法[myDestroy]");
    }

    /**
     * 銷毀2
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("15. [銷毀] 接口DisposableBean方法[destroy]");
    }

    /**
     * 銷毀3
     */
    public void destroyMethod() {
        System.out.println("16. [銷毀] 注解@Bean自定義銷毀方法[destroyMethod]");
    }
}

/**
 * @Description: todo
 * @Author: jianweil
 * @date: 2021/12/20 17:20
 */
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("myServiceBeanName".equals(beanName) || "dog".equals(beanName)) {
            System.out.println("============================InstantiationAwareBeanPostProcessor-開始======================");
            System.out.println("1. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法：beanName為"+beanName);
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("myServiceBeanName".equals(beanName) || "dog".equals(beanName)) {
            System.out.println("3. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法：beanName為"+beanName);
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("myServiceBeanName".equals(beanName) || "dog".equals(beanName)) {
            System.out.println("4. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法：beanName為"+beanName);
            System.out.println("============================InstantiationAwareBeanPostProcessor-結(jié)束======================");

        }
        return null;
    }
}

/**
 * @Description: 后置bean的初始化器：所有的bean都會攔截執(zhí)行
 * @Author: jianweil
 * @date: 2021/12/8 9:46
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //這里過濾掉springboot自動配置的bean，只打印我們項目的bean情況
        if ("myServiceBeanName".equals(beanName) || "dog".equals(beanName)) {
            System.out.println("9. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessBeforeInitialization 方法：beanName為" + beanName);
        }

        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("myServiceBeanName".equals(beanName) || "dog".equals(beanName)) {
            System.out.println("13. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessAfterInitialization 方法：beanName為" + beanName);
        }
        return bean;
    }
}

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("0. [容器級別只調(diào)用一次] 調(diào)用 BeanFactoryPostProcessor.postProcessBeanFactory() 方法");
    }
}

//容器級別的工廠后置處理器，只在應(yīng)用上下文裝配配置文件之后立即調(diào)用1次
0. [容器級別只調(diào)用一次] 調(diào)用 BeanFactoryPostProcessor.postProcessBeanFactory() 方法


//因為我們生命過程只打印("myServiceBeanName".equals(beanName) || "dog".equals(beanName))，所有貓只有構(gòu)造方法打印了
貓----------構(gòu)造方法

//###############################dog的生命周期###############################################
//后置處理器，容器級別，作用于所有bean
============================InstantiationAwareBeanPostProcessor-開始======================
1. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法：beanName為dog
//狗的實例化
狗----------構(gòu)造方法
//后置處理器，容器級別，作用于所有bean
3. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法：beanName為dog
//后置處理器，容器級別，作用于所有bean
4. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法：beanName為dog
============================InstantiationAwareBeanPostProcessor-結(jié)束======================
//后置處理器，容器級別，作用于所有bean
9. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessBeforeInitialization 方法：beanName為dog
//后置處理器，容器級別，作用于所有bean
13. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessAfterInitialization 方法：beanName為dog
//###############################dog的bean完成,開始myServiceBeanName###############################################


//后置處理器，容器級別，作用于所有bean
============================InstantiationAwareBeanPostProcessor-開始======================
1. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法：beanName為myServiceBeanName

//實例化
2. [bean實例化]：MyService----------構(gòu)造方法

//后置處理器，容器級別，作用于所有bean
3. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法：beanName為myServiceBeanName
//后置處理器，容器級別，作用于所有bean
4. [容器級別每個bean都回調(diào)] 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法：beanName為myServiceBeanName
============================InstantiationAwareBeanPostProcessor-結(jié)束======================

//屬性賦值，即是依賴注入
5. [bean屬性賦值]：dog----依賴注入

//bean級別，bean：myServiceBeanName實現(xiàn)了接口BeanNameAware
6. 調(diào)用【BeanNameAware】--setBeanName:myServiceBeanName
//bean級別
7. 調(diào)用【BeanFactoryAware】--setBeanFactory
//bean級別
8. 調(diào)用【ApplicationContextAware】--setApplicationContext

//后置處理器，容器級別，作用于所有bean：初始化前處理
9. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessBeforeInitialization 方法：beanName為myServiceBeanName

//初始化
10. [初始化] 注解@PostConstruct自定義初始化方法[myInit]
11. [初始化] 接口InitializingBean方法[afterPropertiesSet]
12. [初始化] 注解@Bean自定義初始化方法[initMethod]

//后置處理器，容器級別，作用于所有bean：初始化后處理
13. [容器級別每個bean都回調(diào)] 調(diào)用 BeanPostProcessor.postProcessAfterInitialization 方法：beanName為myServiceBeanName

//容器環(huán)境加載完成，這時可以使用所有bean
2021-12-21 11:18:42.994  INFO 18956 --- [           main] c.l.s.SpringbootBeanLifecycleApplication : Started SpringbootBeanLifecycleApplication in 0.719 seconds (JVM running for 1.312)

//銷毀
14. [銷毀] 注解@PreDestroy自定義銷毀方法[myDestroy]
15. [銷毀] 接口DisposableBean方法[destroy]
16. [銷毀] 注解@Bean自定義銷毀方法[destroyMethod]

Process finished with exit code 0