首页  思维导图  详情

spring源码脑图

2021-07-04 16:47:56   39  举报





AI智能生成

源码脑图

源码

作者其他创作

大纲/内容

refresh()

//1、初始化前的预处理
prepareRefresh();

//2、获取BeanFactory，加载所有xml配置文件中的bean定义信息（未实例化）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//刷新BeanFactory（包含配置文件的加载和解析）
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();

//加载配置文件
loadBeanDefinitions(beanFactory);

//XML配置文件由XmlBeanDefinitionReader解析
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

//使用xml解析器，解析xml配置文件
loadBeanDefinitions(beanDefinitionReader);

//加载配置文件资源路径的xml配置文件
reader.loadBeanDefinitions(configLocations);

//真正干活的
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

//重点：registerBeanDefinitions
return registerBeanDefinitions(doc, resource);

BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

//解析
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

doRegisterBeanDefinitions(root);

//取<bean>上的profile属性，并根据Environment中配置好的profile决定是否继续解析（profile过滤）
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

//解析xml
parseBeanDefinitions(root, this.delegate);

////解析<bean>标签
processBeanDefinition(ele, delegate);

//解析xml元素为BeanDefinition
//bdHolder内部组合了BeanDefinition
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

//BeanDefinition注册到BeanDefinitionRegistry
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

//3、BeanFactory的预处理配置
prepareBeanFactory(beanFactory);

//4、准备BeanFactory完成后进行的后置处理
postProcessBeanFactory(beanFactory);

//5、执行BeanFactory创建后的后置处理器
invokeBeanFactoryPostProcessors(beanFactory);

//交给代理执行
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

1、将BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor分离开

registryProcessor.postProcessBeanDefinitionRegistry(registry);

//解析配置类（解析配置类中的定义的bean，并封装为BeanDefinition）
processConfigBeanDefinitions(registry);

//筛选出所有的配置类

//配置类的排序

//构造默认的BeanNameGenerator bean的名称生成器

//真正解析配置类的组件：ConfigurationClassParser
ConfigurationClassParser parser

//解析配置类
parser.parse(candidates);

子主题

//编程式注入配置类

//其他情况

//回调特殊的ImportSelectors，DeferredImportSelectors它的执行时机比ImportSelectors更晚，
// 它会在注解配置类的所有解析工作完成后才执行
processDeferredImportSelectors();

//加载配置类的内容
this.reader.loadBeanDefinitions(configClasses);

loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);

//与条件配置有关

//如果当前配置类是被@Import的，要把自己注册进BeanFactory

registerBeanDefinitionForImportedConfigurationClass(configClass);

//构造AnnotatedGenericBeanDefinition

//包装BeanDefinitionHolder

//注册进BeanDefinitionRegistry

//注册@Bean注解方法（在解析阶段，只是对@Bean加入的处理）

loadBeanDefinitionsForBeanMethod(beanMethod);

//如果条件装配将其跳过，则该@Bean标注的方法，对应的BeanDefinition不会注册进BeanDefinitionRegistry

//检查方法上真的有@Bean注解吗

//如果bean指定了多个name，则第一个作为为唯一标识，其余都是alias别名

//注解中配置了@Bean，与xml中的bean撞车了，会抛出异常

//构造ConfigurationClassBeanDefinition

//【复杂】解析@Bean所在方法的修饰符

//处理@Bean的属性（name，initMethod等），额外的注解（@Lazy，@DependsOn等）

//注册进BeanDefinitionRegistry

//注册来自xml配置文件的bean（使用XmlBeanDefinitionReader搞的）
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

//注册来自ImportBeanDefinitionRegistrars的bean
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

//一些额外处理动作

1、执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法

（1）执行实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor

（2）执行实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessor

（3）执行普通的 BeanDefinitionRegistryPostProcessor

2、执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法

同上

3、执行BeanFactoryPostProcessor 的 postProcessBeanFactory 方法

同上

//6、注册bean的后置处理器
registerBeanPostProcessors(beanFactory);

PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

//获取ioc容器中已经有的BeanPostProcessor的name

//1.1此处会先注册一个BeanPostProcessorChecker

//根据排序规则，给所有的后置处理器分类

//1.2注意此处，PriorityOrdered类型的后置处理器被提前初始化了(防止优先级低的后置处理器干预了优先级高的后置处理器，从而引发程序的运行情况异常)

//MergedBeanDefinitionPostProcessor要额外筛选出来

//首先，注册所有实现了PriorityOrdered接口的后置处理器

//其次，注册所有实现了Ordered接口的后置处理器

//最后注册所有普通的后置处理器

//1.3注意此处，所有的MergedBeanDefinitionPostProcessor又被注册了一次

//最后又注册了一个ApplicationListenerDetector

//7、初始化MessageSource
initMessageSource();

//8、初始化事件派发器
initApplicationEventMulticaster();

//9、子类的多态onRefresh
onRefresh();

//10、注册监听器
registerListeners();

//到此为止BeanFactory已创建完成
// Instantiate all remaining (non-lazy-init) singletons.
//11、初始化所有剩下的单例bean
finishBeanFactoryInitialization(beanFactory);

//处理单实例bean的初始化
beanFactory.preInstantiateSingletons();

//此处循环初始化剩余的非延迟加载的单实例bean

//先合并BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

//不是抽象的、不是延迟加载的单实例bean要初始化

//普通的初始化，就是getBean方法
getBean(beanName);

return doGetBean(name, requiredType, null, false);

//处理bean的alias

//循环依赖的探测

//如果原型bean之间互相依赖，则一定会引发无限循环，此处会抛出循环依赖的异常

//如果本地不存在当前bean的定义信息，则尝试让父容器实例化bean
//此举可以保证每个BeanFactory持有它应该有的bean，而不是所有的bean都集中在某一个BeanFactory中

//标记当前bean已经开始创建了

//此处会合并BeanDefinition，并检查是否为抽象类（abstract则会抛出无法实例化的异常）
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

//核心逻辑：它会自上而下递归寻找父BeanDefinition，再从上而下合并获得最终的BeanDefinition

return getMergedBeanDefinition(beanName, bd, null);

//此处会处理当前bean依赖的bean的初始化

//单实例bean的初始化，如果缓存中没有，最终调用createBean

getSingleton

//加锁后，再查一次单实例bean的缓存

/【createBean】如果单实例bean的缓存中真的没有，那就创建对象（即外面的lamda表达式中的createBean方法）

//新创建的单实例bean要存入单实例bean的缓存中
addSingleton(beanName, singletonObject);

return createBean(beanName, mbd, args);

//给后置处理器一个机会来创建代理bean而不是目标bean实例
//【后置处理器拦截创建bean】
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

//执行所有InstantiationAwareBeanPostProcessor
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//如果成功创建出了bean，则执行BeanPostProcessors的后置初始化
//我们说postProcessorsAfterInitialization方法的一个关键作用是生成代理对象，如果一个bean被
//InstantiationAwareBeanPostProcessor提前创建出了bean，但又需要创建代理对象，这个时候
//就必须要回调postProcessorsAfterInitialization
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

//真正的创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);

进入到这个方法，那就相当于要真实的中规中矩的创建 bean 对象了！这个方法中共有三个大步骤：

1、实例化 bean 对象（此时 bean 中所有属性均为空）
2、属性赋值 & 依赖注入
3、bean 对象的初始化（执行完该步骤后 bean 已经完整）

//处理FactoryBean的小细节问题

//factoryBeanInstanceCache的作用：获取到FactoryBean中生成的bean的类型。

//【真正的bean对象创建】
instanceWrapper = createBeanInstance(beanName, mbd, args);

//解析出bean的类型
Class<?> beanClass = resolveBeanClass(mbd, beanName);

//bean无法被访问，则抛出异常

//【工厂方法创建】

//这一步是为原型bean的一个小优化（由于原型bean的创建过程中，每次的执行流程都是一样的，所以执行一次后，把这个过程中
// 一些需要的东西缓存起来，以备后续再创建该bean是可以直接拿这些信息，去创建bean对象）

//当满足任一条件，就会执行基于构造器的实例化
//1、通过SmartInstantiationAwareBeanPostProcessor找到了构造器
//2、配置了注入方式是AUTOWIRE_CONSTRUCTOR
//3、定义bean的时候指定了constructor-arg
//4、构造bean时传入了args参数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}

//使用默认的无参构造器反射创建bean对象
return instantiateBean(beanName, mbd);

//得到真实的bean对象引用

//回调MergedBeanDefinitionPostProcessor（处理相关注解）

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

InitDestroyAnnotationBeanPostProcessor实现类

//处理初始化和销毁注解的后置处理器
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
//查找bean的生命周期元信息
LifecycleMetadata metadata = findLifecycleMetadata(beanType);
metadata.checkConfigMembers(beanDefinition);
}

//用到缓存机制，把bean的初始化和销毁注解信息都保存到lifecycleMetadataCache里

return buildLifecycleMetadata(clazz);

//反射所有的public方法

//寻找所有被初始化注解（@PostConstruct）标注的方法

//寻找所有被销毁注解（@PreDestroy）标注的方法

CommonAnnotationBeanPostProcessor实现类

//调用InitDestroyAnnotationBeanPostProcessor
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);

//收集注入相关的信息
InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);

//额外收集了@Resource注解的信息

metadata = buildResourceMetadata(clazz);

AutowiredAnnotationBeanPostProcessor实现类

//已经指定好默认支持@Autowire注解、@Value注解、如果 classpath 下有来自 JSR 330 的 @Inject 注解，也会一并支持

//早期bean对象引用的获取与缓存（bean被实例化出来以后还没有进行属性赋值和组件的依赖注入，但此时的bean对象已经实实在在的存在了
// 。如果在此期间，有另外的bean又需要创建它时，就不应该再创建同样的一个bean对象，而是直接拿到该引用）

//属性赋值+依赖注入
populateBean(beanName, mbd, instanceWrapper);

//检查BeanWrapper是否存在

//回调InstantiationAwareBeanPostProcessors（postProcessAfterInstantiation方法也是干预bean的属性等东西。
// 而且postProcessAfterInstantiation方法返回的boolean类型，当postProcessAfterInstantiation返回false时，
// 会直接return出去，不再执行下面的属性赋值+组件依赖注入的逻辑。
// 这个回调的位置，就是让咱在bean已经初始化好，但还没有开始属性赋值和依赖注入时切入自定义逻辑）

//解析出当前bean支持的自动注入模式

//它将这个过程中需要组件依赖注入的信息也封装进了PropertyValues中了，所以此时pvs就应该有一开始封装的信息，
//以及通过自动注入封装好的依赖信息
pvs = newPvs;

//又回调InstantiationAwareBeanPostProcessor

//【核心】回调postProcessProperties（传入pvs返回pvs，这个过程相当于反复给pvs封装数据）
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

AutowiredAnnotationBeanPostProcessor实现类

//收集注解信息
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);

//真正的给bean对象属性赋值（注意点：在BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor
// 中无法使用@Autowire直接注入spring中的内部组件（如Environment），因为当BeanDefinitionRegistryPostProcessor
// 在初始化阶段，还不存在BeanPostProcessor呢，所以那些用于支持依赖注入的后置处理器（AutowiredAnnotationBeanPostProcessor）
// 还没有被初始化，自然也就没办法支持注入了。正确的做法是借助Aware接口的回调注入）
metadata.inject(bean, beanName, pvs);

//收集所有需要注入的信息
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);

//迭代，依次注入

element.inject(target, beanName, pvs);

//反射注入字段
Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));

//反射调用setter方法
Method method = (Method) this.member;
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));

//将PropertyValues应用给bean
applyPropertyValues(beanName, mbd, bw, pvs);

//预检查和准备

//重复解析的提前返回

//BeanDefinitionValueResolver的初始化需要传入一个TypeConverter，而这个TypeConverter是spring中内部用于
//类型转换的核心api。简单来说，使用TypeConverter可以将一个`String类型的数据，转换为特定的所需要的类型的数据。
//而BeanDefinitionValueResolver就利用TypeConverter，完成对bean实例中需要注入的属性值进行解析，并适配
//为bean所需要的类型（如String->int，依赖的bean的名称转为实际bean的引用）
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

//类型转换（不是重点）

//把pvs中的属性值全部应用到bean对象中。
bw.setPropertyValues(new MutablePropertyValues(deepCopy));

//此时bean中的属性都是齐全的了
exposedObject = initializeBean(beanName, exposedObject, mbd);

//执行aware回调
invokeAwareMethods(beanName, bean);

//如果bean实现了BeanNameAware，则强转后调用setBeanName方法注入bean的名称

//如果bean实现了BeanClassLoaderAware，则强转后调用setBeanClassLoader方法注入当前的classLoader

//如果bean实现了BeanFactoryAware，则强转后调用setBeanFactory方法注入BeanFactory

//执行BeanPostProcessor的前置回调
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

InitDestroyAnnotationBeanPostProcessor实现类

//findLifecycleMetadata方法把标注了@PostConstruct 和 @PreDestroy的方法都提取出来，所以这里就相当于回调@PostConstruct
//标注的方法
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}

ApplicationContextAwareProcessor实现类

由此我们可以先得出一个结论：BeanFactory 的注入时机比 ApplicationContext 早。

//执行生命周期回调
invokeInitMethods(beanName, wrappedBean, mbd);

//回调InitializingBean的afterPropertiesSet方法
((InitializingBean) bean).afterPropertiesSet();

//回调init-method方法（同样是反射调用）
invokeCustomInitMethod(beanName, bean, mbd);

//执行BeanPostProcessor的后置回调
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

AbstractAutoProxyCreator实现类

//创建代理对象
return wrapIfNecessary(bean, beanName, cacheKey);

ApplicationListenerDetector实现类

这个 ApplicationListenerDetector它用来关联所有的监听器引用。同样的，监听器在创建的时候，也需要 ApplicationListenerDetector 把这些监听器挂进 ApplicationContext 中，这样这些监听器才可以被事件广播器使用。

//注册销毁时的回调（如果一个bean定义的class有实现DisposableBean接口，或者声明了@@PreDestroy注解，或者声明了
// destroy-method方法，则会在doCreateBean的方法最后一步，注册一个销毁bean的回调钩子）
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}

//不是原型bean，且有定义销毁类型的方法

//处理特殊的scope

//原型bean的初始化，直接调用createBean

//处理自定义的scope

//类型强转前的检查

//初始化的最后阶段

//12、完成容器的创建工作
finishRefresh();

//清楚上下文级别的资源缓存
clearResourceCaches();

//为当前ApplicationContext初始化一个生命周期处理器
initLifecycleProcessor();

无论 BeanFactory 中有没有 LifecycleProcessor ，它都会保证最终容器中会有，注意它的实现类是 DefaultLifecycleProcessor

//将refresh的动作传播到生命周期处理器
getLifecycleProcessor().onRefresh();

startBeans(true);
this.running = true;

//广播事件
publishEvent(new ContextRefreshedEvent(this));

start()

close()

doClose();

//广播 ContextClosedEvent 事件
publishEvent(new ContextClosedEvent(this));

//销毁bean
destroyBeans();

//获取到 ApplicationContext 内部的 BeanFactory ，让它去销毁所有的单实例 bean 。
getBeanFactory().destroySingletons();

DefaultListableBeanFactory实现类

super.destroySingletons();
//清空单实例bean的名称
this.manualSingletonNames.clear();
// 清空“类型到 name ” 的映射。（
// allBeanNamesByType 中保存了 bean 的类型包含的所有 bean ，如 Person 类型的 bean 在 IOC 容器中包含 master 和 admin ）
clearByTypeCache();

DefaultSingletonBeanRegistry实现类

//销毁所有单实例bean
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
//重载的 destroySingleton(beanName)
destroySingleton(disposableBeanNames[i]);
}

//此处会处理掉BeanFactory中设计的用于处理bean循环依赖的三级缓存
removeSingleton(beanName);

//回调 bean 的销毁动作

destroyBean(beanName, disposableBean);

//在销毁一个 bean 时，如果它有依赖其它的 bean ，则首要目标不是销毁自己，而是先销毁那些依赖的 bean ，递归销毁

//自定义bean销毁方法的回调

bean.destroy();

//回调DestructionAwareBeanPostProcessor
//此处会有执行@PreDestoty注解标注的方法

//回调DisposableBean接口的destroy方法
((DisposableBean) bean).destroy();

//回调自定义的destroy-method方法

//处理bean中的bean

//销毁依赖的bean

/清空一切缓存