前言
从前面的章节得知，AbstractAutowireCapableBeanFactory类的createBean方法是创建bean的核心方法。
今天这篇文章，就跟大家一起梳理一下流程，看看Spring到底是如何创建bean实例的。
1 createBean方法
我们一起重点看看AbstractAutowireCapableBeanFactory类中的createBean方法：
protectedObjectcreateBean(StringbeanName,
RootBeanDefinitionmbd,@NullableObject[]args)
throwsBeanCreationException{
//使用局部变量赋值mbd对象
RootBeanDefinitionmbdToUse=mbd;
//获取bean的class
Class<?>resolvedClass=resolveBeanClass(mbd,beanName);
//重新赋值beanClass
if(resolvedClass!=null&&!mbd.hasBeanClass()&&mbd.getBeanClassName()!=null){
mbdToUse=newRootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try{
//设置override属性
mbdToUse.prepareMethodOverrides();
}
catch(BeanDefinitionValidationExceptionex){
thrownewBeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName,"Validationofmethodoverridesfailed",ex);
}
try{
//提供一个机会返回代理对象
Objectbean=resolveBeforeInstantiation(beanName,mbdToUse);
if(bean!=null){
returnbean;
}
}
catch(Throwableex){
thrownewBeanCreationException(mbdToUse.getResourceDescription(),beanName,
"BeanPostProcessorbeforeinstantiationofbeanfailed",ex);
}
try{
//真正创建bean对象的地方
ObjectbeanInstance=doCreateBean(beanName,mbdToUse,args);
returnbeanInstance;
}
catch(BeanCreationException|ImplicitlyAppearedSingletonExceptionex){
throwex;
}
catch(Throwableex){
thrownewBeanCreationException(
mbdToUse.getResourceDescription(),beanName,"Unexpectedexceptionduringbeancreation",ex);
}
}createBean方法的流程还是比较简单的：
其中resolveBeanClass方法，主要处理两种情况：
- 配置了beanClass时，直接返回Class。
- 没有配置beanClass时，获取bean的name，通过类加载器加载返回Class。
拿到Class对象，说白了是方便通过反射创建bean实例。
其中doCreateBean方法才是真正创建bean的地方。
2 doCreateBean方法
protectedObjectdoCreateBean(StringbeanName,RootBeanDefinitionmbd,@NullableObject[]args)
throwsBeanCreationException{
BeanWrapperinstanceWrapper=null;
//如果是单例的bean，先删除factoryBeanInstance缓存，在 getSingletonFactoryBeanForTypeCheck方法中会用到这个缓存
if(mbd.isSingleton()){
instanceWrapper=this.factoryBeanInstanceCache.remove(beanName);
}
//如果instanceWrapper为空，则创建一个instanceWrapper
if(instanceWrapper==null){
instanceWrapper=createBeanInstance(beanName,mbd,args);
}
//从instanceWrapper对象中获取bean
Objectbean=instanceWrapper.getWrappedInstance();
//从instanceWrapper对象中获取Class
Class<?>beanType=instanceWrapper.getWrappedClass();
if(beanType!=NullBean.class){
mbd.resolvedTargetType=beanType;
}
//加锁
synchronized(mbd.postProcessingLock){
if(!mbd.postProcessed){
try{
//使用PostProcessor合并BeanDefinition,常用的注解@Autowired、@Controller、@Service、@Componet等都是在这里处理的。
applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName);
}
catch(Throwableex){
thrownewBeanCreationException(mbd.getResourceDescription(),beanName,
"Post-processingofmergedbeandefinitionfailed",ex);
}
mbd.postProcessed=true;
}
}
//是否提前曝光，满足3个条件：1.单例 2.允许循环依赖 3.单例正在创建过程中， earlySingletonExposure才为true
booleanearlySingletonExposure=(mbd.isSingleton()&&this.allowCircularReferences&&
isSingletonCurrentlyInCreation(beanName));
if(earlySingletonExposure){
//为了避免后面出现循环依赖，可以提前将创建bean的ObjectFactory加入三级缓存中
addSingletonFactory(beanName,()->getEarlyBeanReference(beanName,mbd,bean));
}
ObjectexposedObject=bean;
try{
//对bean的属性进行填充，依赖注入
populateBean(beanName,mbd,instanceWrapper);
//初始化bean
exposedObject=initializeBean(beanName,exposedObject,mbd);
}
catch(Throwableex){
if(exinstanceofBeanCreationException&&beanName.equals(((BeanCreationException)ex).getBeanName())){
throw(BeanCreationException)ex;
}
else{
thrownewBeanCreationException(
mbd.getResourceDescription(),beanName,"Initializationofbeanfailed",ex);
}
}
//如果允许提前曝光，校验一种特殊的循环依赖
if(earlySingletonExposure){
ObjectearlySingletonReference=getSingleton(beanName,false);
if(earlySingletonReference!=null){
if(exposedObject==bean){
exposedObject=earlySingletonReference;
}
elseif(!this.allowRawInjectionDespiteWrapping&&hasDependentBean(beanName)){
String[]dependentBeans=getDependentBeans(beanName);
Set<String>actualDependentBeans=newLinkedHashSet<>(dependentBeans.length);
for(StringdependentBean:dependentBeans){
if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
actualDependentBeans.add(dependentBean);
}
}
if(!actualDependentBeans.isEmpty()){
thrownewBeanCurrentlyInCreationException(beanName,
"Beanwithname'"+beanName);
}
}
}
}
//注册DisposableBean，bean销毁时执行destroy方法
try{
registerDisposableBeanIfNecessary(beanName,bean,mbd);
}
catch(BeanDefinitionValidationExceptionex){
thrownewBeanCreationException(
mbd.getResourceDescription(),beanName,"Invaliddestructionsignature",ex);
}
//返回bean实例
returnexposedObject;
}doCreateBean方法的流程如下：
其实最主要的流程是：
- 创建bean实例
- 填充bean实例的属性
- 初始化bean
3 createBeanInstance方法
记下来，我们一起看看createBeanInstance方法是如何创建instanceWrapper对象的。
protectedBeanWrappercreateBeanInstance(StringbeanName,RootBeanDefinitionmbd,@NullableObject[]args){
//获取bean对应的Class对象
Class<?>beanClass=resolveBeanClass(mbd,beanName);
//如果Class不为空，但访问权限不是public则抛异常
if(beanClass!=null&&!Modifier.isPublic(beanClass.getModifiers())&&!mbd.isNonPublicAccessAllowed()){
thrownewBeanCreationException(mbd.getResourceDescription(),beanName,
"Beanclassisn'tpublic,andnon-publicaccessnotallowed:"+beanClass.getName());
}
//允许使用Supplier回调的方式创建bean实例
Supplier<?>instanceSupplier=mbd.getInstanceSupplier();
if(instanceSupplier!=null){
returnobtainFromSupplier(instanceSupplier,beanName);
}
//如果工厂方法不为空，即设置了factory-method属性的情况，则使用工厂方法创建bean实例
if(mbd.getFactoryMethodName()!=null){
returninstantiateUsingFactoryMethod(beanName,mbd,args);
}
//先获取构造器缓存
booleanresolved=false;
booleanautowireNecessary=false;
if(args==null){
synchronized(mbd.constructorArgumentLock){
if(mbd.resolvedConstructorOrFactoryMethod!=null){
resolved=true;
autowireNecessary=mbd.constructorArgumentsResolved;
}
}
}
//如果存在构造器缓存
if(resolved){
//有参构造方法创建bean实例
if(autowireNecessary){
returnautowireConstructor(beanName,mbd,null,null);
}
else{
//使用无参构造方法创建bean实例
returninstantiateBean(beanName,mbd);
}
}
//根据SmartInstantiationAwareBeanPostProcessor寻找合适的构造器方法
Constructor<?>[]ctors=determineConstructorsFromBeanPostProcessors(beanClass,beanName);
//满足下面4种情况，任意1种情况：
//1.ctors不为空
//2.BeanDefinion的AutowireMode为AUTOWIRE_CONSTRUCTOR
//3.BeanDefinion构造器中添加的参数和值不为空
//4.getBean方法传入的构造器参数不为空
if(ctors!=null||mbd.getResolvedAutowireMode()==AUTOWIRE_CONSTRUCTOR||
mbd.hasConstructorArgumentValues()||!ObjectUtils.isEmpty(args)){
//创建bean实例
returnautowireConstructor(beanName,mbd,ctors,args);
}
//返回为null，给子类扩展，子类可以自定义获取合适的构造器的方法，比如：ClassDerivedBeanDefinition
ctors=mbd.getPreferredConstructors();
if(ctors!=null){
returnautowireConstructor(beanName,mbd,ctors,null);
}
//使用无参构造器创建bean实例
returninstantiateBean(beanName,mbd);
}下面用一张图梳理一下createBeanInstance方法的主要流程：
Spring在创建bean的时候考虑了下面几种情况：
- 使用Supplier回调的方式创建bean实例。
- 使用工厂方法创建bean实例。
- 使用缓存中有参构造器创建bean实例
- 使用缓存中无参构造器创建bean实例。
- 使用4中特殊的情况创建bean实例。
- 根据getPreferredConstructors返回的构造器创建bean实例。
- 使用无参构造器创建bean实例。
其中4种特殊的情况为：
- ctors不为空，即通过SmartInstantiationAwareBeanPostProcessor后置BeanPostProcessor返回的构造器。
- BeanDefinion的AutowireMode为AUTOWIRE_CONSTRUCTOR。
- BeanDefinion构造器中添加的参数和值不为空。
- getBean方法传入的构造器参数不为空。
只要这4种情况中，任意一种情况不为空，则执行autowireConstructor逻辑。
这里使用缓存，是为了提升性能，特别是bean的类型是prototype类型时，每一次请求都需要创建一个bean实例，每次获取构造器，还是比较耗时的。
obtainFromSupplier,instantiateUsingFactoryMethod,autowireConstructor,instantiateBean这些方法具体是怎么创建bean实例的，它们之间有什么区别？
下一篇文章，会告诉你答案。
好了，今天内容先分享到这里，下期再见。
