面试部分难点梳理 - Spring+SpringBoot自动装配

关注

原创 2022-04-05 19:05:55 1.5k 阅读 AI 写同款· GEO 优化 ›

SpringBoot面试核心：自动装配、启动流程与生产部署实战解析在Java企业级开发领域，SpringBoot以其约定大于配置的理念，极大地简化了基于Spring框架的应用开发。其核心机制自动装配，通过条件注解与SpringFactoriesLoader，实现了依赖的智能导入与Bean的自动化配置，这是理解SpringBoot设计思想的关键。从技术价值看，这种机制不仅提升了开发效率，降低了配置复杂度，还为微服务架构提供了理想的构建单元。在实际应用场景中，开发者需要掌握其启动流程，理解从main方法到内嵌Servlet容器的完整初始化序列，并熟悉多种生产部署方式，例如将应阅读详情

SpringIOC
Spring事务
 SpringMVC
感觉MVC随便看看就行，最主要的还是那张大图要记住。

随看随记

ApplicationContext和BeanFactory的区别

BeanFactory是访问spring容器的根接口，里面只是提供了某些基本方法的约束和规范，为了满足更多的需求，ApplicationContext实现了此接口，并在此接口的基础之上做了某些打展功能，提供了更加丰富的api调用。一般我们在使用的时候用applicationContext更多

BeanFactory 和 FactoryBean

BeanFactory是个bean 工厂，是一个工厂类(接口)，它负责生产和管理bean的一个工厂，是ioc 容器最底层的接口，是个ioc容器，是spring用来管理和装配普通bean的ioc容器（这些bean成为普通bean）。
FactoryBean是个bean，在IOC容器的基础上给Bean的实现加上了一个简单工厂模式，是一个可以生产对象和装饰对象的工厂bean，由spring管理后，生产的对象是由getObject()方法决定的。

各种注解之间的区别

@Configuration
public class AppConfig {    
	@Bean
	public TransferService transferService() {
		return new TransferServiceImpl();    
	}
}

@Component
public class ServiceImpl implements AService {   
	....
}

@Bean
public OneService getService(status) {
	case (status)  {
		when 1:return new serviceImpl1();
		when 2:return new serviceImpl2();
		when 3:return new serviceImpl3();    
	}
}

@Configuration
public class AppConfig {
    @Beanpublic MyBean myBean() {
    // instantiate, configure and return bean ...    
    }
}

SpringIOC

Spring程序是如何启动的

整体流程(除去各种PostProcessor的细节) ：
1. 获取从外部文件或注解中得到的信息，并封装到BeanDefinition中。其中存有bean的定义信息。
2. 根据BeanDefinition，创建beanFactory工厂。
3. 得到bean的对象(全是空)，将这个初始化对象进行初始化。
4. 得到完整的可用对象，并使用。
能够进行AOP切片的位置
1. 从BeanDefinition到BeanFactory。
2. 从实例化对象到初始化对象。
3. 初始化对象到得到完整的可用对象。
在上述的图中，从BeanDefinitionReader得到的BeanDefinition还是会有占位符，不会替换。在invokeBeanFactoryPostProcessor中会将占位符，替换成我们配置信息。
在实例化对象前(3.5步骤)，会准备beanPostProcesspr，准备监听器，事件和广播器。(观察者模式)

aware接口的作用

aware的目的是得到SpringIOC容器创建好的对象的相应属性

如何加载配置文件到应用程序

文档
大概的流程:
1. 通过I/O流得到xml的内容到内存；
2. 将内存中流转化成document(sax解析器)；
3. 根据不同的命名空间，找到对应的Handler；
4. 遍历每一个子元素；
5. 对不同的元素进行解析；
6. 得到BeanDefinition。

循环依赖

A对象的属性有B，B对象的属性有A，由于Spring创建对象默认是单例模式，因此，对导致A和B之间会循环引用，无休无止。
对于构造器注入的方式是无法打破循环依赖的，只有通过set注入的方式才可以打破循环依赖。
创建Bean的函数调用链:
getBean -> doGetBean ->createBean -> doCreateBean ->createBeanInstance ->populateBean
循环依赖图示:
1. 创造A对象
2. 实例化A对象
3. set()填充A对象，如果有A对象则直接填充，如果没有则创建B对象。
4. 实例化B对象
5. set()填充B对象，如果有B对象则直接填充，如果没有则创建A对象。
这样反复调用创建A和B对象，导致产生循环，出现问题。
因此三级缓存的作用就在于，将实例化但未完成初始化的对象进行临时储存。从而在B找不到A对象处进行处理，返回未完成创建的A对象。

三级缓存

如果要自己debug，从preInstantiateSingletons()方法开始debug。
Bean对象成为成品的流程是：
1. 未经过Aop增强的半成品(三级缓存)，存储的是lambda表达式而不是对象。
2. 经过Aop增强的半成品(二级缓存)
3. 完全实例化和初始化的成品(一级缓存)
一级缓存是singletonObjects，用于存放完成实例化和初始化的bean对象。(成品)
二级缓存是earlySingletonObjects，用于存放完成实例化但未完成初始化的bean对象。(经过AOP增强过半成品)
三级缓存是singletonFactories，用于存放需要进行AOP增强，但还未进行增强的半成品。(未经过AOP增强的半成品)
三级缓存的流程:
1. A实例化对象。
2. 将A存入三级缓存中
3. 注入A的属性，尝试获取B对象
4. B对象为空，同时一级缓存和二级中也没有，创建B对象
5. B实例化对象
6. 将B存入三级缓存中
7. 注入B的属性，尝试获取A对象
8. 没有A对象，但是发现A对象处于正在创建的状态
9. 从三级缓存中拿出A对象，经过AOP增强后，放到A的二级缓存中，同时删除A的三级缓存。并返回。
10. 将A对象填充给B对象，同时删除A的二级缓存中和B的三级缓存，经过AOP增强后，将B对象(成品)放到一级缓存中。
11. 一直返回到，填充A对象的B属性，发现B对象在一级缓存中，使用一级缓存的B对象填充给A。
12. 删除B三级对象和A的二级对象。
如果没有循环依赖的话，直接在将属性填充以后，直接调用三级缓存，进行AOP增强，放到一级缓存，不会使用二级缓存。

三级缓存面试问题

仅仅使用一级缓存行不行?

不行，如果仅仅使用一级缓存，会导致半成品对象和成品对象放到了一个map中，会导致后面取出的对象是半成品对象。
仅仅使用二级缓存行不行?

在不使用aop增强的情况下是可以的，但是在使用aop增强后，因为aop也是输入一个对象，然后生成了一个对象，也需要两个缓存池子去存，因此也是不可以的。
三级缓存做了什么事情?

三级缓存主要解决了aop过程中产生的循环依赖的问题，aop需要一个原对象，然后生成一个代理对象。三级缓存中缓存的是原对象，二级缓存中缓存的是经过aop代理后生成的代理对象。如果没有三级缓存，则会导致代理对象和原对象都存储到二级缓存中，依旧会导致取出的对象不是成品对象的问题。

谈谈Spring IOC的理解，原理与实现?

总:

IOC是一种控制反转的思想，原来的对象是由使用者来创建的，Spring是由把整个对象交给Spring来管理的。其实实现方式DI依赖注入，比如方法populateBean()来完成对实例后的对象的属性进行填充。
IOC是一种容器，是通过三级缓存的方式在存储的，一般完整的bean对象是存储在singletonObjects的ConcurrentHashMap中。

分:

首先Spring在开始时创建BeanFactory，并像BeanFactory中设置一些属性，包括==BeanPostProcessor，和Aware接口的子类等。
从XML等方式加载配置文件信息到BeanDefinition中。
然后触发BeanFactoryPostProcessor增强器，进行相应的处理，这里可以做很多扩展处理，例如在这里会对配置文件中的占位符进行置换。
注册BeanPostProcessor，方便对后面创建的对象进行拓展。
BeanFactory会通过反射的方式，将Bean对象实例化，目前这个对象没有属性被填充。
然后就开始了一个bean的生命周期，包括填充bean对象的属性，调用aware子类的方法，一般顺序是先beanNameAware，然后是BeanFactoryAware，然后是ApplicationContextAware，然后调用BeanPostProcessor的前增强器，然后调用init_method方法，然后调用BeanPostProcessor的后增强器。
然后生成了一个完整的bean，通过getBean的方法可以获取这个bean
最后销毁Bean

结：

这是我对SpringIOC的理解，面试官您有什么疑问？

谈一下springIOC的底层实现

首先通过createBean()方法创建一个bean工厂(defaultListableBeanFactory)
然后循环创建bean对象，因为Spring创建Bean默认是单例的，因此通过调用getBean方法和doGetBean方法
如果没有get到就创建对象，调用createBean()和doCreateBean()方法，通过反射的方式得到对象的构造器，然后通过反射的getInstance方法得到实例化的bean对象。
调用populationBean()方法对这个bean进行填充属性
进行其他初始化操作。

描述一下bean的生命周期?

首先BeanFactory会通过反射的方法实例化bean对象。
然后调用populateBean()方法，填充bean的属性。
如果实现了Aware接口相关的方法，调用Aware接口的相关方法，依次完成对BeanName，BeanFactory和BeanClassLoader，ApplicationContext对象的属性设置。
如果实现了BeanPostProcessor，就调用BeanPostProcessor的前置增强方法。
调用Initmethod()方法，如果实现了==initializingBean()==方法或init_method属性中声明了初始化方法，则调用该方法afterPropertiesSet()。
BeanPostProcessor的后置增强方法。
获得完整的Bean对象，可以通过getBean方式获得该对象。
最后销毁，如果该对象实现==DisposableBean()==方法，先调用这个方法，然后调用destory()方法。

Spring是如何解决循环依赖的问题的?

三级缓存，提前暴露对象，aop
什么是循环依赖:
总:

bean的创建过程分为实例化和初始化两个部分
1. 先创建A对象，实例化A对象，此时A对象的B属性为空
2. 对A对象的属性进行注入，但是没有找到B对象，因此去创建B对象
3. 实例化B对象，此时B对象的A属性为空
4. 填充B对象的A属性时，依旧找不到A对象，尝试去创建A对象，由此导致的循环创建对象的过程。

分:

解决循环依赖问题的关键点在于A对象虽然没有创建完成，但是已经被实例化了的半成品。我们已经拥有了该对象的引用，可以在后续的操作中给他赋值，相当于提前暴露了A对象的引用，解决循环依赖的关键是实例化和初始化分开操作。因此对于构造函数初始化的循环引用是无法避免的
当所有的对象都完成实例化和初始化操作后，容器中的对象会有两种状态，已经实例化但是未完成初始化的状态，和完全初始化状态。因此使用了两种不同的容器进行存储，就是一级缓存和二级缓存。如果一级缓存有了，就不会在二级缓存中出现，三级缓存的查询顺序是一级、二级和三级。一级缓存中存储的是完整对象，二级缓存存储的是非完整对象。
三级缓存中value存储的ObjectFactory，存储的是lambda表达式，三级缓存主要解决的是如果这个过程存在aop操作，则会需要一个普通对象，然后通过代理生成新的代理对象。在IOC容器中是不允许同时出现两个相同的对象的，当一个对象需要被代理的时候，需要使用代理对象覆盖掉原来的对象。
在实际调用的过程中，是没有办法判断对象什么时候被调用，所以当某个对象被调用时，有先判断这个对象是否需要被代理，类似于一种回调机制。因此当传入lambda表达式式，可以通过lambda来执行代理对象覆盖原对象的操作。

缓存放置时间和删除时间

三级缓存: createBeanInstance之后: addSingletonFactory
二级缓存:第一次从三级缓存确定对象是代理对象还是普通对象的时候,同时删除三级缓存getSingleton
-级缓存:生成完整对象之后放到一级缓存，删除二三级缓存:addSingletonFactory

BeanFactory与FactoryBean有什么区别

这两个都是用来创建对象的。
BeanFactory是整个SpringIOC的管理者，所有IOC中管理的bean都继承自BeanFactory。如果继承了BeanFactory就需要按照Spring要求的生命周期进行实现，
FactoryBean是一个bean，被BeanFactory管理。是一个实现了工厂模式的bean，我们可以通过FactoryBean创建自己需要的bean，同时被SpringIOC管理。FactoryBean方法可以让我们获得我们需要的对象等。

SpringAOP

SpringAOP的功能有哪些：事务，权限验证，异常处理，log记录
Aspect：切面 = join point + pointcut + advice；
joinpoint:连接点，需要被增强的每一个方法
pointcut:切点，一堆连接点的集合，指出需要被增强的范围。
advice:通知，包括增强逻辑和增强位置(Before,AfterReturning ,AfterThrowing,Around)。
weaving:织入，实现增强的过程(静态增强，动态增强)
TargetObject：需要被代理的对象
proxy：代理以后生成的代理对象
下图所示
@Aspect 表示这是一个切面，切面也是一个bean，因此用@component装填到IOC容器中。
@advice表示的方法内部表示的是增强逻辑，@before和@After表示的是增强时机。
@pointcut表示要增强的范围，execution(~)的内容
在(~)中的每一个方法就是joincut。
代码可以插入的位置，(advice能够插入的位置):
1. before:前面
2. after:后面
3. around:环绕 = before + after
4. afterReturning:当切入的方法成功返回时
5. afterThrowing:当切入的方法抛出异常时
当有多个通知时，需要有一套责任链来排序advice执行的顺序。
Spring中每一个advice都要实现MethodInterceptor接口，CGLIB动态代理中CallBack()接口需要传入的内容。

SpringAop的执行过程

SpringAop的执行链：有点难理解自己看视频吧

为什么每次都回到链上，可以让我们可以在当前的链结构中拿到最新的排好序的下一个结构的数据

Spring中用到的设计模式?

单例模式(节省内存)：在IOC容器中生成的bean默认都是单例模式的。
抽象工厂、简单工厂(实现创建对象和使用对象相分离):BeanFactory是抽象工厂，Spring中所有的Bean都实现了BeanFactory。简单工厂主要是FactoryBean，这也是一个具有工厂模式的Bean，也是实现了BeaFactory，其可以通过这个方法来制造我们相想要的bean。
模板方法(模板方法可以):Spring中的 jdbcTemplate中就是使用了模板方法
动态代理:SpringAOP大量使用了动态代理，来对切点，切面，连接点进行通知操作。通过JDK动态代理和CGLIB两种方式实行了动态代理
回调模式:在CGLIB中Enchancer.create()中就需要传递CallBack方法，在AOP中一般是通过继承了MethodeInterceptor，来实现回调。
适配器模式:在SpringMVC中用的很多，通过在DispatchServlet得到Handler调用链以后，会调用HandlerAdaptor，进行适配操作，再调用相关的controller，来获取modelAndView。

在这里插入图片描述

Spring的AOP的底层实现原理?

AOP是面向切面编程，它主要使用在增加打印日志，进行进行事务处理等功能。是通过动态地理的方式实现的。
在IOC容器中，当bean被实例化和初始化之后，会询问是否实现了BeanPostProcessor，如果实现了，就会调用其后置增强方法，Spring就是在这个方法中实现了AOP。
1. 当Bean对象创建过程中会获取bean相关的，切面，切点，连接点，通知的时间和通知的内容，并将这个对象作为目标对象。
2. 然后会通过JDK或者CGLIB的方式进行动态代理，生成代理类。
3. 在执行到方法调用时，因为动态代理本身就是直接操作字节码文件的，会从字节码文件中找到DynamicAdvisoredInterceptor类中的Intercept()方法，从这个方法开始执行通知内容。
4. 如果有多个通知的话，还会根据定义好的通知生成拦截器链，按照拓扑排序的顺序进行方法增强。

在这里插入图片描述

Spring事务

在这里插入图片描述

Spring事务的三大基础

PlatformTransctionManager：(由持久层框架帮我们实现)，声明式事务还是编程式事务都是这个起了作用。
TransctionDefinition：定义了事务的5种状态.
TransctionStatus：

PlatformTransctionManager

定义了基本的事务处理的方法，包括获取事务的TransctionStatus
事务的提交和回滚。

public interface PlatformTransactionManager {
	TransactionStatus getTransaction(@Nullable TransactionDefinition definition);
	void commit(TransactionStatus status) throws TransactionException;
	void rollback(TransactionStatus status) throws TransactionException;
}

TransactionDefinition

传播性
隔离性
超时时间
是否只读
回滚规则

在这里插入图片描述

编程式事务

声明式事务

事务的传播性

除了第一个以外别的都是看内事务失败会不会影响到外事务，或者说外事务是否对内事务的失败进行了处理

Required(最多只有一个事务)

默认是Requred
内事务方法默认是一定在事务中执行
如果两个都是Requred 两个会并入一个事务中执行，会导致整体回滚或提交。
就算是在外事务中出现了bug，内事务依旧会回滚

Requires_New(多个事务并行)

Required(外) + Requires_New(内)
可能会同时存在多个事务
外bug 外回滚内有独立事务内不回滚
内bug看情况内bug无法处理抛异常给外则外回滚如果内异常处理好了则外不回滚

Nested(事务嵌套)

相当于外部事务的子事务，外部事务回滚内是要回滚的，Requires_New不同的是Requires_New是独立的事务，外回滚内是不需要回滚的
内bug看情况内bug无法处理抛异常给外则外回滚如果内异常处理好了则外不回滚

Supports(无所谓)

外有事务加入事务，没事务就非事务

Not_Supports(非事务)

外有事务挂起事务没事务就没事务

Mandatory(强制加入事务)

外有事务加入事务没有事务抛出异常

Never(强制非事务)

外有事务抛出异常没事务就没事务

事务回滚规则

默认是运行时异常会回滚，检查型异常是不会回滚的
运行时异常指的是1/0，检查型异常指的是IOException等以检查为主的异常。
可以通过roolBackFor来扩大异常回滚的范围或 notroolBackFor来缩小异常的回滚范围

只读事务(select)

开启只读事务，多个Sql会合并到一个事务中，多个sql获取相同的结果

事务仅在public上生效

同类中无事务方法调用有事务方法会失效(AOP)

仅仅会从外部动态代理生成的类中调用，自己内部是不会调用动态代理生成的对象的。

Spring的事务是如何回滚的?

总:

Spring事务是通过AOP的形式来实现的。Spring事务对AOP的事务通知进行了定制化，没有使用Aop的Advice，而是自己实现了MethodInterceptor，并调用invoke方法。
分:

首先实例化并初始化一个bean对象，获得事务相关的切点，切面，连接点等。
如果需要开启事务则，需要连接数据库，开启事务。
如果事务执行失败，会会通过completeTransactionAfterThrowing，调用doRollback()方法，具体也是通过数据库连接来实现数据库的回滚操作。
如果事务执行成功，会会通过completeTransactionAfterReturning，调用doCommit()方法，具体也是通过数据库连接来实现数据库的提交操作。
最后执行完毕后，清除相关事务信息，调用clearupTransactionInfo()清除事务信息。

在这里插入图片描述

谈一下spring事务传播?

在这里插入图片描述

Spring核心

在这里插入图片描述

Spring事务隔离级别

在这里插入图片描述

SpringMVC

两种定义方式，一个是继承类加@bean，但是这种方法一个类仅能定义一个controller，在SpringMVC中，在mapHandler中存储的对象名。
对于注解方法来说，一个controller可以直接定义在方法上，存储在HandlerMethod的是方法名。HandlerMethod
两个Handler解析器，HandlerMapping ： mapHandler 和 HandlerMethod。
四个controller适配器，分别处理实现Controller接口的，处理HttpServlet，处理HttpRequestHandler和@RequestingMapping的。
HandlerMapping 返回的是一个执行链。

SpringMVC的执行流程

在这里插入图片描述

SpringMVC的执行核心是DispatchServlet前端控制器，通过HandlerMapping去查找Handler，HandlerAdaptor的适配和viewResolver的解析三大步骤。

用户发送前端请求到DispatchServlet；
DispatchServlet收到请求后，发送请求到HandlerMapping处理器。
HandlerMapping处理后会生成执行链，返回给DispatchServlet。
DispatchServlet请求HandlerAdapter适配器。
HandlerAdapter适配器寻找到合适的Controller，对请求进行处理。
Controller会返回ModelAndView对象给HandlerAdapter
HandlerAdapter将ModelAndView对象DispatchServlet
DispatchServlet将得到的ModelAndView对象传给viewResolver，对ModelAndView进行解析。
viewResolver返回View对象给DispatchServlet
DispatchServlet处理View信息，并渲染视图。
传给前端展示，目前更多的是返回Json字符串给前端显示数据。

SpringBoot自动装配

SpringBoot解决了开发者需要大量配置文件的问题，虽然在使用注解的形式在一定程度上缓解了配置地狱的情况，但是需要配置的内容依旧很多。Spring Boot 通过约定大于配置的思想，减少配置。

在主启动类中有@SpringBootApplication，这个注解表明了这个类是Spring Boot的启动类，其中的@EnableAutoConfigration是实现自动装配的核心注解，其中的使用@import引入了AutoConfigurationImportSelector类，这个类是Spring Boot实现自动装配核心。
AutoConfigurationImportSelector中继承了selectImports()方法，这个方法用于获取所有符合条件的全限定类名，并加载到IOC容器中。
通过getAutoConfigurationEntry()方法，先把所有的META-INF/SpringFactories中以AutoConfigration为后缀的配置文件全部加载进来，然后根据@CondiOn注解来判断是否将该配置文件注入IOC容器中。
这样实现了SpringBoot自动装配