Spring原理篇(6)--为什么你跟别的程序员一起去面试，2024年最新js底层原理面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

@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 {

构造器的构造参数类型;

Class<?>[] parameterTypes = ctor.getParameterTypes();

Assert.isTrue(args.length <= parameterTypes.length, “Can’t specify more arguments than constructor parameters”);

构造方法入参;

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

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

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

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

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！**

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

[外链图片转存中…(img-Qk9uHkWO-1713574530937)]

[外链图片转存中…(img-UEn3TnZ1-1713574530937)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-UdwD1Jfi-1713574530937)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！