Spring面试题持续更新

这些都是我在微信公众号上看到的一些很有质量的文章,于是乎,自己记录一遍供自己学习

Spring中使用了哪些设计模式

  1. 单例模式:Spring中的Bean 模式都是单例的。
  2. 工厂模式:工厂模式主要是通过BeanFactory和ApplicationContext来生产Bean对象的
  3. 代理模式:最常见的AOP的实现方式就是通过代理来实现的 , Spring主要是使用JDK动态代理 和 CGLIB代理.
  4. 模板方法模式: 主要是一些对数据库操作的类用到, 如JdbcTemplate, JpaTemplate, 因为查询数据库的建立连接, 执行查询, 关闭连接几个过程, 非常适用于模板方法.

对IOC 和 AOP的理解, 以及它们的实现原理

IOC叫做控制反转, 指的是通过Spring来管理对象的创建、配置和声明周期, 这样相当于把控制权交给Spring,不需要人工来管理对象之间复杂的依赖关系, 这样做的好处是解耦。在Spring里面, 主要提供了BeanFactory和ApplicationContext两种IOC容器,通过它们来实现对Bean的管理。

AOP叫做面向切面编程,它是一个编程范式,目的是提高代码的模块性。Spring AOP基于动态代理的方式实现,如果是实现了接口的话就会使用JDK动态代理, 反之则使用CGLIB代理。

Spring中AOP的应用主要体现在事务,日志,异常处理等方面,通过在代码的前后做一些增强处理,可以实现对业务逻辑的隔离,提高代码的模块化能力,同时也是解耦

Spring主要提供了Aspect切面、JoinPoint连接点,PointCut切入点、Advice等实现方式。

JDK动态代理 和 CGLIB代理有什么区别?

  1. JDK动态代理主要是针对类实现了某个接口,AOP则会使用JDK动态代理。它基于反射的机制实现,生成一个实现同样接口的一个代理类,然后通过重写方法的方式, 实现对代码的增强。
  2. 如果某个类没有实现接口, AOP则会使用CGLIB代理。它的底层是基于asm第三方框架,通过修改字节码生成一个子类,然后重写父类的方法, 实现对代码的增强。

Spring AOP 和AspectJ AOP 有什么区别?

  1. Spring AOP 基于动态代理实现, 属于运行时增强
  2. AspectJ AOP则属于编译时增强, 主要有三种方式:
    • 编译时植入:指的是增强的代码和源代码我们都有,直接使用AspectJ 编译器就行, 编译之后会生成一个新的类,它也会作为一个正常的Java类装载到JVM中。
    • 编译后植入:指的是代码已经被编译成class文件或者已经打包成jar包,这时候要增强的话,就是编译后植入,如依赖了第三方的类库, 又想对它进行增强, 则通过这种方法。
    • 加载时植入:指的是在JVM加载类的时候进行植入
  3. 总结:Spring AOP只能在运行时植入, 不需要单独编译, 性能相比AspectJ AOP编译植入的方式慢,而AspectJ只支持编译前后和类加载时植入,性能更好,功能更强。

FactoryBean 和FactoryFactory的区别

  1. BeanFactory是Bean的工厂,ApplicationContext的父类, IOC容器的核心, 负责生产和管理Bean对象
  2. FactoryBean是Bean,可以通过实现FactoryBean接口定制实例化Bean的逻辑,通过代理一个Bean对象,对方法前后做一些操作。

SpringBean的生命周期。

  1. 实例化:创建一个Bean对象。
  2. 填充属性: 为对象赋值
  3. 初始化
    1. 如果实现了xxxAware接口,通过不同类型的Aware接口拿到Spring容器的资源
    2. 如果实现了BeanPostProcessor接口,则会回调该接口的postProcessBeforeInitialization和postProcessAfterInitialization方法。
    3. 如果配置了init-method方法, 则会执行init-method配置的方法。
  4. 销毁
    1. 容器关闭后,如果Bean实现了DisposableBean接口,则会回调该接口的destroy方法
    2. 如果配置了destroy-method方法, 则会执行destroy-method配置的方法。

Spring是怎么解决循环依赖的?

首先, Spring解决循环依赖有两个前提条件:

  1. 不全是构造器方法的循环依赖
  2. 必须是单例

基于上面的问题,我们知道Bean的生命周期,本质上解决循环依赖的问题就是三级缓存, 通过三级缓存提前拿到为初始化的对象

第一级缓存:用来保存实例化、初始化都完成的对象。

第二级缓存:用来保存实例化完成, 但是未初始化完成的对象。

第三级缓存:用来保存一个对象工厂,提供一个匿名内部类,用于创建二级缓存中的对象

假设一个简单的循环依赖场景,A、B互相依赖。

A对象的创建过程:

  1. 创建对象A,实例化的时候把A对象工厂放入三级缓存

  1. A注入属性时,发现依赖B,转而去实例化B
  2. 同样创建对象B,注入属性时发现依赖A,一次从一级到三级缓存查询A,从三级缓存通过对象工厂拿到A,把A放入二级缓存,同时删除三级缓存中的A,此时,B已经实例化并且初始化完成,把B放入一级缓存。

  1. 接着继续创建A,顺利从一级缓存拿到实例化且初始化完成的B对象,A对象创建也完成,删除二级缓存中的A,同时把A放入一级缓存
  2. 最后,一级缓存中保存着实例化、初始化都完成的A、B对象

因此,由于把实例化和初始化的流程分开了,所以如果都是用构造器的话,就没法分离这个操作,所以都是构造器的话就无法解决循环依赖的问题了。

为什么要三级缓存?二级缓存不行吗?

不可以,主要是为了生成代理对象。

因为三级缓存中放的是生成具体对象的匿名内部类,他可以生成代理对象,也可以是普通的实例对象。

使用三级缓存主要是为了保证不管什么时候使用的都是一个对象。

假设只有二级缓存的情况,往二级缓存中放的显示一个普通的Bean对象,BeanPostProcessor去生成代理对象之后,覆盖掉二级缓存中的普通Bean对象,那么多线程环境下可能取到的对象就不一致了。

Spring事务传播机制有哪些?

  1. PROPAGATION_REQUIRED:如果没有当前事务,就创建一个新事务,如果当前存在事务,就加入该事务, 默认选择
  2. PROPAGATION_REQUIRES_NEW:创建新事务,无论当前存不存在事务,都创建新事务。
  3. PROPAGATION_NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则按REQUIRED属性执行。
  4. PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
  5. PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。
  6. PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。
  7. PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就以非事务执行。‘

SpringBoot的启动流程

  1. 准备环境,根据不同的环境创建不同的Environment
  2. 准备、加载上下文,为不同的环境选择不同的Spring Context,然后加载资源,配置Bean
  3. 初始化,这个阶段刷新Spring Context,启动应用
  4. 最后结束流程

img

posted @ 2020-12-07 16:17  无法手执玫瑰  阅读(150)  评论(0编辑  收藏  举报