Spring 学习笔记04 - 事务管理

最新推荐文章于 2024-08-18 23:25:39 发布

什么样的人不睡觉

最新推荐文章于 2024-08-18 23:25:39 发布

阅读量203

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/O____OZzz/article/details/105892428

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

事务概述

什么是事务

举个栗子，小明给小华转账，操作流程大致分为二步：1.小明执行转账，余额减少；2.小华收款，账户余额增加。
其中转账就是一个事务，而这个事务由二个操作组成。总的来说,事务是一系列操作组成的工作单元，该工作单元内的操作是不可分割的，即所有操作执行必须成功完成，否则在每个操作所做的更改将会被撤销。

事务的特性（ACID）

原子性（Atomicity）：事务必须是原子工作单元，由一系列操作组成。事务的原子性确保操作要么全都执行，要么全都不执行。
一致性（Consistency）：:事务执行前和执行后必须使所有的数据都保持一致状态.例如:转账事务执行前后,两账户余额的总和不变.。
隔离性（Isolation）:可能有多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离。
持久性（Durability）：事务完成之后，它对数据库数据的改变是永久性的，该修改即使出现致命的系统故障也将一直保持。

事务的隔离级别

事务的隔离级别是为了解决并发问题，分为四种，隔离级别由低到高分别为：

read uncommited：读未提交，是最低的事务隔离级别，它允许其它事务可以看到这个事务未提交的数据。
read commited：读已提交（Oracle 数据库默认隔离级别），保证一个事务不会读到其它事务已修改但未提交的数据。
repeatable read：可重复读（Mysql 数据库默认的隔离级别），保证同一事务先后执行的多次查询将返回同一结果，不受其它事务影响。
serializable：序列化，是花费最高代价但最可靠的事务隔离级别。不允许事务并发执行，强制事务串行执行。

事务隔离级别	脏读	不可重复读	幻读
读未提交（read-uncommitted）	✓	✓	✓
读已提交（read-committed）	✕	✓	✓
隔离性（Isolation）	✕	✕	✓
持久性（Durability）	✕	✕	✕

脏读: 一个事务读到其它事务还未提交(可能被回滚)的脏数据。
不可重复读: 一个事务多次读取同一数据期间(多次查询同一张表)，其他事务修改了该数据，导致第一个事务前后两次查询结果不一致。
幻读: 一个事务执行期间其它事务提交添加数据,导致第一个事务前后两次查询结果到的数据条数不同。

Spring 事务管理 API

事务管理，就是按照给定的事务规则来执行提交或者回滚操作。Spring 框架中，最重要的事务管理的 API 有三个：TransactionDefinition、PlatformTransactionManager 和 TransactionStatus。

PlatformTransactionManager 事务管理器

PlatformTransactionManager 是 Spring 事务管理的核心接口。主要功能是事务管理器，该接口的源代码如下：

public interface PlatformTransactionManager {
	//获取事务状态
    TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
	//事务提交
    void commit(TransactionStatus var1) throws TransactionException;
	//事务回滚
    void rollback(TransactionStatus var1) throws TransactionException;
}

PlatformTransactionManager 接口有许多不同的实现类，应用程序面向与平台无关的接口编程，而对不同平台的底层支持由此接口的实现类完成，故而应用程序无须与具体的事务 API 耦合。在实际开发中我们常使用的实现类有：

org.springframework.jdbc.datasource.DataSourceTransactionManager ：使用 SpringJDBC 或 iBatis 进行持久化数据时使用；
org.springframework.orm.hibernate5.HibernateTransactionManager ：使用 Hibernate 版本进行持久化数据时使用；

TransactionStatus 事务状态

在上面 PlatformTransactionManager 接口中，有如下方法：

 TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;

这个方法返回的是 TransactionStatus对象，然后程序根据返回的对象来获取事务状态，然后进行相应的操作，该接口的源代码如下：

public interface TransactionStatus extends SavepointManager, Flushable {
	//查询是否是新事务
    boolean isNewTransaction();
	//查询是否存在存储点
    boolean hasSavepoint();
	//设置事务回滚
    void setRollbackOnly();
	//查询事务是否回滚
    boolean isRollbackOnly();
	//刷新事务
    void flush();
	//查询事务是否完成
    boolean isCompleted();
}

TransactionDefinition 基本事务属性的定义

TransactionDefinition 接口用于定义事务信息，它包含了一些事务的相关属性，Spring 还为我们提供了一个默认的实现类：DefaultTransactionDefinition，该类适用于大多数情况。TransactionDefinition接口包含与事务属性相关的方法，如下：

public interface TransactionDefinition {
	//获取事务传播行为
    int getPropagationBehavior();
	//获取事务隔离级别
    int getIsolationLevel();
	//获取事务超时时间
    int getTimeout();
	//获取事务是否只读
    boolean isReadOnly();
	//获取事务对象名称
    String getName();
}

事务传播行为：事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有>若干选项可以指定一个事务性方法的执行行为，常用的是 REQUIRED 和 SUPPORTS：

REQUIRED：Spring 默认事务传播行为.若当前存在事务，则加入该事务；若当前没有事务，则创建一个新的事务，增删改查操作均可用。
SUPPORTS：若当前存在事务，则加入该事务；若当前没有事务，则以非事务的方式继续运行，查询操作可用。
MANDATORY：若当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
REQUERS_NEW：创建一个新的事务，若当前存在事务，则把当前事务挂起。
NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
NESTED：若当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;若当前没有事务,则执行 REQUIRED 类似的操作。

事务隔离级别：事务的隔离级别是指若干个并发的事务之间的隔离程度，事务的隔离级别由弱到强,依次有如下五种：

ISOLATION_DEFAULT：Spring 事务管理的的默认级别，使用数据库默认的事务隔离级别。
ISOLATION_READ_UNCOMMITTED：读未提交.
ISOLATION_READ_COMMITTED：读已提交.
ISOLATION_REPEATABLE_READ：可重复读.
ISOLATION_SERIALIZABLE：序列化

事务超时：事务超时是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。Spring 默认设置事务的超时时间为-1，表示永不超时，也可自行设置，在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。

事务是否只读：事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。

使用 XML 配置实现事务

模拟实现一个转账业务，
依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.7.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

实体类 Account

public class Account implements Serializable {
    private Integer id;
    private String name;
    private float money;
	...
	//此处省略 getter setter toStirng
}

持久层接口和实现类

public interface AccountDao {
    /**
     * 根据名称查询账户
     * @param name
     * @return
     */
    Account queryAccountByName(String name);

    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
}

public class AccountDaoImpl implements AccountDao {
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Account queryAccountByName(String name) {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (accounts.isEmpty()) {
            return null;
        }
        if (accounts.size() > 1) {
            throw new RuntimeException("查询结果不唯一");
        }
        return accounts.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name = ?, money = ? where id = ?", account.getName(), account.getMoney(), account.getId());
    }
}

业务层接口和实现类

public interface AccountService {
    /**
     * 根据名称查询账户
     * @param name
     * @return
     */
    Account queryAccountByName(String name);

    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 转账
     * @param sourceName    转出账户
     * @param targetName    转入账户
     * @param money         交易金额
     */
    void transfer(String sourceName, String targetName, float money);
}

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    
    @Override
    public Account queryAccountByName(String name) {
        return accountDao.queryAccountByName(name);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void transfer(String sourceName, String targetName, float money) {
        //1.根据名称查询转出账户
        Account source = accountDao.queryAccountByName(sourceName);
        //2.根据名称查询转入账户
        Account target = accountDao.queryAccountByName(targetName);
        //3.转出账户金额减少
        source.setMoney(source.getMoney() - money);
        //4.转入账户金额增加
        target.setMoney(target.getMoney() + money);
        //5.更新转出账户
        accountDao.updateAccount(source);
        int i = 1/0;
        //6.更新转入账户
        accountDao.updateAccount(target);
    }
}

在 applicationContext.xml 中配置 Spring 容器需要管理的对象

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
        
    <bean id="accountService" class="com.hn.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    
    <bean id="accountDao" class="com.hn.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

Spring 配置事务控制本质上是基于 AOP 的,因此下面我们在 applicationContext.xml 中配置事务管理器对象并和 AOP 配置建立联系.

    <!-- Spring 事务控制 -->
    <!-- 1.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 2.配置事务通知 引用事务管理器-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事务的属性 -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="query*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!-- 3.配置 AOP -->
    <aop:config>
        <!-- 配置切入点表达式 -->
        <aop:pointcut id="pcService" expression="execution(* com.hn.service.impl.*.*(..))"/>
        <!-- 4.切入点表达式和事务通知建立关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pcService"></aop:advisor>
    </aop:config>
</beans>

<tx:advice>标签：配置事务通知

id：事务通知的唯一标识
transaction-manager：该通知对应的事务管理器

<tx:attributes> 标签下的<tx:method> 标签,为切面上的方法配置事务属性,<tx:method>标签常用的属性如下:

name: 拦截到的方法,可以使用通配符*。
propagation: 事务的传播行为,默认为REQUIRED.增删改方法应该用REQUIRED,查询方法可以使用SUPPORTS。
read-only: 事务是否为只读事务,默认为false.增删改方法应该用false,查询方法可以使用true。

配置完成后执行单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer(){
        accountService.transfer("张学友","李冰冰",200);
    }
}

由于在业务层转账方法中添加了 int i = 1/0 ; 进行模拟事务操作异常，在配置了事务管理后，事务将会回滚，符合了事务的特性。

什么样的人不睡觉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 学习笔记04 - 事务管理

目录事务概述什么是事务事务的特性（ACID）事务的隔离级别Spring 事务管理 APIPlatformTransactionManager 事务管理器TransactionStatus 事务状态TransactionDefinition 基本事务属性的定义使用 XML 配置实现事务事务概述什么是事务举个栗子，小明给小华转账，操作流程大致分为二步：1.小明执行转账，余额减少；2.小华收款，账...
复制链接

扫一扫

专栏目录