最近研究了一下分布式事务框架，ttc,总体感觉还可以，当然前提条件下是你要会使用这个框架。下面分层次讲，尽量让想学习的同学读了这篇文章能加以操作运用。我不想废话，直接上干货。
一.什么是tcc?干什么用的？
ttc是分布式事务框架，用于分布式事务的。分布式事务就是针对两个以上的库操作数据事务管理的，比如操作A库B库，当B库失败，也要把A库哪一步操作也要回滚。
ttc其实是一个模板框架，是英文字母try,confirm,cnacel三个单词的缩写。我们要操作的业务处理部分在try里面执行，执行的所有结果是否有失败的情况在confirm里面确认，如果有失败，则在cancel里面做回滚操作。不要问我什么是回滚操作，回滚操作就是比如你增加了一条数据，回滚就指你去删掉这条数据。相信已经够直白了。
二.模板什么样子？怎么使用？
首先我贴出模板框架，大概TccTemplate,TccResult,TccCallBack,TranslationTask 四个类
public class TccTemplate {
private static final Logger logger = LoggerFactory.getLogger(TccCallBack.class);
/**
* 分布式事务模板
*
* @param tccCallBack 分布式事务执行回调
* @param method 当前方法名(封装参数, 可方便捞取数据)
*/
public static TccResult process(TccCallBack tccCallBack, String method) {
// 返回一个消息用于
TccResult tccResult = new TccResult();
String msg = “”;
try {
// 执行主业务
tccCallBack.tryExecute();
// 进行确认执行结果,如果结果是false,则执行回滚操作
boolean confirm = tccCallBack.confirm();
if (confirm) {
tccResult.setStatus(true);
msg = String.format(“分布式事务{%s}执行成功”, method);
logger.info(msg);
} else {
tccResult.setStatus(false);
msg = String.format(“分布式事务{%s}执行失败,进行回滚操作”, method);
logger.warn(msg);
tccCallBack.cancel();
}
} catch (BizException e) {
// 主流程发生异常, 则直接执行回滚操作
tccResult.setStatus(false);
tccResult.setCode(e.getErrorCode().getCode());
msg = e.getMessage();
logger.warn(String.format(“分布式事务{%s}执行发生异常,进行回滚操作”, method), e);
tccCallBack.cancel();
throw e;
}catch (BusinessException e) {
// 主流程发生异常, 则直接执行回滚操作
tccResult.setStatus(false);
tccResult.setCode(e.getErrorCode());
msg = e.getErrorMessage();
logger.warn(String.format(“分布式事务{%s}执行发生异常,进行回滚操作”, method), e);
tccCallBack.cancel();
throw e;
} catch (Exception e) {
// 主流程发生异常, 则直接执行回滚操作
tccResult.setCode(BizErrorCodeEnum.UNSPECIFIED.getCode());
tccResult.setStatus(false);
msg = e.getMessage();
logger.warn(String.format(“分布式事务{%s}执行发生异常,进行回滚操作”, method), e);
tccCallBack.cancel();
throw e;
} finally {
// 返回结果Result
tccResult.setMsg(msg);
return tccResult;
}
}
}
框架种用到的类也给大家贴出来：
public class TccResult {
private String code;
/** 响应数据 */
private T data;
/** 响应状态 */
private Boolean status = true;
/** 响应消息 */
private String msg;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Boolean getStatus() {
return status;
}
public void setStatus(Boolean status) {
this.status = status;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
public interface TccCallBack {
/**
* 执行主要分布式业务操作
*/
void tryExecute();
/**
* 确认分布式业务操作最终结果,
* 如果返回true,则不执行cancel,返回false则执行cancel
*/
boolean confirm();
/**
* 取消操作
*/
void cancel();
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TranslationTask {
private String name;
private Object parameter;
}
新学习这个框架的同学，可以先在项目里面建立一个文件夹，然后把这四个类copy进去，然后在你需要用到的地方，直接用就行，具体使用，举例子，我也直接来干货。
比如我想在test方法里面用到分布式事务，用伪代码表示具体逻辑，下单在订单库，用户在用户库
public Boolean test(Map inParams) {
//把操作成功的结果放进这里
Stack taskStack = new Stack<>();
//暂存分布式结果
HashMap tempResult = Maps.newHashMap();
// 分布式事务调用
TccResult process = TccTemplate.process(new TccCallBack() {
@Override
public void tryExecute() {
boolean flag=false;
1.下单,生成订单id
if(订单id不为空){
taskStack.push(new TranslationTask(“1”,订单id));flag=true;
}else{ flag=false;
}
2.下单成功后，改用户状态if(flag){修改用户状态}
if(修改用户状态成功){
flag=true;
}else{
flag=false;
}
tempResult.put(“result”, flag);
}
@Override
public boolean confirm() {
return tempResult.get(“result”) == true ;
}
@Override
public void cancel() {
for (int i = 0; i < taskStack.size(); i++) {
TranslationTask translationTask = (TranslationTask) taskStack.pop();
switch (translationTask.getName()) {
case “1”:
订单id = translationTask.getParameter();
根据订单id删除生成的订单
break;
default:
break;
}
}
}
}, “分布式事务测试”);
return tempResult.get(“result”);
}
上面伪代码其实就是指先下单，下单成功的话，把结果装到taskStack里面，装到这里是为了用于取出数据回滚用。然后还有个tempResult，这个类的作用目的在于把每一步的结果放进去，用于确认的，如果有一步失败，将会回滚操作
如果有疑问，请留言，或者喜欢请给个关注，我会持续为大家用尽量通俗的话，不讲废话，把好的东西分享出来。