三TCC-transaction分布式事务关键组件--2事务拦截器
三 TCC-transaction分布式事务关键组件--2事务拦截器
2.2.3 事务拦截器
TCC有两个拦截器：
CompensableTransactionInterceptor：可补偿事务拦截器
用于tcc事务的流程执行begin（try)、commit(confirm)、rollback(cancel)
ResourceCoordinatorInterceptor：资源协调拦截器
用于记录tcc事务的Participant（参与方）
这两个拦截器，例如ResourceCoordinatorInterceptor，其基于@Compensable注解在try方法上、@Aspect注解在aspect类上作为切面类，能够拦截事务的try方法。在参与者的try方法前后是around切面逻辑，拦截器在try目标方法执行前后，分别调用两个拦截器内的方法，实现TCC事务的透明化执行过程。
@Aspect
public abstract class ResourceCoordinatorAspect {
private ResourceCoordinatorInterceptor resourceCoordinatorInterceptor = new ResourceCoordinatorInterceptor();
@Pointcut("@annotation(org.mengyun.tcctransaction.api.Compensable) || @annotation(org.mengyun.tcctransaction.api.EnableTcc)")
public void transactionResourcePointcut() {
}
@Around("transactionResourcePointcut()")
public Object interceptTransactionResourceMethodWithCompensableAnnotation(ProceedingJoinPoint pjp) throws Throwable {
Method method = ((MethodSignature) pjp.getSignature()).getMethod();
Compensable compensable = method.getAnnotation(Compensable.class);
return interceptTransactionContextMethod(new AspectJTransactionMethodJoinPoint(pjp, compensable, ThreadLocalTransactionContextEditor.class));
}
0 @Compensable注解
该注解标注在参与者的try方法上，并指定cancel/confirm方法名、事务的传播级别
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Compensable {
//指定事务传播级别
public Propagation propagation() default Propagation.REQUIRED;
//指定cc方法
public String confirmMethod() default "";
public String cancelMethod() default "";
//是否异步执行
public boolean asyncConfirm() default false;
public boolean asyncCancel() default false;
}
传播级别定义：
public enum Propagation {
/**
* 支持当前事务，如果当前没有事务，就新建一个事务。
*/
REQUIRED(0),
/**
* 支持当前事务，如果当前没有事务，就以非事务方式执行。
*/
SUPPORTS(1),
/**
* 支持当前事务，如果当前没有事务，就抛出异常。
*/
MANDATORY(2),
/**
* 新建事务，如果当前存在事务，把当前事务挂起。
*/
REQUIRES_NEW(3);
1 CompensableTransactionInterceptor可补偿事务拦截器
用于tcc事务的流程执行begin（try)、commit(confirm)、rollback(cancel)
(1)CompensableTransactionAspect切面类
//配置当前类为aspect切面类（springAOP）
@Aspect
public abstract class CompensableTransactionAspect {
//切面类内对目标方法拦截，需要调用拦截器执行具体的TCC框架逻辑
private CompensableTransactionInterceptor compensableTransactionInterceptor = new CompensableTransactionInterceptor();
//设置拦截器内的TransactionManager
public void setTransactionManager(TransactionManager transactionManager) {
this.compensableTransactionInterceptor.setTransactionManager(transactionManager);
}
//配置@Compensable标注的方法为切点
@Pointcut("@annotation(org.mengyun.tcctransaction.api.Compensable)")
public void compensableTransactionPointcut() {
}
//在切点处，配置around环绕执行的逻辑
@Around("compensableTransactionPointcut()")
public Object interceptCompensableMethod(ProceedingJoinPoint pjp) throws Throwable {
//获取@Compensable注解的方法对象
Method method = ((MethodSignature) pjp.getSignature()).getMethod();
Compensable compensable = method.getAnnotation(Compensable.class);
return compensableTransactionInterceptor.interceptCompensableMethod(new AspectJTransactionMethodJoinPoint(pjp, compensable, ThreadLocalTransactionContextEditor.class));
}
//获取当前切面执行的优先级
public abstract int getOrder();
}
(2)ConfigurableTransactionAspect 切面配置类（执行优先级）
@Aspect
public class ConfigurableTransactionAspect extends CompensableTransactionAspect implements Ordered {
@Override
public int getOrder() {
return Ordered.HIGHEST_PRECEDENCE; //指定当前切面的优先级
}
@Autowired
public void setTransactionManager(TransactionManagerFactory transactionManagerFactory) {
super.setTransactionManager(transactionManagerFactory.getTransactionManager());
}
}
当前切面配置类，主要是实现orderde接口，定义切面的优先级Ordered.HIGHEST_PRECEDENCE（ResourceCoordinatorInterceptor配置的优先级为Ordered.HIGHEST_PRECEDENCE+1，所以执行时，位于后面，先执行CompensableTransactionAspect）
(3)CompensableTransactionInterceptor拦截器
public class CompensableTransactionInterceptor {
//拦截器中持有transactionManager
private TransactionManager transactionManager;
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public Object interceptCompensableMethod(TransactionMethodJoinPoint pjp) throws Throwable {
//获取当前transactionManager的本地线程变量上事务队列的首部transaction
Transaction transaction = transactionManager.getCurrentTransaction();
//创建可补偿方法执行上下文对象
CompensableMethodContext compensableMethodContext = new CompensableMethodContext(pjp, transaction);
//如果方法被@Compensable注解&transaction context为null&transaction对象为null，那么ParticipantRole为ROOT根角色
//如果方法被@Compensable注解&transaction context存在&transaction对象为null，那么表示已经创建transaction context事务上下文，此时ParticipantRole的为privider提供者角色
//TAG1 compensableMethodContext.getParticipantRole()
switch (compensableMethodContext.getParticipantRole()) {
case ROOT: //执行root根事务方法
//TAG2 rootMethodProceed
return rootMethodProceed(compensableMethodContext);
case PROVIDER: //执行provider提供者事务方法
//TAG3 providerMethodProceed
return providerMethodProceed(compensableMethodContext);
default: //默认不处理，继续目标方法try的执行
return compensableMethodContext.proceed();
}
}
这里，CompensableTransactionInterceptor拦截器，在被@Compensable标注的try方法执行时，通过切面类拦截，然后调用此处拦截器方法：
1 获取当前transactionManager的本地线程变量上事务队列的首部transaction；
2 创建CompensableMethodContext；
3 根据TCC方法上下文，判断当前参与者的角色，是ROOT(事务发起者)还是PROVIDER(分支事务的参与者）------根据不同参与者类型，执行不同的事务处理
TAG1 compensableMethodContext.getParticipantRole()
该方法，是通过transactionContext、compensable、transaction三个对象的存在情况，判断当前参与者的角色--是ROOT发起根事务的角色、还是PRIVIDER分支事务参与者的角色。
判断参与者角色是ROOT还是PROVIDER原则：
//如果方法被@Compensable注解&transaction context为null&transaction对象为null，那么ParticipantRole为ROOT根角色
//如果方法被@Compensable注解&transaction context存在&transaction对象为null，那么表示已经创建transaction context事务上下文，此时ParticipantRole的为privider提供者角色
public class CompensableMethodContext {
//事务方法连结点（具体详看spring部分）
TransactionMethodJoinPoint pjp = null;
TransactionContext transactionContext = null;
Compensable compensable = null;
private Transaction transaction = null;
public ParticipantRole getParticipantRole() {
// 1 如果方法是@Compensable注释的，则表示需要tcc事务，如果没有活动事务，则需要require new。
// 2 If方法没有@Compensable注解，但TransactionContext存在：
//2.1如果有活动事务，则表示需要参与者tcc事务。如果transactionContext为空，那么它将事务登记为CONSUMER角色;
// 2.2 如果没有活动事务activeTransaction，表示有另一个方法被调用，因为Consumer已经登记为了事务，这个方法不需要登记为参与者。
//如果方法被@Compensable注解&transaction context为null&transaction对象为null，那么ParticipantRole为ROOT根角色
if (compensable != null && transaction == null && transactionContext == null) {
return ParticipantRole.ROOT;
}
//如果方法被@Compensable注解&transaction context存在&transaction对象为null，那么表示已经创建transaction context事务上下文，此时ParticipantRole的为privider提供者角色
if (compensable != null && transaction == null && transactionContext != null) {
return ParticipantRole.PROVIDER;
}
//不进行事务处理
return ParticipantRole.NORMAL;
}
public Object proceed() throws Throwable {
return this.pjp.proceed();
}
TAG2 rootMethodProceed发起TCC流程
当ParticipantRole为ROOT时，发起根事务，开启TCC流程：
private Object rootMethodProceed(CompensableMethodContext compensableMethodContext) throws Throwable {
Object returnValue = null;
//事务对象
Transaction transaction = null;
//是否异步执行confirm/cancel
boolean asyncConfirm = compensableMethodContext.getAnnotation().asyncConfirm();
boolean asyncCancel = compensableMethodContext.getAnnotation().asyncCancel();
try {
//发起根root事务
transaction = transactionManager.begin(compensableMethodContext.getUniqueIdentity());
try {
//执行方法原逻辑，即try逻辑
returnValue = compensableMethodContext.proceed();
} catch (Throwable tryingException) {
try {
//当原逻辑执行失败时，即try阶段失败---回滚
transactionManager.rollback(asyncCancel);
} catch (Exception rollbackException) {
logger.warn("compensable transaction rollback failed, recovery job will try to rollback later", rollbackException);
}
throw tryingException;
}
//当原逻辑执行成功时，即try阶段成功，提交事务
transactionManager.commit(asyncConfirm);
} finally {
//将事物从当前线程事务队列移除
transactionManager.cleanAfterCompletion(transaction);
}
return returnValue;
}
主要逻辑：
1 transactionManager.begin发起根事务；
2 compensableMethodContext.proceed()执行try；
2.1 如果try失败抛异常，transactionManager.rollback(asyncCancel)回滚
3 transactionManager.commit(asyncConfirm) try执行成功，commit提交事务；
4 transactionManager.cleanAfterCompletion(transaction）将transaction从事务管理器transactionManager的本地线程变量的事务队列中移除；
5 返回结果；
TAG3 providerMethodProceed服务提供者参与TCC流程
当参与者角色为PROVIDER时，执行该方法：（ROOT是发起事务，在TCC三个阶段开始前，所以不需要通过compensableMethodContext.getTransactionContext().getStatus()判断当前所处的阶段；但是PROVIDER角色时，参与者参与事务，因此需要知道自己当前处于当前事务的哪个阶段执行过程TRYING、CONFIRMING、CANCELLING。
private Object providerMethodProceed(CompensableMethodContext compensableMethodContext) throws Throwable {
Transaction transaction = null;
//是否异步执行cc
boolean asyncConfirm = compensableMethodContext.getAnnotation().asyncConfirm();
boolean asyncCancel = compensableMethodContext.getAnnotation().asyncCancel();
try {
//获取TransactionContext().getStatus()中，当前TCC执行的阶段
switch (compensableMethodContext.getTransactionContext().getStatus()) {
/** ……………………………………………………………………………………………………TRYING………………………………………………………………………………………………………………*/
case TRYING:
//如果trying阶段，需要propagationNewBegin传播并发起分支事务（包括创建transaction、存储、注册）
transaction = transactionManager.propagationNewBegin(compensableMethodContext.getTransactionContext());
Object result = null;
try {
//执行原try逻辑
result = compensableMethodContext.proceed();
//设置transactionManager上事务队列首个事务状态TRY_SUCCESS，并在数据库中更新
transactionManager.changeStatus(TransactionStatus.TRY_SUCCESS);
} catch (Throwable e) {
try {
//如果try执行失败，设置transactionManager上事务队列首个事务状态为TRY_FAILED，并更新数据库中数据
transactionManager.changeStatus(TransactionStatus.TRY_FAILED);
} catch (Exception ignore) {
//ignore
}
throw e;
}
return result;
/** ……………………………………………………………………………………………………CONFIRMING………………………………………………………………………………………………………………*/
case CONFIRMING:
try {
//获取传播分支事务
transaction = transactionManager.propagationExistBegin(compensableMethodContext.getTransactionContext());
//执行提交
transactionManager.commit(asyncConfirm);
} catch (NoExistedTransactionException excepton) {
//the transaction has been commit,ignore it.
logger.warn("no existed transaction found at CONFIRMING stage, will ignore and confirm automatically. transaction xid:{}", compensableMethodContext.getTransactionContext().getXid());
}
break;
/** ……………………………………………………………………………………………………CANCELLING………………………………………………………………………………………………………………*/
case CANCELLING:
try {
//从消费者端传递过来的，分支事务branch的状态status
ParticipantStatus transactionStatusFromConsumer = compensableMethodContext.getTransactionContext().getParticipantStatus();
//获取传播分支事务
transaction = transactionManager.propagationExistBegin(compensableMethodContext.getTransactionContext());
// 1 只有transaction's status 处于TRY_SUCCESS、TRY_FAILED、CANCELLING stage，才能rollback（表示第一阶段的try执行结束，所以，单纯的trying状态，是不能够rollback的）
// 2 如果 transactionStatusFromConsumer 是TRY_SUCCESS，也表示第一阶段try执行结束, 无论当前transaction的状态是否是trying，都可以rollback
// （原因：transaction's status is TRYING while transactionStatusFromConsumer is TRY_SUCCESS 可能会发生的，就是当 transaction's changeStatus 是异步执行时.）
if (transaction.getStatus().equals(TransactionStatus.TRY_SUCCESS)
|| transaction.getStatus().equals(TransactionStatus.TRY_FAILED)
|| transaction.getStatus().equals(TransactionStatus.CANCELLING)
|| ParticipantStatus.TRY_SUCCESS.equals(transactionStatusFromConsumer)) {
transactionManager.rollback(asyncCancel);
} else {
//in this case, transaction's Status is TRYING and transactionStatusFromConsumer is TRY_FAILED
// this may happen if timeout exception throws during rpc call.
throw new IllegalTransactionStatusException("Branch transaction status is TRYING, cannot rollback directly, waiting for recovery job to rollback.");
}
} catch (NoExistedTransactionException exception) {
//the transaction has been rollback,ignore it.
logger.info("no existed transaction found at CANCELLING stage, will ignore and cancel automatically. transaction xid:{}", compensableMethodContext.getTransactionContext().getXid());
}
break;
}
} finally {
//清理当前事务对象
transactionManager.cleanAfterCompletion(transaction);
}
Method method = compensableMethodContext.getMethod();
return ReflectionUtils.getNullValue(method.getReturnType());
}
对于服务提供者provider，在事务执行过程的逻辑如下：
switch (compensableMethodContext.getTransactionContext().getStatus()) {
TRYING:
1 propagationNewBegin传播并发起分支事务------该方法调用前提：TransactionStatus.TRYING&ParticipantRole.PROVIDER;
2 compensableMethodContext.proceed()执行try方法逻辑；
3 transactionManager.changeStatus(TransactionStatus.TRY_SUCCESS) try成功，修改transaction状态，并update持久存储内；
2.1 如果try失败，transactionManager.changeStatus(TransactionStatus.TRY_FAILED)，修改transaction状态，并update；
4 return；
CONFIRMING:
1 propagationExistBegin传播并获取分支事务------该方法调用前提：TransactionStatus.CONFIRMING&ParticipantRole.PROVIDER;
2 transactionManager.commit(asyncConfirm)提交；
（confirm失败的逻辑，在transactionManager中，会update更新transaction）
CANCELLING:
1 propagationExistBegin传播并获取分支事务------该方法调用前提：TransactionStatus.CANCELLING&ParticipantRole.PROVIDER;
2 可以执行rollback的条件和情况如下：
// 1 只有transaction's status 处于TRY_SUCCESS、TRY_FAILED、CANCELLING stage，才能rollback（表示第一阶段的try执行结束，所以，单纯的trying状态，是不能够rollback的）
// 2 如果 transactionStatusFromConsumer 是TRY_SUCCESS，也表示第一阶段try执行结束, 无论当前transaction的状态是否是trying，都可以rollback
// （原因：transaction's status is TRYING while transactionStatusFromConsumer is TRY_SUCCESS 可能会发生的，就是当 transaction's changeStatus 是异步执行时.）
finally{
transactionManager.cleanAfterCompletion(transaction);清理事务
}
2 ResourceCoordinatorInterceptor资源协调拦截器
用于记录tcc事务的Participant（参与方），ResourceCoordinatorInterceptor只在try阶段使用，负责participant的创建、添加入transaction、pjp.proceed执行try方法、根据try执行是否成功设置participant的执行状态。负责参与者的管理。
(1)ResourceCoordinatorAspect 切面类
@Aspect
public abstract class ResourceCoordinatorAspect {
private ResourceCoordinatorInterceptor resourceCoordinatorInterceptor = new ResourceCoordinatorInterceptor();
@Pointcut("@annotation(org.mengyun.tcctransaction.api.Compensable) || @annotation(org.mengyun.tcctransaction.api.EnableTcc)")
public void transactionResourcePointcut() {
}
@Around("transactionResourcePointcut()")
public Object interceptTransactionResourceMethodWithCompensableAnnotation(ProceedingJoinPoint pjp) throws Throwable {
Method method = ((MethodSignature) pjp.getSignature()).getMethod();
Compensable compensable = method.getAnnotation(Compensable.class);
return interceptTransactionContextMethod(new AspectJTransactionMethodJoinPoint(pjp, compensable, ThreadLocalTransactionContextEditor.class));
}
public Object interceptTransactionContextMethod(TransactionMethodJoinPoint pjp) throws Throwable {
return resourceCoordinatorInterceptor.interceptTransactionContextMethod(pjp);
}
public void setTransactionManager(TransactionManager transactionManager) {
this.resourceCoordinatorInterceptor.setTransactionManager(transactionManager);
}
public abstract int getOrder();
}
具体分析和可补偿事务拦截器相同，省略。
(2)ConfigurableCoordinatorAspect切面配置类（执行优先级）
@Aspect
public class ConfigurableCoordinatorAspect extends ResourceCoordinatorAspect implements Ordered {
@Override
public int getOrder() {
return Ordered.HIGHEST_PRECEDENCE + 1;
}
@Autowired
public void setTransactionManager(TransactionManagerFactory transactionManagerFactory) {
super.setTransactionManager(transactionManagerFactory.getTransactionManager());
}
}
切面优先级为Ordered.HIGHEST_PRECEDENCE + 1，其在可补偿事务拦截器切面后执行。
(3)ResourceCoordinatorInterceptor资源协调拦截器
这个拦截器两个作用：
1 负责participant参与者对象的创建（条件：事务transaction对象不为null&&transaction.getStatus()事务状态为TRYING），然后将participant加入transaction的list中，并update入持久化存储；
2 并在try执行过程中，如果执行成功，设置ParticipantStatus.TRY_SUCCESS；如果失败，ParticipantStatus.TRY_FAILED。
总结：
ResourceCoordinatorInterceptor只在try阶段使用，负责participant的创建、添加入transaction、pjp.proceed执行try方法、根据try执行是否成功设置participant的执行状态。负责参与者的管理。
public class ResourceCoordinatorInterceptor {
private TransactionManager transactionManager;
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public Object interceptTransactionContextMethod(TransactionMethodJoinPoint pjp) throws Throwable {
Transaction transaction = transactionManager.getCurrentTransaction();
if (transaction != null && transaction.getStatus().equals(TransactionStatus.TRYING)) { //1
//当事务状态为trying时，添加事务参与者
Participant participant = enlistParticipant(pjp);
Object result = null;
//创建TransactionStatus.TRYING, ParticipantStatus.TRYING两个状态的事务上下文TransactionContext
TransactionContext transactionContext = new TransactionContext(transaction.getRootDomain(), transaction.getRootXid(), participant.getXid(), TransactionStatus.TRYING, ParticipantStatus.TRYING);
FactoryBuilder.factoryOf(participant.getTransactionContextEditorClass()).getInstance().set(transactionContext, pjp.getTarget(), pjp.getMethod(), pjp.getArgs());
try {
//执行try方法原逻辑
result = pjp.proceed(pjp.getArgs());
//如果执行成功，设置参与者participantStatus为TRY_SUCCESS
participant.setStatus(ParticipantStatus.TRY_SUCCESS);
} catch (Throwable e) {
participant.setStatus(ParticipantStatus.TRY_FAILED);
//if root transaction, here no need persistent transaction
// because following stage is rollback, transaction's status is changed to CANCELING and save
// transactionManager.update(participant);
throw e;
} finally {
FactoryBuilder.factoryOf(participant.getTransactionContextEditorClass()).getInstance().clear(transactionContext, pjp.getTarget(), pjp.getMethod(), pjp.getArgs());
}
return result;
} //1
//如果不需要加入participant对象到transaction，那么执行方法原逻辑（即拦截器链，继续向下执行，try方法）
return pjp.proceed(pjp.getArgs());
}
private Participant enlistParticipant(TransactionMethodJoinPoint pjp) {
Transaction transaction = transactionManager.getCurrentTransaction();
CompensableMethodContext compensableMethodContext = new CompensableMethodContext(pjp, transaction);
String confirmMethodName = compensableMethodContext.getConfirmMethodName();
String cancelMethodName = compensableMethodContext.getCancelMethodName();
Class<? extends TransactionContextEditor> transactionContextEditorClass = compensableMethodContext.getTransactionContextEditorClass();
TransactionXid xid = TransactionXid.withUniqueIdentity(null);
Class targetClass = compensableMethodContext.getDeclaredClass();
InvocationContext invocationContext = new InvocationContext(targetClass,
confirmMethodName,
cancelMethodName,
compensableMethodContext.getMethod().getParameterTypes(), compensableMethodContext.getArgs());
//构造参与者Participant
Participant participant =
new Participant(
transaction.getRootDomain(),
transaction.getRootXid(),
xid,
invocationContext,
transactionContextEditorClass);
//将participant加入transactionManager的当前transaction的list<Participant>中，然后update
transactionManager.enlistParticipant(participant);
return participant;
}
}
