基本概念
Spring家事务中的几个关键类：
- TransactionManager
- PlatformTransactionManager ：用于命令式事务管理的事务管理器,定义了获取事务，回滚事务和提交事务的规范
- ReactiveTransactionManager ：用于响应式事务管理的事务管理器
- TransactionException：事务异常，Spring家定义的事务超类，我们自定义事务异常时可以继承TransactionException
- TransactionStatus ：getTransaction方法的返回值；TransactionStatus 可能表示新事务或可以表示现有事务
- TransactionDefinition ：标准事务概念，包含了事务的传播行为，隔离级别，超时设置，是否只读状态等信息
声明式事务
1.使用说明
Spring的声明式事务可谓是其一大亮点了，做到了代码侵入性最小：在开启Spring声明式事务的环境下（即在配置类上标注EnableTransactionManagement注解），我们仅仅需要在需要事务管理的方法上标注@Transactional就能为该方法开启事务。既然是这两个注解就能让我们把事务交给Spring来管理，我们就来看看这两个注解的使用吧，具体的原理我们下节再来讲述。
2.@EnableTransactionManagement注解的源码解释
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
/**
* 是否开启基于子类的Cglib动态代理，默认是基于接口的JDK动态代理
*/
boolean proxyTargetClass() default false;
/**
* AOP的模式：基于代理的模式和基于Aspect织入的模式
*/
AdviceMode mode() default AdviceMode.PROXY;
/**
* 设置增强器Advice的优先级order,从而可以控制事务控制逻辑在增强器链中的执行时机,
* 默认是Ordered#LOWEST_PRECEDENCE
*/
int order() default Ordered.LOWEST_PRECEDENCE;
}
3.@Transactional注解的源码解释：
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
/**
* 用来指定事务管理器
*/
@AliasFor("transactionManager")
String value() default "";
/**
* 用来指定事务管理器
*/
@AliasFor("value")
String transactionManager() default "";
/**
* 标签
*/
String[] label() default {};
/**
* 事务的传播行为
*/
Propagation propagation() default Propagation.REQUIRED;
/**
* 事务的隔离级别
*/
Isolation isolation() default Isolation.DEFAULT;
/**
* 事务的超时时间int格式
*/
int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
/**
* 事务的超时时间String格式
*/
String timeoutString() default "";
/**
* 是否开启只读事务
*/
boolean readOnly() default false;
/**
* 自动回滚的异常Class
*/
Class<? extends Throwable>[] rollbackFor() default {};
/**
* 自动回滚的异常ClassName
*/
String[] rollbackForClassName() default {};
/**
* 不自动回滚的异常Class
*/
Class<? extends Throwable>[] noRollbackFor() default {};
/**
* 不自动回滚的异常ClassName
*/
String[] noRollbackForClassName() default {};
}
使用案例：
@Transactional
public String sayHello(String name) {
String result = "你好2" + name;
applicationContext.publishEvent(new TransactionEvent(name));
System.out.println(result);
int length = name.length();
return result + "-------2" + length;
}
4.存在的问题：
失效的场景：（面试中常问的两种场景吧）
- @Transactional 应用在非 public 修饰的方法上
- 同一个类中方法调用（自调用），导致@Transactional失效
具体失效的原理我们后面说
// 1.@Transactional 应用在非 public 修饰的方法上
@Transactional
private String sayHello(String name) {
String result = "你好2" + name;
applicationContext.publishEvent(new TransactionEvent(name));
System.out.println(result);
int length = name.length();
return result + "-------2" + length;
}
// 2.自调用导致失效
public void testA() {
testB();
}
@Transactional
public void testB() {
System.out.println(" testB.... ");
}
编程式事务
相较于声明式事务，可能编程式事务对于读者来说可能用的不多，Spring提供了两种程序化管理的方法：
- 通过TransactionTemplate（命令式）或者TransactionalOperator（响应式）
- 直接通过TransactionManager来实现
Spring家是十分推荐我们使用方法一来进行编程市事务的。TransactionTemplate中帮我们处理好了开启，回滚，提交事务等公共的方法，并且把业务的逻辑通过TransactionCallback的形式暴露给开发人员，这样我们只需要关注自己的业务逻辑代码就可以了，无需过多的关心事务的管理，一个例子如下：
public class SimpleService implements Service {
private final TransactionTemplate transactionTemplate;
public SimpleService(PlatformTransactionManager transactionManager) {
this.transactionTemplate = new TransactionTemplate(transactionManager);
}
public Object someServiceMethod() {
return transactionTemplate.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
updateOperation1();
return resultOfUpdateOperation2();
}
});
}
}
如果你的业务代码是没有返回值的，则可以实现TransactionCallbackWithoutResult来编写自己的业务逻辑：
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
protected void doInTransactionWithoutResult(TransactionStatus status) {
updateOperation1();
updateOperation2();
}
});
而基于TransactionManager来完成编程式事务，则是把开启事务，提交以及回滚的操作都完全交给程序员们来实现，因为我们发现TransactionTemplate的底层就是帮助我们实现了开启事务，提交以及回滚的这些公共操作，就好比是一个工具类嘛，这也是Spring推荐我们使用TransactionTemplate的原因，更方便，更安全。最后看一下，怎么完全基于TransactionManager来实现：
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = txManager.getTransaction(def);
try {
// put your business logic here
} catch (MyException ex) {
txManager.rollback(status);
throw ex;
}
txManager.commit(status);
事务绑定事件
前面我们就已经有讲解过Spring的常规事务逻辑，即我们可以通过@EventListener注册常规事件侦听器，没有看过而且不理解的可以去看看之前的文章，@EventListener的监听器会在监听到事件后就立即出发监听逻辑。而如果我们需要将其绑定到事务，即我们可以指定在事务的什么状态下执行这个监听器的逻辑，我们就需要使用@TransactionalEventListener。默认情况下侦听器绑定到事务的提交阶段，也就是当事务正常的提交了才会出发监听器的逻辑，这个的原理我们后面也会详细的讲解，在此先就介绍下如何使用。
关于监听器触发的时机，我们可以通过配置注解的phase属性来设置触发的时机，TransactionPhase的枚举有一下几个值：
- AFTER_COMMIT - 默认设置，在事务提交后执行
- AFTER_ROLLBACK - 在事务回滚后执行
- AFTER_COMPLETION - 在事务完成后执行（不管是否成功）
- BEFORE_COMMIT - 在事务提交前执行
使用案例：
@Service
public class CustomerService {
private final UserRepository userRepository;
private final ApplicationEventPublisher applicationEventPublisher;
public CustomerService(UserRepository userRepository, ApplicationEventPublisher applicationEventPublisher) {
this.userRepository = userRepository;
this.applicationEventPublisher = applicationEventPublisher;
}
@Transactional
public Customer createCustomer(User user) {
User newUser = userRepository.save(user);
final UserCreatedEvent event = new UserCreatedEvent(newUser);
// 客户创建成功了才会发送短信
applicationEventPublisher.publishEvent(event);
return newUser;
}
}
@Component
public class UserCreatedEventListener {
private final EmailService emailService;
public UserCreatedEventListener(EmailService emailService) {
this.emailService = emailService;
}
@TransactionalEventListener
public void processUserCreatedEvent(UserCreatedEvent event) {
emailService.sendEmail(event.getUser().getEmail());
}
}
总结
本文仅仅是介绍了Spring事务的相关概念，包含声明式事务、编程式事务以及事务监听相关的内容，具体的原理我们后面一一道来。
网友评论