【小家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;
  }
}