SpringIoc容器初始化主题流程

204 阅读5分钟

这是我参与更文挑战的第5天,活动详情查看: 更文挑战

1.1 Spring IoC的容器体系

IoC容器是Spring的核心模块,是抽象了对象管理、依赖关系管理的框架解决方案。Spring 提供了很多 的容器,其中 BeanFactory 是顶层容器(根容器),不能被实例化,它定义了所有 IoC 容器 必须遵从 的一套原则,具体的容器实现可以增加额外的功能,比如我们常用到的ApplicationContext,其下更具 体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等一系列的内容,
AnnotationConfigApplicationContext 则是包含了注解解析等一系列的内容。Spring IoC 容器继承体系 非常聪明,需要使用哪个层次用哪个层次即可,不必使用功能大而全的。
BeanFactory 顶级接口方法栈如下

image.png BeanFactory 容器继承体系

image.png 通过其接口设计,我们可以看到我们一贯使用的 ApplicationContext 除了继承BeanFactory的子接口, 还继承了ResourceLoader、MessageSource等接口,因此其提供的功能也就更丰富了。
下面我们以 ClasspathXmlApplicationContext 为例,深入源码说明 IoC 容器的初始化流程。

1.2 Bean生命周期关键时机点

思路:创建一个类 LagouBean ,让其实现几个特殊的接口,并分别在接口实现的构造器、接口方法中 断点,观察线程调用栈,分析出 Bean 对象创建和管理关键点的触发时机。
TestBean类:

 
package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/**
* @Author yuyuyu
* @create 2021/06/07 11:46 */
public class TestBean implements InitializingBean{
/**
* 构造函数 */
  public LagouBean(){
  System.out.println("TestBean 构造器..."); 
  }
  /**
* InitializingBean 接口实现 */
  public void afterPropertiesSet() throws Exception {
    System.out.println("TestBean afterPropertiesSet...");
  } 
}

BeanPostProcessor 接口实现类

 
package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* @Author yuyuyu
* @create 2019/06/07 16:59 */
public class MyBeanPostProcessor implements BeanPostProcessor {
  public MyBeanPostProcessor() { 
    System.out.println("BeanPostProcessor 实现类构造函数...");
  }
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if("LagouBean".equals(beanName)) { 
      System.out.println("BeanPostProcessor 实现类
      postProcessBeforeInitialization 方法被调用中......"); 
     }
    return bean;
  }
 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if("LagouBean".equals(beanName)) { 
        System.out.println("BeanPostProcessor 实现类
        postProcessAfterInitialization 方法被调用中......"); }
    return bean;
  }
}

BeanFactoryPostProcessor 接口实现类

 
package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/**
* @Author yuyuyu
* @create 2021/06/07 16:56 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() { 
    System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
}
@Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("BeanFactoryPostProcessor的实现方法调用中......"); }
}

applicationContext.xml

 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     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">
  <bean id="lagouBean" class="com.lagou.LagouBean"/>
  <bean id="myBeanFactoryPostProcessor" class="com.lagou.MyBeanFactoryPostProcessor"/>
  <bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/>
</beans>

IoC 容器源码分析用例

 
/**
* Ioc 容器源码分析基础案例 */
@Test
public void testIoC() {
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
  LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
  System.out.println(lagouBean);
}

(1)分析 Bean 的创建是在容器初始化时还是在 getBean 时

image.png 根据断点调试,我们发现,在未设置延迟加载的前提下,Bean 的创建是在容器初始化过程中完成的。
(2)分析构造函数调用情况

image.png

image.png 通过如上观察,我们发现构造函数的调用时机在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory)处;
(3)分析 InitializingBean 之 afterPropertiesSet 初始化方法调用情况

image.png 通过如上观察,我们发现 InitializingBean中afterPropertiesSet 方法的调用时机也是在 AbstractApplicationContext类refresh方法的finishBeanFactoryInitialization(beanFactory);
(4)分析BeanFactoryPostProcessor 初始化和调用情况 分别在构造函数、postProcessBeanFactory 方法处打断点,观察调用栈,
发现 BeanFactoryPostProcessor 初始化在AbstractApplicationContext类refresh方法的 invokeBeanFactoryPostProcessors(beanFactory);
postProcessBeanFactory 调用在AbstractApplicationContext类refresh方法的 invokeBeanFactoryPostProcessors(beanFactory);
(5)分析 BeanPostProcessor 初始化和调用情况
分别在构造函数、postProcessBeanFactory 方法处打断点,观察调用栈,发现
BeanPostProcessor 初始化在AbstractApplicationContext类refresh方法的 registerBeanPostProcessors(beanFactory);
postProcessBeforeInitialization 调用在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory);
postProcessAfterInitialization 调用在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory);
(6)总结
根据上面的调试分析,我们发现 Bean对象创建的几个关键时机点代码层级的调用都在 AbstractApplicationContext 类 的 refresh 方法中,可⻅这个方法对于Spring IoC 容器初始化来说相当 关键,汇总如下:

关键点触发代码
构造器refresh#finishBeanFactoryInitialization(beanFactory)(beanFactory)
BeanFactoryPostProcessor 初始化refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor 方法调用refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanPostProcessor 初始化registerBeanPostProcessors(beanFactory)
BeanPostProcessor 方法调用refresh#finishBeanFactoryInitialization(beanFactory)

1.3 Spring IoC容器初始化主流程

由上分析可知,Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() 方法中 ,我们查看 refresh 方法来俯瞰容器创建的主体流程,主体流程下的具体子流程我们后面再来讨论。

 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接口的监听器
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
                                /*
                                第十一步:
                                初始化所有剩下的非懒加载的单例bean 初始化创建非懒加载方式的单例Bean实例(未设置属性)
                                填充属性 初始化方法调用(比如调用afterPropertiesSet方法、init-method方法) 调用BeanPostProcessor(后置处理器)对实例bean进行后置处
                                */
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

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

				// Propagate exception to caller.
				throw ex;
			}
		}
	}