AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【分布式技术专题】「架构实践于案例分析」总结和盘点目前常用分布式事务特别及问题分析（Seata-终）

2023-01-16 165
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【分布式技术专题】「架构实践于案例分析」总结和盘点目前常用分布式事务特别及问题分析（Seata-终）

分布式事务中间件对⽐与选择

  • tx-lcn
  • EasyTransaction
  • ByteTCC
  • Seata




Seata实现分布式事务

我们主要以Seata的分布式事务框架进行介绍分析，相关的并且针对于其三种模式进行分别说明介绍。



搭建Seata Server


前往github.com/seata/seata… 下载Seata安装包，本书使⽤Seata 1.0.0。将⽬录切换⾄Seata根⽬录，根据操作系统，执⾏对应命令，即可启动Seata Server。



Linux/Unix/Mac

sh ./bin/seata-server.sh
复制代码


Windows

bin\seata-server.bat
复制代码


启动时，也可指定参数

$ sh ./bin/seata-server.sh -p 8091 -h 127.0.0.1 -m file
复制代码


⽀持的参数如下表所示

image.png

Seata AT模式


  • ⼀阶段：业务数据和回滚⽇志记录在同⼀个本地事务中提交，释放本地锁和连接资源。
  • ⼆阶段：提交异步化，⾮常快速地完成。回滚通过⼀阶段的回滚⽇志进⾏反向补偿。



官⽅⽂档

seata.io/zh-cn/docs/…



代码演示


Maven依赖
<dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
复制代码


配置
seata:
   tx-service-group: content-center-seata-service-group
   service:
    vgroup-mapping:
        content-center-seata-service-group: seata-cluster
        grouplist:
           seata-cluster: 127.0.0.1:8091
           disable-global-transaction: false
复制代码



配置说明


  • tx-service-group：事务分组，默认是 ${spring.application.name}-seata-service-group ，唯⼀即可。


  • vgroup-mapping：事务分组映射，表示 tx-service-group 对应到哪个Seata Server集群。
  • key是tx-service-group的值，value是集群名称，唯⼀即可


  • grouplist：集群中所包含的Seata Server的地址列表，key是vgroup-mapping中value的值，
  • value是Seata Server的地址列表


  • disable-global-transaction：是否开启全局事务开关，默认false。


在Seata1.0.0中，该配置⽆法正常读取，这是⼀个Bug，详⻅ github.com/seata/seata… ，好在，该配置的默认值就是false，所以不影响使⽤。




创建Seata事务记录表
-- auto-generated definition
create table undo_log (
id bigint auto_increment comment 'increment id' primary key,
branch_id bigint not null comment 'branch transaction id',
xid varchar(100) not null comment 'global transaction id',
context varchar(128) not null comment 'undo_log context,such as serialization',
rollback_info longblob not null comment 'rollback info',
log_status int not null comment '0:normal status,1:defense status',
log_created datetime not null comment 'create datetime',
log_modified datetime not null comment 'modify datetime',
constraint ux_undo_log
unique (xid, branch_id)
) comment 'AT transaction mode undo table' charset = utf8;
复制代码


Controller代码：
private final ShareSeataService shareSeataService;
@PutMapping("/audit/seata1/{id}")
public Share auditByIdSeata1(@PathVariable Integer id, @RequestBody ShareAuditDTO auditDTO) {
     return this.shareSeataService.auditById(id, auditDTO);
}
复制代码


Service代码：


  • 审核中心服务代码（含调用用户中心代码接口）
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class ShareSeataService {
    private final ShareMapper shareMapper;
    private final UserCenterFeignClient userCenterFeignClient;
   @GlobalTransactional(rollbackFor = Exception.class)
    public Share auditById(Integer id, ShareAuditDTO auditDTO) {
        if (AuditStatusEnum.PASS.equals(auditDTO.getAuditStatusEnum())) { 
            userCenterFeignClient.addBonus(id, 50);
           // 故意抛异常，如果⽤户中⼼侧也能回滚，说明实现了分布式事务
          // throw new IllegalArgumentException("发⽣异常...");
        }
        this.auditByIdInDB(id, auditDTO);
        return this.shareMapper.selectByPrimaryKey(id);
   }
复制代码
  • 审核中心服务代码（执行操作更新数据库机制）
public void auditByIdInDB(Integer id, ShareAuditDTO auditDTO) {
        Share share = Share.builder().id(id).auditStatus(auditDTO.getAuditStatusEnum().toString()).reason(auditDTO.getReason())
       .build();
        this.shareMapper.updateByPrimaryKeySelective(share);
    }
复制代码

@GlobalTransactional 注解⽤来创建分布式事务。




被调⽤⽅代码


Maven依赖
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
复制代码
配置
seata:
    tx-service-group: user-center-seata-service-group
      service:
      vgroup-mapping:
         user-center-seata-service-group: seata-cluster
         grouplist:
            seata-cluster: 127.0.0.1:8091
            disable-global-transaction: false
复制代码



可以看出来，差距主要体现在tx-service-group的值。

Controller代码：
@GetMapping("/add-bonus/{id}/{bonus}")
public User addBonus(@PathVariable Integer id, @PathVariable Integer bonus) {
    this.userService.addBonus(id, bonus);
    return this.userService.findById(id);
}
复制代码



Service代码：
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class UserService {
    private final UserMapper userMapper;
    private final BonusEventLogMapper bonusEventLogMapper;
    public User findById(Integer id) {
    // select * from user where id = #{id}
        return this.userMapper.selectByPrimaryKey(id);
    }
public void addBonus(Integer userId, Integer bonus) {
    // 1. 为⽤户加积分
    User user = this.userMapper.selectByPrimaryKey(userId);
    user.setBonus(user.getBonus() + bonus);
    this.userMapper.updateByPrimaryKeySelective(user);
    // 2. 记录⽇志到bonus_event_log表⾥⾯
    this.bonusEventLogMapper.insert(BonusEventLog.builder().userId(userId).value(bonus).event("CONTRIBUTE").createTime(new Date()).description("投稿加积分..").build());
    log.info("积分添加完毕...");
 }
}
复制代码



Seata TCC模式


  • ⼀阶段 prepare ⾏为
  • ⼆阶段 commit 或 rollback ⾏为



需要实现的3个⽅法：


  • ⼀阶段：
  • ⽤于业务预处理的⽅法，即 Try 阶段、的⽅法，⽐如冻结⽤户的部分余额等等；
  • ⼆阶段：
  • ⽤于提交业务的⽅法，即 Commit ⽅法，⽐如扣除⽤户之前冻结的部分余额；
  • ⽤于回滚业务的⽅法，即 Rollback ⽅法，⽐如返还之前冻结的⽤户余额；



官⽅⽂档

seata.io/zh-cn/docs/…



代码演示


行为操作接口
@LocalTCC
public interface TccActionOne {
   @TwoPhaseBusinessAction(name = "TccActionOne", commitMethod = "commit", rollbackMethod = "rollback")
    boolean prepare(BusinessActionContext actionContext, int a);
    boolean commit(BusinessActionContext actionContext);
    boolean rollback(BusinessActionContext actionContext);
}
复制代码
接口实现类


  • 实现类1
@Component
public class TccActionOneImpl implements TccActionOne {
    @Override
    public boolean prepare(BusinessActionContext actionContext, int a) {
        // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
        String xid = actionContext.getXid();
        System.out.println("TccActionOne prepare, xid:" + xid);
        return true;
    }
    @Override
    public boolean commit(BusinessActionContext actionContext) {
        // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
        String xid = actionContext.getXid();
        System.out.println("TccActionOne commit, xid:" + xid);
        ResultHolder.setActionOneResult(xid, "T");
        return true;
    }
    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
        String xid = actionContext.getXid();
        System.out.println("TccActionOne rollback, xid:" + xid);
        ResultHolder.setActionOneResult(xid, "R");
        return true;
    }
}
复制代码
@LocalTCC
public interface TccActionTwo {
    @TwoPhaseBusinessAction(name = "TccActionTwo", commitMethod = "commit", rollbackMethod = "rollback")
    boolean prepare(BusinessActionContext actionContext, int a);
    boolean commit(BusinessActionContext actionContext);
    boolean rollback(BusinessActionContext actionContext);
}
复制代码
  • 实现类2
@Component
public class TccActionTwoImpl implements TccActionTwo {
       @Override
       public boolean prepare(BusinessActionContext actionContext, String b) {
              // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
              String xid = actionContext.getXid();
              System.out.println("TccActionTwo prepare, xid:" + xid);
              return true;
       }
       @Override
       public boolean commit(BusinessActionContext actionContext) {
              // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
              String xid = actionContext.getXid();
              System.out.println("TccActionTwo commit, xid:" + xid);
              ResultHolder.setActionTwoResult(xid, "T");
              return true;
       }
       @Override
       public boolean rollback(BusinessActionContext actionContext) {
              // 这⾥是本地玩的，也可以调⽤其他微服务的接⼝
              String xid = actionContext.getXid();
              System.out.println("TccActionTwo rollback, xid:" + xid);
              ResultHolder.setActionTwoResult(xid, "R");
              return true;
       }
}
复制代码



  • 聚合实现服务业务实现类执行
@Service
public class ShareSeataService{
    @Autowired
    TccActionOne tccActionOne;
    @Autowired
    TccActionTwo tccActionTwo;
    @GlobalTransactional
    public void tccTransactionCommit(Map<String, String> paramMap) {
        //第一个TCC 事务参与者
        boolean result = tccActionOne.prepare(null, "one");
        if (!result) {
      paramMap.put("xid",RootContext.getXID());
            throw new RuntimeException("TccActionOne failed.");
        }
        List list = new ArrayList();
        list.add("c1");
        list.add("c2");
        result = tccActionTwo.prepare(null, "two");
        if (!result) {
            paramMap.put("xid",RootContext.getXID());
            throw new RuntimeException("TccActionTwo failed.");
        }
       paramMap.put("xid",RootContext.getXID());
        return ;
    }
}
// 回滚的代码相似，就不写了
复制代码



  • 执行调用点
@Slf4j
@RestController
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class ShareAdminController {
    private final ShareSeataService shareSeataService;
    @GetMapping("tcc-commit")
    public String tccTransactionCommit() {
        Map<String, String> map = new HashMap<>();
        this.shareSeataService.tccTransactionCommit(map);
        String xid = map.get("xid");
        // 结果T
        return ResultHolder.getActionOneResult(xid);
    }
    @GetMapping("/tcc-rollback")
    public String tccTransactionRollback() {
       Map<String, String> map = new HashMap<>();
       try {
          this.shareSeataService.tccTransactionRollback(map);
       } catch (Throwable t) {
          log.warn("事务回滚..", t);
       }
       String xid = map.get("xid");
       // 结果R
       return ResultHolder.getActionOneResult(xid);
   }
}
复制代码



定义状态机⽂件：
{
    "Name": "reduceInventoryAndBalance",
    "Comment": "reduce inventory then reduce balance in a transaction",
    "StartState": "ReduceInventory",
    "Version": "0.0.1",
    "States": {
        "ReduceInventory": {
            "Type": "ServiceTask",
            "ServiceName": "inventoryAction",
            "ServiceMethod": "reduce",
            "CompensateState": "CompensateReduceInventory",
            "Next": "ChoiceState",
            "Input": [
                "$.[businessKey]",
                "$.[count]"
            ],
            "Output": {
                "reduceInventoryResult": "$.#root"
            },
            "Status": {
                "#root == true": "SU",
                "#root == false": "FA",
                "$Exception{java.lang.Throwable}": "UN"
            }
        },
        "ChoiceState": {
            "Type": "Choice",
            "Choices": [
                {
                    "Expression": "[reduceInventoryResult] == true",
                    "Next": "ReduceBalance"
                }
            ],
            "Default": "Fail"
        },
        "ReduceBalance": {
            "Type": "ServiceTask",
            "ServiceName": "balanceAction",
            "ServiceMethod": "reduce",
            "CompensateState": "CompensateReduceBalance",
            "Input": [
                "$.[businessKey]",
                "$.[amount]",
                {
                    "throwException": "$.[mockReduceBalanceFail]"分布式事务27
                }
            ],
            "Output": {
                "compensateReduceBalanceResult": "$.#root"
            },
            "Status": {
                "#root == true": "SU",
                "#root == false": "FA",
                "$Exception{java.lang.Throwable}": "UN"
            },
            "Catch": [
                {
                    "Exceptions": [
                        "java.lang.Throwable"
                    ],
                    "Next": "CompensationTrigger"
                }
            ],
            "Next": "Succeed"
        },
        "CompensateReduceInventory": {
            "Type": "ServiceTask",
            "ServiceName": "inventoryAction",
            "ServiceMethod": "compensateReduce",
            "Input": [
                "$.[businessKey]"
            ]
        },
        "CompensateReduceBalance": {
            "Type": "ServiceTask",
            "ServiceName": "balanceAction",
            "ServiceMethod": "compensateReduce",
            "Input": [
                "$.[businessKey]"
            ]
        },
        "CompensationTrigger": {
            "Type": "CompensationTrigger",
            "Next": "Fail"
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail",
            "ErrorCode": "PURCHASE_FAILED",
            "Message": "purchase failed"
        }
    }
}
复制代码

测试代码：

public class LocalSagaTransactionStarter {
        public static void main(String[] args) {
            AbstractApplicationContext applicationContext = new ClassPathXmlApplication
            Context(new String[] {"spring/seata-saga.xml"});
            StateMachineEngine stateMachineEngine = (StateMachineEngine) applicationCon
            text.getBean("stateMachineEngine");
            transactionCommittedDemo(stateMachineEngine);
            transactionCompensatedDemo(stateMachineEngine);
            new ApplicationKeeper(applicationContext).keep();
        }
        private static void transactionCommittedDemo(StateMachineEngine stateMachineEng
ine) {
            Map<String, Object> startParams = new HashMap<>(3);
            String businessKey = String.valueOf(System.currentTimeMillis());
            startParams.put("businessKey", businessKey);
            startParams.put("count", 10);
            startParams.put("amount", new BigDecimal("100"));
//sync test
            StateMachineInstance inst = stateMachineEngine.startWithBusinessKey("reduce
                    InventoryAndBalance", null, businessKey, startParams);
                    Assert.isTrue(ExecutionStatus.SU.equals(inst.getStatus()), "saga transactio
                            n execute failed. XID: " + inst.getId());
            System.out.println("saga transaction commit succeed. XID: " + inst.getId())
            ;
            inst = stateMachineEngine.getStateMachineConfig().getStateLogStore().getSta
            teMachineInstanceByBusinessKey(businessKey, null);
            Assert.isTrue(ExecutionStatus.SU.equals(inst.getStatus()), "saga transactio
                    n execute failed. XID: " + inst.getId());
//async test
            businessKey = String.valueOf(System.currentTimeMillis());
            inst = stateMachineEngine.startWithBusinessKeyAsync("reduceInventoryAndBala
                    nce", null, businessKey, startParams, CALL_BACK);
                    waittingForFinish(inst);
            Assert.isTrue(ExecutionStatus.SU.equals(inst.getStatus()), "saga transactio
                    n execute failed. XID: " + inst.getId());
            分布式事务
            29
            System.out.println("saga transaction commit succeed. XID: " + inst.getId())
            ;
        }
        private static void transactionCompensatedDemo(StateMachineEngine stateMachineE
ngine) {
            Map<String, Object> startParams = new HashMap<>(4);
            String businessKey = String.valueOf(System.currentTimeMillis());
            startParams.put("businessKey", businessKey);
            startParams.put("count", 10);
            startParams.put("amount", new BigDecimal("100"));
            startParams.put("mockReduceBalanceFail", "true");
//sync test
            StateMachineInstance inst = stateMachineEngine.startWithBusinessKey("reduce
                    InventoryAndBalance", null, businessKey, startParams);
//async test
                    businessKey = String.valueOf(System.currentTimeMillis());
            inst = stateMachineEngine.startWithBusinessKeyAsync("reduceInventoryAndBala
                    nce", null, businessKey, startParams, CALL_BACK);
                    waittingForFinish(inst);
            Assert.isTrue(ExecutionStatus.SU.equals(inst.getCompensationStatus()), "sag
                    a transaction compensate failed. XID: " + inst.getId());
            System.out.println("saga transaction compensate succeed. XID: " + inst.getI
                    d());
        }
        private static volatile Object lock = new Object();
        private static AsyncCallback CALL_BACK = new AsyncCallback() {
            @Override
            public void onFinished(ProcessContext context, StateMachineInstance stateMach
ineInstance) {
                synchronized (lock){
                    lock.notifyAll();
                }
            }
            @Override
            public void onError(ProcessContext context, StateMachineInstance stateMachine
Instance, Exception exp) {
                synchronized (lock){
                    lock.notifyAll();
                }
            }
        };
        private static void waittingForFinish(StateMachineInstance inst){
            synchronized (lock){
                if(ExecutionStatus.RU.equals(inst.getStatus())){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
复制代码




Seata saga模式


Saga 事务：最终一致性



方案简介


Saga 事务核心思想是将长事务拆分为多个本地短事务，由 Saga 事务协调器协调，如果正常结束那就正常完成，如果某个步骤失败，则根据相反顺序一次调用补偿操作。



处理流程


Saga事务基本协议


  1. 每个 Saga 事务由一系列幂等的有序子事务(sub-transaction) Ti 组成。
  2. 每个 Ti 都有对应的幂等补偿动作 Ci，补偿动作用于撤销 Ti 造成的结果。
  3. 可以看到，和 TCC 相比，Saga 没有“预留”动作，它的 Ti 就是直接提交到库。

代码实现

// 接⼝略
public class BalanceActionImpl implements BalanceAction {
    private static final Logger LOGGER = LoggerFactory.getLogger(BalanceActionImpl.class);
    @Override
    public boolean reduce(String businessKey, BigDecimal amount, Map<String, Object> params) {
       if(params != null && "true".equals(params.get("throwException"))){
         throw new RuntimeException("reduce balance failed");
       }
       LOGGER.info("reduce balance succeed, amount: " + amount + ", businessKey:" + businessKey);
       return true;
    }
      @Override
      public boolean compensateReduce(String businessKey, Map<String, Object> params) {
            if(params != null && "true".equals(params.get("throwException"))){
                  throw new RuntimeException("compensate reduce balance failed");
            }
            LOGGER.info("compensate reduce balance succeed, businessKey:" + businessKey);
            return true;
      }
}
// 接⼝略
public class InventoryActionImpl implements InventoryAction {
     private static final Logger LOGGER = LoggerFactory.getLogger(InventoryActionImpl.class);
     @Override
     public boolean reduce(String businessKey, int count) {
          LOGGER.info("reduce inventory succeed, count: " + count + ", businessKey:" + businessKey);
          return true;
     }
     @Override
     public boolean compensateReduce(String businessKey) {
          LOGGER.info("compensate reduce inventory succeed, businessKey:" + businessKey);
          return true;
     }
}
复制代码

Seata XA模式


官⽅⽂档


seata.io/zh-cn/docs/…


代码演示


  • 添加Seata的依赖 & 配置
  • 你平时的JDBC代码怎么写，依然怎么写。




4种模式对⽐与选择


AT


优势：


  • 使⽤简单：对业务侵⼊性⼩


缺点：


  • 性能中等
  • 有全局锁




适⽤场景：
  • 适⽤于对性能没有特别⾼的要求的场景
  • 适⽤于不希望对业务进⾏改造的场景



TCC


优势


  • 性能会⽐ AT 模式⾼很多
缺点

相对于 AT 模式，TCC 模式对业务代码有⼀定的侵⼊性

  • 适⽤场景： 适⽤于核⼼系统等对性能有很⾼要求的场景



Saga


优势：
  • ⼀阶段提交本地数据库事务，⽆锁，⾼性能；
  • 参与者可以采⽤事务驱动异步执⾏，⾼吞吐；
  • 补偿服务即正向服务的“反向”，易于理解，易于实现；


缺点：


  • Saga 模式由于⼀阶段已经提交本地数据库事务，且没有进⾏“预留”动作，所以不能保证隔离性。后续会讲到对于缺乏隔离性的应对措施。


适⽤场景：


  • 业务流程⻓/多
  • 参与者包含其他公司或遗留系统服务，⽆法提供 TCC 模式要求的三个接⼝
  • 典型业务系统：如⾦融⽹络（与外部⾦融机构对接）、互联⽹微贷、渠道整合、分布式架构服务
  • 集成等业务系统
  • 银⾏业⾦融机构使⽤⼴泛




XA


优势：


  • ⽆侵⼊
缺点：
  • 性能较差
  • 需要数据库⽀持XA



适⽤场景：


  • 强⼀致性的解决⽅案，适⽤于对⼀致性要求⾮常⾼的场景（使⽤较少）




文章标签：
Java
Linux
Unix
Windows
Maven
中间件
数据库
数据库连接
关键词：
架构实践
分布式seata
分布式事务seata
分布式实践
分布式架构
洛神灬殇
目录
相关文章
Deephub
|
29天前
|
监控 安全 API
使用PaliGemma2构建多模态目标检测系统：从架构设计到性能优化的技术实践指南
本文详细介绍了PaliGemma2模型的微调流程及其在目标检测任务中的应用。PaliGemma2通过整合SigLIP-So400m视觉编码器与Gemma 2系列语言模型，实现了多模态数据的高效处理。文章涵盖了开发环境构建、数据集预处理、模型初始化与配置、数据加载系统实现、模型微调、推理与评估系统以及性能分析与优化策略等内容。特别强调了计算资源优化、训练过程监控和自动化优化流程的重要性，为机器学习工程师和研究人员提供了系统化的技术方案。
Deephub
150 77
使用PaliGemma2构建多模态目标检测系统：从架构设计到性能优化的技术实践指南
喵手
|
8天前
|
数据采集 人工智能 分布式计算
MaxFrame：链接大数据与AI的高效分布式计算框架深度评测与实践！
阿里云推出的MaxFrame是链接大数据与AI的分布式Python计算框架，提供类似Pandas的操作接口和分布式处理能力。本文从部署、功能验证到实际场景全面评测MaxFrame，涵盖分布式Pandas操作、大语言模型数据预处理及企业级应用。结果显示，MaxFrame在处理大规模数据时性能显著提升，代码兼容性强，适合从数据清洗到训练数据生成的全链路场景...
喵手
26 5
MaxFrame：链接大数据与AI的高效分布式计算框架深度评测与实践！
高端源码库
|
3天前
|
监控 JavaScript 数据可视化
建筑施工一体化信息管理平台源码，支持微服务架构，采用Java、Spring Cloud、Vue等技术开发。
智慧工地云平台是专为建筑施工领域打造的一体化信息管理平台，利用大数据、云计算、物联网等技术，实现施工区域各系统数据汇总与可视化管理。平台涵盖人员、设备、物料、环境等关键因素的实时监控与数据分析，提供远程指挥、决策支持等功能，提升工作效率，促进产业信息化发展。系统由PC端、APP移动端及项目、监管、数据屏三大平台组成，支持微服务架构，采用Java、Spring Cloud、Vue等技术开发。
高端源码库
30 7
弹性计算-百晓生
|
1月前
|
运维 Kubernetes 调度
阿里云容器服务 ACK One 分布式云容器企业落地实践
阿里云容器服务ACK提供强大的产品能力，支持弹性、调度、可观测、成本治理和安全合规。针对拥有IDC或三方资源的企业，ACK One分布式云容器平台能够有效解决资源管理、多云多集群管理及边缘计算等挑战，实现云上云下统一管理，提升业务效率与稳定性。
弹性计算-百晓生
59 7
游客nmbcre4jd7shs
|
1月前
|
运维 Cloud Native 持续交付
云原生技术深度探索：重塑现代IT架构的无形之力####
本文深入剖析了云原生技术的核心概念、关键技术组件及其对现代IT架构变革的深远影响。通过实例解析，揭示云原生如何促进企业实现敏捷开发、弹性伸缩与成本优化，为数字化转型提供强有力的技术支撑。不同于传统综述，本摘要直接聚焦于云原生技术的价值本质，旨在为读者构建一个宏观且具体的技术蓝图。 ####
游客nmbcre4jd7shs
69 7
我是快乐的嘟嘟
|
2月前
|
Java 数据库
在Java中使用Seata框架实现分布式事务的详细步骤
通过以上步骤，利用 Seata 框架可以实现较为简单的分布式事务处理。在实际应用中，还需要根据具体业务需求进行更详细的配置和处理。同时，要注意处理各种异常情况，以确保分布式事务的正确执行。
我是快乐的嘟嘟
186 64
XiaoHHSuperme
|
8天前
|
Java 关系型数据库 数据库
微服务SpringCloud分布式事务之Seata
SpringCloud+SpringCloudAlibaba的Seata实现分布式事务，步骤超详细，附带视频教程
XiaoHHSuperme
29 1
江-小北
|
1月前
|
消息中间件 SQL 中间件
大厂都在用的分布式事务方案，Seata+RocketMQ带你打破10万QPS瓶颈
分布式事务涉及跨多个数据库或服务的操作，确保数据一致性。本地事务通过数据库直接支持ACID特性，而分布式事务则需解决跨服务协调难、高并发压力及性能与一致性权衡等问题。常见的解决方案包括两阶段提交（2PC）、Seata提供的AT和TCC模式、以及基于消息队列的最终一致性方案。这些方法各有优劣，适用于不同业务场景，选择合适的方案需综合考虑业务需求、系统规模和技术团队能力。
江-小北
220 7
dufadayang
|
2月前
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架，实现分布式事务的管理和处理。在实际应用中，还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时，要注意处理各种可能出现的问题，以保障分布式事务的顺利执行。
dufadayang
111 6
dufadayang
|
2月前
|
数据库
如何在Seata框架中配置分布式事务的隔离级别？
总的来说，配置分布式事务的隔离级别是实现分布式事务管理的重要环节之一，需要认真对待和仔细调整，以满足业务的需求和性能要求。你还可以进一步深入研究和实践 Seata 框架的配置和使用，以更好地应对各种分布式事务场景的挑战。
dufadayang
53 6

热门文章

最新文章

  • 1
    最新发布！阿里云卓越架构框架重磅升级
  • 2
    日交易笔百万级，Ping++的大数据平台架构
  • 3
    阿里高级技术专家谈开源DDD框架：COLA4.1，分离架构和组件（下）
  • 4
    App 组件化/模块化之路——构建开发架构思路
  • 5
    深入了解云计算架构：从基础到高级
  • 6
    架构之旅~一个操作的返回要有一个标准，看我的公用消息类
  • 7
    02springmvc架构原理分析
  • 8
    MyCat-架构剖析-核心技术之跨库 join 实现 | 学习笔记
  • 9
    微服务架构 | 3.2 Alibaba Nacos 注册中心
  • 10
    linux块设备模型架构框架
  • 1
    Windows系统下安装分布式事务组件Seata
    297
  • 2
    基于Seata实现分布式事务
    197
  • 3
    分布式事务Seata
    120
  • 4
    SpringCloud集成seata分布式事务控制
    97
  • 5
    分布式事务Seata
    82
  • 6
    安装Docker&镜像容器操作&使用Docker安装部署MySQL，Redis，RabbitMQ，Nacos，Seata，Minio
    913
  • 7
    分布式事务解决方案Seata
    109
  • 8
    Seata常见问题之Seata报错Failed to fetch schema of t_table如何解决
    237
  • 9
    Seata常见问题之Seata关闭自动代理提交数据时候报错如何解决
    258
  • 10
    Seata常见问题之Seata AT的设计不支持使用临时表如何解决
    182

    • 相关课程

    更多
  • Serverless 函数计算架构
  • 架构的演进
  • MySQL企业常见架构与调优经验分享
  • 企业Web常用架构LAMP-LNMP实战
  • 企业级互联网分布式系统应用架构学习
  • 高校精品课-上海交通大学 -企业级应用体系架构

    • 相关电子书

    更多
  • MaxCompute架构升级及开放性解读
  • MaxCompute Serverless 架构演进
  • 阿里云消息队列的 Serverless架构演进

    • 相关实验场景

    更多
  • 体验PolarDB-X透明分布式
  • 每个IT人都想学的“Web应用上云经典架构”实战
  • MySQL引擎及架构优化
  • 基于数据湖架构的网站访问行为分析
  • 使用SLB+2ECS+NAS，部署电商web网站的高可用架构
  • 高性能特性体验：ePQ 的详解与实战
    • 下一篇
    DataWorks智能交互式数据开发与分析之旅