Spring学习笔记 事务管理
事务简介
所谓事务，指的是程序中可运行的不可分割的最小单位。在生活中事务也是随处可见的。比方说你在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 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会在方法中抛出运行时错误时执行回滚，如果方法中抛出受检异常则不回滚。我们可以向rollback-for属性来指定当方法抛出什么异常时执行回滚，这里的异常可以是某一个具体的异常，也可以是一些异常的父类。
method name="get*" read-only="true"/>
<tx:method name="*" rollback-for="Exception"/>
tx:attributes> 相应的，还有一个no-rollback-for属性来配置在遇到某些异常下不执行回滚操作。
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>事务传播级别
上面简单使用了
- 传播设置为：
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() { ... }
}配置文件中，事务管理器需要使用
"transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
...
"order"/>
"transactionManager2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
...
"account"/>
如果要应用的注解有很多地方重复，可以将它们定义为一个自定义注解，然后使用自定义注解应用到需要的地方。
@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的配置，所有内容都在前面解释过了。所以应该很容易理解。
<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.Uservalue>
list>
property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">trueprop>
<prop key="hibernate.format_sql">trueprop>
<prop key="hibernate.hbm2ddl.auto">createprop>
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，有兴趣的同学可以看看。