Spring原理篇(6)--为什么你跟别的程序员一起去面试-优快云博客

如果找不到就会创建这个Bean;

return createBean(beanName, mbd, args);

}

catch (BeansException ex) {

destroySingleton(beanName);

throw ex;

}

});

beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

--------------- 省过部分代码

try {

Object scopedInstance = scope.get(beanName, () -> {

初始化前

beforePrototypeCreation(beanName);

try {

初始化

return createBean(beanName, mbd, args);

}

finally {

初始化后

afterPrototypeCreation(beanName);

}

});

}

在createBean 方法中:

@Override

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

throws BeanCreationException {

if (logger.isTraceEnabled()) {

logger.trace(“Creating instance of bean '” + beanName + “'”);

}

…

RootBeanDefinition mbdToUse = mbd;

确保bean类在这一点上被实际解析，并且

在动态解析类的情况下克隆bean定义

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {

mbdToUse = new RootBeanDefinition(mbd);

mbdToUse.setBeanClass(resolvedClass);

}

准备方法重写

try {

mbdToUse.prepareMethodOverrides();

}

catch (BeanDefinitionValidationException ex) {

throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),

beanName, “Validation of method overrides failed”, ex);

}

try {

允许BeanPostProcessors有机会返回代理而不是目标bean实例-这里能明白的同学可以加分了;

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

if (bean != null) {

return bean;

}

catch (Throwable ex) {

throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,

“BeanPostProcessor before instantiation of bean failed”, ex);

}

try {

调用方法是 doCreateBean 跟CreateBean 方法是两个方法;重点重点重点

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

if (logger.isTraceEnabled()) {

logger.trace(“Finished creating instance of bean '” + beanName + “'”);

}

接下来直接返回实例; 不用多说;

return beanInstance;

}

catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {

throw ex;

}

catch (Throwable ex) {

throw new BeanCreationException(

mbdToUse.getResourceDescription(), beanName, “Unexpected exception during bean creation”, ex);

}

doCreateBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

throws BeanCreationException {

开始实例化Bean

BeanWrapper instanceWrapper = null;

判断Bean是不是单例的如果是

if (mbd.isSingleton()) {

先从Factory 删除Bean; 这里就是个ConcurrentMap 也就是删除正在创建的Bean的包装对象;

instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

}

删除了之后是不是null; 然后开始createBeanInstance

if (instanceWrapper == null) {

开始进入createBeanInstance

instanceWrapper = createBeanInstance(beanName, mbd, args);

}

以下源码暂时不解析; 在之后的篇章会详细说的; 目前就到这里可以了

进入createBeanInstance 方法内不用纠结每一行代码;不然会彻底迷失在Spring源码中;

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {

确保bean class 这里过;

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

}

重新创建同一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);

}

获取目前传入的Bean的构造器确定Bean使用的是什么构造器; 如果没有指定构造器那么就是无参构造器;

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||

mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {

return autowireConstructor(beanName, mbd, ctors, args);

}

确定构造器的阶段;

ctors = mbd.getPreferredConstructors();

if (ctors != null) {

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

}

这一行代码是重点; 没有特殊处理那么就用无参的这里进来;

return instantiateBean(beanName, mbd);

}

instantiateBean

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {

传入的BeanName 与 RootBeanDefinition 最后在 instantiate 中被执行;

try {

Object beanInstance;

if (System.getSecurityManager() != null) {

beanInstance = AccessController.doPrivileged(

(PrivilegedAction) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),

getAccessControlContext());

}

else {

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);

}

BeanWrapper bw = new BeanWrapperImpl(beanInstance);

initBeanWrapper(bw);

return bw;

}

catch (Throwable ex) {

throw new BeanCreationException(

mbd.getResourceDescription(), beanName, “Instantiation of bean failed”, ex);

}

instantiate

@Override

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {

if (!bd.hasMethodOverrides()) {

构造方法;

Constructor<?> constructorToUse;

加锁

synchronized (bd.constructorArgumentLock) {

获取构造对象赋值

constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;

判断构造对象主要是判断; 下面的BeanUtils 那一句才是重点;

if (constructorToUse == null) {

final Class<?> clazz = bd.getBeanClass();

if (clazz.isInterface()) {

throw new BeanInstantiationException(clazz, “Specified class is an interface”);

}

try {

if (System.getSecurityManager() != null) {

constructorToUse = AccessController.doPrivileged(

(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);

}

else {

constructorToUse = clazz.getDeclaredConstructor();

}

bd.resolvedConstructorOrFactoryMethod = constructorToUse;

}

catch (Throwable ex) {

throw new BeanInstantiationException(clazz, “No default constructor found”, ex);

}

这里是重点 instantiateClass

return BeanUtils.instantiateClass(constructorToUse);

}

else {

cglib的东西不管; 后面再说;

return instantiateWithMethodInjection(bd, beanName, owner);

}

instantiateClass

public static T instantiateClass(Constructor ctor, Object… args) throws BeanInstantiationException {

这里大家应该都可以看懂了; 传进构造函数; 判空

Assert.notNull(ctor, “Constructor must not be null”);

try {

ReflectionUtils.makeAccessible(ctor);

if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {

return KotlinDelegate.instantiateClass(ctor, args);

}

else {

构造器的构造参数类型;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

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

[外链图片转存中…(img-EYQ33pmf-1715090668360)]

[外链图片转存中…(img-of0WfVkE-1715090668361)]

[外链图片转存中…(img-WC3nR2yl-1715090668361)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

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