createBean方法分析

小鱼儿 2022-11-10 10:55 189阅读 0赞

## 1：写在前面 ##

在[spring使用bean定义初始化bean分析  
][spring_bean_bean_]中已经详细分析了bean真正创建前的操作，本文，就来分析，springbean到底是如何创建的。

## 2：createBean ##

最终会执行`AbstractAutowireCapableBeanFactory`类对该方法的默认实现，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException { 
    	// 启用trace日志，则打印开始创建bean实例的日志信息
    	if (logger.isTraceEnabled()) { 
    		logger.trace("Creating instance of bean '" + beanName + "'");
    	}
    	RootBeanDefinition mbdToUse = mbd;
    
    	// 解析出beandefinition的class的类型，即当前beanName对应的
    	// 要创建的实例的类型
    	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
    		// 重新定义一个RootBeanDefinition，并设置class类型
    		mbdToUse = new RootBeanDefinition(mbd);
    		mbdToUse.setBeanClass(resolvedClass);
    	}
    
    	try { 
    		// <2021-03-18 17:39>
    		// 处理beandefinition的methodOverrides属性,主要是对
    		// 方法做一些校验工作，如果是校验不通过则异常
    		mbdToUse.prepareMethodOverrides();
    	}
    	catch (BeanDefinitionValidationException ex) { 
    		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
    				beanName, "Validation of method overrides failed", ex);
    	}
    
    	try { 
    		// <2021-03-19 14:10>
    		// 给BeanPostProcessor一个机会来返回bean的代理类
    		// 而非类本身，spring的其中一个核心功能AOP就是基于这里
    		// 来实现的
    		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    		// 这里的if判断就比较重要了，代表直接让用户使用代理类
    		// 如果是BeanPostProcessor返回的bean不为空，则返回
    		// 生成的代理bean
    		if (bean != null) { 
    			return bean;
    		}
    	}
    	catch (Throwable ex) { 
    		// 发生异常，抛出因为BeanPostProcessor初始化bean的异常信息
    		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
    				"BeanPostProcessor before instantiation of bean failed", ex);
    	}
    
    	try { 
    		// <2021-03-19 14:55>,创建bean
    		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Finished creating instance of bean '" + beanName + "'");
    		}
    		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);
    	}
    }

`<2021-03-18 17:39>`处是处理beandefinition的`methodOverrides`属性，定义如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#methodOverrides
    private MethodOverrides methodOverrides = new MethodOverrides();

在[spring解析bean标签过程分析  
][spring_bean_]文章我们分析了bean的主要子标签，其中[replace-method][]和[lookup-method][]解析出的信息会被存储到该属性中，如下相关解析代码段：

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)
    parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

该代码段就是执行具体解析，然后将解析的信息存储到`methodOverrides`属性中的。  
该处源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverrides
    public void prepareMethodOverrides() throws BeanDefinitionValidationException { 
    	// <2021-03-19 10:18>
    	if (hasMethodOverrides()) { 
    		// <2021-03-19 10:19>
    		getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
    	}
    }

`<2021-03-19 10:18>`查看是否有methodOverrides的信息，源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#hasMethodOverrides
    public boolean hasMethodOverrides() { 
    	// 不为空即为存在
    	return !this.methodOverrides.isEmpty();
    }

`<2021-03-19 10:19>`处是获取methodOverrides属性，然后循环调用方法`org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverride`,因此我们来看下这个方法做了哪些处理，源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverride
    protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException { 
    	// 检测方法被重载的次数，因为不管是通过lookup-method调用bean的方法
    	// 获取一个bean，还是replace-method使用MethodReplacer的实现类
    	// 动态替换bean的方法，都首先必须有这个方法
    	int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    	// 当count为0时，代表没有需要的方法，直接抛出异常
    	if (count == 0) { 
    		throw new BeanDefinitionValidationException(
    				"Invalid method override: no method with name '" + mo.getMethodName() +
    				"' on class [" + getBeanClassName() + "]");
    	}
    	// 如果是1个方法，则设置没有重载版本，这样的话后续就不需要通过
    	// 判断参数来确定到底是哪个方法了，算是一种优化手段
    	else if (count == 1) { 
    		mo.setOverloaded(false);
    	}
    }

`<2021-03-19 14:10>`是执行bean的前置处理器们BeanPostProcessor，其中AOP返回代理类就是在这里实现的，详细参考`2.1：BeanPostProcessor处理`,`<2021-03-19 14:55>`处是创建bean，具体参考`2.2：创建bean`。

### 2.1：BeanPostProcessor处理 ###

这里是处理Bean后置处理器，BeanPostProcessor，其中AOP代理对象的返回就是通过这里完成的，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { 
    	Object bean = null;
    	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { 
    		// Make sure bean class is actually resolved at this point.
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
    			Class<?> targetType = determineTargetType(beanName, mbd);
    			if (targetType != null) { 
    				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
    				if (bean != null) { 
    					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
    				}
    			}
    		}
    		mbd.beforeInstantiationResolved = (bean != null);
    	}
    	return bean;
    }

这段代码不会影响bean创建的主逻辑，先放在这里，不做深入分析。

### 2.2：创建bean ###

源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException { 
    
    	// BeanWrapper是用来对bean简单包装的，具有以下的的功能
    	// 1：获取被包装的bean 2：获取被包装的bean的类型 
    	// 3：获取被包装的bean的属性描述器
    	BeanWrapper instanceWrapper = null;
    	// 如果是单例模式，则清除缓存？？？
    	if (mbd.isSingleton()) { 
    		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    	}
    	// <2021-03-20 09:39>
    	// 使用合适的初始化策略来创建bean，如构造器，工厂方法
    	// 主要完成的工作是将BeanDefinition转换为beanwrapper
    	if (instanceWrapper == null) { 
    		instanceWrapper = createBeanInstance(beanName, mbd, args);
    	}
    	final Object bean = instanceWrapper.getWrappedInstance();
    	Class<?> beanType = instanceWrapper.getWrappedClass();
    	if (beanType != NullBean.class) { 
    		mbd.resolvedTargetType = beanType;
    	}
    
    	// 应用mergedbeandefinition的后置处理，详细略
    	synchronized (mbd.postProcessingLock) { 
    		if (!mbd.postProcessed) { 
    			try { 
    				// 通过merged beandefinition的后置处理修改BeanDefinition
    				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    			}
    			catch (Throwable ex) { 
    				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    						"Post-processing of merged bean definition failed", ex);
    			}
    			mbd.postProcessed = true;
    		}
    	}
    
    	// <2021-03-20 10:11>
    	// 单例模式的循环依赖的处理
    	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    			isSingletonCurrentlyInCreation(beanName));
    	if (earlySingletonExposure) { 
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Eagerly caching bean '" + beanName +
    					"' to allow for resolving potential circular references");
    		}
    		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    	}
    
    	// 到这里创建bean结束，但是bean还没有初始化，开始初始化bean
    	Object exposedObject = bean;
    	try { 
    		// <2021-03-20 10:27>
    		// 处理Bean对应的BeanWrapper，填充属性到bean中
    		// 存在ref依赖bean的话则递归处理
    		populateBean(beanName, mbd, instanceWrapper);
    		// <2021-03-20 11:06>
    		// 调用初始化方法
    		exposedObject = initializeBean(beanName, exposedObject, mbd);
    	}
    	catch (Throwable ex) { 
    		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
    			throw (BeanCreationException) ex;
    		}
    		else { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    		}
    	}
    
    	if (earlySingletonExposure) { 
    		Object earlySingletonReference = getSingleton(beanName, false);
    		if (earlySingletonReference != null) { 
    			if (exposedObject == bean) { 
    				exposedObject = earlySingletonReference;
    			}
    			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    				String[] dependentBeans = getDependentBeans(beanName);
    				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    				for (String dependentBean : dependentBeans) { 
    					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
    						actualDependentBeans.add(dependentBean);
    					}
    				}
    				if (!actualDependentBeans.isEmpty()) { 
    					throw new BeanCurrentlyInCreationException(beanName,
    							"Bean with name '" + beanName + "' has been injected into other beans [" +
    							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    							"] in its raw version as part of a circular reference, but has eventually been " +
    							"wrapped. This means that said other beans do not use the final version of the " +
    							"bean. This is often the result of over-eager type matching - consider using " +
    							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    				}
    			}
    		}
    	}
    
    	// Register bean as disposable.
    	try { 
    		registerDisposableBeanIfNecessary(beanName, bean, mbd);
    	}
    	catch (BeanDefinitionValidationException ex) { 
    		throw new BeanCreationException(
    				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    	}
    
    	return exposedObject;
    }

`<2021-03-20 09:39>`处参考[spring通过不同的方式创建bean][spring_bean]。`<2021-03-20 10:11>`处参考[spring关于单例模式循环依赖的处理][spring]。`<2021-03-20 10:27>`处参考[处理BeanWrapper填充bean属性][BeanWrapper_bean]。`<2021-03-20 11:06>`处参考[spring调用bean的初始化方法分析][spring_bean 1]。

[spring_bean_bean_]: https://blog.csdn.net/wang0907/article/details/114590369
[spring_bean_]: https://blog.csdn.net/wang0907/article/details/114252232
[replace-method]: https://blog.csdn.net/wang0907/article/details/114325252
[lookup-method]: https://blog.csdn.net/wang0907/article/details/114321253
[spring_bean]: https://blog.csdn.net/wang0907/article/details/115022759
[spring]: https://blog.csdn.net/wang0907/article/details/115023213
[BeanWrapper_bean]: https://blog.csdn.net/wang0907/article/details/115023488
[spring_bean 1]: https://blog.csdn.net/wang0907/article/details/115024344