Spring面试题

答题技巧

总：当前问题回答的是哪些具体的点
分：以1,2,3,4,5的方式分析接取描述相关的知识点，如果有哪些点不清楚，直接忽略过去突出一些技术名词（核心概念，接口，类，关键方法）

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

• 总：
• 控制反转：理论思想，原来的对象是由使用者来进行控制，有了Spring之后，可以把整个对象交给Spring来帮我们进行管理
• DI：依赖注入，把对应的属性的值注入到具体的对象中，@Autowired，populateBean 完成属性值的注入
• 容器：存储对象，使用map结构来存储，在spring中一般存在三级缓存，singletonObject存放完整的bean对象，整个bean的生命周期，从创建到使用到销毁的过程全部都是由容器管理的（bean的生命周期）
• 分：
  1. 一般聊ioc容器的时候要涉及到容器的创建过程（beanFactory，DefaultListableBeanFactory）,向bean工厂中设置一些参数（BeanPostProcessor, Aware接口的子类）等等
  2. 加载解析bean对象，准备要创建的bean对象的定义对象 beanDefinition（XML或注解的解析过程）
  3. beanFactoryPostProcessor 的处理，此处是扩展点，PlaceHolderConfigurSupport，ConfigurationClassPostProcessor
  4. BeanPostProcessor 的注册功能，方便后续对bean对象完成具体的扩展功能
  5. 通过反射的方式将 beanDefinition 对象实例化成具体的bean对象
  6. bean对象的初始化过程（填充属性，调用 aware 接口实现类方法，调用 BeanPostProcessor 的前置处理方法，调用 init-method 方法，调用 BeanPostProcessor 的后置处理方法）
  7. 生成完整的 bean 对象，通过 getBean 方法可以直接获取
  8. 销毁过程

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

底层实现：工作原理，过程，数据结构，流程，设计模式，设计思想
你对它的理解和你了解过的实现过程
反射，工厂，设计模式（会的说，不会的不说），关键的几个方法
createBeanFactory, getBean, doGetBean, doCreateBean, createBeanInstance(getDeclaredConstructor()), populateBean, initializingBean

1. 先通过 createBeanFactory 创建一个Bean工厂（DefaultListableBeanFactory）
2. 开始循环创建对象，因为容器中的bean默认都是单例的，所以优先通过getBean，doGetBean从容器中查找
3. 找不到的话通过 createBean（doCreateBean）方法，以反射的方式创建对象，一般情况下使用的是无参的构造方法（getDeclaredConstructor，newInstance）
4. 进行对象的属性填充 populateBean
5. 进行其他的初始化操作 initializingBean

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

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

1. 实例化bean：反射的方式生成对象
2. 填充bean的属性：populateBean()，循环依赖的问题（三级缓存）
3. 调用aware接口的方法：invokeAwareMethod（完成BeanName，BeanFactory，BeanClassLoader对象的属性设置）
4. 调用 BeanPostProcessor 中的前置处理方法：使用比较多的有（ApplicationContextPostProcessor,设置ApplicationContext, Environment, ResourceLoader, EmbeddValueResolver等对象）
5. 调用initmethod()方法：invokeInitmethod(), 判断是否实现了 initializingBean 接口，如果有，调用 afterPropertiesSet 方法，没有就不调用
6. 调用BeanPostProcessor的后置方法：Spring的aop就是在此处实现的，AbstractAutoProxyCreator
7. 获取到完成的对象，可以通过getBean的方式来进行对象的获取
8. 销毁流程：
   1. 判断是否实现了 DispoableBean 接口
   2. 调用 destroyMethod() 方法

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

三级缓存，提前暴露对象，aop
总：什么是循环依赖问题，A依赖B，B依赖A
分：先说明bean的创建过程：实例化、初始化（填充属性）
1. 先创建A对象，实例化A对象，此时A对象中的b属性为空，填充属性 B
2. 从容器中查找B对象，如果找到了，直接赋值，找不到且不存在循环依赖问题直接创建B对象
3. 实例化B对象，此时B对象中的a属性为空，填充属性a
4. 从容器中查找 a 对象，找不到则经过三级缓存获取

• 形成闭环的原因：
  • 此时，如果仔细琢磨的话，会发现A对象是存在的，只不过此时的A对象不是一个完整的状态，只完成了实例化但是为完成初始化，如果在程序调用过程中，拥有某个对象的引用，是可以在后期给它完成赋值操作，可以优先把非完整状态的对象优先赋值，等待后续操作来完成赋值，相当于提前暴露了某个不完整对象的引用，所以解决问题的核心在于 实例化 和初始化 分开操作，这也是循环依赖问题的关键。
  • 当所有的对象后完成实例化和初始化操作之后，还要把完整对象放到容器中，此时在容器中存在的对象的几个状态：完成实例化但未完成初始化, 完整状态，因为都在容器中，所以要使用不同的map结构来进行存储，此时就有了 一级缓存（存放完整对象） 和 二级缓存（存放完成实例化但未完成初始化）,如果一级缓存中有了，那么二级缓存中就不会存在同名的对象，因为它们的查找顺序是1,2,3这样的方式。
  • 为什么需要三级缓存？三级缓存的value类型是 ObjectFactory，一个函数式接口，存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个。
  • 如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象？要
  • 普通对象和代理对象是不能同时出现在容器中，因此当一个对象需要被代理的时候，就要还是用代理对象覆盖掉之前的普通对象，在实际的调用过程中，是没有办法确定什么时候对象调用被使用，所以就要求当某个对象被调用的时候，优先判断此对象是否需要被代理，类似于一种回调机制，此时传入Lambda表达式的时候，可以通过Lambda表达式来执行对象的覆盖过程，getEarlyBeanReference()
  • 因此，所有的bean对象在创建的时候都要优先放入到三级缓存中，在后续使用过程中，如果需要被代理则返回代理对象，如果不需要被代理，则直接返回普通对象

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

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

5. BeanFactory 与 FactoryBean有什么区别？

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

• isSingleton：是否是单例对象
• getObjectType：获取返回对象的类型
• getObject：自定义创建对象的过程（new，反射，动态代理）

6. Spring中的设计模式?

单例模式：bean默认都是单例的
原型模式：指定作用域为prototype
工厂模式：BeanFactory
模板方法：postProcessBeanFactory，onRefresh，iniPropertyValue
策略模式：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的事务是由aop来实现的,首先要生成具体的代理对象，然后按照aop的整套流程来执行具体的操作逻辑，正常情况下要通过通知来完成核心功能，但是事务不是通过通知来实现的，而是通过一个 TransactionInterceptor 来实现的，然后调用 invoke 来实现具体的逻辑
  • 分：
    1. 先做准备工作，解析各个方法上事务相关的属性，根据具体的属性来判断是否开始新事务
    2. 当需要开启的时候，获取数据库连接，关闭自动提交功能，开启事务
    3. 执行具体的sql逻辑操作
    4. 在操作过程中，如果执行失败了，那么通过completeTransactionAfterThrowing 看来完成事务的回滚操作，回滚的具体逻辑是通过 doRollback 方法来实现的，实现的首也是要先获取连接对象，通过连接对象来回滚
    5. 如果执行过程中没有任何的意外情况发生，那么通过 commitTransactionAfterReturning 来完成事务的提交操作，提交的具体逻辑是通过 doCommit 方法来实现的，实现的时候也是要获取连接，通过连接对象
    6. 当事务执行完毕之后需要清楚相关的事务信息 cleanupTransactionInfo

9. 谈一下spring的事务传播？

• 传播特性有几种？7种
  Required,Required_new,nested,Support,Not_Support,Never,Mandatory
  某一个事务嵌套另一个事务的时候怎么办？
  A方法调用B方法，A、B方法都有事务，并且传播特性不同，那么A如果有异常，B怎么办，B如果有异常，A怎么办?

• 总：事务的传播特性指的是不同方法的乔涛调用过程中，事务应该如何处理，使用同一个事务还是不同的事务，当出现异常的时候会回滚还是提交，两个方法之间的相关影响，在日常工作中，使用比较多的是 Required，Required_new，nested

• 分：

  1. 先说事务的不同分类，可以分为三类：支持当前事务，不支持当前事务，嵌套事务
  2. 如果外层方法是 Required，内存方法是 Required，Required_new，nested
  3. 如果外层方法是 Required_new，内存方法是 Required，Required_new，nested
  4. 如果外层方法是 nested，内存方法是 Required，Required_new，nested