AnnotationTransactionAttributeSource
该类读取Spring的 {@link Transactional} 注解并将相应的事务属性TransactionAttribute暴露给 Spring 的事务管理器，如PlatformTransactionManager，ReactiveTransactionManager。
还支持 JTA 1.2 的 {@link javax.transaction.Transactional} 和 EJB3 的 {@link javax.ejb.TransactionAttribute}注解。
从该类的名称以Annotation开头就可以知道，该类是通过注解的形式设置TransactionAttribute并进行解析，此类会委托相应的注解解析类annotationParsers解析相应的注解，并放入到缓存中(该缓存在父类中)，key是方法+类的名称，value是相应的事务属性TransactionAttribute。
该事务属性源是一个全局的属性源，记录着Spring容器中所有的事务方法的事务信息，供事务管理器TransactionManager使用。
public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource
implements Serializable {
private static final boolean jta12Present;
private static final boolean ejb3Present;
static {
ClassLoader classLoader = AnnotationTransactionAttributeSource.class.getClassLoader();
//如果javax.transaction.Transactional类存在或者可以被加载，则表示要支持该类型的事务
jta12Present = ClassUtils.isPresent("javax.transaction.Transactional", classLoader);
//如果javax.ejb.TransactionAttribute类存在或者可以被加载，则表示要支持该类型的事务
ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute", classLoader);
}
//是否只支持public方法为事务型方法
private final boolean publicMethodsOnly;
//事务注解解析器集合
private final Set<TransactionAnnotationParser> annotationParsers;
//创建一个默认的AnnotationTransactionAttributeSource，
//支持带有@Transactional注解的公共方法或EJB3 {@link javax.ejb.TransactionAttribute}注解的公共方法
public AnnotationTransactionAttributeSource() {
this(true);
}
public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
this.publicMethodsOnly = publicMethodsOnly;
if (jta12Present || ejb3Present) {
//设置注解解析器
this.annotationParsers = new LinkedHashSet<>(4);
//添加Spring的事务org.springframework.transaction.annotation.Transactional注解解析器
this.annotationParsers.add(new SpringTransactionAnnotationParser());
//支持javax.transaction.Transactional注解的解析器
if (jta12Present) {
this.annotationParsers.add(new JtaTransactionAnnotationParser());
}
//支持javax.ejb.TransactionAttribute注解的解析器
if (ejb3Present) {
this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
}
}
else {
//添加Spring的事务org.springframework.transaction.annotation.Transactional注解解析器
this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
}
}
//根据TransactionAnnotationParser创建AnnotationTransactionAttributeSource
public AnnotationTransactionAttributeSource(TransactionAnnotationParser annotationParser) {
this.publicMethodsOnly = true;
Assert.notNull(annotationParser, "TransactionAnnotationParser must not be null");
this.annotationParsers = Collections.singleton(annotationParser);
}
public AnnotationTransactionAttributeSource(TransactionAnnotationParser... annotationParsers) {
this.publicMethodsOnly = true;
Assert.notEmpty(annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
this.annotationParsers = new LinkedHashSet<>(Arrays.asList(annotationParsers));
}
public AnnotationTransactionAttributeSource(Set<TransactionAnnotationParser> annotationParsers) {
this.publicMethodsOnly = true;
Assert.notEmpty(annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
this.annotationParsers = annotationParsers;
}
@Override
public boolean isCandidateClass(Class<?> targetClass) {
for (TransactionAnnotationParser parser : this.annotationParsers) {
if (parser.isCandidateClass(targetClass)) {
return true;
}
}
return false;
}
//获取该类上的事务属性
protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
return determineTransactionAttribute(clazz);
}
//获取该方法上的事务属性
protected TransactionAttribute findTransactionAttribute(Method method) {
return determineTransactionAttribute(method);
}
//解析AnnotatedElement的事务属性。
//此实现委托给已配置的TransactionAnnotationParsers用于将已知注释解析为Spring的元数据属性类，如果不是事务型的，则返回null
//可以通过方法重写用于支持自定义的事务注解
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
for (TransactionAnnotationParser parser : this.annotationParsers) {
//调用事务注解解析器类解析该注解元素AnnotatedElement
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
if (attr != null) {
return attr;
}
}
return null;
}
//默认情况下只有public方法可以是事务型方法
@Override
protected boolean allowPublicMethodsOnly() {
return this.publicMethodsOnly;
}
}
AbstractFallbackTransactionAttributeSource
AnnotationTransactionAttributeSource的抽象父类，使用模板模式，提供了获取目标方法，目标类的统一方法，具体的获取实现交给不同的子类对特定的属性进行解析获取
-
如果事务没有与目标方法关联，则默认使用目标类的事务属性；与目标方法关联的任何事务属性都会完全覆盖类事务属性。
-
在首次使用属性后按方法缓存属性，key是方法+类的名称，value是相应的事务属性
TransactionAttribute。
public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {
//无事务属性对象，表示在该方法上没有找到事务属性，并且我们不需要再次查找了
@SuppressWarnings("serial")
private static final TransactionAttribute NULL_TRANSACTION_ATTRIBUTE = new DefaultTransactionAttribute() {
@Override
public String toString() {
return "null";
}
};
//事务属性TransactionAttribute缓存，由目标类上的方法作为key
private final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>(1024);
@Override
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
if (method.getDeclaringClass() == Object.class) {
return null;
}
//先从缓存中查找给定的方法和目标类是否有TransactionAttribute
Object cacheKey = getCacheKey(method, targetClass);
TransactionAttribute cached = this.attributeCache.get(cacheKey);
//在缓存中找到了TransactionAttribute
if (cached != null) {
//如果缓存的结果是NULL_TRANSACTION_ATTRIBUTE，则返回null
if (cached == NULL_TRANSACTION_ATTRIBUTE) {
return null;
}
//返回TransactionAttribute
else {
return cached;
}
}
//在缓存中没有找到TransactionAttribute
else {
// 从给定的方法和目标类中提取TransactionAttribute
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
// 将提取的结果放入到缓存中
// 如果提取的结果是null，则将NULL_TRANSACTION_ATTRIBUTE放入到缓存中，表示该方法和目标类中没有TransactionAttribute，并且不需要再次进行提取
if (txAttr == null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
}
//如果提取的结果不是null，则将其放入缓存中
else {
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
if (txAttr instanceof DefaultTransactionAttribute) {
((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
}
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
}
//确定给定方法和目标类的缓存key
//不同实例的相同方法必须生成相同的缓存key，不能为重载的方法生成相同的缓存key
protected Object getCacheKey(Method method, @Nullable Class<?> targetClass) {
return new MethodClassKey(method, targetClass);
}
//从给定方法和目标类上提取TransactionAttribute
@Nullable
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// 如果只允许public方法作为事务型方法，则非public就返回null
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
//给定一个可能来自接口的方法和当前AOP调用中使用的目标类，找到对应的目标方法。
//方法可能是一个接口的方法，但是我们需要来自目标类的属性
Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
// 首先从目标类的特定方法上找到TransactionAttribute
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
if (txAttr != null) {
return txAttr;
}
// 其次从目标类上找TransactionAttribute
txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
// 再次进一步找TransactionAttribute
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;
}
//子类需要实现这个方法，返回从给定的类中提取的TransactionAttribute，如果没有则返回null
@Nullable
protected abstract TransactionAttribute findTransactionAttribute(Class<?> clazz);
//子类需要实现则会个方法，返回从给定的方法中提取的TransactionAttribute，如果没有则返回null
@Nullable
protected abstract TransactionAttribute findTransactionAttribute(Method method);
protected boolean allowPublicMethodsOnly() {
return false;
}
}
SpringTransactionAnnotationParser
Spring的事务org.springframework.transaction.annotation.Transactional注解解析器
public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
//实现接口方法
@Override
public boolean isCandidateClass(Class<?> targetClass) {
return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
}
//实现接口方法，解析该AnnotatedElement中@Transactional注解的事务属性
@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
//
if (attributes != null) {
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
}
//解析注解属性得到TransactionAttribute
protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
//这些就是我们平时在@Transactional中常设置的事务属性
//设置事务的传播属性
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"));
//设置事务管理器的名称transactionManager
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;
}
}
TransactionAttribute
public interface TransactionAttribute extends TransactionDefinition {
//返回与此事务属性关联的限定符值
//这可以用于选择相应的事务管理器(transaction manager)来处理这个特定的事务，在TransactionInterceptor#invokeWithinTransaction中会根据该值找相应的事务管理器。
String getQualifier();
//判断指定的异常是否进行回滚
boolean rollbackOn(Throwable ex);
}
TransactionDefinition
public interface TransactionDefinition {
int PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;
int ISOLATION_DEFAULT = -1;
// same as java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
int ISOLATION_READ_UNCOMMITTED = 1;
// same as java.sql.Connection.TRANSACTION_READ_COMMITTED;
int ISOLATION_READ_COMMITTED = 2;
// same as java.sql.Connection.TRANSACTION_REPEATABLE_READ;
int ISOLATION_REPEATABLE_READ = 4;
// same as java.sql.Connection.TRANSACTION_SERIALIZABLE;
int ISOLATION_SERIALIZABLE = 8;
//默认使用底层事务系统的超时事件，即数据库的超时事件
int TIMEOUT_DEFAULT = -1;
//获取事务的传播行为
default int getPropagationBehavior() {
return PROPAGATION_REQUIRED;
}
//获取事务的隔离级别
default int getIsolationLevel() {
return ISOLATION_DEFAULT;
}
default int getTimeout() {
return TIMEOUT_DEFAULT;
}
default boolean isReadOnly() {
return false;
}
@Nullable
default String getName() {
return null;
}
static TransactionDefinition withDefaults() {
return StaticTransactionDefinition.INSTANCE;
}
}
DefaultTransactionDefinition
public class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
/** Prefix for the propagation constants defined in TransactionDefinition. */
public static final String PREFIX_PROPAGATION = "PROPAGATION_";
/** Prefix for the isolation constants defined in TransactionDefinition. */
public static final String PREFIX_ISOLATION = "ISOLATION_";
/** Prefix for transaction timeout values in description strings. */
public static final String PREFIX_TIMEOUT = "timeout_";
/** Marker for read-only transactions in description strings. */
public static final String READ_ONLY_MARKER = "readOnly";
/** Constants instance for TransactionDefinition. */
static final Constants constants = new Constants(TransactionDefinition.class);
//事务传播特性，默认为REQUIRED
private int propagationBehavior = PROPAGATION_REQUIRED;
//事务隔离级别
private int isolationLevel = ISOLATION_DEFAULT;
//事务超时时间
private int timeout = TIMEOUT_DEFAULT;
private boolean readOnly = false;
@Nullable
private String name;
public DefaultTransactionDefinition() {}
public DefaultTransactionDefinition(TransactionDefinition other) {
this.propagationBehavior = other.getPropagationBehavior();
this.isolationLevel = other.getIsolationLevel();
this.timeout = other.getTimeout();
this.readOnly = other.isReadOnly();
this.name = other.getName();
}
public DefaultTransactionDefinition(int propagationBehavior) {
this.propagationBehavior = propagationBehavior;
}
public final void setPropagationBehavior(int propagationBehavior) {
if (!constants.getValues(PREFIX_PROPAGATION).contains(propagationBehavior)) {
throw new IllegalArgumentException("Only values of propagation constants allowed");
}
this.propagationBehavior = propagationBehavior;
}
@Override
public final int getPropagationBehavior() {
return this.propagationBehavior;
}
public final void setIsolationLevel(int isolationLevel) {
if (!constants.getValues(PREFIX_ISOLATION).contains(isolationLevel)) {
throw new IllegalArgumentException("Only values of isolation constants allowed");
}
this.isolationLevel = isolationLevel;
}
@Override
public final int getIsolationLevel() {
return this.isolationLevel;
}
//设置事务超时时间，单位是秒，默认值为-1
public final void setTimeout(int timeout) {
if (timeout < TIMEOUT_DEFAULT) {
throw new IllegalArgumentException("Timeout must be a positive integer or TIMEOUT_DEFAULT");
}
this.timeout = timeout;
}
@Override
public final int getTimeout() {
return this.timeout;
}
public final void setReadOnly(boolean readOnly) {
this.readOnly = readOnly;
}
}
DefaultTransactionAttribute
public class DefaultTransactionAttribute extends DefaultTransactionDefinition implements TransactionAttribute {
@Nullable
private String qualifier;
@Nullable
private String descriptor;
//默认回滚的异常RuntimeException和Error
@Override
public boolean rollbackOn(Throwable ex) {
return (ex instanceof RuntimeException || ex instanceof Error);
}
//其他代码省略
}
RuleBasedTransactionAttribute
public class RuleBasedTransactionAttribute extends DefaultTransactionAttribute implements Serializable {
/** Prefix for rollback-on-exception rules in description strings. */
public static final String PREFIX_ROLLBACK_RULE = "-";
/** Prefix for commit-on-exception rules in description strings. */
public static final String PREFIX_COMMIT_RULE = "+";
@Nullable
private List<RollbackRuleAttribute> rollbackRules;
@Override
public boolean rollbackOn(Throwable ex) {
RollbackRuleAttribute winner = null;
int deepest = Integer.MAX_VALUE;
if (this.rollbackRules != null) {
for (RollbackRuleAttribute rule : this.rollbackRules) {
int depth = rule.getDepth(ex);
if (depth >= 0 && depth < deepest) {
deepest = depth;
winner = rule;
}
}
}
// User superclass behavior (rollback on unchecked) if no rule matches.
if (winner == null) {
return super.rollbackOn(ex);
}
return !(winner instanceof NoRollbackRuleAttribute);
}
扫一扫
1007
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
