先聊聊IOC
IoC(Inversion of Control) 控制反转，是spring框架的精髓，简单来说，就是创建过程你不管，交给容器。与之对应的两个重要的类：
- BeanFactory - 接口的定义，定义了最基础的操作接口，具体功能依赖实现类
- ApplicationContext - 实现了BeanFactory，并扩展其功能
spring中的IOC
Spring以往通过xml文件加载bean，过程大致如下：
- 通过 xml 文件加载，xml文件举例：
<bean id="hello" class="cn.test.service.Hello">
<property name="content" value="hello"/>
</bean>
- 加载相关属性
- 反射实例化对象
- xml中的autowire
注意：xml中也可以配置 autowire 会自动注入，参数 byName，意思是通过name去寻找依赖，通过这个方式解决依赖的注入。
<!-- 通过设置 autowire 属性，我们就不需要像上面那样显式配置依赖了 -->
<bean name="serviceAutowire" class="cn.test.autowire.Service" autowire="byName"/>
- 解决配置bean太多的问题 引入FactoryBean（注意不是BeanFactory）
- ApplicationContextAware引入
在我们的web程序中，用spring来管理各个实例(bean), 有时在程序中为了使用已被实例化的bean, 通常会用到这样的代码
ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext-common.xml");
AbcService abcService = (AbcService)appContext.getBean("abcService");
这会重新装载applicationContext-common.xml并实例化上下文bean，如果有些线程配置类也是在这个配置文件中，那么会造成做相同工作的的线程会被启两次。一次是web容器初始化时启动，另一次是上述代码显示的实例化了一次。当于重新初始化一遍，这样就产生了冗余。
解决方法
不用类似new ClassPathXmlApplicationContext()的方式，从已有的spring上下文取得已实例化的bean。通过ApplicationContextAware接口进行实现。
- BeanPostProcessor 是 bean 实例化时的后置处理器，包含两个方法，其源码如下：
public interface BeanPostProcessor {
// bean 初始化前的回调方法
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
// bean 初始化后的回调方法
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
BeanPostProcessor 是 Spring 框架的一个扩展点，通过实现 BeanPostProcessor 接口，我们就可插手 bean 实例化的过程。比如大家熟悉的 AOP 就是在 bean 实例后期间将切面逻辑织入 bean 实例中的，AOP 也正是通过 BeanPostProcessor 和 IOC 容器建立起了联系。
简单来说：Spring容器从xml配置、java注解、spring注解中读取bean配置信息，形成bean定义注册表，填充bean的相关属性，应用通过getBean方法可以获取其中的bean并实例化使用。
在Spring中，ClassPathXmlApplicationContext 的构造过程，实际就是 Spring IoC 的初始化过程，ClassPathXmlApplicationContext的继承关系如下图：
image.png
BeanFactory的getBean的实现细节
回到这个类最基础的一个方法，我们看getBean的过程是如何实现的。
获取bean
BeanFactory中只定义了接口，getBean(String)方法实现细节体现5个实现类中。
image.png
- SimpleJndiBeanFactory - spring beanFactory接口的基于jndi的简单实现
- StaticListableBeanFactory - 简化版的BeanFactory,由于未实现BeanDefinitionRegistry，所以并不支持BeanDefinition的注册操作
- StubWebApplicationContext - WebApplicationContext的实现
- AbstractApplicationContext - ApplicationContext是应用的配置中的核心接口，应用运行过程中是只读的，但是可以通过实现其中的接口来达到reload的目的，AbstractApplicationContext是ApplicationContext的抽象类。相比于简单的BeanFactory，ApplicationContext能在类内部检查特定的bean的定义，这个类会自动注册BeanFactoryPostProcessor和BeanPostProcessors和ApplicationListeners
- AbstractBeanFactory - BeanFactory实现的一个抽象基类，我们重点研究。
GetBean过程：AbstractBeanFactory中doGetBean
继承关系如下
image.png
BeanFactory实现的一个抽象基类，同时实现了ConfigurableBeanFactory的SPI。这个方法的getBean的实现（实际逻辑在doGetBean中），如下。
/**
* 返回一个实例，实例可以是共享的，独立的或者是一个特定的bean
* @param name： bean的名称
* @param requiredType： bean的类型
* @param args ：其他参数集合，***仅仅用于创建新对象的时候，而不是获取一个已经存在的对象*** @Nullable 表示可以为空，不能为空用@NotNull修饰
* @param typeCheckOnly：是否对象只是用来做类型检查而不是实际要用
* @return bean的实例
* @throws BeansException 如果bean不能被创建抛出异常
*/
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 去掉间接引用，去别名，使得最后的beanName是一个最简的名称，举例：
// 1 有的name名字用&开头，表示取FactoryBean本身，需要调用该方法。
// 2 name是别名，也需要转为对应的beanName
// 其中调用了BeanFactoryUtils中的方法，这个是bean操作的工具类，也很值得一读，加个todo
final String beanName = transformedBeanName(name);
Object bean;
// 检查单例缓存，获取人工注册的单例从beanName-->getSingleton获得object-->getObjectForBeanInstance获取bean
// sharedInstance 是从一个 Map<String, Object> singletonObjects结构中获取的对象，这个对象cache了bean name和bean instance的映射
// 实际接口调用过程中，有一些获取不到，向前置earlySingletonObjects获取的处理细节，这里可以看源码
Object sharedInstance = getSingleton(beanName);
// 如果 sharedInstance = null，则说明缓存里没有对应的实例，表明这个实例还没创建。
// BeanFactory 并不会在一开始就将所有的单例 bean 实例化好，而是在调用 getBean 获取bean的时候实例化，也就是 lazy加载
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 条件1:如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。
// 条件2:如果是FactoryBean，且&开头，是FactoryBean的解引用，返回FactoryBean，这个也是特殊的bean
// 条件1，2不满足，如果sharedInstance是FactoryBean，调用getObjectFromFactoryBean这个函数从中获取Object
// getObjectFromFactoryBean方法中调用doGetObjectFromFactoryBean，其中又调用factory.getObject()方法，这个方法是一个抽象接口，所有的Factory的实现类实现这个接口去create instance
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 进入这个分支，则表明 sharedInstance 可能为空，
// 此时 beanName 对应的 bean未创建，或者在父类中创建
// 如果当前的bean已经创建过（非父类），会返回失败，应该是循环引用导致的。
// debug到代码内部，prototypesCurrentlyInCreation.set有个分支：else if (curVal instanceof String)不明白为什么要有这个分支，但是不影响后续阅读，这里加个todo。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查bean的定义是否已经出现在工厂中
// 先检查父亲工厂中是否有
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 没找到，就递归地向上寻找
// 递归过程中根据不同的参数分治
// getBean 方法有很多重载，工厂模式了解一下
// 比如 getBean(String name, Object... args)，我们在首次获取，某个 bean 时，可以传入用于初始化 bean 的参数数组（args）
// BeanFactory 会根据这些参数，去匹配合适的构造方法构造 bean 实例。
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 用alreadyCreated保存需要创建的beanName，如果只是做typeCheck，可以不用创建bean
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 贯穿父子关系去获取RootBeanDefinition
// RootBeanDefinition是BeanDefinition最常用地实现类，对应配置文件中bean元素标签。在配置文件中可以定义父<bean>和子<bean>，父<bean>用RootBeanDefiniton表示，子<bean>用ChildBeanDefinition表示。
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 当前版本spring-beans-5.1.10只是在检查 !mbd.isAbstract()
checkMergedBeanDefinition(mbd, beanName, args);
// 初始化bean的依赖，举例：初始化一个店铺，店铺内有基本的设施，店铺依赖设施，这里先检查设施能否初始化。
// todo：这里有个好奇，setDependsOn什么时候被赋值的？
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 再次检查是否包含循环依赖
// 这里是最朴素的循环依赖检查逻辑，内部是深度优先遍历，
// 找到A的依赖B的集合set<B>，然后判断set<B>的每个元素的依赖集合中是否依赖A
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 给当前bean注册一个依赖bean，对应下面的dep，销毁顺序是：依赖bean销毁后，当前bean才被销毁
// 注册后，下次判断循环依赖有可以检查到这次新注册的这组依赖关系
registerDependentBean(dep, beanName);
try {
// 递归调用自己，来做检查，好多冗余操作啊...
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 创建bean的实例，其中核心方法是createBean和getObjectForBeanInstance，这一大段只不过是区分单例，原型和其他的处理情况而已。
// todo： 有时间要再读读createBean和getObjectForBeanInstance的源码。
// 单例情况
if (mbd.isSingleton()) {
// 从匿名函数返回中获取单例对象
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建一个bean
// todo：create是一个抽象接口，具体的实现逻辑在子类中，这里以后有时间可以读一下源码
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 从缓存中明确的移除单例：避免在创建流程中因为缓存导致的循环引用，同时移除任何关于这个bean的临时引用。
// 删除的位置包含singletonObjects，singletonFactories，earlySingletonObjects，registeredSingletons，disposableBeans，dependentBeanMap
destroySingleton(beanName);
throw ex;
}
});
// 从bean的实例中获取对象
// bean的实例可能是一个普通bean，也可能是FactoryBean，如果是普通Bean可以直接返回，如果是FactoryBean，需要从中再获取到bean的实例。这个方法前面也提到过
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果是原型（参考原型模式的概念）
else if (mbd.isPrototype()) {
// 如果是原型，创建一个新实例
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 非单例，非原型的方式获取bean
// 获取作用域
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, () -> {
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;
}
}
// 类型检查：判断需要的类型是否匹配实际的bean实例。
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// todo： 通过类型转化来判断是否类型匹配，这个方法的源码也值得一读。
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
// todo： ClassUtils也是一个值得读源码的工具类
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
主要流程已经在代码的注释中写清楚了，重点的几个逻辑我再总结一下：
1 去掉间接引用，去别名，使得最后的beanName是一个最简的名称transformedBeanName(name)
2 检查单例缓存，获取人工注册的单例中获取对象，利用该对象生成bean，生成方法中区分对待一般的bean和FactoryBean
3 第2步骤如果为null，从父类中获取bean和FactoryBean
4 父类中没有的话合并 BeanDefinition
5 处理 depends-on 依赖
6 创建并缓存 bean
7 调用 getObjectForBeanInstance 方法，生成 bean 实例
8 类型检查和转化
CreateBean过程
看上述核心代码，我们不难发现，有一个核心函数getSingleton一直在被调用
image.png
这个方法中传入了一个匿名函数，匿名函数中调用createBean，这是我们创建bean 的一段核心逻辑。我们先来看下getSingleton的代码逻辑
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 缓存中获取bean，不为空则直接返回
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
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!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// beforeSingletonCreation 将bean添加到 singletonsCurrentlyInCreation 的集合中，集合中存放的是正在创建的bean
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
singletonObject = 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.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 创建完成，将bean从正在创建的集合中移除
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 将 <beanName, singletonObject> 映射缓存到 singletonObjects中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
总结一下上述过程：
- 1 从singletonObjects获取能获取则直接获取，singletonObjects可以看作缓存
- 2 不能获取进入创建流程，先将 beanName 添加到 singletonsCurrentlyInCreation
- 3 getObject 调用 createBean 方法，创建bean
- 4 beanName 从 singletonsCurrentlyInCreation 中移除
- 5 <beanName, singletonObject> 添加至 singletonObjects
createBean是流程中创建bean的核心方法，我们继续看下这个createBean方法的实现。可以搜一下以下函数
return createBean(beanName, mbd, args);
在AbstractBeanFactory中只定义了一个抽象接口
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
接口的实现在AbstractAutowireCapableBeanFactory中的createBean方法
createBean方法和getBean方法有一些类似，就是真正getBean前后都做了很多事情，getBean的核心逻辑封装在另外一个方法中。
这里就不帖详细的源码了，整个代码结构就是如下形式：
- pre-createBean：
- 解析bean的类型
- prepareMethodOverrides，override method的处理，实际在处理lookup-method 和 replace-method 配置（bean配置中的两个关键字）
- 初始化前应用后置处理 resolveBeforeInstantiation，后置处理返回的 bean 不为空，则直接返回（这里也可能返回bean）
- 核心逻辑：Object beanInstance = doCreateBean(beanName, mbdToUse, args);
- post-createBean：日志记录，返回对象
resolveBeforeInstantiation会生成bean，但是我们这里先不聊，因为和AOP原理相关，这里先不扩展，另外一个生成bean的核心逻辑写在doCreateBean中。我们具体看这个方法的实现。
ps：spring框架中，真实的执行逻辑一般都放在do开头的方法中，doCreateBean也是一样。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// bean初始化
// BeanWrapper 是bean 的包装类，通过这个包装，能方便的设置和获取bean的实例属性
BeanWrapper instanceWrapper = null;
// 单例先从factoryBeanInstanceCache移除，返回为null表示不存在，那么直接用createBeanInstance创建
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// createBeanInstance创建createBean，使用三种策略之一：
// factory method, constructor autowiring 或者 simple instantiation
// factory method, 工厂方法
// constructor autowiring，构造方式自动注入
// simple instantiation，通过无参数构造方法
// 另外bean的信息配置了lookup-method和replace-method会另外处理。
// 返回类型是BeanWrapper，能用于填充对象的属性，todo：BeanWrapper的源码也值得读一读。
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 原始的bean，还没有填充属性
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 允许后置处理器post-processors 修改 MBD
synchronized (mbd.postProcessingLock) {
// postProcessed默认为false
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 缓存单例用于解决循环依赖，earlySingletonExposure用于表示是否提前暴露，即使生命周期处理接口带来的循环依赖也包含
// earlySingletonExposure的满足的条件：
// 条件: bean 是否是单例类型 & 允许循环依赖 & bean 是处于创建的状态中
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");
}
// 匿名函数获取早期bean引用，如果bean中的方法被AOP切点匹配到，会进入aop相关逻辑
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化bean的实例
Object exposedObject = bean;
try {
// 给bean装载属性，也是一个核心方法，todo：值得一读的源码
populateBean(beanName, mbd, instanceWrapper);
// 剩余的初始化工作
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.");
}
}
}
}
// 注册bean，为当前bean的销毁提供策略和实现
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
以上创建过程给各小结：
- 缓存中获取BeanWrapper，获取不到就创建BeanWrapper
- 一些预处理，MergedBeanDefinitionPostProcessor； 暴露 bean 的早期引用（early reference），用于处理循环依赖问题
- populateBean填充属性
- initializeBean进行剩下的初始化
- 注册销毁逻辑
createBeanInstance
doCreateBean这个方法中，有个很重要的核心方法createBeanInstance。
复述一下前面的批注：
createBeanInstance创建createBean，使用三种策略之一：
- factory method, constructor autowiring 或者 simple instantiation
- factory method, 工厂方法
- constructor autowiring，构造方式自动注入
- simple instantiation，通过无参数构造方法，另外bean的信息配置了lookup-method和replace-method会另外处理。返回类型是BeanWrapper，能用于填充对象的属性
instanceWrapper = createBeanInstance(beanName, mbd, args);
下面重点剖析这段代码
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);
// 检测访问权限，默认情况下，对于public的类有访问权限，没有访问权限抛出异常
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);
}
// 工厂方法不为空，通过工厂方法构建bean对象
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 如果是处理同一个bean，第一次处理的时候，做个标记，之后同类型的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 {
// 默认方法构造bean对象
return instantiateBean(beanName, mbd);
}
}
// 通过后处理器返回一系列构造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 条件mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR：bean的autowire属性是否为constructor
// 条件mbd.hasConstructorArgumentValues(): bean中是否配置了<construct-arg/>
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);
}
autowireConstructor
上面的代码通过不同的条件选择调用autowireConstructor，
这个方法比较复杂，到了这一步已经大致知道创建过程是如何的了，
这一层后续继续详解吧。
springboot中BeanWrapper的生成方法autowireConstructor
网友评论