跳到主要内容

Spring

1. Spring IOC​

总​

  • 控制反转: 理论思想，原来的对象由使用者进行控制，有了 Spring 之后，可以把整个对象交给 Spring 进行管理
    DI: 依赖注入，把对应的属性的值注入到具体对象中，@Autowired、populateBean完成属性值的注入
  • 容器: 存储对象，使用 map 结构来存储，在 Spring 中一般存在三级缓存，singletonObjects中存放完整的bean对象（singletonObjects的设计模式）
    整个bean的生命周期，从创建到使用到销毁的过程全都由容器管理（bean的生命周期）

分​

  1. 容器的创建过程（beanFactory、DefaultListableBeanFactory），向 bean 工厂中设置一些参数（beanPostProcessor，Aware 接口的子类）
  2. 加载解析 bean 对象，准备要创建的 bean 对象的定义对象 BeanDefinition（xml 或者注解的解析过程）
  3. beanFactoryPostProcessor 的处理，扩展点，PlaceHolderConfigureSupport、ConfigurationClassPostProcessor
  4. BeanPostProcessor 的注册功能，方便后续对 bean 对象完成具体的扩展功能
  5. 通过反射将 BeadDefinition 对象实例化成具体的 bean 对象
  6. bean 对象的初始化过程（填充属性，调用 aware 子类的方法，调用 BeanPostProcessor 前置处理方法，调用 init-method 方法，调用 BeanPostProcessor 的后置处理方法）
  7. 生成完整的 bean 对象，通过 getBean 方法直接获取
  8. 销毁过程
  • Spring 中的 bean 都是通过反射的方式生成的，同时其中包含很多扩展点，比如最常用的对 BeanFactory 的扩展，对 bean 的扩展（对占位符的处理），IOC 中最核心的也就是填充具体 bean 的属性和生命周期（背）

2. IOC的底层实现​

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

3. bean的生命周期​

  • 背图

    1. 实例化 bean: 反射的方式生成对象
    2. 填充 bean 的属性: populateBean()，循环依赖的问题（三级缓存）
    3. 调用 aware 接口相关的方法: invokeAwareMethod（完成BeanName、BeanFactory、BeanClassLoader 对象的属性设置）
    4. 调用 BeanPostProcessor 中的前置处理方法: 使用比较多的（ApplicationContextPostProcessor、设置ApplicationContext、Environment、ResourceLoader、EmbedValueResolver等对象）
    5. 调用 initMethod 方法: invokeInitMethod()，判断是否实现了 initializingBean 接口，如果有，调用 afterPropertiesSet 方法，没有就不调用
    6. 调用 BeanPostProcessor 的后置处理方法： Spring 的 AOP 就在此处实现，AbstractAutoProxyCreator
      注册 Destruction 相关的回调接口: 钩子函数
    7. 获取到完整的对象，可以通过getBean的方式来进行对象的获取
    8. 销毁流程: 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对象不是一个完整的状态，只完成了实例化但未完成初始化，如果在程序调用过程中，拥有了某个对象的引用，能否在后期给他完成赋值操作，可以优先把非完整状态的对象优先赋值，等待后续来完成赋值，相当于提前暴露了某个不完整对象的引用，所以解决问题的核心在于实例化和初始化分开操作，这也是解决循环依赖问题的关键，当所有的对象都完成实例化和初始化操作后，还要把完整对象放到容器中，此时在容器中存在对象的几个状态: 完成实例化但未完成初始化状态、完整状态，因为都在容器中，要使用不同的map结构来进行存储，此时就有了一级缓存和二级缓存，如果一级缓存有了，二级缓存中就不会存在同名对象，查找顺序是1->2->3的方式，一级缓存中放的完整对象，二级缓存中放的是非完整对象
  • 为什么需要三级缓存
    三级缓存的 value 类型是 ObjectFactory,是一个函数式接口，存在的意义是保证在整个容器的运行过程中，同名的 bean 对象只能有一个
    如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象？ 要。 普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理时，就要使用代理对象覆盖之前的普通对象，在实例的调用过程中，是没有办法确定什么时候对象被使用，因此要求当某个对象被调用的时候，优先判断此对象是否需要被代理，类似于一种回调机制的实现，因此传入 lambda 表达式的时候，可以通过 lambda 表达式来执行对象的覆盖过程，getEarlyBeanReference
    因此所有的 bean 对象在创建的时候都要优先放到三级缓存中，在后续的使用过程中，如果需要被代理，则返回代理对象，如果不需要被代理，则直接返回普通对象
  • 缓存的放置时间和删除时间
    三级缓存: createBeanInstance 之后，addSingletonFactory
    二级缓存: 第一次从三级缓存确定对象是代理对象还是普通对象的时候，同时删除三级缓存，getSingleton
    一级缓存: 生成完整对象后放到一级缓存，删除二三级缓存，addSingleton

5. Bean Factory 与 FactoryBean 的区别​

  • 相同点: 都是用来创建bean对象的
  • 不同点: 使用 BeanFactory 创建对象的时候必须遵循严格的生命周期流程，过于复杂，如果想要简单的自定义某个对象的创建，同时创建完成的对象想交给 Spring 管理，就需要实现 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，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

  • 更加细致，需要知道 TransactionInfo、TransactionStatus

9. Spring 的事务传播​

  • 传播特性有几种: 7种
    Required、Requires_new、nested、Support、Not_Support、Never、Mandatory

  • 某一个事务嵌套另一个事务怎么办
    A方法调用B方法，AB方法都有事务，并且传播特性不同，那么如果A有异常，B怎么办，B如果有异常，A怎么办

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

  • 分:

    1. 先说事务的不同分类，可以分为三类: 支持当前事务、不支持当前事务、嵌套事务
    2. 外层方法是 required，内层方法是 required、Require_new、nested
    3. 外层方法是 Require_new，内层方法是 required、Require_new、nested
    4. 外层方法是 nested，内层方法是 required、Require_new、nested

  • 核心处理逻辑:
    判断内外方法是否是同一个事务
    （大概可以这么理解，但是有个别情况不同，nested）

    • 是: 异常统一在外层方法处理
    • 不是: 内层方法有可能影响外层方法，但是外层方法不会影响内层方法