【小家Spring】Spring事务相关的基础类打点(spring-jdbc和spring-tx两个jar)，着重讲解AnnotationTransactionAttributeSource

// 它继承自TransactionDefinition ，所有可以定义事务的基础属性
public interface TransactionAttribute extends TransactionDefinition {
	 // 返回与此事务属性关联的限定符值
	//@since 3.0
	@Nullable
	String getQualifier();
	// Should we roll back on the given exception?
	boolean rollbackOn(Throwable ex);
}

// 它继承自DefaultTransactionDefinition 
public class DefaultTransactionAttribute extends DefaultTransactionDefinition implements TransactionAttribute {

	@Nullable
	private String qualifier;
	@Nullable
	private String descriptor;

	// 你自己也可以自定义一个TransactionAttribute other 来替换掉一些默认行为
	public DefaultTransactionAttribute() {
		super();
	}
	public DefaultTransactionAttribute(TransactionAttribute other) {
		super(other);
	}

	// @since 3.0
	public void setQualifier(@Nullable String qualifier) {
		this.qualifier = qualifier;
	}
	@Override
	@Nullable
	public String getQualifier() {
		return this.qualifier;
	}
	...
	// 可以清晰的看到：默认只回滚RuntimeException 或者 Error(比如OOM这种)
	@Override
	public boolean rollbackOn(Throwable ex) {
		return (ex instanceof RuntimeException || ex instanceof Error);
	}
	
}

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 = "+";

	// RollbackRuleAttribute：它是个实体类，确定给定异常是否应导致回滚的规则
	// 相当于封装了这个规则的一个实体，内部封装一个异常  提供一个实例变量： 这个变量相当于回滚规则为只回滚RuntimeException
	// public static final RollbackRuleAttribute ROLLBACK_ON_RUNTIME_EXCEPTIONS = new RollbackRuleAttribute(RuntimeException.class);
	// 所以此类最重要的一个属性，就是这个，它能维护多种回滚的规则~~~~
	@Nullable
	private List<RollbackRuleAttribute> rollbackRules;
	...
	public List<RollbackRuleAttribute> getRollbackRules() {
		if (this.rollbackRules == null) {
			this.rollbackRules = new LinkedList<>();
		}
		return this.rollbackRules;
	}

	// 核心逻辑输入，复写了父类的rollbackOn方法。也就是看看当前异常是否需要回滚呢？？？
	@Override
	public boolean rollbackOn(Throwable ex) {
		RollbackRuleAttribute winner = null;
		int deepest = Integer.MAX_VALUE;

		// 这里getDepth()就是去看看异常栈里面  该类型的异常处于啥位置。
		// 这里用了Integer的最大值，基本相当于不管异常有多深，遇上此异常都应该回滚喽，也就是找到这个winnner了~~~~~
		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.
		// 这句相当于：如果你没有指定回滚规则，那就交给父类吧（只回滚RuntimeException和Error类型）
		if (winner == null) {
			return super.rollbackOn(ex);
		}
		
		// 最终只要找到了，但是不是NoRollbackRuleAttribute类型就成`~~~~
		return !(winner instanceof NoRollbackRuleAttribute);
	}
}

// @since 5.1
// 指示资源事务，尤其是事务性资源是否准备好进行本地优化
public interface ResourceTransactionDefinition extends TransactionDefinition {
	// 确定事务性资源是否准备好进行本地优化
	// @see #isReadOnly()
	boolean isLocalResource();
}

public interface TransactionAttributeSource {
	// 通过Method和目标类，拿到事务属性~~~
	// 比如我们的@Transaction是标注在方法上的，可议自定义方法级别的事务属性，用它就特别的方便~
	@Nullable
	TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass);

}

    // 自定义配置一个事务拦截器（@Transaction注解也会使用此拦截器进行拦截）
    @Bean
    public TransactionInterceptor transactionInterceptor(PlatformTransactionManager transactionManager) {
        Map<String, TransactionAttribute> txMap = new HashMap<>();
        // required事务  适用于觉得部分场景~
        RuleBasedTransactionAttribute requiredTx = new RuleBasedTransactionAttribute();
        requiredTx.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(RuntimeException.class)));
        requiredTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        txMap.put("add*", requiredTx);
        txMap.put("save*", requiredTx);
        txMap.put("insert*", requiredTx);
        txMap.put("update*", requiredTx);
        txMap.put("delete*", requiredTx);

        // 查询 使用只读事务
        RuleBasedTransactionAttribute readOnlyTx = new RuleBasedTransactionAttribute();
        readOnlyTx.setReadOnly(true);
        readOnlyTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
        txMap.put("get*", readOnlyTx);
        txMap.put("query*", readOnlyTx);

        // 定义事务属性的source~~~ 此处使用它  也就是根据方法名进行匹配的~~~
        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
        source.setNameMap(txMap);
        return new TransactionInterceptor(transactionManager, source);
    }

// @since 2.0 它是Spring2.0后才推出来的
public class CompositeTransactionAttributeSource implements TransactionAttributeSource, Serializable {
	private final TransactionAttributeSource[] transactionAttributeSources;
	public CompositeTransactionAttributeSource(TransactionAttributeSource... transactionAttributeSources) {
		Assert.notNull(transactionAttributeSources, "TransactionAttributeSource array must not be null");
		this.transactionAttributeSources = transactionAttributeSources;
	}
		
	// 这个实现方法也很容易。多个TransactionAttributeSource放在一起，只要任意一个匹配上就成
	// 备注：若匹配上多个，请注意先后顺序就成   这里面是数组  会保持和你放入的顺序一样~~~
	@Override
	@Nullable
	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		for (TransactionAttributeSource source : this.transactionAttributeSources) {
			TransactionAttribute attr = source.getTransactionAttribute(method, targetClass);
			if (attr != null) {
				return attr;
			}
		}
		return null;
	}
}

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource implements Serializable {

	// 这个是“向下兼容”，JavaEE提供的其余两种注解~~
	private static final boolean jta12Present; //JTA 1.2事务注解
	private static final boolean ejb3Present; //EJB 3 事务注解是
	static {
		ClassLoader classLoader = AnnotationTransactionAttributeSource.class.getClassLoader();
		jta12Present = ClassUtils.isPresent("javax.transaction.Transactional", classLoader);
		ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute", classLoader);
	}
	
	// true：只处理public方法（基于JDK的代理  显然就只会处理这种方法）
	// false：private/protected等方法都会处理。   基于AspectJ代理得方式可议设置为false
	// 默认情况下：会被赋值为true，表示只处理public的方法
	private final boolean publicMethodsOnly;
	// 保存用于分析事务注解的事务注解分析器   这个注解分析的解析器是重点
	private final Set<TransactionAnnotationParser> annotationParsers;

	// 构造函数, publicMethodsOnly 缺省使用 true
	public AnnotationTransactionAttributeSource() {
		this(true);
	}
	public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
		this.publicMethodsOnly = publicMethodsOnly;
		if (jta12Present || ejb3Present) {
			this.annotationParsers = new LinkedHashSet<>(4);
			this.annotationParsers.add(new SpringTransactionAnnotationParser());
			if (jta12Present) {
				this.annotationParsers.add(new JtaTransactionAnnotationParser());
			}
			if (ejb3Present) {
				this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
			}
		} 
		// 默认情况下，只添加Spring自己的注解解析器（绝大部分情况都实这里）
		else {
			this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
		}
	}
	// 自己也可以指定一个TransactionAnnotationParser   或者多个也成
	public AnnotationTransactionAttributeSource(TransactionAnnotationParser annotationParser) {	... }
	public AnnotationTransactionAttributeSource(TransactionAnnotationParser... annotationParsers) { ... }
	public AnnotationTransactionAttributeSource(Set<TransactionAnnotationParser> annotationParsers) { ... }

	// 获取某个类/方法上的事务注解属性（属于 父类的抽象方法）
	@Override
	@Nullable
	protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
		return determineTransactionAttribute(clazz);
	}
	@Override
	@Nullable
	protected TransactionAttribute findTransactionAttribute(Method method) {
		return determineTransactionAttribute(method);
	}

	// 具体实现如下：
	// 分析获取某个被注解的元素（AnnotatedElement ），具体的来讲，指的是一个类或者一个方法上的事务注解属性。
	// 实现会遍历自己属性annotationParsers中所包含的事务注解属性分析器试图获取事务注解属性  所以主要还是依赖于TransactionAnnotationParser 去解析的
	@Nullable
	protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
		for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
			TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
			if (attr != null) {
				return attr;
			}
		}
		return null;
	}

	/**
	 * By default, only public methods can be made transactional.
	 */
	@Override
	protected boolean allowPublicMethodsOnly() {
		return this.publicMethodsOnly;
	}
	...
}

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {

	// 针对没有事务注解属性的方法进行事务注解属性缓存时使用的特殊值，用于标记该方法没有事务注解属性
	// 从而不用在首次缓存在信息后，不用再次重复执行真正的分析  来提高查找的效率
	// 标注了@Transaction注解的表示有事务属性的，才会最终加入事务。但是，但是此处需要注意的是，只要被事务的Advisor切中的，都会缓存起来  放置过度的查找~~~~ 因此才有这个常量的出现
	private static final TransactionAttribute NULL_TRANSACTION_ATTRIBUTE = new DefaultTransactionAttribute() {
		@Override
		public String toString() {
			return "null";
		}
	};

	// 方法上的事务注解属性缓存，key使用目标类上的方法，使用类型MethodClassKey来表示
	// 这个Map会比较大，会被事务相关的Advisor拦截下来的方法，最终都会缓存下来。关于事务相关的Advisor，后续也是会着重讲解的~~~
	// 因为会有很多，所以我们才需要一个NULL_TRANSACTION_ATTRIBUTE常量来提高查找的效率~~~
	private final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>(1024);

	// 获取指定方法上的注解事务属性   如果方法上没有注解事务属性，则使用目标方法所属类上的注解事务属性
	@Override
	@Nullable
	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		// 如果目标方法是内置类Object上的方法，总是返回null，这些方法上不应用事务
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		// 先看缓存里有木有，此处使用的非常经典的MethodClassKey作为Map的key
		Object cacheKey = getCacheKey(method, targetClass);
		TransactionAttribute cached = this.attributeCache.get(cacheKey);
		if (cached != null) {
			//目标方法上上并没有事务注解属性，但是已经被尝试分析过并且已经被缓存，
			// 使用的值是 NULL_TRANSACTION_ATTRIBUTE,所以这里再次尝试获取其注解事务属性时，直接返回 null
			if (cached == NULL_TRANSACTION_ATTRIBUTE) {
				return null;
			} else {
				return cached;
			}
		}
		// 缓存没有命中~~~~
		else {
			// 通过方法、目标Class 分析出此方法上的事务属性~~~~~
			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
			// 如果目标方法上并没有使用注解事务属性，也缓存该信息，只不过使用的值是一个特殊值:
			if (txAttr == null) {
				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
			}
			// 存在目标属性~ 就put到里面去。
			// 获取到methodIdentification  基本只为了输出日志~~~
			else {
				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
				if (txAttr instanceof DefaultTransactionAttribute) {
					((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
				}
				this.attributeCache.put(cacheKey, txAttr);
			}
			return txAttr;
		}
	}

	//查找目标方法上的事务注解属性 也是上面的核心方法
	@Nullable
	protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		// 如果事务注解属性分析仅仅针对public方法，而当前方法不是public，则直接返回null
		// 如果是private，AOP是能切入，代理对象也会生成的  但就是事务不回生效的~~~~
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		// 上面说了，因为Method并不一样属于目标类。所以这个方法就是获取targetClass上的那个和method对应的方法  也就是最终要执行的方法
		Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

		// 第一步：去找直接标记在方法上的事务属性~~~ 如果方法上有就直接返回（不用再看类上的了）
		// findTransactionAttribute这个方法其实就是子类去实现的
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}

		// 然后尝试检查事务注解属性是否标记在目标方法 specificMethod（注意此处用不是Method） 所属类上
		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
			return txAttr;
		}

		// 程序走到这里说明目标方法specificMethod，也就是实现类上的目标方法上没有标记事务注解属性（否则直接返回了嘛）
		
		// 如果 specificMethod 和 method 不同，则说明 specificMethod 是具体实现类的方法method 是实现类所实现接口的方法
		// 因此再次尝试从 method 上获取事务注解属性
		// 这也就是为何我们的@Transaction标注在接口上或者接口的方法上都是好使的原因~~~~~~~
		if (specificMethod != method) {
			// Fallback is to look at the original method.
			txAttr = findTransactionAttribute(method);
			if (txAttr != null) {
				return txAttr;
			}
			txAttr = findTransactionAttribute(method.getDeclaringClass());
			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
				return txAttr;
			}
		}
		return null;
	}

	// 可议看到默认值是false  表示private的也是ok的
	// 但是`AnnotationTransactionAttributeSource`复写了它  可以由开发者指定（默认是true了）
	protected boolean allowPublicMethodsOnly() {
		return false;
	}

}

// @since 2.5
public interface TransactionAnnotationParser {
	@Nullable
	TransactionAttribute parseTransactionAnnotation(AnnotatedElement element);

}

// @since 2.5 此类的实现相对来说还是比较简单的
public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
	
	// 此方法对外暴露，表示获取该方法/类上面的TransactionAttribute 
	@Override
	@Nullable
	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
		AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(element, Transactional.class, false, false);
		if (attributes != null) {
			// 此处注意，把这个注解的属性交给它，最终转换为事务的属性类~~~~
			return parseTransactionAnnotation(attributes);
		}
		// 注解都木有，那就返回null
		else {
			return null;
		}
	}

	// 顺便提供的一个重载方法，可以让你直接传入一个注解
	public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
		return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
	}

	// 这个简单的说：就是把注解的属性们 专门为事务属性们~~~~
	protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
		// 此处用的 RuleBasedTransactionAttribute  因为它可议指定不需要回滚的类~~~~
		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
		
		// 事务的传播属性枚举：内部定义了7种事务传播行为~~~~~
		Propagation propagation = attributes.getEnum("propagation");
		rbta.setPropagationBehavior(propagation.value());
		
		// 事务的隔离级别枚举。一共是4中，枚举里提供一个默认值: 也就是上面我们说的TransactionDefinition.ISOLATION_DEFAULT
		// 至于默认值是哪种隔离界别：这个具体的数据库有关~~~
		Isolation isolation = attributes.getEnum("isolation");
		rbta.setIsolationLevel(isolation.value());
	
		// 设置事务的超时时间
		rbta.setTimeout(attributes.getNumber("timeout").intValue());
		// 是否是只读事务
		rbta.setReadOnly(attributes.getBoolean("readOnly"));
		// 这个属性，是指定事务管理器PlatformTransactionManager的BeanName的，若不指定，那就按照类型找了
		// 若容器中存在多个事务管理器，但又没指定名字  那就报错啦~~~
		rbta.setQualifier(attributes.getString("value"));

		// rollbackFor可以指定需要回滚的异常，可议指定多个  若不指定默认为RuntimeException
		// 此处使用的RollbackRuleAttribute包装~~~~  它就是个POJO没有实现其余接口
		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));
		}


		// 指定不需要回滚的异常类型们~~~
		// 此处使用的NoRollbackRuleAttribute包装  它是RollbackRuleAttribute的子类
		for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		// 最后别忘了set进去
		rbta.setRollbackRules(rollbackRules);

		return rbta;
	}
}

// @since 1.1
public interface SavepointManager {
	Object createSavepoint() throws TransactionException;
	void rollbackToSavepoint(Object savepoint) throws TransactionException;
	void releaseSavepoint(Object savepoint) throws TransactionException;
}

// @since 1.1  继承自SmartTransactionObject 
public abstract class JdbcTransactionObjectSupport implements SavepointManager, SmartTransactionObject {
	
	// 这是Spring定义的类，持有java.sql.Connection
	// 所以最支不支持还原点、创建还原点其实都是委托给它来的~
	@Nullable
	private ConnectionHolder connectionHolder;
	...
}