Spring容器原始Bean是如何创建的?Spring源码中方法的执行顺序

描述

以下内容基于 Spring6.0.4。

这个话题其实非常庞大,我本来想从 getBean 方法讲起,但一想这样讲完估计很多小伙伴就懵了,所以我们还是一步一步来,今天我主要是想和小伙伴们讲讲 Spring 容器创建 Bean 最最核心的 createBeanInstance 方法,这个方法专门用来创建一个原始 Bean 实例。

这里就以 Spring 源码中方法的执行顺序为例来和小伙伴们分享。

1. doCreateBean

AbstractAutowireCapableBeanFactory#doCreateBean 就是 Bean 的创建方法,但是 Bean 的创建涉及到的步骤非常多,包括各种需要调用的前置后置处理器方法,今天我主要是想和大家聊聊单纯的创建 Bean 的过程,其他方法咱们后面文章继续。

在 doCreateBean 方法中,有如下一行方法调用:

 

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  throws BeanCreationException {
 // Instantiate the bean.
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
 if (instanceWrapper == null) {
  instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 Object bean = instanceWrapper.getWrappedInstance();
    //...
 return exposedObject;
}

 

createBeanInstance 这个方法就是真正的根据我们的配置去创建一个 Bean 了。

2. createBeanInstance

先来看源码:

 

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
 // Make sure bean class is actually resolved at this point.
 Class beanClass = resolveBeanClass(mbd, beanName);
 if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
 }
 Supplier instanceSupplier = mbd.getInstanceSupplier();
 if (instanceSupplier != null) {
  return obtainFromSupplier(instanceSupplier, beanName);
 }
 if (mbd.getFactoryMethodName() != null) {
  return instantiateUsingFactoryMethod(beanName, mbd, args);
 }
 // Shortcut when re-creating the same bean...
 boolean resolved = false;
 boolean autowireNecessary = false;
 if (args == null) {
  synchronized (mbd.constructorArgumentLock) {
   if (mbd.resolvedConstructorOrFactoryMethod != null) {
    resolved = true;
    autowireNecessary = mbd.constructorArgumentsResolved;
   }
  }
 }
 if (resolved) {
  if (autowireNecessary) {
   return autowireConstructor(beanName, mbd, null, null);
  }
  else {
   return instantiateBean(beanName, mbd);
  }
 }
 // Candidate constructors for autowiring?
 Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
 if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
   mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  return autowireConstructor(beanName, mbd, ctors, args);
 }
 // Preferred constructors for default construction?
 ctors = mbd.getPreferredConstructors();
 if (ctors != null) {
  return autowireConstructor(beanName, mbd, ctors, null);
 }
 // No special handling: simply use no-arg constructor.
 return instantiateBean(beanName, mbd);
}

 

这里就是核心的 Bean 的创建方法了,因此这个方法我来和大家详细分析一下。

2.1 resolveBeanClass

这个方法是用来解析出来当前的 beanClass 对象,它的核心逻辑就是根据我们在 XML 文件中配置的类的全路径,通过反射加载出来这个 Class

 

@Nullable
protected Class resolveBeanClass(RootBeanDefinition mbd, String beanName, Class... typesToMatch)
  throws CannotLoadBeanClassException {
    if (mbd.hasBeanClass()) {
        return mbd.getBeanClass();
    }
    return doResolveBeanClass(mbd, typesToMatch);
}

 

首先会调用 mbd.hasBeanClass() 方法去判断是否已经通过反射加载出来 beanClass 了,如果加载出来了就直接返回,没有加载的话,就继续执行下面的 doResolveBeanClass 去加载。

什么时候会走 if 这条线呢?松哥举一个例子,如果我们设置某一个 Bean 的 Scope 是 prototype 的话,那么当第二次获取该 Bean 的实例的时候,就会走 if 这条线。

 

@Nullable
private Class doResolveBeanClass(RootBeanDefinition mbd, Class... typesToMatch)
  throws ClassNotFoundException {
 //...
 String className = mbd.getBeanClassName();
 if (className != null) {
  Object evaluated = evaluateBeanDefinitionString(className, mbd);
  if (!className.equals(evaluated)) {
   // A dynamically resolved expression, supported as of 4.2...
   if (evaluated instanceof Class clazz) {
    return clazz;
   }
   else if (evaluated instanceof String str) {
    className = str;
    freshResolve = true;
   }
   else {
    throw new IllegalStateException("Invalid class name expression result: " + evaluated);
   }
  }
  if (freshResolve) {
   // When resolving against a temporary class loader, exit early in order
   // to avoid storing the resolved Class in the bean definition.
   if (dynamicLoader != null) {
                return dynamicLoader.loadClass(className);
   }
   return ClassUtils.forName(className, dynamicLoader);
  }
 }
 // Resolve regularly, caching the result in the BeanDefinition...
 return mbd.resolveBeanClass(beanClassLoader);
}

 

按理说,根据我们配置的类的全路径加载出来一个 Class 应该是非常容易的,直接 Class.forName 就可以了。

但是!!!

如果对 Spring 用法比较熟悉的小伙伴就知道,配置 Class 全路径的时候,我们不仅可以像下面这样老老实实配置:

 


 

我们甚至可以使用 SpEL 来配置 Bean 名称,例如我有如下类:

 

public class BeanNameUtils {
    public String getName() {
        return "org.javaboy.bean.User";
    }
}

 

这里有一个 getName 方法,这个方法返回的是一个类的全路径,现在我们在 XML 文件中可以这样配置:

 



 

在 XML 的 class 属性中,我们可以直接使用 SpEL 去引用一个方法的执行,用该方法的返回值作为 class 的值。

了解了 Spring 中的这个玩法,再去看上面的源码就很好懂了:

首先调用 mbd.getBeanClassName(); 去获取到类路径。

接下来调用 evaluateBeanDefinitionString 方法进行 SpEL 运算,这个运算的目的是为了解析 className 中的 SpEL 表达式,当然,一般情况下 className 就是一个普通的字符串,不是 SpEL 表达式,那么解析完成之后就还是原本的字符串。如果是 className 是一个 SpEL,那么合法的解析结果分为两种:

首先就是解析之后拿到了一个 Class,那这个就是我们想要的结果,直接返回即可。

要么就是解析出来是一个字符串,松哥上面举的例子就是这种情况,那么就把这个字符串赋值给 className,并且将 freshResolve 属性设置为 true,然后在接下来的 if 分支中去加载 Class。

当然,上面这些都是处理特殊情况,一般我们配置的普通 Bean,都是直接走最后一句 mbd.resolveBeanClass(beanClassLoader),这个方法的逻辑其实很好懂,我把代码贴出来小伙伴们来瞅一瞅:

 

@Nullable
public Class resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
 String className = getBeanClassName();
 if (className == null) {
  return null;
 }
 Class resolvedClass = ClassUtils.forName(className, classLoader);
 this.beanClass = resolvedClass;
 return resolvedClass;
}

 

这个方法就相当直白了,根据 className 加载出来 Class 对象,然后给 beanClass 属性也设置上值,这就和一开始的 if (mbd.hasBeanClass()) 对应上了。

好了,到此,我们总算是根据 className 拿到 Class 对象了。

2.2 Supplier 和 factory-method

好了,回到一开始的源码中,接下来该执行如下两行代码了:

 

Supplier instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
 return obtainFromSupplier(instanceSupplier, beanName);
}
if (mbd.getFactoryMethodName() != null) {
 return instantiateUsingFactoryMethod(beanName, mbd, args);
}

 

这两个松哥在前面的文章中和小伙伴们已经讲过了(Spring5 中更优雅的第三方 Bean 注入):前面的 obtainFromSupplier 方法是 Spring5 开始推出来的 Supplier,通过回调的方式去获取一个对象;第二个方法 instantiateUsingFactoryMethod 则是通过配置的 factory-method 来获取到一个 Bean 实例。

对这两个方法不熟悉的小伙伴可以参考前面的文章:Spring5 中更优雅的第三方 Bean 注入。

2.3 re-create 逻辑

继续回到一开始的源码中,接下来是一段 re-create 的处理逻辑,如下:

 

boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
 synchronized (mbd.constructorArgumentLock) {
  if (mbd.resolvedConstructorOrFactoryMethod != null) {
   resolved = true;
   autowireNecessary = mbd.constructorArgumentsResolved;
  }
 }
}
if (resolved) {
 if (autowireNecessary) {
  return autowireConstructor(beanName, mbd, null, null);
 }
 else {
  return instantiateBean(beanName, mbd);
 }
}

 

根据前面的介绍,我们现在已经获取到 Class 对象了,接下来直接调用相应的构造方法就可以获取到 Bean 实例了。但是这个 Class 对象可能存在多个构造方法,所以还需要一堆流程去确定到底调用哪个构造方法。

所以这里会先去判断 resolvedConstructorOrFactoryMethod 是否不为空,不为空的话,说明这个 Bean 之前已经创建过了,该用什么方法创建等等问题都已经确定了,所以这次就不用重新再去确定了(resolved = true)。另一方面,autowireNecessary 表示构造方法的参数是否已经处理好了,这个属性为 true 则表示构造方法的参数已经处理好了,那么就可以调用 autowireConstructor 方法去创建一个 Bean 出来,否则调用 instantiateBean 方法初始化 Bean。

这里涉及到的 autowireConstructor 和 instantiateBean 方法我们先不细说了,因为在后面还会再次涉及到。

2.4 构造器注入

继续回到一开始的源码中,接下来就是针对各种处理器的预处理了:

 

Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
 return autowireConstructor(beanName, mbd, ctors, args);
}

 

先来看 determineConstructorsFromBeanPostProcessors 方法,这个方法主要是考虑到你可能提供了 SmartInstantiationAwareBeanPostProcessor,松哥在前面的文章中和大家专门讲过 BeanPostProcessor(BeanFactoryPostProcessor 和 BeanPostProcessor 有什么区别?),这里的 SmartInstantiationAwareBeanPostProcessor 算是 BeanPostProcessor 的一种,也是 Bean 的一种增强器。SmartInstantiationAwareBeanPostProcessor 中有一个 determineCandidateConstructors 方法,这个方法返回某一个 Bean 的构造方法,将来可以通过这个构造方法初始化某一个 Bean。

我给大家举一个简单例子,假设我有如下类:

 

public class User {
    private String username;
    private String address;

    public User() {
        System.out.println("=====no args=====");
    }

    public User(ObjectProvider username) {
        System.out.println("args==username");
        this.username = username.getIfAvailable();
    }

    //省略 getter/setter/toString
}

 

现在我在 Spring 容器中注册这个对象:

 



 

按照我们已有的知识,这个将来会调用 User 的无参构造方法去完成 User 对象的初始化。

但是现在,假设我添加如下一个处理器:

 

public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    @Override
    public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {
        if ("user".equals(beanName)) {
            Constructor constructor = null;
            try {
                constructor = beanClass.getConstructor(ObjectProvider.class);
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
            return new Constructor[]{constructor};
        }
        return SmartInstantiationAwareBeanPostProcessor.super.determineCandidateConstructors(beanClass, beanName);
    }
}

 

在 determineCandidateConstructors 方法中,返回一个有参构造方法,那么将来 Spring 容器会通过这里返回的有参构造方法去创建 User 对象,而不是通过无参构造方法去创建 User 对象。

最后,将这个处理器注册到 Spring 容器:

 


 

现在,当我们启动 Spring 容器的时候,User 就是通过有参构造方法初始化的,而不是无参构造方法。之所以会这样,就是因为本小节一开始提到的源码 determineConstructorsFromBeanPostProcessors,这个方法就是去查看有无 SmartInstantiationAwareBeanPostProcessor,如果有,就调用对应的方法找到处理器并返回。

这个弄懂之后,if 中其他几种情况就好理解了,mbd.getResolvedAutowireMode() 是查看当前对象的注入方式,这个一般是在 XML 中配置的,不过日常开发中我们一般不会配置这个属性,如果需要配置,方式如下:

 



 

如果添加了 autowire="constructor" 就表示要通过构造方法进行注入,那么这里也会进入到 if 中。

if 里边剩下的几个条件都好说,就是看是否有配置构造方法参数,如果配置了,那么也直接调用相应的构造方法就行了。

这里最终执行的是 autowireConstructor 方法,这个方法比较长,我就不贴出来了,和大家说一说它的思路:

首先把能获取到的构造方法都拿出来,如果构造方法只有一个,且目前也没有任何和构造方法有关的参数,那就直接用这个构造方法就行了。

如果第一步不能解决问题,接下来就遍历所有的构造方法,并且和已有的参数进行参数数量和类型比对,找到合适的构造方法并调用。

2.5 PreferredConstructors

继续回到一开始的源码中,接下来是这样了:

 

ctors = mbd.getPreferredConstructors();
if (ctors != null) {
 return autowireConstructor(beanName, mbd, ctors, null);
}

 

这块代码看字面好理解,就是获取到主构造方法,不过这个是针对 Kotlin 的,跟我们 Java 无关,我就不啰嗦了。

2.6 instantiateBean

最后就是 instantiateBean 方法了,这个方法就比较简单了,我把代码贴一下小伙伴们应该自己都能看明白:

 

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
 try {
  Object beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
  BeanWrapper bw = new BeanWrapperImpl(beanInstance);
  initBeanWrapper(bw);
  return bw;
 }
 catch (Throwable ex) {
  throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
 }
}
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
 // Don't override the class with CGLIB if no overrides.
 if (!bd.hasMethodOverrides()) {
  Constructor constructorToUse;
  synchronized (bd.constructorArgumentLock) {
   constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
   if (constructorToUse == null) {
    final Class clazz = bd.getBeanClass();
    if (clazz.isInterface()) {
     throw new BeanInstantiationException(clazz, "Specified class is an interface");
    }
    try {
     constructorToUse = clazz.getDeclaredConstructor();
     bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    }
    catch (Throwable ex) {
     throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    }
   }
  }
  return BeanUtils.instantiateClass(constructorToUse);
 }
 else {
  // Must generate CGLIB subclass.
  return instantiateWithMethodInjection(bd, beanName, owner);
 }
}

 

从上面小伙伴么可以看到,本质上其实就是调用了 constructorToUse = clazz.getDeclaredConstructor();,获取到一个公开的无参构造方法,然后据此创建一个 Bean 实例出来。

3. 小结

好了,这就是 Spring 容器中 Bean 的创建过程,我这里单纯和小伙伴们分享了原始 Bean 的创建这一个步骤,这块内容其实非常庞杂,以后有空我会再和小伙伴们分享。

最后,给上面分析的方法生成了一个时序图,小伙伴们作为参考。

处理器

其实看 Spring 源码,松哥最大的感悟就是小伙伴们一定要了解 Spring 的各种用法,在此基础之上,源码就很好懂,如果你只会 Spring 一些基本用法,那么源码一定是看得云里雾里的。






审核编辑:刘清

打开APP阅读更多精彩内容
声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉

全部0条评论

快来发表一下你的评论吧 !

×
20
完善资料,
赚取积分