CoderTnT
CoderTnT

Tx-lcn 源码解析：基于lcn模式下的正常流程源码（3）

 

一、代理Connect的获取

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

请记住：state为事务状态，state=1表示分布式事务成功，本地连接提交，其它为失败进行本地连接回滚。

代理连接代码如下:



package com.codingapi.txlcn.tc.core.transaction.lcn.resource;

import com.codingapi.txlcn.txmsg.dto.RpcResponseState;
import lombok.extern.slf4j.Slf4j;

import java.sql.*;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * @author CoderTnT
 */
@Slf4j
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;
        }
    }
    
    
    // autoCommit设置false，表示 连接关闭自动提交，采用手动提交模式
    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        connection.setAutoCommit(false);
    }

    @Override
    public void commit() throws SQLException {
        connection.commit();
    }

    @Override
    public void rollback() throws SQLException {
        connection.rollback();
    }

    @Override
    public void close() throws SQLException {
        connection.close();
    }


    @Override
    public boolean getAutoCommit() throws SQLException {
        return connection.getAutoCommit();
    }
    /*
    * 忽略其他无关代码。。。
    */

}

 LcnConnectionProxy代理连接的获取是通过AOP实现的

@Aspect
@Component
@Slf4j
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;
    }

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


    @Override
    public int getOrder() {
        return txClientConfig.getResourceOrder();
    }


}
@Component
@Slf4j
public class DTXResourceWeaver {

    private final TxLcnBeanHelper txLcnBeanHelper;

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

    public Object getConnection(ConnectionCallback connectionCallback) throws Throwable {
        //获取事务本地上下文 dtxLocalContext
        DTXLocalContext dtxLocalContext = DTXLocalContext.cur();
        if (Objects.nonNull(dtxLocalContext) && dtxLocalContext.isProxy()) {
            //获取事务本地上下文的事务类型  dtxLocalContext的事务类型
            String transactionType = dtxLocalContext.getTransactionType();
            //根据事务类型获取事务代理器：LcnTransactionResourceProxy或TccTransactionResourceProxy或TxcTransactionResourceProxy
            TransactionResourceProxy resourceProxy = txLcnBeanHelper.loadTransactionResourceProxy(transactionType);
            //由事务代理器根据connectionCallback Connection提供者 构造生成代理连接connection对象
            Connection connection = resourceProxy.proxyConnection(connectionCallback);
            log.debug("proxy a sql connection: {}.", connection);
            return connection;
        }
        return connectionCallback.call();
    }
}

二、整体正常执行的代码流程

实现分布式事务需要在特定执行的service方法上增加一个注解@LcnTransaction，这也是一个入口，整个流程的开始就在这里。

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

2.1 分布式事务执行方法的环绕

@Aspect    //切面类注解
@Component
@Slf4j
public class TransactionAspect implements Ordered {

    private final TxClientConfig txClientConfig;

    private final DTXLogicWeaver dtxLogicWeaver;

    public TransactionAspect(TxClientConfig txClientConfig, DTXLogicWeaver dtxLogicWeaver) {
        this.txClientConfig = txClientConfig;
        this.dtxLogicWeaver = dtxLogicWeaver;
    }

    /**
     * DTC Aspect Common type() can lcn,tcc,txc and custom DTX type
     */
    @Pointcut("@annotation(com.codingapi.txlcn.tc.annotation.TxTransaction)")
    public void txTransactionPointcut() {
    }

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

    /**
     * DTC Aspect (Type of TXC)
     */
    @Pointcut("@annotation(com.codingapi.txlcn.tc.annotation.TxcTransaction)")
    public void txcTransactionPointcut() {
    }

    /**
     * DTC Aspect (Type of TCC)
     */
    @Pointcut("@annotation(com.codingapi.txlcn.tc.annotation.TccTransaction)")
    public void tccTransactionPointcut() {
    }


    @Around("txTransactionPointcut()")
    public Object transactionRunning(ProceedingJoinPoint point) throws Throwable {
        //见2.1.1
        DTXInfo dtxInfo = DTXInfo.getFromCache(point);
        TxTransaction txTransaction = dtxInfo.getBusinessMethod().getAnnotation(TxTransaction.class);
        dtxInfo.setTransactionType(txTransaction.type());
        dtxInfo.setTransactionPropagation(txTransaction.propagation());
        return dtxLogicWeaver.runTransaction(dtxInfo, point::proceed);
    }

    @Around("lcnTransactionPointcut() && !txcTransactionPointcut()" +
            "&& !tccTransactionPointcut() && !txTransactionPointcut()")
    public Object runWithLcnTransaction(ProceedingJoinPoint point) throws Throwable {
        //根据ProceedingJoinPoint  从缓存中获取事务信息dtxInfo
        DTXInfo dtxInfo = DTXInfo.getFromCache(point);
        //获取注解LcnTransaction，因为注解LcnTransaction上配置不同的传播行为propagation，如REQUIRED，SUPPORTS等
        LcnTransaction lcnTransaction = dtxInfo.getBusinessMethod().getAnnotation(LcnTransaction.class);
        //设置dtxInfo的事务类型为LCN
        dtxInfo.setTransactionType(Transactions.LCN);
        //设置事务传播行为，发起方是REQUIRED，参与方式是SUPPORTS
        dtxInfo.setTransactionPropagation(lcnTransaction.propagation());
        //织入后 开始执行事务
        //见2.1.2
        return dtxLogicWeaver.runTransaction(dtxInfo, point::proceed);
    }
   /*
   *  忽略其他代码。。。
   */
}

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

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

2.1.2 事务执行runTransaction方法

public Object runTransaction(DTXInfo dtxInfo, BusinessCallback business) throws Throwable {
        // 1、获取或新建一个线程变量DTXLocalContext
        if (Objects.isNull(DTXLocalContext.cur())) {
            DTXLocalContext.getOrNew();
        } else {
            return business.call();
        }

        log.debug("<---- TxLcn start ---->");
        DTXLocalContext dtxLocalContext = DTXLocalContext.getOrNew();
        TxContext txContext;
        // ---------- 保证每个模块在一个DTX下只会有一个TxContext ---------- //
        //2、如果已经存在事务上下文则获取，否则构建事务上下文TxContext 
        if (globalContext.hasTxContext()) {
            // 有全局TC事务上下文的获取上下文
            txContext = globalContext.txContext();
            dtxLocalContext.setInGroup(true);
            log.debug("Unit[{}] used parent's TxContext[{}].", dtxInfo.getUnitId(), txContext.getGroupId());
        } else {
            // 没有的开启本地事务上下文
            // 见2.1.4
            txContext = globalContext.startTx();
        }

        // 本地事务调用
        if (Objects.nonNull(dtxLocalContext.getGroupId())) {
            dtxLocalContext.setDestroy(false);
        }
        //3、为DTXLocalContext设置参数
        dtxLocalContext.setUnitId(dtxInfo.getUnitId());
        dtxLocalContext.setGroupId(txContext.getGroupId());
        dtxLocalContext.setTransactionType(dtxInfo.getTransactionType());

        // 事务参数
        //4、构造TxTransactionInfo 并设置参数
        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 {
            //执行5、执行事务 事务业务执行
            return transactionServiceExecutor.transactionRunning(info);
        } 
        //6、finally做一些通知与销毁操作。
        //见2.1.5
        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 ---->");
        }
    }

2.1.3 主要说下2.1.2代码注释中的第2点什么情况下要获取已有的TxContext ，什么时候构造新的

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

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

2.1.4 构建新的TxContext

public TxContext startTx() {
        TxContext txContext = new TxContext();
        // 事务发起方判断
        txContext.setDtxStart(!TracingContext.tracing().hasGroup());
        // 是否为事务发起方
        if (txContext.isDtxStart()) {
            //是的话开始 初始化事务组操作,主要是构造事务组groupId，并放入以groupId和appMap为键的Map 到tracingContext对象缓存中
            TracingContext.tracing().beginTransactionGroup();
        }
        //设置txContext事务组groupId
        txContext.setGroupId(TracingContext.tracing().groupId());
        String txContextKey = txContext.getGroupId() + ".dtx";
        //key与txContext缓存起来
        attachmentCache.attach(txContextKey, txContext);
        log.debug("Start TxContext[{}]", txContext.getGroupId());
        return txContext;
    }

2.1.5  线程执行完的一些销毁动作 放到finally 块中

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 ---->");
        }
@Override
    public void destroyTx() {
        if (!hasTxContext()) {
            throw new IllegalStateException("non TxContext.");
        }
        // 销毁缓存中的 以groupId.dtx 为键的事务组信息
        destroyTx(txContext().getGroupId());
    }

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

 @Override
    public void destroyTx(String groupId) {
        attachmentCache.remove(groupId + ".dtx");
        log.debug("Destroy TxContext[{}]", groupId);
    }

三、LCN分布式事务业务执行器 开始执行事务：transactionServiceExecutor.transactionRunning(info)

/**
     * 事务业务执行
     *
     * @param info info
     * @return Object
     * @throws Throwable Throwable
     */
    public Object transactionRunning(TxTransactionInfo info) throws Throwable {

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

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

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

        // 3. 获取本地分布式事务控制器   dtxLocalControl ：事务发起方控制器是LcnStartingTransaction，事务参与方控制器是LcnRunningTransaction
        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);
        }
    }

3.1 事务控制器根据事务类型与传播状态执行的也不同。获取传播类型：发起方是create，参与方是join

 @Override
    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;
    }

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

Tx-lcn 源码解析：基于lcn模式下的正常流程源码（3）_第1张图片

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

3.3.1 执行业务前preBusinessCode方法：dtxLocalControl.preBusinessCode(info);

1）发起方：LcnStartingTransaction

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

设置DTXLocalContext的proxy为true。

@Override
    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();
    }
 /**
     * Client创建事务组操作集合
     *
     * @param groupId         groupId
     * @param unitId          unitId
     * @param transactionInfo txTrace
     * @param transactionType transactionType
     * @throws TransactionException 创建group失败时抛出
     */
    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");
    }
@Override
    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));
        }
    }

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

@Service("rpc_create-group")
public class CreateGroupExecuteService implements RpcExecuteService {

    private static final TxLogger txLogger = TxLogger.newLogger(CreateGroupExecuteService.class);

    private final TransactionManager transactionManager;

    @Autowired
    public CreateGroupExecuteService(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    @Override
    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;
    }
}


    @Override
    public void begin(String groupId) throws TransactionException {
        try {
            dtxContextRegistry.create(groupId);
        } catch (TransactionException e) {
            throw new TransactionException(e);
        }
    }
@Override
    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);
    }
 @Override
    public void initGroup(String groupId) {
        redisTemplate.opsForHash().put(REDIS_GROUP_PREFIX + groupId, "root", "");
        redisTemplate.expire(REDIS_GROUP_PREFIX + groupId, managerConfig.getDtxTime() + 10000, TimeUnit.MILLISECONDS);
    }

lcn-manager服务端会以hash结构在redis创建一个key。hashkey为“tm:group:”+groupId，key为root，value为空。超时时间为分布式事务超时时间dtxTime（默认值8秒）外加上10s 一共18秒。

2）参与方 ：LcnRunningTransaction

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

3.3.2 执行业务方法doBusinessCode ：dtxLocalControl.doBusinessCode(info);

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

/**
     * 执行业务代码
     *
     * @param info info
     * @return  Object Object
     * @throws Throwable Throwable
     */
    default Object doBusinessCode(TxTransactionInfo info) throws Throwable {
        // 调用执行服务
        return info.getBusinessCallback().call();
    }

3.3.3 业务执行成功方法onBusinessCodeSuccess：dtxLocalControl.onBusinessCodeSuccess(info, result);

1）发起方：LcnStartingTransaction

设置系统分布式事务状态为1，代表标识成功

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

2）参与方：LcnRunningTransaction

加入到事务组

@Override
    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());
    }
 /**
     * Client加入事务组操作集合
     *
     * @param groupId         groupId
     * @param unitId          unitId
     * @param transactionType transactionType
     * @param transactionInfo txTrace
     * @throws TransactionException 加入事务组失败时抛出
     */
    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");
    }
@Override
    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));
        }
    }

lcn-client客户端会调用lcn-manager服务端去把当前操作加入到事务组中。服务端收到后会调用JoinGroupExecuteService类的execute进行处理。

@Service("rpc_join-group")
public class JoinGroupExecuteService implements RpcExecuteService {

    private static final TxLogger txLogger = TxLogger.newLogger(JoinGroupExecuteService.class);

    private final TransactionManager transactionManager;

    private final DTXContextRegistry dtxContextRegistry;

    private final RpcClient rpcClient;


    @Autowired
    public JoinGroupExecuteService(TransactionManager transactionManager,
                                   DTXContextRegistry dtxContextRegistry, RpcClient rpcClient) {
        this.transactionManager = transactionManager;
        this.dtxContextRegistry = dtxContextRegistry;
        this.rpcClient = rpcClient;
    }


    @Override
    public Serializable execute(TransactionCmd transactionCmd) throws TxManagerException {
        try {
            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());
            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;
    }
}

@Override
    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);
    }
@Override
    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() + ']');
        }
    }
@Override
    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);
    }

lcn-manager服务端收到信息后会在redis与creategroup的hashkey相同数据下(hashkey为“tm:group:”+groupId)保存事务单元信息，key为事务单元id,值为事务单元信息。

3.3.4 业务执行成功后finally中的postBusinessCode：dtxLocalControl.postBusinessCode(info);

1）客户端发起方 LcnStartingTransaction 通知lcn-manager 服务端 处理事务组，然后服务端返回状态值state,根据状态值，客户端发起方再决定真正的提交事务还是回滚事务。客户端参与方 不加额外处理。

@Override
    public void postBusinessCode(TxTransactionInfo info) {
        // RPC close DTX group
        transactionControlTemplate.notifyGroup(
                info.getGroupId(), info.getUnitId(), info.getTransactionType(),
                DTXLocalContext.transactionState(globalContext.dtxState(info.getGroupId())));
    }
/**
     * Client通知事务组操作集合
     *
     * @param groupId         groupId
     * @param unitId          unitId
     * @param transactionType transactionType
     * @param state           transactionState
     */
    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
            state = reliableMessenger.notifyGroup(groupId, state);
           //清理事务 包含本地事务的提交和回滚 
           //执行不同代理LcnConnectionProxy的notify(int state)方法
            //细节见3.3.5
            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);
    }

注意：通知事务组进行提交事务这边比较绕。

 @Override
    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);
    }

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

@Service("rpc_notify-group")
public class NotifyGroupExecuteService implements RpcExecuteService {

    private static final TxLogger txLogger = TxLogger.newLogger(NotifyGroupExecuteService.class);

    private final TransactionManager transactionManager;

    private final DTXContextRegistry dtxContextRegistry;

    @Autowired
    public NotifyGroupExecuteService(TransactionManager transactionManager, DTXContextRegistry dtxContextRegistry) {
        this.transactionManager = transactionManager;
        this.dtxContextRegistry = dtxContextRegistry;
    }

    @Override
    public Serializable execute(TransactionCmd transactionCmd) throws TxManagerException {
        try {
            DTXContext dtxContext = dtxContextRegistry.get(transactionCmd.getGroupId());
            // 解析参数
            NotifyGroupParams notifyGroupParams = transactionCmd.getMsg().loadBean(NotifyGroupParams.class);
           //如果状态为1则事务成功，通知参与模块进行提交
            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);
            } 
          //如果状态为0则事务失败，通知参与模块进行回滚
          else if (commitState == 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.");
        }
    }
}

 @Override
    public void commit(DTXContext dtxContext) throws TransactionException {
        notifyTransaction(dtxContext, 1);
    }
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方法进行处理
 
  
@Service("rpc_lcn_notify-unit")
@Slf4j
public class LcnNotifiedUnitService extends DefaultNotifiedUnitService {

    @Autowired
    public LcnNotifiedUnitService(TransactionCleanTemplate transactionCleanTemplate, TCGlobalContext context) {
        super(transactionCleanTemplate, context);
    }
}
 
  
public class DefaultNotifiedUnitService implements RpcExecuteService {

    private static final TxLogger txLogger = TxLogger.newLogger(DefaultNotifiedUnitService.class);

    private final TransactionCleanTemplate transactionCleanTemplate;

    private TCGlobalContext globalContext;

    public DefaultNotifiedUnitService(TransactionCleanTemplate transactionCleanTemplate, TCGlobalContext globalContext) {
        this.transactionCleanTemplate = transactionCleanTemplate;
        this.globalContext = globalContext;
    }

    @Override
    public Serializable execute(TransactionCmd transactionCmd) throws TxClientException {
        try {
            NotifyUnitParams notifyUnitParams = transactionCmd.getMsg().loadBean(NotifyUnitParams.class);
            // 保证业务线程执行完毕后执行事务清理操作
            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();
                }
            }
            // 事务清理操作
            // 见3.3.5
            transactionCleanTemplate.clean(
                    notifyUnitParams.getGroupId(),
                    notifyUnitParams.getUnitId(),
                    notifyUnitParams.getUnitType(),
                    notifyUnitParams.getState());
            return true;
        } catch (TransactionClearException | InterruptedException e) {
            throw new TxClientException(e);
        }
    }
}
 
  
3.3.5  根据服务端返回的状态值state 客户端决定真正执行提交本地事务还是回滚
 
  
调用的方法为：transactionCleanTemplate.clean(groupId, unitId, transactionType, state);
 
  
/**
     * 清理事务
     *
     * @param groupId  groupId
     * @param unitId   unitId
     * @param unitType unitType
     * @param state    transactionState
     * @throws TransactionClearException TransactionClearException
     */
    public void clean(String groupId, String unitId, String unitType, int state) throws TransactionClearException {
        txLogger.txTrace(groupId, unitId, "clean transaction");
        try {
            cleanWithoutAspectLog(groupId, unitId, unitType, state);
            aspectLogger.clearLog(groupId, unitId);
        } catch (TransactionClearException e) {
            if (!e.isNeedCompensation()) {
                aspectLogger.clearLog(groupId, unitId);
            }
        } catch (Throwable throwable) {
            aspectLogger.clearLog(groupId, unitId);
        }
        txLogger.txTrace(groupId, unitId, "clean transaction over");
    }

 
  
/**
     * 清理事务（不清理切面日志）
     *
     * @param groupId  groupId
     * @param unitId   unitId
     * @param unitType unitType
     * @param state    transactionState
     * @throws TransactionClearException TransactionClearException
     */
    public void cleanWithoutAspectLog(String groupId, String unitId, String unitType, int state) throws TransactionClearException {
        try {
            transactionBeanHelper.loadTransactionCleanService(unitType).clear(
                    groupId, state, unitId, unitType
            );
        } finally {
            globalContext.clearGroup(groupId);

            dtxChecking.stopDelayChecking(groupId, unitId);
        }
    }
 
  
  /**
     * 事务清理业务
     *
     * @param groupId  groupId
     * @param state    事务状态 1 提交 0 回滚
     * @param unitId   unitId
     * @param unitType 事务类型
     * @throws TransactionClearException TransactionClearException
     */
    void clear(String groupId, int state, String unitId, String unitType) throws TransactionClearException;

 
  
@Component
@Slf4j
public class LcnTransactionCleanService implements TransactionCleanService {

    private final TCGlobalContext globalContext;

    @Autowired
    public LcnTransactionCleanService(TCGlobalContext globalContext) {
        this.globalContext = globalContext;
    }

    @Override
    public void clear(String groupId, int state, String unitId, String unitType) throws TransactionClearException {
        try {
            LcnConnectionProxy connectionProxy = globalContext.getLcnConnection(groupId);
            connectionProxy.notify(state);
            // todo notify exception
        } catch (TCGlobalContextException e) {
            log.warn("Non lcn connection when clear transaction.");
        }
    }
}

 
  
@Slf4j
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;
        }
    }
    /*
    *   省略其他代码
    *
    */
}
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    
                    
    • 
                    
  • 导购返利系统的分布式事务管理
                        wx_tangjinjinwx
分布式
                        
    导购返利系统的分布式事务管理大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨导购返利系统中的分布式事务管理。随着系统的分布式架构越来越普遍，如何有效地管理分布式事务成为了一个关键问题。本文将详细介绍如何在Java应用中实现分布式事务管理，并提供相应的代码示例。1.分布式事务的挑战在分布式系统中，事务通常涉及多个服务或数据库，这给事务的一致性和可靠性带
    
                    
    • 
                    
  • 分布式事务之理论基础
                        xiaogaot

                        
    分布式事务的概念理论事务具备以下四个基本特性（ACID）原子性（Atomicity）：一系列操作作被看作一个整体，要么全部成功，要么全部失败一致性（consistency）：如果把所有参与者的数据看成是一个数据集，那么操作前后，数据的总量是不增不减的。也可以理解成数据是满足完整约束的。举例：一个数据集中只有两个参与者A&B，A持有100元，B持有0元，总额100元；A对B转账50元，余额50，B收
    
                    
    • 
                    
  • 两阶段事务提交
                        码农小伙
事务java
                        
    简介分布式事务是指会涉及到操作多个数据库的事务,在分布式系统中，各个节点之间在物理上相互独立，通过网络进行沟通和协调。XA就是X/OpenDTP定义的交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。XA接口函数由数据库厂商提供。二阶段提交(Two-phaseCommit)是指，在计算机网络以及数据库领域内，为了使基于分布式系统架构下的所有
    
                    
    • 
                    
  • 分布式事务
                        天黑了g
技术方案分布式后端微服务
                        
    在微服务结构中，分布式事务是经常要考虑的问题。分布式事务解决方案有多种，有各自的优劣势和适用场景。主流的分布式事务框架库是阿里的seata，将根据seata库说明这些分布式事务的特点。尽量避免使用分布式事务。按照领域驱动设计思想，微服务之间是低耦合，微服务内部是高内聚，领域的限界上下文一般都在一个微服务里，那么微服务内的领域模型也是高内聚的。良好的架构设计只需在微服务里通过本地事务和领域事件就能够
    
                    
    • 
                    
  • fescar源码分析4-TM
                        leiwingqueen

                        
    一、概要说明这里重点分析下TM的实现。下面是TM的定义：TransactionManager(TM):明确全局事务的范围：开始一个全局事务，提交或者回滚一个全局事务简单来说，就是分布式事务的业务发起方。二、配置定义GlobalTransactionScanner。构造函数如下。applicationId和txServiceGroup我们这里可以理解为一个分布式事务的唯一标识。可以用于保存一个事务的
    
                    
    • 
                    
  • seata环境搭建以及官方示例的坑
                        qq_20546587
javaspringbootspringcloud
                        
    1、seataserver搭建（windows）在建seata服务之前请搭建好nacos服务官方的最新的为2.0.0版的，这个版本暂时有些问题，管理分布式事务时会报错。所以建议使用1.8的。下载地址Releases·apache/incubator-seata(github.com)https://github.com/apache/incubator-seata/releases下下来的报也有问
    
                    
    • 
                    
  • 数据库分库分表-ShardingSphere学习
                        学Java的skyyyyyyyy
数据库java
                        
    ShardingSphere是一个开源的分布式数据库中间件解决方案，旨在提供数据库分片、分布式事务、读写分离、数据治理等多种数据服务，它以模块化的方式设计，使用户可以根据不同的应用场景选择适合的模块来部署。ShardingSphere架构概述ShardingSphere的架构主要围绕四个核心组件展开，分别是Sharding-JDBC、Sharding-Proxy、Sharding-Sidecar（
    
                    
    • 
                    
  • 微服务架构（MSA）
                        鸣鸣就
微服务架构microservices
                        
    微服务架构（MSA）的基础是将单个应用程序拆分成多个独立的小服务，这些服务可以独立开发、部署和运行。这个过程类城市建设多个火车站,达到分流的效果。springCloudAlibaba是SpringCloud的一个子项目，致力于提供微服务开发的一站式解决方案。它的核心组件有:服务限流降级、服务注册与发现、分布式配置管理、消息驱动能力、分布式事务、分布式任务调度。Summary：微服务是一个架构设计方
    
                    
    • 
                    
  • Seata 分布式事务控制
                        动物园首领
Seata分布式事务框架分布式Seata
                        
    概述Seata是阿里巴巴和蚂蚁集团内部开发了分布式事务中间件，用于解决电商、支付、物流等业务场景中应用数据的一致性问题，2023年10月，为了更好的通过社区驱动技术的演进，阿里和蚂蚁集团正式将Seata捐赠给Apache基金会。Seata是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata将为用户提供了AT、TCC、SAGA和XA事务模式，为用户打造一站式的分布式
    
                    
    • 
                    
  • 分布式事务
                        懒人w
#分布式分布式
                        
    当我们讨论分布式事务时，我们通常涉及到如何在一个分布式系统中保证事务的一致性。在传统的单体应用中，事务可以保证ACID（原子性、一致性、隔离性、持久性）属性，但在分布式环境中，由于网络延迟、节点故障等因素，实现这些属性变得更加复杂。CAP理论和BASE理论是在分布式系统设计中经常提到的两个概念，它们帮助我们理解在分布式系统中需要做出哪些权衡。CAP理论根据CAP理论，任何分布式系统只能同时满足以下
    
                    
    • 
                    
  • 传播行为、事务回滚、分布式事务（CAP理论和BASE理论）
                        小丁学Java
分布式事务java开发语言
                        
    文章目录1、事务回顾2、传播行为：3、事务回滚4、分布式事务4.1、分布式事务理论4.1.1、CAP理论4.1.1.1、CAP理论的基本概念4.1.1.2、CAP理论的权衡4.1.1.3、CAP理论的应用场景4.1.1.4、CAP理论的启示4.1.2、BASE理论的基本概念4.1.3、BASE理论与CAP理论的关系5、分布式事务解决方案1、事务回顾事务：逻辑上的一组操作，组成这组操作的各个逻辑单元
    
                    
    • 
                    
  • 谷粒商城实战笔记-282~283-商城业务-订单服务-提交订单的问题
                        小手追梦
谷粒商城笔记谷粒商城
                        
    文章目录一，282-商城业务-订单服务-提交订单的问题调试过程中出现的问题services面板介绍什么是ServicesPanel？主要作用解决的痛点使用方法二，283-商城业务-分布式事务-本地事务在分布式下的问题分布式事务问题解决方案分布式事务处理流程事务保证一，282-商城业务-订单服务-提交订单的问题这一节的主要内容是测试正常情况下的订单提交流程是否顺畅。调试过程中出现的问题出现异常后，因
    
                    
    • 
                    
  • 分布式的 服务保护
                        绿蚁新亭
分布式
                        
    商品服务：扣减库存订单服务：保存订单购物车服务：清理购物车这些业务全部都是数据库的写操作，我们必须确保所有操作的同时成功或失败。但是这些操作在不同微服务，也就是不同的Tomcat，这样的情况如何确保事务特性呢？下面则是主要总结的重点微服务保护服务保护方案请求限流隔离和熔断分布式事务初识分布式事务Seata需要掌握的知识:知道雪崩问题产生原因及常见解决方案能使用Sentinel实现服务保护理解分布式
    
                    
    • 
                    
  • 5.分布式事务基础理论-BASE理论
                        LANSHENGYANG

                        
    BASE理论理解强一致性和最终一致性CAP理论告诉我们一个分布式系统最多只能同时满足一致性（Consistency），可用性（Availability）和分区容错性（Partitiontolerance）这三项中的两项，其中AP在实际应用中较多，AP即舍弃一致性，保证可用性和分区容错性，但是在实际生产中很多场景都要实现一致性，比如前边我们举的例子主数据库向从数据库同步数据，即使不要一致性，但是最终
    
                    
    • 
                    
  • 分布式事务的几种解决方案
                        北极冰雨
微服务java分布式
                        
    分布式事务的几种解决方案事务理论BASE理论解决方案2PC-两阶段提交协议3PC-两阶段提交协议TCC-事务SAGA-事务AT-事务当架构从单体走向分布式，特别是转向微服务架构。随之而来就必然遇到分布式事务这个难题，什么是分布式事务？就是在分布式系统中运行的事务，使用多个数据源，由多个本地事务组合而成。在分布式场景下，对事务的处理操作可能来自不同的机器，甚至是来自不同的操作系统，保证数据一致性。整
    
                    
    • 
                    
  • 分布式事务处理模型:一致性 TCC VS 2PC
                        学博成
技术分布式事务
                        
    TCC（Try-Confirm/Cancel）和2PC（Two-PhaseCommit，两阶段提交）是两种常用的分布式事务处理模型，它们在解决分布式系统中的事务一致性问题上各有特点。以下是对两者的详细比较：一、基本概念TCC：TCC是一种分布式事务处理模型，通过Try、Confirm、Cancel三个阶段来处理事务。Try阶段进行业务检查和资源预留，Confirm阶段执行业务并使用预留资源，Can
    
                    
    • 
                    
  • 【微服务】（十六）—— 分布式事务Seata
                        喵喵喵更多
面试学习路线阿里巴巴微服务分布式java排序算法架构
                        
    目录事务ACID原则一、理论基础1）CAP理论CAP定理-Consistency?CAP定理-AvailabilityCAP定理-Partitiontolerance2）BASE理论?二、分布式事务Seata1）初识seata2）Seata架构?3）微服务集成seata1、首先，引入seata相关依赖：2、然后，配置application.yml，让微服务通过注册中心找到seata-tc-serv
    
                    
    • 
                    
  • JAVA面试题--分布式（最新最全）
                        傲浮刷题
java分布式开发语言
                        
    分布式在线刷题小程序：傲浮刷题小程序1.分布式id如何生成？2.雪花算法了解过吗？3.什么是CAP定理？4.分布式事务了解过吗？5.什么是二阶段提交（2PC）？什么是三阶段提交（3PC）？6.TCC了解过吗？7.Paxos算法了解过吗？8.Zookeeper的Zab协议了解过吗？9.知道什么是Gossip协议吗？10.了解过哪些负载均衡算法？11.负载均衡的实现方案有哪些？12.正向代理和反向代理
    
                    
    • 
                    
  • 分布式事务：基本概念
                        玉成226
【分布式事务】分布式
                        
    文章目录一、基础概念1、什么是事务2、本地事务3、分布式事务4、分布式事务产生的场景二、分布式事务基础理论1、CAP理论（1）理解CAP（2）CAP组合方式（3）总结2、BASE理论三、分布式事务解决方案之2PC（两阶段提交）1、什么是2PC2、解决方案（1）传统2PC（2）seata实现2PC3、seata实现2PC事务（1）业务说明（2）程序组成部分（3）创建数据库四、一、基础概念1、什么是事
    
                    
    • 
                    
  • 若依框架集成seata分布式事务的一些幺蛾子
                        半山惊竹
分布式
                        
    一、bug连环炮A服务调用B服务，B服务异常，A服务插入的数据没有回退，前面没有思路，就查了下，说是没有切换为seata的数据源，我就在启动类加了一个@EnableAutoDataSourceProxy注解，结果就开始报错了：2024-03-1910:49:30.653[http-nio-8080-exec-2]INFOc.a.n.client.config.impl.CacheData-Line
    
                    
    • 
                    
  • MySQL 中的“两阶段提交”机制
                        好奇的菜鸟
数据库mysql数据库
                        
    在MySQL数据库中，为了确保redolog（重做日志）和binlog（二进制日志）之间的数据安全性和一致性，引入了“两阶段提交”这一重要概念。MySQL将redolog的写入过程细分为“prepare”和“commit”两个步骤，并在其中同步写入binlog，以此来实现事务的原子性和持久性。什么是两阶段提交？两阶段提交是一种分布式事务处理策略，在MySQL中主要用来保证redolog和binlo
    
                    
    • 
                    
  • Java面试题总结18之springcloud四种分布式事务解决方案
                        陈平安＂
Java面试分布式springcloudjava
                        
    XA规范：分布式事务规范，规定了分布式事务模型四个角色：事务管理器（协调者TM），资源管理器（参与者RM），应用程序AP，通信资源管理器CRM全局事务：一个横跨多个数据库的事务，要么全部提交，要么全部回滚JTA事务时Java对XA规范的实现，对应JDBC的单库事务两阶段协议第一阶段（prepare）：每个参与者执行本地但不提交，进入ready状态，并通知协调者已经准备就绪。第二阶段（commit）
    
                    
    • 
                    
  • 【Docker】Jaeger 容器化部署
                        轻云UC
运维部署docker容器运维分布式
                        
    什么是jaeger?Jaeger是受到Dapper和OpenZipkin启发的由UberTechnologies作为开源发布的分布式跟踪系统，兼容OpenTracing以及Zipkin追踪格式，目前已成为CNCF基金会的开源项目。其前端采用React语言实现，后端采用GO语言实现，适用于进行链路追踪，分布式跟踪消息传递，分布式事务监控、问题分析、服务依赖性分析、性能优化等场景。快速运行docker
    
                    
    • 
                    
  • 三天学会阿里分布式事务框架Seata-seata事务分组介绍
                        java1234_小锋
java分布式分布式事务Seata事务框架seata
                        
    锋哥原创的分布式事务框架Seata视频教程：实战阿里分布式事务框架Seata视频教程（无废话，通俗易懂版）_哔哩哔哩_bilibili实战阿里分布式事务框架Seata视频教程（无废话，通俗易懂版）共计10条视频，包括：1阿里分布式事务框架Seata简介、2分布式事务简介、3SpringCloudAlibaba分布式基础案例搭建等，UP主更多精彩视频，请关注UP账号。https://www.bili
    
                    
    • 
                    
  • 分布式事务
                        你不懂、、、
分布式
                        
    分布式事务是指在分布式系统中，涉及多个参与者（数据库、消息队列等）的跨多个节点的事务操作。分布式系统由于涉及多个独立的节点，各个节点之间的事务操作可能需要保持一致性和隔离性，以确保数据的正确性和可靠性。传统的关系型数据库事务（如ACID）难以适应分布式环境的要求，因为分布式系统中的节点可能会面临网络延迟、故障、并发等问题。因此，为了确保分布式系统中的事务具备一致性，需要采用特定的分布式事务管理机制
    
                    
    • 
                    
  • Alibaba分布式事务组件Seata实战
                        枫吹过的柚
分布式专题微服务专题Seata分布式
                        
    Alibaba分布式事务组件Seata实战事务本地事务对于操作单一数据库的场景下的事务，ACIO特性是数据库直接支持的分布式事务在分布式情况下，需要的操作资源分布在多个资源服务上，而应用需要保证对于多个资源服务器的数据操作要么全部成功要么全部失败，本质上是为了保证不同服务的数据一致性应用场景跨库事务分库分表跨服务调用如何实现分布式事务两阶段提交(2PC)将提交过程分为准备阶段和提交，全局事务的AC
    
                    
    • 
                    
  • Java架构师之路四、分布式系统：分布式架构、分布式数据存储、分布式事务、分布式锁、分布式缓存、分布式消息中间件、分布式存储等。
                        述清-架构师之路
Java架构师之路java分布式架构
                        
    目录分布式架构：分布式数据存储：分布式事务：分布式锁：分布式缓存：分布式消息中间件：分布式存储：Java架构师之路三、网络通信：TCP/IP协议、HTTP协议、RESTfulAPI、WebSocket、RPC等。-CSDN博客Java架构师之路五、微服务：微服务架构、服务注册与发现、服务治理、服务监控、容器化等。-CSDN博客分布式架构：分布式架构是一种计算机系统设计方法，它将一个复杂的系统划分为
    
                    
    • 
                    
  • JavaWeb之分布式事务规范
                        
程序员
                        
    J2EE包括了两套规范用来支持分布式事务：一种是JavaTranscationAPI(JTA)，一种是JavaTranscationService(JTS)JTA是一种高层的、与实现无关的、与协议无关的标准API。JTS规定了支持JTA的事务管理器的实现规范。两阶段提交协议多个分布式数据库，有一个全局的事务管理器来协调各个数据库的事务提交，为了实现分布式事务，需要两个阶段第一阶段：全局的事务管理器
    
                    
    • 
                                
  • C/C++Win32编程基础详解视频下载
                                    择善Zach
编程C++Win32
                                    
    课题视频：C/C++Win32编程基础详解 
视频知识：win32窗口的创建 
                  windows事件机制 
主讲：择善Uncle老师 
学习交流群：386620625 
验证码：625 
 
--
    
                                
    • 
                                
  • Guava Cache使用笔记
                                    bylijinnan
javaguavacache
                                    
    1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常 
 
我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。 
实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 
 
 
2.Guava
    
                                
    • 
                                
  • 解决ora-01652无法通过128（在temp表空间中）
                                    0624chenhong
oracle
                                    
    解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程 
 
一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。 
分析过程： 
   既然是temp表空间有问题，那当
    
                                
    • 
                                
  • Struct在jsp标签
                                    不懂事的小屁孩
struct
                                    
    非UI标签介绍： 
控制类标签： 
1：程序流程控制标签   if   elseif    else 
<s:if test="isUsed"> 
 <span class="label label-success">True</span> 
</
    
                                
    • 
                                
  • 按对象属性排序
                                    换个号韩国红果果
JavaScript对象排序
                                    
    利用JavaScript进行对象排序，根据用户的年龄排序展示 
 
<script>
var bob={
name;bob,
age:30
}
var peter={
name;peter,
age:30
}
var amy={
name;amy,
age:24
}
var mike={
name;mike,
age:29
}
var john={

    
                                
    • 
                                
  • 大数据分析让个性化的客户体验不再遥远
                                    蓝儿唯美
数据分析
                                    
    顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。 
分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。 挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。 
然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
    
                                
    • 
                                
  • java笔记4
                                    a-john
java
                                    
    操作符 
1，使用java操作符 
      操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。 
      操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
    
                                
    • 
                                
  • 从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序
                                    aijuans
嵌入式学习
                                    
        笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。 
    笔者因此写上自己的学习心得，希望能给和我一样转变
    
                                
    • 
                                
  • 在springmvc中解决FastJson循环引用的问题
                                    asialee
循环引用fastjson
                                    
              我们先来看一个例子： 
          
package com.elong.bms;

import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;

import co
    
                                
    • 
                                
  • ArrayAdapter和SimpleAdapter技术总结
                                    百合不是茶
androidSimpleAdapterArrayAdapter高级组件基础
                                    
    ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 
  
ArrayAdapter;的数据可以是数组或者是队列 
  
     // 获得下拉框对象 
AutoCompleteTextView textview = (AutoCompleteTextView) this

    
                                
    • 
                                
  • 九封信
                                    bijian1013
人生励志
                                    
            有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。         2014，写给人
    
                                
    • 
                                
  • Linux下安装MySQL Web 管理工具phpMyAdmin
                                    sunjing
PHPInstallphpMyAdmin
                                    
    PHP http://php.net/ 
phpMyAdmin http://www.phpmyadmin.net 
Error compiling PHP on CentOS x64 
  
一、安装Apache 
请参阅http://billben.iteye.com/admin/blogs/1985244 
  
二、安装依赖包 
sudo yum install gd 
    
                                
    • 
                                
  • 分布式系统理论
                                    bit1129
分布式
                                    
    FLP 
One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes, 
    
                                
    • 
                                
  • ssh2整合(spring+struts2+hibernate)-附源码
                                    白糖_
eclipsespringHibernatemysql项目管理
                                    
    最近抽空又整理了一套ssh2框架，主要使用的技术如下： 
spring做容器，管理了三层(dao,service,actioin)的对象 
struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 
hibernate与数据库交互 
BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 
MySql数据库 
  
项目用eclipse
    
                                
    • 
                                
  • treetable bug记录
                                    braveCS
table
                                    
    // 插入子节点删除再插入时不能正常显示。修改：
//不知改后有没有错，先做个备忘
 Tree.prototype.removeNode = function(node) {
      // Recursively remove all descendants of +node+
      this.unloadBranch(node);

      // Remove
    
                                
    • 
                                
  • 编程之美-电话号码对应英语单词
                                    bylijinnan
java算法编程之美
                                    
    

import java.util.Arrays;

public class NumberToWord {

	/**
	 * 编程之美 电话号码对应英语单词
	 * 题目：
     *  手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ，
     *  要求对一段数字，输出其代表的所有可能的字母组合
    
                                
    • 
                                
  • jquery ajax读书笔记
                                    chengxuyuancsdn
jQuery ajax
                                    
    1、jsp页面 
 
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()
    
                                
    • 
                                
  • JWFD工作流拓扑结构解析伪码描述算法
                                    comsci
数据结构算法工作活动J#
                                    
      对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 
 
 
  /*  流程图拓扑结构解析伪码描述算法 
 
        public java.util.ArrayList DFS(String graphid, String stepid, int j) 
    
                                
    • 
                                
  • oracle I/O 从属进程
                                    daizj
oracle
                                    
    I/O 从属进程 
 
　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
    
                                
    • 
                                
  • 高级排序:希尔排序
                                    dieslrae
希尔排序
                                    
    
    public void shellSort(int[] array){
        int limit = 1;
        int temp;
        int index;
        
        while(limit <= array.length/3){
            limit = limit * 3 + 1;
    
    
                                
    • 
                                
  • 初二下学期难记忆单词
                                    dcj3sjt126com
englishword
                                    
    kitchen 厨房 
cupboard 厨柜 
salt 盐 
sugar 糖 
oil 油 
fork 叉；餐叉 
spoon 匙；调羹 
chopsticks 筷子 
cabbage 卷心菜；洋白菜 
soup 汤 
Italian 意大利的 
  
Indian 印度的 
workplace  工作场所 
even 甚至；更 
Italy 意大利 
laugh 笑 
m
    
                                
    • 
                                
  • Go语言使用MySQL数据库进行增删改查
                                    dcj3sjt126com
mysql
                                    
    目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: 
 
  http://code.google.c...o-mysql-dri
    
                                
    • 
                                
  • git命令
                                    shuizhaosi888
git
                                    
    ---------------设置全局用户名：
git config --global user.name "HanShuliang" //设置用户名 
git config --global user.email "[email protected]" //设置邮箱

---------------查看环境配置
git config --li
    
                                
    • 
                                
  • qemu-kvm 网络 nat模式 (四)
                                    haoningabc
kvmqemu
                                    
    qemu-ifup-NAT 
 

#!/bin/bash
BRIDGE=virbr0
NETWORK=192.168.122.0
GATEWAY=192.168.122.1
NETMASK=255.255.255.0
DHCPRANGE=192.168.122.2,192.168.122.254
TFTPROOT=
BOOTP=
function check_bridge()

    
                                
    • 
                                
  • 不要让未来的你，讨厌现在的自己
                                    jingjing0907
生活 奋斗 工作 梦想
                                    
     故事one 
　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
    
                                
    • 
                                
  • 枚举类型详解
                                    一路欢笑一路走
enum枚举详解enumsetenumMap
                                    
    枚举类型详解 
一.Enum详解 
     1.1枚举类型的介绍 
  
JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 
  
   Demo:一个最简单的枚举类 
  
public enum ColorType {
   RED
    
                                
    • 
                                
  • 第11章 动画效果（上）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Eclipse中jsp、js文件编辑时，卡死现象解决汇总
                                    ljf_home
eclipsejsp卡死js卡死
                                    
    使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 
  
1、取消验证 
windows–>perferences–>validation 
把 除了manual 下面的全部点掉，build下只留 classpath dependency Valida
    
                                
    • 
                                
  • MySQL编程中的6个重要的实用技巧
                                    tomcat_oracle
mysql
                                    
    每一行命令都是用分号(;)作为结束 
对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： 
mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')"); 

    
                                
    • 
                                
  • zoj 3820 Building Fire Stations(二分+bfs)
                                    阿尔萨斯
Build
                                    
     题目链接：zoj 3820 Building Fire Stations 
 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 
 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点最多
    
                                
    •