java中单边事务 java独立事务

转载

码海探险先锋 2023-12-14 16:26:18

文章标签 java中单边事务 java spring 数据库 bc 文章分类 Java 后端开发

1、事务

1.1 什么是事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操
作都失败
（2）典型场景：银行转账
* lucy 转账 100 元给 mary
* lucy 少 100，mary 多 100

1.2 事务四个特性（ACID）

原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
⚫ 一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
⚫ 持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

2、编程式事务

事务功能的相关操作全部通过自己编写代码来实现：

Connection conn = ...; 
  
      
  
 try { 
  
      
  
    
   // 开启事务：关闭事务的自动提交 
  
     conn.setAutoCommit(false); 
  
      
  
核心操作 
  
      
  
   
     // 提交事务 
  
     conn.commit(); 
  
      
  
 }catch(Exception e){ 
  
      
  
    
    // 回滚事务 
  
     conn.rollBack(); 
  
      
  
 }finally{ 
  
      
  
    // 释放数据库连接 
  
     conn.close(); 
  
      
  
 }

编程式的实现方式存在缺陷：

细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。
代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

3、声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

好处1：提高开发效率
好处2：消除了冗余的代码
好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化

所以，我们可以总结下面两个概念：
编程式：自己写代码实现功能
声明式：通过配置让框架实现功能

4、事务管理器

① 事务管理器使用场景
无论使用Spring的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的事务管理器是Spring的核心事务管理抽象，管理封装了一组独立于技术的方法
② @Transactional 注解的事务管理。
默认配置下 Spring 只会回滚运行时、未检查异常(继承自 RuntimeException 的异常)或者 Error。
@Transactional 注解只能应用到 public 方法才有效。
使用mybatis ， spring boot 会自动配置一个 DataSourceTransactionManager，只需在方法(或者类)加上 @Transactional 注解，就自动纳入 Spring 的事务管理了。
③ 技术体系
DataSourceTransactionManager，整合 Mybatis 用的也是这个类。

DataSourceTransactionManager类中的主要方法：
doBegin()：开启事务
doSuspend()：挂起事务
doResume()：恢复挂起的事务
doCommit()：提交事务
doRollback()：回滚事务

5、基于注解的声明式事务

5.1、准备工作

① 加入依赖

<dependencies>

		<!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.3.1</version>
		</dependency>

		<!-- Spring 持久化层支持jar包 -->
		<!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个jar包 -->
		<!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>5.3.1</version>
		</dependency>

		<!-- Spring 测试相关 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>5.3.1</version>
		</dependency>

		<!-- junit测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<!-- MySQL驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.27</version>
		</dependency>
		<!-- 数据源 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.31</version>
		</dependency>

	</dependencies>

② 创建jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=root

③ 配置Spring的配置文件

<!-- 扫描组件 -->
	<context:component-scan base-package="com.chenyixin.ssm.annotation"/>

	<!-- 导入外部属性文件 -->
	<!-- classpath: 表示类路径 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>

	<!-- 配置数据源 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>

	<!-- 配置 JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<!-- 装配数据源 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

④ 创建表

USE `ssm`;

CREATE TABLE `t_book` (
	`book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
	`book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
	`price` int(11) DEFAULT NULL COMMENT '价格',
	`stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
	PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) 
values (1,'斗破苍穹',80,100),(2,'斗罗大陆',50,100);

CREATE TABLE `t_user` (
	`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
	`username` varchar(20) DEFAULT NULL COMMENT '用户名',
	`balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

insert into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);

⑤ 创建组件

创建 BookController ：

@Controller
public class BookController {

    @Autowired
    private BookService bookService;

    public void buyBook(Integer bookId, Integer userId) {
        bookService.buyBook(bookId,userId);
    }
}

创建接口 BookService ：

public interface BookService {
    void buyBook(Integer bookId, Integer userId);
}

创建实现类 BookServiceImpl ：

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;
    @Override
    public void buyBook(Integer bookId, Integer userId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId,price);
    }
}

创建接口 BookDao ：

public interface BookDao {
    Integer getPriceByBookId(Integer bookId);

    void updateStock(Integer bookId);

    void updateBalance(Integer userId,Integer price);

}

创建实现类BookDaoImpl：

@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class,bookId);
    }

    @Override
    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock -1 where book_id = ?";
        jdbcTemplate.update(sql, bookId);
    }

    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql = "update from t_user set balance = balance - ? where user_id = ?";
        jdbcTemplate.update(sql, price, userId);
    }
}

5.2、测试无事务情况

① 创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml")
public class TxByAnnotationTest {

    @Autowired
    private BookController bookController;

    @Test
    public void testBuyBook() {
        bookController.buyBook(1, 1);
    }

}

② 模拟场景

用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额

假设用户 id 为 1 的用户，购买 id 为 1 的图书

用户余额为 50 ，而图书价格为 80

购买图书之后，用户的余额为 -30 ，数据库中余额字段设置了无符号，因此无法将 -30 插入到余额字段

此时执行 sql 语句会抛出 SQLException

③ 观察结果

因为没有添加事务，图书的库存更新了，但是用户的余额没有更新

显然这样的结果是错误的，购买图书是一个完整的功能，更新库存和更新余额要么都成功要么都失败

5.3、加入事务

① 添加事务配置

在 Spring 的配置文件中添加配置：

<!--配置事务管理器-->
	<bean id="transactionManager"
		  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!--
	开启事务的注解驱动
	通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务
	-->
	<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就
	是这个默认值，则可以省略这个属性 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

注意：导入的名称空间需要 tx 结尾的那个。

② 添加事务注解

因为 service 层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在 service 层处理

在 BookServiceImpl 的 buybook() 添加注解 @Transactional

@Service
@Transactional
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;
    @Override
    // @Transactional
    public void buyBook(Integer bookId, Integer userId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId,price);
    }
}

③ 测试

/**
 * 声明式事务的配置步骤：
 * 1、在Spring的配置文件中配置事务管理器
 * 2、开始事务的注解驱动
 * 在需要被事务管理的方法上，添加@Transaction注解，该方法就会被事务管理
 *
 * @Transaction注解标识的位置：
 * ① 标识在方法上
 * ② 标识在类上，则类中所有的方法都会被事务管理
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml")
public class TxByAnnotationTest {

    @Autowired
    private BookController bookController;

    @Test
    public void testBuyBook() {
        bookController.buyBook(1, 1);
    }

}

④ 观察测试结果

由于使用了Spring的声明式事务，更新库存和更新余额都没有执行

6、事务属性

注解@Transactional 或 xml文件tx中 attributes 属性中，可以配置事务相关参数（属性）：

java中单边事务 java独立事务_数据库_02

6.1 只读

① 介绍

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

只读
（ 1 ）读：查询操作，写：添加修改删除操作
（2） readOnly 默认值 false ，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true ，设置成 true 之后，只能查询
如果一个事务只对数据库执行读操作，那么该数据库就可能利用那个事务的只读特性，采取某些优化措施。通过把一个事务声明为只读，可以给后端数据库一个机会来应用那些它认为合适的优化措施。由于只读的优化措施是在一个事务启动时由后端数据库实施的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、 ROPAGATION_NESTED）的方法来说，将事务声明为只读才有意义。

② 设置方式

@Override
    @Transactional(readOnly = true)
    public void buyBook(Integer bookId, Integer userId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId,price);
    }

③ 针对增删改操作设置只读

会抛出下面异常：

java中单边事务 java独立事务_数据库_03

6.2、超时

① 需求

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

② 使用方式

@Override
    @Transactional(
            // readOnly = true
            timeout = 3
    )
    public void buyBook(Integer bookId, Integer userId) {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId, price);
    }

TIP
PS：注意：sleep操作如果放在执行 SQL 语句后面那就不起作用。

③ 观察结果

执行过程中抛出异常：

java中单边事务 java独立事务_spring_04

6.3、回滚和不回滚的异常

① 介绍

声明式事务默认只针对运行时异常回滚，编译时异常不回滚。

可以通过@Transactional中相关属性设置回滚策略

rollbackFor属性：需要设置一个Class类型的对象
rollbackForClassName属性：需要设置一个字符串类型的全类名
noRollbackFor属性：需要设置一个Class类型的对象
noRollbackForClassName属性：需要设置一个字符串类型的全类名

② 使用方式

@Override
    @Transactional(
            // readOnly = true
            // timeout = 3
            // noRollbackFor = ArithmeticException.class
            noRollbackForClassName = "java.lang.ArithmeticException"
    )
    public void buyBook(Integer bookId, Integer userId) {
        /*try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }*/
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId, price);
        
        //  抛出运行时异常测试是否回滚
        System.out.println(1 / 0);
    }
}

③ 观察结果

虽然购买图书功能中出现了数学运算异常（ ArithmeticException ），但是我们设置的回滚策略是，当出现ArithmeticException 不发生回滚，因此购买图书的操作正常执行

6.4、事务隔离级别

① 介绍

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL 标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

事务的隔离级别定义一个事务可能受其他并发务活动活动影响的程度，可以把事务的隔离级别想象为这个事务对于事物处理数据的自私程度。
在一个典型的应用程序中，多个事务同时运行，经常会为了完成他们的工作而操作同一个数据。并发虽然是必需的，但是会导致以下问题：
脏读（Dirty read）
脏读发生在一个事务读取了被另一个事务改写但尚未提交的数据时。如果这些改变在稍后被回滚了，那么第一个事务读取的数据就会是无效的。

不可重复读（Nonrepeatable read）
不可重复读发生在一个事务执行相同的查询两次或两次以上，但每次查询结果都不相同时。这通常是由于另一个并发事务在两次查询之间更新了数据。不可重复读重点在修改。

幻读（Phantom reads）
幻读和不可重复读相似。当一个事务（T1）读取几行记录后，另一个并发事务（T2）插入了一些记录时，幻读就发生了。在后来的查询中，第一个事务（T1）就会发现一些原来没有的额外记录。幻读重点在新增或删除。
在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常涉及到锁定在数据库中的记录（甚至有时是锁表）。完全隔离要求事务相互等待来完成工作，会阻碍并发。因此，可以根据业务场景选择不同的隔离级别。

在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常涉及到锁定在数据库中的记录（甚至有时是锁表）。完全隔离要求事务相互等待来完成工作，会阻碍并发。因此，可以根据业务场景选择不同的隔离级别。

② 隔离级别一共有四种

         读未提交：READ UNCOMMITTED

                允许Transaction01读取 Transaction02 未提交的修改。（会导致脏读）

         读已提交：READ COMMITTED

                要求Transaction01只能读取Transaction02已提交的修改。（会导致不可重复度）

         可重复读：REPEATABLE READ

                确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。（会导致幻读）

         串行化：SERIALIZABLE

                确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

各个隔离级别解决并发问题的能力见下表：

java中单边事务 java独立事务_数据库_07

各种数据库产品对事务隔离级别的支持程度：

java中单边事务 java独立事务_数据库_08

③ 使用方式

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别 
@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交 
@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交 
@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读 
@Transactional(isolation = Isolation.SERIALIZABLE)//串行化

6.5、事务传播行为

① 介绍

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中

运行，也可能开启一个新事务，并在自己的事务中运行。

事务的传播性一般用在事务嵌套的场景，比如一个事务方法里面调用了另外一个事务方法，那么两个方法是各自作为独立的方法提交还是内层的事务合并到外层的事务一起提交，这就是需要事务传播机制的配置来确定怎么样执行。

② 常用的事务传播机制

事务	功能
REQUIRED	Spring默认的传播机制，能满足绝大部分业务需求，如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。如果外层没有事务，新建一个事务执行
REQUES_NEW	该事务传播机制是每次都会新开启一个事务，同时把外层事务挂起，当当前事务执行完毕，恢复上层事务的执行。如果外层没有事务，执行当前新开启的事务即可
SUPPORT	如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务
NOT_SUPPORT	该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码
NEVER	该传播机制不支持外层事务，即如果外层有事务就抛出异常
MANDATORY	与NEVER相反，如果外层没有事务，则抛出异常
NESTED	该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚的。传播规则回答了这样一个问题：一个新的事务应该被启动还是被挂起，或者是一个方法是否应该在事务性上下文中运行。

③ 测试

创建接口 CheckoutService ：

public interface CheckoutService {
    void checkout(Integer userId, Integer[] bookIds);
}

创建实现类CheckoutServiceImpl：

@Service
public class CheckoutServiceImpl implements CheckoutService {

    @Autowired
    private BookService bookService;
    @Override
    @Transactional
    public void checkout(Integer userId, Integer[] bookIds) {
        for (Integer bookId : bookIds) {
            bookService.buyBook(bookId,userId);
        }
    }
}

在 BookController 中添加方法：

@Autowired 
private CheckoutService checkoutService; 

public void checkout(Integer[] bookIds, Integer userId){ 
    checkoutService.checkout(bookIds, userId); 
}

在数据库中将用户的余额修改为100元

③ 观察结果

可以通过@Transactional 中的propagation属性设置事务传播行为修改BookServiceImpl中buyBook()上，注解@Transactional的propagation属性@Transactional(propagation = Propagation.REQUIRED)，默认情况，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。

经过观察，购买图书的方法buyBook()在checkout()中被调用，checkout()上有事务注解，因此在此事务中执行。所购买的两本图书的价格为80和50，而用户的余额为100，因此在购买第二本图书时余额不足失败，导致整个checkout()回滚，即只要有一本书买不了，就都买不了

@Transactional(propagation = Propagation.REQUIRES_NEW)，表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在buyBook()的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的buyBook()中回滚，购买第一本图书不受影响，即能买几本就买几本

7、基于XML的声明式事务

7.1、场景模拟

参考基于注解的声明式事务

7.2、添加新依赖

基于xml实现的声明式事务，必须引入aspectJ的依赖

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>5.3.1</version>
		</dependency>

7.3、Spring配置文件

<!-- 扫描组件 -->
	<context:component-scan base-package="com.chenyixin.ssm.xml"/>

	<!-- 导入外部属性文件 -->
	<!-- classpath: 表示类路径 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>

	<!-- 配置数据源 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>

	<!-- 配置 JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<!-- 装配数据源 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

	<!--配置事务管理器-->
	<bean id="transactionManager"
		  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>

	<!-- tx:advice标签：配置事务通知 -->
	<!-- id属性：给事务通知标签设置唯一标识，便于引用 -->
	<!-- transaction-manager属性：关联事务管理器 -->
	<tx:advice id="tx" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- tx:method标签：配置具体的事务方法 -->
			<!-- name属性：指定方法名，可以使用星号代表多个字符 -->
			<!-- read-only属性：设置只读属性 -->
			<!-- rollback-for属性：设置回滚的异常 -->
			<!-- no-rollback-for属性：设置不回滚的异常 -->
			<!-- isolation属性：设置事务的隔离级别 -->
			<!-- timeout属性：设置事务的超时属性 -->
			<!-- propagation属性：设置事务的传播行为 -->
			<tx:method name="get*" read-only="true"/>
			<tx:method name="buy*" read-only="false"/>
			<!--
			即使需要事务功能的目标方法已经被切入点表达式涵盖到了，但是如果没有给它配置事务属性，
			那么这个方法就还是没有事务。所以事务属性必须配置。
			-->
			<tx:method name="*"/><!-- 将切入点中的所有方法都关联事务 -->
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<!-- 配置切入点表达式，将事务功能定位到具体方法上 -->
		<aop:advisor advice-ref="tx" pointcut="execution(* com.chenyixin.ssm.xml.service.impl.*.*(..))"/>
	</aop:config>

注意

即使需要事务功能的目标方法已经被切入点表达式涵盖到了，但是如果没有给它配置事务属性，那么这个方法就还是没有事务。所以事务属性必须配置。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：android 图片设置磨砂效果手机磨砂图片怎么做的

下一篇：java并发新增版本 java如何提高并发

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯