getBean( )流程
getBean() 方法是顶层接口 BeanFactory 提供的,一共五个原型。AbstractBeanFactory
作为抽象实现,复写了其中3
个方法,
@Overridepublic Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);}@Overridepublic <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {return doGetBean(name, requiredType, null, false);}@Overridepublic Object getBean(String name, Object... args) throws BeansException {return doGetBean(name, null, args, false);}
// 备注:此处的doGetBean,就是Bean实例化的核心逻辑
DefaultListableBeanFactory
继承自 AbstractBeanFactory
,复写了剩余的2个方法:
@Overridepublic <T> T getBean(Class<T> requiredType) throws BeansException {return getBean(requiredType, (Object[]) null);}// 上面那个方法是调用这个方法的逻辑。@Overridepublic <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {]// resolveNamedBean里面的逻辑,也是根据requiredType去找的。若不止一个会抛错:NoUniqueBeanDefinitionExceptionNamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);if (namedBean != null) {return namedBean.getBeanInstance();}// 从这里我们可以看到,如果子容器里没有找到Bean,还回去父容器(若存在的话)里找找看BeanFactory parent = getParentBeanFactory();if (parent != null) {return (args != null ? parent.getBean(requiredType, args) : parent.getBean(requiredType));}throw new NoSuchBeanDefinitionException(requiredType);}
getBean方法的具体实现逻辑在 AbstractBeanFactory
类里面的doGetBean方法中。那么接下里,我们就看看这里面最最核心的逻辑:doGetBean(),
AbstractBeanFactory#doGetBean
依赖注入主要有两个过程,一个是实例化Bean,另一个是将依赖关系注入到Bean中。
从命名上我们也可以看出:他是 doGetBean,是有 do
这个动作的。因此不是简单的 get 有就返回,没有就返回 null 这么简单的操作。而是里面做了实例化、依赖注入、属性赋值、解决循环依赖等一些列操作~
【小家Spring】AbstractBeanFactory#getBean()、doGetBean完成Bean的初始化、实例化,以及BeanPostProcessor后置处理器源码级详细分析_方向盘(YourBatman)的博客-CSDN博客
关于 Spring 中 getBean 的全流程源码解析 - 小傅哥 - 博客园
可以通过 ApplicationContext 的 getBean 方法来获取 Spring 容器中已初始化的 bean。getBean 一共有以下3种方法原型。首先定义一个 Person 类,接下来演示 getBean 的3种方法原型,
(1)getBean(String beanName)
(2)getBean(Class<T> type)
对getBean(String name)和getBean(Class<T> type)的异同点进行对比总结:
1. 相同点:都要求 id 或者 name 或者类型在容器中的唯一性。
2. 不同点:getBean(String name)获得的对象需要类型转换,而getBean(Class<T> type)获得的对象无需类型转换。
(3)getBean(String beanName, Class<T> type)
(4)getBean(String beanName, Object[] args)
这种方式本质还是通过 bean 的 id 或者 name 来获取 bean,通过第二个参数 Object[] args 可以给 bean 的属性赋值,赋值的方式有两种:构造方法和工厂方法。但是通过这种方式获取的 bean 必须把 scope 属性设置为 prototype,也就是原型模式。
getBean() 核心流程
源码位置:AbstractBeanFactory --> getBean() --> doGetBean()。
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException { // getBean 就像你的领导其实没做啥,都在 doGetBean 里return doGetBean(name, requiredType, null, false);
}
protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException { // 处理别名BeanName、处理带&符的工厂BeanName// 1.如果传入的是FactoryBean,则去掉Bean开头的&符号;// 2.可能存在传入别名且别名存在多重映射的情况,这里会返回最终的名字。如存在多层别名映射A->B->C->D,传入D,最终会返回Afinal String beanName = transformedBeanName(name);Object bean; // 先尝试从缓存中获取Bean实例,这个位置就是三级缓存解决循环依赖的方法。若获取不到,就走下面的创建// getSingleton()方法的实现,在父类DefaultSingletonBeanRegistry中,请先移步下面,看详解Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { // 获取到了if (logger.isDebugEnabled()) {// 这里虽然只是一句日志,但是能说明用意。// 若条件为true,表示这个Bean虽然在缓存里,但是还并没有完全被初始化(循环引用)if (isSingletonCurrentlyInCreation(beanName)) {logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.debug("Returning cached instance of singleton bean '" + beanName + "'");}} // 在getBean方法中,getObjectForBeanInstance是个频繁使用的方法。因此为了更好的知道细节,下面会详解这个方法的。其实简单理解就是处理FactoryBean的getObject()方法// 1. 如果sharedInstance是普通的Bean实例,则下面的方法会直接返回// 2. 如果sharedInstance是工厂Bean类型,则需要获取getObject方法,可以参考关于FactoryBean的实现类 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}else { // 没有获取到// 循环依赖有三种,setter注入、多实例和构造函数,Spring 只能解决 setter 注入,所以这里是 Prototype 则会抛出异常。即原型对象不允许循环创建,如果是原型对象正在创建,那就抛异常if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);} // 1. 若父bean工厂存在,就要检查父容器是否实例化过它,避免被重复实例化(若父容器实例化过,就以父容器实例化的为准)。Spring中的单例bean只会被实例化一次BeanFactory parentBeanFactory = getParentBeanFactory();if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // 父容器存在且当前工厂中不存在// 获取name对应的beanName,如果name是以&开头,则返回& + beanNameString nameToLookup = originalBeanName(name); // 根据 args 参数是否为空,调用不同的父容器方法获取 bean 实例if (args != null) {return (T) parentBeanFactory.getBean(nameToLookup, args);}else {return parentBeanFactory.getBean(nameToLookup, requiredType);}} // 1. typeCheckOnly,用于判断调用 getBean 方法时,是否仅是做类型检查// 2. 如果不是只做类型检查,就会调用 markBeanAsCreated 进行记录if (!typeCheckOnly) {markBeanAsCreated(beanName);}try { // 从容器 getMergedLocalBeanDefinition 获取 beanName 对应的 GenericBeanDefinition,转换为 RootBeanDefinitionfinal RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检查当前创建的 bean 定义是否为抽象 bean 定义checkMergedBeanDefinition(mbd, beanName, args);//这里就重要了,因为我们会有属性注入等,故这里就要保证它依赖的那些属性先初始化才行//这部分是处理循环依赖的核心,下面有大篇幅专门讲解这方面的以及原理解决方案//@DependsOn注解可以控制Bean的初始化顺序~~~String[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {for (String dep : dependsOn) { // 监测是否存在 depends-on 循环依赖,若存在则会抛出异常if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");} // 注册依赖记录registerDependentBean(dep, beanName);try { // 加载 depends-on 依赖(dep 是 depends-on 缩写)getBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}} // 从这里开始,就正式开始着手创建单例 bean 实例了if (mbd.isSingleton()) { //也是一样先尝试从缓存去获取,获取失败就通过ObjectFactory的createBean方法创建。这个getSingleton方法和上面是重载方法,它支持通过ObjectFactory去根据Scope来创建对象,具体源码解析见下面//把 beanName 和 new ObjectFactory 匿名内部类传入回调sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {try { // 这是创建Bean的核心方法,非常重要~~~~~~~~~~~~~~~下面会有return createBean(beanName, mbd, args);}catch (BeansException ex) {// 创建失败则销毁destroySingleton(beanName);throw ex;}}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);} // 创建其他类型的 bean 实例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, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {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;}}// 这里就比较简单了,就是requiredType,比如要求是Integer,获得的是String,俺么就会调用转换器转换过来。绝大多数情况下,没啥卵用if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {try {return getTypeConverter().convertIfNecessary(bean, requiredType);}catch (TypeMismatchException ex) {if (logger.isDebugEnabled()) {logger.debug("Failed to convert bean '" + name + "' to required type '" +ClassUtils.getQualifiedName(requiredType) + "'", ex);}throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}} // 返回 Beanreturn (T) bean;
}
DefaultSingletonBeanRegistry#getSingleton
详解(三级缓存原理):
@Override
@Nullable
public Object getSingleton(String beanName) {return getSingleton(beanName, true);
}@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 此处是先从已经缓存好了的singletonObjects的Map中,查看有木有(至于当前已经有哪些了,下面有个截图,相信什么时候进来的都应该有些印象吧)Object singletonObject = this.singletonObjects.get(beanName);// 若缓存里没有。并且,并且,并且这个Bean必须在创建中,才会进来。// singletonsCurrentlyInCreation字段含义:会缓存下来所有的正在创建中的Bean,如果有Bean是循环引用的 会把这种Bean先放进去,这里才会有值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) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;
}
DefaultSingletonBeanRegistry#getSingleton
详解(根据ObjectFactory结合Scope来创建合适的对象):
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");synchronized (this.singletonObjects) {// 从缓存中获取(上面获取过一次的,这里是双从判定)Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {// 如果这个Bean正在被销毁,就抛异常了if (this.singletonsCurrentlyInDestruction) {throw new BeanCreationNotAllowedException(beanName,"Singleton bean creation not allowed while singletons of this factory are in destruction " +"(Do not request a bean from a BeanFactory in a destroy method implementation!)");}// 创建前置检查:1、若在inCreationCheckExclusions面校验名单里,是ok的//2、singletonsCurrentlyInCreation把它添加进去,证明这个Bean正在创建中beforeSingletonCreation(beanName);// 此处先打标机为为falseboolean newSingleton = false;boolean recordSuppressedExceptions = (this.suppressedExceptions == null);if (recordSuppressedExceptions) {this.suppressedExceptions = new LinkedHashSet<>();}try {// 把这个实例生成出来,并且标志位设为truesingletonObject = singletonFactory.getObject();newSingleton = true;} catch (IllegalStateException ex) {// Has the singleton object implicitly appeared in the meantime ->// if yes, proceed with it since the exception indicates that state.// in the meantime再次旗舰,若有人已经把这个Bean放进去了,那就抛出这个异常吧singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {throw ex;}} catch (BeanCreationException ex) {// 处理异常// 比如我们经常遇到的UnsatisfiedDependencyException异常:@Autowired的时候找不到依赖的Bean就是这个异常(一般由NoSuchBeanDefinitionException这个异常导致)// 这里会吧异常链接拼接起来,然后一起打印出来~~~~非常方便查找问题if (recordSuppressedExceptions) {for (Exception suppressedException : this.suppressedExceptions) {ex.addRelatedCause(suppressedException);}}throw ex;} finally {if (recordSuppressedExceptions) {this.suppressedExceptions = null;}// 创建完成后再检查一遍。做的操作为:从正在创建缓存中移除afterSingletonCreation(beanName);}// 这里也非常重要:若是新的Bean,那就执行addSingleton这个方法,这个方法做了什么,就下面4步操作://this.singletonObjects.put(beanName, singletonObject); //缓存起来//this.singletonFactories.remove(beanName); //把对应ObjectFactory的缓存移除//this.earlySingletonObjects.remove(beanName);//this.registeredSingletons.add(beanName);if (newSingleton) {addSingleton(beanName, singletonObject);}}return singletonObject;}}
开始创建Bean AbstractAutowireCapableBeanFactory#createBean
提供此方法的抽象类为:AbstractBeanFactory
,由子类去实现创建的逻辑,
@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {RootBeanDefinition mbdToUse = mbd;// 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.// 确保对应BeanClass完成解析(已经加载进来了Class对象)具体表现是进行了ClassLoder.loadClass或Class.forName完成了类加载// 主要根据传入的typesToMatch生成特定的ClassLoader,之后还要调用RootBeanDefinition#resolveBeanClass,根据特定的加载器或者默认加载器加载出class属性对应的Class对象// 我们这里解析出来,显然就是class com.fsx.service.HelloServiceImpl这个Class了// 判断需要创建的Bean是否可以实例化,这个类是否可以通过类装载器来载入(也就说它甚至可能来源于网络)Class<?> resolvedClass = resolveBeanClass(mbd, beanName);if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {mbdToUse = new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.try {// 这里主要是解析<lookup-method name="getFruit" bean="bananer"/>类似这种方式的依赖注入(Spring支持lookup-method,replace-method两个依赖注入的方式)// 它相当于调用指定类里面的指定方法进行注入,所以需要考虑到方法重载的情况,因此这个方法解析的就是这种情况// 由于项目中一般这么使用,也非常的不大众,具体原理此处省略mbdToUse.prepareMethodOverrides();} catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName, "Validation of method overrides failed", ex);}try {// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.// 从doc解释:给BeanPostProcessors一个机会来返回一个代理对象代替目标对象 什么动态代理之类的,都在这里实现的~~~~~~~~~~~~~~~~~~~// 1、具体逻辑是判断当前Spring容器是否注册了实现了InstantiationAwareBeanPostProcessor接口的后置处理器如果有,则依次调用其中的applyBeanPostProcessorsBeforeInstantiation方法,如果中间任意一个方法返回不为null,直接结束调用。// 2、然后依次所有注册的BeanPostProcessor的postProcessAfterInitialization方法(同样如果任意一次返回不为null,即终止调用。// 这个方法也非常的重要,后续有详细讲解// 容器里所有的InstantiationAwareBeanPostProcessors实例,都会在此处生效,进行前置处理~~~~~~~~~~// 下面有解释:BeanPostProcessor和InstantiationAwareBeanPostProcessor的区别,可以分清楚他们执行的时机Object bean = resolveBeforeInstantiation(beanName, mbdToUse);// 如果不为空,说明提前生成了实例,直接返回if (bean != null) {return bean;}} catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,"BeanPostProcessor before instantiation of bean failed", ex);}// 这里又是一个核心逻辑:doCreateBean 创建Beantry {Object beanInstance = doCreateBean(beanName, mbdToUse, args);// 创建完成后 直接短路掉返回 return beanInstance;// 这些都是可能出现的异常们~~~~~~~~~~~~~~~~~~~~} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {// A previously detected exception with proper bean creation context already,// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.throw ex;} catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);}}
简略总结下 getBean 整体的执行流程,
1. 根据传入的 beanName 获取 bean 的别名;
2. 尝试从缓存中获取之前被实例化了的单例 bean;
3. 根据上面获取到的实例进一步获取 bean(因为获取到的可能是工厂 bean);
4. 若第2步中没有获取到 bean,那么就需要创建 bean 了;
5. 先根据缓存判断一下当前的 bean 是否正在被创建,如果是的话表示依赖循环了;
6. 尝试获取当前工厂的父工厂,并从当前工厂的 bean 定义缓存中获取 bean 定义委托父工厂去生成;
7. 若当前要获取的 bean 只是为了进行类型检查,就标记 bean 已被创建;
8. 同当前 bean 的父类合并 bean 定义,并检查获取到的 bean 定义是不是抽象的;
9.通过上面获取到的 bean 定义找到当前 bean 的依赖 bean,并递归调用 getBean 方法获取依赖 bean;
10. 判断 bean 的 scope 是单例的还是原型的或是其他类型的,接着创建 bean;
11. 根据要求返回的 bean 类型通过 convertService 来对 bean 进行转换;
12. 最后返回 bean。
下面是 getBean 方法的简要说明:
(1)如果缓存中能取得我们想要的Bean,取得那些已经被创建过的Singleton的Bean,对这种Bean的请求不需要重复创建;
(2)如果缓存中不能取得的话,并且有parentBeanFactory的话,就从parentBeanFactory中取;
(3)如果parentBeanFactory中也取不到的话,那就根据Bean的类型(Singlton或Prototype或其它)去创建我们Bean(createBean方法)。
getBean( )流程相关推荐
- Spring IoC 源码系列(五)getBean 流程分析
一.FactoryBean 用法讲解 在分析源码流程之前,我们先来看一下 FactoryBean,乍一看这家伙和 BeanFactory 很像,它们都可以用来获取 bean 对象,简单来说 Facto ...
- 简单理解Spring getBean流程
本文直接讲述流程,不贴代码,全是干货,面试必看,口口相传. 熟悉Spring启动流程的同学应该清楚,refresh()是最为重要的关键方法,其调用的finishBeanFactoryInitializ ...
- Spring getBean流程
Bean的生命周期(创建Bean的流程) 简单来说,Bean的生命周期只有四个阶段:实例化 Instantiation --> 属性赋值 Populate --> 初始化 Initiali ...
- Spring的getBean的流程(源码级讲解 + 核心流程总结)
如果你正打算深入学习Spring,但是不知从何学起,那么我强烈推荐你可以按照这个系列做一遍.本系列将Spring框架的各个部分从它庞杂的代码体系中抽取出来,然后对每一个部分进行讲解,并最终搭建成简易版 ...
- Spring源码学习(-)别怕,老外点中餐与AbstractBeanFactory.getBean的主流程差不多
引言 AbstractBeanFactory.getBean的流程,有点像老外点餐,不信咱们往下看. 入口 AbstractBeanFactory中有getBean的通用逻辑 //AbstractBe ...
- spring getBean()方法解析概述
1.getBean(beanName) 整体概述 1.transformedBeanName(name) name可能是别名,将别名(alias)解析成真正的beanName 截取&beanN ...
- Spring IoC 源码导读
源码记录:spring-framework-5.1.7-source-code-read 文章导读 Spring IoC 源码系列(一)BeanDefinition 初始化与注册 Spring IoC ...
- Spring 通过 @Lazy 注解解决构造方法循环依赖问题
什么是循环依赖? 先定义两个类 Apple.Orange,如下所示: @Component public class Apple{@Autowiredprivate Orange orange; }@ ...
- 面试官:你来说一下Spring IOC容器的创建过程
这篇文章主要讲解 IOC 容器的创建过程,让你对整体有一个全局的认识,文章没有复杂嵌套的 debug 流程,相对来说比较简单. 不 BB,上文章目录. 1. 基础知识 1.1 什么是 Spring I ...
最新文章
- 区块链笔记-Hash算法
- react生命周期函数
- 仅用10天设计的JavaScript,凭什么成为程序员最受欢迎的编程语言?
- 萌新养成 | AI科技大本营实习生招募计划
- SFB 项目经验-28-设置-所有用户-OWA-时区-语言-跳过-时区设置)
- Altium Designer 隐藏铺铜
- HD1864_最大报销额
- mysql如何创建日志_mysql中的日志
- 小白初解Linux基础相关
- 你写得API接口代码真是一坨屎,难道不能对返回格式统一处理一下吗?
- web 开发生产率_11种可帮助Web开发人员克服最后期限的生产力工具
- CV战神常用代码-----kj15
- linux ubuntu设置中文,ubuntu 中文设置 (LANG设置)
- 我的专业作文300字计算机,以我的专业为题的作文(以我写一篇作文300字)
- 2021届校招求职流程全解析(IT企业和国企)
- 那些崩溃率低于万分之一的独角兽APP都作对了什么?
- 标准C++为什么没有垃圾回收(Garbage Collection)
- bluemix_使用Bluemix采用混合云模型
- Google Play通话记录和短信权限使用限制
- 【Microsoft Azure 的1024种玩法】二十四.通过Azure Front Door 的 Web 应用程序防火墙来对 OWASP TOP 10 威胁进行防御