前面我们讲了Spring 中的JdbcTemplate，现在我们来讲Spring中的事务控制。

文章目录

Spring 中的事务控制

Spring 中的事务控制

基本介绍

我们在讲Spring中AOP的引入及相关概念中，为了实现业务层的事务管理，我们自己创建了连接工具类 ConnectionUtils和事务管理器 TransactionManager。但是其实 Spring已经给我们提供了事务管理相关的接口，我们只需要在配置文件中声明使用即可。

JavaEE 体系进行分层开发，事务处理位于业务层，Spring 提供了分层设计业务层的事务处理解决方案。
spring 框架为我们提供了一组事务控制的接口。具体在后面的第二小节介绍。这组接口是在spring-tx-5.0.2.RELEASE.jar中。依赖我们在讲Spring 中的JdbcTemplate的时候已经讲过了，这里就不在贴代码了。
spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现。我们学习的重点是使用配置的方式实现。

Spring 中事务控制的 API 介绍

PlatformTransactionManager 接口

PlatformTransactionManager 接口是 Spring 的事务管理器，它里面提供了我们常用的操作事务的方法，见下表：

常用方法	作用
`TransactionStatus getTransaction(@Nullable TransactionDefinition definition)`	获取事务状态信息
`void commit(TransactionStatus status)`	提交事务
`void rollback(TransactionStatus status)`	回滚事务

我们在开发中都是使用它的实现类，真正管理事务的对象，如下表：

实现类	作用
org.springframework.jdbc.datasource.`DataSourceTransactionManager`	使用Spring JDBC 或者 Mybatis 进行持久化数据时使用
org.springframework.orm.hibernate5.`HibernateTransactionManager`	使用 HIbernate 进行持久化数据时使用

TransactionDefinition 接口

TransactionDefinition 接口是事务的定义信息对象，提供以下方法：

常用方法	作用
`String getName()`	获取事务的名称
`int getIsolationLevel()`	获取事务的隔离级别
`int getPropagationBehavior`	获取事务的传播行为
`int getTimeout()`	获取事务的超时时间
`boolean isReadOnly()`	获取事务是否只读

读写型事务：增加、删除、修改开启事务
只读型事务：执行查询时，也会开启事务

事务的隔离级别

事务的隔离级别反映了事务提交并发访问时的处理态度，在TransactionDefinition中定义了以下几种级别：

类型	级别
`ISOLATION_DEFAULT`	使用数据库默认的隔离级别，为以下四种的其中之一
`ISOLATION_READ_UNCOMMITTED`	可以读取未提交数据
`ISOLATION_READ_COMMITTED`	只能读取已提交数据，解决脏读问题（Oracle 默认级别）
`ISOLATION_REPEATABLE_READ`	只有当前事务提交后才可以看到其他事务提交的修改（MySQL 默认级别）
`ISOLATION_SERIALIZABLE`	事务串行执行，一个时刻只能有一个事务执行

事务的传播行为

事务的传播行为反映了事务的控制范围，在 TransactionDefinition 中定义了以下几种级别：

类型	作用
`REQUIRED`	默认的 Spring 事务传播行为，能满足大部分应用场景。如果当前没有事务，就新建一个事务；如果已经存在一个事务，那么加入到这个事务中。
`SUPPORTS`	支持当前事务，如果没有事务，就以非事务方式执行
`MANDATORY`	使用当前的事务，如果没有事务就抛出异常
`REQUIRES_NEW`	新建事务，如果当前处于事务中，就把当前事务挂起
`NOT_SUPPORTED`	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
`NEVER`	以非事务方式执行操作，如果当前存在事务就抛出异常
`NESTED`	如果当前存在事务，则在嵌套事务中执行；如果当前没有事务，则执行 `REQUIRED` 类似的操作

事务的超时时间
- 默认值是 -1 ，没有超时限制。设置的时候以秒为单位进行设置
事务是否为只读事务
- 一般把查询操作设置为只读事务
想要了解隔离级别和传播行为可以看这里：Spring五个事务隔离级别和七个事务传播行为

TransactionStatus 接口

TransactionStatus接口描述了某个时间点上事务对象具体的运行状态，提供以下方法：

常用方法	作用
`void flush()`	刷新事务
`boolean hasSavepoint()`	获取是否存在存储点
`boolean isCompleted()`	获取事务是否完成
`boolean isNewTransaction()`	获取事务是否为新的事务
`boolean isRollbackOnly()`	获取事务是否回滚
`void setRollbackOnly()`	设置回滚

所谓的存储点，就是按步提交，一旦设置了储存点，每个存储点就是事务的一步，当执行成功之后，那就提交一步，所以步骤都成功，整个事务就结束。如果在某一步没有成功，那回滚的时候只回滚到当前的那一步之前，而不是回滚了所有的。

基于 XML 的声明式事务控制

这里我们采用上篇文章的案例，然后在此基础上修改。

导入相关依赖

<packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

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

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

持久层的接口和实现类和之前的一样，就不在贴代码了。
业务层的接口和实现类（其实也跟之前的文章一样）：

/**
 * 账户的业务层接口
 */
public interface IAccountService {
    
    

    /**
     * 根据id查询账户信息
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 转账
     * @param name 转出账户名称
     * @param targetName 转入账户名称
     * @param money 转账金额
     */
    void transfer(String name,String targetName,Float money);
}

/**
 * 账户的业务层实现类
 *  * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService {
    
    

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
    
    
        this.accountDao = accountDao;
    }

    @Override
    public Account findAccountById(Integer accountId) {
    
    
        return accountDao.findAccountById(accountId);

    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
    
    
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            //int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

编写配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置service-->
    <bean id="accountService" class="com.cz.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.cz.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring?serverTimezone=UTC&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置事务的通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.cz.service.impl.*.*(..))"></aop:pointcut>
        <!--建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
</beans>

基于XML的声明式事务的配置步骤

使用 <bean>标签配置一个事务管理器DataSourceTransactionManager
使用<tx:advice>标签配置事务的通知并且引用事务管理器

id 属性用于给事务通知提供一个唯一标识， ref属性用于引用配置好的事务管理器 Bean

在<tx:advice>标签内部使用<tx:attributes>标签和 <tx:method>标签配置事务的属性

<tx:method>标签用于配置事务的属性，有以下属性：

name属性：指定要控制的方法，可以使用通配符*

propagation 属性：指定事务的传播行为，增删改使用REQUIRED（默认值），查询使用SUPPORTS

isolation属性：指定事务的隔离级别，默认值是 DEFAULT，表示使用数据库的默认隔离级别

read-only 属性：指定事务是否只读，默认值为 false，表示读写，只有查询方法才需要设置为true

timeout 属性：指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。

rollback-for属性：用于指定一个异常，当产生该异常时，事务回滚；产生其它异常时，事务不回滚。没有默认值，表示任何事务都回滚

no-rollback-for 属性：用于指定一个异常，当产生该异常时，事务不回滚；产生其它异常时，事务回滚。没有默认值，表示任何事务都回滚

使用 <aop:config>标签和 <aop:pointcut>标签配置 AOP 切入点表达式
在 <aop:config> 标签内部使用<aop:advisor>标签配置切入点表达式和事务通知的关系

advice-ref 属性用于指定通知的引用，pointcut-ref 属性用于指定切入点表达式的引用

基于半注解（XML + 注解）的声明式事务控制

修改业务层和持久层代码，使用@Transactional 注解开启业务层方法的事务配置

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)//只读型
public class AccountServiceImpl implements IAccountService {
    
    

    @Autowired
    private IAccountDao accountDao;
    
    @Override
    public Account findAccountById(Integer accountId) {
    
    
        return accountDao.findAccountById(accountId);

    }

    @Override
    //读写型事务
    // 单独配置非查询方法
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
    public void transfer(String sourceName, String targetName, Float money) {
    
    
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            //int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}


/**
 * 账户的持久层实现类
 */
@Repository("accountDao")
public class AccountDaoImpl  implements IAccountDao {
    
    

    private JdbcTemplate jdbcTemplate;
    //对于dao的注解和xml的区别我在Spring 中的 JdbcTemplate就讲过了
	//........

关于 @Transactional注解：

该注解的属性和 XML 中的属性含义一致。该注解可以出现在接口上，类上和方法上。

出现接口上，表示该接口的所有实现类都有事务支持。

出现在类上，表示类中所有方法有事务支持

出现在方法上，表示方法有事务支持。

以上三个位置的优先级：方法>类>接口

使用注解不需要配置 AOP 的原因是在业务层配置了 @Transactional 注解的地方就相当于是切入点

编写配置文件，注意在配置文件中一样要配置事务管理器，同时还要开启对注解事务的支持

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.cz"></context:component-scan>

    <!-- 配置JdbcTemplate-->
    <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.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring?serverTimezone=UTC&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="7107883"/>
    </bean>

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

    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

基于纯注解的声明式事务控制

如果想使用纯注解的方式，那么需要使用 @EnableTransactionManagement注解开启事务

/**
 * spring的配置类，相当于bean.xml
 */
@Configuration
@ComponentScan("com.cz")
@Import({
    
    JdbcConfig.class,TransactionConfig.class})
@PropertySource("jdbcConfig.properties")
@EnableTransactionManagement
public class SpringConfiguration {
    
    

}

Jdbc 配置类

**
 * 和连接数据库相关的配置类
 */
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;

    /**
     * 创建JdbcTemplate
     * @param dataSource
     * @return
     */
    @Bean(name="jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
    
    
        return new JdbcTemplate(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name="dataSource")
    public DataSource createDataSource(){
    
    
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

事务配置类


/**
 * 和事务相关的配置类
 */
public class TransactionConfig {
    
    

    /**
     * 用于创建事务管理器对象
     * @param dataSource
     * @return
     */
    @Bean(name="transactionManager")
    public PlatformTransactionManager createTransactionManager(DataSource dataSource){
    
    
        return new DataSourceTransactionManager(dataSource);
    }
}

新建jdbcConfig.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring?serverTimezone=UTC&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

SSM之Spring系列（八）---- Spring 中的事务控制

文章目录

Spring 中的事务控制

基本介绍

Spring 中事务控制的 API 介绍

PlatformTransactionManager 接口

TransactionDefinition 接口

事务的隔离级别

事务的传播行为

TransactionStatus 接口

基于 XML 的声明式事务控制

基于XML的声明式事务的配置步骤

基于半注解（XML + 注解）的声明式事务控制

基于纯注解的声明式事务控制

猜你喜欢

SSM之Spring系列（八）---- Spring 中的事务控制

文章目录

Spring 中的事务控制

基本介绍

Spring 中事务控制的 API 介绍

PlatformTransactionManager 接口

TransactionDefinition 接口

事务的隔离级别

事务的传播行为

TransactionStatus 接口

基于 XML 的声明式事务控制

基于XML的声明式事务的配置步骤

基于半注解（XML + 注解） 的声明式事务控制

基于纯注解的声明式事务控制

猜你喜欢

基于半注解（XML + 注解）的声明式事务控制