Skip to content

S
Spring_resource_analysis
Commit 9a4ff3c2 by SunWei峰
Options

8月2日

parent e4da2d33
Showing with 72 additions and 1 deletions
.idea/vcs.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>
\ No newline at end of file
spring-framework-main/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
......@@ -495,6 +495,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 锁定class, 根据设置的class属性或者根据className 解析出来 class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
......@@ -503,6 +504,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
// Prepare method overrides.
try {
// 验证及准备覆盖的方法
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
......@@ -512,6 +514,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给BeanPostProcessors一个机会来替代真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
......@@ -523,6 +526,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
}
try {
// 创建 bean 的真正方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
......
spring-framework-main/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java
......@@ -265,7 +265,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 返回对应的实例，有时候在诸如beanFactory的情况下，并不是返回实力本身，而是返回指定方法返回的实例
// 返回对应的实例，有时候在诸如FactoryBean的情况下，并不是返回实力本身，而是返回指定方法返回的实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
......@@ -319,20 +319,24 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
beanCreation.tag("beanType", requiredType::toString);
}
// 将父类的BeanDefinition与子类的BeanDefinition进行合并覆盖
// 将存储xml配置文件的GernericBeanDefinition转化为RootBean，如果指定beanName是子bean的话，同时会合并父类相关属性
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 对合并的BeanDefinition做验证，主要看属性是否为abstract的
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
// 若存在依赖，则实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存依赖调用，注意这里传入的key是被依赖的bean名称
registerDependentBean(dep, beanName);
try {
//递归调用getBean方法，注册Bean之间的依赖(如C需要晚于B初始化，而B需要晚于A初始化)
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
......@@ -342,8 +346,10 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
}
}
//如果BeanDefinition为单例
// Create bean instance.
if (mbd.isSingleton()) {
// 创建Bean实例对象，并且注册给所依赖的对象
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
......@@ -352,13 +358,17 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 显示从单例缓存中删除bean实例
// 因为单例模式下为了解决循环依赖，可能它已经存在了，所有将其销毁
destroySingleton(beanName);
throw ex;
}
});
// 如果是普通bean，直接返回，如果是FactoryBean，则返回它的getObject
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 原型模式创建
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
......@@ -372,6 +382,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 指定模式创建
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
......@@ -1793,40 +1804,69 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// 整个这个判断的意思是说，如果要获取的bean是FactoryBean的引用，但是beanInstance不是FactoryBean的就抛异常
// 1. 验证： 判断输入的bean的name是否是FactoryBean相关的BeanName（前缀是&）
if (BeanFactoryUtils.isFactoryDereference(name)) {
// BeanInstance 是 NullBean就直接返回
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// name的前缀是&,但是类型不是FactoryBean，就报错
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
// 如果 BeanName 与 FactoryBean<?> 相关 && beanInstance 不是 NullBean
// 且 beanInstance 是 FactoryBean<?> 类型 && RootBeanDefinition 不为空
if (mbd != null) {
// 当前 Bean 实例为 FactoryBean<?> 类型的 Bean
mbd.isFactoryBean = true;
}
// 直接返回当前 Bean 实例, 这也是为什么针对于一个 FactoryBean<?> 类型的 Bean 实例而言
// 使用 '&' + beanName 就能获取到 FactoryBean<?> 本身
return beanInstance;
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
// 如果是 FactoryBean<?> 则使用它创建实例,但如果是开发者想要直接获取工厂实例而不是工厂的 getObject()
// 方法对应的实例, 那么传入的 BeanName 应该加入前缀 '&'
// 2. 如果不是 FactoryBean 直接返回当前 Bean 实例
if (!(beanInstance instanceof FactoryBean<?> factoryBean)) {
return beanInstance;
}
// 如果是 FactoryBean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
// 从缓存中加载
object = getCachedObjectForFactoryBean(beanName);
}
// 加载失败则，激活 FactoryBean<?> 的 getObject() 方法
if (object == null) {
// Return bean instance from factory.
// Caches object obtained from FactoryBean if it is a singleton.
// 这里已经明确知道 beanInstance 一定是 FactoryBean<?> 类型
// 如果 mbd 为空 && 从 XML 配置文件中加载的 BeanDefinition 中包含 BeanName 对应的 Bean 定义信息
// 3. 转化bean
if (mbd == null && containsBeanDefinition(beanName)) {
// 将解析 XML 配置文件的 GenericBeanDefinition 转换为 RootBeanDefinition, 如果指定的 BeanName
// 是子 Bean 的话同时会合并父类的相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 4，从Factory中解析bean
object = getObjectFromFactoryBean(factoryBean, beanName, !synthetic);
}
return object;
......
spring-framework-main/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java
......@@ -179,7 +179,9 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
// 首先检查是否存在实例
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存没有，判断该bean是否在创建中，通过Set的contains来判断
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
......@@ -192,6 +194,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// earlySingletonObjects和singletonFactories二者互斥
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
......@@ -214,8 +217,10 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 首先判断bean是否已经存在
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 判断，如果当前beanFactory正在被销毁则直接抛出异常，不允许创建单例bean
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
......@@ -224,6 +229,9 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 做一些bean创建前的准备工作： 记录beanName 正在加载的状态(添加到 singletonsCurrentlyInCreation 缓存中)，
// 若bean已经正在加载，则抛出异常。为了解决循环引用的问题
// 记录bean到singletonsCurrentlyInCreation（记录加载状态）
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
......@@ -231,6 +239,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 通过回调方式获取bean实例。
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
......@@ -254,9 +263,11 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 删除状态
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 加入缓存
addSingleton(beanName, singletonObject);
}
}
......
spring-framework-main/spring-beans/src/main/java/org/springframework/beans/factory/support/FactoryBeanRegistrySupport.java
......@@ -83,14 +83,20 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 如果是单例 Bean 并且 Bean 实例已经创建过, 没有再次创建的必要, 要保证单例 Bean 全局唯一, 直接从缓存中获取
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 从缓存中获取
Object object = this.factoryBeanObjectCache.get(beanName);
// 如果缓存中没有
if (object == null) {
// 激活 FactoryBean<?> 中的 getObject() 方法获取开发者
// 定制的初始化逻辑
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
// 其余线程初始化过
if (alreadyThere != null) {
object = alreadyThere;
}
......@@ -102,6 +108,7 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
}
beforeSingletonCreation(beanName);
try {
// TODO: 2022/8/2 BeanPostProcessor的后置处理器postProcessAfterInitialization，还没学到
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
......@@ -120,7 +127,9 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
return object;
}
}
// 不是单例模式
else {
// 直接调用
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment