分布式事务（三）--Seata TCC模式事务

TCC 基本原理

TCC 与 Seata AT 事务一样都是两阶段事务，它与 AT 事务的主要区别为：

  • TCC 对业务代码侵入严重
    每个阶段的数据操作都要自己进行编码来实现，事务框架无法自动处理。
  • TCC 效率更高
    不必对数据加全局锁，允许多个事务同时操作数据。

分布式事务（三）--Seata TCC模式事务_第1张图片

第一阶段 Try

以账户服务为例，当下订单时要扣减用户账户金额：

分布式事务（三）--Seata TCC模式事务_第2张图片

假如用户购买 100 元商品，要扣减 100 元。

TCC 事务首先对这100元的扣减金额进行预留，或者说是先冻结这100元：

分布式事务（三）--Seata TCC模式事务_第3张图片

第二阶段 Confirm

如果第一阶段能够顺利完成，那么说明“扣减金额”业务（分支事务）最终肯定是可以成功的。当全局事务提交时， TC会控制当前分支事务进行提交，如果提交失败，TC 会反复尝试，直到提交成功为止。

当全局事务提交时，就可以使用冻结的金额来最终实现业务数据操作：
分布式事务（三）--Seata TCC模式事务_第4张图片

第二阶段 Cancel

如果全局事务回滚，就把冻结的金额进行解冻，恢复到以前的状态，TC 会控制当前分支事务回滚，如果回滚失败，TC 会反复尝试，直到回滚完成为止。

分布式事务（三）--Seata TCC模式事务_第5张图片

多个事务并发的情况

多个TCC全局事务允许并发，它们执行扣减金额时，只需要冻结各自的金额即可：

分布式事务（三）--Seata TCC模式事务_第6张图片

Seata TCC事务模式

Seata 支持 TCC 事务模式，与 AT 模式相同的，也需要以下组件来支持全局事务的控制：

  • TC 事务协调器
  • TM 事务管理器
  • RM 资源管理器

准备订单项目案例

新建 seata-tcc 工程

新建 Empty Project：
在这里插入图片描述
工程命名为 seata-tcc，存放到 seata-samples 文件夹下，与 seata-at 工程存放在一起：

分布式事务（三）--Seata TCC模式事务_第7张图片

导入订单项目，无事务版本

下载项目代码

  1. 访问 git 仓库 https://gitee.com/benwang6/seata-samples
  2. 访问项目标签
    a
  3. 下载无事务版
    a

解压到 seata-tcc 目录

压缩文件中的 7 个项目目录解压缩到 seata-tcc 目录：

分布式事务（三）--Seata TCC模式事务_第8张图片

导入项目

在 idea 中按两下 shift 键，搜索 add maven projects，打开 maven 工具：
a

然后选择 seata-tcc 工程目录下的 7 个项目的 pom.xml 导入：

分布式事务（三）--Seata TCC模式事务_第9张图片

order启动全局事务，添加“保存订单”分支事务

在订单项目中执行添加订单：

分布式事务（三）--Seata TCC模式事务_第10张图片

我们要添加以下 TCC 事务操作的代码：

  • Try - 第一阶，冻结数据阶段，向订单表直接插入订单，订单状态设置为0（冻结状态）。

分布式事务（三）--Seata TCC模式事务_第11张图片

  • Confirm - 第二阶段，提交事务，将订单状态修改成1（正常状态）。

分布式事务（三）--Seata TCC模式事务_第12张图片

  • Cancel - 第二阶段，回滚事务，删除订单。

分布式事务（三）--Seata TCC模式事务_第13张图片

order-parent 添加 seata 依赖

打开 order-parent 中注释掉的 seata 依赖：




    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.2.RELEASE
         
    
    cn.tedu
    order-parent
    1.0-SNAPSHOT
    pom
    order-parent

    
        3.3.2
        1.1.23
        1.3.0
        2.0.0.RELEASE
        Hoxton.SR6
    

    
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign
        

        
            com.baomidou
            mybatis-plus-boot-starter
            ${mybatis-plus.version}
        

        
            mysql
            mysql-connector-java
        
        
            com.alibaba
            druid-spring-boot-starter
            ${druid-spring-boot-starter.version}
        

        
        
          com.alibaba.cloud
          spring-cloud-alibaba-seata
          ${spring-cloud-alibaba-seata.version}
          
            
              seata-all
              io.seata
            
          
        
        
          io.seata
          seata-all
          ${seata.version}
        

        
            org.projectlombok
            lombok
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    

    
        
            
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring-cloud.version}
                pom
                import
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

配置

application.yml

设置全局事务组的组名：

spring:
  application:
    name: order

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost/seata_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
    username: root
    password: root

  # 事务组设置
  cloud:
    alibaba:
      seata:
        tx-service-group: order_tx_group

......

registry.conf 和 file.conf

与 AT 事务中的配置完全相同：

registry.conf：

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "eureka"

  nacos {
    serverAddr = "localhost"
    namespace = ""
    cluster = "default"
  }
  eureka {
    serviceUrl = "http://localhost:8761/eureka"
    # application = "default"
    # weight = "1"
  }
  redis {
    serverAddr = "localhost:6379"
    db = "0"
    password = ""
    cluster = "default"
    timeout = "0"
  }
  zk {
    cluster = "default"
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
    username = ""
    password = ""
  }
  consul {
    cluster = "default"
    serverAddr = "127.0.0.1:8500"
  }
  etcd3 {
    cluster = "default"
    serverAddr = "http://localhost:2379"
  }
  sofa {
    serverAddr = "127.0.0.1:9603"
    application = "default"
    region = "DEFAULT_ZONE"
    datacenter = "DefaultDataCenter"
    cluster = "default"
    group = "SEATA_GROUP"
    addressWaitTime = "3000"
  }
  file {
    name = "file.conf"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3、springCloudConfig
  type = "file"

  nacos {
    serverAddr = "localhost"
    namespace = ""
    group = "SEATA_GROUP"
  }
  consul {
    serverAddr = "127.0.0.1:8500"
  }
  apollo {
    app.id = "seata-server"
    apollo.meta = "http://192.168.1.204:8801"
    namespace = "application"
  }
  zk {
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
    username = ""
    password = ""
  }
  etcd3 {
    serverAddr = "http://localhost:2379"
  }
  file {
    name = "file.conf"
  }
}

file.conf：

transport {
  # tcp udt unix-domain-socket
  type = "TCP"
  #NIO NATIVE
  server = "NIO"
  #enable heartbeat
  heartbeat = true
  # the client batch send request enable
  enableClientBatchSendRequest = true
  #thread factory for netty
  threadFactory {
    bossThreadPrefix = "NettyBoss"
    workerThreadPrefix = "NettyServerNIOWorker"
    serverExecutorThread-prefix = "NettyServerBizHandler"
    shareBossWorker = false
    clientSelectorThreadPrefix = "NettyClientSelector"
    clientSelectorThreadSize = 1
    clientWorkerThreadPrefix = "NettyClientWorkerThread"
    # netty boss thread size,will not be used for UDT
    bossThreadSize = 1
    #auto default pin or 8
    workerThreadSize = "default"
  }
  shutdown {
    # when destroy server, wait seconds
    wait = 3
  }
  serialization = "seata"
  compressor = "none"
}
service {
  #transaction service group mapping
  # order_tx_group 与 yml 中的 “tx-service-group: order_tx_group” 配置一致
  # “seata-server” 与 TC 服务器的注册名一致
  # 从eureka获取seata-server的地址，再向seata-server注册自己，设置group
  vgroupMapping.order_tx_group = "seata-server"
  #only support when registry.type=file, please don't set multiple addresses
  order_tx_group.grouplist = "127.0.0.1:8091"
  #degrade, current not support
  enableDegrade = false
  #disable seata
  disableGlobalTransaction = false
}

client {
  rm {
    asyncCommitBufferLimit = 10000
    lock {
      retryInterval = 10
      retryTimes = 30
      retryPolicyBranchRollbackOnConflict = true
    }
    reportRetryCount = 5
    tableMetaCheckEnable = false
    reportSuccessEnable = false
  }
  tm {
    commitRetryCount = 5
    rollbackRetryCount = 5
  }
  undo {
    dataValidation = true
    logSerialization = "jackson"
    logTable = "undo_log"
  }
  log {
    exceptionRate = 100
  }
}

OrderMapper 添加更新订单状态、删除订单

根据前面的分析，订单数据操作有以下三项：

  • 插入订单
  • 修改订单状态
  • 删除订单

在 OrderMapper 中已经有插入订单的方法了，现在需要添加修改订单和删除订单的方法（删除方法从BaseMapper继承）：

package cn.tedu.order.mapper;

import cn.tedu.order.entity.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

public interface OrderMapper extends BaseMapper {
    void create(Order order);
    void updateStatus(@Param("orderId") Long orderId, @Param("status") Integer status);
}

那么对应的 OrderMapper.xml 中也要添加 sql：




    
        
        
        
        
        
        
    
    
        INSERT INTO `order` (`id`,`user_id`,`product_id`,`count`,`money`,`status`)
        VALUES(#{id}, #{userId}, #{productId}, #{count}, #{money}, ${status});
    
    
        UPDATE `order` SET `status`=#{status} WHERE `id`=#{orderId};
    
    
        DELETE FROM `order` WHERE `id`=#{orderId}

Seata 实现订单的 TCC 操作方法

  • 第一阶段 Try

  • 第二阶段

    • Confirm
    • Cancel

第二阶段为了处理幂等性问题这里首先添加一个工具类 ResultHolder。

这个工具也可以在第二阶段 Confirm 或 Cancel 阶段对第一阶段的成功与否进行判断，在第一阶段成功时需要保存一个标识。

ResultHolder可以为每一个全局事务保存一个标识：

package cn.tedu.order.tcc;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ResultHolder {
    private static Map, Map> map = new ConcurrentHashMap, Map>();

    public static void setResult(Class actionClass, String xid, String v) {
        Map results = map.get(actionClass);

        if (results == null) {
            synchronized (map) {
                if (results == null) {
                    results = new ConcurrentHashMap<>();
                    map.put(actionClass, results);
                }
            }
        }

        results.put(xid, v);
    }

    public static String getResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            return results.get(xid);
        }

        return null;
    }

    public static void removeResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            results.remove(xid);
        }
    }
}

Seata 实现 TCC 操作需要定义一个接口，我们在接口中添加以下方法：

  • Try - prepareCreateOrder()
  • Confirm - commit()
  • Cancel - rollback()
package cn.tedu.order.tcc;

import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;

import java.math.BigDecimal;

@LocalTCC
public interface OrderTccAction {
    // T (try - 预留资源，冻结订单)
    /*
    第一阶段的方法
    通过注解指定第二阶段的两个方法名
    
    BusinessActionContext 上下文对象，用来在两个阶段之间传递数据
    @BusinessActionContextParameter 注解的参数数据会被存入 BusinessActionContext
    @TwoPhaseBusinessAction 提交回滚的默认值可以不写
     */
    @TwoPhaseBusinessAction(name = "orderTccAction", commitMethod = "commit", rollbackMethod = "rollback")
    boolean prepareCreateOrder(BusinessActionContext businessActionContext,
                      @BusinessActionContextParameter(paramName = "orderId") Long orderId,
                      @BusinessActionContextParameter(paramName = "userId") Long userId,
                      @BusinessActionContextParameter(paramName = "productId") Long productId,
                      @BusinessActionContextParameter(paramName = "count") Integer count,
                      @BusinessActionContextParameter(paramName = "money") BigDecimal money);

    //C (confirm - 确认，提交)
    boolean commit(BusinessActionContext businessActionContext);

    //C (cancel - 取消，回滚)
    boolean rollback(BusinessActionContext businessActionContext);

}

实现类：

package cn.tedu.order.tcc;

import cn.tedu.order.entity.Order;
import cn.tedu.order.mapper.OrderMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
@Component
public class OrderTccActionImpl implements OrderTccAction {
    @Autowired
    private OrderMapper orderMapper;

    @Override
    public boolean prepareCreateOrder(BusinessActionContext ctx, Long orderId, Long userId, Long productId, Integer count, BigDecimal money) {
        orderMapper.create(new Order(orderId, userId, productId, count, money, 0));

        //保存一阶段的成功标记
        ResultHolder.setResult(OrderTccAction.class, ctx.getXid(), "p");
        return true;
    }

    @Override
    public boolean commit(BusinessActionContext ctx) {
        //检查标记是否存在，如果标记不存在不重复提交
        String p = ResultHolder.getResult(OrderTccAction.class, ctx.getXid());
        if (p == null){
            return true;
        }

        /**
         * 上下文对象从第一阶段向第二阶段传递时，先转成了json数据，然后还原成上下文对象
         * 其中的整数比较小的会转成Integer类型，所以如果需要Long类型，需要先转换成字符串在用Long.valueOf()解析。
         */
        Long orderId = Long.valueOf(ctx.getActionContext("orderId").toString());
        orderMapper.updateStatus(orderId, 1);

        //提交完成后，删除标记
        ResultHolder.removeResult(OrderTccAction.class, ctx.getXid());
        return true;
    }

    @Override
    public boolean rollback(BusinessActionContext ctx) {
        //第一阶段没有完成的情况下，不必执行回滚
        //因为第一阶段有本地事务，事务失败时已经进行了回滚。
        //如果这里第一阶段成功，而其他全局事务参与者失败，这里会执行回滚
        //幂等性控制：如果重复执行回滚则直接返回
        
        //检查标记是否存在，如果标记不存在不重复提交
        String p = ResultHolder.getResult(OrderTccAction.class, ctx.getXid());
        if (p == null){
            return true;
        }

        Long orderId = Long.valueOf(ctx.getActionContext("orderId").toString());
        orderMapper.deleteById(orderId);

        //提交完成后，删除标记
        ResultHolder.removeResult(OrderTccAction.class, ctx.getXid());
        return true;
    }
}

在业务代码中调用 Try 阶段方法

业务代码中不再直接保存订单数据，而是调用 TCC 第一阶段方法prepareCreateOrder()，并添加全局事务注解 @GlobalTransactional：

package cn.tedu.order.service;

import cn.tedu.order.entity.Order;
import cn.tedu.order.feign.AccountClient;
import cn.tedu.order.feign.EasyIdGeneratorClient;
import cn.tedu.order.feign.StorageClient;
import cn.tedu.order.mapper.OrderMapper;
import cn.tedu.order.tcc.OrderTccAction;
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Random;

@Service
public class OrderServiceImpl implements OrderService {
    // @Autowired
    // private OrderMapper orderMapper;
    @Autowired
    EasyIdGeneratorClient easyIdGeneratorClient;
    @Autowired
    private AccountClient accountClient;
    @Autowired
    private StorageClient storageClient;

    @Autowired
    private OrderTccAction orderTccAction;

    @GlobalTransactional
    @Override
    public void create(Order order) {
        // 从全局唯一id发号器获得id
        Long orderId = easyIdGeneratorClient.nextId("order_business");
        order.setId(orderId);

        // orderMapper.create(order);

        // 这里修改成调用 TCC 第一节端方法
        //orderTccAction是一个动态代理对象，其中添加了前置拦截器，所以底层会创建，所以传null值即可
        orderTccAction.prepareCreateOrder(
                null,
                order.getId(),
                order.getUserId(),
                order.getProductId(),
                order.getCount(),
                order.getMoney());

        // 修改库存
        //storageClient.decrease(order.getProductId(), order.getCount());

        // 修改账户余额
        //accountClient.decrease(order.getUserId(), order.getMoney());

    }
}

启动 order 进行测试

按顺序启动服务：

  1. Eureka
  2. Seata Server
  3. Easy Id Generator
  4. Order

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

观察控制台日志：
分布式事务（三）--Seata TCC模式事务_第14张图片

查看数据库表中的订单数据：

分布式事务（三）--Seata TCC模式事务_第15张图片

storage添加“减少库存”分支事务

在库存项目中执行减少库存：

分布式事务（三）--Seata TCC模式事务_第16张图片

我们要添加以下 TCC 事务操作的代码：

  • Try - 第一阶，冻结数据阶段，将要减少的库存量先冻结：

分布式事务（三）--Seata TCC模式事务_第17张图片

  • Confirm - 第二阶段，提交事务，使用冻结的库存完成业务数据处理：

分布式事务（三）--Seata TCC模式事务_第18张图片

  • Cancel - 第二阶段，回滚事务，冻结的库存解冻，恢复以前的库存量：

分布式事务（三）--Seata TCC模式事务_第19张图片

配置

有三个文件需要配置：

  • application.yml
  • registry.conf
  • file.conf

这三个文件的设置与上面 order 项目的配置完全相同，请参考上面订单配置一章进行配置。

StorageMapper 添加冻结库存相关方法

根据前面的分析，库存数据操作有以下三项：

  • 冻结库存
  • 冻结库存量修改为已售出量
  • 解冻库存

在 StorageMapper 中添加三个方法：

package cn.tedu.storage.mapper;

import cn.tedu.storage.entity.Storage;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

public interface StorageMapper extends BaseMapper {
    void decrease(Long productId, Integer count);
    // 冻结库存
    void updateFrozen(@Param("productId") Long productId, @Param("residue") Integer residue, @Param("frozen") Integer frozen);
    // 提交时，把冻结量修改到已售出
    void updateFrozenToUsed(@Param("productId") Long productId, @Param("count") Integer count);
    // 回滚时，把冻结量修改到可用库存
    void updateFrozenToResidue(@Param("productId") Long productId, @Param("count") Integer count);
}

那么对应的 StorageMapper.xml 中也要添加 sql：




    
        
        
        
        
        
    
    
    UPDATE storage SET used = used + #{count},residue = residue - #{count} WHERE product_id = #{productId}
  
    

    
        UPDATE storage SET `residue`=#{residue},`frozen`=#{frozen} WHERE `product_id`=#{productId}
    

    
        UPDATE storage SET `frozen`=`frozen`-#{count}, `used`=`used`+#{count} WHERE `product_id`=#{productId}
    

    
        UPDATE storage SET `frozen`=`frozen`-#{count}, `residue`=`residue`+#{count} WHERE `product_id`=#{productId}

Seata 实现库存的 TCC 操作方法

工具类 ResultHolder：

package cn.tedu.storage.tcc;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ResultHolder {
    private static Map, Map> map = new ConcurrentHashMap, Map>();

    public static void setResult(Class actionClass, String xid, String v) {
        Map results = map.get(actionClass);

        if (results == null) {
            synchronized (map) {
                if (results == null) {
                    results = new ConcurrentHashMap<>();
                    map.put(actionClass, results);
                }
            }
        }

        results.put(xid, v);
    }

    public static String getResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            return results.get(xid);
        }

        return null;
    }

    public static void removeResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            results.remove(xid);
        }
    }
}

添加 TCC 接口，在接口中添加以下方法：

  • Try - prepareDecreaseStorage()
  • Confirm - commit()
  • Cancel - rollback()
package cn.tedu.storage.tcc;

import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;

@LocalTCC
public interface StorageTccAction {

    @TwoPhaseBusinessAction(name = "storageTccAction", commitMethod = "commit", rollbackMethod = "rollback")
    boolean prepareDecreaseStorage(BusinessActionContext businessActionContext,
                                   @BusinessActionContextParameter(paramName = "productId") Long productId,
                                   @BusinessActionContextParameter(paramName = "count") Integer count);

    boolean commit(BusinessActionContext businessActionContext);

    boolean rollback(BusinessActionContext businessActionContext);

}

实现类：

package cn.tedu.storage.tcc;

import cn.tedu.storage.entity.Storage;
import cn.tedu.storage.mapper.StorageMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
@Slf4j
public class StorageTccActionImpl implements StorageTccAction {

    @Autowired
    private StorageMapper storageMapper;

    @Transactional
    @Override
    public boolean prepareDecreaseStorage(BusinessActionContext businessActionContext, Long productId, Integer count) {
        log.info("减少商品库存，第一阶段，锁定减少的库存量，productId="+productId+"， count="+count);

        Storage storage = storageMapper.selectById(productId);
        if (storage.getResidue()-count<0) {
            throw new RuntimeException("库存不足");
        }

        /*
        库存减掉count， 冻结库存增加count
         */
        storageMapper.updateFrozen(productId, storage.getResidue()-count, storage.getFrozen()+count);

        //保存标识
        ResultHolder.setResult(getClass(), businessActionContext.getXid(), "p");
        return true;
    }

    @Transactional
    @Override
    public boolean commit(BusinessActionContext businessActionContext) {
        long productId = Long.parseLong(businessActionContext.getActionContext("productId").toString());
        int count = Integer.parseInt(businessActionContext.getActionContext("count").toString());
        log.info("减少商品库存，第二阶段提交，productId="+productId+"， count="+count);

        //防止重复提交
        if (ResultHolder.getResult(getClass(), businessActionContext.getXid()) == null) {
            return true;
        }

        storageMapper.updateFrozenToUsed(productId, count);

        //删除标识
        ResultHolder.removeResult(getClass(), businessActionContext.getXid());
        return true;
    }

    @Transactional
    @Override
    public boolean rollback(BusinessActionContext businessActionContext) {

        long productId = Long.parseLong(businessActionContext.getActionContext("productId").toString());
        int count = Integer.parseInt(businessActionContext.getActionContext("count").toString());
        log.info("减少商品库存，第二阶段，回滚，productId="+productId+"， count="+count);

        //防止重复回滚
        if (ResultHolder.getResult(getClass(), businessActionContext.getXid()) == null) {
            return true;
        }

        storageMapper.updateFrozenToResidue(productId, count);

        //删除标识
        ResultHolder.removeResult(getClass(), businessActionContext.getXid());
        return true;
    }
}

在业务代码中调用 Try 阶段方法

业务代码中调用 TCC 第一阶段方法prepareDecreaseStorage()，并添加全局事务注解 @GlobalTransactional：

package cn.tedu.storage.service;

import cn.tedu.storage.tcc.StorageTccAction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StorageServiceImpl implements StorageService {
    // @Autowired
    // private StorageMapper storageMapper;

    @Autowired
    private StorageTccAction storageTccAction;

    @Override
    public void decrease(Long productId, Integer count) throws Exception {
        // storageMapper.decrease(productId,count);
        storageTccAction.prepareDecreaseStorage(null, productId, count);
    }

}

启动 storage 进行测试

按顺序启动服务：

  1. Eureka
  2. Seata Server
  3. Easy Id Generator
  4. Storage
  5. Order

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

观察 storage 的控制台日志：
分布式事务（三）--Seata TCC模式事务_第20张图片

查看数据库表中的库存数据：

分布式事务（三）--Seata TCC模式事务_第21张图片

account添加“扣减金额”分支事务

扣减金额 TCC 事务分析请见《分布式事务（六）Seata TCC模式-TCC模式介绍》

配置

有三个文件需要配置：

  • application.yml
  • registry.conf
  • file.conf

这三个文件的设置与上面 order 项目的配置完全相同，请参考上面订单配置一章进行配置。

AccountMapper 添加冻结库存相关方法

根据前面的分析，库存数据操作有以下三项：

  • 冻结库存
  • 冻结库存量修改为已售出量
  • 解冻库存

在 AccountMapper 中添加三个方法：

package cn.tedu.account.mapper;

import cn.tedu.account.entity.Account;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

import java.math.BigDecimal;

public interface AccountMapper extends BaseMapper {
    void decrease(Long userId, BigDecimal money);

    void updateFrozen(@Param("userId") Long userId, @Param("residue") BigDecimal residue, @Param("frozen") BigDecimal frozen);

    void updateFrozenToUsed(@Param("userId") Long userId, @Param("money") BigDecimal money);

    void updateFrozenToResidue(@Param("userId") Long userId, @Param("money") BigDecimal money);
}

那么对应的 AccountMapper.xml 中添加 sql：




    
        
        
        
        
        
        
    
    
      UPDATE account SET residue = residue - #{money},used = used + #{money} where user_id = #{userId};
    
    

    
        UPDATE account SET `residue`=#{residue},`frozen`=#{frozen} WHERE `user_id`=#{userId}
    

    
        UPDATE account SET `frozen`=`frozen`-#{money}, `used`=`used`+#{money} WHERE `user_id`=#{userId}
    

    
        UPDATE account SET `frozen`=`frozen`-#{money}, `residue`=`residue`+#{money} WHERE `user_id`=#{userId}

Seata 实现库存的 TCC 操作方法

工具类 ResultHolder：

package cn.tedu.account.tcc;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ResultHolder {
    private static Map, Map> map = new ConcurrentHashMap, Map>();

    public static void setResult(Class actionClass, String xid, String v) {
        Map results = map.get(actionClass);

        if (results == null) {
            synchronized (map) {
                if (results == null) {
                    results = new ConcurrentHashMap<>();
                    map.put(actionClass, results);
                }
            }
        }

        results.put(xid, v);
    }

    public static String getResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            return results.get(xid);
        }

        return null;
    }

    public static void removeResult(Class actionClass, String xid) {
        Map results = map.get(actionClass);
        if (results != null) {
            results.remove(xid);
        }
    }
}

添加 TCC 接口，在接口中添加以下方法：

  • Try - prepareDecreaseAccount()
  • Confirm - commit()
  • Cancel - rollback()
package cn.tedu.account.tcc;

import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;

import java.math.BigDecimal;

@LocalTCC
public interface AccountTccAction {

    @TwoPhaseBusinessAction(name = "accountTccAction", commitMethod = "commit", rollbackMethod = "rollback")
    boolean prepareDecreaseAccount(BusinessActionContext businessActionContext,
                                   @BusinessActionContextParameter(paramName = "userId") Long userId,
                                   @BusinessActionContextParameter(paramName = "money") BigDecimal money);

    boolean commit(BusinessActionContext businessActionContext);

    boolean rollback(BusinessActionContext businessActionContext);

}

实现类：

package cn.tedu.account.tcc;

import cn.tedu.account.entity.Account;
import cn.tedu.account.mapper.AccountMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;

@Component
@Slf4j
public class AccountTccActionImpl implements AccountTccAction {
    @Autowired
    private AccountMapper accountMapper;

    @Transactional
    @Override
    public boolean prepareDecreaseAccount(BusinessActionContext businessActionContext, Long userId, BigDecimal money) {
        log.info("减少账户金额，第一阶段锁定金额，userId="+userId+"， money="+money);

        Account account = accountMapper.selectById(userId);
        if (account.getResidue().compareTo(money) < 0) {
            throw new RuntimeException("账户金额不足");
        }

        /*
        余额-money
        冻结+money
         */
        accountMapper.updateFrozen(userId, account.getResidue().subtract(money), account.getFrozen().add(money));

        //保存标识
        ResultHolder.setResult(getClass(), businessActionContext.getXid(), "p");
        return true;
    }

    @Transactional
    @Override
    public boolean commit(BusinessActionContext businessActionContext) {

        long userId = Long.parseLong(businessActionContext.getActionContext("userId").toString());
        BigDecimal money =  new BigDecimal(businessActionContext.getActionContext("money").toString());
        log.info("减少账户金额，第二阶段，提交，userId="+userId+"， money="+money);

        //防止重复提交
        if (ResultHolder.getResult(getClass(), businessActionContext.getXid()) == null) {
            return true;
        }

        accountMapper.updateFrozenToUsed(userId, money);

        //删除标识
        ResultHolder.removeResult(getClass(), businessActionContext.getXid());
        return true;
    }

    @Transactional
    @Override
    public boolean rollback(BusinessActionContext businessActionContext) {
        long userId = Long.parseLong(businessActionContext.getActionContext("userId").toString());
        BigDecimal money =  new BigDecimal(businessActionContext.getActionContext("money").toString());

        //防止重复回滚
        if (ResultHolder.getResult(getClass(), businessActionContext.getXid()) == null) {
            return true;
        }

        log.info("减少账户金额，第二阶段，回滚，userId="+userId+"， money="+money);

        accountMapper.updateFrozenToResidue(userId, money);

        //删除标识
        ResultHolder.removeResult(getClass(), businessActionContext.getXid());
        return true;
    }
}

在业务代码中调用 Try 阶段方法

业务代码中调用 TCC 第一阶段方法prepareDecreaseAccount()，并添加全局事务注解 @GlobalTransactional：

package cn.tedu.account.service;

import cn.tedu.account.mapper.AccountMapper;
import cn.tedu.account.tcc.AccountTccAction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
@Service
public class AccountServiceImpl implements AccountService {
    // @Autowired
    // private AccountMapper accountMapper;

    @Autowired
    private AccountTccAction accountTccAction;

    @Override
    public void decrease(Long userId, BigDecimal money) {
        // accountMapper.decrease(userId,money);
        accountTccAction.prepareDecreaseAccount(null, userId, money);
    }
}

启动 account 进行测试

按顺序启动服务：

  1. Eureka
  2. Seata Server
  3. Easy Id Generator
  4. Storage
  5. Account
  6. Order

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

观察 account 的控制台日志：
分布式事务（三）--Seata TCC模式事务_第22张图片

查看数据库表中的账户数据：

分布式事务（三）--Seata TCC模式事务_第23张图片

全局事务回滚测试

下面来测试全局事务回滚的情况。

订单和库存第一阶段成功，而账户第一阶段失败了，这时会触发全局事务的回滚，如下图所示：

分布式事务（三）--Seata TCC模式事务_第24张图片
首先在 account 的第一阶段代码中添加模拟异常：

AccountTccActionImpl 的 prepareDecreaseAccount 方法

@Transactional
    @Override
    public boolean prepareDecreaseAccount(BusinessActionContext businessActionContext, Long userId, BigDecimal money) {
        log.info("减少账户金额，第一阶段锁定金额，userId="+userId+"， money="+money);

        Account account = accountMapper.selectById(userId);
        if (account.getResidue().compareTo(money) < 0) {
            throw new RuntimeException("账户金额不足");
        }

        /*
        余额-money
        冻结+money
         */
        accountMapper.updateFrozen(userId, account.getResidue().subtract(money), account.getFrozen().add(money));

        if (Math.random() < 0.5) {
            throw new RuntimeException("模拟异常");
        }

        //保存标识
        ResultHolder.setResult(getClass(), businessActionContext.getXid(), "p");
        return true;
    }

重启 account 后，访问订单：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

查看控制台，可以看到 storage 和 order 的回滚日志，order 的回滚日志如下：

分布式事务（三）--Seata TCC模式事务_第25张图片

你可能感兴趣的:(分布式事务seata)

  • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理 朱杰jjj 缓存分布式
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
  • 导购返利系统的分布式事务管理 wx_tangjinjinwx 分布式
    导购返利系统的分布式事务管理大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨导购返利系统中的分布式事务管理。随着系统的分布式架构越来越普遍，如何有效地管理分布式事务成为了一个关键问题。本文将详细介绍如何在Java应用中实现分布式事务管理，并提供相应的代码示例。1.分布式事务的挑战在分布式系统中，事务通常涉及多个服务或数据库，这给事务的一致性和可靠性带
  • SpringCloud-Alibaba之Seata入门以及踩坑 DN金猿 springbootjava数据库seata
    前言上一篇文章：➣SpringCloudAlibaba之Seata入门以及踩坑（一）老顾介绍了seata相关的准备工作，以及版本的选择；今天老顾就来介绍一下seata的使用。以及在使用过程中遇到的问题。案例背景今天老顾介绍的案例场景也就是网上常用的场景，用户下单场景。整个流程就是用户下单时：1）创建订单，订单状态为创建中2）扣减商品库存3）扣减用户金额4）更改订单状态，订单状态为已完结从以上业务流
  • 分布式事务之理论基础 xiaogaot
    分布式事务的概念理论事务具备以下四个基本特性（ACID）原子性（Atomicity）：一系列操作作被看作一个整体，要么全部成功，要么全部失败一致性（consistency）：如果把所有参与者的数据看成是一个数据集，那么操作前后，数据的总量是不增不减的。也可以理解成数据是满足完整约束的。举例：一个数据集中只有两个参与者A&B，A持有100元，B持有0元，总额100元；A对B转账50元，余额50，B收
  • seata基本使用，柚子快报邀请码778899 登录成功
    把seata的使用在这里做了一个总结，希望能够帮助到大家。本案例在实施过程中，威哥力求简单明了，希望大家在学习过程中能够掌握其中的每个细节。好了，废话不多说，如果我们要学习seata，首先需要具备如下技术储备：数据库事务的基本知识；maven工具的使用；熟悉SpringCloudAlibaba技术栈；掌握SpringDataJPA简单使用；一.Seata基本概念1.seata是什么Seata是阿里
  • 两阶段事务提交 码农小伙 事务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事务模式，为用户打造一站式的分布式
  • 第十二章节 xxjob, seata, zk, minio,activeMQ进行 helm化 Wade_Crab dockerkubernetes容器
    要将你提供的Docker命令转换为HelmChart，你需要将相关的配置转化为Kubernetes资源文件，并使用Helm的模板语法进行参数化配置。以下是一个基本的HelmChart示例，包括Deployment、Service和Values.yaml文件。helmcreatexxl-job-admin1.values.yaml这是HelmChart中用于定义默认值的文件。你可以在这里配置镜像、端
  • 分布式事务 懒人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）难以适应分布式环境的要求，因为分布式系统中的节点可能会面临网络延迟、故障、并发等问题。因此，为了确保分布式系统中的事务具备一致性，需要采用特定的分布式事务管理机制
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他