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

}

首先定义了一个包装类BeanWrapper，

该接口是spring提供的用于操作bean中属性的工具，使用它可以直接修改bean里面的属性，

BeanWrapperImpl是AbstractNestablePropertyAccessor的子类，BeanWrapper的实现类，通过父类使得其具有处理属性的能力。

---

回到doCreateBean，接下来判断BeanDefinition是否是单例，如果是的话尝试从缓存中获取FactoryBean实例，如果获取不到就会执行

instanceWrapper = createBeanInstance(beanName, mbd, args);

进入到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);

// 检查是否有权通过反射创建private的Class

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

}

第一行会再次调用resolveBeanClass尝试去获取bean里面的class对象，之后看看class的访问修饰符，检查是否有权通过反射创建private的Class，如果bean使用了java自带的函数式接口Supplier，即工厂方法，就会调用工厂方法里的get方法来创建bean实例

@FunctionalInterface

public interface Supplier {

/**

• Gets a result.

• @return a result

*/

T get();

}

这里我们没有用到Supplier，就会看一下BeanDefinition里有没有定义Spring里的工厂方法，如果有则通过factory-method来返回实例。

如果不是上述两种方式，如果传入的args参数为空就会来到synchronized代码块，先判断一下先前解析配置成BeanDefinition实例的时候，有没有获取到已经解析的构造函数，如果有就会调用

return autowireConstructor(beanName, mbd, null, null);

进行有参构造函数的解析。

之后会使用带参的构造函数进行装配或者无参的构造函数进行装配。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

如何快速更新自己的技术积累？

• 在现有的项目里，深挖技术，比如用到netty可以把相关底层代码和要点都看起来。
• 如果不知道目前的努力方向，就看自己的领导或公司里技术强的人在学什么。
• 知道努力方向后不知道该怎么学，就到处去找相关资料然后练习。
• 学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

[外链图片转存中…(img-WlUlK1JM-1711856934315)]

[外链图片转存中…(img-VJpiOJDB-1711856934315)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！