Spring学习笔记事务管理

心已赠人 2022-07-11 13:44 138阅读 0赞

## 事务简介 ##

所谓事务，指的是程序中可运行的不可分割的最小单位。在生活中事务也是随处可见的。比方说你在Steam上剁手买了一款游戏，那么付款就是一个事务，要么付款成功，游戏到手；要么付款失败，钱退回你账户。不可能也绝不应该出现花了钱游戏却没到的情况。所以，事务也应该具有两个操作：成功时候**提交**，或者失败时候**回滚**。

许多框架也提供事务管理功能。JDBC中，你可以关闭自动提交，然后使用`Connection.commit()`和`Connection.rollback()`执行提交或回滚。在Hibernate中，也有类似的功能。但是，这些框架的事务管理有一个问题，就是它们虽然提供了事务功能，但是为了使用这些功能，你必须在每个需要事务的地方添加额外代码，当执行正常时提交，出现异常时回滚。这样一来，程序中就会出现大量重复的事务管理代码（有过这种经历的人应该能够感同身受吧）。

另外事务还分为本地事务和全局事务。JDBC事务、Hibernate事务都是本地事务，只关注特定资源的事务管理。全局事务则用来控制多个数据库、消息队列等等。Spring提供了统一的事务管理来操作全局事务和本地事务，让我们的代码更加简洁。

### Spring事务管理 ###

Spring事务的核心接口是org.springframework.transaction.PlatformTransactionManager。

public interface PlatformTransactionManager { 
    
        TransactionStatus getTransaction(
                TransactionDefinition definition) throws TransactionException;
    
        void commit(TransactionStatus status) throws TransactionException;
    
        void rollback(TransactionStatus status) throws TransactionException;
    }

提交和回滚方法我们已经了解了。getTransaction方法会根据给定的事务定义，返回一个事务状态对象。事务定义包含了事务的一些特征：是否是只读的，超时设置、事务的隔离和传播等。Spring实现了几个PlatformTransactionManager，用于不同环境（JDBC、Hibernate、JPA等等）下的事务管理。我们在使用的时候只要设置好相应的PlatformTransactionManager即可。事务管理包括在Spring核心包中，所以只要项目中添加了`spring-core.jar`，那么就可以使用Spring的事务管理功能了。如果需要和Hibernate等框架的集成，那么还需要`spring-orm.jar`。

## 声明式事务管理 ##

Spring支持声明式和编程式两种方式来控制事务管理。最流行的方式就是使用声明式。利用声明式事务管理，我们可以设置遇到什么异常时候回滚事务、在哪些方法上执行事务，而不用修改任何代码。如果已经了解了Spring AOP的话，应该可以猜得到，Spring声明式事务管理需要AOP代理的支持。下面我们来用一个例子说明一下。

### 配置PlatformTransactionManager ###

下面我们使用JDBC来演示一下Spring事务管理。因此首先需要配置相应的PlatformTransactionManager，在这里是DataSourceTransactionManager，它需要相应的数据源来初始化。

<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/test"/>
        <property name="username" value="root"/>
        <property name="password" value="12345678"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>

然后我们需要一个类来进行事务管理。首先我们定义一个接口。

public interface UserService {
        void add(User user);
    
        User get(String username);
    }

然后来实现这个接口。在这里我用了Spring JDBC来进行数据操作。throwException来模拟抛出异常的情况。

public class JdbcUserService implements UserService { 
    
        private JdbcTemplate template;
        private boolean throwException;
    
        @Autowired
        public void setTemplate(JdbcTemplate template) {
            this.template = template;
        }
    
        public void setThrowException(boolean throwException) {
            this.throwException = throwException;
        }
    
    
        @Override
        public void add(User user) {
            template.update("INSERT INTO user(name) VALUES(?)", user.getName());
            if (throwException) {
                throw new RuntimeException("抛出异常");
            }
        }
    
        @Override
        public User get(String username) {
            return template.queryForObject("SELECT id,name FROM user WHERE name=?", new UserRowMapper(), username);
        }
    }

### 配置事务管理 ###

然后我们需要配置一个切入点和通知，指定哪些方法应用什么样的事务管理，这一部分属于AOP的部分，这里不再细述。我们需要`<tx:advice>`节点设置事务管理，该节点需要设置标识符和事务管理器。`<tx:attributes>`节点中的配置表示，以get开头的方法是只读的，其他方法不是只读的。这有助于Spring正确设置事务。

<tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        <aop:pointcut id="userService" expression="execution(* yitian..transaction.JdbcUserService.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="userService"/>
    </aop:config>

### 回滚操作 ###

默认情况下，Spring会在方法中抛出运行时错误时执行回滚，如果方法中抛出受检异常则不回滚。我们可以向`<tx:method/>`节点添加`rollback-for`属性来指定当方法抛出什么异常时执行回滚，这里的异常可以是某一个具体的异常，也可以是一些异常的父类。

<tx:attributes>
        <tx:method name="get*" read-only="true"/> <tx:method name="*" rollback-for="Exception"/> </tx:attributes>

相应的，还有一个`no-rollback-for`属性来配置在遇到某些异常下不执行回滚操作。

<tx:attributes>
        <tx:method name="get*" read-only="true"/> <tx:method name="*" no-rollback-for="IndexOutOfBoundsException"/> </tx:attributes>

如果遇到了多个回滚规则，以最具体的那一个为准。所以下面的配置，当遇到`InstrumentNotFoundException`时不会回滚，当遇到其他异常时则执行回滚。

<tx:advice id="txAdvice">
        <tx:attributes>
        <tx:method name="*" rollback-for="Throwable" no-rollback-for="InstrumentNotFoundException"/>
        </tx:attributes>
    </tx:advice>

### 事务传播级别 ###

上面简单使用了`<tx:advice/>`节点。下面我们来分析一下这个节点的配置。默认情况下，`<tx:advice/>`的配置如下：

*  传播设置为：`REQUIRED`
 *  隔离级别是：`DEFAULT`
 *  事务是可读可写的
 *  事务超时是底层事务系统的默认超时，如果底层不支持就没有超时
 *  任何运行时异常会触发回滚，任何受检异常不触发回滚。

首先来说明一下事务的传播，这指的是外层事务和内层事务之间的关系。常用的值有三个：`PROPAGATION_REQUIRED` 、`PROPAGATION_REQUIRES_NEW`和`PROPAGATION_NESTED`。

首先来说说`PROPAGATION_REQUIRED`。当外层事务需要一个内层事务的时候，会直接使用当前的外层事务。这样一来多个方法可能会共享同一个事务。如果内层事务出现回滚，那么外层事务会也会回滚。这种情况下内层事务会抛出一个`UnexpectedRollbackException`异常，外层调用者需要捕获该异常来判断外层事务是否已回滚。

`PROPAGATION_REQUIRES_NEW`会为每个事务创建**完全独立**的事务作用域，如果外层事务需要一个内层事务，内层事务会先挂起外层事务，当内层事务执行完毕之后会恢复外层事务。这样一来内外层事务的提交和回滚完全是独立的，不会互相干扰。

`PROPAGATION_NESTED`使用带有多个保存点的单个事务。这些保存点会映射到JDBC的保存点上。所以只能用于JDBC环境和`DataSourceTransactionManager`中。

事务的隔离级别，除了`DEFAULT`之外，剩下的几种隔离级别和JDBC中的隔离级别一一对应。详细情况请查看JDBC的相关文档。

### 测试事务 ###

前面都配置完成之后，我们就可以测试一下Spring的事务管理功能。下面使用了一个测试类来测试。设置`userService.setThrowException(false)`之后，事务不会抛出异常，我们可以看到成功插入了用户数据。当设置`userService.setThrowException(true)`，事务会抛出异常，我们发现这次没有插入数据。

@ContextConfiguration(locations = {
       "classpath:transaction.xml"})
    @RunWith(SpringRunner.class)
    public class TransactionTest { 
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Autowired
        private JdbcUserService userService;
    
        @Before
        public void before() {
            jdbcTemplate.execute("CREATE TABLE user(id INT AUTO_INCREMENT PRIMARY KEY ,name VARCHAR(255))");
        }
    
        @After
        public void after() {
            jdbcTemplate.execute("DROP TABLE IF EXISTS user");
        }
    
        @Test
        public void testTransaction() {
            //事务成功
            userService.setThrowException(false);
            User user = new User();
            user.setName("yitian");
            userService.add(user);
            User u = userService.get(user.getName());
            assertEquals(user.getName(), u.getName());
            //事务失败
            userService.setThrowException(true);
            user.setName("liu6");
            u = null;
            try {
                userService.add(user);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            try {
                //由于没有记录，Spring JDBC会抛出异常
                //所以必须捕获该异常
                u = userService.get(user.getName());
            } catch (EmptyResultDataAccessException e) {
                System.out.println(e.getMessage());
            }
    
            assertNull(u);
    
        }
    }

### 注解配置 ###

前面用的都是XML配置方式，还可以使用注解配置声明式事务管理。这需要在配置文件中添加一行，这一行仍然需要指明使用的事务管理器。

<tx:annotation-driven transaction-manager="txManager"/>

如果你全部使用注解配置，那么在标记了`@Configuration`的类上在添加`@EnableTransactionManagement`即可。需要注意这两种方法都会在当前ApplicationContext中寻找`@Transactional` Bean。

注解配置主要使用`@Transactional`注解，该注解可以放置到类、接口或者公有方法上。该注解还有一些属性和XML配置相对应。但是根据配置的不同，注解可能不会起作用。下面是Spring官方的两段话。

> Spring建议你只在具体类上应用注解@Transactional注解，而不是注解到接口上。你可以将注解应用到接口（或者接口方法）上，但是这只在你知道你在用基于接口的代理时起作用。实际上，Java注解*不会从接口继承*，这意味着如果你使用基于类的代理（proxy-target-class=”true”）或者基于编织的切面（ mode=”aspectj”），那么事务设置不会被代理和编织体系识别，事务对象也不会被包装到事务代理中，这毫无疑问是件坏事。
> 
> 在代理模式（这是默认选项）中，只有显式经过代理的方法调用会被拦截。这意味着自我调用，也就是目标对象中的一个方法调用该目标对象的另一个方法，不会在运行时触发事务，即使该方法标记了@Transactional。同样的，代理必须完全初始化来提供期望的行为，所以你不应该在初始化代码中依赖这样的功能（例如@PostConstruct）。

如果需要使用多个事务管理器，可以像下面这样。

public class TransactionalService {
    
        @Transactional("order")
        public void setSomething(String name) { ... }
    
        @Transactional("account")
        public void doSomething() { ... }
    }

配置文件中，事务管理器需要使用`<qualifier>`节点指定不同的名称。

<tx:annotation-driven/>
    
        <bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            ...
            <qualifier value="order"/>
        </bean>
    
        <bean id="transactionManager2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            ...
            <qualifier value="account"/>
        </bean>

如果要应用的注解有很多地方重复，可以将它们定义为一个自定义注解，然后使用自定义注解应用到需要的地方。

@Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Transactional("account")
    public @interface AccountTx { 
    }

## Hibernate事务管理 ##

前面简单使用了JDBC的事务管理。不过实际上大部分人应该都需要使用Hibernate等高级框架的事务管理功能。下面也做一些介绍。

首先需要一个接口，定义我们需要的操作。

public interface UserDao {
        void add(User user);
    
        User get(String name);
    }

然后我们实现这个接口，定义hibernate数据访问。这里使用了HibernateTemplate类，这个类是Spring提供的，我们可以使用这个类简化Hibernate操作。我们可以看到使用这个类不需要操作Session，Session会由Spring自动管理。当然，这里为了使用Hibernate的自然主键，所以还是需要直接使用Session来查找自然主键。

public class DefaultUserDao implements UserDao { 
        private HibernateTemplate template;
        private SessionFactory sessionFactory;
    
        @Autowired
        public void setTemplate(HibernateTemplate template) {
            this.template = template;
        }
    
        @Autowired
        public void setSessionFactory(SessionFactory sessionFactory) {
            this.sessionFactory = sessionFactory;
        }
    
        @Override
        public void add(User user) {
            template.save(user);
        }
    
        @Override
        public User get(String name) {
            Session session = sessionFactory.getCurrentSession();
            return session.bySimpleNaturalId(User.class).load(name);
        }
    }

然后是Spring的配置，所有内容都在前面解释过了。所以应该很容易理解。

<?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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" 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">
        
        <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
            <property name="username" value="root"/>
            <property name="password" value="12345678"/>
        </bean>
        
        <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <property name="annotatedClasses">
                <list>
                    <value>yitian.learn.hibernate.User</value>
                </list>
            </property>
            <property name="hibernateProperties">
                <props>
                    <prop key="hibernate.show_sql">true</prop>
                    <prop key="hibernate.format_sql">true</prop>
                    <prop key="hibernate.hbm2ddl.auto">create</prop>
                </props>
            </property>
        </bean>
        
        <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
            <property name="sessionFactory" ref="sessionFactory"/>
        </bean>
        
        <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory"/>
        </bean>
        
        <bean id="userDao" class="yitian.learn.hibernate.DefaultUserDao"/>
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="get*" read-only="true"/>
                <tx:method name="*"/>
            </tx:attributes>
        </tx:advice>
        
        <aop:config>
    
            <aop:pointcut id="userDaoPointcut" expression="execution(* yitian.learn.hibernate.DefaultUserDao.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="userDaoPointcut"/>
    
        </aop:config>
    </beans>

最后使用一个测试类来测试一下代码。可以看到，在操作数据上我们完全没有使用Hibernate的事务API，完全交由Spring管理。当然如果抛出异常，Spring也会回滚。

@ContextConfiguration(locations = {
       "classpath:hibernate-bean.xml"})
    @RunWith(SpringRunner.class)
    public class HibernateTransactionTest { 
        @Autowired
        private UserDao userDao;
    
        @Test
        public void testHibernateTransaction() {
            User user = new User();
            user.setUsername("yitian");
            user.setPassword("1234");
            user.setNickname("易天");
            user.setBirthday(LocalDate.now());
            userDao.add(user);
    
            User u = userDao.get(user.getUsername());
            System.out.println(u);
            assertEquals(user.getNickname(), u.getNickname());
        }
    }

代码在[Csdn code][]，有兴趣的同学可以看看。

[Csdn code]: https://code.csdn.net/u011054333/spring-core-sample/tree/master