Transaction 注解的解析原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {
    public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		// 获取事务注解属性
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		// 先从缓存中拿。如果一个方法的事务注解信息被获取过，就会将其缓存到一个并发安全的map中。后面再获取就从这个缓存中获取。
		// First, see if we have a cached value.
		Object cacheKey = getCacheKey(method, targetClass);
		TransactionAttribute cached = this.attributeCache.get(cacheKey);
		if (cached != null) {
			// 省略...
		}else {
			// TODO 获取事务注解属性，放入缓存。
			// We need to work it out.
			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
			// Put it in the cache.
			if (txAttr == null) {// 放入缓存
				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
			}
			else {
				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
				// 省略...
				this.attributeCache.put(cacheKey, txAttr);
			}
			return txAttr;
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {

	protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		// Don't allow no-public methods as required.
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		// The method may be on an interface, but we need attributes from the target class.
		// If the target class is null, the method will be unchanged.
		Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

		// TODO 重点：查找事务属性，首先从目标方法上查找
		// First try is the method in the target class.
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}
		// 如果目标方法上查找不到，从目标类上查找。
		// Second try is the transaction attribute on the target class.
		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
			return txAttr;
		}
		// 如果方法上找不到，到接口方法、接口上找对应注解。
		if (specificMethod != method) {
			// Fallback is to look at the original method.
			txAttr = findTransactionAttribute(method);
			if (txAttr != null) {
				return txAttr;
			}
			// Last fallback is the class of the original method.
			txAttr = findTransactionAttribute(method.getDeclaringClass());
			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
				return txAttr;
			}
		}

		return null;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource
		implements Serializable {
    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
		// TODO 循环所有的解析器，如果有解析器解析出的结果不为空，则直接返回事务属性，解析器列表是在当前对象构造函数时，加载的
		//  如果是注解方式，用到的注解解析器是：SpringTransactionAnnotationParser
		for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
			TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
			if (attr != null) {
				return attr;
			}
		}
		return null;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

	@Override
	@Nullable
	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {

		// TODO 重点：从方法上查找@Transactional注解，AnnotatedElement是Method、Field的超类
		AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
				element, Transactional.class, false, false);
		if (attributes != null) {
			// TODO 重点：如果从方法上查找到了@Transactional注解，则解析注解中的各个属性值
			return parseTransactionAnnotation(attributes);
		}
		else {
			return null;
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

	protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
		// TODO 此方法主要做对象类型转换，将AnnotationAttributes中的属性赋值到RuleBasedTransactionAttribute中，返回。
		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
		// 解析 @Transactional 中的属性：propagation、isolation、timeout、readOnly、value。
		// 解析后将其封装到 RuleBasedTransactionAttribute 对象中。
		Propagation propagation = attributes.getEnum("propagation");
		rbta.setPropagationBehavior(propagation.value());
		Isolation isolation = attributes.getEnum("isolation");
		rbta.setIsolationLevel(isolation.value());
		rbta.setTimeout(attributes.getNumber("timeout").intValue());
		rbta.setReadOnly(attributes.getBoolean("readOnly"));
		rbta.setQualifier(attributes.getString("value"));

		List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
		for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
			rollbackRules.add(new RollbackRuleAttribute(rbRule));
		}
		for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
			rollbackRules.add(new RollbackRuleAttribute(rbRule));
		}
		for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		rbta.setRollbackRules(rollbackRules);

		return rbta;
	}
}