2023JavaWeb面试问答_Spring

使用 Spring 框架的好处是什么?

轻量：Spring 是轻量的，基本的版本大约 2MB。

控制反转：Spring 通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。

面向切面的编程(AOP)：Spring 支持面向切面的编程，并且把应用业务逻辑和系统服务分开。

容器：Spring 包含并管理应用中对象的生命周期和配置。

MVC框架：Spring 的 Web 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。

事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。

异常处理：Spring 提供方便的 API 把具体技术相关的异常（比如由 JDBC，Hibernate or JDO 抛出的）转化为一致的 unchecked 异常

解释下什么是 AOP?

AOP（Aspect-Oriented Programming，面向方面编程），可以说是 OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。也就是说，OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如：安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在 OOP 设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而 AOP 技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP 代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP 把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，它们经常发生在核心关注点的多处，而各处都基本相似。比如：权限认证、日志、事务处理。AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

AOP 的代理有哪几种方式?

AOP 思想的实现一般都是基于代理模式 ，在 Java 中一般采用 JDK 动态代理模式，但是我们都知道，JDK 动态代理模式只能代理接口而不能代理类。因此，Spring AOP 会按照下面两种情况进行切换，因为 Spring AOP 同时支持 CGLIB、ASPECTJ、JDK 动态代理。

如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；

如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类。不过这个选择过程对开发者完全透明、开发者也无需关心。

怎么实现 JDK 动态代理?

JDK 动态代理最核心的一个接口和方法如下所示：

1. java.lang.reflect 包中的 InvocationHandler 接口：

public interface InvocationHandler { 
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; 
}

对于被代理的类的操作都会由该接口中的 invoke 方法实现，其中的参数的含义分别是：

proxy：被代理的类的实例；
method：调用被代理的类的方法；
args：该方法需要的参数。
使用方法首先是需要实现该接口，并且我们可以在 invoke 方法中调用被代理类的方法并获得返回值，自然也可以在调用该方法的前后去做一些额外的事情，从而实现动态代理。

2. java.lang.reflect 包中的 Proxy 类中的 newProxyInstance 方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

其中的参数含义如下：

loader：被代理的类的类加载器；
interfaces：被代理类的接口数组；

invocationHandler：调用处理器类的对象实例

该方法会返回一个被修改过的类的实例，从而可以自由的调用该实例的方法

AOP 的基本概念:切面、连接点、切入点等?

切面（Aspect）：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。

连接点（Joinpoint）：程序执行过程中的某一行为。

通知（Advice）：“切面”对于某个“连接点”所产生的动作。

切入点（Pointcut）：匹配连接点的断言，在 AOP 中通知和一个切入点表达式关联。

目标对象（Target Object）：被一个或者多个切面所通知的对象。

AOP 代理（AOP Proxy）：在 Spring AOP 中有两种代理方式，JDK 动态代理和 CGLIB 代理。

通知类型(Advice)型(Advice)有哪些?

前置通知（Before advice）：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext 中在 < aop:aspect > 里面使用 < aop:before > 元素进行声明；

后置通知（After advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext 中在 < aop:aspect > 里面使用 < aop:after > 元素进行声明。

返回后通知（After return advice ：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext 中在 < aop:aspect > 里面使用 << after-returning >> 元素进行声明。

环绕通知（Around advice）：包围一个连接点的通知，类似 Web 中 Servlet规范中的 Filter 的 doFilter 方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext 中在 < aop:aspect > 里面使用 < aop:around > 元素进行声明。

抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。ApplicationContext 中在 < aop:aspect > 里面使用 < aop:after-throwing > 元素进行声明。

谈谈你对 IOC 的理解?

IOC 是 Inversion of Control 的缩写，多数书籍翻译成“控制反转”。简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。IOC 理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦。如下图：

由于引进了中间位置的“第三方”，也就是 IOC 容器，使得 A、B、C、D 这 4 个对象没有了耦合关系，齿轮之间的传动全部依靠“第三方”了，全部对象的控制权全部上缴给“第三方”IOC 容器，所以，IOC 容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用，把系统中的所有对象粘合在一起发挥作用，如果没有这个“粘合剂”，对象与对象之间会彼此失去联系，这就是有人把 IOC 容器比喻成“粘合剂”的由来。

把上图中间的 IOC 容器拿掉，然后再来看看这套系统：

现在看到的画面，就是我们要实现整个系统所需要完成的全部内容。这时候，A、B、C、D 这 4 个对象之间已经没有了耦合关系，彼此毫无联系，这样的话，当你在实现 A 的时候，根本无须再去考虑 B、C 和 D了，对象之间的依赖关系已经降低到了最低程度。所以，如果真能实现 IOC 容器，对于系统开发而言，这将是一件多么美好的事情，参与开发的每一成员只要实现自己的类就可以了，跟别人没有任何关系！

我们再来看看，控制反转(IOC)到底为什么要起这么个名字？我们来对比一下：

软件系统在没有引入 IOC 容器之前，对象 A 依赖于对象 B，那么对象 A 在初始化或者运行到某一点的时候，自己必须主动去创建对象 B 或者使用已经创建的对象 B。无论是创建还是使用对象 B，控制权都在自己手上。

软件系统在引入 IOC 容器之后，这种情形就完全改变了，由于 IOC 容器的加入，对象 A 与对象 B 之间失去了直接联系，所以，当对象 A 运行到需要对象 B 的时候，IOC 容器会主动创建一个对象 B 注入到对象 A 需要的地方。

通过前后的对比，我们不难看出来：对象 A 获得依赖对象 B 的过程，由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。

Bean 的生命周期?

在传统的 Java 应用中，bean 的生命周期很简单，使用 Java 关键字 new 进行 Bean 的实例化，然后该 Bean 就能够使用了。一旦 Bean 不再被使用，则由 Java 自动进行垃圾回收。

相比之下，Spring 管理 Bean 的生命周期就复杂多了，正确理解 Bean 的生命周期非常重要，因为 Spring 对 Bean 的管理可扩展性非常强，下面展示了一个 Bean 的构造过程：

Spring 启动，查找并加载需要被 Spring 管理的 Bean，进行 Bean 的实例化；

Bean 实例化后，对 Bean 的引入和值注入到 Bean 的属性中；

如果 Bean 实现了 BeanNameAware 接口的话，Spring 将 Bean 的 Id 传递给 setBeanName() 方法；

如果 Bean 实现了 BeanFactoryAware 接口的话，Spring 将调用 setBeanFactory() 方法，将 BeanFactory 容器实例传入；

如果 Bean 实现了 ApplicationContextAware 接口的话，Spring 将调用 Bean 的 setApplicationContext() 方法，将 Bean 所在应用上下文引用传入进来；

如果 Bean 实现了 BeanPostProcessor 接口，Spring 就将调用它们的 postProcessBeforeInitialization() 方法；

如果 Bean 实现了 InitializingBean 接口，Spring 将调用它们的 afterPropertiesSet() 方法。类似地，如果 Bean 使用 init-method 声明了初始化方法，该方法也会被调用；

如果 Bean 实现了 BeanPostProcessor 接口，Spring 就将调用它们的 postProcessAfterInitialization() 方法；

此时，Bean 已经准备就绪，可以被应用程序使用了。它们将一直驻留在应用上下文中，直到应用上下文被销毁；

如果 Bean 实现了 DisposableBean 接口，Spring 将调用它的 destory() 接口方法，同样，如果 Bean 使用了 destory-method 声明销毁方法，该方法也会被调用.

Bean 的作用域?

singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的；

prototype : 每次请求都会创建一个新的 bean 实例；

request：每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效；

session : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效；

global-session：全局 session 作用域，仅仅在基于 portlet 的 web 应用中才有意义，Spring5 已经没有了。Portlet 是能够生成语义代码(例如：HTML)片段的小型 Java Web 插件。它们基于 portlet 容器，可以像 servlet 一样处理 HTTP 请求。但是，与 servlet 不同，每个 portlet 都有不同的会话。

Spring 中的单例 Bean 的线程安全问题了解吗?

大部分时候我们并没有在系统中使用多线程，所以很少有人会关注这个问题。单例 bean 存在线程问题，主要是因为：当多个线程操作同一个对象的时候，对这个对象的非静态成员变量的写操作会存在线程安全问题。常见的有两种解决办法：

在 Bean 对象中尽量避免定义可变的成员变量（不太现实）。

在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal 中（推荐的一种方式）。

谈谈你对 Spring 中的事务的理解?

事务是逻辑上的一组操作，要么都执行，要么都不执行。

事务特性

原子性：事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；

一致性：执行事务前后，数据保持一致；

隔离性：并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的；

持久性: 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。

Spring 事务管理接口

• PlatformTransactionManager：（平台）事务管理器；
• TransactionDefinition：事务定义信息（事务隔离级别、传播行为、超时、只读、回滚规则）；
• TransactionStatus：事务运行状态；

所谓事务管理，其实就是“按照给定的事务规则来执行提交或者回滚操作”。

Spring 中的事务隔离级别?

TransactionDefinition 接口中定义了五个表示隔离级别的常量：

TransactionDefinition.ISOLATION_DEFAULT：使用后端数据库默认的隔离级别，MySQL 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别；

TransactionDefinition.ISOLATION_READ_UNCOMMITTED：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读；

TransactionDefinition.ISOLATION_READ_COMMITTED：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生；

TransactionDefinition.ISOLATION_REPEATABLE_READ：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生；

TransactionDefinition.ISOLATION_SERIALIZABLE：最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

Spring 中的事物传播行为?

事务传播行为是为了解决业务层方法之间互相调用的事务问题。当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。在 TransactionDefinition 定义中包括了如下几个表示传播行为的常量：

• 支持当前事务的情况：

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务；

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行；

TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

• 不支持当前事务的情况：

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起；

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

• 其他情况：

TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 TransactionDefinition.PROPAGATION_REQUIRED。

Spring 常用的注入方式有哪些?

构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

Setter 方法注入：Setter 方法注入是容器通过调用无参构造器或无参 static 工厂方法实例化 bean 之后，调用该 bean 的 Setter 方法，即实现了基于 Setter 的依赖注入。

基于注解的注入：最好的解决方案是用构造器参数实现强制依赖，Setter 方法实现可选依赖。

Spring 框架中用到了哪些设计模式?

工厂设计模式 : Spring 使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象；

代理设计模式 : Spring AOP 功能的实现；

单例设计模式 : Spring 中的 Bean 默认都是单例的；

模板方法模式 : Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式；

包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源；

观察者模式：Spring 事件驱动模型就是观察者模式很经典的一个应用；

适配器模式：Spring AOP 的增强或通知(Advice)使用到了适配器模式、SpringMVC 中也是用到了适配器模式适配 Controller。

ApplicationContext 通常的实现有哪些?

FileSystemXmlApplicationContext：此容器从一个 XML 文件中加载beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。

ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载beans 的定义，这里，你需要正确设置 classpath 因为这个容器将在 classpath 里找 bean 配置。

WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 Web 应用的所有 bean。

Spring如何解决循环依赖问题(超详细)

什么是循环依赖？
简单来说就是对象A依赖了对象B，而对象B又依赖了对象A，如下面代码：

// A -> B
class A{
    public B b;
}

// B -> A
class B{
    public A a;
}

循环依赖带来的影响
实际上，如果对象不是放在在Spring容器中管理，上面代码是没有所谓循环依赖问题，可以正常运行。而循环依赖之所以产生，是因为Spring中的bean创建要经过一定的生命周期。

A与B的bean创建流程：
假设A先被扫描到，于是先执行A的bean生命周期：
1、实例化A得到一个原始对象

2、给A中的B属性赋值，于是执行B的bean生命周期

…

初始化后，可能进行AOP

执行B的bean生命周期：
1、实例化B得到一个原始对象

2、给B中的A属性赋值，于是去执行A的bean生命周期

…

初始化后，可能进行AOP

按照常规逻辑，当上面A的生命周期执行到第2步时，会去执行B的生命周期，而B的生命周期执行到第2步又需要一个A对象，于是又会去走A的生命周期。。此时便出现循环依赖问题了，如下图所示。

三级缓存之 “第二级缓存“：earlySingletonObjects
顺着上面的思路，如果由我们来设计Spring，会如何设计解决上面这种循环依赖的问题？加一个中间缓存（二级缓存，Spring中对应名称为earlySingletonObjects）似乎就可以解决，思路如下：

在创建完A原始对象后，会将其放入earlySingletonObjects缓存中（提早暴露给其它的bean），然后注入依赖B，此时发现B在singletonObjects单例池中（图中省略）不存在且earlySingletonObjects也不存在，于是创建B的bean，创建B的bean过程也和创建A一样，会先创建B的原始对象并放入earlySingletonObjects中进行暴露，然后注入依赖A，此时发现A不存在于singletonObjects，但A的原始对象存在于singletonsCurrentlyInCreation（说明A的bean也正在创建中），于是从earlySingletonObjects找，可以找到一个原始对象，B完成依赖注入并实例化后，A也可以完成依赖注入。

那么上面这样处理方式，是否就能解决循环依赖问题了？咋一看似乎满足了，但实际上下面场景就会打破上面这种平衡。

场景：如果A的原始对象注入给B的属性之后，A的原始对象进行了AOP（按照bean的生命周期，AOP是在初始化后在后置处理器中处理的），此时会产生另外一个对象-代理对象，这个对象最终会被存放到单例池singletonObjects中，也就是说，对于A而言，它最终的bean对象实际上应该是AOP之后的代理对象而不是原来那个原始对象，但B拿的是原始对象，这就产生冲突：B依赖的A和最终的A不是同一个对象。（这也回答了面试题：解决Spring循环依赖问题只用一二级缓存行不行？）

三级缓存之 “第三级缓存“：singletonFactories
那么如何解决B依赖的A和最终的A不是同一个对象这种冲突？
方式1：不管有没有循环依赖问题，统一在初始化前AOP？这种做法明显破坏了Spring所设定的bean生命周期，如果为了解决循环依赖问题去破坏bean生命周期的设计原则，那么得不偿失。

方式2：判断是否依赖的对象也在创建，如果是才提前对该对象进行AOP，并将AOP代理对象存放起来，后续该对象在初始化后，判断如果对象已被代理过，是则不再进行AOP。

对比发现显然第二种方式更加合适，Spring也确实采用了第二种方式来解决冲突，于是三级缓存：singletonFactories派上用场。就像其名一样，singletonFactories是一个单例工厂。如果我们打开Spring源码，可以看到它的值存的是一个beanName → lambda表达式，这个lambda表达式可能用到也可能用不到。

何时存入lambda表达式？
存入步骤是在创建完原始对象之后执行的，Spring中是在AbstractAutowireCapableBeanFactory.doCreateBean() → getSingleTon() 中进行存储。

什么时候执行lambda表达式？
获取bean的逻辑，走的是DefaultSingletonBeanRegistry.getBean()，当getBean调用到getSingleton()时，会进入下面代码。从代码可以看出，只有当1级、2级缓存拿不到bean时，且存在循环依赖问题（通过代码isSingletonCurrentlyInCreation(beanName)判断）时，才会去执行lambda表达式，获取真正的bean（普通原始对象或代理对象），并将其放入二级缓存earlySingletonObjects中，同时删除三级缓存中的引用（注意：此处因为需要保证原子性，前面对singletonObjects加了独占锁）。

• lambda中的逻辑是啥？

同样是在AbstractAutowireCapableBeanFactory类中，可以从getEarlyBeanReference方法中看到，最终lambda表达式执行的逻辑，就是去遍历所有后置处理器，然后在SmartInstantiationAwareBeanPostProcessor的实现类中的getEarlyBeanReference方法中去创建bean，而创建的bean可能是普通原始对象 （在InstantiationAwareBeanPostProcessorAdapter中，直接返回当前bean），也可能是代理对象（也就是提前AOP，在 AbstractAutoProxyCreator中通过jdk动态代理或cglib创建），需要注意的是无论是普通对象还是代理对象，都不是经过完整生命周期的最终对象，因此在执行lambda表达式后不能将返回的bean直接放入一级缓存，即单例池singletonObjects中，而是要先放到二级缓存提前暴露给其他bean，只有经过所有后置处理器BeanPostProcesssor后才会真正放入singletonObjects中。

如果bean被提前AOP，初始化后的AOP逻辑中，要如何判断不需再进行AOP？
当bean初始化后，后置处理器AbstractAutoProxyCreator中的postProcessAfterInitialization方法会被调用，其中存在这么一段逻辑，即判断earlyProxyReferences（又是一个cache，但一般不会把它计入三级缓存中）中是否已有该cache，有则说明已经进行过AOP，那么就不会再次进行AOP。（wrapIfNecessary中还有更多细节的判断是否需要AOP，此处相当于提前截断，不需要再进行细节判断了）

什么时候下Spring解决不了循环依赖？
情况一：使用构造器注入
Spring在创建原始对象的原理也是调用构造器进行创建，如果使用构造器进行注入，那么Spring自身无法解决循环依赖问题，此时加入@Lazy注解即可，原理是对于Lazy修饰的对象，Spring会先创建一个代理对象给属性赋值，那么依赖方就可以正常进行实例化了。

class A {

    B b;

    @Autowired
    public void method(B b) {
        this.b = b;
    }
}

class B {
    A a;

    @Autowired
    public void method(A a) {
        this.a = a;
    }
}

情况二：循环依赖且用@Async注解修饰方法
Spring在扫描bean、发现某个类方法被@Async修饰时，会通过后置处理器AsyncAnnotationBeanPostProcessor生成代理对象，而该后置处理器的顺序比处理AOP的后置处理器还靠后，因此仍然会导致Spring处理不了循环依赖。同理，可以使用@Lazy注解解决该问题。

class A {

    @Autowired
    B b;

    @Async
    public void method() {
        b.xx();
    }
}

class B {
    A a;
}