@Scope注解 、@Lazy注解 -【Spring底层原理

beanFactory.registerScope(scopeKey, (Scope)value);

} else {

Class scopeClass;

if (value instanceof Class) {

scopeClass = (Class)value;

Assert.isAssignable(Scope.class, scopeClass, “Invalid scope class”);

beanFactory.registerScope(scopeKey, (Scope)BeanUtils.instantiateClass(scopeClass));

} else {

if (!(value instanceof String)) {

throw new IllegalArgumentException(“Mapped value [” + value + “] for scope key [” + scopeKey + “] is not an instance of required type [” + Scope.class.getName() + “] or a corresponding Class or String value indicating a Scope implementation”);

}

scopeClass = ClassUtils.resolveClassName((String)value, this.beanClassLoader);

Assert.isAssignable(Scope.class, scopeClass, “Invalid scope class”);

beanFactory.registerScope(scopeKey, (Scope)BeanUtils.instantiateClass(scopeClass));

}

}

});

}

}

这里是进行注册Scope，在该类中，有个doGetBean方法，所有的bean的创建都会去调用该方法，咱们继续跟踪源码，看Scope是如何创建的：

public void registerScope(String scopeName, Scope scope) {

Assert.notNull(scopeName, “Scope identifier must not be null”);

Assert.notNull(scope, “Scope must not be null”);

if (!“singleton”.equals(scopeName) && !“prototype”.equals(scopeName)) {

Scope previous = (Scope)this.scopes.put(scopeName, scope);

if (previous != null && previous != scope) {

if (this.logger.isDebugEnabled()) {

this.logger.debug(“Replacing scope '” + scopeName + “’ from [” + previous + “] to [” + scope + “]”);

}

} else if (this.logger.isTraceEnabled()) {

this.logger.trace(“Registering scope '” + scopeName + “’ with implementation [” + scope + “]”);

}

} else {

throw new IllegalArgumentException(“Cannot replace existing scopes ‘singleton’ and ‘prototype’”);

}

}

AbstractBeanFactory类中doGetBean方法：

protected  T doGetBean(String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {

// 转化传入的Bean,如果是别名转真名，如果是&开头，去掉&。&代表取factoryBean

String beanName = this.transformedBeanName(name);

// 1、这里为了解决Singleton循环依赖，如果允许早期暴露，会在这里取到其早期暴露，后面会介绍

// 2、如果是工厂模式，在获取bean的时候，在这里会先获取到factoryBean

Object sharedInstance = this.getSingleton(beanName);

Object bean;

// 如果 sharedInstance 不为空，说明当前singleton是依赖者在注入属性时创建的。则打印相关日志

if (sharedInstance != null && args == null) {

if (this.logger.isTraceEnabled()) {

if (this.isSingletonCurrentlyInCreation(beanName)) {

this.logger.trace(“Returning eagerly cached instance of singleton bean '” + beanName + “’ that is not fully initialized yet - a consequence of a circular reference”);

} else {

this.logger.trace(“Returning cached instance of singleton bean '” + beanName + “'”);

}

}

// 这里会将name和beanName同时传进来, 因为一开始我们的name可能是带&符号的，代表这里需要获取factoryBean而不是bean

bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);

} else {

if (this.isPrototypeCurrentlyInCreation(beanName)) {

throw new BeanCurrentlyInCreationException(beanName);

}

// 判断是否有父容器，如果有父容器，优先用父容器调用其getBean

BeanFactory parentBeanFactory = this.getParentBeanFactory();

if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {

String nameToLookup = this.originalBeanName(name);

if (parentBeanFactory instanceof AbstractBeanFactory) {

return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);

}

if (args != null) {

return parentBeanFactory.getBean(nameToLookup, args);

}

if (requiredType != null) {

return parentBeanFactory.getBean(nameToLookup, requiredType);

}

return parentBeanFactory.getBean(nameToLookup);

}

if (!typeCheckOnly) {

this.markBeanAsCreated(beanName);

}

StartupStep beanCreation = this.applicationStartup.start(“spring.beans.instantiate”).tag(“beanName”, name);

try {

if (requiredType != null) {

beanCreation.tag(“beanType”, requiredType::toString);

}

// 获取目标bean的definition

RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

this.checkMergedBeanDefinition(mbd, beanName, args);

// 实例化依赖bean

String[] dependsOn = mbd.getDependsOn();

String[] var12;

if (dependsOn != null) {

var12 = dependsOn;

int var13 = dependsOn.length;

for(int var14 = 0; var14 < var13; ++var14) {

String dep = var12[var14];

if (this.isDependent(beanName, dep)) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Circular depends-on relationship between '” + beanName + “’ and '” + dep + “'”);

}

this.registerDependentBean(dep, beanName);

try {

this.getBean(dep);

} catch (NoSuchBeanDefinitionException var33) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, “'” + beanName + “’ depends on missing bean '” + dep + “'”, var33);

}

}

}

// 这里就是和单例相关的，开始创建Singleton

if (mbd.isSingleton()) {

// 这里用了一个实现ObjectFactory接口 的 lambda表达式。getSingleton会有对这个createBean，有个前置操作和后置操作，中间调用lambda进行创建

sharedInstance = this.getSingleton(beanName, () -> {

try {

return this.createBean(beanName, mbd, args);

} catch (BeansException var5) {

this.destroySingleton(beanName);

throw var5;

}

});

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

}

// 多例相关，创建Prototype

else if (mbd.isPrototype()) {

var12 = null;

Object prototypeInstance;

try {

this.beforePrototypeCreation(beanName);

prototypeInstance = this.createBean(beanName, mbd, args);

} finally {

this.afterPrototypeCreation(beanName);

}

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

} else {

String scopeName = mbd.getScope();

if (!StringUtils.hasLength(scopeName)) {

throw new IllegalStateException(“No scope name defined for bean ��” + beanName + “'”);

}

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

if (scope == null) {

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

}

try {

// scope创建和single差不多, 也是调用get by beanName + lambda表达式, 这个scope会对scopeBean生命进行管理

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

// 也有before, 只是和singleton有点不一样, 它的before和after封装在lambda中

this.beforePrototypeCreation(beanName);

Object var4;

try {

var4 = this.createBean(beanName, mbd, args);

} finally {

this.afterPrototypeCreation(beanName);

}

return var4;

});

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

} catch (IllegalStateException var32) {

throw new ScopeNotActiveException(beanName, scopeName, var32);

}

}

} catch (BeansException var35) {

beanCreation.tag(“exception”, var35.getClass().toString());

beanCreation.tag(“message”, String.valueOf(var35.getMessage()));

this.cleanupAfterBeanCreationFailure(beanName);

throw var35;

} finally {

beanCreation.end();

}

}

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

try {

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

if (convertedBean == null) {

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

} else {

return convertedBean;

}

} catch (TypeMismatchException var34) {

if (this.logger.isTraceEnabled()) {

this.logger.trace(“Failed to convert bean '” + name + “’ to required type '” + ClassUtils.getQualifiedName(requiredType) + “'”, var34);

}

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

}

} else {

return bean;

}

}

这个方法比较长，内容比较多，咱们挑重要的分开来进行讲解：

【1】获取单例对象

if (sharedInstance != null && args == null) {

if (this.logger.isTraceEnabled()) {

if (this.isSingletonCurrentlyInCreation(beanName)) {

this.logger.trace(“Returning eagerly cached instance of singleton bean '” + beanName + “’ that is not fully initialized yet - a consequence of a circular reference”);

} else {

this.logger.trace(“Returning cached instance of singleton bean '” + beanName + “'”);

}

}

bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);

} else {

// 创建对象

}

首先，会去spring的容器里面根据名字查找单例，如果获取到单例实例对象，就直接返回该实例，如果获取不到，则进入到else分支，就是创建单例，创建单例之前，首先会把目标bean里面的所有依赖bean（并非@Autowired注解的bean，而是xml用到depend-on标签，或者是参数值引用的bean）全都创建完才创建目标bean，部分代码如下：

【2】实例化依赖bean

// 获取目标bean的definition

RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

this.checkMergedBeanDefinition(mbd, beanName, args);

// 实例化依赖bean

String[] dependsOn = mbd.getDependsOn();

String[] var12;

if (dependsOn != null) {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

f (dependsOn != null) {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-JCn8nsKW-1710779681153)]
[外链图片转存中…(img-Pu8YIkhZ-1710779681154)]
[外链图片转存中…(img-cVRIRKh7-1710779681154)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-LoDoPG2o-1710779681155)]