使用Spring为业务层添加声明式事务

前言

业务层的职能不仅仅是调用DAO层这么简单，它在进行一个业务的时候，还有一件重要的事要兼顾——事务处理。事务处理是任何企业级应用开发中不能回避的一个重要问题，以往我们通过在业务方法中硬编码的方式进行事务控制，比如这样：

Connection connection=null;
try {
    connection=DatabaseUtil.getConnection();
    connection.setAutoCommit(false);
    //执行操作
    connection.commit();
} catch (SQLException e) {
    try {
        connection.rollback();
    } catch (SQLException e1) {
        
    }
}finally {
    DatabaseUtil.close(connection,null,null);
}

这样做的弊端显而易见，也许一个业务方法真正需要关注的代码块只有两三行，但是因为事务代码的分散，使得代码结构变得复杂得多。并且事务处理的代码都是那么几句话，你会发现这几个try-catch结构穿插在你所有的业务层，代码复用性极低，需要调整时工作量也比较大。结合我们之前所学过的面向切面编程，这些横向的逻辑是不是可以抽出来呢？答案是肯定的，技术总会往高的地方发展。Spring提供了声明式事务处理机制，它基于AOP实现，无须编写任何事务管理代码，关于事务的所有工作都放到配置文件，由Spring进行事务控制。这意味着事务控制代码与业务代码完全分离，开发者只需要专心于业务体，降低了开发和维护的成本，并且声明式事务的复用性较强，它可监控多个业务类中的多个业务方法。Spring还支持编程式事务，但是这种不提倡使用，灵活性较差，稍作了解即可。

接下来以一个示例，来演示声明式事务的使用过程。仍然接着我们之前的例子做，新朋友可以参照上上篇博文（初级整合）的代码。

配置前的准备

1、在学生数据接口StudentDao、服务层接口StudentService中定义如下方法

public int addStudent(Student student);  //新增学生记录

2、在SQL映射文件中定义如下映射块

<insert id="addStudent" parameterType="Student">
    INSERT INTO Student(StuName) VALUE (#{stuName})
</insert>

3、在服务层实现类中实现addStudent(Student student)方法

@Override
public int addStudent(Student student) {
    int num=studentDao.addStudent(student);
    num=0/0;  //模拟异常，验证是否回滚
    return num;
}

开始配置声明式事务

先贴出来实现，下文进行解释。不要忘了引入tx和aop两个命名空间。

<?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:p="http://www.springframework.org/schema/p"
       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
">
    <!--第一步，配置数据源-->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url">
            <value><![CDATA[jdbc:mysql://localhost:3306/Blog?useSSL=true&serverTimezone=UTC]]></value>
        </property>
        <property name="username" value="root" />
        <property name="password" value="accp" />
    </bean>

    <!--第二步，配置SqlSessionFactoryBean-->
    <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />  <!--引用数据源组件-->
        <property name="configLocation" value="classpath:mybatis-config.xml" />  <!--引入mybatis配置文件-->
        <property name="mapperLocations">  <!--配置SQL映射文件-->
            <list>
                <value>classpath:com/Blog/Mapper/*.xml</value>  <!--代表扫描com.Blog.Mapper包下所有的xml格式的文件-->
            </list>
        </property>
    </bean>

    <!--使用MapperScannerConfigurer扫描指定包的接口，并自动生成MapperFactoryBean-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="factory" />
        <property name="basePackage" value="com.Blog.Dao" />
    </bean>

    <context:component-scan base-package="com.Blog.ServiceImpl" />

    <!--声明式事务第一步，定义事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />  <!--需要引用我们之前定义好的数据源组件，指定对哪个数据库进行事务控制-->
    </bean>

    <!--声明式事务第二步，配置事务增强，设定事务的属性-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <!--指定匹配的方法，指定事务传播机制，指定能够触发回滚的异常类型-->
            <tx:method name="add*" propagation="REQUIRED" rollback-for="RunTimeException"/>
        </tx:attributes>
    </tx:advice>

    <!--声明式事务第三步，定义切面，将事务规则应用到指定的方法上-->
    <aop:config>
        <!--定义切入点，匹配ServiceImpl下所有类的所有方法，再结合<tx:advice>标签中匹配的方法，筛选出进行事务控制的方法-->
        <aop:pointcut id="serviceMethod" expression="execution(* com.Blog.ServiceImpl.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod" />  <!--将事务增强与连接点组合-->
    </aop:config>
</beans>

最后在测试类中进行测试

@Test
public void addStudent(){
    ApplicationContext context=new ClassPathXmlApplicationContext("spring-mybatis.xml");
    StudentService studentService=(StudentService)context.getBean("studentService");
    Student student=new Student();
    student.setStuName("小李");
    studentService.addStudent(student);
}

运行结果是插入不了这条数据的，即使在抛出异常之前已经执行了SQL语句，但是声明式事务管理依然会回滚数据。

实现声明式事务，我们在配置文件中只增加了三步操作，便实现了事务控制，在业务方法中无须关心任何与事务有关的东西，只需要专注于逻辑实现。如果在一个大型项目中有多个业务类，那么就省略了大量的事务控制代码，是不是很强大、简单？

接下来就对这三步进行一一介绍。

一、定义事务管理器

首先我们要做的就是定义一个事务管理器，它提供了对事务处理的全面支持和统一处理，在切面中相当于增强处理的角色。Spring框架提供了多种事务管理器，核心接口是org.springframework.transaction.PlatformTransactionManager，通过这个接口的不同实现类，Spring为不同的平台（框架）如JDBC、Hibernate等提供了不同的事务管理器，贴一张网上找的图：

因为我们现在用的是MyBatis框架，所以这里我们使用DataSourceTransactionManager类。我们需要为它指定一个数据源组件，以指示它要进行事务控制的数据库环境。

<!--声明式事务第一步，定义事务管理器-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource" />  <!--需要引用我们之前定义好的数据源组件，指定对哪个数据库进行事务控制-->
</bean>

二、为事务管理器设置事务属性

定义好了一个事务管理器，肯定要对它进行设置，以便更好地适应不同业务方法对于事务的不同要求。在Spring中，使用<tx:advice>标签配置事务增强，设定事务的属性，为不同的方法指定具体的业务规则。

在<tx:advice>标签设置id和transaction-manager属性，其中transaction-manager属性引用一个事务管理器Bean。需要注意的是，transaction-manager属性有一个默认值是transactionManager，也就是说，如果你的事务管理器Bean的id是transactionManager，那么你可以不指定这个属性的值。

除了以上两个属性，<tx:advice>标签通过定义<tx:attributes>子标签定制事务属性。事务属性又通过<tx:attributes>的子标签<tx:method>标签进行设置。Spring支持对不同的方法设置不同的事务属性，可以设置多个<tx:method>。比如我们要为更新操作、删除操作也进行事务控制，而且这些方法都是以update、del开头，那么配置增删改的事务如下：

<!--声明式事务第二步，配置事务增强，设定事务的属性-->
<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
        <!--指定匹配的方法，指定事务传播机制，指定能够触发回滚的异常类型-->
        <tx:method name="add*" propagation="REQUIRED" rollback-for="RunTimeException"/>
        <tx:method name="update*" propagation="REQUIRED" rollback-for="RunTimeException"/>
        <tx:method name="del*" propagation="REQUIRED" rollback-for="RunTimeException"/>
    </tx:attributes>
</tx:advice>

如此一来，再加上切面中配置的切入点，岂不是可以对所有业务类的多个方法进行事务控制？

<tx:method>标签中的name属性是必须的，用于指定匹配的方法，对方法名进行约定，可以使用通配符*。比如我们例子中的方法名叫addStudent，那么通过add*就可以匹配到这个方法，所以可以对这个方法进行事务控制。其他属性均为可选，因为它们都有默认值，这些默认值都可以满足一般的场景。但还是要了解这些属性：

1、propagation：事务传播机制。即当一个事务方法被调用时，指定该事务如何传播，Spring定义了7中传播机制：

• REQUIRED：默认值，表示如果存在一个事务，则在当前事务执行；如果不存在事务，则开启一个新事务。
• REQUIRES_NEW：表示总是开启一个新的事务。如果已经存在一个事务，则将这个事务挂起，开启新事务先执行该方法。
• MANDATORY：表示如果存在一个事务，则支持当前事务；如果当前没有一个活动的事务，则抛出异常。
• NESTED：表示当前如果存在一个活动的事务，则创建一个事务作为当前事务的嵌套事务运行；如果没有事务在活动，该取值与REQUIRED相同。
• SUPPORTS：表示如果存在一个事务，则支持当前事务；如果当前不存在事务，则按非事务方式执行。
• NOT_SUPPORTED：表示总是以非事务的方式执行。如果已存在一个活动的事务，则将事务挂起，然后执行该方法。
• NEVER：表示总是以非事务的方式执行。如果存在一个活动的事务，则抛出异常。

REQUIRED能够满足大多数的事务需求，可以作为首选的事务传播行为。

2、isolation：事务隔离级别。即当前事务和其他事务的隔离程度，在并发事务处理的情况下此属性很重要。可选值：

• DEFAULT：默认值，表示使用数据库默认的事务隔离级别。
• READ_UNCOMMITTED：未提交读。
• READ_COMMITTED：提交读。
• REPEATABLE_READ：可重复读。
• SERIALIZABLE：串行读。

3、timeout：事务超时时间。允许事务运行的最长时间，以秒为单位，超过最长时间则进行回滚，防止事务执行时间过长而影响系统性能。该属性需要底层的实现支持，默认值是-1，表示不超时。

4、read-only：事务是否为只读。默认为false，对于只执行查询功能的事务，指定为true能够提高事务处理的性能。

5、rollback-for：设定能够触发回滚操作的异常类型。默认在抛出RunTimeException时进行回滚。可以通过全限定类名指定需要回滚的异常，多个异常类使用逗号隔开。

6、no-rollback-for：设定不会触发回滚操作的异常类型。默认checked Exception不会触发回滚操作。同样可自行指定异常类型，多个则用逗号分开。

关于这一部分知识的详解，在这里不进行大规模阐述，推荐一篇不错的博文：

https://blog.csdn.net/hcmony/article/details/77850183

三、定义切面

完成上面两个步骤，我们还需要定义切面，将事务规则应用到指定的方法上。

定义切入点之后，使用<aop:advisor>标签引用事务属性的组件，通过其advice-ref属性引用定义好的事务属性配置Bean。

<!--声明式事务第三步，定义切面，将事务规则应用到指定的方法上-->
<aop:config>
    <!--定义切入点，匹配ServiceImpl下所有类的所有方法，再结合<tx:advice>标签中匹配的方法，筛选出进行事务控制的方法-->
    <aop:pointcut id="serviceMethod" expression="execution(* com.Blog.ServiceImpl.*.*(..))" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod" />  <!--将事务增强与连接点组合-->
</aop:config>

至此，Spring的声明式事务就配置完成了，总结一下步骤：

1、引入tx和aop命名空间；

2、定义事务管理器Bean，并为其注入数据源Bean；

3、通过<tx:advice>配置事务增强，绑定事务管理器并对不同方法定义事务规则；

4、配置切面，将事务增强与方法切入点组合。

使用注解实现声明式事务处理

Spring还支持使用注解配置声明式事务，所使用的注解是@Transactional。

首先仍需要在Spring配置文件中定义事务管理器，并添加对注解配置的事务的支持，如下：

<!--声明式事务第一步，定义事务管理器-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />  <!--需要引用我们之前定义好的数据源组件，指定对哪个数据库进行事务控制-->
</bean>

<tx:annotation-driven transaction-manager="txManager" />  <!--指定一个事务管理器-->

经过以上配置，程序便支持使用@Transactional注解来配置事务了，我们不需要再在配置文件中定义事务属性、配置切面。

package com.Blog.ServiceImpl;

import com.Blog.Dao.StudentDao;
import com.Blog.Entity.Student;
import com.Blog.Service.StudentService;
import org.apache.ibatis.annotations.Param;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional
@Service("studentService")
public class StudentServiceImpl implements StudentService {

    @Autowired
    @Qualifier("studentDao")
    private StudentDao studentDao;  //所依赖的Dao层接口

    @Override
    public Student getStudent(@Param("id") int id) {
        return studentDao.getStudent(id);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public int addStudent(Student student) {
        int num=studentDao.addStudent(student);
        num=0/0;  //模拟异常，验证是否回滚
        return num;
    }
}

以上代码中，我们使用@Transactional注解为StudentServiceImpl配置了事务管理，会根据默认事务规则为该类的所有方法添加事务处理（当然可以自己设置相关属性值）。如果某个方法需要不同的事务规则，则可在方法上再次使用此注解，并指定相关的属性值。

@Transactional注解的默认事务规则：

• 事务传播机制：PROPAGATION_REQUIRED
• 事务隔离级别：ISOLATION_DEFAULT
• 事务是读/写
• 事务超时默认是依赖于事务系统的，或者事务超时没有被支持
• 任何RunTimeException都将触发回滚操作，任何checked Exception都不会触发回滚

@Transactional注解的属性：

属性	类型	说明
propagation	枚举型：Propagation	事务传播机制，用例： @Transactional(propagation=Propagation.REQUIRED)
isolation	枚举型：Isolation	事务的隔离级别，用例： @Transactional(isolation=Isolation.READ_COMMITTED)
readOnly	布尔型	是否只读，用例： @Transactional(readOnly=true)
timeout	int型（单位：秒）	事务超时，用例： @Transactional(timeout=60)
rollbackFor	一组Class类的实例	一组异常类，遇到时进行回滚，用例： @Transactional(rollbackFor={SQLException.class})，多个用逗号隔开
rollbackForClassName	一组Class类的名称	一组异常类名，遇到时进行回滚，用例： @Transactional(rollbackForClassName={SQLException})，多个逗号隔开
noRollbackFor	一组Class类的实例	同rollbackFor
noRollbackForClassName	一组Class类的名称	同rollbackForClassName

这种方式没有上一种方式作用广泛，只能配置当前服务类。可根据实际情况，根据需要开启事务控制的业务类的多少，进行两种方式之间的选择。