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);}}