经常问的14002

spring事务五个隔离级别

default默认的隔离级别，使用数据库默认的隔离级别，别外四个与JDBC事物隔离级别对应 读未提交、可重复读、不可重复读、序列化 (脏读、不可重复读（侧重修改）、幻读（侧重插入）)

default(默认) PlatfromTransactionManager默认的隔离级别 使用数据库默认的事务隔离级别, 除了default 其它几个Spring事务隔离级别与JDBC事务隔离级别相对应

read_uncommited(读未提交) 一个事务可以读取另外一个事务未提交的数据 这可能出现脏读 而且不可重复度,出现幻像读等.

read_commited(读已提交) 一个事务可以读取另一个事务已经提交的数据 不可以读取未提交的数据 可以避免脏读 但是无法避免不可重复读和幻像读

repeatTable_read(可重复读) 一个事务可以读取另外一个事务已经提交的数据 可以避免脏读的前提下 也可以避免不可重复读 但是还是无法避免幻像读

serializable(串行化) 这是一个花费较高但是比较可靠的事务隔离级别 可以避免脏读 幻像读和不可重复读

*8**Spring****TransactionDefinition****中的事务隔离级别***

在Spring框架中，TransactionDefinition接口定义了事务的各种属性，其中事务隔离级别是一个非常重要的属性。它定义了事务如何与其他事务隔离，以避免如脏读、不可重复读和幻读等问题。Spring支持的事务隔离级别包括以下几种：

\00001.

· ‌ISOLATION_DEFAULT‌： ‌特点‌：使用数据库默认的隔离级别。

· ‌适用场景‌：当不特别指定隔离级别时，可以选择这个选项，它将遵循数据库本身的隔离级别设置。

\00002.

· ‌ISOLATION_READ_UNCOMMITTED‌（读未提交）： ‌特点‌：允许一个事务读取另一个事务尚未提交的修改。

· ‌并发问题‌：可能导致脏读问题，即读取到其他事务未提交的数据。

· ‌性能‌：性能较高，但并发安全性较差。

· ‌适用场景‌：适用于对数据一致性要求不高的场景。

‌ISOLATION_READ_COMMITTED‌（读已提交）：

· ‌特点‌：一个事务只能看到其他事务已经提交的修改。

· ‌并发问题‌：可以避免脏读问题，但仍可能发生不可重复读问题。

· ‌性能‌：性能较好，适用于大多数场景。

· ‌适用场景‌：适用于大多数对数据一致性有一定要求的场景。

‌ISOLATION_REPEATABLE_READ‌（可重复读）：

‌特点‌： 对同一字段的多次读取结

果都是一致的， 即使其他事务已经修改并提交了数据，除非数据是被本身事务自己所修改

· ‌并发问题‌：可以避免脏读和不可重复读问题，但仍可能发生幻读问题。

· ‌性能‌：性能较低，但并发安全性较好。

· ‌适用场景‌：适用于对数据一致性要求较高，但不需要完全避免幻读的场景。

‌ISOLATION_SERIALIZABLE‌（串行化）：最高的隔离级别

· ‌特点‌：事务被强制按顺序执行，完全避免了脏读、不可重复读和幻读问题。

· ‌性能‌：性能最差，因为它限制了事务的并发执行。

· ‌适用场景‌：适用于对数据一致性要求极高的场景，如金融系统等。

对于银行转账系统等对数据一致性要求极高的场景，可以选择ISOLATION_SERIALIZABLE串行化隔离级别；而对于内容管理系统等对性能要求较高，但对数据一致性要求不高的场景，可以选择ISOLATION_READ_COMMITTED读已提交隔离级别。

*Spring事务传播行为*

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

解决互相调用的事务问题

1REQUIRED默认的传播机制，如果当前存在事务，则加入该事务；

如果当前没有事务，则创建一个新的事务；如果外部方法没有开启事务的话，.REQUIRED 修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

如果外部方法开启事务并且被 Propagation.REQUIRED 的话，所有REQUIRED 修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚

2SUPPORTS支持当前事务：如果当前存在事务，则加入该事务；如果当前没有事务，就不加入事务

3mandatory强制性的支持当前事务： 如果当前存在事务，则加入 该事务；如果当前没有事务，则抛出异常。

4REQUIRES_NEW不支持当前事务的情况：：创建一个新的事务，如果 当前存在事务，则把当前事务挂起；

5NOT_SUPPORTED不支持当前事务的情况：：以非事务方式运行，如 果当前存在事务，则把当前事务挂起。

6NEVER不支持当前事务的情况：：以非事务方式运行，如果当前存在 事务，则抛出异常。

7NESTED其他情况嵌套事务：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；

我们项目使用的是第一种，也就是默认的传播机制： REQUIRED。

spring七个事务传播属性*

PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 ​ PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。 ​ PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。 ​ PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。 ​ PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 ​ PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。 ​ PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

*谈谈你对 Spring 的理解？*

Spring 是一个IOC 和AOP 容器框架。

• 控制反转（IOC） ：使用 new 创建一个对象

底层反射和工厂

1、Spring通过Bean工厂来创建Bean对象（包含id，class，和property三个属性）

2、Spring通过反射机制来获取class对象的实例，利用实例来操作该class对象的相关属性和方法。

简述一下你对反射的理解？

类获取这个类的所有属性和方法

对象调用它的任意一个方法和属性

先获取到该类的字节码文件对象(.class)， 就能够通过该类中的方法获取到我们想要的所有信息

MyBatisPlus 中 QueryWrapper 动态条件

IOC

JDBC

反射实现的方式

能够运行时动态获取类的实例

第一种：通过Object类]getClass方法 第二种：通过对象实例方法获取对象 第三种：通过Class.forName方式

IOC 是什么？

控制反转

• 将对象之间的相互依赖关系交给 IOC 容器来管理，并由IOC 容器完成对象的注入

工厂一配置好配置文件/注解即可，完全不用考虑对象是 如何被创建出来的

如果利用 IOC 的话，你只需要配置好文件/注解，然后在需要的地方引用就行了，大大增加了项目的可维护性且降低了开发难度。

*AOP* *通知的执行顺序*

解读：从 Spring5.2.7 开始，Spring AOP 不再严格按照 AspectJ 定义的规

则来执行 advice，而是根据其类型按照从高到低的优先级进行执行：

@Around，@Before ，@After，@AfterReturning，@AfterThrowing。

*注入方式*

1Xml-context，aop，mvc

2注解：在开发的类使用@Controller，@Service等注解

在service层想调用另外一个service的方法，不需要去new了，直接把它交给spring管理，然后用注解的方式引入就能使用。

controller 中注入 service，service 中注入 mapper 都是 IOC 的具体应用

优点： IOC 代码量减少测试容易

• 面向切面编程（AOP）， AOP 底层是动态代理，

注入方式

Spring AOP使用纯Java实现， JDK动态代理和CGLIB代理。

可以通过配置XML或注解来开启AOP自动代理对象。例如，使用<aop:aspectj-autoproxy>标签或@EnableAspectJAutoProxy注解来开启AOP支持。

如果要代理的对象实现了某个接口，那么 Spring

AOP 就会使 用 JDK 动态代理去创建代理对象；而对于没有实现接口的对象，就

无法使用 JDK 动态代理，转 而使用 CGlib 动态代理生成一个被代理对象的子类

来作为代理。 对这个切面进行一些如权限控制、事物管理，记录日志全局异常处理器 性能监视安全检查缓存

*AOP 通知的执行顺序*高到低的优先级进行执行： @Around，@Before ，@After，@AfterReturning，@AfterThrowing。

将代码封装起来，便于减少系统的重复代码

DI是Spring用的set方法或带参数的构造方法创建对象的值的过程.

• 依赖注入（DI），spring 使用 javaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程，就是依赖注入的思想

AOP 的基本概念有哪些？

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

横切多个对象”。

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

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

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

关联。

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

*Around和Before这些通知什么意思？*

@Before 前置通知（Before advice） ：在某连接点（JoinPoint 类或者方法）之前执行的通知，但这个通知不能阻止连接点前的执行。

@After 后通知（After advice） ：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。

*AOP 的注解有哪些*

*Spring 的通知是什么？有哪几种类型？*

@Aspect: 该注解是把此类声明为一个切面类。

@Before: 前置通知，该注解是声明此方法为前置通知 (目标方法执行之前就

会先执行被此注解标注的方法)

@After:后置通知， 该注解是声明此方法为后置通知 (目标方法执行完之后就

会执行被此注解标注的方法)

@AfterReturning: 返回通知，该注解是声明此方法为返回通知 (目标方法正常

执行返回后就会执行被此注解标注的方法)

@AfterThrowing: 异常通知，该注解是声明此方法为异常通知 (目标方法在执

行出现异常时就会执行被此注解标注的方法)

@Around: 环绕通知，该注解是环绕通知是动态的,可以在前后都设置执行

@PointCut: 该注解是声明一个公用的切入点表达式(通知行为的注解的都可以

直接拿来复用)如果是注解式开发还会用到@EnableAspectJAutoProxy: 该注解是声明这

个配置类使用注解式的 AOP(还有一种古老的方式是在 xml 文件里声明开

启 AOP)

*1**单例bean怎么实现***

一 二 三

一是实例化- new出一个对象

二是依赖注入，

三是初始化，调用initMethod

*2**Bean有几种配置方式?将一个类声明为**** **Spring* *的* *bean* *的注解有哪些？*

1xml2注解3@Configuration4@bean

一般使用@Autowired 注解去自动装配 bean

@Resource 和 @Inject

*SpringMVC 的常用注解有哪些？*

• @RequestMapping：用于处理请求 url 映射的注解，可用于类或方法上。用于

类上，则表示类中的所有响应请求的方法都是以该地址作为父路径；

• @RequestBody：注解实现接收 HTTP 请求的 json 数据，将 json 转换为 Java

对象；

• @ResponseBody：注解实现将 Controller 方法返回对象转化为 json 对象响应给

客户。

@PathVariable:获取url中的数据

@RequestParam:获取请求参数的值

@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解

@PostMapping用于将HTTP post请求映射到特定处理程序的方法注解

*SpringBoot注解*

一、启动注解 @SpringBootApplication

@SpringBootConfiguration 注解，继承@Configuration注解，主要用于加载配置文件

@EnableAutoConfiguration 注解，开启自动配置功能

@ComponentScan 注解，主要用于组件扫描和自动装配

二、Controller 相关注解

@Controller @service

@RestController 复合注解

@RequestBody

@RequestMapping

三、取请求参数值 部分的值绑定到方法的参数上

@CookieValue 把Request header中关于cookie的值绑定到方法的参数上

*Bean* *有**注入方式？***

Spring依赖注入是Spring框架的核心特性之一，它允许在对象创建时，由Spring容器自动将依赖关系注入，通常有以下几种实现方式：

1‌构造器注入（Constructor Injection）‌

构造器注入是通过调用类的构造方法来实现依赖注入。要求被注入的类提供一个带有参数的构造方法

构造器注入的优点是：

· 可以确保注入的依赖在对象创建时就已经被初始化。

· 可以避免在对象创建后还需要通过setter方法进行依赖注入的情况。

· 有助于实现不可变对象。

缺点是： 当依赖对象较多时，构造方法的参数列表可能会变得很长，影响代码的可读性。

2调用‌Setter方法注入（Setter Injection）‌

Setter方法注入的优点是：

灵活性高，允许在对象创建后再进行依赖注入。

可以设置可选的依赖，如果某些依赖不是必需的，可以在对象创建时不注入。

缺点是：

· 不能注入不可变对象。

· 注入的对象可以在对象创建后被修改。

3‌字段注入（Field Injection）‌

被注入的字段上使用@Autowired等注解来标记依赖关系

字段注入的优点是：

· 使用简单，不需要编写额外的setter方法或构造方法。

缺点是：

· 不能注入不可变对象。

· 注入的对象可以在对象创建后被修改。

· 不符合面向对象的封装原则，因为依赖关系直接暴露在了类的字段上

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

*单例bean 是线程安全的吗?*

单例 bean 存在线程问题，主要是因为多个线程操作同一个对象时，对这个对象

的非静态成员变量的写操作会存在线程安全问题。

有两种常见的解决方案：

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

2.在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal

中（推 荐的一种方式）。 在拦截器中存在service中取用完再删除

*Spring多例*

1、xml文件scope属性 或者使用@Scope注解

4prototype多例，每次使用的时候都会创建一个新的对象，并交给JVM管理。 多例的使用分几种情况： ①多例注入多例：@Autowired等注解； ②单例注入多例：用 ApplicationContext.getBean方法相当于多次@Autowired

*@Component 和@Bean 的区别？*

@Component 注解作用于类，而@Bean 注解作用于方法。

当引用第三方库的类需要装配到 Spring 容器的时候，就只能通过@Bean 注解来实现。

*Spring 是怎么解决循环依赖的？*

循环依赖就是A对象依赖了B对象，B对象依赖了A对象

Spring 通过三级缓存和提前暴露对象引用的机制解决了单例 Bean 的循环依赖问题。

然而，在实际开发中，我们应该尽量避免循环依赖的发生

如果确实需要处理循环依赖，可以优先考虑使用 Setter 注入而非构造器注入，并谨慎使用 AOP 代理和延迟加载等特性。

一级缓存 二级缓存 三级缓存

一级缓存已经经历了完整生命周期的bean对象。成品bean

二级缓存为多了没走完就生命周期的Bean 半成品bean 但未注入属性和初始化

主要是通过二级缓存和三级缓存来解决的，其中三级缓存是主要贡献者

三级缓存存放工厂对象，生成半成品bean放到二级缓存中，解决循环依赖对象需要提前被aop代理，以及如果没有循环依赖，早期的bean也不会真正暴露，不用提前执行代理过程，也不用重复执行代理过程。

三级缓存怎么解决呢？可以对依赖代理类时 加上一个懒加载注解@Lazy。

*SpringMVC ResultType 和 ResultMap 的区别？*

数据库列名和要封装实体的属性名完全一致的话用 resultType

数据库列名和要封装实体的属性名有不一致的话用 resultMap

*SpringBoot、Spring MVC**和*** *Spring* *有什么区别？*

application.yml文件中去编写一些内容，配置简单了

Jsp作为视图，开发效率低

但是springboot不推荐使用jsp，主推的是thymeleaf和freemarker等模板引擎；

1单独的Web 服务器需要。这意味着你不再需要启动Tomcat

2需要更少的配置

因为没有web.xml 文件。只需添加用@ Configuration 注释的类，然后添加用@Bean 注释的方法，Spring 将自动加载对象并像以前一样对其进行管理。您甚至可以将@Autowired 添加到bean 方法中，以使Spring 自动装入需要的依赖关系中。

3集成了大量常用的第三方库的配置， Spring Boot 应用为这些第三方库提供了几乎可以零配置的开箱即用的能力。spring-boot-starter-web添加了对构建web应用所需的所有依赖。

4Spring Boot与Spring框架紧密集成，能够充分利用Spring框架提供的各种功能，如依赖注入、AOP等。

5Spring Boot提供了对单元测试和集成测试的良好支持，使得开发者能够轻松地编写和运行测试。

Spring 最重要的特征是依赖注入控制反转

Spring MVC开发 Web 应用将会变的非常简单

SpringBoot解决Spring 和 Spring MVC需要配置大量的参数

自动配置消除了设置 Spring 应用程序所需的 XML配置和启动的项来解决这个问题。 集成spring

并加入嵌入式 服务器、Security、统计、健康检查、外部配置等等。

简化代码集成Spring Security、 Spring AOP 、Spring ORM 、Spring Test

*SpringBoot* *缺点、**开发服务会遇到哪些问题？***

与分布式系统相关的复杂性：这种开销包括网络问题，延迟开销，带宽问题，安全问题。 • 服务发现：服务发现工具管理群集中的流程和服务。它涉及一个服务目录，在该目录中注册服务，然后能够查找并连接到该目录中的服务。

• 冗余：分布式系统中的冗余问题。 •

负载平衡：负载平衡改善跨多个计算资源的工作负荷，诸如计算机，计算机集群，网络链路，中央处理单元，或磁盘驱动器的分布。

• 性能问题：由于各种运营开销导致的性能问题。

*SpringBoot自动状态的原理spring.factories*

Spring Factories 机制是 Spring Boot 中的一种服务发现机制，Spring Boot 会自动扫描所有 Jar 包类路径下 META-INF/spring.factories 文件，并读取其中的内容，进行实例化

注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心，

@EnableAutoConfiguration 给容器导入 META-INF/spring.factories 里定义的自动配置类。 每一个自动配置类结合对应的 xxxProperties.java 读取配置文件进行自动配置功能。

*题目* *5**：****SpringBoot*** *自动配置原理？*

注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配

置的核心，

@EnableAutoConfiguration 给容器导入 META-INF/spring.factories 里定义的自动配

置类。

每一个自动配置类结合对应的 xxxProperties.java 读取配置文件进行自动配置功能。

SpringBean 的生命周期？

1构造 Bean 对象 2. 设置 Bean 属性 3. 初始化回调 4.Bean 调用 5. 销毁 Bean

Spring 为啥默认把 Bean 设计成单例的单例bean的优势

由于不会每次都新创建新对象所以有一下几个性能上的优势：

1.减少了新生成实例的消耗

新生成实例消耗包括两方面，第一，spring会通过反射或者cglib来生成bean实例这都是耗性能的操作，其次给对象分配内存也会涉及复杂算法。

2.减少jvm垃圾回收

由于不会给每个请求都新生成bean实例，所以自然回收的对象少了。

3.可以快速获取到bean

因为单例的获取bean操作除了第一次生成之外其余的都是从缓存里获取的所以很快。

单例bean的劣势

=============

单例的bean一个很大的劣势就是他不能做到线程安全！！！，由于所有请求都共享一个bean实例，所以这个bean要是有状态的一个bean的话可能在并发场景下出现问题，而原型的bean则不会有这样问题（但也有例外，比如他被单例bean依赖），因为给每个请求都新创建实例。关于这方面我正在准备写一篇文章，在整理当中，感兴趣的朋友可以关注我，我后续写一篇详细的文章。

总结

======

Spring 为啥把bean默认设计成单例？

答案：为了提高性能！！！从几个方面，

少创建实例 垃圾回收 缓存快速获取 单例有啥劣势？ 如果是有状态的话在并发环境下线程不安全。

redis缓存雪崩、穿透以及技术预防* 缓存的击穿场景的主要原因；*

缓存雪崩：数据大批量到达过期时间，并发量很大直接访问数据库导致数据库压力过大down机（优化过期时间、异步构建缓存） 缓存穿透：热key问题，高并发key失效后重建任务时间长，导致所有请求访问到数据库导致压力过大down机（分布式锁<未命中加锁，其余等待>、key永不过期、异步构建key） 缓存击穿：不存在的key，导致直接命中数据库（设置默认值和过期时间、布隆过滤器）

redis数据持久化方式（RDB、AOF）

*,应用场景：断电数据恢复 RDB：定时对整个内存做快照，间隔时间长，两次备份之间数据不完整，但备份文件小，恢复速度快，灾难恢复可选择RDB AOF：记录每一次的写命令，默认每秒一次，数据相对完整，但备份文件大，恢复速度慢，恢复时可以重写AOF

redis据过期策略*

定期删除：默认每100毫秒扫描一次，随机抽取20个key，删除这20个key中的过期key，过期比例超过1/4,重复步骤 惰性删除：对key操作时，redis会主动检查key是否过期，过期则删除

依赖注入的方式有哪些*

IOC：控制反转，把对象的创建权利交给spring，实现方式DI AOP：面向切面编程，重复的功能抽取出来，动态切入到需要的方法中，减少重复代码，降低耦合度 注入方式：构造方法注入、setter方法注入、接口注入（基本不用）

Spring Bean自动装配有哪些方式*

ref、byName、byType、注解（常用），前面三种是通过XML配置，现在基本不推荐使用

bean生命周期的管理

实例化 -> 属性赋值 -> 初始化 -> 销毁 Bean 的管理就是通过 IOC 容器中的 BeanDefinition 信息进行管理的

springboot 启动类里用的注解；如何实现自动装配；

(1) Spring Boot 在启动时除了扫描与启动类同一包下的组件之外，还会检查各个 jar 包中是否存在 META-INF/spring.factories 文件，为自动装配做准备。

(2) 第三方的 spring-boot-starter 会通过将自己的自动装配类写到 META-INF/spring.factories 中让 Spring Boot 加载到容器中，使自动装配类能够生效。 (3) 第三方的自动装配类会通过利用 @Conditional 系列注释保证自己能在各种环境中成功自动装配。 @AutoConfigurationPackage 注解的作用应该是扫描与 @SpringBootApplication 标注的类同一包下的所有组件。 @Import(AutoConfigurationImportSelector)翻译为大白话就是 自动配置导入选择器,就是要扫描 META-INF 文件夹下面的spring.factories文件 @Conditional扩展注解作用（判断当前条件是否满足）

自动装配: spring.factories配置文件存在大量的以AutoConfiguration为结尾的类名称，这些类就是存有自动配置信息的类，而SpringApplication在获取这些类名后再加载 这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(…)的内部就会执行selectImports()方法，找到所有JavaConfig自动配置类的全限定名对应的class，然后将所有自动配置类加载到Spring容器中。 总结: Spring Boot启动的时候会通过@EnableAutoConfiguration注解找到META-INF/spring.factories配置文件中的所有自动配置类，并对其进行加载，而这些自动配置类都是以AutoConfiguration结尾来命名的，它实际上就是一个JavaConfig形式的Spring容器配置类，它能通过以Properties结尾命名的类中取得在全局配置文件中配置的属性如：server.port，而XxxxProperties类是通过@ConfigurationProperties注解与全局配置文件中对应的属性进行绑定的。