Spring IOC初始化执行流程

时间  2020-12-18
标签 java spring 缓存 springboot app post this .net 代理 code 栏目 Spring 繁體版
原文   原文链接

运行环境：jdk8，springboot-2.2.2java

Spring IOC容器的初始化核心在于AbstractApplicationContext的refresh方法spring

refresh方法执行的大致流程缓存

  1. 获取到BeanFactory并作一些BeanFactory的准备工做
  2. 执行BeanFactory的后置处理器
  3. 建立并注册其余的后置处理器
  4. 初始化MessageSource组件（作国际化功能；消息绑定，消息解析）
  5. 初始化事件派发器，注册监听器
  6. 建立剩余的非懒加载的单实例bean
  7. 收尾工做。发布容器建立完成，清理一些缓存等

SpringBoot下执行refresh()方法的ApplicationContext的实际类型是AnnotationConfigServletWebServerApplicationContextspringboot

关于AnnotationConfigServletWebServerApplicationContext的结构请看这里app

prepareRefresh()

  • 激活容器
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
  • 建立早期的事件监听器和早期的事件
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
this.earlyApplicationEvents = new LinkedHashSet<>();

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

  • 为 子类GenericApplicationContext类的成员变量private final DefaultListableBeanFactory beanFactory设置一个序列化IDpost

    refreshBeanFactory();
	this.beanFactory.setSerializationId(getId());

  • 返回子类GenericApplicationContext类的成员变量private final DefaultListableBeanFactory beanFactorythis

    返回类型为ConfigurableListableBeanFactory .net

    return getBeanFactory();

GenericApplicationContext的beanFactory是在建立上下文对象时就new了出来的代理

prepareBeanFactory(beanFactory)

为beanFactory进行了一些准备工做code

  • 设置了beanFactory使用的类加载器，设置了用于解析表达式解析器（好比解析${}或#{}表达式的解析器）

    beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

  • 添加了一些后置处理器

    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); 
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  • 设置了一些不能被自动装配的接口

    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
...
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

  • 注册了一些能被自动装配的接口

    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
...
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

补充：

  • ApplicationListenerDetector的postProcessAfterInitialization(Object bean, String beanName)在bean被建立实例化对象后执行

    做用：若是此bean是ApplicationListener，就执行this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);

  • beanFactory.ignoreDependencyInterface指定自动装配时忽略的接口

  • beanFactory.registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue)指定自动装配的默认对象。

    做用有点像@Primary 注解。

postProcessBeanFactory(beanFactory)

此方法为空方法，留给子类作实现。

invokeBeanFactoryPostProcessors(beanFactory)

  • 执行两种后置处理器

    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

执行顺序

  1. BeanDefinitionRegistryPostProcessor 的postProcessBeanDefinitionRegistry
  2. BeanDefinitionRegistryPostProcessor 的postProcessBeanFactory
  3. BeanFactoryPostProcessor的postProcessBeanFactory

其中包含建立BeanDefinition的流程：

ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法会为主启动类所在包和子包中全部组件建立BeanDefinition并 添加到DefaultListableBeanFactory成员变量this.BeanDefinitionMap中。

下面是扫描并获取到组件的方法栈

// 你能够在doScan方法中看到你basePackages（主启动类所在的包）下全部将要被建立BeanDefinition的组件
doScan:292, ClassPathBeanDefinitionScanner (org.springframework.context.annotation)
parse:132, ComponentScanAnnotationParser (org.springframework.context.annotation)
doProcessConfigurationClass:290, ConfigurationClassParser (org.springframework.context.annotation)
processConfigurationClass:245, ConfigurationClassParser (org.springframework.context.annotation)
parse:202, ConfigurationClassParser (org.springframework.context.annotation)
parse:170, ConfigurationClassParser (org.springframework.context.annotation)
processConfigBeanDefinitions:325, ConfigurationClassPostProcessor (org.springframework.context.annotation)
postProcessBeanDefinitionRegistry:242, ConfigurationClassPostProcessor (org.springframework.context.annotation)
invokeBeanDefinitionRegistryPostProcessors:275, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanFactoryPostProcessors:95, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanFactoryPostProcessors:706, AbstractApplicationContext (org.springframework.context.support)
refresh:532, AbstractApplicationContext (org.springframework.context.support)

关于BeanDefinitionRegistryPostProcessor 的postProcessBeanDefinitionRegistry和BeanFactoryPostProcessor的postProcessBeanFactory两个方法的区别

执行时机不不一样。这两个方法上的注释是这样说的

postProcessBeanDefinitionRegistry方法是在容器标准初始化完成后，bean定义信息（BeanDefinition对象）未被加载，且未实例化任何bean时调用的。此时还能够向容器中添加新的或覆盖旧的bean定义信息

postProcessBeanFactory方法是在容器标准初始化完成后，全部bean的定义信息已经被加载 ，可是还未实例化温和bean时调用的。执行时机要晚于postProcessBeanDefinitionRegistry方法

registerBeanPostProcessors(beanFactory)

向容器中添加后置处理器

PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

  • 向容器中添加一个后置处理器

    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

  • 分四类注册自定义的后置处理器

    // 实现了PriorityOrdered接口
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 实现了PriorityOrdered接口，且是MergedBeanDefinitionPostProcessor类型
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 实现了Ordered接口的
List<String> orderedPostProcessorNames = new ArrayList<>();
// 没有实现PriorityOrdered或Ordered接口的
List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    先将后置处理器根据上述规则分类添加到不一样的List中，再排序

    再建立后置处理器的实例对象

    再将实例对象添加到容器中（AbstractBeanFactory的成员变量private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();）

  • 向容器中添加一个后置处理器

    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

补充：

  • MergedBeanDefinitionPostProcessor接口是用来在建立bean时作依赖注入的

initMessageSource()

初始化MessageSource组件（作国际化功能；消息绑定，消息解析）

  • 检查容器中是否有beanName == "messageSource"的bean。若是没有就new一个，并赋值给this.messageSource，再将其添加到容器中

之后可注入此bean，执行其getMessage方法获取到国际化配置文件中的内容

initApplicationEventMulticaster()

初始化事件派发器

  • 检查容器中是否有beanName == "applicationEventMulticaster"的bean。若是没有就new一个，并赋值给this.applicationEventMulticaster，再将其添加到容器中

onRefresh()

此方法为空方法，留给子类作实现。

registerListeners()

  • 将AbstractApplicationContext的成员变量this.applicationListeners事件监听器添加到事件派发器中

    for (ApplicationListener<?> listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
}

  • 将容器中的事件监听器的名字添加到事件派发器中

    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

  • 发布this.earlyApplicationEvents早期事件，并清理掉早期事件

    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
    for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
        getApplicationEventMulticaster().multicastEvent(earlyEvent);
    }
}

finishBeanFactoryInitialization(beanFactory)

==建立剩下的非懒加载的单实例bean==

// 建立剩余的非懒加载单实例bean
finishBeanFactoryInitialization(beanFactory);
	
	// 调用beanFactory建立剩余的非懒加载单实例bean
	beanFactory.preInstantiateSingletons();
		
		// 获取并遍历beanNames，用beanName获取BeanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		
		getBean(beanName);
			
			doGetBean(name, null, null, false);
			
				// 尝试从容器中获取bean，若是获取不到再自行建立bean。getSingleton方法为DefaultSingletonBeanRegistry的方法
				Object sharedInstance = getSingleton(beanName);
				// sharedInstance==null 执行如下流程建立bean
				// 获取bean的定义信息
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 获取此bean所依赖的其余bean
				String[] dependsOn = mbd.getDependsOn();
				// 若是dependsOn不为空，遍历dependsOn，执行getBean(dep)。即，先建立此bean所依赖的bean。
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						getBean(dep);
					}
				}
				// 若是此bean是单实例，执行如下方法建立bean
				sharedInstance = getSingleton(beanName, () -> {
							return createBean(beanName, mbd, args);
				});
					// 调用上面建立的匿名类实现的方法
					singletonObject = singletonFactory.getObject();
						
						// 调用上述的createBean(beanName, mbd, args);方法。建立bean						
						Object beanInstance = doCreateBean(beanName, mbdToUse, args);
							
							// 建立并接收bean的实例对象
							instanceWrapper = createBeanInstance(beanName, mbd, args);
							// 执行MergedBeanDefinitionPostProcessor类型的后置处理器。其中包含将@Autowired，@Value等信息放到injectionMetadataCache中的逻辑，以后执行的populateBean会从中取值，完成依赖注入
							applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
							// 赋值。其中包括依赖注入，为此bean的成员变量完成赋值
							populateBean(beanName, mbd, instanceWrapper);
								
								// 遍历调用InstantiationAwareBeanPostProcessor类型的后置处理器
								ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName);
								...
                                // 此过程包含AutowiredAnnotationBeanPostProcessor将@Autowired注解的对象注入到当前bean中
								ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
							// 初始化。执行Aware接口方法，执行后置处理器，执行初始化方法
							exposedObject = initializeBean(beanName, exposedObject, mbd);
								
								// 若是实现了如下接口就执行BeanNameAware\BeanClassLoaderAware\BeanFactoryAware的接口方法
								invokeAwareMethods(beanName, bean);
								// 执行后置处理器的postProcessBeforeInitialization方法。其中包含执行@PostConstruct指定的初始化方法
								wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
								// 执行初始化方法。先执行实现了InitializingBean接口的方法再执行@Bean指定的初始化方法
								invokeInitMethods(beanName, wrappedBean, mbd);
								// 执行后置处理器的applyBeanPostProcessorsAfterInitialization方法。其中包含建立并返回aop代理对象的后置处理器
							// 注册销毁方法
							registerDisposableBeanIfNecessary(beanName, bean, mbd);

					// 将bean添加到容器中
					addSingleton(beanName, singletonObject);
		全部Bean都利用getBean建立完成之后：
        检查全部的Bean是不是SmartInitializingSingleton接口的；若是是；就执行afterSingletonsInstantiated()；

finishRefresh()

作一些收尾工做

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程