//实现 InitializingBean 接口
public class TestBean implements InitializingBean {

    public TestBean() {
        System.out.println("------------------TestBean 构造器执行------------------------");
    }

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


}

//实现 BeanPostProcessor 接口
public class TestBeanPostProcessor implements BeanPostProcessor {

    public TestBeanPostProcessor() {
        System.out.println("------------------BeanPostProcessor 实现类 构造器------------------------");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("------------------BeanPostProcessor 实现类 postProcessBeforeInitialization 执行------------------------");

        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("------------------BeanPostProcessor 实现类 postProcessAfterInitialization 执行------------------------");

        return bean;
    }
}

//实现 BeanFactoryPostProcessor 接口
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public TestBeanFactoryPostProcessor() {
        System.out.println("------------------BeanFactoryPostProcessor 实现类 构造器 执行------------------------");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("------------------BeanFactoryPostProcessor 实现类 postProcessBeanFactory 执行------------------------");
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
">
    <bean id="testBean" class="com.example.demo.entity.TestBean"/>
    <bean id="testBeanPostProcessor" class="com.example.demo.processor.TestBeanPostProcessor"/>
    <bean id="testBeanFactoryPostProcessor" class="com.example.demo.processor.TestBeanFactoryPostProcessor"/>

</beans>

//测试类
public class TestDemo {

    @Test
    public void test1() {
        ClassPathXmlApplicationContext context = new    ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        TestBean testBean = (TestBean) context.getBean("testBean");
        System.out.println(testBean);
    }
}

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
      // 预处理
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			// 获取BeanFactory；默认实现是DefaultListableBeanFactory
			// 加载BeanDefition 并注册到 BeanDefitionRegistry
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
      // BeanFactory的预准备⼯作 BeanFactory进⾏⼀些设置，⽐如context的类加载器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
        // BeanFactory准备⼯作完成后进⾏的后置处理⼯作
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
        // 实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
        // 注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
        // 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
				initMessageSource();

				// Initialize event multicaster for this context.
        // 初始化事件派发器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
        // ⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
				onRefresh();

				// Check for listener beans and register them.
        // 注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
        // 初始化所有剩下的⾮懒加载的单例bean
        // 初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
        // 填充属性
        // 初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
        // 调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
        // 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事件（ContextRefreshedEvent）
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

ClassPathXmlApplicationContext#refresh obtainFreshBeanFactory()
   AbstractApplicationContext#obtainFreshBeanFactory refreshBeanFactory()
     AbstractRefreshableApplicationContext#refreshBeanFactory  createBeanFactory()
       protected DefaultListableBeanFactory createBeanFactory() {
					return new DefaultListableBeanFactory(getInternalParentBeanFactory());
			 }

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      //此处初始化非抽象bean、单例bean、非lazy-init的bean
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
          //如果是普通bean则进⾏初始化并依赖注⼊，此 getBean(beanName)接下来触发的逻辑和
					//懒加载时 context.getBean("beanName") 所触发的逻辑是⼀样的
					getBean(beanName);
				}
			}
		}