SYSTEM
IOC
src/content/notes/system/IOC.md IOC
容器启动
Spring IOC 容器是 ApplicationContext 或者 BeanFactory,使用多个 Map 集合保存单实例 Bean,环境信息等资源,不同层级有不同的容器,比如整合 SpringMVC 的父子容器(先看 Bean 部分的源码解析再回看容器)
ClassPathXmlApplicationContext 与 AnnotationConfigApplicationContext 差不多:
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);// 解析配置类,封装成一个 BeanDefinitionHolder,并注册到容器
refresh();// 加载刷新容器中的 Bean
}
public AnnotationConfigApplicationContext() {
// 注册 Spring 的注解解析器到容器
this.reader = new AnnotatedBeanDefinitionReader(this);
// 实例化路径扫描器,用于对指定的包目录进行扫描查找 bean 对象
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
AbstractApplicationContext.refresh():
-
prepareRefresh():刷新前的预处理
this.startupDate = System.currentTimeMillis():设置容器的启动时间initPropertySources():初始化一些属性设置,可以自定义个性化的属性设置方法getEnvironment().validateRequiredProperties():检查环境变量earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>():保存容器中早期的事件
-
obtainFreshBeanFactory():获取一个全新的 BeanFactory 接口实例,如果容器中存在工厂实例直接销毁
refreshBeanFactory():创建 BeanFactory,设置序列化 ID、读取 BeanDefinition 并加载到工厂if (hasBeanFactory()):applicationContext 内部拥有一个 beanFactory 实例,需要将该实例完全释放销毁destroyBeans():销毁原 beanFactory 实例,将 beanFactory 内部维护的单实例 bean 全部清掉,如果哪个 bean 实现了 Disposablejie接口,还会进行 bean distroy 方法的调用处理this.singletonsCurrentlyInDestruction = true:设置当前 beanFactory 状态为销毁状态String[] disposableBeanNames:获取销毁集合中的 bean,如果当前 bean 有析构函数就会在销毁集合destroySingleton(disposableBeanNames[i]):遍历所有的 disposableBeans,执行销毁方法removeSingleton(beanName):清除三级缓存和 registeredSingletons 中的当前 beanName 的数据this.disposableBeans.remove(beanName):从销毁集合中清除,每个 bean 只能 destroy 一次destroyBean(beanName, disposableBean):销毁 bean- dependentBeanMap 记录了依赖当前 bean 的其他 bean 信息,因为依赖的对象要被回收了,所以依赖当前 bean 的其他对象都要执行 destroySingleton,遍历 dependentBeanMap 执行销毁
bean.destroy():解决完成依赖后,执行 DisposableBean 的 destroy 方法this.dependenciesForBeanMap.remove(beanName):保存当前 bean 依赖了谁,直接清除
- 进行一些集合和缓存的清理工作
closeBeanFactory():将容器内部的 beanFactory 设置为空,重新创建beanFactory = createBeanFactory():创建新的 DefaultListableBeanFactory 对象beanFactory.setSerializationId(getId()):进行 ID 的设置,可以根据 ID 获取 BeanFactory 对象customizeBeanFactory(beanFactory):设置是否允许覆盖和循环引用loadBeanDefinitions(beanFactory):加载 BeanDefinition 信息,注册 BD注册到 BeanFactory 中this.beanFactory = beanFactory:把 beanFactory 填充至容器中
getBeanFactory():返回创建的 DefaultListableBeanFactory 对象,该对象继承 BeanDefinitionRegistry -
prepareBeanFactory(beanFactory):BeanFactory 的预准备工作,向容器中添加一些组件
setBeanClassLoader(getClassLoader()):给当前 bf 设置一个类加载器,加载 bd 的 class 信息setBeanExpressionResolver():设置 EL 表达式解析器addPropertyEditorRegistrar:添加一个属性编辑器,解决属性注入时的格式转换addBeanPostProcessor():添加后处理器,主要用于向 bean 内部注入一些框架级别的实例ignoreDependencyInterface():设置忽略自动装配的接口,bean 内部的这些类型的字段 不参与依赖注入registerResolvableDependency():注册一些类型依赖关系addBeanPostProcessor():将配置的监听者注册到容器中,当前 bean 实现 ApplicationListener 接口就是监听器事件beanFactory.registerSingleton():添加一些系统信息
-
postProcessBeanFactory(beanFactory):BeanFactory 准备工作完成后进行的后置处理工作,扩展方法
-
invokeBeanFactoryPostProcessors(beanFactory):执行 BeanFactoryPostProcessor 的方法
-
processedBeans = new HashSet<>():存储已经执行过的 BeanFactoryPostProcessor 的 beanName -
if (beanFactory instanceof BeanDefinitionRegistry):当前 BeanFactory 是 bd 的注册中心,bd 全部注册到 bf -
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors):遍历所有的 bf 后置处理器 -
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor):是 Registry 类的后置处理器registryProcessor.postProcessBeanDefinitionRegistry(registry):向 bf 中注册一些 bdregistryProcessors.add(registryProcessor):添加到 BeanDefinitionRegistryPostProcessor 集合 -
regularPostProcessors.add(postProcessor):添加到 BeanFactoryPostProcessor 集合 -
逻辑到这里已经获取到所有 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 接口类型的后置处理器
-
首先回调 BeanDefinitionRegistryPostProcessor 类的后置处理方法 postProcessBeanDefinitionRegistry()
-
获取实现了 PriorityOrdered(主排序接口)接口的 bdrpp,进行 sort 排序,然后全部执行并放入已经处理过的集合
-
再执行实现了 Ordered(次排序接口)接口的 bdrpp
-
最后执行没有实现任何优先级或者是顺序接口 bdrpp,
boolean reiterate = true控制 while 是否需要再次循环,循环内是查找并执行 bdrpp 后处理器的 registry 相关的接口方法,接口方法执行以后会向 bf 内注册 bd,注册的 bd 也有可能是 bdrpp 类型,所以需要该变量控制循环 -
processedBeans.add(ppName):已经执行过的后置处理器存储到该集合中,防止重复执行 -
invokeBeanFactoryPostProcessors():bdrpp 继承了 BeanFactoryPostProcessor,有 postProcessBeanFactory 方法
-
-
执行普通 BeanFactoryPostProcessor 的相关 postProcessBeanFactory 方法,按照主次无次序执行
if (processedBeans.contains(ppName)):会过滤掉已经执行过的后置处理器
-
beanFactory.clearMetadataCache():清除缓存中合并的 Bean 定义,因为后置处理器可能更改了元数据
-
以上是 BeanFactory 的创建及预准备工作,接下来进入 Bean 的流程
-
registerBeanPostProcessors(beanFactory):注册 Bean 的后置处理器,为了干预 Spring 初始化 bean 的流程,这里仅仅是向容器中注入而非使用
-
beanFactory.getBeanNamesForType(BeanPostProcessor.class):获取配置中实现了 BeanPostProcessor 接口类型 -
int beanProcessorTargetCount:后置处理器的数量,已经注册的 + 未注册的 + 即将要添加的一个 -
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker()):添加一个检查器BeanPostProcessorChecker.postProcessAfterInitialization():初始化后的后处理器方法!(bean instanceof BeanPostProcessor):当前 bean 类型是普通 bean,不是后置处理器!isInfrastructureBean(beanName):成立说明当前 beanName 是用户级别的 bean 不是 Spring 框架的this.beanFactory.getBeanPostProcessorCount() < this.beanPostProcessorTargetCount:BeanFactory 上面注册后处理器数量 < 后处理器数量,说明后处理框架尚未初始化完成
-
for (String ppName : postProcessorNames):遍历 PostProcessor 集合,根据实现不同的顺序接口添加到不同集合 -
sortPostProcessors(priorityOrderedPostProcessors, beanFactory):实现 PriorityOrdered 接口的后处理器排序registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors):注册到 beanFactory 中 -
接着排序注册实现 Ordered 接口的后置处理器,然后注册普通的( 没有实现任何优先级接口)后置处理器
-
最后排序 MergedBeanDefinitionPostProcessor 类型的处理器,根据实现的排序接口,排序完注册到 beanFactory 中
-
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)):重新注册 ApplicationListenerDetector 后处理器,用于在 Bean 创建完成后检查是否属于 ApplicationListener 类型,如果是就把 Bean 放到监听器容器中保存起来
-
-
initMessageSource():初始化 MessageSource 组件,主要用于做国际化功能,消息绑定与消息解析
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)):容器是否含有名称为 messageSource 的 beanbeanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class):如果有证明用户自定义了该类型的 bean,获取后直接赋值给 this.messageSourcedms = new DelegatingMessageSource():容器中没有就新建一个赋值
-
initApplicationEventMulticaster():初始化事件传播器,在注册监听器时会用到
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)):条件成立说明用户自定义了事件传播器,可以实现 ApplicationEventMulticaster 接口编写自己的事件传播器,通过 bean 的方式提供给 Spring- 如果有就直接从容器中获取;如果没有则创建一个 SimpleApplicationEventMulticaster 注册
-
onRefresh():留给用户去实现,可以硬编码提供一些组件,比如提供一些监听器
-
registerListeners():注册通过配置提供的 Listener,这些监听器最终注册到 ApplicationEventMulticaster 内
-
for (ApplicationListener<?> listener : getApplicationListeners()):注册编码实现的监听器 -
getBeanNamesForType(ApplicationListener.class, true, false):注册通过配置提供的 Listener -
multicastEvent(earlyEvent):发布前面步骤产生的事件 applicationEventsExecutor executor = getTaskExecutor():获取线程池,有线程池就异步执行,没有就同步执行
-
-
finishBeanFactoryInitialization():实例化非懒加载状态的单实例
-
beanFactory.freezeConfiguration():冻结配置信息,就是冻结 BD 信息,冻结后无法再向 bf 内注册 bd -
beanFactory.preInstantiateSingletons():实例化 non-lazy-init singletons-
for (String beanName : beanNames):遍历容器内所有的 beanDefinitionNames -
getMergedLocalBeanDefinition(beanName):获取与父类合并后的对象(Bean → 获取流程部分详解此函数) -
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()):BD 对应的 Class 满足非抽象、单实例,非懒加载,需要预先实例化if (isFactoryBean(beanName)):BD 对应的 Class 是 factoryBean 对象getBean(FACTORY_BEAN_PREFIX + beanName):获取工厂 FactoryBean 实例本身isEagerInit:控制 FactoryBean 内部管理的 Bean 是否也初始化getBean(beanName):初始化 Bean,获取 Bean 详解此函数
getBean(beanName):不是工厂 bean 直接获取 -
for (String beanName : beanNames):检查所有的 Bean 是否实现 SmartInitializingSingleton 接口,实现了就执行 afterSingletonsInstantiated(),进行一些创建后的操作
-
-
-
finishRefresh():完成刷新后做的一些事情,主要是启动生命周期clearResourceCaches():清空上下文缓存initLifecycleProcessor():初始化和生命周期有关的后置处理器,容器的生命周期if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)):成立说明自定义了生命周期处理器defaultProcessor = new DefaultLifecycleProcessor():Spring 默认提供的生命周期处理器beanFactory.registerSingleton():将生命周期处理器注册到 bf 的一级缓存和注册单例集合中
getLifecycleProcessor().onRefresh():获取该生命周期后置处理器回调 onRefresh(),调用startBeans(true)lifecycleBeans = getLifecycleBeans():获取到所有实现了 Lifecycle 接口的对象包装到 Map 内,key 是beanName, value 是 Lifecycle 对象int phase = getPhase(bean):获取当前 Lifecycle 的 phase 值,当前生命周期对象可能依赖其他生命周期对象的执行结果,所以需要 phase 决定执行顺序,数值越低的优先执行LifecycleGroup group = phases.get(phase):把 phsae 相同的 Lifecycle 存入 LifecycleGroupif (group == null):group 为空则创建,初始情况下是空的group.add(beanName, bean):将当前 Lifecycle 添加到当前 phase 值一样的 group 内Collections.sort(keys):从小到大排序,按优先级启动phases.get(key).start():遍历所有的 Lifecycle 对象开始启动doStart(this.lifecycleBeans, member.name, this.autoStartupOnly):底层调用该方法启动bean = lifecycleBeans.remove(beanName): 确保 Lifecycle 只被启动一次,在一个分组内被启动了在其他分组内就看不到 Lifecycle 了dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName):获取当前即将被启动的 Lifecycle 所依赖的其他 beanName,需要先启动所依赖的 bean,才能启动自身if ():传入的参数 autoStartupOnly 为 true 表示启动 isAutoStartUp 为 true 的 SmartLifecycle 对象,不会启动普通的生命周期的对象;false 代表全部启动- bean.start():调用启动方法
publishEvent(new ContextRefreshedEvent(this)):发布容器刷新完成事件liveBeansView.registerApplicationContext(this):暴露 Mbean
补充生命周期 stop() 方法的调用
-
DefaultLifecycleProcessor.stop():调用 DefaultLifecycleProcessor.stopBeans()
-
获取到所有实现了 Lifecycle 接口的对象并按 phase 数值分组的
-
keys.sort(Collections.reverseOrder()):按 phase 降序排序 Lifecycle 接口,最先启动的最晚关闭(责任链?) -
phases.get(key).stop():遍历所有的 Lifecycle 对象开始停止-
latch = new CountDownLatch(this.smartMemberCount):创建 CountDownLatch,设置 latch 内部的值为当前分组内的 smartMemberCount 的数量 -
countDownBeanNames = Collections.synchronizedSet(new LinkedHashSet<>()):保存当前正在处理关闭的smartLifecycle 的 BeanName -
for (LifecycleGroupMember member : this.members):处理本分组内需要关闭的 LifecycledoStop(this.lifecycleBeans, member.name, latch, countDownBeanNames):真正的停止方法-
getBeanFactory().getDependentBeans(beanName):获取依赖当前 Lifecycle 的其他对象的 beanName,因为当前的 Lifecycle 即将要关闭了,所有的依赖了当前 Lifecycle 的 bean 也要关闭 -
countDownBeanNames.add(beanName):将当前 SmartLifecycle beanName 添加到 countDownBeanNames 集合内,该集合表示正在关闭的 SmartLifecycle -
bean.stop():调用停止的方法
-
-
-
获取Bean
单实例:在容器启动时创建对象
多实例:在每次获取的时候创建对象
获取流程:获取 Bean 时先从单例池获取,如果没有则进行第二次获取,并带上工厂类去创建并添加至单例池
Java 启动 Spring 代码:
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
AbstractBeanFactory.doGetBean():获取 Bean,context.getBean() 追踪到此
-
beanName = transformedBeanName(name):name 可能是一个别名,重定向出来真实 beanName;也可能是一个 & 开头的 name,说明要获取的 bean 实例对象,是一个 FactoryBean 对象(IOC 原理 → 核心类)BeanFactoryUtils.transformedBeanName(name):判断是哪种 name,返回截取 & 以后的 name 并放入缓存transformedBeanNameCache.computeIfAbsent:缓存是并发安全集合,key == null || value == null 时 put 成功- do while 循环一直去除 & 直到不再含有 &
canonicalName(name):aliasMap 保存别名信息,其中的 do while 逻辑是迭代查找,比如 A 别名叫做 B,但是 B 又有别名叫 C, aliasMap 为 {“C”:“B”, “B”:“A”},get(C) 最后返回的是 A
-
DefaultSingletonBeanRegistry.getSingleton():第一次获取从缓存池获取(循环依赖详解此代码)- 缓存中有数据进行 getObjectForBeanInstance() 获取可使用的 Bean(本节结束部分详解此函数)
- 缓存中没有数据进行下面的逻辑进行创建
-
if(isPrototypeCurrentlyInCreation(beanName)):检查 bean 是否在原型(Prototype)正在被创建的集合中,如果是就报错,说明产生了循环依赖,原型模式解决不了循环依赖原因:先加载 A,把 A 加入集合,A 依赖 B 去加载 B,B 又依赖 A,去加载 A,发现 A 在正在创建集合中,产生循环依赖
-
markBeanAsCreated(beanName):把 bean 标记为已经创建,防止其他线程重新创建 Bean -
mbd = getMergedLocalBeanDefinition(beanName):获取合并父 BD 后的 BD 对象,BD 是直接继承的,合并后的 BD 信息是包含父类的 BD 信息-
this.mergedBeanDefinitions.get(beanName):从缓存中获取 -
if(bd.getParentName()==null):beanName 对应 BD 没有父 BD 就不用处理继承,封装为 RootBeanDefinition 返回 -
parentBeanName = transformedBeanName(bd.getParentName()):处理父 BD 的 name 信息 -
if(!beanName.equals(parentBeanName)):一般情况父子 BD 的名称不同pbd = getMergedBeanDefinition(parentBeanName):递归调用,最终返回父 BD 的父 BD 信息 -
mbd = new RootBeanDefinition(pbd):按照父 BD 信息创建 RootBeanDefinition 对象 -
mbd.overrideFrom(bd):子 BD 信息覆盖 mbd,因为是要以子 BD 为基准,不存在的才去父 BD 寻找(类似 Java 继承) -
this.mergedBeanDefinitions.put(beanName, mbd):放入缓存
-
-
checkMergedBeanDefinition():判断当前 BD 是否为抽象 BD,抽象 BD 不能创建实例,只能作为父 BD 被继承 -
mbd.getDependsOn():获取 bean 标签 depends-on -
if(dependsOn != null):遍历所有的依赖加载,解决不了循环依赖isDependent(beanName, dep):判断循环依赖,出现循环依赖问题报错-
两个 Map:
<bean name="A" depends-on="B" ...>- dependentBeanMap:记录依赖了当前 beanName 的其他 beanName(谁依赖我,我记录谁)
- dependenciesForBeanMap:记录当前 beanName 依赖的其它 beanName
- 以 B 为视角 dependentBeanMap {“B”:{“A”}},以 A 为视角 dependenciesForBeanMap {“A” :{“B”}}
-
canonicalName(beanName):处理 bean 的 name -
dependentBeans = this.dependentBeanMap.get(canonicalName):获取依赖了当前 bean 的 name -
if (dependentBeans.contains(dependentBeanName)):依赖了当前 bean 的集合中是否有该 name,有就产生循环依赖 -
进行递归处理所有的引用:假如
<bean name="A" dp="B"> <bean name="B" dp="C"> <bean name="C" dp="A">dependentBeanMap={A:{C}, B:{A}, C:{B}} // C 依赖 A 判断谁依赖了C 递归判断 谁依赖了B isDependent(C, A) → C#dependentBeans={B} → isDependent(B, A); → B#dependentBeans={A} //返回true
registerDependentBean(dep, beanName):把 bean 和依赖注册到两个 Map 中,注意参数的位置,被依赖的在前getBean(dep):先加载依赖的 Bean,又进入 doGetBean() 的逻辑 -
-
if (mbd.isSingleton()):判断 bean 是否是单例的 beangetSingleton(String, ObjectFactory<?>):第二次获取,传入一个工厂对象,这个方法更倾向于创建实例并返回sharedInstance = getSingleton(beanName, () -> { return createBean(beanName, mbd, args);//创建,跳转生命周期 //lambda表达式,调用了ObjectFactory的getObject()方法,实际回调接口实现的是 createBean()方法进行创建对象 });-
singletonObjects.get(beanName):从一级缓存检查是否已经被加载,单例模式复用已经创建的 bean -
this.singletonsCurrentlyInDestruction:容器销毁时会设置这个属性为 true,这时就不能再创建 bean 实例了 -
beforeSingletonCreation(beanName):检查构造注入的依赖,构造参数注入产生的循环依赖无法解决!this.singletonsCurrentlyInCreation.add(beanName):将当前 beanName 放入到正在创建中单实例集合,放入成功说明没有产生循环依赖,失败则产生循环依赖,进入判断条件内的逻辑抛出异常原因:加载 A,向正在创建集合中添加了 {A},根据 A 的构造方法实例化 A 对象,发现 A 的构造方法依赖 B,然后加载 B,B 构造方法的参数依赖于 A,又去加载 A 时来到当前方法,因为创建中集合已经存在 A,所以添加失败
-
singletonObject = singletonFactory.getObject():创建 bean(生命周期部分详解) -
创建完成以后,Bean 已经初始化好,是一个完整的可使用的 Bean
-
afterSingletonCreation(beanName):从正在创建中的集合中移出 -
addSingleton(beanName, singletonObject):添加一级缓存单例池中,从二级三级缓存移除
bean = getObjectForBeanInstance:单实例可能是普通单实例或者 FactoryBean,如果是 FactoryBean 实例,需要判断 name 是带 & 还是不带 &,带 & 说明 getBean 获取 FactoryBean 对象,否则是获取 FactoryBean 内部管理的实例-
参数 name 是未处理 & 的 name,beanName 是处理过 & 和别名后的 name
-
if(BeanFactoryUtils.isFactoryDereference(name)):判断 doGetBean 中参数 name 前是否带 &,不是处理后的 -
if(!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)):Bean 是普通单实例或者是 FactoryBean 就可以直接返回,否则进入下面的获取 FactoryBean 内部管理的实例的逻辑 -
getCachedObjectForFactoryBean(beanName):尝试到缓存获取,获取到直接返回,获取不到进行下面逻辑 -
if (mbd == null && containsBeanDefinition(beanName)):Spring 中有当前 beanName 的 BeanDefinition 信息mbd = getMergedLocalBeanDefinition(beanName):获取合并后的 BeanDefinition -
mbd.isSynthetic():默认值是 false 表示这是一个用户对象,如果是 true 表示是系统对象 -
object = getObjectFromFactoryBean(factory, beanName, !synthetic):从工厂内获取实例factory.isSingleton() && containsSingleton(beanName):工厂内部维护的对象是单实例并且一级缓存存在该 bean- 首先去缓存中获取,获取不到就使用工厂获取然后放入缓存,进行循环依赖判断
-
-
else if (mbd.isPrototype()):bean 是原型的 beanbeforePrototypeCreation(beanName):当前线程正在创建的原型对象 beanName 存入 prototypesCurrentlyInCreationcurVal = this.prototypesCurrentlyInCreation.get():获取当前线程的正在创建的原型类集合this.prototypesCurrentlyInCreation.set(beanName):集合为空就把当前 beanName 加入if (curVal instanceof String):已经有线程相关原型类创建了,把当前的创建的加进去
createBean(beanName, mbd, args):创建原型类对象,不需要三级缓存afterPrototypeCreation(beanName):从正在创建中的集合中移除该 beanName, 与 beforePrototypeCreation逻辑相反 -
convertIfNecessary():依赖检查,检查所需的类型是否与实际 bean 实例的类型匹配 -
return (T) bean:返回创建完成的 bean
生命周期
四个阶段
Bean 的生命周期:实例化 instantiation,填充属性 populate,初始化 initialization,销毁 destruction
AbstractAutowireCapableBeanFactory.createBean():进入 Bean 生命周期的流程
-
resolvedClass = resolveBeanClass(mbd, beanName):判断 mdb 中的 class 是否已经加载到 JVM,如果未加载则使用类加载器将 beanName 加载到 JVM中并返回 class 对象 -
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null):条件成立封装 mbd 并把 resolveBeanClass 设置到 bd 中- 条件二:mbd 在 resolveBeanClass 之前是否有 class
- 条件三:mbd 有 className
-
bean = resolveBeforeInstantiation(beanName, mbdToUse):实例化前的后置处理器返回一个代理实例对象(不是 AOP)- 自定义类继承 InstantiationAwareBeanPostProcessor,重写 postProcessBeforeInstantiation 方法,方法逻辑为创建对象
- 并配置文件
<bean class="intefacePackage.MyInstantiationAwareBeanPostProcessor">导入为 bean - 条件成立,短路操作,直接 return bean
-
Object beanInstance = doCreateBean(beanName, mbdToUse, args):Do it
AbstractAutowireCapableBeanFactory.doCreateBean(beanName, RootBeanDefinition, Object[] args):创建 Bean
-
BeanWrapper instanceWrapper = null:Spring 给所有创建的 Bean 实例包装成 BeanWrapper,内部最核心的方法是获取实例,提供了一些额外的接口方法,比如属性访问器 -
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName):单例对象尝试从缓存中获取,会移除缓存 -
createBeanInstance():缓存中没有实例就进行创建实例(逻辑复杂,下一小节详解) -
if (!mbd.postProcessed):每个 bean 只进行一次该逻辑applyMergedBeanDefinitionPostProcessors():后置处理器,合并 bd 信息,接下来要属性填充了AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition():后置处理逻辑(@Autowired)-
metadata = findAutowiringMetadata(beanName, beanType, null):提取当前 bean 整个继承体系内的 @Autowired、@Value、@Inject 信息,存入一个 InjectionMetadata 对象,保存着当前 bean 信息和要自动注入的字段信息private final Class<?> targetClass; //当前 bean private final Collection<InjectedElement> injectedElements; //要注入的信息集合-
metadata = buildAutowiringMetadata(clazz):查询当前 clazz 感兴趣的注解信息-
ReflectionUtils.doWithLocalFields():提取字段的注解的信息findAutowiredAnnotation(field):代表感兴趣的注解就是那三种注解,获取这三种注解的元数据 -
ReflectionUtils.doWithLocalMethods():提取方法的注解的信息 -
do{} while (targetClass != null && targetClass != Object.class):循环从父类中解析,直到 Object 类
-
-
this.injectionMetadataCache.put(cacheKey, metadata):存入缓存
-
mbd.postProcessed = true:设置为 true,下次访问该逻辑不会再进入 -
-
earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName):单例、解决循环引用、是否在单例正在创建集合中if (earlySingletonExposure) { // 【放入三级缓存一个工厂对象,用来获取提前引用】 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); // lamda 表达式,用来获取提前引用,循环依赖部分详解该逻辑 } -
populateBean(beanName, mbd, instanceWrapper):**属性填充,依赖注入,整体逻辑是先处理标签再处理注解,填充至 pvs 中,最后通过 apply 方法最后完成属性依赖注入到 BeanWrapper **-
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)):实例化后的后置处理器,默认返回 true,可以自定义类继承 InstantiationAwareBeanPostProcessor 修改后置处理方法的返回值为 false,使 continueWithPropertyPopulation 为 false,会导致直接返回,不进行属性的注入 -
if (!continueWithPropertyPopulation):自定义方法返回值会造成该条件成立,逻辑为直接返回,不进行依赖注入 -
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null):处理依赖注入逻辑开始 -
mbd.getResolvedAutowireMode() == ?:根据 bean 标签配置的 autowire 判断是 BY_NAME 或者 BY_TYPEautowireByName(beanName, mbd, bw, newPvs):根据字段名称去获取依赖的 bean,还没注入,只是添加到 pvs-
propertyNames = unsatisfiedNonSimpleProperties(mbd, bw):bean 实例中有该字段和该字段的 setter 方法,但是在 bd 中没有 property 属性-
拿到配置的 property 信息和 bean 的所有字段信息
-
pd.getWriteMethod() != null:当前字段是否有 set 方法,配置类注入的方式需要 set 方法!isExcludedFromDependencyCheck(pd):当前字段类型是否在忽略自动注入的列表中!pvs.contains(pd.getName():当前字段不在 xml 或者其他方式的配置中,也就是 bd 中不存在对应的 property!BeanUtils.isSimpleProperty(pd.getPropertyType():是否是基本数据类型和内置的几种数据类型,基本数据类型不允许自动注入
-
-
if (containsBean(propertyName)):BeanFactory 中存在当前 property 的 bean 实例,说明找到对应的依赖数据 -
getBean(propertyName):拿到 propertyName 对应的 bean 实例 -
pvs.add(propertyName, bean):填充到 pvs 中 -
registerDependentBean(propertyName, beanName)):添加到两个依赖 Map(dependsOn)中
autowireByType(beanName, mbd, bw, newPvs):根据字段类型去查找依赖的 beandesc = new AutowireByTypeDependencyDescriptor(methodParam, eager):依赖描述信息resolveDependency(desc, beanName, autowiredBeanNames, converter):根据描述信息,查找依赖对象,容器中没有对应的实例但是有对应的 BD,会调用 getBean(Type) 获取对象
pvs = newPvs:newPvs 是处理了依赖数据后的 pvs,所以赋值给 pvs -
-
hasInstAwareBpps:表示当前是否有 InstantiationAwareBeanPostProcessors 的后置处理器(Autowired) -
pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName):@Autowired 注解的注入,这个传入的 pvs 对象,最后原封不动的返回,不会添加东西-
findAutowiringMetadata():包装着当前 bd 需要注入的注解信息集合,三种注解的元数据,直接缓存获取 -
InjectionMetadata.InjectedElement.inject():遍历注解信息解析后注入到 Bean,方法和字段的注入实现不同以字段注入为例:
-
value = resolveFieldValue(field, bean, beanName):处理字段属性值value = beanFactory.resolveDependency():解决依赖result = doResolveDependency():真正处理自动注入依赖的逻辑-
Object shortcut = descriptor.resolveShortcut(this):默认返回 null -
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor):获取 @Value 的值 -
converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor()):如果 value 不是 null,就直接进行类型转换返回数据 -
matchingBeans = findAutowireCandidates(beanName, type, descriptor):如果 value 是空说明字段是引用类型,获取 @Autowired 的 Bean// addCandidateEntry() → Object beanInstance = descriptor.resolveCandidate() public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException { // 获取 bean return beanFactory.getBean(beanName); }
-
-
ReflectionUtils.makeAccessible(field):修改访问权限 -
field.set(bean, value):获取属性访问器为此 field 对象赋值
-
-
-
applyPropertyValues():将所有解析的 PropertyValues 的注入至 BeanWrapper 实例中(深拷贝)if (pvs.isEmpty()):注解 @Autowired 和 @Value 标注的信息在后置处理的逻辑注入完成,此处为空直接返回- 下面的逻辑进行 XML 配置的属性的注入,首先获取转换器进行数据转换,然后获取 WriteMethod (set) 方法进行反射调用,完成属性的注入
-
-
initializeBean(String,Object,RootBeanDefinition):初始化,分为配置文件和实现接口两种方式-
invokeAwareMethods(beanName, bean):根据 bean 是否实现 Aware 接口执行初始化的方法 -
wrappedBean = applyBeanPostProcessorsBeforeInitialization:初始化前的后置处理器,可以继承接口重写方法processor.postProcessBeforeInitialization():执行后置处理的方法,默认返回 bean 本身if (current == null) return result:重写方法返回 null,会造成后置处理的短路,直接返回
-
invokeInitMethods(beanName, wrappedBean, mbd):反射执行初始化方法-
isInitializingBean = (bean instanceof InitializingBean):初始化方法的定义有两种方式,一种是自定义类实现 InitializingBean 接口,另一种是配置文件配置 <bean id=”…” class=”…” init-method=“init”/ > -
isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet")):-
条件一:当前 bean 是不是实现了 InitializingBean
-
条件二:InitializingBean 接口中的方法 afterPropertiesSet,判断该方法是否是容器外管理的方法
-
-
if (mbd != null && bean.getClass() != NullBean.class):成立说明是配置文件的方式if(!(接口条件))表示如果通过接口实现了初始化方法的话,就不会在调用配置类中 init-method 定义的方法((InitializingBean) bean).afterPropertiesSet():调用方法invokeCustomInitMethod:执行自定义的方法initMethodName = mbd.getInitMethodName():获取方法名Method initMethod = ():根据方法名获取到 init-method 方法methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod):将方法转成从接口层面获取ReflectionUtils.makeAccessible(methodToInvoke):访问权限设置成可访问methodToInvoke.invoke(bean):反射调用初始化方法,以当前 bean 为角度去调用
-
-
wrappedBean = applyBeanPostProcessorsAfterInitialization:初始化后的后置处理器-
AbstractAutoProxyCreator.postProcessAfterInitialization():如果 Bean 被子类标识为要代理的 bean,则使用配置的拦截器创建代理对象,AOP 部分详解 -
如果不存在循环依赖,创建动态代理 bean 在此处完成;否则真正的创建阶段是在属性填充时获取提前引用的阶段,循环依赖详解,源码分析:
// 该集合用来避免重复将某个 bean 生成代理对象, private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16); public Object postProcessAfterInitialization(@Nullable Object bean,String bN){ if (bean != null) { // cacheKey 是 beanName 或者加上 & Object cacheKey = getCacheKey(bean.getClass(), beanName);y if (this.earlyProxyReferences.remove(cacheKey) != bean) { // 去提前代理引用池中寻找该key,不存在则创建代理 // 如果存在则证明被代理过,则判断是否是当前的 bean,不是则创建代理 return wrapIfNecessary(bean, bN, cacheKey); } } return bean; }
-
-
-
if (earlySingletonExposure):是否允许提前引用earlySingletonReference = getSingleton(beanName, false):从二级缓存获取实例,放入一级缓存是在 doGetBean 中的sharedInstance = getSingleton() 逻辑中,此时在 createBean 的逻辑还没有返回,所以一级缓存没有if (earlySingletonReference != null):当前 bean 实例从二级缓存中获取到了,说明产生了循环依赖,在属性填充阶段会提前调用三级缓存中的工厂生成 Bean 的代理对象(或原始实例),放入二级缓存中,然后使用原始 bean 继续执行初始化-
if (exposedObject == bean):初始化后的 bean == 创建的原始实例,条件成立的两种情况:当前的真实实例不需要被代理;当前实例存在循环依赖已经被提前代理过了,初始化时的后置处理器直接返回 bean 原实例exposedObject = earlySingletonReference:把代理后的 Bean 传给 exposedObject 用来返回,因为只有代理对象才封装了拦截器链,main 方法中用代理对象调用方法时会进行增强,代理是对原始对象的包装,所以这里返回的代理对象中含有完整的原实例(属性填充和初始化后的),是一个完整的代理对象,返回后外层方法会将当前 Bean 放入一级缓存 -
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)):是否有其他 bean 依赖当前 bean,执行到这里说明是不存在循环依赖、存在增强代理的逻辑,也就是正常的逻辑-
dependentBeans = getDependentBeans(beanName):取到依赖当前 bean 的其他 beanName -
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)):判断 dependentBean 是否创建完成if (!this.alreadyCreated.contains(beanName)):成立当前 bean 尚未创建完成,当前 bean 是依赖exposedObject 的 bean,返回 true
-
return false:创建完成返回 falseactualDependentBeans.add(dependentBean):创建完成的 dependentBean 加入该集合 -
if (!actualDependentBeans.isEmpty()):条件成立说明有依赖于当前 bean 的 bean 实例创建完成,但是当前的 bean 还没创建完成返回,依赖当前 bean 的外部 bean 持有的是不完整的 bean,所以需要报错
-
-
-
registerDisposableBeanIfNecessary:判断当前 bean 是否需要注册析构函数回调,当容器销毁时进行回调-
if (!mbd.isPrototype() && requiresDestruction(bean, mbd))-
如果是原型 prototype 不会注册析构回调,不会回调该函数,对象的回收由 JVM 的 GC 机制完成
-
requiresDestruction():
-
DisposableBeanAdapter.hasDestroyMethod(bean, mbd):bd 中定义了 DestroyMethod 返回 true -
hasDestructionAwareBeanPostProcessors():后处理器框架决定是否进行析构回调
-
-
-
registerDisposableBean():条件成立进入该方法,给当前单实例注册回调适配器,适配器内根据当前 bean 实例是继承接口(DisposableBean)还是自定义标签来判定具体调用哪个方法实现
-
-
this.disposableBeans.put(beanName, bean):向销毁集合添加实例
创建实例
AbstractAutowireCapableBeanFactory.createBeanInstance(beanName, RootBeanDefinition, Object[] args)
-
resolveBeanClass(mbd, beanName):确保 Bean 的 Class 真正的被加载 -
判断类的访问权限是不是 public,不是进入下一个判断,是否允许访问类的 non-public 的构造方法,不允许则报错
-
Supplier<?> instanceSupplier = mbd.getInstanceSupplier():获取创建实例的函数,可以自定义,没有进入下面的逻辑 -
if (mbd.getFactoryMethodName() != null):判断 bean 是否设置了 factory-method 属性,优先使用,设置了该属性进入 factory-method 方法创建实例 -
resolved = false:代表 bd 对应的构造信息是否已经解析成可以反射调用的构造方法 -
autowireNecessary = false:是否自动匹配构造方法 -
if(mbd.resolvedConstructorOrFactoryMethod != null):获取 bd 的构造信息转化成反射调用的 method 信息- method 为 null 则 resolved 和 autowireNecessary 都为默认值 false
autowireNecessary = mbd.constructorArgumentsResolved:构造方法有参数,设置为 true
-
bd 对应的构造信息解析完成,可以直接反射调用构造方法了:
-
return autowireConstructor(beanName, mbd, null, null):有参构造,根据参数匹配最优的构造器创建实例 -
return instantiateBean(beanName, mbd):无参构造方法通过反射创建实例-
SimpleInstantiationStrategy.instantiate():真正用来实例化的函数(无论如何都会走到这一步)-
if (!bd.hasMethodOverrides()):没有方法重写覆盖BeanUtils.instantiateClass(constructorToUse):调用Constructor.newInstance()实例化 -
instantiateWithMethodInjection(bd, beanName, owner):有方法重写采用 CGLIB 实例化
-
-
BeanWrapper bw = new BeanWrapperImpl(beanInstance):包装成 BeanWrapper 类型的对象 -
return bw:返回实例
-
-
-
ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName):@Autowired 注解,对应的后置处理器 AutowiredAnnotationBeanPostProcessor 逻辑-
配置了 lookup 的相关逻辑
-
this.candidateConstructorsCache.get(beanClass):从缓存中获取构造方法,第一次获取为 null,进入下面逻辑 -
rawCandidates = beanClass.getDeclaredConstructors():获取所有的构造器 -
Constructor<?> requiredConstructor = null:唯一的选项构造器,@Autowired(required = “true”) 时有值 -
for (Constructor<?> candidate : rawCandidates):遍历所有的构造器:ann = findAutowiredAnnotation(candidate):有三种注解中的一个会返回注解的属性-
遍历 this.autowiredAnnotationTypes 中的三种注解:
this.autowiredAnnotationTypes.add(Autowired.class);//!!!!!!!!!!!!!! this.autowiredAnnotationTypes.add(Value.class); this.autowiredAnnotationTypes.add(...ClassUtils.forName("javax.inject.Inject")); -
AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type):获取注解的属性 -
if (attributes != null) return attributes:任意一个注解属性不为空就注解返回
if (ann == null):注解属性为空userClass = ClassUtils.getUserClass(beanClass):如果当前 beanClass 是代理对象,方法上就已经没有注解了,所以获取原始的用户类型重新获取该构造器上的注解属性(事务注解失效也是这个原理)
if (ann != null):注解属性不为空了-
required = determineRequiredStatus(ann):获取 required 属性的值!ann.containsKey(this.requiredParameterName) ||:判断属性是否包含 required,不包含进入后面逻辑this.requiredParameterValue == ann.getBoolean(this.requiredParameterName):获取属性值返回
-
if (required):代表注解 @Autowired(required = true)if (!candidates.isEmpty()):true 代表只能有一个构造方法,构造集合不是空代表可选的构造器不唯一,报错requiredConstructor = candidate:把构造器赋值给 requiredConstructor -
candidates.add(candidate):把当前构造方法添加至 candidates 集合
if(candidate.getParameterCount() == 0):当前遍历的构造器的参数为 0 代表没有参数,是默认构造器,赋值给 defaultConstructor -
-
candidateConstructors = candidates.toArray(new Constructor<?>[0]):将构造器转成数组返回
-
-
if(ctors != null):条件成立代表指定了构造方法数组mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR:标签内 autowiremode 的属性值,默认是 no,AUTOWIRE_CONSTRUCTOR 代表选择最优的构造方法 mbd.hasConstructorArgumentValues():bean 信息中是否配置了构造参数的值!ObjectUtils.isEmpty(args):getBean 时,指定了参数 arg -
return autowireConstructor(beanName, mbd, ctors, args):选择最优的构造器进行创建实例(复杂,不建议研究)-
beanFactory.initBeanWrapper(bw):向 BeanWrapper 中注册转换器,向工厂中注册属性编辑器 -
Constructor<?> constructorToUse = null:实例化反射构造器ArgumentsHolder argsHolderToUse:实例化时真正去用的参数,并持有对象- rawArguments 是转换前的参数,arguments 是类型转换完成的参数
Object[] argsToUse:参数实例化时使用的参数 -
Object[] argsToResolve:表示构造器参数做转换后的参数引用 -
if (constructorToUse != null && mbd.constructorArgumentsResolved):- 条件一成立说明当前 bd 生成的实例不是第一次,缓存中有解析好的构造器方法可以直接拿来反射调用
- 条件二成立说明构造器参数已经解析过了
-
argsToUse = resolvePreparedArguments():argsToResolve 不是完全解析好的,还需要继续解析 -
if (constructorToUse == null || argsToUse == null):条件成立说明缓存机制失败,进入构造器匹配逻辑 -
Constructor<?>[] candidates = chosenCtors:chosenCtors 只有在构造方法上有 autowaire 三种注解时才有数据 -
if (candidates == null):candidates 为空就根据 beanClass 是否允许访问非公开的方法来获取构造方法 -
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()):默认无参bw.setBeanInstance(instantiate()):使用无参构造器反射调用,创建出实例对象,设置到 BeanWrapper 中去 -
boolean autowiring:需要选择最优的构造器 -
cargs = mbd.getConstructorArgumentValues():获取参数值resolvedValues = new ConstructorArgumentValues():获取已经解析后的构造器参数值final Map<Integer, ValueHolder> indexedArgumentValues:key 是 index, value 是值final List<ValueHolder> genericArgumentValues:没有 index 的值
minNrOfArgs = resolveConstructorArguments(..,resolvedValues):从 bd 中解析并获取构造器参数的个数valueResolver.resolveValueIfNecessary():将引用转换成真实的对象resolvedValueHolder.setSource(valueHolder):将对象填充至 ValueHolder 中resolvedValues.addIndexedArgumentValue():将参数值封装至 resolvedValues 中
-
AutowireUtils.sortConstructors(candidates):排序规则 public > 非公开的 > 参数多的 > 参数少的 -
int minTypeDiffWeight = Integer.MAX_VALUE:值越低说明构造器参数列表类型和构造参数的匹配度越高 -
Set<Constructor<?>> ambiguousConstructors:模棱两可的构造器,两个构造器匹配度相等时放入 -
for (Constructor<?> candidate : candidates):遍历筛选出 minTypeDiffWeight 最低的构造器 -
Class<?>[] paramTypes = candidate.getParameterTypes():获取当前处理的构造器的参数类型 -
if():candidates 是排过序的,当前筛选出来的构造器的优先级一定是优先于后面的 constructor -
if (paramTypes.length < minNrOfArgs):需求的小于给的,不匹配 -
int typeDiffWeight:获取匹配度mbd.isLenientConstructorResolution():true 表示 ambiguousConstructors 允许有数据,false 代表不允许有数据,有数据就报错(LenientConstructorResolution:宽松的构造函数解析)argsHolder.getTypeDifferenceWeight(paramTypes):选择参数转换前和转换后匹配度最低的,循环向父类中寻找该方法,直到寻找到 Obejct 类
-
if (typeDiffWeight < minTypeDiffWeight):条件成立说明当前循环处理的构造器更优 -
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight):当前处理的构造器的计算出来的 DiffWeight 与上一次筛选出来的最优构造器的值一致,说明有模棱两可的情况 -
if (constructorToUse == null):未找到可以使用的构造器,报错 -
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()):模棱两可有数据,LenientConstructorResolution == false,所以报错 -
argsHolderToUse.storeCache(mbd, constructorToUse):匹配成功,进行缓存,方便后来者使用该 bd 实例化 -
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse)):匹配成功调用 instantiate 创建出实例对象,设置到 BeanWrapper 中去
-
-
return instantiateBean(beanName, mbd):默认走到这里
循环依赖
循环引用
循环依赖:是一个或多个对象实例之间存在直接或间接的依赖关系,这种依赖关系构成一个环形调用
Spring 循环依赖有四种:
- DependsOn 依赖加载【无法解决】(两种 Map)
- 原型模式 Prototype 循环依赖【无法解决】(正在创建集合)
- 单例 Bean 循环依赖:构造参数产生依赖【无法解决】(正在创建集合,getSingleton() 逻辑中)
- 单例 Bean 循环依赖:setter 产生依赖【可以解决】
解决循环依赖:提前引用,提前暴露创建中的 Bean
- Spring 先实例化 A,拿到 A 的构造方法反射创建出来 A 的早期实例对象,这个对象被包装成 ObjectFactory 对象,放入三级缓存
- 处理 A 的依赖数据,检查发现 A 依赖 B 对象,所以 Spring 就会去根据 B 类型到容器中去 getBean(B),这里产生递归
- 拿到 B 的构造方法,进行反射创建出来 B 的早期实例对象,也会把 B 包装成 ObjectFactory 对象,放到三级缓存,处理 B 的依赖数据,检查发现 B 依赖了 A 对象,然后 Spring 就会去根据 A 类型到容器中去 getBean(A.class)
- 这时从三级缓存中获取到 A 的早期对象进入属性填充
循环依赖的三级缓存:
//一级缓存:存放所有初始化完成单实例 bean,单例池,key是beanName,value是对应的单实例对象引用
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//二级缓存:存放实例化未进行初始化的 Bean,提前引用池
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
/** Cache of singleton factories: bean name to ObjectFactory. 3*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
-
为什么需要三级缓存?
- 循环依赖解决需要提前引用动态代理对象,AOP 动态代理是在 Bean 初始化后的后置处理中进行,这时的 bean 已经是成品对象。因为需要提前进行动态代理,三级缓存的 ObjectFactory 提前产生需要代理的对象,把提前引用放入二级缓存
- 如果只有二级缓存,提前引用就直接放入了一级缓存,然后 Bean 初始化完成后又会放入一级缓存,产生数据覆盖,导致提前引用的对象和一级缓存中的并不是同一个对象
- 一级缓存只能存放完整的单实例,为了保证 Bean 的生命周期不被破坏,不能将未初始化的 Bean 暴露到一级缓存
- 若存在循环依赖,后置处理不创建代理对象,真正创建代理对象的过程是在 getBean(B) 的阶段中
-
三级缓存一定会创建提前引用吗?
- 出现循环依赖就会去三级缓存获取提前引用,不出现就不会,走正常的逻辑,创建完成直接放入一级缓存
- 存在循环依赖,就创建代理对象放入二级缓存,如果没有增强方法就返回 createBeanInstance 创建的实例,因为 addSingletonFactory 参数中传入了实例化的 Bean,在 singletonFactory.getObject() 中返回给 singletonObject,所以存在循环依赖就一定会使用工厂,但是不一定创建的是代理对象,不需要增强就是原始对象
-
wrapIfNecessary 一定创建代理对象吗?(AOP 动态代理部分有源码解析)
- 存在增强器会创建动态代理,不需要增强就不需要创建动态代理对象
- 存在循环依赖会提前增强,初始化后不需要增强
-
什么时候将 Bean 的引用提前暴露给第三级缓存的 ObjectFactory 持有?
-
实例化之后,依赖注入之前
createBeanInstance -> addSingletonFactory -> populateBean
-
源码解析
假如 A 依赖 B,B 依赖 A
-
当 A 创建实例后填充属性前,执行:
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))// 添加给定的单例工厂以构建指定的单例 protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { // 单例池包含该Bean说明已经创建完成,不需要循环依赖 if (!this.singletonObjects.containsKey(beanName)) { //加入三级缓存 this.singletonFactories.put(beanName,singletonFactory); this.earlySingletonObjects.remove(beanName); // 从二级缓存移除,因为三个Map中都是一个对象,不能同时存在! this.registeredSingletons.add(beanName); } } } -
填充属性时 A 依赖 B,这时需要 getBean(B),也会把 B 的工厂放入三级缓存,接着 B 填充属性时发现依赖 A,去进行**第一次 ** getSingleton(A)
public Object getSingleton(String beanName) { return getSingleton(beanName, true);//为true代表允许拿到早期引用。 } protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 在一级缓存中获取 beanName 对应的单实例对象。 Object singletonObject = this.singletonObjects.get(beanName); // 单实例确实尚未创建;单实例正在创建,发生了循环依赖 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { // 从二级缓存获取 singletonObject = this.earlySingletonObjects.get(beanName); // 二级缓存不存在,并且允许获取早期实例对象,去三级缓存查看 if (singletonObject == null && allowEarlyReference) { ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 从三级缓存获取工厂对象,并得到 bean 的提前引用 singletonObject = singletonFactory.getObject(); // 【缓存升级】,放入二级缓存,提前引用池 this.earlySingletonObjects.put(beanName, singletonObject); // 从三级缓存移除该对象 this.singletonFactories.remove(beanName); } } } } return singletonObject; } -
从三级缓存获取 A 的 Bean:
singletonFactory.getObject(),调用了 lambda 表达式的 getEarlyBeanReference 方法:public Object getEarlyBeanReference(Object bean, String beanName) { Object cacheKey = getCacheKey(bean.getClass(), beanName); // 【向提前引用代理池 earlyProxyReferences 中添加该 Bean,防止对象被重新代理】 this.earlyProxyReferences.put(cacheKey, bean); // 创建代理对象,createProxy return wrapIfNecessary(bean, beanName, cacheKey); } -
B 填充了 A 的提前引用后会继续初始化直到完成,返回原始 A 的逻辑继续执行