Spring 事务管理

一、事务简介

1.事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.

2.事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用

3.事务的四个关键属性

1.3.1 原子性

事务是一个原子操作，由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.

1.3.2 一致性

一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.

1.3.3 隔离性

可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.

1.3.4 持久性

一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

二、Spring中的事务管理

Spring既支持编程式事务管理，也支持声明式事务管理。

2.1 编程式事务管理

将事务管理嵌入到业务方法中来控制事务的提交和回滚。在编程式事务管理时，必须在每个事物操作中包含额外的事务管理代码。

1. 取消事务的自动提交 conn.setAutoCommit(false)；

2. 执行业务操作;

3. catch块 发生异变时，回滚 conn.rollback();

4. finally块 必执行，提交 conn.commit()、conn.setAutoCommit(true)

 2.2  声明式事务管理

@Transcational 对原有的业务逻辑实现增强事务操作

原理：1：默认使用JDK动态代理、若没有出现接口或者@EnableTransactionManagement(proxyTargetClass = true)；2：基于AOP完成对业务逻辑的事务操作 TransactionAspectSupport事务管理切面 invokeWithinTransaction() 异常通知、返回通知+执行目标方法

三、@Transactional 注解+配置类 声明式管理事务

1.修改pom.xml文件

<!-- 引入spring的JDBC依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.13</version>
</dependency>

<!--mysql驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

<!--c3p0 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

<!-- 单元测试 -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.10</version>
</dependency>

2. 添加配置类

@ComponentScan(basePackages = "com.igeek.ch27.config")
@PropertySource("db.properties")
//开启事务管理器
@EnableTransactionManagement(proxyTargetClass = true)
public class MyConfig {

    //数据源
    @Bean
    public DataSource dataSource(
            @Value("${db.user}") String username,
            @Value("${db.password}") String password,
            @Value("${db.url}") String jdbcUrl,
            @Value("${db.driverClass}") String driverClass,
            @Value("${db.maxPoolSize}") int maxPoolSize
    ) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(username);
        dataSource.setPassword(password);
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setDriverClass(driverClass);
        dataSource.setMaxPoolSize(maxPoolSize);
        return dataSource;
    }

    //JdbcTemplate
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        return jdbcTemplate;
    }

    //事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        PlatformTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}


//db.properties文件
#mysql
db.user=root
db.password=root
db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
db.driverClass=com.mysql.cj.jdbc.Driver
db.maxPoolSize=30
db.minPoolSize=3
db.initialPoolSize=5
db.acquireIncrement=5

3. Dao层 与 自定义异常类

//Dao层接口
public interface IBookShopDao {

	//根据bookId获取书的价格
	public int selectPrice(int bookId);
	//根据bookId更新库存
	public void updateStock(int bookId);
	//根据username,price更新账户余额
	public void updateBalance(String username, int price) throws AccountException;
	
}

//Dao层实现类
@Repository
public class BookShopDaoImpl implements IBookShopDao {

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

	@Override
	public void updateStock(int bookId) {
		String s = "select stock from t_stock where bookId=?";
		int stock = jdbcTemplate.queryForObject(s, Integer.class, bookId);
		if(stock<=0){
			throw new BookStockException("库存不足!!!");
		}
		
		String sql = "update t_stock set stock=stock-1 where bookId=?";
		jdbcTemplate.update(sql, bookId);
	}

	@Override
	public void updateBalance(String username, int price) throws AccountException {
		String s = "select balance from t_account where username=?";
		Integer balance = jdbcTemplate.queryForObject(s, Integer.class, username);
		if(balance<price){
			throw new AccountException("账户余额不足!!!");
		}
		
		String sql = "update t_account set balance=balance-? where username=?";
		jdbcTemplate.update(sql, price,username);
	}

}

//自定义异常
//1.extends Exception
// 	1.1 编译期异常，强制需要进行处理
// 	1.2 事务不能进行回滚
//2.extends RuntimeException
//  2.1 运行期异常，无需强制进行处理
//  2.2 一旦发生运行期异常，事务可以正常回滚
public class AccountException extends RuntimeException{

	public AccountException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public AccountException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public AccountException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public AccountException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public AccountException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
}


public class BookStockException extends RuntimeException{

	public BookStockException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BookStockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public BookStockException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public BookStockException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public BookStockException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
	
}

4.Service层

接口类

public interface IBookShopService {

	//通过账户名及书号购买书
	public void purchase(String username, int bookId) throws AccountException, IOException;
}

public interface ICashierService {

	//客户的结账
	public void cash(String username, List<Integer> bookIds) throws AccountException, IOException;
}

实现类：添加@Transactional注解与@Service注解

//@Transactional注解标注在类上，代表当前类中所有的方法都受Spring事务管理
//@Transactional
@Service
public class CashierServiceImpl implements ICashierService {
	@Autowired
	private IBookShopService bookShopService;
	
	public void setBookShopService(IBookShopService bookShopService) {
		this.bookShopService = bookShopService;
	}


	@Transactional
	@Override
	public void cash(String username, List<Integer> bookIds) throws AccountException, IOException {
		for (Integer bookId : bookIds) {
			bookShopService.purchase(username, bookId);
		}
	}

}

@Service
public class BookShopServiceImpl implements IBookShopService {
	@Autowired
	private IBookShopDao bookShopDao;
	
	public void setBookShopDao(IBookShopDao bookShopDao) {
		this.bookShopDao = bookShopDao;
	}

	/**
	 * 注解@Transactional  当前方法受事务管理
	 * 1.propagation属性：传播行为，当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播
	 * 默认使用Propagation.REQUIRED，会在现有的事务内运行
	 * 使用Propagation.REQUIRES_NEW，表示该方法必须启动一个新事务, 并在自己的事务内运行. 如果有事务在运行, 就应该先挂起它.
	 * 2.isolation属性：隔离级别
	 * MySQL数据库默认使用REPEATABLE_READ
	 * Oracle数据库默认使用READ_COMMITTED
	 * 3.timeout属性：超时时间，单位s
	 * 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.
	 * 4.readOnly属性：只读属性
	 * readOnly = true，一般搭配select查询业务使用，表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.
	 * 5.rollbackFor  指定会发生回滚
	 * noRollbackFor  指定不会发生回滚
	 * 默认情况下Spring会捕获RuntimeException和Error
	 */
	@Transactional(
			propagation = Propagation.REQUIRES_NEW,
			isolation = Isolation.READ_COMMITTED,
			timeout = 2,
			readOnly = false,
			rollbackFor = IOException.class,
			noRollbackFor = ArithmeticException.class
	)
	@Override
	public void purchase(String username, int bookId) throws AccountException, IOException {
		//测试超时时间属性  TransactionTimedOutException: Transaction timed out: deadline was Sun May 26 11:03:03 CST 2024
		/*try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}*/

		int price = bookShopDao.selectPrice(bookId);
		bookShopDao.updateStock(bookId);
		bookShopDao.updateBalance(username, price);

		//测试发生异常情况  运行期异常，正常来说会造成事务回滚
		int i = 10/0;

		//测试发生异常情况  编译期异常，正常来说不会造成事务回滚
		//throw new IOException();
	}

}

 

5.用 @Transactional 注解声明式管理事务

除了在带有切入点，通知和增强器的Bean配置文件中声明事务外, Spring 还允许简单地用 @Transactional 注解来标注事务方法。

为了将方法定义为支持事务处理的, 可以为方法添加 @Transactional 注解. 根据 Spring AOP 基于代理机制, 只能标注公有方法。

可以在方法或者类级别上添加 @Transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的。

5.1 事务传播属性（propagation）

当事务方法被另一个书屋方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

事务的传播行为可以由传播属性指定。事务的传播实现可以在 @Transactional 注解的 propagation 属性中定义

5.1.1 REQUIRED：如果有事务在运行，当前的方法就在这个事务运行内运行，否则，就启动一个新的事务，并在自己的事务内运行。

例如当购买方法purchase() 被另一个事务方法 checkout() 调用时, 它默认会在现有的事务内运行。这个默认的传播行为就是 REQUIRED. 因此在 checkout() 方法的开始和终止边界内只有一个事务. 这个事务只在 checkout() 方法结束的时候被提交。

5.1.2 REQUIRED_NEW：当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起。

5.2 事务的隔离级别 （isolation）

并发事务所导致的问题。当同一个应用程序或者不同应用程序的多个事务在同一个数据集上并发执行，肯会出现很多问题。具体可以分为脏读、不可重复读、幻读三种情况。

脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的。

不可重复读:对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了。

幻读:对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行。

从理论说，应该使用高级别的事务隔离，但是实际开发中为了提升性能，事务会从较低的隔离级别运行，事务的隔离级别可以通过隔离事务属性 isolation 指定。Spring支持的事务隔离级别可以分为：

5.2.1 DEAULT

使用底层数据库的默认隔离级别，对于大多数数据库来说，默认隔离级别都是READ_COMMTED

5.2.2  READ_UNCOMMTTED

允许事务读取未被其他事务提交的变更，脏读、不可重复读、幻读的问题都会出现，Oracle数据库默认使用READ_COMMITTED。

5.2.3 READ_COMMTTED

只允许事务读取已经被其他事务提交的变更，可以避免脏读 ，但不可重复读、幻读问题仍然可能出现。

5.2.4 REPEATABLE_READ

确保事务可以多次从一个字段中读取相同的值。在这个书屋持续期间，禁止其他事务对这个字段进行更新，可以避免脏读和不可重复读，但幻读的问题仍然存在。MySQL数据库默认使用REPEATABLE_READ。

5.2.5 SERIALIZABLE

确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他书屋对该表执行插入，更新和删除操作，所以的并发问题都可以解决但是性能十分低下。

事务的隔离级别要得到底层数据库引擎的支持，而不是应用程序或者框架的支持Oracle 支持的 2 种事务隔离级别：READ_COMMITED , SERIALIZABLE。Mysql 支持以上 4种事务隔离级别.

5.3 设置回滚事务属性（rollbackFor，noRollbackFor）

默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚. 而受检查异常不会。

事务的回滚规则可以通过@Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义. 这两个属性被声明为 Class[] 类型的, 因此可以为这两个属性指定多个异常类 。rollbackFor:遇到时，必须回滚；noRollbackFor:不会发生回滚。

5.4 超时（timeout）和只读（readOnly）属性

由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响，如果一个事务只读取数据但不修改，数据库引擎就可以对这个事务进行优化。

超时事务属性: timeout属性，事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源。

只读事务属性: readOnly属性为true时，表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务。

超时和只读属性可以在 @Transactional 注解中定义.超时属性以秒为单位来计算。