Spring事务

最新推荐文章于 2024-06-13 22:47:13 发布
最新推荐文章于 2024-06-13 22:47:13 发布
阅读量2.6k 收藏 6
点赞数 2
文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58342797/article/details/129737661
版权

目录

手动操作

 声明式提交

 注解的属性

 事务隔离级别

事务传播机制

事务可以将一组操作封装成为一个单元，一组操作要么全部成功，要么全部失败

Mysql中操作事务，有三个步骤；

1、start transaction ；开启事务

2、commit；提交事务

3、rollback；回滚事务

Spring操作事务，可以分为手动操作和声明式自动提交

手动操作

SpringBoot内置了两个对象，DataSourceTransactionManager用户获取事务、开启事务、，提交事务、回滚事务。TransactionDefinition是事务的属性


@Controller
@RequestMapping("/user")
public class InsertUserController {

    @Autowired
    InsertUserService insertUserService;

    //用于管理事务
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;

    private TransactionDefinition transactionDefinition;
    @RequestMapping("/insert")
    @ResponseBody
    public int insert(String name, String password) {

        //开启一个事务
        TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
        //插入数据库
        int i = insertUserService.insert(name, password);
        //提交事务
        dataSourceTransactionManager.commit(transactionStatus);
        //回滚事务
        //  dataSourceTransactionManager.rollback(transactionStatus);
        return i;
    }
}

在启用事务提交后，插入数据成功

 如果启用事务回滚，可以看到返回的是1，但是数据库查找不到这个数据（因为事务回滚，删除了新增的数据）

 声明式提交

使用@Transactional注解声明方法，这个方法就可以自动开启事务，自动提交事务，遇到没有处理的异常，就可以自动回滚事务

@Transactional注解通过AOP实现，也就是基于动态代理实现。在执行业务代码之前，调用代理类的方法，开启事务，如果执行成功，提交事务，否则回滚事务

@Transactional可以用于修饰类或者方法

1、修饰方法时，只能用于public方法，否则不会生效

2、修饰类时，表示对注解类的所有public方法生效


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;

    @RequestMapping("/autoinsert")
    @ResponseBody
    @Transactional
    public int insert(String name, String password) {
        int i = insertUserService.insert(name, password);
      //  System.out.println(1 / 0);
        return i;
    }
}

在没有引入异常时，事务自动提交

 在引入异常之后，并且没有手动处理这个异常，那么会自动回滚事务

 调试发现，i=1，但是调试结束之后，发现数据没有插入，也就是发生了事务回滚

 如果异常被处理了，这时spring会认为我们会自己处理业务，执行回滚操作，所以不会进行事务回滚


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;

    @RequestMapping("/autoinsert")
    @ResponseBody
    @Transactional()
    public int insert(String name, String password) {
        int i = insertUserService.insert(name, password);
        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return i;
    }
}

插入成功

 这时，有两种解决办法，手动抛出异常，手动回滚事务

1、手动抛出异常


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;

    @RequestMapping("/autoinsert")
    @ResponseBody
    @Transactional()
    public int insert(String name, String password) {
        int i = insertUserService.insert(name, password);
        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            throw e;//手动抛出异常
        }
        return i;
    }
}

2、手动回滚事务


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;

    @RequestMapping("/autoinsert")
    @ResponseBody
    @Transactional()
    public int insert(String name, String password) {
        int i = insertUserService.insert(name, password);
        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            //手动回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

        }
        return i;
    }
}

 注解的属性

@Transactional 注解的关键属性大致有九个：

readOnly（事务读写性）

默认情况下是 false（即：不指定只读性），设置为 true 的含义是： 告诉程序该方法下使用的是只读操作，如果进行其他非读操作，则会抛出异常。

如果一次执行多次查询，这时为了保证数据整体的一致性，要用只读事务。

noRollbackFor 和 noRollbackForClassName（遇到时不回滚）
用来指明不回滚的条件是哪些异常类或者异常类名。

rollbackFor 和 rollbackForClassName（遇到时回滚）
用来指明回滚的条件是哪些异常类或者异常类名。

timeout（超时时间）
用于设置事务处理的时间长度，阻止可能出现的长时间的阻塞系统或者占用系统资源，单位为秒，超出设置时间，会抛出异常TransactionTimedOutException

默认值是-1，表示没有设置超时时间


value（指定使用的事务管理器）
value 主要用来指定不同的事务管理器，主要用来满足在同一个系统中，存在不同的事务管理器的场景需要。

 事务隔离级别

事务的隔离级别，可以让多个并发运行的事务更加稳定，减少并发问题

在mysql中，有四种隔离级别：读未提交，读已提交，可重复读，可串行化

而在spring中，有五种隔离级别，由isolation属性设置

Isolation.DEFAULT：使用连接数据库中默认的隔离级别【默认】
Isolation.READ_UNCOMMITTED：读取未提交数据
Isolation.READ_COMMITTED：读取已提交数据
Isolation.REPEATABLE_READ：可重复读
Isolation.SERIALIZABLE：串行化

 1、当Spring中设置的隔离级别和数据库的隔离级别有区别时，以Spring中设置的隔离级别为准

2、Spring中隔离级别的实现以连接的数据库的隔离级别的支持为基础

事务传播机制

事务传播机制表示了多个包含了事务的方法在相互调用时，事务在这些方法中如何传递

事务隔离级别用于保证多个事务并发执行的稳定性；事务传播机制用于保证一个事务在多个调用方法之间的稳定性

Spring中定义了“七个”表示隔离级别的值，由propagation属性设置

1、Propagation.REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务，加入这个事务。是Spring默认的传播机制
2、Propagation.SUPPORTS：如果当前有事务，就以事务方式执行；如果当前没有事务，就以非事务方式执行
3、Propagation.MANDATORY：如果已经存在一个事务，加入这个事务。如果当前不存在事务，抛出异常
4、Propagation.REQUIRES_NEW：不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务
5、Propagation.NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，就把当前事务挂起，非事务方式的方法完毕，继续执行挂起的事务
6、Propagation.NEVER：以非事务方式执行，如果当前存在事务，则抛出异常
7、Propagation.NESTED：如果当前存在事务，则创建一个新的事务作为这个事务的嵌套事务来运行；如果当前没有事务，则创建一个新的事务

1、默认级别（Propagation.REQUIRED）：如果当前没有事务，就新建一个事务，如果已经存在一个事务，加入这个事务


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;
 
    @RequestMapping("/autoinsert")
    @ResponseBody
    
    public void insert(String name, String password) throws InterruptedException {

        //一个增加 user表的事务
       insertUserService.insert(name, password);
        

    }
}



@Service
public class InsertUserService {

    @Autowired
    InsertUserMapper insertUserMapper;
    @Autowired
    InsertLogService insertLogService;

    @Transactional()
    public int insert(@Param("user_name") String user_name, @Param("user_password") String user_password) {
        
        int i = insertUserMapper.insert(user_name, user_password);
        System.out.println("添加User表的数据的行数" + i);

        java.util.Date day = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //一个增加 日志表的事务
        insertLogService.insert(user_name, sdf.format(day));
        return i;
    }
}

@Service
public class InsertLogService {
    @Autowired
    InsertBlogMapper insertBlogMapper;

    @Transactional()
    public int insert(String name, String time) {

        int i = insertBlogMapper.insert(name, time);
        System.out.println("添加日志表的数据的行数" + i);
        System.out.println(1 / 0);
        return i;
    }
}

程序执行的过程：调用InsertUserAutoController类-》调用user表的数据新增方法-》调用log表的数据新增方法

因为采用默认的传播机制，InsertUserService类中创建一个事务之后，调用InsertLogService类的方法，在log表新增数据，此时不会创建新的事务，而是会进入之前InsertUserService类中创建的事务，但是InsertLogService类中方法在新增数据时报错，导致事务回滚，因为是同一个事务，所以两个表的数据都会被回滚

  查询表数据，数据被回滚

2、Propagation.SUPPORTS：如果当前有事务，就以事务方式执行；如果当前没有事务，就以非事务方式执行


@Service
public class InsertLogService {
    @Autowired
    InsertBlogMapper insertBlogMapper;

    @Transactional(propagation = Propagation.SUPPORTS)
    public int insert(String name, String time) {

        int i = insertBlogMapper.insert(name, time);
        System.out.println("添加日志表的数据的行数" + i);
        System.out.println(1 / 0);
        return i;
    }
}


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertLogService insertLogService;

    @RequestMapping("/autoinsert")
    @ResponseBody

    public void insert(String name, String password) throws InterruptedException {

        java.util.Date day = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //一个增加 日志表的事务
        insertLogService.insert(name, sdf.format(day));

    }
}

程序执行的过程：调用InsertUserAutoController类-》调用log表的数据新增方法；

InsertLogService采用的传播机制是SUPPORTS，所以log表新增操作此时是以非事务的方式运行的，不会造成事务回滚

 3、Propagation.MANDATORY：如果已经存在一个事务，加入这个事务。如果当前不存在事务，抛出异常

 4、Propagation.REQUIRES_NEW：不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务


@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insert;
    @Autowired
    InsertLogService insertLogService;

    @RequestMapping("/autoinsert")
    @ResponseBody

    public void insert(String name, String password)  {

        //一个增加 user表的事务
        insert.insert(name, password);


        java.util.Date day = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //一个增加 日志表的事务
        insertLogService.insert(name, sdf.format(day));
    }
}


@Service
public class InsertLogService {
    @Autowired
    InsertBlogMapper insertBlogMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int insert(String name, String time) {
        int i = insertBlogMapper.insert(name, time);
        System.out.println("添加日志表的数据的行数" + i);
        System.out.println(1/0);
        return i;
    }
}
@Service
public class InsertUserService {

    @Autowired
    InsertUserMapper insertUserMapper;


    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int insert(@Param("user_name") String user_name, @Param("user_password") String user_password) {

        int i = insertUserMapper.insert(user_name, user_password);
        System.out.println("添加User表的数据的行数" + i);
        return i;
    }
}

程序执行的过程：调用InsertUserAutoController类-》调用user表的数据新增方法，调用log表的数据新增方法；

采用REQUIRES_NEW这个传播机制，user表新增会创建一个事务，在log表新增也会创建一个事务，此时，log表新增报错，事务回滚，但是user表不会事务回滚

 

 5、Propagation.NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，就把当前事务挂起

当InsertLogService采用NOT_SUPPORTED传播级别，而InsertUserService采用默认级别时

程序执行的过程：调用InsertUserAutoController类-》调用user表的数据新增方法-》调用log表的数据新增方法；

采用NOT_SUPPORTED传播机制，InsertUserService中会创建一个事务，在InsertLogService会挂起存在的事务，InsertLogService的方法会以非事务方式运行，运行结束后恢复InsertUserService的事务

6、Propagation.NEVER：以非事务方式执行，如果当前存在事务，则抛出异常
7、Propagation.NESTED：如果当前存在事务，则创建一个新的事务作为这个事务的嵌套事务来运行；如果当前没有事务，则创建一个新的事务


@Service
public class InsertUserService {

    @Autowired
    InsertUserMapper insertUserMapper;
    @Autowired
    InsertLogService insertLogService;

    @Transactional(propagation = Propagation.NESTED)
    public int insert(@Param("user_name") String user_name, @Param("user_password") String user_password) {

        int i = insertUserMapper.insert(user_name, user_password);
        System.out.println("添加User表的数据的行数" + i);

        java.util.Date day = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //一个增加 日志表的事务
        insertLogService.insert(user_name, sdf.format(day));
        return i;
    }
}


@Service
public class InsertLogService {
    @Autowired
    InsertBlogMapper insertBlogMapper;

    @Transactional(propagation = Propagation.NESTED)
    public int insert(String name, String time) {
        int i = insertBlogMapper.insert(name, time);
        System.out.println("添加日志表的数据的行数" + i);
        System.out.println(1/0);
        return i;
    }
}

@Controller
@RequestMapping("/user")
public class InsertUserAutoController {
    @Autowired
    InsertUserService insertUserService;

    @RequestMapping("/autoinsert")
    @ResponseBody

    public void insert(String name, String password)  {

        //一个增加 user表的事务
        insertUserService.insert(name, password);

    }
}

程序执行的过程：调用InsertUserAutoController类-》调用user表的数据新增方法-》调用log表的数据新增方法；

InsertUserService采用NESTED传播机制，创建了一个事务，在  InsertLogService类中使用 @Transactional()创建了一个事务，这个事务会作为InsertUserService开启的事务的嵌套事务来运行

当InsertLogService事务出现异常，事务回滚，这时，会继续向上查找调用InsertLogService方法的事务，对其进行回滚，所以，两个表都不会插入数据

 

REQUIRED和NESTED两种传播机制的区别：

NESTED：如果当前存在事务，则创建一个新的事务作为这个事务的嵌套事务来运行；如果当前没有事务，则创建一个新的事务

REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务，加入这个事务

两个实际上都可以实现A，B两个事务的关联，只不过NESTED是A包含B，REQUIRED是AB一起

在NESTED中，在一个保存点，如果B事务手动回滚，会保留到B事务之前的状态，也就是不影响A事务。而REQUIRED没有这种机制。所以，NESTED可以实现部分事务回滚


@Service
public class InsertLogService {
    @Autowired
    InsertBlogMapper insertBlogMapper;

    @Transactional(propagation = Propagation.NESTED)
    public int insert(String name, String time) {
        int i = insertBlogMapper.insert(name, time);
        System.out.println("添加日志表的数据的行数" + i);
        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return i;
    }
}

 insertUserService类和insertLogService类的事务传播级别都是NESTED，而insertLogService中实现了手动回滚，回到了保留点，不会影响insertUserService的事务

two 倩
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
SpringSpringMVCMybatis框架
09-28
Spring SSM项目 https://edu.csdn.net/course/detail/37962 Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。◆目的：解决企业应用开发的复杂性◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能◆范围：任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts 2(一般老项目使用)等等。MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）
如何开启SpringBoot的事务
qq_46130027的博客
07-22 4263
如果项目中使用了多个数据源或需要使用特定的事务管理器配置，那么@EnableTransactionManagement注解就很有用。我们可以通过这个注解来配置自定义的事务管理器，并与数据源进行关联。
在Spring中如何手动开启事务（使用编程式事务）
最新发布
白羊座的橙子
06-13 401
一、使用 transactionManager1、向容器中注入事务管理器2、使用 transactionManager 提交事务3、测试二、使用TransactionTemplate1、向容器中注入 TransactionTemplate2、开启事务。
SpringBoot 开启事务的两种常用方式
weixin_44340643的博客
01-12 1万+
spring boot 使用事务
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
spring 手动开启事务
qq_40929531的博客
03-08 1701
【代码】spring 手动开启事务。
Spring事务处理原理步骤详解
08-19
Spring事务处理原理步骤详解 Spring事务处理原理步骤详解是指在Spring框架中实现事务处理的整个过程，它涉及到事务处理的实现、事务处理原理和事务管理器的配置等几个方面。下面是Spring事务处理原理步骤详解的知识...
深入理解Spring事务原理
09-02
Spring事务管理是Spring框架的核心特性之一，它使得开发者能够在应用层面上轻松地处理数据库事务，无需直接接触底层的事务控制。本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库...
Spring事务例子
11-28
通过运行这些例子，你将对Spring事务管理有更深入的理解，知道何时选择编程式还是声明式事务，以及如何有效地处理事务异常。 总之，Spring的事务管理是其强大功能的一部分，无论是编程式还是声明式，都能帮助开发者...
spring 事务
07-11
spring事务讲解
spring事务控制
03-04
spring事务控制jar包，请网上自寻下载
事务及SpringBoot中的事务开启
m0_70770402的博客
02-28 3701
1.什么是事务？1.什么是事务？事务是指在数据库管理系统中执行的一系列操作的逻辑单元。事务可以由一个或多个数据库操作（例如插入、更新、删除等）组成，这些操作被视为一个不可分割的工作单元。在事务中，要么所有的操作都成功执行，要么所有的操作都不执行，不会出现部分操作成功而部分操作失败的情况。传播行为（Propagation）：指定事务的传播行为，即定义了事务方法调用之间的关系。隔离级别（Isolation Level）：指定事务的隔离级别，即定义了事务之间的可见性和并发控制的程度。
Spring中开启事务的方式有哪些
阳阳的博客
06-17 9812
Spring中开启事务的方式主要有两种：编程式事务和声明式事务。 编程式事务 编程式事务：在代码中调用 commit()、rollback()等事务管理相关的方法。 maven pom.xml文件： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.2.4.RELEASE</
Spring之事务管理
ABestRookie的博客
10-10 482
事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败。
SpringBoot 开启事务的常用方式
qq_34091529的博客
07-13 1655
一般在service类标签上添加@Transactional，这样可以将整个service类纳入spring事务管理（所有的 public 方法纳入），在每个业务方法执行时都会开启一个事务，不过这些事务采用相同的管理方式。前言，有时候统一异常处理不太好，因为范围太广了，很多没必要回滚的地方，因为抛了个异常都没办法继续执行别的代码，所以，可以在需要开事务的地方添加 @Transation 注解开启事务就行了。答：因为在SpringBoot中自动装配了此注解配置，所以已被默认启用，自然不需要手动加上此注解。
springboot开启事务
blood_Z的博客
09-06 9229
springboot开启事务 手动事务 TransactionTemplate编程式事务
Spring 事务（详解）
qq_45559559的博客
03-24 6346
将⼀组操作封装成⼀个执⾏单元，要么全部成功要么全部失败。
如何正确打开 Spring 事务？
大鹏的博客
07-07 4106
Spring 事务传播行为是 Spring 中一个常见的面试题，它贯穿于 Spring 的事务管理中，因此想要理解 Spring 事务传播行为，首先要对 Spring 的事务管理有一个整体的认识。本篇先对 Spring 事务的使用加以介绍，后续逐步分析 Spring 事务实现，直至深入理解 Spring 事务传播行为为止。...
MySQL事务
阿莫夕林的博客
11-09 4808
回滚：在事务运行过程中发生了某种故障，事务不能继续执行，系统将事务中对数据库已完成的操作全部撤销，滚回到事务开始之前的状态。 模拟转账 当在执行任意一条语句时出现问题，都会造成银行或用户的损失，所以必须保证整个事务执行的完整性，要么都成功，要么都失败。MySQL事务操作的方式有两种：语法： 2. 开启事务 3. 转账 4. 提交事务 5. 查看账户余额变化 插入两条数据 不手动提交事务，发生异常（关闭命令窗口），查看数据 自动提交事务 自动提交事务演示 取消自动提交 ON ：自

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值