在这里插入图片描述

个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
个人主页：.29.的博客
学习社区：进去逛一逛~

在这里插入图片描述

声明式事务

一、编程式事务
二、声明式事务
- 🚀XML配置文件设置
- 🚀声明式事务的使用
三、声明式事务的属性
- ⚪只读
- ⚪超时
- ⚪回滚策略
- ⚪隔离等级
- ⚪传播行为
四、全注解配置事务

一、编程式事务

事务的相关操作都需要我们自己去编写。

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

主要缺陷：

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

二、声明式事务

框架将事务操作固定模式的代码抽取出来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作，可通过注解标注来使用事务。

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

🚀XML配置文件设置

P命名空间 ：

需要新增相关的p命名空间（可直接复制）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

相关设置：

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

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

🚀声明式事务的使用

@Transactional 注解：

我们通过 @Transactional 标签，来声明需要使用事务的位置，

@Transactional 标签既可以声明类，也可以声明方法，

@Transactional 标识在方法上，则只会影响该方法
@Transactional 标识的类上，则会影响类中所有的方法

例如：

/**
 * @author .29.
 * @create 2023-02-28 21:21
 */
@Transactional  //⭐事务声明⭐
@Service        //对象生成，存入IOC容器
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);
    }
}

三、声明式事务的属性

⚪只读

使用：

@Transactional(readOnly = true)

功能:

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

注意:
对增删改操作设置只读会抛出异常：
java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

⚪超时

使用：

@Transactional(timeout = 3)//数字3代表时间限制三秒

功能:

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。这大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，当事务执行超过我们设置的时间，就回滚事务，撤销它已做的操作，事务结束，释放资源。

结果:
超时回滚，抛出异常
org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was…

⚪回滚策略

使用：

@Transactional(rollbackFor = .class)

@Transactional(noRollbackFor = .class)

@Transactional(rollbackForClassName = 全类名)

@Transactional(noRollbackForClassName= 全类名)

功能：

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

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

 rollbackFor* :可让原本不回滚的回滚；
 noRollbascFor* :可让原本会回滚的不回滚

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

⚪隔离等级

使用：

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

功能：

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

读未提交：READ_UNCOMMITTED
允许Transaction01读取Transaction02未提交的修改。
读已提交：READ_COMMITTED、
要求Transaction01只能读取Transaction02已提交的修改。
可重复读：REPEATABLE_READ
确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。
串行化：SERIALIZABLE
确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

在这里插入图片描述

 👆  隔离级别处理并发问题的能力，及数据库对其支持程度；👆

⚪传播行为

使用：
通过@Transactional中的propagation属性设置事务传播行为

@Transactional(propagation = Propagation.REQUIRED)

@Transactional(propagation = Propagation.SUPPORTS)

@Transactional(propagation = Propagation.MANDATORY)

@Transactional(propagation = Propagation.REQUIRES_NEW)

@Transactional(propagation = Propagation.NOT_SUPPORTED)

@Transactional(propagation = Propagation.NEVER)

@Transactional(propagation = Propagation.NESTED)

功能：
在service类中有a()方法和b()方法，a()方法上有事务，b()方法上也有事务，当a()方法执行过程中调用了b()方法，事务是如何传递的？合并到一个事务里？还是开启一个新的事务？这就是事务传播行为。

一共有七种传播行为：

REQUIRED：支持当前事务，如果不存在就新建一个(默认)
SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
MANDATORY：必须运行在一个事务中，如果当前没有事务正在发生，将抛出一个异常
REQUIRES_NEW：开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起
NOT_SUPPORTED：以非事务方式运行，如果有事务存在，挂起当前事务
NEVER：以非事务方式运行，如果有事务存在，抛出异常
NESTED：如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于外层事务进行提交或回滚。如果外层事务不存在，行为就像REQUIRED一样。

四、全注解配置事务

案例：

配置类：

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;


/**
 * @author .29.
 * @create 2023-03-01 8:36
 */
@Configuration   //标记为Spring配置类
@ComponentScan("com.haojin.spring")  //设置扫描的包
public class SpringConfig {
    @Bean  //标记存放至IOC容器中的方法
    public DataSource getDataSource(){  //获取数据源对象的方法
        DruidDataSource druidDataSource = new DruidDataSource();
        //设置用于连接数据库的 用户 密码 url 驱动
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring?characterEncoding=utf-8&useSSL=false");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("abc123");
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        return druidDataSource;
    }

    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){  //获取JdbcTemplate对象的方法
        JdbcTemplate jdbcTemplate = new JdbcTemplate();          //JdbcTemplate是spring封装的，实现jdbc相关操作类
        jdbcTemplate.setDataSource(dataSource);                  //设置数据源
        return jdbcTemplate;
    }

    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){ //获取事务管理器的方法
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(); //获取DataSourceTransactionManager对象
        dataSourceTransactionManager.setDataSource(dataSource);               //为其设置数据源对象
        return dataSourceTransactionManager;
    }
}

测试：

import com.haojin.spring.controller.BookController;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author .29.
 * @create 2023-03-01 8:48
 */
public class TxAllAnnotationTest {

    @Test
    public void test1(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookController bookController = context.getBean("bookController", BookController.class);
        bookController.buyBook(2,2);
    }
}