SpringloC容器的依赖注入源码解析（2）—，mysql事务面试题-CSDN博客

本文链接：https://blog.csdn.net/erthre/article/details/137335239

}

if (!typeCheckOnly) {

markBeanAsCreated(beanName);

}

try {

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

checkMergedBeanDefinition(mbd, beanName, args);

// Guarantee initialization of beans that the current bean depends on.

String[] dependsOn = mbd.getDependsOn();

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 + “'”);

}

registerDependentBean(dep, beanName);

try {

getBean(dep);

}

catch (NoSuchBeanDefinitionException ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName,

“'” + beanName + “’ depends on missing bean '” + dep + “'”, ex);

}

// Create bean instance.

// 如果BeanDefinition为单例

if (mbd.isSingleton()) {

// 这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象

sharedInstance = getSingleton(beanName, () -> {

try {

return createBean(beanName, mbd, args);

}

catch (BeansException ex) {

// 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.

destroySingleton(beanName);

throw ex;

}

});

bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

}

else if (mbd.isPrototype()) {

// It’s a prototype -> create a new instance.

Object prototypeInstance = null;

try {

beforePrototypeCreation(beanName);

prototypeInstance = createBean(beanName, mbd, args);

}

finally {

afterPrototypeCreation(beanName);

}

bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

}

else {

String scopeName = mbd.getScope();

final Scope scope = this.scopes.get(scopeName);

if (scope == null) {

throw new IllegalStateException(“No Scope registered for scope name '” + scopeName + “'”);

}

try {

Object scopedInstance = scope.get(beanName, () -> {

beforePrototypeCreation(beanName);

try {

return createBean(beanName, mbd, args);

}

finally {

afterPrototypeCreation(beanName);

}

});

bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

}

catch (IllegalStateException ex) {

throw new BeanCreationException(beanName,

“Scope '” + scopeName + "’ is not active for the current thread; consider " +

“defining a scoped proxy for this bean if you intend to refer to it from a singleton”,

ex);

}

catch (BeansException ex) {

cleanupAfterBeanCreationFailure(beanName);

throw ex;

}

// Check if required type matches the type of the actual bean instance.

if (requiredType != null && !requiredType.isInstance(bean)) {

try {

T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);

if (convertedBean == null) {

throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

}

return convertedBean;

}

catch (TypeMismatchException ex) {

if (logger.isTraceEnabled()) {

logger.trace(“Failed to convert bean '” + name + “’ to required type '” +

ClassUtils.getQualifiedName(requiredType) + “'”, ex);

}

throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

}

return (T) bean;

}

第一行先将方法传入的name转换成容器真实的beanName，回顾之前，可以通过三种形式获取beanName，一个是原始的beanName，一个是加了&的，一个是别名

final String beanName = transformedBeanName(name);

Object bean;

进入到transformedBeanName方法里面

protected String transformedBeanName(String name) {

return canonicalName(BeanFactoryUtils.transformedBeanName(name));

}

public static String transformedBeanName(String name) {

Assert.notNull(name, “‘name’ must not be null”);

if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {

return name;

}

return transformedBeanNameCache.computeIfAbsent(name, beanName -> {

do {

beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());

}

while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));

return beanName;

});

}

先看看是否是以&前缀开始的，不是的话直接返回name，是的话将&全部去掉。

再进入到canonicalName方法里：

public String canonicalName(String name) {

String canonicalName = name;

// Handle aliasing…

String resolvedName;

do {

// 根据别名获取真正的beanName，传入beanName就啥都获取不到

resolvedName = this.aliasMap.get(canonicalName);

if (resolvedName != null) {

canonicalName = resolvedName;

}

while (resolvedName != null);

return canonicalName;

}

如果能在map里找到真名，则证明传入的是别名，为了防止是别名的别名，这里有一个递归操作直到找不到，此时为真名

回到doGetBean，获取到beanName之后就尝试去缓存获得Bean实例

Object sharedInstance = getSingleton(beanName);

进入方法里

public Object getSingleton(String beanName) {

return getSingleton(beanName, true);

}

第二个参数控制是否允许非延迟加载，true表示允许立即加载

protected Object getSingleton(String beanName, boolean allowEarlyReference) {

// 尝试从一级缓存里面获取完备的Bean

Object singletonObject = this.singletonObjects.get(beanName);

// 如果完备的单例还没有创建出来，创建中的Bean的名字会被保存在singletonsCurrentlyInCreation中

// 因此看看是否正在创建

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

// 尝试给一级缓存对象加锁，因为接下来就要对缓存对象操作了

synchronized (this.singletonObjects) {

// 尝试从二级缓存earlySingletonObjects这个存储还没进行属性添加操作的Bean实例缓存中获取

singletonObject = this.earlySingletonObjects.get(beanName);

// 如果还没有获取到并且第二个参数为true，为true则表示bean允许被循环引用

if (singletonObject == null && allowEarlyReference) {

// 从三级缓存singletonFactories这个ObjectFactory实例的缓存里尝试获取创建此Bean的单例工厂实例

ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

// 如果获取到工厂实例

if (singletonFactory != null) {

// 调用单例工厂的getObject方法返回对象实例

singletonObject = singletonFactory.getObject();

// 将实例放入二级缓存里

this.earlySingletonObjects.put(beanName, singletonObject);

// 从三级缓存里移除

this.singletonFactories.remove(beanName);

}

return singletonObject;

}

该方法在DefaultSingletonBeanRegistry类里，负责对容器创建出来的单例进行注册，从一个map （singletonObjects）中尝试获取key为beanName的单例实例，其中singletonObjects就是一级缓存。

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName))

保证从一级缓存里没有获取到相关实例，并且该实例一定是当前正在创建的实例

public boolean isSingletonCurrentlyInCreation(String beanName) {

return this.singletonsCurrentlyInCreation.contains(beanName);

}

isSingletonCurrentlyInCreation方法会去查询一个set，看看正在创建的单例bean名单里是否有beanName，如果此时bean是单例的且正在创建，则会给一级缓存加一个同步锁，之后再操作另外两层缓存。

为了提高性能，二级缓存earlySingletonObjects和三级缓存singletonFactories都是HashMap，因为前面已经对一级缓存加了锁，所以是安全的。

首先尝试从二级缓存里获取Bean实例

singletonObject = this.earlySingletonObjects.get(beanName);

二级缓存里存的是还没有实例化的Bean（没执行populate）

之后又可能从三级缓存singletonFactories里尝试获取，这里存储的是Bean对应的ObjectFactory实例（工厂），后续可以通过getObject()来创建Bean的实例，由于Bean实例的属性可能还没有注入，所以先将其放入二级缓存里，然后从三级缓存里清除（保证三级缓存里只有一级保存Bean实例，避免重复创建Bean实例打破单例），之所以没有注入的Bean也要返回的原因是为了打破循环依赖问题。

回到doGetBean，

请添加图片描述