Spring的理解

• Spring 是一个基本的框架，同时他给我们提供了一个bean的容器，用来方便装载具体的bean对象，我们之前在使用对象的时候是自己new出来的，而现在我们只需要告诉容器有哪些对象，它可以帮我们创建好并且管理bean的生命周期。
• Spring 是一系列Spring全家桶的基石，例如SpringBoot、Spring MVC、Spring Cloud 等技术栈 都是在Spring的基础上扩展而来的。
• Spring 还有两大核心特点IOC和AOP
  • IOC : 表示的是控制反转。也就是说以前我们自己来new对象现在由容器来帮我们创建对象控制管理对象。
  • AOP：表示的是面向切面。就是一些用于跟业务逻辑无关的代码我们可以通过AOP的方式来进行实现。比如日志、权限控制、事务管理这些相关功能都是通过AOP来实现的。也就是具体的业务逻辑代码该怎么写就怎么写，但是需要扩展的时候可以通过AOP的消息通知，在具体方法里的前置后置环绕异常等不同的环节里面添加具体跟业务无关的代码，完成我们具体的功能。

IOC

读取 xml注入 配置过程

解析注解注入过程

• xml 、注解 配置就是bean的定义信息 通过 BeanDefinitionReader接口 进行对信息的约束和规范 读取成BeanDefinition对象 存储的是map形式

高频 ：IOC 理解 及原理 底层实现

总分方式回答：

• 总:
  • 控制反转：理论思想，原来的对象是由使用者来进行控制，有了Spring之后，可以把整个对象交给Spring来帮我们进行管理.
  • DI：依赖注入，把对应的属性的值注入到具体的对象中，@Autowired，populateBean（属性赋值）方法完成属性值的注入.
  • 容器：存储对象，使用Map结构来存储，在Spring中一般存在三级缓存（bean初始化过程属性赋值时），singletonObjects（一级缓存 -> Map对象） 存放完整的Bean对象，整个Bean的生命周期，从创建到使用到销毁的过程全部都是由容器来管理（Bean的生命周期）.
• 分：
  • 一般聊Ioc容器的时候要涉及到容器的创建过程（beanFactory，DefaultListableBeanFactory），向Bean工厂中设置这些参数（BeanPOstProcessor，Aware接口的子类）等等属性。
  • 加载解析Bean对象，准备要创建的Bean对象的定义对象BeanDefinition，（XML或者注解的解析过程）
  • BeanFactoryPostProcessor的处理，此处是扩展点，PlaceHolderConfigurSupport，ConfigurationClassPostProcessor
  • BeanPostProcessor的注册功能，方便后续对Bean对象完成具体的扩展功能。
  • 通过反射的方式将BeanDefinition对象实例化成具体的Bean对象。
  • Bean对象的初始化过程（填充属性，调用Aware子类的方法，调用BeanPostProcessor前置处理方法，调用init-method方法，调用BeanPostProcessor的后置处理方法）
  • 生成完整的Bean对象，通过getBean（）方法可以直接获取
  • 销毁过程
  • 具体细节我记不太清了，但是Spring中的Bean都是通过反射的方式生成的，同时其中包含了很多的扩展点，比如最常用的对BeanFactory的扩展，对Bean的扩展（对占位符的处理），除此之外，Ioc中最核心的就是填充具体Bean的属性，和生命周期了（背一下）。

IoC的底层实现

对Ioc的理解和了解过的实现过程

• 底层实现：反射、工厂、设计模式（会的说，不会的不说）,关键的几个方法 （Ioc底层实现过程中的重要方法 ->（createBeanFactory、getBean、doGetBean、createBean、doCreateBean、createBeanInstance（getDeclaredConstructor,newInstance）,populateBean,initializingBean）实例化+初始化（属性填充）
  1、先通过createBeanFactory创建出一个Bean工厂（DefaultListableBeanFactory）
  2、开始循环创建对象，因为容器中的Bean默认都是单例的，所以优先通过getBean、doGetBean从容器中查找，找不到的话开始第三步
  3、通过createBean、doCreateBean方法，以反射的方式创建对象，一般情况下使用的无参的构造方法（getDeclaredConstructor，newInstance）
  4、进行对象的属性填充populateBean
  5、进行其他的初始化操作（initalizingBean）

高频：Bean的生命周期（图解）

生命周期：bean在创建到使用到销毁的过程
1、实例化*：在堆中申请空间，对象的属性值一般是默认值，反射创建对象的过程，调用createBeanInstance方法

2、初始化： 首先进行自定义属性赋值，调用了populateBean方法，通过set方法完成赋值操作

3、初始化：容器对象属性赋值。aware：接口（没有定义任何方法）作用是 做一个标记。 判断是否实现aware接口来进行赋值

在invokeAwareMethods 进行赋值

4、执行前置处理方法BeanPostProcessor


5、执行初始化方法：invokeInitmethods

6、使用Bean 、 销毁Bean

高频：Bean的生命周期（文解）

1、实例化Bean：反射的方式生成对象
2、填充Bena的属性：populateBean（）（循环依赖问题在此时产生（你中有我，我中有你）-> 三级缓存、提前暴露对象引用）
3、调用Aware接口相关的方法：InvokeAwareMethod（完成BeanName，BeanFaactory，BeanClassLoader对象的属性设置）
4、调用BeanPostProcessor中的前置处理方法：使用比较多的有（ApplicationContextPostProcessor，设置ApplicationContext，Environment，ResourceLoader，EmbeddValueResolver等对象）
**5、调用init-method方法：invokeInitmethod(),**判断是否实现了initializingBean接口，如果有，调用afterPropertiesSet（）方法，没有就不调用。
6、调用BeanPostProcessor的后置处理方法：Spring的Aop就是在此处实现的，AbstractAutoProxyCreator（动态代理），注册Destuction相关的回调接口
7、获取到完整的对象（getBean）
8、销毁流程 1、判断是否实现了 DispoableBean接口 。2、调用 destoryMethod（） 方法。

扩展知识

高频：BeanFactory 和 FactoryBean 的区别

相同点

• 都是用来创建Bean的。

不同点

• BeanFactory：创建Bean对象时，必须要遵循严格的Bean生命周期流程，（复杂）
• FactoryBean：简单的自定义某个对象的创建，同时创建完成的对象交给Spring来管理。
• FactoryBean有三个方法如下：
• isSingleton：是否是单例对象
• getObjectType：获取返回对象的类型
• getObject：自定义创建对象的过程（new、反射、动态代理）

高频：循环依赖-----三级缓存 （图解）

• 一级缓存：实例化 + 初始化（属性赋值 完成） === 成品（完整）对象
• 二级缓存：实例化 + 初始化（属性赋值未完成） === 半成品对象 （当判断需要代理对象时 —> 执行getObject（）方法 ----> 生成代理对象覆盖原对象）
• 三级缓存：实例化之后 === lambda表达式 不知道是否需要代理所以存放表达式，
  
  
  
  
  

高频：循环依赖-----三级缓存 （文解）

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

• 分：先说明Bean的创建过程：实例化、初始化（填充属性）
  1、先创建A对象，实例化A对象，此时A对象中的b属性为空，填充属性b，
  2、从容器中查询B对象，如果找到了直接赋值（那就不存在循环依赖问题，不通），找不到直接创建B对象
  3、实例化B对象，此时B对象中的a属性为空，填充属性a。
  4、从容器中查询A对象，找不到，直接创建 -------> 形成闭环

• 此时，如果仔细琢磨的话，会发现A对象是存在的，只不过此时的A对象不是一个完整的状态，只完成了实例化但是未完成初始化。

• 如果在程序调用过程中，拥有了某个对象的引用，能否在后期对他进行赋值（可以）。

• 可以优先把非完整状态的对象优先赋值，等待后续操作来完成赋值，相当于：提前暴露了某个不完整对象的引用

• 所有解决循环依赖问题的核心是：实例化和初始化分开操作。

• 当所有的对象都完成实例化和初始化操作之后，还要把完整对象放到容器中，此时容器中存在对象的几个状态？ （2个），①完成实例化但未完成初始化，②完整对象（完成实例化和初始化）。

• 因为都在容器中，所以要使用不同的Map结构来进行存储，此时就有了一级缓存和二级缓存。

• 如果一级缓存中有了，那么二级缓存中就不会存在同名的对象，因为他们（map）的查找顺序是1、2、3这样的方式来查找的。

• 一级缓存中存放的是完整对象，二级缓存中存放的是非完整对象。

为什么需要三级缓存

• 三级缓存的value类型是ObjectFactory,是一个函数式接口，存在的意义是保证在整个容器的运行过程中同名的Bean对象只能有一个
• 如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象？（要）.
• 普通对象和代理对象是不能出现在容器中的，因此当一个对象需要被代理的时候，就要使用代理对象覆盖掉之前的普通对象，在实际调用过程中，没有办法确定什么时候对象被使用，所以就要求当某个对象被调用时，优先判断此对象是否需要被代理，类似于一种回调机制的实现，因此传入lambda表达式时，可以通过lambda表达式来执行对象的覆盖过程，getEarlyBeanReference().
• 因此，所有的Bean对象在创建的时候都要优先放到三级缓存中，在后续的使用过程中，如果需要被代理则返回代理对象，如果不需要被dialing，则直接返回普通对象。

缓存存放时间和删除时间

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

Spring中用到的设计模式

高频：Spring 中aop的底层实现及原理

底层：动态代理

• Aop 是 Ioc 的一个扩展功能。先有的Ioc，在有的Aop，只是在Ioc的整个流程中新增的一个扩展点而已：BeanPostProcessor（增强器）
  总：

  • Aop概念、应用场景（事务、日志）、动态代理

  分：

  • bean的创建过程中有一个步骤可以对Bean进行扩展实现，Aop本身就是一个扩展功能，所以在BeanPostProcessor的后置处理方法中来进行实现。
  • 1、代理对象的创建过程（advice、切面、切点）
  • 2、通过JDK或者Cglib的方式来生成代理对象
  • 3、在执行方法调用的时候，会调用到生成的字节码文件中，直接会找到**DynamicAdvisoredInterceptor类中的intercept方法，**从此方法开始执行。
  • 4、根据之前定义好的通过来生成拦截器链。
  • 5、从拦截器链中依次获取每一个通知开始进行执行，在执行过程中，为了方便找到下一个通知是哪个，会有一个InvocationInterceptor的对象，找的时候是从-1的位置依次开始查找并执行的

Spring 事务是如何回滚的

高频：Spring 事务的传播特性

传播特性几种？ 七种
Required，Requires_new，nested，Support，Not_Support，Never，Mandatory

某个事务嵌套另一个事务该怎么办？

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

• 事务的传播特性指的是不同方法的嵌套调用过程

分：

• 先说事务的不同分类，可以分为三类：支持当前事务，不支持当前事务，嵌套事务
• 如果外层方法是required，内层方法是，required，requires_new，nested
• 如果外层方法是requires_new，内层方法是，required，requires_new，nested
• 如果外层方法是nested，内层方法是，required，requires_new，nested

核心处理逻辑

• 判断内外方法是否是同一个事务
  • 是：异常统一在外层方法处理
  • 不是：内层方法有可能影响到外层方法，但是外层方法是不会影响内层方法的
    （大致可以这么理解，但是有个别情况不同，nested）

1、required 和 nested 回滚的区别

• 在回答两种方式区别的时候，最大的问题在于保存点的设置
• 在外层方法对内层方法的异常情况在于捕获的时候区别都不同，使用required的时候，汇报Transaction rolled back because it has been marked as rollback-only 信息，
• 因为内部异常了，设置了回滚标记，外部捕获之后，要进行事务的提交
• 意味着要回滚，所以会报异常。而nested不会发生这种情况，因为在回滚的时候把回滚标记清除了，外部捕获异常后去提交，没发现回滚标记，就可以正常提交了。

2、required-new 和 required 区别

• 这两种方式产生的效果是一样的，但是required_new会有新的连接生成，而nested使用的是当前事务的链接，而且nested还可以回滚到保存点
• required_new 每次都是一个新的事务的回滚，但nested其实是一个事务，外层事务可以控制内层事务的回滚，内层就算是没有异常，外层出现异常，也可以全部回滚。