ToB企服应用市场:ToB评测及商务社交产业平台

标题: （史上最全的）Spring6框架学习教程 [打印本页]

---

作者: 张国伟    时间: 2024-7-29 09:43
标题: （史上最全的）Spring6框架学习教程
一、什么是Spring

1.javaWeb框架发展史

1、Servlet+JSP+JavaBean(跳转页面、业务逻辑判断、数据库查询)

2、MVC三层架构(M Model =pojo(User)V-view(USP)C-(controller-servlet))
(
web-跳转页面
service-业务逻辑判断   new UserService0;
dao-数据库查询 new UserDao();
)

3、使用EJB进行应用的开发，但是EJB是重量级框架(在使用的时间，过多的接口和依赖，侵入性强)，在使用上比较麻烦 UserService imp extends

4、Struts1/Struts2+Hibernate+Spring
Spring
(
web-跳转页面 Struts
service-业务逻辑判断
dao-数据库查询Hibernate
）--------SSH
5、SpringMVC+Mybatis+Spring
(
web-跳转页面 SpringMVC(出现BUG，使用毕竟麻烦)
service-业务逻辑判断
dao-数据库查询 myBatis
）-------SSM
6、SpringBoot开发，约定大于配置SSM搭建架构需要大量XML配置文件
7、mvvm架构
Model（模子）：负责处置惩罚应用程序的数据逻辑，比如数据库读写等数据源的操纵。
View（视图）：负责表现数据（即模子层的数据）而且吸收用户操纵界面的界面。
ViewModel（视图模子）：作为Model和View之间的桥梁，从Model层获取数据后，处置惩罚并返回给View层表现。ViewModel 还负责处置惩罚View层的用户界面操纵，将相关事件转发到Model层。
2.Spring框架简介

Spring框架英文全称Spring framework，是由Spring团队研发的模块化、轻量级开源框架。其告急目标 是为了简化项目开发。在项目开发中，可以说没有刻意使用Spring，却处处有着Spring存在，用官网对Spring框架的先容:Spring框架核心功能包罗依赖注入、事务管理、Web应用、数据访问、消息发送等等。

Spring框架的计划理念基于以下核心原则：
轻量级计划：
   轻量级计划是Spring框架的主要原则之一。通过采用轻量级的计划，Spring能够在应用程序开发中提供高效、简朴的办理方案。相比于其他重型框架，Spring注重简洁性，使得开发者能够更专注于业务逻辑的实现，而不必被繁琐的框架细节所困扰。
  非侵入性的计划：
   Spring框架夸大非侵入性，这意味着开发者不需要修改已有的Java类来适应框架，从而保持了代码的整洁性和可维护性。非侵入性计划的上风在于，开发者可以更灵活地选择使用和配置框架的功能，而不会影响到已有的代码结构。
  3.Spring loC/Dl 详解

3.1、IoC/DI简介

 因为loC/Dl是 Spring Framework的底子。Spring Framework 其他所有功能都是在loC/DI 底子上 研发的。
loc: Inversion of Control控制反转
DlependencyInjection 依赖注入
   控制(对象创建权利)被反转:
之前:由程序员控制对象创建
UserService(new UserDao())-------->UserDao ;强耦合，再小的代码变更都会引起BUG的大概性之后:依赖Spring注入(DI)
Spring(newUserService(); new UserDao();)如果需要用到Spring管理的对象，需要依赖Spring注入(DI)
  下图是没有使用IoC/DI前和使用了之后的对比图 
 

 3.2、IoC/DI的优缺点

优点：
   

• 解耦合：降低组件之间的依赖，使代码更易于理解和维护。
  
• 提高灵活性：便于在运行时更换依赖，增加系统的灵活性。
  
• 易于测试：支持单元测试，可以轻松注入模拟对象。
  
• 代码重用：相同的组件可以在不同的上下文中重用。
  
• 提高可读性：依赖关系明确，代码意图清楚。
  

  缺点：
   

• 学习曲线：需要时间理解和把握IoC和DI的概念。
  
• 配置复杂性：在复杂系统中，容器的配置大概变得复杂。
  
• 性能开销：大概引入一些性能开销，尤其是在应用程序启动时。
  
• 过度依赖框架：大概使得代码过于依赖特定的框架，降低可移植性。
  
• 引入复杂性：在一些简朴应用中，大概会引入不必要的复杂性。
  

  3.3、IoC/DI在项目中的应用场景

Java EE企业应用开发：
IoC和DI是解耦组件之间复杂关系的利器。Spring IoC模块就是IoC模式的一种实现，通过依赖注入和AOP切面加强了为JavaBean如许的POJO对象赋予事务管理、生命周期管理等基本功能。
EJB模式：
在EJB模式中，应用开发人员需要编写EJB组件，满意EJB容器的规范，才能运行在EJB容器中。Spring通过IoC提供了一个基本的JavaBean容器，管理依赖关系，降低了应用开发对传统J2EE技术规范的依赖。
Web应用程序：
在Web应用程序中，控制器（Controller）和视图（View）之间的依赖关系可以通过DI来管理。如许可以降低代码的耦合度，提高可维护性和可扩展性。
服务层：
在服务层中，服务类之间也可以通过DI来传递依赖对象。这种方式使得组件可以独立于其他组件进行开发和测试，提高了开发服从和代码质量。
数据访问层：
在数据访问层中，DAO（Data Access Object）对象也可以通过DI来注入数据库毗连信息。这种方式简化了代码的配置，使得依赖关系管理更加灵活和可维护。
二、基于Springboot快速启动Spring

点击下一步就可以创建一个SpringBoot项目而且Springboot项目我们也可以从下面图片看到SpringBoot中是依赖了Spring的。

三、SpringIoc核心容器

1.什么是Bean

1.1 Bean的简述

 Bean 是由Spring容器创建并管理的对象实例。Spring通过依赖注入（DI）和控制反转（IoC）机制管理这些对象的生命周期和依赖关系。
1.2 如何配置Bean

• <bean class="">
  
• @Component 写在类上面
  
  
  • @Service
    
  • @Repository
    
  • @Configuration
    
  • ...
    
  
  
• @Bean
  
  
  • 写在方法上面
    
  • 通常写在配置类里面
    
    
    • @Bean方法调用别的一个@Bean方法，会从spring容器中去获取
      
    
    
  • 可以干预bean的实例化过程的，jar包中的类如果要配置bean就需要用@Bean
    
  • 在方法中声明的参数spring会帮我们自动注入进来
    
  
  
• @lmport
  
  
  • @Import必须写在类上面
    
  • 标记的类必须是一个bean否则不会起作用
    
  • 普通类-----直接@lmport(UserService.class)普通类，把普通类注入spring
     
    
  • lmportSelector-----lmportSelector -用于根据完备限定名字符串批量注入Bean
    
    
    
    • 定义一个类实现
      
    • ii.批量注册bean(通过实现selectlmports，返回bean的完备类路径字符串数组)
      ii.@lmport(实现lmportSelector.class)
      
    
    
  
  

1.3 实例化Bean

1.3.1 使用默认构造函数：

这是最常见的方式，Spring容器会调用Bean类的默认无参构造函数来创建实例。

1. @Component
2. public class MyBean {
3.     public MyBean() {
4.         // 构造函数逻辑
5.     }
6. }

复制代码

1.3.2 使用实例工厂方法实例化--@Bean

        可以自由的选择构造函数进行实例化

1.3.3 使用工厂类：

        通过实现BeanFactory接口或使用FactoryBean接口来创建Bean实例。这种方式提供了更高的灵活性，答应你控制Bean的创建和初始化过程。

1. public class MyBeanFactory implements FactoryBean<MyBean> {
2.     public MyBean getObject() throws Exception {
3.         return new MyBean();
4.     }
6.     public Class<MyBean> getObjectType() {
7.         return MyBean.class;
8.     }
9. }

复制代码

2.依赖注入

2.1 @Autowired注解

 要实现自动装配一定要用@Autowired

• @Bean 方法的参数默认会自动装配
  
• Bean的有参构造函数默认会自动装配(前提只能有一个有参构造函数)
  

@Autowired特性
@Autowired可以写在构造函数、方法、字段、参数
   

• 构造函数
  
  
  • 如果bean只有一个有参构造函数，是省略@Autowired，会自动注入构造函数的参数。
    
  • 如果有多个有参构造函数，而且没有无参构造函数:会报错， 办理:使用@Autowired指定某一个构造函数
    
  • 构造函数上指定的@Autowired(required=false);会失效
    
  
  

         2.参数:
        如果想设置构造函数上面的参数为不是必须注入:单独去设置
          @Autowired(required = false)
          @Autowired(value = "specificBean")
  2.2 @Inject和@Resource

 @Inject和@Resource
都是由JDK官方提供的。
Idea为什么不建议在字段上面使用@autowired

• 通过@Autowired注入私有字段不建议字段private，建议通过构造函数或者方法来进行自动注入
  
• @autowired受框架的限制
  

@Inject
不能设置required=false属性

1. <dependency>
2.     <groupId>jakarta.inject</groupId>
3.     <artifactId>jakarta.inject-api</artifactId>
4.     <version>2.0.1</version>
5. </dependency>

复制代码

@Resource
会先根据名字找，再根据类型找 
2.3 @Value

接受前端哀求参数---pojo , 把数据库查询到的数据---pojo
user{ name ,age ..}

1. 直接值（基本类型，String等）

1.   @Value("ltx")
2.     private String name;
3.     @Value("18")
4.     private Integer age;

复制代码

2.对外部属性（SpringBoot配置文件）文件的引用 

2. @Component
3. public class MovieRecommender {
5.     private final String catalog;
7.     public MovieRecommender(@Value("${catalog.name}") String catalog) {
8.         this.catalog = catalog;
9.     }
10. }

复制代码

3.默认值

1. @Component
2. public class MovieRecommender {
4.     private final String catalog;
6.     public MovieRecommender(@Value("${catalog.name:defaultCatalog}") String catalog) {
7.         this.catalog = catalog;
8.     }
9. }

复制代码

3.自动注入次序

3.1  @Order改变自动注入次序

 用于改变自动装配时：如果一个类型， 有多个bean, 可以List来承接装备的类型。 在List里面的bean可以通过@Order来改变。

1. @Component
2. //@Order(9)
3. class A implements I {
4.     public A() {
5.         System.out.println("A");
6.     }
7. }
9. @Component
10. //@Order(0)
11. public class B implements I{
12.     public B() {
13.         System.out.println("B");
14.     }
15. }
16. @SpringBootTest
17. public class TestOrder {
19.     @Test
20.     public void test(@Autowired List<I> i){
21.         System.out.println(i);
22.         // 输出的A 在前面B在后面
23.     }
24. }

复制代码

1. @Component
2. @Order(9)
3. class A implements I {
4.     public A() {
5.         System.out.println("A");
6.     }
7. }
9. @Component
10. @Order(0)
11. public class B implements I{
12.     public B() {
13.         System.out.println("B");
14.     }
15. }
16. @SpringBootTest
17. public class TestOrder {
19.     @Test
20.     public void test(@Autowired List<I> i){
21.         System.out.println(i);
22.         
23.         // 输出的B 在前面A在后面
24.     }
25. }

复制代码

 
3.2 @DependsOn改变Bean创建次序

 Bean创建: (@Componet class A --b---> 容器加载 new ApplicationContext()------>
new A(); DI ... ; )


new A () 负载数据库查询
new B(）数据库毗连

1. @DependsOn("d")
2. public class C {
3.     public C() {
4.         System.out.println("C");
5.     }
6. }

复制代码

4.懒加载bean

懒加载作用：
默认的bean会在启动的时间就会创建， 如果说某些Bean非常大， 如果在启动的时间就创建就会影响启动速率， 就可以把那些大的Bean设置成懒加载， 如许可以优化启动速率
懒加载Bean创建: (@Componet class A --b---> 容器加载 new ApplicationContext()------> )
用到的时间才会创建(new A(); DI ... ; ):

SpringBoot将所有的bean都配置为懒加载

1. spring.main.lazy-initialization=true

复制代码

5.@Scope作用域


默认Bean单例（只会new 一次，不管@autowired多少次，只会创建一次）
利益： 节省内存空间（有线程安全风险）
多例Bean（只会new 一次，不管@autowired多少次，只会创建一次）
利益： 节省内存空间（有线程安全风险）

Bean 是单例的，会不会有线程安全题目?
   线程安全题目: 多线程并发的情况下， 同时对同一个共享资源（Bean）进行读写，就出现线程不安全，题目：（脏读、数据串改）
  会不会有线程安全题目: 会！
但是！ 只要不在单例bean中声明一些共享的类成员变量（共享资源），而且不对共享资源进行读写， 也不会出现线程安全题目， 所以基本上bean就会使用默认的单例（节省内存开销）。
   单例

1. @Scope("singleton")
2. @Component
3. public class SingletonBean {
4.     // ...
5. }

复制代码

原型

1. @Scope("prototype")
2. @Component
3. public class PrototypeBean {
4.     // ...
5. }

复制代码

6.循环依赖

new applicationContext(); ----> new BeanA(); ——>剖析@autowired----->去容器中获取BeanB(容器容器中没有B,创建B)----> ----> new BeanB(); ——>剖析@autowired----->去容器中获取BeanA(容器容器中没有A,创建A)---->循环执行......

题目的根本Bean要经过依赖注入完（剖析@autowired之后）后才会放到spring容器

办理
1.在配置文件中放开循环依赖的限制

1. # 放开循环依赖的限制
3. #spring.main.allow-circular-references=true

复制代码

2.代码计划层面：
        a. 把依赖的方法， 直接写在本类中，断绝其中一方依赖关系
        b. 添加一个中间类， 中间类去依赖A、B， 然后让中间类去组织他们的依赖方法。
3.耽误注入
        a.添加需要依赖的构造函数参数
        b.添加@Lazy注解

1. @Lazy
2. public BeanA(BeanB beanb) {
3.     this.beanb = beanb;
4. }
6. @Lazy
7. public Bean(BeanA beana) {
8.     this.beana = beana;
9. }

复制代码

四、SpringAOP面相切面编程

 AOP：Aspect Oriented Programming 面向切面编程 编程头脑
4.1 为什么要用到AOP

所有业务功能都已经实现，但是末了我想在所有的功能里面加一个公共的功能，（记录所有的哀求的用时）， 使用AOP， 切面（需要加强的公共的、跟业务没有关系的公共代码）。可以在不改变原有业务代码的底子上进行了加强。
如安在Spring中创建一个所谓切面？
切面里面的代码怎么运行在业务方法（之前、之后）

4.2 AOP快速上手

第一步：引入pom.xml依赖

1.         <dependency>
2.             <groupId>org.springframework.boot</groupId>
3.             <artifactId>spring-boot-starter-aop</artifactId>
4.         </dependency>

复制代码

 通过下面的图片我们可以看到AOP包中实在另有aspect，aspect是一个成熟的AOP框架

 
第二步：编写业务代码

1. package com.ltx.springtest.service;
3. import org.springframework.stereotype.Service;
5. @Service
6. public class UserService {
7.     //添加用户
8.     public void addUser(){
9.         System.out.println("添加用户");
10.     }
11.     //删除用户
12.     public void deleteUser(){
13.         System.out.println("删除用户");
14.     }
15.     //修改用户
16.     public void updateUser(){
17.         System.out.println("修改用户");
18.     }
19. }

复制代码

第三步：编写aop切面类
之前说过AOP就是面向切面编程， OK大家现在可以直观的看到切面了，我们现在就是要面向这个切面类来编程，加强业务方法，记录日志：

1. package com.ltx.springtest;
3. import org.aspectj.lang.ProceedingJoinPoint;
4. import org.aspectj.lang.annotation.Around;
5. import org.aspectj.lang.annotation.Aspect;
6. import org.springframework.stereotype.Component;
8. @Aspect
9. @Component
10. public class LogAspect {
12.     /**
13.      * 切面环绕通知，针对UserService接口的所有方法执行进行监控。
14.      * 使用 ProceedingJoinPoint 参数来获取方法信息并控制方法的执行。
15.      * 该通知将在方法执行前、执行后以及发生异常时打印日志信息。
16.      *
17.      * @param proceedingJoinPoint AOP联盟提供的 ProceedingJoinPoint 类型的参数，用于获取方法信息和继续方法的执行。
18.      * @return 返回方法的执行结果。
19.      * @throws Throwable 如果方法执行过程中抛出异常，则重新抛出异常。
20.      */
21.     @Around("execution(* com.ltx.springtest.service.UserService.*(..))")
22.     public Object before(ProceedingJoinPoint proceedingJoinPoint){
23.         System.out.println("方法进入");
24.         Object proceed=null;
25.         try {
26.             proceed = proceedingJoinPoint.proceed();
27.         } catch (Throwable e) {
28.             System.out.println("方法异常");
29.             throw new RuntimeException(e);
30.         }
31.         finally {
32.             System.out.println("方法执行完毕");
33.         }
34.         System.out.println("方法返回");
35.         return proceed;
36.     }
37. }

复制代码

第四步：测试
测试类

1. package com.ltx.springtest;
3. import com.ltx.springtest.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
8. @SpringBootTest
9. class SpringTestApplicationTests {
11.     @Test
12.     void contextLoads(@Autowired UserService userService) {
13.         userService.addUser();
14.     }
16. }

复制代码

效果如下所示：

 
所以spring可以在不改变原有业务代码的底子上进行了加强。
如安在Spring中创建一个所谓切面？
   @Aspect+@Component+通知+切点
  4.3 AOP具体使用

 4.3.1 @EnableAspectJAutoProxy

 启用AOP，没有这个注解AOP功能无法使用

@EnableAspectJAutoProxy是否一定要加？
为什么没有加AOP也起作用了？
SpringBoot实在会通过启动类自动帮我们加上@EnableAspectJAutoProxy，所以可以省略。
但是依然建议加上@EnableAspectJAutoProxy，在Spring中是要加的。

4.3.2 通知

 通知分类
   后置通知@After：目标方法之后执行
  异常通知@AfterThrowing：目标方法出现了异常执行
返回通知@AfterReturning：目标方法返回值执行
环绕通知@Around：可以把代码加强在目标方法的恣意地方，更通用
  前置通知实例

1. // 前置通知
2. @Before("execution(* com.example.c4_aop.advice.UserServce.*(..) )")
3. public void before(JoinPoint joinPoint){
4. // 记录当前方法的方法名，参数
5. String methodName = joinPoint.getSignature().getName();
7. // 参数
8. Object[] args = joinPoint.getArgs();
10. // 目标对象
11. Object target = joinPoint.getTarget();
13. System.out.println("当前执行的方法是"+target.getClass()+"."+methodName+"；参数"+ Arrays.toString(args));
15. }

复制代码

  执行次序：
正常：前置-->目标方法-->返回通知--->后置通知(finally)
异常: 前置-->目标方法-->异常通知--->后置通知(finally)
  4.3.3 切点 

4.3.3.1 表达式抽取

1. @Pointcut("execution( public int cn.ltx.inter.MyCalculator.*(int,int))")
2.     public void myPoint(){}
3.    
4.     @Before("myPoint()")
5.     public static void start(JoinPoint joinPoint){
6.         Object[] args = joinPoint.getArgs();
7.         String name = joinPoint.getSignature().getName();
8.         System.out.println(name+"方法开始执行，参数是："+ Arrays.asList(args));
9.     }
11.     @AfterReturning(value = "myPoint()",returning = "result")
12.     public static void stop(JoinPoint joinPoint,Object result){
13.         String name = joinPoint.getSignature().getName();
14.         System.out.println(name+"方法执行完成，结果是："+result);
16.     }
18.     @AfterThrowing(value = "myPoint()",throwing = "exception")
19.     public static void logException(JoinPoint joinPoint,Exception exception){
20.         String name = joinPoint.getSignature().getName();
21.         System.out.println(name+"方法出现异常："+exception.getMessage());
22.     }
24.     @After("myPoint()")
25.     private int end(JoinPoint joinPoint){
26.         String name = joinPoint.getSignature().getName();
27.         System.out.println(name+"方法执行结束了......");
28.         return 0;
29.     }
30. }

复制代码

4.3.3.2 切点表达式 

Spring AOP支持使用以下AspectJ切点标识符(PCD),用于切点表达式：
切点标识符：规定匹配的位置

• execution: 用于匹配方法执行毗连点。 这是使用Spring AOP时使用的告急切点标识符。 可以匹配到方法级别 ，细粒度
  

• 访问修饰符：不写代表所有
  
• 返回值：*代表所有
  
• 完备限定名
  
  
  
  • 包
    
    
    
    • com.xs.service
      
    • com.xs.*=com.xs.service com.xs.dao com.xs.xxx 名字恣意，不代表层级恣意
      
    • com.xs..= com.xs.service.imple 层级恣意
      
    
    
  • 类
    
    
    
    • *
      
    • com.xs..*=com.xs.service.imple.恣意包. 恣意类
      
    • 参数： 不写代表没有参数的方法， .. 代表恣意参数 
      
    
    
  
  

五、Spring声明式事务

5.1 事务是什么

  一组关联的数据库操纵 （转账）；要么都乐成，要么都失败，保证业务操纵完备性的一种数据库机制。

ACID四大特性
   A  原子性：原子性指的是 在一组业务操纵下 要么都乐成 要么都失败
在一组增编削查的业务下 要么都提交 要么都回滚
C  同等性：事务前后的数据要保证数据的同等性
在一组的查询业务下 必须要保证前后关联数据的同等性
I  隔离性：在并发情况下 事物之间要相互隔离。
D  恒久性：数据一旦保存就是恒久性的。
  5.2 使用@Transactional注解

Spring的@Transactional注解是最常用的声明式事务管理方式。你可以将其添加到类或方法上，来声明事务的边界。
示例代码：

1. import org.springframework.stereotype.Service;
2. import org.springframework.transaction.annotation.Transactional;
4. @Service
5. public class UserService {
7.     // 声明类级别的事务，类中的所有方法都会应用这个事务配置
8.     @Transactional
10.     public void createUser(User user) {
11.         // 创建用户的业务逻辑
12.     }
14.     public void updateUser(User user) {
15.         // 更新用户的业务逻辑
16.     }
18.     // 声明方法级别的事务，只对这个方法生效
19.     @Transactional(readOnly = true)
20.     public User getUser(Long id) {
21.         // 获取用户的业务逻辑
22.         return user;
23.     }
24. }

复制代码

5.3. 事务属性

@Transactional注解支持多个属性来定义事务的举动：

• propagation：定义事务的传播举动，默以为Propagation.REQUIRED。
  
• isolation：定义事务的隔离级别，默以为Isolation.DEFAULT。
  
• timeout：定义事务的超时时间，默以为-1（不超时）。
  
• readOnly：定义事务是否为只读，默以为false。
  
• rollbackFor：定义哪些异常会导致事务回滚，默以为Throwable。
  
• noRollbackFor：定义哪些异常不会导致事务回滚。
  

示例代码：

1. @Transactional(readOnly = true, propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
2. public User getUser(Long id)
3. {
4.     // 获取用户的业务逻辑 return user;
5. }

复制代码

5.4. 事务传播举动

事务的传播举动定义了当事务方法被另一个事务方法调用时，事务如何传播：

• Propagation.REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
  
• Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
  
• Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
  
• Propagation.REQUIRES_NEW：无论当前是否存在事务，都创建一个新的事务。
  
• Propagation.NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，则挂起当前事务。
  
• Propagation.NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
  

示例代码：

1. @Transactional(propagation = Propagation.REQUIRES_NEW)
2. public void createUser(User user)
3. {
4.     // 创建用户的业务逻辑
5. }

复制代码

5.5. 事务隔离级别

事务的隔离级别定义了事务在执行过程中对数据的可见性：

• Isolation.DEFAULT：使用后端数据库的默认隔离级别。
  
• Isolation.READ_UNCOMMITTED：最低的隔离级别，答应读取未提交的数据。
  
• Isolation.READ_COMMITTED：保证读取的都是已提交的数据。
  
• Isolation.REPEATABLE_READ：保证在同一个事务中，多次读取同一数据的效果是同等的。
  
• Isolation.SERIALIZABLE：最高的隔离级别，完全串行执行事务。
  

   脏读（Dirty Read）：一个事务读取到了另一个事务未提交的数据。如果谁人事务终极回滚，读取到的数据将是无效的。
  不可重复读（Non-repeatable Read）：在一个事务中，多次读取同一数据聚集时，由于其他事务的修改，大概会得到不同的效果。这违反了事务的隔离性。
  幻读（Phantom Read）：一个事务在执行过程中，由于其他事务的插入或删除操纵，导致读取到之前不存在的行，或者丢失了之前存在的行。
  丢失更新（Lost Update）：两个或多个事务同时修改同一数据，其中一个事务的修改大概会覆盖另一个事务的修改。特别是当两个事务读取同一数据，然后各自修改并提交时
  死锁（Deadlock）：两个或多个事务相互等待对方持有的资源，导致无法继承执行。这通常发生在事务试图获取多个资源的锁时。
  示例代码：

1. @Transactional(isolation = Isolation.REPEATABLE_READ)
2. public void updateUser(User user)
3. {
4.     // 更新用户的业务逻辑
5. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4