突击面试Spring

Marco酒馆

已于 2022-10-14 15:15:59 修改

阅读量1.3k

点赞数 1

分类专栏： Spring 文章标签： spring 面试 java

于 2022-10-12 17:24:25 首次发布

本文链接：https://blog.csdn.net/qq_39631634/article/details/127286891

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.谈谈Spring IOC的理解，原理与实现

总：

控制反转：理论思想，原来的对象是由使用者来进行控制，有了spring之后，可以把整个对象交给spring来帮我们进行管理

DI：依赖注入，把对应的属性的值注入到具体的对象中，@Autowired，populateBean完成属性值的注入

容器：存储对象，使用map结构来存储，在spring中一般存在三级缓存，singletonObjeacts存放完整的bean对象，整个bean的生命周期，从创建到使用到销毁的过程全部都是由容器来管理的(bean的生命周期)

分：

1.一般聊ioc容器的时候涉及到容器的创建过程(beanFactory,DefaultListableBeanFactory),想bean工厂中设置一些参数(BeanPostProcessor,Aeare接口的子类)等等属性
        
2.加载解析bean对象，准备要创建的bean对象的定义对象beanDefinition(xml或者注解的解析过程)
        
3.beanFactoryPostProcessor的处理，此处是扩展点，PlaceHolderConfigurSupport，ConfigurationClassPostProcessor
        
4.BeanPostProcessor的注册功能，方便后续对bean对象完成具体的扩展功能
        
5.通过反射的方式讲BeanDefinition对象实例化成具体的bean对象
        
6.bean对象的初始化过程(填充属性，调用aware子类的方法，调用BeanPostProcessor前置处理方法，调用init-mehtod方法，BeanPostProcessor的后置处理方法)
        
7.生成完整的bean对象，通过getBean方法可以直接获取
        
8.销毁过程

没看过源码？

具体的细节就不清楚了，但是spring中的bean都是通过反射的方式生成的，同时其中包含了很多的扩展点(对占位符的处理)，比如最常用的对BeanFactory的扩展，对bean的扩展，我们在公司对这方面的使用是比较多的，除此之外，ioc中最核心的也就是填充具体bean的属性，和生命周期(背一下)。

在这里插入图片描述

2.谈一下spring IOC的底层实现

底层实现：工作原理，过程，数据结构，流程，设计模式，设计思想

你对他的理解和你了解过的实现过程

反射，工厂，设计模式，关键的几个方法：

createBeanFactory , getBean ,doGetBean , createBean , doCreateBean,createBeanInstance(getDeclaredConstructor(),newinstance,populateBean

1.先通过createBeanFactory 创建一个Bean工厂(DefaultListableBeanFactory)

2.开始循环创建对象，因为容器中的bean默认都是单例的，所以优先通过getBean，doGetBean从容器中查找，找不到的话，

3.通过createBean，doCreateBean方法，以反射的方式创建对象，一般情况下使用的是无参的构造器(getDeclaredConstructor(),newinstance)

4.进行对象的属性填充populateBean

5.进行其他的初始化操作(initializingBean)

3.描述一下bean的生命周期

背图:记住图中的流程
在这里插入图片描述

在表述的时候不要只说图片中有的关键点，要学会扩展描述

设置对象这步骤，可以衍生出循环依赖的问题

1.实例化Bean，反射的方式生成对象

2.填充bena的属性：populateBean(),循环依赖的问题(三级缓存)

3.调用aware接口相关的方法：invokeAwareMethod(完成BeanName可以获取容器bean的名称，BeanFactory获取当前bean
factory这也可以调用容器的服务，BeanClassLoader对象的属性设置)

4.调用BeanPostProcessor中的前置处理方法：使用比较多的有(ApplicationContextPostProcessor设置ApplicationContext，Environment,ResourceLoader,EmbeddValueResolver等对象)

5.调用initmethod方法:invokeInitmethod(),判断是否实现了InitializingBean接口，如果有，调用afterPropertiesSet方法，

6.调用BeanPostProcessor的后置处理方法：spring的aop就是在此处实现的，AbstractAutoProxyCreator

注册Destuction相关的回调接口

7.获取到完整的对象，可以通过getBean的方式来进行对象的获取

8.销毁流程 ①判断是否实现了DispoableBean接口②调用destroyMethod方法

4.Spring是如何解决循环依赖的问题的？

围绕三点开展：三级缓存，提前暴露对象，aop

总：什么是循环依赖问题，A依赖B，B依赖C，C依赖A

分：先说明bean得创建过程：实例化，初始化（填充属性）（可参考前面三点的图）

1.先创建A对象，实例化A对象，此时A对象中的b属性为空

2.从容器中查找B对象，如果找到了，直接赋值不存在循环依赖问题(不通)，找不到直接创建B对象

3.实例化B对象，此时B对象中的a属性为空，填充属性a

4.从容器中查找A对象，找不到，直接创建

在这里插入图片描述
此时，如果仔细琢磨的话，会发现A对象，是存在的，只不过此时的A对象不是一个完整的状态，只完成了实例化但是未完成初始化，如果在程序调用过程中，拥有了某个对象的引用，能否在后期给他完成赋值操作，可以优先把非完整状态的对象优先赋值，等待后续操作来完成赋值，相当于提前暴露了某个不完整对象的引用，所以解决问题的核心在于实例化和初始化分开操作，这也是解决循环依赖问题的关键，

当所有的对象都完成实例化和初始化操作之后，还要把完整对象放到容器中，此时在容器中存在对象的两种状态：1.完成实例化=但未完成初始化。2.完整状态。因为都在容器中，所以要使用不同的map结构来进行存储，此时就有了一级缓存和二级缓存，如果一级缓存中有了，那么二级缓存中就不会存在同名的对象，因为他们的查找顺序是1，2，3这样的方式来查找的。一级缓存中放的是完整对象，二级缓存中放的是非完整对象

为什么需要三级缓存？

三级缓存的value类型是ObjectFactory，是一个函数式接口，存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个。
如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象？

要，普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理的时候，就要使用代理对象覆盖掉之前的普通对象。在实际的调用过程中，是没有办法确定什么时候对象被使用，所以就要求某个对象被调用的时候，优先判断此对象是否需要被代理，类似于一种回调机制的实现，因此传入lambda表达式的时候，可以通过lambda表达式来执行对象的覆盖过程，通过getEarlyBeanReference()方式实现。

因此，所有的bean对象在创建的时候要优先放到三级缓存中，在后续的使用过程中，如果需要被代理则返回代理对象，如果不需要被代理，则直接返回普通对象

4.1缓存的放置时间和删除时间

三级缓存: createBeanlnstance之后删除。通过addSingletonFactory方法删除。
二级缓存:第一次从三级缓存确定对象是代理对象还是普通对象的时候删除，同时删除三级缓存。通过getSingleton方法删除。
—级缓存:生成完整对象之后放到一级缓存，删除二三级缓存。通过addSingleton方法删除。

5.Bean Factory与FactoryBean有什么区别？

相同点：都是用来创建bean对象的。

不同点：使用BeanFactory创建对象的时候，必须要遵循严格的生命周期流程，太复杂了，如果想要简单的自定义某个对象的创建，同时创建完成的对象想交给spring来管理，那么就需要实现FactoryBean接口了它的方法。

FactoryBean接口的三个实现方法：

isSingleton：是否是单例对象

getObjectType：获取返回对象的类型

getObject：自定义创建对象的过程(new,反射,动态代理)

6.Spring中用到的设计模式

单例模式：bean默认都是单例的

原型模式：指定作用域为prototype

工厂模式：BeanFactory

模板模式：postProcessBeanFactory，onRefresh，initPropertyValue

策略模式：XmlBeanDefinitionReader，PropertiesBeanDefinitionReader

观察者模式：listener，event，multicast

适配器模式：Adapter

装饰者模式：BeanWrapper

责任链模式：使用aop的时候会生成一个拦截器

代理模式：动态代理

委托者模式：delegate

7.Spring的AOP的底层实现原理

aop是ioc的一个扩展功能，现有的ioc再有的aop，只是在ioc的整个流程中新增的一个扩展点而已：BeanPostProcessor

总：aop概念，应用场景，动态代理

分：bean的创建过程中有一个步骤可以对bean进行扩展实现，aop本身就是一个扩展功能，所以在BeanPostProcessor的后置处理方法中来进行实现

1.代理对象的创建过程（advice，切面，切点）

2.通过jdk或者cglib的方式来生成代理对象

3.在执行方法调用的时候，会调用到生成的字节码文件中，直接回找到DynamicAdvisoredInterceptor类中的intercept方法，从此方法开始执行

4.根据之前定义好的通知来生成拦截器

5.从拦截器链中依次获取每一个通知开始进行执行，在执行过程中，为了方便找到下一个通知是哪个，会有一个CglibMethodInvocation的对象，找的时候是从-1的位置依次开始查找并且执行的。

8.Spring的事务是如何回滚的？

spring的事务管理是如何实现的？

spring事务的五种通知类型：

https://blog.csdn.net/weixin_45525272/article/details/125955962

总：spring的事务是由aop来实现的，首先要生成具体的代理对象，然后按照aop的整套流程来执行具体的操作逻辑，正常情况下要通过通知来完成核心功能，但是事务不是通过通知实现的，而是通过一个TransactionInterceptor来实现的，然后调用invoke来实现具体的逻辑
在这里插入图片描述

分：

1.先做准备工作，解析各个方法上事务相关的属性，根据具体的属性来判断是否开始新事务

2.当需要开启的时候，获取数据库连接，关闭自动提交功能，开启事务

3.执行具体的sql逻辑操作

4.在操作过程中，如果执行失败了，那么会通过completeTransactionAfterThrowing看来完成事务的回滚操作，回滚的具体逻辑是通过doRollBack方法来实现的，实现的时候也是要先获取链接对象，通过连接对象来回滚。

5.如果执行过程中，没有任何意外情况的发生，那么通过commitTransactionAfterReturning来完成事务的提交操作，提交的具体逻辑是通过doCommit方法来实现的，实现的时候也要获取链接，通过链接对象来提交

6.当事务执行完毕之后需要清除相关的事务信息cleanupTransactionInfo

如果想要聊的更加细致的话，需要知道TransactionInfo，TransactionsStatus

9.谈一下spring事务传播？

传播特性：

https://blog.csdn.net/t_t2_3/article/details/114548914?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166573042316800182189252%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166573042316800182189252&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-2-114548914-null-null.142^v56control_1,201^v3control&utm_term=spring%E4%BA%8B%E5%8A%A1%E4%BC%A0%E6%92%AD&spm=1018.2226.3001.4187

Required，Requireds_new,nested,Support,Not_Support,Never,Mandatory

某一个事务嵌套另外一个事务的时候怎么办？

A方法调用B方法，AB方法都有事务，并且传播特性不同，那么A如果有异常，B怎么办，B如果有异常，A怎么办？

总：事务的传播特性指的是不同方法的嵌套调用过程中，事务该如何进行处理，是同一个事务还是不同的事务，当出现异常的时候会回滚还是提交，两个方法之间相互影响，在日常工作中，使用比较多的是required，Requireds_new
在这里插入图片描述

分：

1.先说事务的不同分类，可以分为三类，支持当前事务，不支持当前事务，嵌套事务

2.如果外层方法是required，内层方法是：required，requireds_new,nested

3.如果外层方法是requireds_new，内层方法是：required，requireds_new,nested

4.如果外层方法是nested，内层方法是：required，requireds_new,nested

核心处理逻辑非常简单：

1.判断内外方法是否是同一事务：

是：异常统一在外层方法处理

不是：内层方法有可能影响到外层方法，但是外层方法是不会影响内层方法的

（大致可以这么理解，但是有个别情况不同，nested）

如果自己动手把每一种情况都演示了，其实挺好理解的，关键是大家舍不舍得花费时间一个一个去验证，在面试过程中，可能会经常问一下两个问题:

1、REQUIRED和NESTED回滚的区别
在回答两种方式区别的时候、最大的问题在于保存点的没置，很多同学会认为内部设置NREQURED和NESTED效果是一样的，其实在外层方法对内层方法的异常情况在进行捕获的时候区彤都不同，使用REQURED的时候，会报Tansacion rold back because t has been matedas rolack-only信息，因为内部异常了，没置了回滚标记，外部捕获之后，要进行事务的提交.意味着要回滚，所以会报异常，而NESTED不会发证这种情况，因为在回滚的时候把回滚标记清除了，外部捕获异常后去提交，没发现回滚标记，就可以正常提交了。
2、REQUIRED_NEW和REQUIRED区别
这两种方式产生的教果是一样的，但是REQURED NlEIW会有新的连接生成，而NESTED使用的是当前事务的连接，而且NESTED还可以回滚到保存点，REQURED NFY每次都是一个新的务的回滚，但NESTED其实是一个事务，外层事务可以控制内层事务的回滚，内层就算没有异常，外层出现异常，也可以全部回滚。