Spring 相关原理与实现

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

总：

控制反转：理论思想，原来的对象是由使用者来进行控制，有了spring以后，可以把整个对象交给spring来帮我们进行管理。
DI：依赖注入，把对应的属性的值注入到具体的对象中。@Autowired，polulateBean完成属性值的注入。

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

分：

• IOC容器的创建过程（beanFactory,DefaultListableBeanFactory）,像bean工厂中设置一些参数（beanPostProcess，Aware接口的子类）等等属性。
• 加载解析bean对象，准备要创建的bean对象的定义对象beanDefinition，（xml或者注解的解析过程）
• beanFactoryPostProcess的处理，此处是扩展点。例如，PlaceHolderConfigurSupport,ConfigurationClassPostProcessor就是完成了扩展。
• BeanPostProcess的注册功能，方便后续对bean对象完成具体的扩展功能。
• 通过反射的方式将BeanDefinition对象实例化成具体的bean对象
• bean对象的初始化过程（填充属性，调用aware子类的方法，调用BeanPostProcess前置处理方法，调用init-method方法，，调用BeanPostProcess后置处理方法）。
• 生成完整的bean对象，通过getBean()方法可以直接获取
• 销毁过程

突出一些技术名词（核心概念，接口，类，关键方法）。

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

底层实现：对他的理解和实现过程

反射，工厂，设计模式，关键的几个方法（createBeanFactory,getBean,doGetBean,creatBean,doCreatebean,createBeanInatance,populateBean，initializingBean）

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

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

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. 注册Destuction相关的回调接口。
8. 获取到完成的对象，可以通过getBean的方式来进行对象的获取。
9. 销毁流程：(1)判断是否实现了DisposableBean接口；(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对象不是一个完整的状态，只完成了实例化，没有完成初始化（b属性未赋值）。如果在程序调用的过程中拥有了某个对象的引用能否在后期完成赋值操作，能。可以优先把一个非完整状态的对象优先赋值，等待后续操作来完成对该属性的赋值，相当于提前暴露了某个不完整对象的引用。所以解决问题的核心在于实例化和初始化分开操作，这也是解决循环依赖问题的关键。
当所有的对象都完成实例化和初始化操作之后，还要把完整对象放到容器中，此时在容器中存在对象的两种状态：完成实例化但未完成初始化，完整状态。因为都在容器中，所以要使用不同的map结构来进行存储，此时就有了一级缓存和二级缓存。如果一级缓存中有了，则二级缓存中就不会存在同名的对象，因为他们的查找顺序是1，2，3这样的方式来查找的。

一级缓存：存放完整对象
二级缓存：非完整对象

为什么需要三级缓存？三级缓存的value类型是ObjectFactory，是一个函数式接口。存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个版本。 

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

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

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

三级缓存：createBeanInstance之后。addSingletonFactory()

二级缓存：第一次从三级缓存确定对象是代理对象还是普通对象的时候，同时删除三级缓存，getSingleton()。

一级缓存：生成完整对象之后放到一级缓存，删除二三级缓存addSingleton()。

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

都是用来创建bean对象的，当使用Bean Factory创建对象的是偶，必须要遵循严格的生命周期流程，太复杂了，如果想要简单的自定义某个对象的创建，同时创建完成时的对象交给spring管理，那么就需要实现FactoryBean接口了。
        isSingleton()：是否是单例对象
        getObjectType()：获取返回对象的类型
        getObject()：自定义创建对象的流程（new，反射，动态代理）

6.spring中用到的设计模式

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

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

工厂模式：BeanFactory

模板方法：postProcessBeanFactory，onRefresh，initPropertyValue

策略模式：XmlBeanDefinitionReader，PropertieBeanDefinitionReader

观察者模式：listener，event，multicast

适配器模式：Adapter，

代理模式：动态代理

委托者模式：delegate

7.spring的aop的底层实现原理

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

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

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

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

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

总：spring的事务是由AOP实现的，首先要生成具体的代理对象，然后按照AOP的整套流程来执行具体操作。正常情况下要通过通知来实现核心功能，但是事务不是通过通知来实现的，而是通过TransacionInterceptor来实现的，然后调用invoke方法来实现具体的逻辑。

分：

1. 先做准备工作，解析各个方法上事务相关的属性（比如隔离级别，传播特性等），根据具体的属性来判断是否开启新事务。
2. 当需要开启的时候，获取数据库连接，关闭自动提交功能，开启事物。
3. 执行具体的sql逻辑操作。
4. 在操作过程中，如果执行失败了，会通过completeTransactionAfterThrowing来完成事物的回滚操作，回滚的具体逻辑是通过doRollBack方法来实现的，实现的时候也是先获取连接对象，通过连接对象来回滚。
5. 如果执行过程中没有任何意外情况发生，那么通过commitTransactionAfterReturning来完成事务的提交操作，提交的具体逻辑是通过doCommit方法来提交的，实现的时候也是先获取连接对象，通过连接对象来进行提交。
6. 当事务执行完毕之后，需要清除相关的事务信息cleanupTransactionInfo

9.谈一下spring事务传播？

传播特性有几种？7种。

Required，Requires_new，nested，Support，Non_Support，Never，Mandatory

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

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

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

分：

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