1. Toy模板网首页
  2. > Toy博客

【Spring篇】AOP事务管理

10月前 作者：热爱编程的小白白 分类：Toy博客 阅读(42) 违法举报

这篇具有很好参考价值的文章主要介绍了【Spring篇】AOP事务管理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

🍓系列专栏:Spring系列专栏
🍉个人主页:个人主页

一、AOP事务管理

1.Spring事务简介

1.相关概念介绍
  • 事务作用：在数据层保障一系列的数据库操作同成功同失败
  • Spring事务作用：在数据层或 业务层 保障一系列的数据库操作同成功同失败

数据层有事务我们可以理解，为什么业务层也需要处理事务呢?

举个简单的例子:

  • 转账业务会有两次数据层的调用，一次是加钱一次是减钱
  • 把事务放在数据层，加钱和减钱就有两个事务
  • 没办法保证加钱和减钱同时成功或者同时失败
  • 这个时候就需要将事务放在业务层进行处理。

Spring为了管理事务，提供了一个平台事务管理器PlatformTransactionManager

【Spring篇】AOP事务管理

commit是用来提交事务，rollback是用来回滚事务。

PlatformTransactionManager只是一个接口，Spring还为其提供了一个具体的实现:

【Spring篇】AOP事务管理

从名称上可以看出，我们只需要给它一个DataSource对象，它就可以帮你去在业务层管理事务。其内部采用的是JDBC的事务。所以说如果你持久层采用的是JDBC相关的技术，就可以采用这个事务管理器来管理你的事务。而Mybatis内部采用的就是JDBC的事务，所以后期我们Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器。

2. 转账案例-需求分析

接下来通过一个案例来学习下Spring是如何来管理事务的。

先来分析下需求:

需求: 实现任意两个账户间转账操作

需求微缩: A账户减钱，B账户加钱

为了实现上述的业务需求，我们可以按照下面步骤来实现下:
①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）

②：业务层提供转账操作（transfer），调用减钱与加钱的操作

③：提供2个账号和操作金额执行转账操作

④：基于Spring整合MyBatis环境搭建上述操作

3. 转账案例-环境搭建
步骤1:准备数据库表

之前我们在整合Mybatis的时候已经创建了这个表,可以直接使用

create database spring_db character set utf8;
use spring_db;
create table tbl_account(
    id int primary key auto_increment,
    name varchar(35),
    money double
);
insert into tbl_account values(1,'Tom',1000);
insert into tbl_account values(2,'Jerry',1000);
步骤2:创建项目导入jar包

项目的pom.xml添加相关依赖

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

  </dependencies>
步骤3:根据表创建模型类
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Double money;
	//setter...getter...toString...方法略    
}
步骤4:创建Dao接口
public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}
步骤5:创建Service接口和实现类
public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        accountDao.inMoney(in,money);
    }

}
步骤6:添加jdbc.properties文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
步骤7:创建JdbcConfig配置类
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}
步骤8:创建MybatisConfig配置类
public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}
步骤9:创建SpringConfig配置类
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
步骤10:编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }

}

最终创建好的项目结构如下:

【Spring篇】AOP事务管理

4. 事务管理

上述环境，运行单元测试类，会执行转账操作，Tom的账户会减少100，Jerry的账户会加100。

这是正常情况下的运行结果，但是如果在转账的过程中出现了异常，如:

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }

}

这个时候就模拟了转账过程中出现异常的情况，正确的操作应该是转账出问题了，Tom应该还是900，Jerry应该还是1100，但是真正运行后会发现，并没有像我们想象的那样，Tom账户为800而Jerry还是1100,100块钱凭空消息了，银行乐疯了。如果把转账换个顺序，银行就该哭了。

不管哪种情况，都是不允许出现的，对刚才的结果我们做一个分析:

①：程序正常执行时，账户金额A减B加，没有问题

②：程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

当程序出问题后，我们需要让事务进行回滚，而且这个事务应该是加在业务层上，而Spring的事务管理就是用来解决这类问题的。

Spring事务管理具体的实现步骤为:

步骤1:在需要被事务管理的方法上添加注解
public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
	@Transactional
    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }

}

注意:

@Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上

  • 写在接口类上，该接口的所有实现类的所有方法都会有事务
  • 写在接口方法上，该接口的所有实现类的该方法都会有事务
  • 写在实现类上，该类中的所有方法都会有事务
  • 写在实现类方法上，该方法上有事务
  • 建议写在实现类或实现类的方法上
步骤2:在JdbcConfig类中配置事务管理器
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }

    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

**注意：**事务管理器要根据使用技术进行选择，Mybatis框架使用的是JDBC事务，可以直接使用DataSourceTransactionManager

步骤3：开启事务注解

在SpringConfig的配置类中开启

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
步骤4:运行测试类

会发现在转换的业务出现错误后，事务就可以控制回顾，保证数据的正确性。

知识点1：@EnableTransactionManagement
名称 @EnableTransactionManagement
类型 配置类注解
位置 配置类定义上方
作用 设置当前Spring环境中开启注解式事务支持
知识点2：@Transactional
名称 @Transactional
类型 接口注解 类注解 方法注解
位置 业务层接口上方 业务层实现类上方 业务方法上方
作用 为当前业务层方法添加事务（如果设置在类或接口上方则类或接口中所有方法均添加事务）

2. Spring事务角色

这节中我们重点要理解两个概念，分别是事务管理员和事务协调员。

  1. 未开启Spring事务之前:

【Spring篇】AOP事务管理

  • AccountDao的outMoney因为是修改操作，会开启一个事务T1
  • AccountDao的inMoney因为是修改操作，会开启一个事务T2
  • AccountService的transfer没有事务，
    • 运行过程中如果没有抛出异常，则T1和T2都正常提交，数据正确
    • 如果在两个方法中间抛出异常，T1因为执行成功提交事务，T2因为抛异常不会被执行
    • 就会导致数据出现错误
  1. 开启Spring的事务管理后

【Spring篇】AOP事务管理

  • transfer上添加了@Transactional注解，在该方法上就会有一个事务T
  • AccountDao的outMoney方法的事务T1加入到transfer的事务T中
  • AccountDao的inMoney方法的事务T2加入到transfer的事务T中
  • 这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准确性。

通过上面例子的分析，我们就可以得到如下概念:

  • 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
  • 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

注意:

目前的事务管理是基于DataSourceTransactionManager和SqlSessionFactoryBean使用的是同一个数据源。

3. Spring事务属性

上一节我们介绍了两个概念，事务的管理员和事务的协同员，对于这两个概念具体做什么的，我们待会通过案例来使用下。除了这两个概念，还有就是事务的其他相关配置都有哪些，就是我们接下来要学习的内容。

在这一节中，我们主要学习三部分内容事务配置、转账业务追加日志、事务传播行为。

1. 事务配置

【Spring篇】AOP事务管理

上面这些属性都可以在@Transactional注解的参数上进行设置。

  • readOnly：true只读事务，false读写事务，增删改要设为false,查询设为true。

  • timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。

  • rollbackFor:当出现指定异常进行事务回滚

  • noRollbackFor:当出现指定异常不进行事务回滚

    • 思考:出现异常事务会自动回滚，这个是我们之前就已经知道的

    • noRollbackFor是设定对于指定的异常不回滚，这个好理解

    • rollbackFor是指定回滚异常，对于异常事务不应该都回滚么，为什么还要指定?

      • 这块需要更正一个知识点，并不是所有的异常都会回滚事务，比如下面的代码就不会回滚

        public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    public void transfer(String out,String in ,Double money) throws IOException;
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
	@Transactional
    public void transfer(String out,String in ,Double money) throws IOException{
        accountDao.outMoney(out,money);
        //int i = 1/0; //这个异常事务会回滚
        if(true){
            throw new IOException(); //这个异常事务就不会回滚
        }
        accountDao.inMoney(in,money);
    }

}

  • 出现这个问题的原因是，Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回顾，其他的异常类型是不会回滚的，对应IOException不符合上述条件所以不回滚

    • 此时就可以使用rollbackFor属性来设置出现IOException异常不回滚

      @Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
	 @Transactional(rollbackFor = {IOException.class})
    public void transfer(String out,String in ,Double money) throws IOException{
        accountDao.outMoney(out,money);
        //int i = 1/0; //这个异常事务会回滚
        if(true){
            throw new IOException(); //这个异常事务就不会回滚
        }
        accountDao.inMoney(in,money);
    }

}

  • rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串

  • noRollbackForClassName等同于noRollbackFor，只不过属性为异常的类全名字符串

  • isolation设置事务的隔离级别

    • DEFAULT :默认隔离级别, 会采用数据库的隔离级别
    • READ_UNCOMMITTED : 读未提交
    • READ_COMMITTED : 读已提交
    • REPEATABLE_READ : 重复读取
    • SERIALIZABLE: 串行化

介绍完上述属性后，还有最后一个事务的传播行为，为了讲解该属性的设置，我们需要完成下面的案例。

2. 转账业务追加日志案例
1. 需求分析

在前面的转案例的基础上添加新的需求，完成转账后记录日志。

  • 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
  • 需求微缩：A账户减钱，B账户加钱，数据库记录日志

基于上述的业务需求，我们来分析下该如何实现:

①：基于转账操作案例添加日志模块，实现数据库中记录日志

②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能

需要注意一点就是，我们这个案例的预期效果为:

无论转账操作是否成功，均进行转账操作的日志留痕

2. 环境准备

该环境是基于转账环境来完成的，所以环境的准备可以参考6.1.3的环境搭建步骤，在其基础上，我们继续往下写

步骤1:创建日志表
create table tbl_log(
   id int primary key auto_increment,
   info varchar(255),
   createDate datetime
)
步骤2:添加LogDao接口
public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}
步骤3:添加LogService接口与实现类
public interface LogService {
    void log(String out, String in, Double money);
}
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
	@Transactional
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}
步骤4:在转账的业务中添加记录日志
public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    public void transfer(String out,String in ,Double money)throws IOException ;
}
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
    @Autowired
    private LogService logService;
	@Transactional
    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }

}
步骤5:运行程序

  • 当程序正常运行，tbl_account表中转账成功，tbl_log表中日志记录成功

  • 当转账业务之间出现异常(int i =1/0),转账失败，tbl_account成功回滚，但是tbl_log表未添加数据

  • 这个结果和我们想要的不一样，什么原因?该如何解决?

  • 失败原因:日志的记录与转账操作隶属同一个事务，同成功同失败

  • 最终效果:无论转账操作是否成功，日志必须保留

3. 事务传播行为

【Spring篇】AOP事务管理

对于上述案例的分析:

  • log方法、inMoney方法和outMoney方法都属于增删改，分别有事务T1,T2,T3
  • transfer因为加了@Transactional注解，也开启了事务T
  • 前面我们讲过Spring事务会把T1,T2,T3都加入到事务T中
  • 所以当转账失败后，所有的事务都回滚，导致日志没有记录下来
  • 这和我们的需求不符，这个时候我们就想能不能让log方法单独是一个事务呢?

要想解决这个问题，就需要用到事务传播行为，所谓的事务传播行为指的是:

事务传播行为：事务协调员对事务管理员所携带事务的处理态度。

具体如何解决，就需要用到之前我们没有说的propagation属性。

1.修改logService改变事务的传播行为
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
	//propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

运行后，就能实现我们想要的结果，不管转账是否成功，都会记录日志。

2.事务传播行为的可选值

【Spring篇】AOP事务管理

对于我们开发实际中使用的话，因为默认值需要事务是常态的。根据开发过程选择其他的就可以了，例如案例中需要新事务就需要手工配置。其实入账和出账操作上也有事务，采用的就是默认值。

笔记来自：黑马程序员SSM框架教程

二、图书推荐

Java诞生日，推荐Java“此生错过必遗憾”系列书单：

Java28岁了，当打之年，并且还会打很多年。
为即将或正在使用Java的你推荐Java“此生错过必遗憾”系列书单。看看你还缺哪本？请补齐。优惠购书链接就在文中，拿好不谢。

1.Java核心技术第12版开发基础+高级特性

【Spring篇】AOP事务管理
Java四大名著”之一Core Java最新版，一键打包全套2册！建议入门小白和准备升级到Java17的开发者购买。本书根据Java17新特性全面升级！赠送作者亲授视频课+海量代码集。
限时秒杀链接：点击购买

2.Java核心技术第11版基础知识+高级特性

【Spring篇】AOP事务管理
“Java四大名著”之一Core Java次新版，一键打包全套2册！建议实际生产环境仍在使用Java8、Java11开发且暂时没有升级版本打算的开发者购买。本书基于Java9-11编写，赠送作者亲授视频课+海量代码集。

限时秒杀链接：点击购买

3.Java编程思想[Thinking in Java]

【Spring篇】AOP事务管理
“Java四大名著”之一，需要有一定编程基础的人才可阅读，即使很多内容还无法理解，但每次读完一定会有所收获。本书单最前面推荐的《Java核心技术》侧重技术，而《Java编程思想》侧重于“思想”，本书为你剖析Java中各个内容的设计理念。这是一本伴随我们技术成长的好书，买一本放在旁边，摸着就有底气。

限时秒杀链接：点击购买

4.Effective Java 中文版（原书第3版）

【Spring篇】AOP事务管理
Java之父James Gosling：
“我很希望我10年前就能拥有这本书。有人可能认为我不需要任何Java方面的书籍，但是我需要这本书。”

“Java四大名著”之一，适合已经掌握Java核心技术的程序员，想更加深入地了解Java编程语言的开发者阅读。针对如何编写高效、设计优良的程序提出了最实用、最权威的指导方针，通过90条简短、独立的经验法则，探索新的设计模式和语言习惯用法，帮你更加有效地使用Java编程语言及其基本类库，指引你少走弯路。这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。是Java开发人员案头上的一本不可或缺的参考书。

限时秒杀链接：点击购买

5.Java语言程序设计基础篇+进阶篇（原书第12版）

【Spring篇】AOP事务管理

本套书相较于《Java核心技术》更加的基础，如果你阅读《Java核心技术》有些吃力，建议从本书读起。畅销20余年的“长城书”一键打包全套！被世界各地的大学选作教材，更新至Java9、10和11。本书通过示例讲解问题求解技巧，提供大量的程序清单，每章配有丰富的复习题和编程练习题，帮助读者掌握编程技术并解决实际开发中遇到的问题。

限时秒杀链接：点击购买

6.Java并发编程实战

【Spring篇】AOP事务管理
让注重实战的你更快领悟Java并发编程的要领，快速构建大规模并发应用程序。“Java四大名著”之一《Effective Java》的作者Joshua Bloch参与编写。本书是Java并发编程领域的里程碑著作！从并发编程的基本理论入手，逐步介绍了在设计Java并发程序时各种重要的设计原则、设计模式与思维模式。另一本蚂蚁金服方腾飞老师写的《Java并发编程的艺术》也适合一并阅读。
限时秒杀链接：点击购买

7.软件架构实践（原书第4版）

【Spring篇】AOP事务管理
让你少走弯路的进阶架构师避坑指南！图书届奥斯卡Jolt大奖双冠王作品！全球10余个国家出版。卡内基梅隆等名校教材，IEEE杂志10佳图书，软件架构图书事实标准。

限时秒杀链接：点击购买

🍓本次送 6本书 ，评论区抽6位小伙伴送书🍓
中奖的小伙伴，从以上10本书籍中任选一本
活动时间：截止到 2023-05-28 10:00:00
抽奖方式：利用程序进行抽奖。
参与方式：关注博主、点赞、收藏，评论区评论 “Java，生日快乐！”

🍓 获奖名单🍓
卡丘. 钦爱
凌晨五点深蓝
ly_stars
我是一盘牛肉
喵果森森
Jmh-Ethereal
名单公布时间： 2023-05-28 10:00:00文章来源地址https://www.toymoban.com/news/detail-457022.html

到了这里，关于【Spring篇】AOP事务管理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • [JavaWeb]【十二】web后端开发-事务管理&AOP

    [JavaWeb]【十二】web后端开发-事务管理&AOP

    目录 一、事务管理 1.1 事务回顾 1.2 Spring事务管理 1.2.1 案例  1.2.1.1 EmpMapper新增deleteByDeptId方法  1.2.1.2 DeptServiceImpl   1.2.1.3 启动服务-测试  1.2.2 模拟异常 1.2.3  分析问题  1.2.4 Spring事务管理（一般用在类似多次delete）  1.2.4.1 开启事务开关application.yml 1.2.4.2  DeptServiceImpl 

    2024年02月11日
    浏览(38)
  • Spring 事务管理方案和事务管理器及事务控制的API

    Spring 事务管理方案和事务管理器及事务控制的API

    目录 一、事务管理方案 1. 修改业务层代码 2. 测试 二、事务管理器 1. 简介 2. 在配置文件中引入约束 3. 进行事务配置 三、事务控制的API 1. PlatformTransactionManager接口 2. TransactionDefinition接口 3. TransactionStatus接口 往期专栏文章相关导读  1. Maven系列专栏文章 2. Mybatis系列专栏文

    2024年02月08日
    浏览(42)
  • spring事务管理详解和实例（事务传播机制、事务隔离级别）

    spring事务管理详解和实例（事务传播机制、事务隔离级别）

    目录 1 理解spring事务 2 核心接口 2.1 事务管理器 2.1.1 JDBC事务 2.1.2 Hibernate事务 2.1.3 Java持久化API事务（JPA） 2.2 基本事务属性的定义 2.2.1 传播行为 2.2.2 隔离级别 2.2.3 只读 2.2.4 事务超时 2.2.5 回滚规则 2.3 事务状态 3 编程式事务 3.1 编程式和声明式事务的区别 3.2 如何实现编程式

    2024年02月06日
    浏览(44)
  • 【Spring】Spring的事务管理

    【Spring】Spring的事务管理

    Spring的事务管理简化了传统的事务管理流程，并且在一定程度上减少了开发者的工作量。 1.1 事务管理的核心接口 在Spring的所有JAR包中包含一个名为Spring-tx-4.3.6.RELEASE的JAR包，该包就是Spring提供的用于事务管理的依赖包。在该JAR包的org.Springframework.transaction包中有3个接口文件：

    2024年02月03日
    浏览(98)

  • Spring的事务管理

    1、事务的回顾 【1】事务的定义 是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作，这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合 【2】事务的ACID原则 事务具有4个基本特性：原子性、一致性

    2023年04月16日
    浏览(76)
  • Spring 事务管理

    Spring 事务管理

    目录 1. 事务管理 1.1. Spring框架的事务支持模型的优势 1.1.1. 全局事务 1.1.2. 本地事务 1.1.3. Spring框架的一致化编程模型 1.2. 了解Spring框架的事务抽象（Transaction Abstraction） 1.2.1. Hibernate 事务设置 1.3. 用事务同步资源 1.3.1. 高级同步方式 1.3.2. 低级同步方式 1.3.3.TransactionAwareDataSo

    2024年02月13日
    浏览(46)
  • Spring之事务管理

    Spring之事务管理

    事务是数据库操作最基本单位，要么都成功，要么都失败。 原子性 一致性 隔离性 持久性。 Spring定义了7种传播行为： 传播属性 描述 REQUIRED 如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行 REQUIRED_NEW 当前的方法必须

    2024年02月13日
    浏览(68)

  • Spring使用@Transactional 管理事务，Java事务详解。

    B站视频：https://www.bilibili.com/video/BV1eV411u7cg 技术文档：https://d9bp4nr5ye.feishu.cn/wiki/HX50wdHFyiFoLrkfEAAcTBdinvh 简单来说事务就是一组对数据库的操作 要么都成功，要么都失败。 事务要保证可靠性，必须具备四个特性：ACID。 A：原子性：事务是一个原子操作单元，要么完全执行，要么

    2024年02月11日
    浏览(31)
  • 【掌握Spring事务管理】深入理解事务传播机制的秘密

    【掌握Spring事务管理】深入理解事务传播机制的秘密

    🎉🎉🎉 点进来你就是我的人了 博主主页： 🙈🙈🙈 戳一戳,欢迎大佬指点! 欢迎志同道合的朋友一起加油喔 🤺🤺🤺 目录 1.Spring 中事务的实现方式 1.1 Spring 编程式事务 (了解) 1.2 Spring 声明式事务 ( @Transactional ) 【异常情况一】(自动回滚成功) 【异常情况二】(自动回滚失效

    2024年02月10日
    浏览(47)

  • Spring中的事务管理

    概念 事务 是一组操作的集合，它是一个不可分割的工作单位，这些操作要么 同时成功 ，要么 同时失败 。 操作 开启事务（一组操作 开始前 ，开启事务) : start transaction / begin ; 提交事务（这组操作 全部成功后 ，提交事务) : commit ; 回滚事务（中间任何一个操作 出现异常 ，

    2024年02月12日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包