zcy
/
spring-reading.
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
spring-reading./spring-transaction/spring-transaction-transact.../README.md

332 lines
15 KiB
Markdown
Raw Normal View History

spring事务源码分析
2024-05-28 07:22:28 +00:00
## TransactionAttributeSource
- [TransactionAttributeSource](#TransactionAttributeSource)
- [一、基本信息](#一基本信息)
- [二、基本描述](#二基本描述)
- [三、主要功能](#三主要功能)
- [四、接口源码](#四接口源码)
- [五、主要实现](#五主要实现)
- [六、最佳实践](#六最佳实践)
- [七、源码分析](#七源码分析)
### 一、基本信息
✒️ **作者** - Lex 📝 **博客** - [掘金](https://juejin.cn/user/4251135018533068/posts) 📚 **源码地址
** - [github](https://github.com/xuchengsheng/spring-reading)
### 二、基本描述
`TransactionAttributeSource` 接口是 Spring Framework
中的关键接口，用于提供事务管理的配置信息，通过分析给定的方法和目标类，确定事务的属性，例如传播行为、隔离级别等，为声明式事务提供了灵活性和可定制性。
### 三、主要功能
1. **提供事务属性**
+ 根据给定的方法和目标类，确定事务的属性，包括传播行为、隔离级别、超时时间、只读状态等。
2. **可扩展性**
+ Spring 框架提供了多种实现 `TransactionAttributeSource`
接口的类，如 `NameMatchTransactionAttributeSource`、`AnnotationTransactionAttributeSource`
等，以支持不同的解析策略，例如基于方法名的匹配、基于注解的配置等。
### 四、接口源码
`TransactionAttributeSource` 接口，主要是由 `TransactionInterceptor`
用于元数据检索的策略接口。该接口的实现知道如何获取事务属性，可以从配置、源级别的元数据属性或其他任何地方获取。它包含了两个方法，一个用于确定给定类是否是事务属性的候选类，另一个用于返回给定方法的事务属性。
```java
/**
* {@code TransactionAttributeSource} 接口是由 {@link TransactionInterceptor} 用于元数据检索的策略接口。
* 实现类知道如何获取事务属性，无论是从配置、源级别的元数据属性（例如 Java 5 注解）还是其他任何地方。
*
* @author Rod Johnson
* @author Juergen Hoeller
* @since 15.04.2003
* @see TransactionInterceptor#setTransactionAttributeSource
* @see TransactionProxyFactoryBean#setTransactionAttributeSource
* @see org.springframework.transaction.annotation.AnnotationTransactionAttributeSource
*/
public interface TransactionAttributeSource {
/**
* 确定给定的类是否是此 {@code TransactionAttributeSource} 的元数据格式中事务属性的候选类。
* <p>如果此方法返回 {@code false}，则不会遍历给定类的方法以进行 {@link #getTransactionAttribute} 内省。
* 返回 {@code false} 因此是对非受影响类的优化，而 {@code true} 则意味着必须针对给定类的每个方法进行完全内省。
* @param targetClass 要内省的类
* @return 如果类已知在类级别或方法级别没有事务属性，则返回 {@code false}；否则返回 {@code true}。
* 默认实现返回 {@code true}，导致常规内省。
* @since 5.2
*/
default boolean isCandidateClass(Class<?> targetClass) {
return true;
}
/**
* 返回给定方法的事务属性，如果方法不是事务性的，则返回 {@code null}。
* @param method 要内省的方法
* @param targetClass 目标类（可能为 {@code null}，在这种情况下，必须使用方法的声明类）
* @return 匹配的事务属性，如果未找到则返回 {@code null}
*/
@Nullable
TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass);
}
```
### 五、主要实现
1. **AnnotationTransactionAttributeSource**
+ 用于解析基于注解的事务配置信息的实现类。它能够解析类级别和方法级别的 `@Transactional`
注解，将注解中定义的事务属性转换为 `TransactionAttribute` 对象。
2. **CompositeTransactionAttributeSource**
+ 将多个 `TransactionAttributeSource` 组合在一起。通过组合多个 `TransactionAttributeSource`
对象，可以实现多种事务属性解析策略的混合使用，提高了灵活性和定制性。
3. **MatchAlwaysTransactionAttributeSource**
+ 简单的 `TransactionAttributeSource`
实现，它始终返回相同的事务属性。通常用于简单的场景或者作为其他复杂 `TransactionAttributeSource` 实现的默认备选项。
4. **MethodMapTransactionAttributeSource**
+ 基于方法名匹配的 `TransactionAttributeSource` 实现。它通过配置一个方法名到事务属性的映射表，根据方法名来确定相应的事务属性。
5. **NameMatchTransactionAttributeSource**
+ 根据方法名进行匹配的 `TransactionAttributeSource` 实现。它能够根据配置的方法名模式，匹配目标方法并返回相应的事务属性。
### 六、类关系图
~~~mermaid
classDiagram
direction BT
class AbstractFallbackTransactionAttributeSource
class AnnotationTransactionAttributeSource
class CompositeTransactionAttributeSource
class MatchAlwaysTransactionAttributeSource
class MethodMapTransactionAttributeSource
class NameMatchTransactionAttributeSource
class TransactionAttributeSource {
<<Interface>>
}
AbstractFallbackTransactionAttributeSource ..> TransactionAttributeSource
AnnotationTransactionAttributeSource --> AbstractFallbackTransactionAttributeSource
CompositeTransactionAttributeSource ..> TransactionAttributeSource
MatchAlwaysTransactionAttributeSource ..> TransactionAttributeSource
MethodMapTransactionAttributeSource ..> TransactionAttributeSource
NameMatchTransactionAttributeSource ..> TransactionAttributeSource
~~~
### 六、最佳实践
使用 `AnnotationTransactionAttributeSource` 类来解析基于注解的事务配置信息。通过获取 `ScoresServiceImpl`
类中的 `insertScore` 方法，然后利用 `AnnotationTransactionAttributeSource`
对象来解析该方法的事务属性，最后将解析结果输出到控制台。这样可以帮助我们了解特定方法的事务配置情况，以便进行调试和优化。
```java
public class TransactionAttributeSourceDemo {
public static void main(String[] args) throws NoSuchMethodException {
// 获取 ScoresServiceImpl 类中的 insertScore 方法
Method insertScoreMethod = ScoresServiceImpl.class.getMethod("insertScore");
// 创建一个基于注解的事务属性源对象
TransactionAttributeSource transactionAttributeSource = new AnnotationTransactionAttributeSource();
// 解析 insertScore 方法的事务属性
TransactionAttribute transactionAttribute = transactionAttributeSource.getTransactionAttribute(insertScoreMethod, ScoresServiceImpl.class);
// 输出事务属性
System.out.println(transactionAttribute);
}
}
```
`ScoresServiceImpl` 类实现了 `ScoresService` 接口，其中的 `insertScore` 方法被 `@Transactional`
注解修饰，声明了一个事务。该事务的特性包括只读（readOnly = true），遇到任何异常都会回滚（rollbackFor =
Exception.class），事务隔离级别为可重复读（isolation = Isolation.REPEATABLE_READ），超时时间为 30 秒（timeout =
30），以及标签为 "tx1" 和 "tx2"。
```java
public class ScoresServiceImpl implements ScoresService {
@Override
@Transactional(
readOnly = true,
rollbackFor = Exception.class,
isolation = Isolation.REPEATABLE_READ,
timeout = 30,
label = {"tx1", "tx2"}
)
public void insertScore() {
// TODO
}
}
```
运行结果，事务的传播行为为 `PROPAGATION_REQUIRED`，隔离级别为 `ISOLATION_REPEATABLE_READ`，超时时间为 30
秒，只读模式开启，标签为 "tx1" 和 "tx2"，同时，事务会回滚遇到 `java.lang.Exception` 及其子类的异常。
```java
PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ,timeout_30,readOnly; [tx1,tx2],-java.lang.Exception
```
### 七、源码分析
在`org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#getTransactionAttribute`
方法中，用于确定方法调用的事务属性。如果在方法级别找不到事务属性，则默认使用类级别的事务属性。首先，它检查是否有缓存的事务属性值，如果有则直接返回缓存值，否则计算方法的事务属性并将其放入缓存。在计算事务属性时，会根据方法的限定名来标识方法，如果事务属性是 `DefaultTransactionAttribute`
类型，则设置描述符和解析属性字符串。最后，根据日志级别输出添加事务方法及其属性的日志，并将计算得到的事务属性放入缓存。
```java
/**
* 确定此方法调用的事务属性。
* <p>如果未找到方法属性，则默认为类的事务属性。
* @param method 当前调用的方法（永远不会为 {@code null}）
* @param targetClass 此调用的目标类（可能为 {@code null}）
* @return 此方法的 TransactionAttribute，如果方法不是事务性的，则返回 {@code null}
*/
@Override
@Nullable
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// 如果方法是 Object 类的方法，直接返回 null，因为这些方法不应该是事务性的。
if (method.getDeclaringClass() == Object.class) {
return null;
}
// 首先，查看是否有缓存值。
Object cacheKey = getCacheKey(method, targetClass);
TransactionAttribute cached = this.attributeCache.get(cacheKey);
if (cached != null) {
// 值将是一个规范值，表示没有事务属性，或者是一个实际的事务属性。
if (cached == NULL_TRANSACTION_ATTRIBUTE) {
return null;
}
else {
return cached;
}
}
else {
// 我们需要计算它。
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
// 将其放入缓存。
if (txAttr == null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
}
else {
// 获取方法的限定名，用于在日志中标识方法。
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
// 如果事务属性是 DefaultTransactionAttribute 类型，设置描述符和解析属性字符串。
if (txAttr instanceof DefaultTransactionAttribute) {
DefaultTransactionAttribute dta = (DefaultTransactionAttribute) txAttr;
dta.setDescriptor(methodIdentification);
dta.resolveAttributeStrings(this.embeddedValueResolver);
}
// 如果日志级别为 TRACE，输出添加事务方法及其属性的日志。
if (logger.isTraceEnabled()) {
logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
}
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
}
```
在`org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#computeTransactionAttribute`
方法中，首先检查方法是否是公共方法，并根据情况从目标类或原始方法中查找事务属性。如果找到了事务属性，则返回该属性；否则返回
null。
```java
/**
* 与 {@link #getTransactionAttribute} 具有相同的签名，但不缓存结果。
* {@link #getTransactionAttribute} 实际上是此方法的缓存装饰器。
* <p>从 4.1.8 版本开始，此方法可以被重写。
* @since 4.1.8
* @see #getTransactionAttribute
*/
@Nullable
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// 如果只允许公共方法，并且方法不是公共的，则不允许。
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
// 方法可能在接口上，但我们需要从目标类获取属性。
// 如果目标类为 null，则方法不会改变。
Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
// 首先尝试目标类中的方法。
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
if (txAttr != null) {
return txAttr;
}
// 其次尝试目标类上的事务属性。
txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
if (specificMethod != method) {
// 回退到原始方法。
txAttr = findTransactionAttribute(method);
if (txAttr != null) {
return txAttr;
}
// 最后回退到原始方法的类。
txAttr = findTransactionAttribute(method.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
}
return null;
}
```
在`org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#findTransactionAttribute(java.lang.reflect.Method)`
方法中，调用了 `determineTransactionAttribute` 方法来确定给定方法的事务属性，并将其返回。如果无法确定事务属性，则返回 null。
```java
@Override
@Nullable
protected TransactionAttribute findTransactionAttribute(Method method) {
return determineTransactionAttribute(method);
}
```
在`org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#determineTransactionAttribute`
方法中，用于确定给定方法或类的事务属性。它通过配置的 `TransactionAnnotationParsers` 来解析已知注解，并将其转换为 Spring
的元数据属性类。如果找不到事务属性，则返回 null。该方法可以被重写以支持携带事务元数据的自定义注解。
```java
/**
* 确定给定方法或类的事务属性。
* <p>此实现委托给配置的 {@link TransactionAnnotationParser TransactionAnnotationParsers}，
* 用于将已知的注解解析为 Spring 的元数据属性类。
* 如果不是事务性的，则返回 {@code null}。
* <p>可以重写此方法以支持携带事务元数据的自定义注解。
* @param element 带有注解的方法或类
* @return 配置的事务属性，如果找不到则返回 {@code null}
*/
@Nullable
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
// 遍历所有的 TransactionAnnotationParser 实例
for (TransactionAnnotationParser parser : this.annotationParsers) {
// 解析注解，获取事务属性
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
// 如果找到事务属性，则返回
if (attr != null) {
return attr;
}
}
// 如果未找到事务属性，则返回 null
return null;
}
```