jackson陈
jackson陈

TX-LCN分布式事务框架源码解析（基于lcn模式下的正常流程源码分析）

TX-LCN中的LCN模式是通过代理数据库连接进而对事物进行控制的。通过静态代理的方式包装的原本来的connection,设置为手动提交，根据事物状态控制提交与回滚。

所以如果用LCN模式的分布式事务，必须有本地连接，即要操作本地数据库。（当然也可以多种模式混合使用）

代理连接如下，state为事务状态，1为分布式事务成功本地链接提交，其他为失败进行本地链接回滚

public class LcnConnectionProxy implements Connection {

    private Connection connection;

    public LcnConnectionProxy(Connection connection) {
        this.connection = connection;
    }

    /**
     * notify connection
     *
     * @param state transactionState
     * @return RpcResponseState RpcResponseState
     */
    public RpcResponseState notify(int state) {
        try {
            
            if (state == 1) {
                log.debug("commit transaction type[lcn] proxy connection:{}.", this);
                connection.commit();
            } else {
                log.debug("rollback transaction type[lcn] proxy connection:{}.", this);
                connection.rollback();
            }
            connection.close();
            log.debug("transaction type[lcn] proxy connection:{} closed.", this);
            return RpcResponseState.success;
        } catch (Exception e) {
            log.error(e.getLocalizedMessage(), e);
            return RpcResponseState.fail;
        }
    }

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        connection.setAutoCommit(false);
    }

代理连接的获取是用Aop实现的

public class DataSourceAspect implements Ordered {

    private final TxClientConfig txClientConfig;

    private final DTXResourceWeaver dtxResourceWeaver;

    public DataSourceAspect(TxClientConfig txClientConfig, DTXResourceWeaver dtxResourceWeaver) {
        this.txClientConfig = txClientConfig;
        this.dtxResourceWeaver = dtxResourceWeaver;
    }

    //环绕通知获取代理连接
    @Around("execution(* javax.sql.DataSource.getConnection(..))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        return dtxResourceWeaver.getConnection(() -> (Connection) point.proceed());
    }
}
public class DTXResourceWeaver {

    private final TxLcnBeanHelper txLcnBeanHelper;

    public DTXResourceWeaver(TxLcnBeanHelper txLcnBeanHelper) {
        this.txLcnBeanHelper = txLcnBeanHelper;
    }

    public Object getConnection(ConnectionCallback connectionCallback) throws Throwable {
        //事务本地上下文
        DTXLocalContext dtxLocalContext = DTXLocalContext.cur();
        //如果设置为代理模式
        if (Objects.nonNull(dtxLocalContext) && dtxLocalContext.isProxy()) {
            String transactionType = dtxLocalContext.getTransactionType();
            //根据事物类型获取代理器
            TransactionResourceProxy resourceProxy = txLcnBeanHelper.loadTransactionResourceProxy(transactionType);
            //构造代理连接对象
            Connection connection = resourceProxy.proxyConnection(connectionCallback);
            log.debug("proxy a sql connection: {}.", connection);
            return connection;
        }
        //如果不是代理直接返回原始连接
        return connectionCallback.call();
    }
}

以上是一些铺垫

下面介绍整体流程，例子以TX-LCN分布式事务框架应用与解析-2例子为标准进行讲解

在例子中我们就在调用接口的地方加上了一个注解@LcnTransaction，这是一个入口整个流程的开始就在这里。

TransactionAspect类是一个切面类，对@LcnTransaction注解设置了环绕通知，在碰到注解@LcnTransaction开始了整个流程

public class TransactionAspect implements Ordered {

 
    /**
     * DTC Aspect (Type of LCN)
     */
    @Pointcut("@annotation(com.codingapi.txlcn.tc.annotation.LcnTransaction)")
    public void lcnTransactionPointcut() {
    }

    @Around("lcnTransactionPointcut() && !txcTransactionPointcut()" +
            "&& !tccTransactionPointcut() && !txTransactionPointcut()")
    public Object runWithLcnTransaction(ProceedingJoinPoint point) throws Throwable {
        //根据ProceedingJoinPoint 从缓存中获取事务信息
        DTXInfo dtxInfo = DTXInfo.getFromCache(point);
        //获取注解
        LcnTransaction lcnTransaction = dtxInfo.getBusinessMethod().getAnnotation(LcnTransaction.class);
        //设置事务类型为LCN
        dtxInfo.setTransactionType(Transactions.LCN);
        //设置事务传播行为，发起方是REQUIRED，参与方式是SUPPORTS
        dtxInfo.setTransactionPropagation(lcnTransaction.propagation());
        //开始执行事务
        return dtxLogicWeaver.runTransaction(dtxInfo, point::proceed);
    }

1、在注解的开始从缓存中获取了事务信息

这里做了个缓存，当再次执行这个方法时则直接取得事务信息。这个方法的作用就是根据当前要执行的类名、方法名和方法参数构造事务信息对象，存入缓存。

public static DTXInfo getFromCache(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //签名
        String signature = proceedingJoinPoint.getSignature().toString();
        //根据签名构造事务单元
        String unitId = Transactions.unitId(signature);
        //根据事务单元获取事务信息
        DTXInfo dtxInfo = dtxInfoCache.get(unitId);
        if (Objects.isNull(dtxInfo)) {
            //获取签名
            MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
            //获取要执行的方法，这是接口的方法并不是我们要的类
            Method method = methodSignature.getMethod();
            //获取目标方法
            Class targetClass = proceedingJoinPoint.getTarget().getClass();
            //这才是我们要的真实方法
            Method thisMethod = targetClass.getMethod(method.getName(), method.getParameterTypes());
            //构造
            dtxInfo = new DTXInfo(thisMethod, proceedingJoinPoint.getArgs(), targetClass);
            //缓存起来
            dtxInfoCache.put(unitId, dtxInfo);
        }
          
        dtxInfo.reanalyseMethodArgs(proceedingJoinPoint.getArgs());
        return dtxInfo;
    }

2、事务执行runTransaction方法

public Object runTransaction(DTXInfo dtxInfo, BusinessCallback business) throws Throwable {

        if (Objects.isNull(DTXLocalContext.cur())) {
            DTXLocalContext.getOrNew();
        } else {
            return business.call();
        }

        log.debug("<---- TxLcn start ---->");
        DTXLocalContext dtxLocalContext = DTXLocalContext.getOrNew();
        TxContext txContext;
        // ---------- 保证每个模块在一个DTX下只会有一个TxContext ---------- //
        if (globalContext.hasTxContext()) {
            // 有事务上下文的获取父上下文
            txContext = globalContext.txContext();
            dtxLocalContext.setInGroup(true);
            log.debug("Unit[{}] used parent's TxContext[{}].", dtxInfo.getUnitId(), txContext.getGroupId());
        } else {
            // 没有的开启本地事务上下文
            txContext = globalContext.startTx();
        }

        // 本地事务调用
        if (Objects.nonNull(dtxLocalContext.getGroupId())) {
            dtxLocalContext.setDestroy(false);
        }

        dtxLocalContext.setUnitId(dtxInfo.getUnitId());
        dtxLocalContext.setGroupId(txContext.getGroupId());
        dtxLocalContext.setTransactionType(dtxInfo.getTransactionType());

        // 事务参数
        TxTransactionInfo info = new TxTransactionInfo();
        info.setBusinessCallback(business);
        info.setGroupId(txContext.getGroupId());
        info.setUnitId(dtxInfo.getUnitId());
        info.setPointMethod(dtxInfo.getBusinessMethod());
        info.setPropagation(dtxInfo.getTransactionPropagation());
        info.setTransactionInfo(dtxInfo.getTransactionInfo());
        info.setTransactionType(dtxInfo.getTransactionType());
        info.setTransactionStart(txContext.isDtxStart());

        //LCN事务处理器
        try {
            return transactionServiceExecutor.transactionRunning(info);
        } finally {
            // 线程执行业务完毕清理本地数据
            if (dtxLocalContext.isDestroy()) {
                // 通知事务执行完毕
                synchronized (txContext.getLock()) {
                    txContext.getLock().notifyAll();
                }

                // TxContext生命周期是？ 和事务组一样（不与具体模块相关的）
                if (!dtxLocalContext.isInGroup()) {
                    globalContext.destroyTx();
                }

                DTXLocalContext.makeNeverAppeared();
                TracingContext.tracing().destroy();
            }
            log.debug("<---- TxLcn end ---->");
        }
    }

方法比较长，但是逻辑比较简单

1、获取或新建一个线程变量DTXLocalContext

2、如果已经存在事务上下文则获取，否则构建事务上下文

3、为DTXLocalContext设置参数

4、构造TxTransactionInfo 并设置参数

5、执行事务

6、finally做一些通知与销毁操作。

其他还好，主要说下第二点什么情况下要获取已有的TxContext ，什么时候构造新的

如果一个调用链是这样的A->B->C 三个都是不同的模块则会为每个模块都构造新的TxContext，保证一个模块一个

如果三个是两个模块，即A是一个模块，B和C是一个模块根据调用链的情况肯定是C的用B的TxContext。

鉴于本例中都是单独的模块所以对于每一个模块来说都是新创建TxContext

public TxContext startTx() {
        TxContext txContext = new TxContext();
        // 事务发起方判断
        txContext.setDtxStart(!TracingContext.tracing().hasGroup());
        //是否是事务发起方
        if (txContext.isDtxStart()) {
            //是的话开始事务组,主要是构造事务id
            TracingContext.tracing().beginTransactionGroup();
        }
        //设置事务组id
        txContext.setGroupId(TracingContext.tracing().groupId());
        String txContextKey = txContext.getGroupId() + ".dtx";
        //key与txContext缓存起来
        attachmentCache.attach(txContextKey, txContext);
        log.debug("Start TxContext[{}]", txContext.getGroupId());
        return txContext;
    }

对于本例中a是事务发起方，其他的两个是事务参与方

第6点虽然东西不多但是有必要讲下

            // 线程执行业务完毕清理本地数据
            if (dtxLocalContext.isDestroy()) {
                // 通知事务执行完毕
                synchronized (txContext.getLock()) {
                    txContext.getLock().notifyAll();
                }

                // TxContext生命周期是？ 和事务组一样（不与具体模块相关的）
                if (!dtxLocalContext.isInGroup()) {
                    globalContext.destroyTx();
                }

                DTXLocalContext.makeNeverAppeared();
                TracingContext.tracing().destroy();
            }
public void destroyTx() {
        if (!hasTxContext()) {
            throw new IllegalStateException("non TxContext.");
        }
        destroyTx(txContext().getGroupId());
    }
public void destroyTx(String groupId) {
        attachmentCache.remove(groupId + ".dtx");
        log.debug("Destroy TxContext[{}]", groupId);
    }

业务执行完会把attachmentCache的key移除掉，后面在参与方clean事务的时候才不会await。

3、transactionRunning方法执行事务

public Object transactionRunning(TxTransactionInfo info) throws Throwable {

        // 1. 获取事务类型,LCN
        String transactionType = info.getTransactionType();

        // 2. 获取事务传播状态
        DTXPropagationState propagationState = propagationResolver.resolvePropagationState(info);

        // 2.1 如果不参与分布式事务立即终止
        if (propagationState.isIgnored()) {
            return info.getBusinessCallback().call();
        }

        // 3. 获取本地分布式事务控制器
        DTXLocalControl dtxLocalControl = txLcnBeanHelper.loadDTXLocalControl(transactionType, propagationState);

        // 4. 织入事务操作
        try {
            // 4.1 记录事务类型到事务上下文
            Set transactionTypeSet = globalContext.txContext(info.getGroupId()).getTransactionTypes();
            transactionTypeSet.add(transactionType);
            //执行前
            dtxLocalControl.preBusinessCode(info);

            // 4.2 业务执行前
            txLogger.txTrace(
                    info.getGroupId(), info.getUnitId(), "pre business code, unit type: {}", transactionType);

            // 4.3 执行业务
            Object result = dtxLocalControl.doBusinessCode(info);

            // 4.4 业务执行成功
            txLogger.txTrace(info.getGroupId(), info.getUnitId(), "business success");
            dtxLocalControl.onBusinessCodeSuccess(info, result);
            return result;
        } catch (TransactionException e) {
            txLogger.error(info.getGroupId(), info.getUnitId(), "before business code error");
            throw e;
        } catch (Throwable e) {
            // 4.5 业务执行失败
            txLogger.error(info.getGroupId(), info.getUnitId(), Transactions.TAG_TRANSACTION,
                    "business code error");
            dtxLocalControl.onBusinessCodeError(info, e);
            throw e;
        } finally {
            // 4.6 业务执行完毕
            dtxLocalControl.postBusinessCode(info);
        }
    }

事务控制器根据事物类型与传播状态执行的也不同

获取传播类型，发起方是create，参与方是join

public DTXPropagationState resolvePropagationState(TxTransactionInfo txTransactionInfo) throws TransactionException {

        // 本地已在DTX，根据事务传播，静默加入
        if (DTXLocalContext.cur().isInGroup()) {
            log.info("SILENT_JOIN group!");
            return DTXPropagationState.SILENT_JOIN;
        }

        // 发起方之前没有事务
        if (txTransactionInfo.isTransactionStart()) {
            // 根据事务传播，对于 SUPPORTS 不参与事务
            if (DTXPropagation.SUPPORTS.equals(txTransactionInfo.getPropagation())) {
                return DTXPropagationState.NON;
            }
            // 根据事务传播，创建事务
            return DTXPropagationState.CREATE;
        }

        // 已经存在DTX，根据事务传播，加入
        return DTXPropagationState.JOIN;
    }

事务发起方控制器是LcnStartingTransaction事务参与方控制器是LcnRunningTransaction

这里分为四步执行业务前、执行业务，执行业务后、最后finally。

1、执行业务前preBusinessCode方法

1）发起方。

通过netty调用服务端创建事务组

设置DTXLocalContext的proxy为true。

public void preBusinessCode(TxTransactionInfo info) throws TransactionException {
        // create DTX group
        transactionControlTemplate.createGroup(
                info.getGroupId(), info.getUnitId(), info.getTransactionInfo(), info.getTransactionType());

        // lcn type need connection proxy
        DTXLocalContext.makeProxy();
    }
public void createGroup(String groupId, String unitId, TransactionInfo transactionInfo, String transactionType)
            throws TransactionException {
        //创建事务组
        try {
            // 日志
            txLogger.txTrace(groupId, unitId,
                    "create group > transaction type: {}", transactionType);
            // 创建事务组消息
            reliableMessenger.createGroup(groupId);
            // 缓存发起方切面信息
            aspectLogger.trace(groupId, unitId, transactionInfo);
        } catch (RpcException e) {
            // 通讯异常
            dtxExceptionHandler.handleCreateGroupMessageException(groupId, e);
        } catch (LcnBusinessException e) {
            // 创建事务组业务失败
            dtxExceptionHandler.handleCreateGroupBusinessException(groupId, e.getCause());
        }
        txLogger.txTrace(groupId, unitId, "create group over");
    }
public void createGroup(String groupId) throws RpcException, LcnBusinessException {
        // TxManager创建事务组
        MessageDto messageDto = request(MessageCreator.createGroup(groupId));
        if (!MessageUtils.statusOk(messageDto)) {
            throw new LcnBusinessException(messageDto.loadBean(Throwable.class));
        }
    }

服务端接收到创建事务组信息后会用CreateGroupExecuteService的execute方法进行处理

public Serializable execute(TransactionCmd transactionCmd) throws TxManagerException {
        try {
            transactionManager.begin(transactionCmd.getGroupId());
        } catch (TransactionException e) {
            throw new TxManagerException(e);
        }
        txLogger.txTrace(transactionCmd.getGroupId(), null, "created group");
        return null;
    }
public void begin(String groupId) throws TransactionException {
        try {
            dtxContextRegistry.create(groupId);
        } catch (TransactionException e) {
            throw new TransactionException(e);
        }
    }
 public DTXContext create(String groupId) throws TransactionException {
        try {
            fastStorage.initGroup(groupId);
        } catch (FastStorageException e) {
            // idempotent processing
            if (e.getCode() != FastStorageException.EX_CODE_REPEAT_GROUP) {
                throw new TransactionException(e);
            }
        }
        return get(groupId);
    }
public void initGroup(String groupId) {
        redisTemplate.opsForHash().put(REDIS_GROUP_PREFIX + groupId, "root", "");
        redisTemplate.expire(REDIS_GROUP_PREFIX + groupId, managerConfig.getDtxTime() + 10000, TimeUnit.MILLISECONDS);
    }

服务端会以hash结构在redis创建一个key。hashkey为“tm:group:”+groupid，key为root，value为空。超时时间为分布式事务超时时间8s加上10s一共18秒。

2）参与方

设置DTXLocalContext的proxy为true。

 public void preBusinessCode(TxTransactionInfo info) {
        // lcn type need connection proxy
        DTXLocalContext.makeProxy();
    }

2、执行业务方法doBusinessCode

对于执行业务方法，就是执行我们的方法的内容。主要是调用其他服务，而其他服务又会有@LcnTransaction注解，又会走同样的流程，只是处理类不一样了，这里都会写出不同处理类的处理方式

3、业务执行成功方法onBusinessCodeSuccess

1）发起方

设置系统分布式事务状态为1成功

public void onBusinessCodeSuccess(TxTransactionInfo info, Object result) {
        DTXLocalContext.cur().setSysTransactionState(1);
    }

2）参与方

加入事务组

 public void onBusinessCodeSuccess(TxTransactionInfo info, Object result) throws TransactionException {
        log.debug("join group: [GroupId: {},Method: {}]" , info.getGroupId(),
                info.getTransactionInfo().getMethodStr());
        
        // join DTX group
        transactionControlTemplate.joinGroup(info.getGroupId(), info.getUnitId(), info.getTransactionType(),
                info.getTransactionInfo());
    }
public void joinGroup(String groupId, String unitId, String transactionType, TransactionInfo transactionInfo)
            throws TransactionException {
        try {
            txLogger.txTrace(groupId, unitId, "join group > transaction type: {}", transactionType);
            //加入事务组
            reliableMessenger.joinGroup(groupId, unitId, transactionType, DTXLocalContext.transactionState(globalContext.dtxState(groupId)));

            txLogger.txTrace(groupId, unitId, "join group message over.");

            // 异步检测，用定时任务去查看是否有异常事务
            dtxChecking.startDelayCheckingAsync(groupId, unitId, transactionType);

            // 缓存参与方切面信息
            aspectLogger.trace(groupId, unitId, transactionInfo);
        } catch (RpcException e) {
            dtxExceptionHandler.handleJoinGroupMessageException(Arrays.asList(groupId, unitId, transactionType), e);
        } catch (LcnBusinessException e) {
            dtxExceptionHandler.handleJoinGroupBusinessException(Arrays.asList(groupId, unitId, transactionType), e);
        }
        txLogger.txTrace(groupId, unitId, "join group logic over");
    }
public void joinGroup(String groupId, String unitId, String unitType, int transactionState) throws RpcException, LcnBusinessException {
        JoinGroupParams joinGroupParams = new JoinGroupParams();
        joinGroupParams.setGroupId(groupId);
        joinGroupParams.setUnitId(unitId);
        joinGroupParams.setUnitType(unitType);
        joinGroupParams.setTransactionState(transactionState);
        MessageDto messageDto = request(MessageCreator.joinGroup(joinGroupParams));
        if (!MessageUtils.statusOk(messageDto)) {
            throw new LcnBusinessException(messageDto.loadBean(Throwable.class));
        }
    }

客户端会调用服务端去把当前操作加入到事务组中。

服务端收到后会调用JoinGroupExecuteService类的execute进行处理

public Serializable execute(TransactionCmd transactionCmd) throws TxManagerException {
        try {
            //根据事务组id获取事务上下文
            DTXContext dtxContext = dtxContextRegistry.get(transactionCmd.getGroupId());
            //从消息中获取参数
            JoinGroupParams joinGroupParams = transactionCmd.getMsg().loadBean(JoinGroupParams.class);
            txLogger.txTrace(transactionCmd.getGroupId(), joinGroupParams.getUnitId(), "unit:{} try join group:{}",
                    joinGroupParams.getUnitId(), transactionCmd.getGroupId());
            //join
            transactionManager.join(dtxContext, joinGroupParams.getUnitId(), joinGroupParams.getUnitType(),
                    rpcClient.getAppName(transactionCmd.getRemoteKey()), joinGroupParams.getTransactionState());
            txLogger.txTrace(transactionCmd.getGroupId(), joinGroupParams.getUnitId(), "unit:{} joined.",
                    joinGroupParams.getUnitId());
        } catch (TransactionException e) {
            txLogger.error(this.getClass().getSimpleName(), e.getMessage());
            throw new TxManagerException(e.getLocalizedMessage());
        }
        // non response
        return null;
    }
public void join(DTXContext dtxContext, String unitId, String unitType, String modId, int userState) throws TransactionException {
        //手动回滚时设置状态为回滚状态 0,这个状态只有在用户自己设置时可用
        if (userState == 0) {
            dtxContext.resetTransactionState(0);
        }
        //构造事务单元
        TransactionUnit transactionUnit = new TransactionUnit();
        transactionUnit.setModId(modId);
        transactionUnit.setUnitId(unitId);
        transactionUnit.setUnitType(unitType);
        dtxContext.join(transactionUnit);
    }
public void join(TransactionUnit transactionUnit) throws TransactionException {
        try {
            fastStorage.saveTransactionUnitToGroup(groupId, transactionUnit);
        } catch (FastStorageException e) {
            throw new TransactionException("attempts to join the non-existent transaction group. ["
                    + transactionUnit.getUnitId() + '@' + transactionUnit.getModId() + ']');
        }
    }
public void saveTransactionUnitToGroup(String groupId, TransactionUnit transactionUnit) throws FastStorageException {
        if (Optional.ofNullable(redisTemplate.hasKey(REDIS_GROUP_PREFIX + groupId)).orElse(false)) {
            redisTemplate.opsForHash().put(REDIS_GROUP_PREFIX + groupId, transactionUnit.getUnitId(), transactionUnit);
            return;
        }
        throw new FastStorageException("attempts to the non-existent transaction group " + groupId,
                FastStorageException.EX_CODE_NON_GROUP);
    }

服务端收到信息后会在redis与creategroup的hashkey相同数据下保存事务单元信息，key为事务单元id,key为事务单元信息

4、业务执行成功后finally中的postBusinessCode

1）发起方

关闭事务组

public void postBusinessCode(TxTransactionInfo info) {
        // RPC close DTX group
        transactionControlTemplate.notifyGroup(
                info.getGroupId(), info.getUnitId(), info.getTransactionType(),
                DTXLocalContext.transactionState(globalContext.dtxState(info.getGroupId())));
    }
public void notifyGroup(String groupId, String unitId, String transactionType, int state) {
        try {
            txLogger.txTrace(
                    groupId, unitId, "notify group > transaction type: {}, state: {}.", transactionType, state);
            if (globalContext.isDTXTimeout()) {
                throw new LcnBusinessException("dtx timeout.");
            }
            //通知事务组,进行事务提交
            state = reliableMessenger.notifyGroup(groupId, state);
            //成功后去提交本地事务
            transactionCleanTemplate.clean(groupId, unitId, transactionType, state);
        } catch (TransactionClearException e) {
            txLogger.trace(groupId, unitId, Transactions.TE, "clean transaction fail.");
        } catch (RpcException e) {
            dtxExceptionHandler.handleNotifyGroupMessageException(Arrays.asList(groupId, state, unitId, transactionType), e);
        } catch (LcnBusinessException e) {
            // 关闭事务组失败
            dtxExceptionHandler.handleNotifyGroupBusinessException(Arrays.asList(groupId, state, unitId, transactionType), e.getCause());
        }
        txLogger.txTrace(groupId, unitId, "notify group exception state {}.", state);
    }

通知事务组进行提交事务这边比较绕

public int notifyGroup(String groupId, int transactionState) throws RpcException, LcnBusinessException {
        NotifyGroupParams notifyGroupParams = new NotifyGroupParams();
        notifyGroupParams.setGroupId(groupId);
        notifyGroupParams.setState(transactionState);
        MessageDto messageDto = request0(MessageCreator.notifyGroup(notifyGroupParams),
                clientConfig.getTmRpcTimeout() * clientConfig.getChainLevel());
        // 成功清理发起方事务
        if (!MessageUtils.statusOk(messageDto)) {
            throw new LcnBusinessException(messageDto.loadBean(Throwable.class));
        }
        return messageDto.loadBean(Integer.class);
    }

同样是向服务端发送请求，服务端接收到请求后用NotifyGroupExecuteService类的execute方法进行处理

public Serializable execute(TransactionCmd transactionCmd) throws TxManagerException {
        try {
            DTXContext dtxContext = dtxContextRegistry.get(transactionCmd.getGroupId());
            // 解析参数
            NotifyGroupParams notifyGroupParams = transactionCmd.getMsg().loadBean(NotifyGroupParams.class);
            int commitState = notifyGroupParams.getState();
            // 获取事务状态（当手动回滚时会先设置状态）
            int transactionState = transactionManager.transactionStateFromFastStorage(transactionCmd.getGroupId());
            if (transactionState == 0) {
                commitState = 0;
            }

            // 系统日志
            txLogger.txTrace(
                    transactionCmd.getGroupId(), "", "notify group state: {}", notifyGroupParams.getState());
            //如果状态为1则事务成功，通知参与模块进行提交
            if (commitState == 1) {
                transactionManager.commit(dtxContext);
            } else if (commitState == 0) {//如果状态为0则事务失败，通知参与模块进行回滚
                transactionManager.rollback(dtxContext);
            }
            if (transactionState == 0) {
                txLogger.txTrace(transactionCmd.getGroupId(), "", "mandatory rollback for user.");
            }
            return commitState;
        } catch (TransactionException e) {
            throw new TxManagerException(e);
        } finally {
            transactionManager.close(transactionCmd.getGroupId());
            // 系统日志
            txLogger.txTrace(transactionCmd.getGroupId(), "", "notify group successfully.");
        }
    }
public void commit(DTXContext dtxContext) throws TransactionException {
        notifyTransaction(dtxContext, 1);
    }
//根据groupid从redis获取所有的事务单元，通知其进行提交
private void notifyTransaction(DTXContext dtxContext, int transactionState) throws TransactionException {
        
        List transactionUnits = dtxContext.transactionUnits();
        log.debug("group[{}]'s transaction units: {}", dtxContext.getGroupId(), transactionUnits);
        for (TransactionUnit transUnit : transactionUnits) {
            NotifyUnitParams notifyUnitParams = new NotifyUnitParams();
            notifyUnitParams.setGroupId(dtxContext.getGroupId());
            notifyUnitParams.setUnitId(transUnit.getUnitId());
            notifyUnitParams.setUnitType(transUnit.getUnitType());
            notifyUnitParams.setState(transactionState);
            txLogger.txTrace(dtxContext.getGroupId(), notifyUnitParams.getUnitId(), "notify {}'s unit: {}",
                    transUnit.getModId(), transUnit.getUnitId());
            try {
                List modChannelKeys = rpcClient.remoteKeys(transUnit.getModId());
                if (modChannelKeys.isEmpty()) {
                    // record exception
                    throw new RpcException("offline mod.");
                }
                MessageDto respMsg =
                        rpcClient.request(modChannelKeys.get(0), MessageCreator.notifyUnit(notifyUnitParams));
                if (!MessageUtils.statusOk(respMsg)) {
                    // 提交/回滚失败的消息处理
                    List params = Arrays.asList(notifyUnitParams, transUnit.getModId());
                    rpcExceptionHandler.handleNotifyUnitBusinessException(params, respMsg.loadBean(Throwable.class));
                }
            } catch (RpcException e) {
                // 提交/回滚通讯失败
                List params = Arrays.asList(notifyUnitParams, transUnit.getModId());
                rpcExceptionHandler.handleNotifyUnitMessageException(params, e);
            } finally {
                txLogger.txTrace(dtxContext.getGroupId(), notifyUnitParams.getUnitId(), "notify unit over");
            }
        } 
  
notifyTransaction方法又会调用客户端，客户端用DefaultNotifiedUnitService的execute方法进行处理
 
  
public Serializable execute(TransactionCmd transactionCmd) throws TxClientException {
        try {
            NotifyUnitParams notifyUnitParams = transactionCmd.getMsg().loadBean(NotifyUnitParams.class);
            // 保证业务线程执行完毕后执行事务清理操作
            //这个参数在参与方会一直是空，在finally会释放
            TxContext txContext = globalContext.txContext(transactionCmd.getGroupId());
            if (Objects.nonNull(txContext)) {
                synchronized (txContext.getLock()) {
                    txLogger.txTrace(transactionCmd.getGroupId(), notifyUnitParams.getUnitId(),
                            "clean transaction cmd waiting for business code finish.");
                    txContext.getLock().wait();
                }
            }
            // 事务清理操作,主要是提交本地事务
            transactionCleanTemplate.clean(
                    notifyUnitParams.getGroupId(),
                    notifyUnitParams.getUnitId(),
                    notifyUnitParams.getUnitType(),
                    notifyUnitParams.getState());
            return true;
        } catch (TransactionClearException | InterruptedException e) {
            throw new TxClientException(e);
        }
 
  
画一张图来表示流程
 
  
TX-LCN分布式事务框架源码解析（基于lcn模式下的正常流程源码分析）_第1张图片
 
  
2）参与方
 
  
空操作，什么也不干
 
  
default void postBusinessCode(TxTransactionInfo info) {

    }
 
  
整体流程图如下，比较粗糙，其中清理事务的已经在上图画出。
 
  
Finally（runTransaction）的作用就是释放资源，保证在清理事务时不至于阻塞线程。
 
  
TX-LCN分布式事务框架源码解析（基于lcn模式下的正常流程源码分析）_第2张图片
 
  
一些其他点：
 
  
关于参与方如何知道已经存在事务的？
 
  
一般我们都是一接口的方式去调用服务，基本就是restTemplate如果用到spring Cloud还会用到Fegin。框架在进行接口调用时都会通过把事务消息放在header中，后边的服务从header中就会得到当前的事务信息。
 
  
ClientHttpRequestInterceptor可以对请求进行拦截，并在其被发送至服务端之前修改请求或是增强相应的信息。
 
  
添加事务组信息到请求头
 
  
RestTemplate调用实现拦截
 
  
RestTemplateTracingTransmitter实现了ClientHttpRequestInterceptor接口。并把此拦截器加入到restTemplate的拦截器链中，当restTemplate去请求别的资源时，会被RestTemplateTracingTransmitter拦截到，在requestheader中加入groupid信息。
 
  
public class RestTemplateTracingTransmitter implements ClientHttpRequestInterceptor {

    @Autowired
    public RestTemplateTracingTransmitter(@Autowired(required = false) List restTemplates) {
        if (Objects.nonNull(restTemplates)) {
            restTemplates.forEach(restTemplate -> {
                List interceptors = restTemplate.getInterceptors();
                //加入拦截器链
                interceptors.add(interceptors.size(), RestTemplateTracingTransmitter.this);
            });
        }
    }

    @Override
    @NonNull
    public ClientHttpResponse intercept(
            @NonNull HttpRequest httpRequest, @NonNull byte[] bytes,
            @NonNull ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
        Tracings.transmit(httpRequest.getHeaders()::add);
        return clientHttpRequestExecution.execute(httpRequest, bytes);
    }
}
 
  
public static void transmit(TracingSetter tracingSetter) {
        //把信息存储到header中
        if (TracingContext.tracing().hasGroup()) {
            log.debug("tracing transmit group:{}", TracingContext.tracing().groupId());
            tracingSetter.set(TracingConstants.HEADER_KEY_GROUP_ID, TracingContext.tracing().groupId());
            tracingSetter.set(TracingConstants.HEADER_KEY_APP_MAP,
                    Base64Utils.encodeToString(TracingContext.tracing().appMapString().getBytes(StandardCharsets.UTF_8)));
        }
    }
 
  
fegin实现请求拦截
 
  
RequestInterceptor可以实现对请求的拦截
 
  
FeignTracingTransmitter实现RequestInterceptor接口在请求资源时在header中加入groupid信息。
 
  
public class FeignTracingTransmitter implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        Tracings.transmit(requestTemplate::header);
    }
}
 
  
从请求头中获取事务信息
 
  
springboot中要实现拦截请求要用HandlerInterceptor，并且需要在WebMvcConfigurer把此拦截器注册到InterceptorRegistry
 
  
public class SpringTracingApplier implements com.codingapi.txlcn.tracing.http.spring.HandlerInterceptor, WebMvcConfigurer {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //从header中获取事务组信息
        Tracings.apply(request::getHeader);
        return true;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(this);
    }
}
 
  
 public static void apply(TracingGetter tracingGetter) {
        String groupId = Optional.ofNullable(tracingGetter.get(TracingConstants.HEADER_KEY_GROUP_ID)).orElse("");
        String appList = Optional.ofNullable(tracingGetter.get(TracingConstants.HEADER_KEY_APP_MAP)).orElse("");
        //事务组信息加载到本地上下文
        TracingContext.init(Maps.newHashMap(TracingConstants.GROUP_ID, groupId, TracingConstants.APP_MAP,
                StringUtils.isEmpty(appList) ? appList : new String(Base64Utils.decodeFromString(appList), StandardCharsets.UTF_8)));
        if (TracingContext.tracing().hasGroup()) {
            log.debug("tracing apply group:{}, app map:{}", groupId, appList);
        }
    }
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(分布式事物,TX-LCN)

        

            

                
    
                    
  • SpringCloud-高级篇（七）
                        喵俺第一专栏
springcloudspring后端
                        
    前面在微服务里整合了Seata，下面利用Seata去解决分布式事务的问题，回去学习Seata中的四种解决方案：首先学习XA模式（1）XA模式RM在前面讲的是资源管理器，在XA标准中RM都是由数据库来实现的，数据库本身实现了这个功能XA是分布时事务领域最早的一个标准，几乎主流的数据库都实现了这个标准XA是基于数据库本身的特性来去实现分布式事物的，是能够满足ACID的特性的，它是一种强一致性的事务Se
    
                    
    • 
                    
  • 分布式事务---2PC和3PC原理
                        吹老师个人app编程教学
分布式java
                        
    1分布式事务(1)—2PC和3PC原理分布式事物基本理论:基本遵循CPA理论，采用柔性事物特征，软状态或者最终一致性特点保证分布式事物一致性问题。分布式事物常见解决方案:2PC两段提交协议3PC三段提交协议(弥补两端提交协议缺点)TCC或者GTS(阿里)消息中间件最终一致性使用LCN解决分布式事物，理念“LCN并不生产事务,LCN只是本地事务的搬运工”。2CAP理论的理解CAP理论作为分布式系统的
    
                    
    • 
                    
  • java 2pc 3pc 实现_分布式事务(1)---2PC和3PC原理
                        馒头夹个把子肉
java2pc3pc实现
                        
    分布式事物基本理论:基本遵循CPA理论，采用柔性事物特征，软状态或者最终一致性特点保证分布式事物一致性问题。分布式事物常见解决方案:2PC两段提交协议3PC三段提交协议(弥补两端提交协议缺点)TCC或者GTS(阿里)消息中间件最终一致性使用LCN解决分布式事物，理念“LCN并不生产事务,LCN只是本地事务的搬运工”。一、两阶段提交(2PC)两阶段提交又称2PC,2PC是一个非常经典的强一致、中心化
    
                    
    • 
                    
  • 基础组件-分布式事物Seata
                        徒步远方999
技术方案分布式javaspringbootspringcloud
                        
    Seata一、技术选型选型对象和特性支持Seata模式AT、TCC、Saga支持数据库类型AT支持mysq/oracle/pgtcc/Saga不依赖数据库类型容器化部署支持RPC框架dubbo,springboot,gRPCTC高可用支持（高可用TCC/saga幂等接口自行控制）持久化支持（故障数据）重试支持（不断重试，无法保证不重复通知）注册中心nacos/eureka,redis,zk,con
    
                    
    • 
                    
  • TX-LCN事务控制原理
                        皮卡车厘子
mysqljava数据库
                        
    原理介绍|事务控制原理TX-LCN由两大模块组成,TxClient、TxManager，TxClient作为模块的依赖框架，提供TX-LCN的标准支持，TxManager作为分布式事务的控制放。事务发起方或者参与反都由TxClient端来控制。原理图:核心步骤创建事务组是指在事务发起方开始执行业务代码之前先调用TxManager创建事务组对象，然后拿到事务标示GroupId的过程。加入事务组添加事
    
                    
    • 
                    
  • SpringBoot常用库
                        青风野客

                        
    maven仓库ALiYunALiYunhttp://maven.aliyun.com/nexus/content/groups/public分布式事物TX-LCN缓存spring-boot-starter-cachespring-boot-starter-data-redis数据库ORMmybatis-plus-boot-starterJSONfastjson常用工具库hutool-all令牌生成
    
                    
    • 
                    
  • SpringCloud+Nacos+Seata实现分布式事物
                        尔雅221
中间件springspringcloud分布式中间件
                        
    文章目录1.macOS上Seata安装2.seata配置3.jdk问题4.服务中加Seata配置5.校验分布式事物前言提示：Spring提供了对编程式事务和声明式事务的支持，编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管
    
                    
    • 
                    
  • Spring-Cloud分布式事物Seata
                        染指1110
个人学习springcloudalibaba分布式
                        
    分布式事务就是为了保证多个jdbc实例同时成功或同时失败分布式事务模型DTPDTP模型由5个元素组成应用程序(ApplicationProgram，简称AP)：用于定义事务边界(即定义事务的开始和结束)，并且在事务边界内对资源进行操作。资源管理器(ResourceManager，简称RM)：跟数据库打交道告诉数据库开启事物回滚事物增删改查等如数据库、文件系统等，并提供访问资源的方式。事务管理器(T
    
                    
    • 
                    
  • Spring Cloud Alibaba Seata 实现分布式事物
                        悟世君子
springcloud分布式springcloudjava微服务
                        
    Seata是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata将为用户提供了AT、TCC、SAGA和XA事务模式，为用户打造一站式的分布式解决方案Seata官网：https://seata.io/zh-cn/SpringCloudAlibaba官网：https://sca.aliyun.com/zh-cn/版本说明SpringBoot版本2.6.5SpringCl
    
                    
    • 
                    
  • MongoDb学习笔记-1
                        六默
工作学习总结mongodb
                        
    1.简介mongoDb是一款性能非常优秀的nosql型文档数据库，横向扩展支持很大数据量和并发。主要特点：存储数据模型是json不需要提前创建数据模型4.0后支持分布式事物多形性（同一个集合可以包含不同字段（类型）的文档对象动态性（线上修改数据模式，修改时应用于数据库无续修改schema）数据治理（支持对collection进行jsonscheme来规范数据模式）目前mongo有两个版本，开源版与
    
                    
    • 
                    
  • Spring + Jta +JDBCTemplate 分布式事物实现方式
                        凯雄，长沙起风了、
后端springJTA分布式事物多数据源Atomikos
                        
    最近项目中需要用到多数据源管,数据访问层采用的是JDBCTemplate去做的,一开始是在数据源这块做了一个多数据源的操作类,通过拦截器注解去动态赋值指定的数据源操作,这种做法在查询中是没有问题的,但是DML操作时,会出现问题:事物中无法动态操作数据源,导致很多操作指针对第一个库。查询资料的时候发现:DataSourceTransactionManager这个事物管理类只针对单个数据源进行事物控制
    
                    
    • 
                    
  • 分布式
                        无痕25

                        
    1.分布式事物不知道你是否遇到过这样的情况，去小卖铺买东西，付了钱，但是店主因为处理了一些其他事，居然忘记你付了钱，又叫你重新付。又或者在网上购物明明已经扣款，但是却告诉我没有发生交易。这一系列情况都是因为没有事务导致的。这说明了事务在生活中的一些重要性。有了事务，你去小卖铺买东西，那就是一手交钱一手交货。有了事务，你去网上购物，扣款即产生订单交易。2.事务的具体定义什么是分布式事务分布式事务指事
    
                    
    • 
                    
  • 20-SpringCloudAlibaba-3
                        是三好
学习整理分布式事务seata
                        
    七分布式事物处理1认识本地事物什么是事物事务就是针对数据库的一组操作，它可以由一条或多条SQL语句组成，同一个事务的操作具备同步的特点，事务中的语句要么都执行，要么都不执行。举个栗子：你去小卖铺买东西，一手交钱，一手交货就是一个事务的例子，交钱和交货必须全部成功，事务才算成功，任何一个活动失败，事务将撤销所有已成功的活动。什么是本地事物在计算机系统中，更多的是通过关系型数据库来控制事务，这是利用数
    
                    
    • 
                    
  • Spring Cloud：初始Spring Cloud（01）
                        贾诩是也
SpringCloud
                        
    研究了一段时间springboot了准备向spirngcloud进发，公司架构和项目也全面拥抱了SpringCloud。在使用了一段时间后发现SpringCloud从技术架构上降低了对大型系统构建的要求，使我们以非常低的成本（技术或者硬件）搭建一套高效、分布式、容错的平台，但SpringCloud也不是没有缺点，小型独立的项目不适合使用，另外对分布式事物的支持暂时也没有。SpringCloud是什
    
                    
    • 
                    
  • 分布式事物实现方案及优缺点
                        lizz666
SpringJava分布式
                        
    实现分布式事务是一个复杂的任务，涉及到许多技术和概念。在Java开发中，你可以借助一些框架和工具来实现分布式事务，以下是一些常见的方法：1.两阶段提交（2PC）这是一种经典的分布式事务处理方法。它涉及到一个协调者（Coordinator）和多个参与者（Participants）。2PC的问题在于它的严重阻塞性，以及在协调者或参与者发生故障时可能会导致一些问题。整个过程可以分为两个阶段：准备阶段：协
    
                    
    • 
                    
  • 分布式事务解决方案tx-lcn和seata简单对比分析
                        婲落ヽ紅顏誶
springcloud分布式
                        
    tx-lcn是本地事务协调，本身并不会产生事务seata是两阶段提交事务，第一阶段解析业务sql并生成对应快照，第二阶段是提交/回滚，并删除快照
    
                    
    • 
                    
  • MYSQL分布式事物案例
                        成功的失败者

                        
    functx(){tx:=settle.Orm()trans:=settle.OrderTrans{}//启动协调器settle.OrderTransandler.Insert(nil,&trans)//orderDborderDb:=model.Orm()orderDb.Exec("XASTART'"+cast.ToString(trans.Id)+"';")err:=orderDb.Exec(
    
                    
    • 
                    
  • Spring Cloud Alibaba【认识分布式事物、分布式事务产生的场景、什么是两阶段提交、XA方案、Seata方案、业务说明、下载启动Seata服务】（十）
                        童小纯
Spring全家桶分布式SpringCloudjava
                        
    目录分布式事物处理_认识分布式事物分布式事物处理_分布式事务产生的场景分布式事物解决方案_什么是两阶段提交分布式事物解决方案_XA方案分布式事物解决方案_Seata方案Seata提供XA模式实现分布式事务_业务说明Seata提供XA模式实现分布式事务_下载启动Seata服务分布式事物处理_认识分布式事物前言随着互联网的快速发展，软件系统由原来的单体应用转变为分布式应用，下图描述了单体应用向微服务的
    
                    
    • 
                    
  • Spring Cloud Alibaba【转账功能实现上、转账功能实现下、没有引入分布式事物问题演示、项目引入Seata 】（十一）
                        童小纯
Spring全家桶SpringCloudjavasentinel
                        
    目录Seata提供XA模式实现分布式事务_转账功能实现上Seata提供XA模式实现分布式事务_转账功能实现下Seata提供XA模式实现分布式事务_没有引入分布式事物问题演示Seata提供XA模式实现分布式事务_项目引入SeataSeata提供XA模式实现分布式事务_转账功能实现上实现如下功能1、李四账户增加金额。创建cloud-seata-bank2pom引入依赖org.springframewo
    
                    
    • 
                    
  • Spring Cloud Alibaba【实时监控数据、Sentinel为什么需要持久化 、Sentinel组件二次开发、认识本地事物 、事务的四大特性ACID】（九）
                        童小纯
Spring全家桶wpfSpringCloudjava
                        
    目录分布式流量防护_SentinelResource配置详解之fallback和blockHandler都配置分布式流量防护_实时监控数据分布式流量防护_Sentinel为什么需要持久化分布式流量防护_Sentinel组件二次开发分布式事物处理_认识本地事物数据库事务的四大特性ACID分布式流量防护_SentinelResource配置详解之fallback和blockHandler都配置/***
    
                    
    • 
                    
  • 浅谈MySQL分布式事物解决方案
                        寂寞的棍棍

                        
    引言：MySQL存储引擎主要分为InnoDB、MyISAM，它们的主要区别是InnoDB支持事物，而MyISAM不支持。生产环境中我们要尽量使用InnoDB来保证数据的完整性，损失一点点性能也没有太大关系，毕竟我们的数据库是需要做分布式。今天我们就来聊一聊如何在分布式数据库当中用好事物。特别强调：数据库的事物是跟着connection走的，通俗点来讲将不同库的SQL操作放在同一个事物当中是没有意义
    
                    
    • 
                    
  • 分布式事物【RocketMQ事务消息、Docker安装 RocketMQ、实现订单微服务、订单微服务业务层实现】(八)-全面详解（学习总结---从入门到深化）
                        童小纯
Java基础深化和提高分布式事物数据库java分布式
                        
    目录可靠消息最终一致性分布式事务实现_RocketMQ事务消息可靠消息最终一致性分布式事务实战_案列业务介绍数据库表设计可靠消息最终一致性分布式事务实战_Docker安装RocketMQ部署RocketMQ的管理工具可靠消息最终一致性分布式事务实战_实现订单微服务可靠消息最终一致性分布式事务实战_订单微服务业务层实现可靠消息最终一致性分布式事务实战_订单微服务监听事务消息可靠消息最终一致性分布式事
    
                    
    • 
                    
  • 分布式事物【XA强一致性分布式事务实战、分布式架构的理论知识、TCC核心组成】(六)-全面详解（学习总结---从入门到深化）
                        童小纯
Java基础深化和提高分布式分布式事物数据库java
                        
    目录XA强一致性分布式事务实战_业务层实现分布式架构的理论知识_BASE理论BASE理论三要素分布式事务解决方案_最终一致性分布式事务最终一致性分布式事务解决方案_TCC是什么TCC核心组成Hmily实现TCC分布式事务实战_认识Hmily-TCCHmily实现TCC分布式事务实战_业务场景介绍XA强一致性分布式事务实战_业务层实现项目的业务逻辑层主要实现具体的跨库转账的业务逻辑，由于具体的XA跨
    
                    
    • 
                    
  • 分布式事物【库存微服务业务层实现、实现充值微服务、充值微服务之业务层实现、账户微服务之业务层实现】(九)-全面详解（学习总结---从入门到深化）
                        童小纯
Java基础深化和提高分布式分布式事物java数据库
                        
    目录可靠消息最终一致性分布式事务实战_库存微服务业务层实现可靠消息最终一致性分布式事务实战_测试程序最终一致性分布式事务解决方案_什么是最大努力通知型分布式事务最大努力通知型分布式事务_最大努力通知与可靠消息最终一致性的区别最大努力通知型分布式事务解决方案最大努力通知型分布式事务_案例业务说明最大努力通知型分布式事务实战_实现充值微服务最大努力通知型分布式事务_充值微服务之业务层实现最大努力通知型
    
                    
    • 
                    
  • 分布式事物【XA强一致性分布式事务实战、Seata提供XA模式实现分布式事务】(五)-全面详解（学习总结---从入门到深化）
                        童小纯
Java基础深化和提高分布式事物java数据库
                        
    目录Seata提供XA模式实现分布式事务_没有引入分布式事物问题演示Seata提供XA模式实现分布式事务_项目引入SeataXA强一致性分布式事务实战_Atomikos介绍什么是JTAXA强一致性分布式事务实战_业务说明XA强一致性分布式事务实战_项目搭建编写主启动类XA强一致性分布式事务实战_多数据源实现Seata提供XA模式实现分布式事务_没有引入分布式事物问题演示初始数据库数据正常情况发送请
    
                    
    • 
                    
  • 分布式事物【Seata实现、下载启动Seata服务、搭建聚合父工程构建】(四)-全面详解（学习总结---从入门到深化）
                        童小纯
Java基础深化和提高分布式事物数据库java
                        
    目录分布式事物解决方案_XA方案分布式事物解决方案_Seata实现Seata提供XA模式实现分布式事务_业务说明Seata提供XA模式实现分布式事务_下载启动Seata服务Seata提供XA模式实现分布式事务_搭建聚合父工程构建创建工程distribute-transaction字符编码注解生效激活Java编译版本选择FileType过滤pom配置版本IDEA开启DashboardSeata提供X
    
                    
    • 
                    
  • 项目描述1
                        莫等闲！
java学习java开发语言
                        
    学成在线-6分片上传，8xxl-job课程模块开发分布式事务，消息表spring-securityoauth用户认证授权学成在线学成在线认证授权一些代码黑马分布式事物框架学习-若依/RuoYi-Vue-Plus统一数据权限若依数据权限使用数据权限表结构1.设备故障描述负载均衡消费消息负载均衡的策共享队列模式订阅EMQ中的售货机状态消息，当设备为故障状态的时候，创建一个自动维修工单。2.xxl-jo
    
                    
    • 
                    
  • 分布式事务一 事物以及分布式事物介绍
                        麦芽糖0219
java分布式数据库java
                        
    一事务简介事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。在关系数据库中，一个事务由一组SQL语句组成。事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。原子性（atomicity）：一个事务是一个不可分割的工作单位，事务中包括的所有操作要么都做，要么都不做。一致性（consistency）：事务必须是使数据库从一
    
                    
    • 
                    
  • 分布式事物解决方案-Seata
                        徒步远方999
技术方案分布式
                        
    Seata官网：http://seata.io/zh-cn/docs/overview/what-is-seata.html案例：http://c.biancheng.net/springcloud/seata.html
    
                    
    • 
                    
  • 分布式事务的常⻅解决⽅案
                        詹姆斯-穆里尼奥
分布式javakafka
                        
    常⻅分布式事务解决⽅案2PC和3PC两阶段提交,基于XA协议TCCTry、Confirm、Cancel事务消息最⼤努⼒通知型分布式事务分类刚性事务：遵循ACID柔性事务：遵循BASE理论分布式事务框架TX-LCN：⽀持2PC、TCC等多种模式https://github.com/codingapi/tx-lcn更新慢（个⼈感觉处于停滞状态）Seata：⽀持AT、TCC、SAGA和XA多种模式htt
    
                    
    • 
                                
  • ztree设置禁用节点
                                    3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax
                                    
    ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 
 
 
$(function(){            	
                showTree();
	            setDisabledNode();

});
                   
        
    
                                
    • 
                                
  • JVM patch by Taobao
                                    bookjovi
javaHotSpot
                                    
    在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 
  
7050685：jsdbproc64.sh has a typo in the package name 
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 
7060619：C1 should respect inline and
    
                                
    • 
                                
  • 将session存储到数据库中
                                    dcj3sjt126com
sqlPHPsession
                                    
    CREATE TABLE sessions (
  id CHAR(32) NOT NULL,
  data TEXT,
  last_accessed TIMESTAMP NOT NULL,
  PRIMARY KEY (id)
); 
  
<?php
/**
 * Created by PhpStorm.
 * User: michaeldu
 * Date
    
                                
    • 
                                
  • Vector
                                    171815164
vector
                                    
    public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
		for (int i = 0; i < cart.size(); i++) {
			if (cart.get(i).getId().equals(id)) {
				cart.remove(i);
				
    
                                
    • 
                                
  • 各连接池配置参数比较
                                    g21121
连接池
                                    
            排版真心费劲，大家凑合看下吧，见谅~ 
      
  
Druid 
DBCP 
C3P0 
Proxool   
数据库用户名称 Username Username User     
数据库密码 Password Password Password     
驱动名
    
                                
    • 
                                
  • [简单]mybatis insert语句添加动态字段
                                    53873039oycg
mybatis
                                    
          mysql数据库,id自增,配置如下： 
      
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
		parameterType=&
    
                                
    • 
                                
  • struts2拦截器配置
                                    云端月影
struts2拦截器
                                    
    struts2拦截器interceptor的三种配置方法 
方法1. 普通配置法 
 
<struts> 
    <package name="struts2" extends="struts-default"> 
        &
    
                                
    • 
                                
  • IE中页面不居中，火狐谷歌等正常
                                    aijuans
IE中页面不居中
                                    
    问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
    
                                
    • 
                                
  • String,int,Integer,char 几个类型常见转换
                                    antonyup_2006
htmlsql.net
                                    
    如何将字串 String 转换成整数 int? 
int i = Integer.valueOf(my_str).intValue(); 
 
int i=Integer.parseInt(str); 
 
如何将字串 String 转换成Integer ? 
Integer integer=Integer.valueOf(str); 
 
如何将整数 int 转换成字串 String ? 
1.
    
                                
    • 
                                
  • PL/SQL的游标类型
                                    百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
                                    
    游标是oracle中的一个结果集,用于存放查询的结果; 
  
PL/SQL中游标的声明; 
1,声明游标

2,打开游标(默认是关闭的);

3,提取数据

4,关闭游标
 
  
  
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标 
  
隐式游标:主要是对DML数据的操作隐
    
                                
    • 
                                
  • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
                                    bijian1013
JUnit4单元测试
                                    
    一.基础知识 
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
    
                                
    • 
                                
  • 精通Oracle10编程SQL(12)开发包
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发包
 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
 */
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
    
                                
    • 
                                
  • 【EhCache二】ehcache.xml配置详解
                                    bit1129
ehcache.xml
                                    
    在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ 
ehcache.xml ： http://ehcache.org/ehcache.xml 
ehcache.xsd ： http://ehcache.org/ehcache.xsd 
ehcache配置文件的根元素是ehcahe 
  ehcac
    
                                
    • 
                                
  • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
                                    白糖_
javaeclipsespringtomcatWeb
                                    
    今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： 
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
 随后启动
    
                                
    • 
                                
  • angular.element
                                    boyitech
AngularJSAngularJS APIangular.element
                                    
    angular.element 
描述:      包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）       如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
    
                                
    • 
                                
  • java-给定两个已排序序列，找出共同的元素。
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class CommonItemInTwoSortedArray {

	/**
	 * 题目：给定两个已排序序列，找出共同的元素。
	 * 1.定义两个指针分别指向序列的开始。
	 * 如果指向的两个元素
    
                                
    • 
                                
  • sftp 异常，有遇到的吗？求解
                                    Chen.H
javajcraftauthjschjschexception
                                    
    com.jcraft.jsch.JSchException: Auth cancel 
 at com.jcraft.jsch.Session.connect(Session.java:460) 
 at com.jcraft.jsch.Session.connect(Session.java:154) 
 at cn.vivame.util.ftp.SftpServerAccess.connec
    
                                
    • 
                                
  • [生物智能与人工智能]神经元中的电化学结构代表什么?
                                    comsci
人工智能
                                    
         我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 
 
     我们可以尝试一下...在某些神经
    
                                
    • 
                                
  • 通过LAC和CID获取经纬度信息
                                    dai_lm
laccid
                                    
    方法1： 
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 
 
方法2： 
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
    
                                
    • 
                                
  • JAVA的困难分析
                                    datamachine
java
                                    
    前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 
  
-----------------------------------------------------------------------------------------
    
                                
    • 
                                
  • 小学5年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    money 钱 
paper 纸 
speak 讲，说 
tell 告诉 
  
remember 记得，想起 
knock 敲，击，打 
question 问题 
number 数字，号码 
  
learn 学会，学习 
street 街道 
carry 搬运，携带 
send 发送，邮寄，发射 
  
must 必须 
light 灯，光线，轻的 
front 
    
                                
    • 
                                
  • linux下面没有tree命令
                                    dcj3sjt126com
linux
                                    
    centos p安装 
yum -y install tree 
  
mac os安装 
brew install tree 
  首先来看tree的用法  
tree  中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
    
                                
    • 
                                
  • Map迭代方式，Map迭代，Map循环
                                    蕃薯耀
Map循环Map迭代Map迭代方式
                                    
    Map迭代方式，Map迭代，Map循环 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年
    
                                
    • 
                                
  • Spring Cache注解+Redis
                                    hanqunfeng
spring
                                    
    Spring3.1 Cache注解  
依赖jar包： 
<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			
    
                                
    • 
                                
  • Guava中针对集合的 filter和过滤功能
                                    jackyrong
filter
                                    
    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 
 
   

@Test
public void whenFilterWithIterables_thenFiltered() {
    List<String> names = Lists.newArrayList("John"
    
                                
    • 
                                
  • 学习编程那点事
                                    lampcy
编程androidPHPhtml5
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • 架构师之流处理---------bytebuffer的mark,limit和flip
                                    nannan408
ByteBuffer
                                    
    1.前言。 
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 
2.例子. 
 

例子代码:
     String str = "helloWorld";  
        ByteBuffer buff  = ByteBuffer.wrap(str.getBytes());  
        Sy
    
                                
    • 
                                
  • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
                                    Everyday都不同
$转义el表达式
                                    
    最近在做Highcharts的过程中，在写js时，出现了以下异常： 
  
严重: Servlet.service() for servlet jsp threw exception 
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
    
                                
    • 
                                
  • 用Java实现发送邮件到163
                                    tntxia
java实现
                                    
    /*

 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

 此篇仅介绍用
    
                                
    • 
                                
  • 探索实体类存在的真正意义
                                    java小叶檀
POJO
                                    
    一. 实体类简述   
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 
POJO（Plain Old Java Objects）简单的Java对象 
  
它的一般格式就是 
public class A{
      private String id;
      public Str
    
                                
    •