Spring 事务管理

116次阅读

共计 4172 个字符,预计需要花费 11 分钟才能阅读完成。

事务
因 Github 自动化测试的原因,(最后找到的原因是 getOneSavedDepartment 时,这个 Department 没存上,所以 ToMessage 引用了一个未持久化的 Department,就报错了),特此学习了一下事务。
事务,基础概念就不说了。
Spring 为我们提供了对事务的支持,我们只需要很简单的注解或者 XML 配置即可实现。
去网上找了好多篇关于 Spring 事务的博客,全是字,根本没有心情去看,更谈不上深入理解了,作者还在标题中自认为自己讲的比较好。

如果你也不喜欢大段的文字,请继续向下看,我保证我画的图不会让你失望。
org.springframework.transaction.annotation.Transactional
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
@AliasFor(“transactionManager”)
String value() default “”;

@AliasFor(“value”)
String transactionManager() default “”;

Propagation propagation() default Propagation.REQUIRED;

Isolation isolation() default Isolation.DEFAULT;

int timeout() default -1;

boolean readOnly() default false;

Class<? extends Throwable>[] rollbackFor() default {};

String[] rollbackForClassName() default {};

Class<? extends Throwable>[] noRollbackFor() default {};

String[] noRollbackForClassName() default {};
}
事务注解中有好多的属性,如果是简单场景的话,那我们只需要默认地配置就好了。
但是如果应用发嵌套事务的复杂场景下,我们就需要研究研究这几个配置项了。
这里我们深入学习一下事务的传播属性 propagation。
Propagation
REQUIRED
因为我们的事务传播级别就是 REQUIRED,所以我们不配置 propagation 来测试 REQUIRED。
如果当前存在事务,则使用当前事务。如果不存在任何事务,则创建一个新的事务。
内部方法开启默认 REQUIRED 级别的事务
一个????,一个????,省略 set、get 方法。
@Entity
public class Cat {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String name;
}

@Entity
public class Dog {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String name;
}
一个猫实现类,一个狗实现类,都有 save 方法,并且 DogServiceImpl 中还有一个保存并抛出异常的方法,用于测试回滚。省略依赖注入的代码。
@Service
public class CatServiceImpl implements CatService {

@Override
@Transactional
public void save(Cat cat) {
catRepository.save(cat);
}
}

@Service
public class DogServiceImpl implements DogService {

@Override
@Transactional
public void save(Dog dog) {
dogRepository.save(dog);
}

@Override
@Transactional
public void saveThrowException(Dog dog) {
dogRepository.save(dog);
throw new RuntimeException();
}
}
外部方法不开启事务
public void test() {
Cat cat = new Cat();
cat.setName(“Hello Kitty!”);
catService.save(cat);

Dog dog = new Dog();
dog.setName(“ 史努比 ”);
dogService.save(dog);
}
没有任何异常抛出,猫存上了,狗也存上了。

将保存狗的方法由 save 修改为 saveThrowException,抛个异常,测试一下回滚。
public void test() {
Cat cat = new Cat();
cat.setName(“Hello Kitty!”);
catService.save(cat);

Dog dog = new Dog();
dog.setName(“ 史努比 ”);
dogService.saveThrowException(dog);
}

猫存上了,狗没存上。因为同一事务的所有操作是同时成功,同时失败的。所以我们断定,猫和狗用的是两个事务。
图解

如果不存在任何事务,则创建一个新的事务。
save 猫和 save 狗都是默认的 REQUIRED 级别,test 方法未开启事务,所以当前不存在任何事务。
所以 save 猫创建了一个新的事务,save 狗也创建了一个新的事务。

外部方法开启事务
为外部 test 方法添加事务。
@Transactional
public void test() {
Cat cat = new Cat();
cat.setName(“Hello Kitty!”);
catService.save(cat);

Dog dog = new Dog();
dog.setName(“ 史努比 ”);
dogService.save(dog);
}
显然,未抛出异常,都存上了。

方法修改为保存并抛出异常。
@Transactional
public void test() {
Cat cat = new Cat();
cat.setName(“Hello Kitty!”);
catService.save(cat);

Dog dog = new Dog();
dog.setName(“ 史努比 ”);
dogService.saveThrowException(dog);
}
两者都没存上,所以断定 save 狗的方法抛出的异常对 save 猫是有影响的,猜测二者用的是同一个事务。

如果当前存在事务,则使用当前事务。

如果捕获抛出的 RuntimeException,该方法仍然不能保存。
Dog dog = new Dog();
dog.setName(“ 史努比 ”);
try {
dogService.saveThrowException(dog);
} catch (RuntimeException e) {
System.out.println(“error”);
}
会抛出异常,该事务不能被提交。

总结:REQUIRED 修饰的内部方法会加入外部方法的事务中,其中有任一一个方法抛异常,事务都会回滚。
SUPPORTS
SUPPORTS 与 REQUIRED 类似:
如果当前存在事务,则使用当前事务。如果不存在任何事务,则不使用事务。
MANDATORY
MANDATORY 与 REQUIRED 类似:
如果当前存在事务,则使用当前事务。如果不存在任何事务,则抛出异常。
REQUIRES_NEW
如果当前存在事务,则挂起当前事务。创建一个新的事务。
应该适合该操作相对独立的情况。就比如下单加支付,如果支付失败,但是这个订单应该还存在。
如果将事务传播级别修改为这个的话,那 save 狗如果抛出异常就不影响 save 猫了。
@Override
@Transactional
public void test() {
Cat cat = new Cat();
cat.setName(“Hello Kitty!”);
catService.save(cat);

Dog dog = new Dog();
dog.setName(“ 史努比 ”);
dogService.saveThrowException(dog);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void save(Cat cat) {
catRepository.save(cat);
}

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveThrowException(Dog dog) {
dogRepository.save(dog);
throw new RuntimeException();
}

NOT_SUPPORTED
如果当前存在事务,则挂起当前事务。同时以非事务方式运行。
NEVER
永远不要存在事务。如果当前存在事务,则抛出异常。
NESTED
如果当前存在事务,则在当前事务的一个嵌套事务中运行。
该级别只对 DataSourceTransactionManager 事务管理器生效。
本来想测试一下的,可惜。

org.springframework.transaction.NestedTransactionNotSupportedException: JpaDialect does not support savepoints – check your JPA provider’s capabilities
NestedTransactionNotSupportedException,不支持嵌套事务。
StackOverflow 上的回答,Hibernate 不支持嵌套事务。

总结

哥仨 REQUIRED、SUPPORTS、MANDATORY,如果当前存在事务,则使用当前事务。
哥仨 REQUIRES_NEW、NOT_SUPPORTED、NEVER 都不支持当前存在的事务。

NESTED,嵌套事务,觉得这个应该是事务中最好用且最合理的,可惜 Hibernate 不支持。

正文完
 0