一,Spring启动流程概述
Spring的IoC容器在实现控制反转和依赖注入的过程中,可以划分为两个阶段:
-
容器启动阶段
-
Bean实例化阶段
容器初始化
容器实例化
-
根据策略实例化对象
-
装配依赖
-
Bean初始化前处理
-
对象初始化
-
对象其他处理
-
注册回调接口
二,Spring启动流程详解
调用后处理器
protected void invokebeanfactoryPostProcessors(ConfigurableListablebeanfactory beanfactory) {
PostProcessorRegistrationDelegate.invokebeanfactoryPostProcessors(beanfactory, getbeanfactoryPostProcessors());
// Detect a LoadTimeweaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClasspostProcessor)
if (beanfactory.getTempClassLoader() == null && beanfactory.containsBean(LOAD_TIME_weaveR_BEAN_NAME)) {
beanfactory.addBeanPostProcessor(new LoadTimeweaverAwareProcessor(beanfactory));
beanfactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanfactory.getBeanClassLoader()));
}
}
beanfactoryPostProcessor
beanfactoryPostProcessor接口与BeanPostProcessor相似,但有一个主要区别:beanfactoryPostProcessor用来操作Bean的配置元数据。也就是说,Spring IoC容器允许beanfactoryPostProcessor读取配置元数据,并能在容器实例化任何Bean之前更改这些元数据。换句话说 :就是可以让我们随心所欲地修改beanfactory内所有BeanDeFinition定义数据。
BeanDeFinitionRegistryPostProcessor 是对标准beanfactoryPostProcessor的扩展,允许在进行常规beanfactoryPostProcessor检测之前注册其他Bean定义。特别是,BeanDeFinitionRegistryPostProcessor注册的Bean定义又定义了beanfactoryPostProcessor实例。
使用示例
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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="xxx.xxx.processor.Car">
<property name="name" value="benz"/>
</bean>
<bean id="carbeanfactoryPostProcessor1"
class="xxx.xxx.processor.CarbeanfactoryPostProcessor1">
<property name="order" value="0" />
</bean>
<bean id="carbeanfactoryPostProcessor2"
class="xxx.xxx.processor.CarbeanfactoryPostProcessor2">
<property name="order" value="1" />
</bean>
</beans>
自定义beanfactoryPostProcessor
// 1号后置处理器
public class CarbeanfactoryPostProcessor1 implements beanfactoryPostProcessor, Ordered {
int order;
@Override
public void postProcessbeanfactory(ConfigurableListablebeanfactory beanfactory)
throws BeansException {
System.out.println("=======> 执行CarbeanfactoryPostProcessor1");
BeanDeFinition bd = beanfactory.getBeanDeFinition("car");
bd.getPropertyValues().addPropertyValue("name", "bmw");
}
public void setorder(int order) {
this.order = order;
}
@Override
public int getorder() {
return order;
}
}
// 2号后置处理器
public class CarbeanfactoryPostProcessor2 implements beanfactoryPostProcessor, Ordered {
int order;
@Override
public void postProcessbeanfactory(ConfigurableListablebeanfactory beanfactory)
throws BeansException {
System.out.println("=======> 执行CarbeanfactoryPostProcessor2");
BeanDeFinition bd = beanfactory.getBeanDeFinition("car");
bd.getPropertyValues().addPropertyValue("color", "red");
}
public void setorder(int order) {
this.order = order;
}
@Override
public int getorder() {
return order;
}
}
// 实现BeanDeFinitionRegistryPostProcessor接口的后处理器类
public class MobilebeanfactoryPostProcessor implements BeanDeFinitionRegistryPostProcessor {
@Override
public void postProcessBeanDeFinitionRegistry(BeanDeFinitionRegistry registry) throws BeansException {
System.out.println("=======> 执行MobilebeanfactoryPostProcessor_1");
BeanDeFinitionBuilder beanDeFinitionBuilder = BeanDeFinitionBuilder.genericBeanDeFinition(Mobile.class);
registry.registerBeanDeFinition("mobile", beanDeFinitionBuilder.getBeanDeFinition());
}
@Override
public void postProcessbeanfactory(ConfigurableListablebeanfactory beanfactory) throws BeansException {
System.out.println("=======> 执行MobilebeanfactoryPostProcessor_2");
BeanDeFinition bd = beanfactory.getBeanDeFinition("mobile");
bd.getPropertyValues().addPropertyValue("number", "123");
}
}
可以在项目中配置多个beanfactoryPostProcessor,同时通过设置Order属性来控制这些beanfactoryPostProcessor的执行顺序,当然仅当beanfactoryPostProcessor实现Ordered接口时,才可以设置此属性。
Spring排序接口
Spring框架中有很多实现了相同接口的类,那么这些实现类之间必定会有优先级的问题。Spring提供了Ordered接口来处理相同接口实现类的优先级问题。Ordered接口,顾名思义,就是用来排序的。
流程源码分析
源码流程
源码解析
public static void invokebeanfactoryPostProcessors(
ConfigurableListablebeanfactory beanfactory, List<beanfactoryPostProcessor> beanfactoryPostProcessors) {
// 临时缓存,用来记录已经调用过的beanfactoryPostProcessor
Set<String> processedBeans = new HashSet<String>();
// 如果beanfactory实现了BeanDeFinitionRegistry接口
// 从类图上可以看到其实是指DefaultListablebeanfactory或者GenericApplicationContext
if (beanfactory instanceof BeanDeFinitionRegistry) {
BeanDeFinitionRegistry registry = (BeanDeFinitionRegistry) beanfactory;
// 存放普通beanfactoryPostProcessor
List<beanfactoryPostProcessor> regularPostProcessors = new LinkedList<beanfactoryPostProcessor>();
// 存放BeanDeFinitionRegistryPostProcessor
List<BeanDeFinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDeFinitionRegistryPostProcessor>();
// 循环applicationContext中已经注册的beanfactoryPostProcessor
for (beanfactoryPostProcessor postProcessor : beanfactoryPostProcessors) {
// 如果是实现了BeanDeFinitionRegistryPostProcessor的后处理器
if (postProcessor instanceof BeanDeFinitionRegistryPostProcessor) {
BeanDeFinitionRegistryPostProcessor registryProcessor =
(BeanDeFinitionRegistryPostProcessor) postProcessor;
// 执行postProcessBeanDeFinitionRegistry回调
registryProcessor.postProcessBeanDeFinitionRegistry(registry);
// 把该后处理器加入到registryProcessors
registryProcessors.add(registryProcessor);
}
else {
// 否则就是普通的后处理器
regularPostProcessors.add(postProcessor);
}
}
// 在这里先不初始化factorybeans,因为需要保留这些Beans让beanfactoryPostProcessor进行处理
// BeanDeFinitionRegistryPostProcessor将按照PriorityOrdered,Ordered进行分类
// 临时缓存,用来记录待执行回调方法的beanfactoryPostProcessor
List<BeanDeFinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDeFinitionRegistryPostProcessor>();
// 首先,处理实现了PriorityOrdered接口的BeanDeFinitionRegistryPostProcessor
String[] postProcessorNames =
beanfactory.getBeanNamesForType(BeanDeFinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanfactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 保存到待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.add(beanfactory.getBean(ppName, BeanDeFinitionRegistryPostProcessor.class));
// 保存到已经执行过beanfactoryPostProcess回调的缓存
processedBeans.add(ppName);
}
}
// 对待执行缓存进行排序
sortPostProcessors(currentRegistryProcessors, beanfactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行beanfactoryPostProcess的回调函数
invokeBeanDeFinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.clear();
// 其次,再处理实现了Ordered接口的BeanDeFinitionRegistryPostProcessor
Next, invoke the BeanDeFinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanfactory.getBeanNamesForType(BeanDeFinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanfactory.isTypeMatch(ppName, Ordered.class)) {
// 保存到待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.add(beanfactory.getBean(ppName, BeanDeFinitionRegistryPostProcessor.class));
// 保存到已经执行过beanfactoryPostProcess回调的缓存
processedBeans.add(ppName);
}
}
// 对待执行缓存进行排序
sortPostProcessors(currentRegistryProcessors, beanfactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行beanfactoryPostProcess的回调函数
invokeBeanDeFinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.clear();
// 最后,处理所有其他BeanDeFinitionRegistryPostProcessor
boolean reiterate = true;
// 循环处理其他BeanDeFinitionRegistryPostProcessor
while (reiterate) {
reiterate = false;
// 把所有实现BeanDeFinitionRegistryPostProcessor的类名取出来
postProcessorNames = beanfactory.getBeanNamesForType(BeanDeFinitionRegistryPostProcessor.class, true, false);
// 遍历postProcessorNames
for (String ppName : postProcessorNames) {
// 已经处理过的缓存不包含该类名
if (!processedBeans.contains(ppName)) {
// 保存到待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.add(beanfactory.getBean(ppName, BeanDeFinitionRegistryPostProcessor.class));
// 保存到已经执行过beanfactoryPostProcess回调的缓存
processedBeans.add(ppName);
reiterate = true;
}
}
// 对待执行缓存进行排序
sortPostProcessors(currentRegistryProcessors, beanfactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行beanfactoryPostProcess的回调函数
invokeBeanDeFinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空待执行beanfactoryPostProcess回调的缓存
currentRegistryProcessors.clear();
}
// 处理所有处理器,并执行postProcessbeanfactory回调
invokebeanfactoryPostProcessors(registryProcessors, beanfactory);
invokebeanfactoryPostProcessors(regularPostProcessors, beanfactory);
}
else {
// 调用在上下文中注册的工厂处理器
invokebeanfactoryPostProcessors(beanfactoryPostProcessors, beanfactory);
}
// 在这里不初始化factorybeans,因为需要让beanfactoryPostProcessor来进行处理
// 获取所有实现了beanfactoryPostProcessor接口的类名称
String[] postProcessorNames =
beanfactory.getBeanNamesForType(beanfactoryPostProcessor.class, true, false);
// 实现了PriorityOrdered接口的PostProcessor缓存
List<beanfactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<beanfactoryPostProcessor>();
// 实现了Ordered接口的PostProcessor缓存
List<String> orderedPostProcessorNames = new ArrayList<String>();
// 没有实现任何Order接口的PostProcessor缓存
List<String> nonorderedPostProcessorNames = new ArrayList<String>();
// 遍历postProcessorNames开始处理beanfactoryPostProcessor
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 如果包含,代表在上面的代码已经处理过则跳过
}
// 首先,处理实现了PriorityOrdered接口的beanfactoryPostProcessor
else if (beanfactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanfactory.getBean(ppName, beanfactoryPostProcessor.class));
}
// 其次,处理实现了Ordered接口的beanfactoryPostProcessor
else if (beanfactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 最后,处理没有实现任何Order接口接口的beanfactoryPostProcessor
else {
nonorderedPostProcessorNames.add(ppName);
}
}
// 首先,处理实现了PriorityOrdered接口的beanfactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanfactory);
invokebeanfactoryPostProcessors(priorityOrderedPostProcessors, beanfactory);
// // 其次,再处理实现了Ordered接口的beanfactoryPostProcessor
List<beanfactoryPostProcessor> orderedPostProcessors = new ArrayList<beanfactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanfactory.getBean(postProcessorName, beanfactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanfactory);
invokebeanfactoryPostProcessors(orderedPostProcessors, beanfactory);
// // 最后,处理所有其他beanfactoryPostProcessor
List<beanfactoryPostProcessor> nonorderedPostProcessors = new ArrayList<beanfactoryPostProcessor>();
for (String postProcessorName : nonorderedPostProcessorNames) {
nonorderedPostProcessors.add(beanfactory.getBean(postProcessorName, beanfactoryPostProcessor.class));
}
invokebeanfactoryPostProcessors(nonorderedPostProcessors, beanfactory);
// 清除被缓存的BeanDeFinition,因为后处理器可能已经修改了原始元数据,例如:替换占位符
beanfactory.clearMetadataCache();
}
原文地址:https://www.jb51.cc/wenti/3287547.html
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。