分布式事务框架seata

最新推荐文章于 2024-06-25 13:59:11 发布
最新推荐文章于 2024-06-25 13:59:11 发布
阅读量464 收藏
点赞数 2
分类专栏： 分布式 文章标签： 分布式 java
ZHRZ
本文链接：https://blog.csdn.net/qq_20286065/article/details/110473354
版权

分布式事务框架seata

1 seata简介

​ Seata（原名Fescar） 是阿里18年开源的分布式事务的框架。Fescar的开源对分布式事务框架领域影响很大。作为开源大户，Fescar来自阿里的GTS，经历了好几次双十一的考验，一经开源便颇受关注。后来Fescar改名为Seata。 https://github.com/seata/seata

Fescar虽然是二阶段提交协议的分布式事务，但是其解决了XA的一些缺点:
  • 单点问题:虽然目前Fescar(0.4.2)还是单server的，但是Fescar官方预计将会在0.5.x中推出HA-Cluster，到时候就可以解决单点问题。
  • 同步阻塞:Fescar的二阶段，其再第一阶段的时候本地事务就已经提交释放资源了，不会像XA会再两个prepare和commit阶段资源都锁住，并且Fescar,commit是异步操作，也是提升性能的一大关键。
  • 数据不一致:如果出现部分commit失败，那么fescar-server会根据当前的事务模式和分支事务的返回状态的结果来进行不同的重试策略。并且fescar的本地事务会在一阶段的时候进行提交，其实单看数据库来说在commit的时候数据库已经是一致的了。
  • 只能用于单一数据库: Fescar提供了三种模式，AT和TCC和混合模式。在AT模式下事务资源可以是任何支持ACID的数据库，在TCC模式下事务资源没有限制，可以是缓存，可以是文件，可以是其他的等等。当然这两个模式也可以混用。

同时Fescar也保留了接近0业务入侵的优点，只需要简单的配置Fescar的数据代理和加个注解，加一个Undolog表，就可以达到我们想要的目的。

2 实现原理

Fescar将一个本地事务做为一个分布式事务分支，所以若干个分布在不同微服务中的本地事务共同组成了一个全局事务，结构如下。

官帮助文档： https://seata.io/zh-cn/index.html
在这里插入图片描述

TM：全局事务管理器，在标注开启fescar分布式事务的服务端开启，并将全局事务发送到TC事务控制端管理

TC：事务控制中心，控制全局事务的提交或者回滚。这个组件需要独立部署维护，目前只支持单机版本，后续迭代计划会有集群版本

RM：资源管理器，主要负责分支事务的上报，本地事务的管理

一段话简述其实现过程：服务起始方发起全局事务并注册到TC。在调用协同服务时，协同服务的事务分支事务会先完成阶段一的事务提交或回滚，并生成事务回滚的undo_log日志，同时注册当前协同服务到TC并上报其事务状态，归并到同一个业务的全局事务中。此时若没有问题继续下一个协同服务的调用，期间任何协同服务的分支事务回滚，都会通知到TC，TC在通知全局事务包含的所有已完成一阶段提交的分支事务回滚。如果所有分支事务都正常，最后回到全局事务发起方时，也会通知到TC，TC在通知全局事务包含的所有分支删除回滚日志。在这个过程中为了解决写隔离和度隔离的问题会涉及到TC管理的全局锁。

（增加订单(branchId=901)，减库存(branchId=109)） xid=101

3 Fescar模式

Fescar对分布式事务的实现提供了3种模式，AT模式和TCC模式、saga模式：

3.1 AT模式

AT模式：主要关注多 DB 访问的数据一致性，实现起来比较简单，对业务的侵入较小，但性能没有TCC高，这种模式推荐大家使用。

AT模式部分代码如下：不需要关注执行状态，对业务代码侵入较小。

/**
  * 此代码为示例代码, 不需要演示, 主要看AT和TCC代码的区别使用
  */
@GlobalTransactional(timeoutMills = 300000, name = "dubbo-demo-tx")
public void purchase(String userId, String commodityCode, int orderCount) {
    LOGGER.info("purchase begin ... xid: " + RootContext.getXID());
    storageService.deduct(commodityCode, orderCount);
    orderService.create(userId, commodityCode, orderCount);
    throw new RuntimeException("AT 模式发生异常，回滚事务");
}

AT模式的核心是对业务无侵入，是一种改进后的两阶段提交，其设计思路如图：

第一阶段：
在这里插入图片描述
核心在于对业务sql进行解析，转换成undolog，两阶段提交往往对资源的锁定需要持续到第二阶段实际的提交或者回滚操作，而有了回滚日志之后，可以在第一阶段释放对资源的锁定，降低了锁范围，提高效率，即使第二阶段发生异常需要回滚，只需找对undolog中对应数据并反解析成sql来达到回滚目的。Seata通过代理数据源将业务sql的执行解析成undolog来与业务数据的更新同时入库，达到了对业务无侵入的效果。

第二阶段：

如果决议是全局提交，此时分支事务此时已经完成提交，不需要同步协调处理（只需要异步清理回滚日志），Phase2 可以非常快速地完成。
在这里插入图片描述

如果决议是全局回滚，RM 收到协调器发来的回滚请求，通过 XID 和 Branch ID 找到相应的回滚日志记录，通过回滚记录生成反向的更新 SQL 并执行，以完成分支的回滚。
在这里插入图片描述

3.3 TCC模式

TCC模式：TCC补偿机制，对代码造成一定的侵入,实现难度较大，这种方式不推荐，不过TCC模式的特点是性能高。

TCC模式部分代码如下：可以看到执行事务回滚，都需要根据不同阶段执行的状态判断，侵入了业务代码。

/**
 * 此代码为示例代码, 不需要演示, 主要看AT和TCC代码的区别使用
 * 转账操作
 * @param from  扣钱账户
 * @param to  加钱账户
 * @param amount  转账金额
 * @return
 */
@Override
@GlobalTransactional
public boolean transfer(final String from, final String to, final double amount) {
    //扣钱参与者，一阶段执行
    boolean ret = firstTccAction.prepareMinus(null, from, amount);

    if(!ret){
        //扣钱参与者，一阶段失败; 回滚本地事务和分布式事务
        throw new RuntimeException("账号:["+from+"] 预扣款失败");
    }

    //加钱参与者，一阶段执行
    ret = secondTccAction.prepareAdd(null, to, amount);

    if(!ret){
        throw new RuntimeException("账号:["+to+"] 预收款失败");
    }

    System.out.println(String.format("transfer amount[%s] from [%s] to [%s] finish.", String.valueOf(amount), from, to));
    return true;
}
3.3 Saga模式

详见 https://seata.io/zh-cn/docs/dev/mode/saga-mode.html

Seata案例

1准备工作

​ 1导入资料中的changgou_common_fescar。注意总父工程中加入模块

<module>changgou_common_fescar</module>

​ 2观察模块中的三个类。

​ 3数据库changgou_order中的undo_log表为记录相关操作的表
在这里插入图片描述
​ 4资料中的fescar-server-0.4.2解压，bin目录中双击fescar-server.bat。注意：这是fescar的服务，并且放到一个短目录才能执行。

在这里插入图片描述
在这里插入图片描述

2分布式事务错误演示

1order服务 com.changgou.order.service.impl 的 add方法中增加一个错误 本地事务控制注解增加@Transactional

		//减库存
        skuFeign.decrCount(order.getUsername());

        int i=1/0;

        // 5）删除购物车中数据
        redisTemplate.delete("cart_"+order.getUsername());

2goods 服务 com.changgou.goods.service.impl decrCount减库存方法上增加本地事务控制注解@Transactional

3查看数据库 tb_order tb_order_item中都有一条数据。

在这里插入图片描述
在这里插入图片描述

tb_sku查看一条数据库存量 9920

在这里插入图片描述

4登陆购物车并登陆 http://localhost:8001/api/wcart/list

5往购物车添加数据 http://localhost:8001/api/cart/addCart?skuId=100000006163&num=10

6购物车页面点击结算到订单页面
在这里插入图片描述

7点击提交订单
在这里插入图片描述
8代码中 order服务报错

在这里插入图片描述
9观察数据库

tb_order tb_order_item没变化

tb_sku 100000006163商品库存减少了10

在这里插入图片描述

10 为什么

order goods服务是两个服务，即使加上@Transactional也是本地事务控制。
在这里插入图片描述

3 分布式事务正确演示

1 goods order 增加fescar依赖

        <dependency>
            <groupId>com.changgou</groupId>
            <artifactId>changgou_common_fescar</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

2在订单微服务的OrderServiceImpl的add方法上增加@GlobalTransactional(name = “order_add”)注解

3order 服务重启 观察 fescar控制台输出

在这里插入图片描述
4goods 服务重启 观察 fescar控制台输出
在这里插入图片描述
5重新提交订单 依然失败 但库存不扣减了
在这里插入图片描述
在这里插入图片描述

消息队列实现分布式事务—整个项目的重点

1业务流程-重点

需求：（一次下单—》用户积分增加一次） 事务

在这里插入图片描述
1 order

​ 1.1 order task.本地事务控制。

​ 1.2 spring-task扫表 task-----》mq发消息

2user

​ 2.1监听消息 6

​ 2.2 8相当于锁 11释放锁

​ 2.3 mq（另一个队列） task 积分加上了

在这里插入图片描述
3order

​ 3.1监听消息 task_his 加上，后期查看，task 删除

思考：

1mq中几个交换机 几个队列？

2 8-11 redis user宕机了 集美没加上？redis 超时间

3 积分日志表 作用？本地事务控制user point 一起成功。

2代码实现
2.1准备
1order中添加两张表

​ tb_task 任务表

在这里插入图片描述
​ tb_task_his 历史任务表
在这里插入图片描述

2order-api中添加对应的实体类
package com.changgou.order.pojo;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Table(name = "tb_task")
public class Task {
    @Id
    private Long id;

    @Column(name = "create_time")
    private Date createTime;

    @Column(name = "update_time")
    private Date updateTime;

    @Column(name = "delete_time")
    private Date deleteTime;

    @Column(name = "task_type")
    private String taskType;

    @Column(name = "mq_exchange")
    private String mqExchange;

    @Column(name = "mq_routingkey")
    private String mqRoutingkey;

    @Column(name = "request_body")
    private String requestBody;

    @Column(name = "status")
    private String status;

    @Column(name = "errormsg")
    private String errormsg;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public Date getDeleteTime() {
        return deleteTime;
    }

    public void setDeleteTime(Date deleteTime) {
        this.deleteTime = deleteTime;
    }

    public String getTaskType() {
        return taskType;
    }

    public void setTaskType(String taskType) {
        this.taskType = taskType;
    }

    public String getMqExchange() {
        return mqExchange;
    }

    public void setMqExchange(String mqExchange) {
        this.mqExchange = mqExchange;
    }

    public String getMqRoutingkey() {
        return mqRoutingkey;
    }

    public void setMqRoutingkey(String mqRoutingkey) {
        this.mqRoutingkey = mqRoutingkey;
    }

    public String getRequestBody() {
        return requestBody;
    }

    public void setRequestBody(String requestBody) {
        this.requestBody = requestBody;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getErrormsg() {
        return errormsg;
    }

    public void setErrormsg(String errormsg) {
        this.errormsg = errormsg;
    }
}


package com.changgou.order.pojo;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Table(name = "tb_task_his")
public class TaskHis {

    @Id
    private Long id;

    @Column(name = "create_time")
    private Date createTime;

    @Column(name = "update_time")
    private Date updateTime;

    @Column(name = "delete_time")
    private Date deleteTime;

    @Column(name = "task_type")
    private String taskType;

    @Column(name = "mq_exchange")
    private String mqExchange;

    @Column(name = "mq_routingkey")
    private String mqRoutingkey;

    @Column(name = "request_body")
    private String requestBody;

    @Column(name = "status")
    private String status;

    @Column(name = "errormsg")
    private String errormsg;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public Date getDeleteTime() {
        return deleteTime;
    }

    public void setDeleteTime(Date deleteTime) {
        this.deleteTime = deleteTime;
    }

    public String getTaskType() {
        return taskType;
    }

    public void setTaskType(String taskType) {
        this.taskType = taskType;
    }

    public String getMqExchange() {
        return mqExchange;
    }

    public void setMqExchange(String mqExchange) {
        this.mqExchange = mqExchange;
    }

    public String getMqRoutingkey() {
        return mqRoutingkey;
    }

    public void setMqRoutingkey(String mqRoutingkey) {
        this.mqRoutingkey = mqRoutingkey;
    }

    public String getRequestBody() {
        return requestBody;
    }

    public void setRequestBody(String requestBody) {
        this.requestBody = requestBody;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getErrormsg() {
        return errormsg;
    }

    public void setErrormsg(String errormsg) {
        this.errormsg = errormsg;
    }
}
3 changgou_user新增积分日志表

在这里插入图片描述

4 changgou_service_user_api添加实体类 PointLog
package com.changgou.user.pojo;

import javax.persistence.Table;

@Table(name = "tb_point_log")
public class PointLog {

    private String orderId;
    private String userId;
    private Integer point;

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public Integer getPoint() {
        return point;
    }

    public void setPoint(Integer point) {
        this.point = point;
    }
}
5rabbitMQ

1 order 服务 导包

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
        </dependency>

2config 下 rabbitMQ配置类

package com.changgou.order.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    //添加积分任务交换机
    public static final String EX_BUYING_ADDPOINTUSER = "ex_buying_addpointuser";

    //添加积分消息队列
    public static final String CG_BUYING_ADDPOINT = "cg_buying_addpoint";

    //完成添加积分消息队列
    public static final String CG_BUYING_FINISHADDPOINT = "cg_buying_finishaddpoint";

    //添加积分路由key
    public static final String CG_BUYING_ADDPOINT_KEY = "addpoint";

    //完成添加积分路由key
    public static final String CG_BUYING_FINISHADDPOINT_KEY = "finishaddpoint";

    //声明交换机
    @Bean(EX_BUYING_ADDPOINTUSER)
    public Exchange EX_BUYING_ADDPOINTUSER(){
        return ExchangeBuilder.directExchange(EX_BUYING_ADDPOINTUSER).durable(true).build();
    }

    //声明队列
    @Bean(CG_BUYING_ADDPOINT)
    public Queue CG_BUYING_ADDPOINT(){
        Queue queue = new Queue(CG_BUYING_ADDPOINT);
        return queue;
    }
    @Bean(CG_BUYING_FINISHADDPOINT)
    public Queue CG_BUYING_FINISHADDPOINT(){
        Queue queue = new Queue(CG_BUYING_FINISHADDPOINT);
        return queue;
    }

    //队列绑定交换机
    @Bean
    public Binding BINDING_CG_BUYING_ADDPOINT(@Qualifier(CG_BUYING_ADDPOINT) Queue queue, @Qualifier(EX_BUYING_ADDPOINTUSER)Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(CG_BUYING_ADDPOINT_KEY).noargs();
    }
    @Bean
    public Binding BINDING_CG_BUYING_FINISHADDPOINT(@Qualifier(CG_BUYING_FINISHADDPOINT) Queue queue,@Qualifier(EX_BUYING_ADDPOINTUSER)Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(CG_BUYING_FINISHADDPOINT_KEY).noargs();
    }
}

3配置文件 rabbitmq

  rabbitmq:
    host: 192.168.200.128
2.2 订单服务逻辑

需求：

在这里插入图片描述

1dao层 增加mapper
package com.changgou.order.dao;

import com.changgou.order.pojo.Task;
import tk.mybatis.mapper.common.Mapper;

public interface TaskMapper extends Mapper<Task> {
}

package com.changgou.order.dao;

import com.changgou.order.pojo.TaskHis;
import tk.mybatis.mapper.common.Mapper;

public interface TaskHisMapper extends Mapper<TaskHis> {
}
2下单逻辑中增加任务
    @Autowired
    TaskMapper taskMapper;

		// int i=1/0;
        //添加任务数据
        System.out.println("向订单数据库中的任务表去添加任务数据");
        Task task = new Task();
        task.setCreateTime(new Date());
        task.setUpdateTime(new Date());
        task.setMqExchange(RabbitMQConfig.EX_BUYING_ADDPOINTUSER);
        task.setMqRoutingkey(RabbitMQConfig.CG_BUYING_ADDPOINT_KEY);

        Map map = new HashMap();
        map.put("username",order.getUsername());
        map.put("orderId",orderId);
        map.put("point",order.getPayMoney());
        task.setRequestBody(JSON.toJSONString(map));
        taskMapper.insertSelective(task);
3定时任务，定时发送任务表信息到mq

启动类增加

@EnableScheduling //开启定时任务

新建task包，加入定时任务类

@Component
public class QueryPointTask {
    @Autowired
    private TaskMapper taskMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Scheduled(cron = "0/2 * * * * ?")
    public void queryTask(){
        //1. 获取小于系统当前时间的数据
        List<Task> taskList = taskMapper.findTaskLessThanCurrentTime(new Date());
        if (taskList != null && taskList.size()>0){
            //2.将任务发送到消息队列上
            for (Task task : taskList) {
                rabbitTemplate.convertAndSend(RabbitMQConfig.EX_BUYING_ADDPOINTUSER, RabbitMQConfig.CG_BUYING_ADDPOINT_KEY, JSON.toJSONString(task));
                System.out.println("订单服务向添加积分队列发送了一条消息");
            }
        }
    }
}

taskmapper中自定义查询小于当前时间的方法

    @Select("select * from tb_task where update_time<#{currentTime}")
    @Results({@Result(column = "create_time",property = "createTime"),
            @Result(column = "update_time",property = "updateTime"),
            @Result(column = "delete_time",property = "deleteTime"),
            @Result(column = "task_type",property = "taskType"),
            @Result(column = "mq_exchange",property = "mqExchange"),
            @Result(column = "mq_routingkey",property = "mqRoutingkey"),
            @Result(column = "request_body",property = "requestBody"),
            @Result(column = "status",property = "status"),
            @Result(column = "errormsg",property = "errormsg")})
    List<Task> findTaskLessThanCurrentTime(Date currentTime);
2.3 用户服务逻辑

需求：
在这里插入图片描述

1配置文件增加redis rabbitMQ配置
spring:
  application:
    name: user
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.200.128:3306/changgou_user?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
  main:
    allow-bean-definition-overriding: true #当遇到同样名字的时候，是否允许覆盖注册
  redis:
    host: 192.168.200.128
  rabbitmq:
    host: 192.168.200.128
2导入mq依赖
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
        </dependency>
3mq配置类

RabbitMQConfig ，从order服务copy

4添加依赖
        <dependency>
            <groupId>com.changgou</groupId>
            <artifactId>changgou_service_order_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
4监听mq队列

com.changgou.user.listener创建AddPointListener

package com.changgou.user.listener;

import com.alibaba.fastjson.JSON;
import com.changgou.order.pojo.Task;
import com.changgou.user.config.RabbitMQConfig;
import com.changgou.user.service.UserService;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class AddPointListener {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private UserService userService;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RabbitListener(queues = RabbitMQConfig.CG_BUYING_ADDPOINT)
    public void receiveAddPointMessage(String message){
        System.out.println("用户服务接收到了任务消息");

        //转换消息
        Task task = JSON.parseObject(message, Task.class);
        if (task == null || StringUtils.isEmpty(task.getRequestBody())){
            return;
        }

        //判断redis中当前的任务是否存在
        Object value = redisTemplate.boundValueOps(task.getId()).get();
        if (value != null){
            return;
        }
     
}
5更新积分方法实现

1userService 定义接口

int updateUserPoint(Task task);

实现类

@Override
    @Transactional
    public int updateUserPoint(Task task) {
        System.out.println("用户服务现在开始对任务进行处理");
        //1.从task中获取相关数据
        Map map = JSON.parseObject(task.getRequestBody(), Map.class);
        String username = map.get("username").toString();
        String orderId = map.get("orderId").toString();
        int point = (int) map.get("point");

        //2.判断当前的任务是否操作过
        PointLog pointLog = pointLogMapper.findPointLogByOrderId(orderId);
        if (pointLog != null){
            return 0;
        }

        //3.将任务存入到redis中
        redisTemplate.boundValueOps(task.getId()).set("exist",30, TimeUnit.SECONDS);

        //4.修改用户积分
        int result = userMapper.updateUserPoint(username,point);
        if (result<=0){
            return 0;
        }

        //5.记录积分日志信息
        pointLog = new PointLog();
        pointLog.setUserId(username);
        pointLog.setOrderId(orderId);
        pointLog.setPoint(point);
        result = pointLogMapper.insertSelective(pointLog);
        if (result <= 0){
            return 0;
        }

        //6.删除redis中的任务信息
        redisTemplate.delete(task.getId());
        System.out.println("用户服务完成了更改用户积分的操作");
        return 1;
    }

2dao层新建mapper,查询当前任务是否操作过

package com.changgou.user.dao;

import com.changgou.user.pojo.PointLog;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import tk.mybatis.mapper.common.Mapper;

public interface PointLogMapper extends Mapper<PointLog> {

    @Select("select * from tb_point_log where order_id =#{orderId}")
    PointLog findPointLogByOrderId(@Param("orderId") String orderId);
}

3userMapper新增一个修改用户积分方法

package com.changgou.user.dao;

import com.changgou.user.pojo.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {

    @Update("update tb_user set points=points+#{point} where username=#{username}")
    int updateUserPoint(@Param("username")String username, @Param("point") int point);
}

4AddPointListener完善

package com.changgou.user.listener;

import com.alibaba.fastjson.JSON;
import com.changgou.order.pojo.Task;
import com.changgou.user.config.RabbitMQConfig;
import com.changgou.user.service.UserService;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class AddPointListener {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private UserService userService;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RabbitListener(queues = RabbitMQConfig.CG_BUYING_ADDPOINT)
    public void receiveAddPointMessage(String message){
        System.out.println("用户服务接收到了任务消息");

        //1转换消息
        Task task = JSON.parseObject(message, Task.class);
        if (task == null || StringUtils.isEmpty(task.getRequestBody())){
            return;
        }

        //2判断redis中当前的任务是否存在
        Object value = redisTemplate.boundValueOps(task.getId()).get();
        if (value != null){
            return;
        }

        //3更新用户积分
        int result = userService.updateUserPoint(task);
        if (result == 0){
            return;
        }

        //4向订单服务返回通知消息
        rabbitTemplate.convertAndSend(RabbitMQConfig.EX_BUYING_ADDPOINTUSER,RabbitMQConfig.CG_BUYING_FINISHADDPOINT_KEY,JSON.toJSONString(task));
        System.out.println("用户服务向完成添加积分队列发送了一条消息");
    }
}
2.4订单服务收尾

需求：
在这里插入图片描述
建立监听类DelTaskListener

package com.changgou.order.listener;

import com.alibaba.fastjson.JSON;
import com.changgou.order.config.RabbitMQConfig;
import com.changgou.order.pojo.Task;
import com.changgou.order.service.TaskService;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DelTaskListener {

    @Autowired
    private TaskService taskService;

    @RabbitListener(queues = RabbitMQConfig.CG_BUYING_FINISHADDPOINT)
    public void receiveDelTaskMessage(String message){
        System.out.println("订单服务接收到了删除任务操作的消息");

        Task task = JSON.parseObject(message, Task.class);

        //删除原有的任务数据,并向历史任务表中添加记录
        taskService.delTask(task);
    }
}

创建taskService写出删除任务的方法

public interface TaskService {
    void delTask(Task task);
}

实现taskService

package com.changgou.order.service.impl;

import com.changgou.order.dao.TaskHisMapper;
import com.changgou.order.dao.TaskMapper;
import com.changgou.order.pojo.Task;
import com.changgou.order.pojo.TaskHis;
import com.changgou.order.service.TaskService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;

@Service
public class TaskServiceImpl implements TaskService {

    @Autowired
    private TaskHisMapper taskHisMapper;

    @Autowired
    private TaskMapper taskMapper;

    @Override
    @Transactional
    public void delTask(Task task) {

        //1.记录删除时间
        task.setDeleteTime(new Date());
        Long taskId = task.getId();
        task.setId(null);

        //2bean拷贝
        TaskHis taskHis = new TaskHis();
        BeanUtils.copyProperties(task,taskHis);

        //3记录历史任务数据
        taskHisMapper.insertSelective(taskHis);

        //4删除原有任务数据
        //taskMapper.deleteByPrimaryKey(id);
        task.setId(id);
        taskMapper.delete(task);
        System.out.println("订单服务完成了添加历史任务并删除原有任务的操作");
    }
}
2.5效果测试

order user服务以dubug打开。

从头到最后一步一步测试。关键点：

1order下单任务表中数据

2order 定时任务扫描表，发信息

3user收到信息，检查redis,修改积分

4order收到成功消息

Z_海瑞_Z
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式事务框架seata安装教程
06-15
分布式事务框架Seata安装教程 Seata是一款开源的分布式事务框架，旨在提供高性能、可靠、可扩展的分布式事务解决方案。下面是Seata安装教程的详细知识点： 1. Seata的安装准备工作 在安装Seata之前，需要准备好...
分布式事务解决方案
IT__LS的博客
07-10 247
分布式事务
分布式事务——分布式事务简介、分布式事务框架 Seata（AT模式、Tcc模式、Tcc Vs AT）、分布式事务—MQ
热门推荐
qq_41824825的博客
03-14 2万+
分布式事务——分布式事务简介、分布式事务框架 Seata（AT模式、Tcc模式、Tcc Vs AT）、分布式事务——MQ
分布式事务之Seata框架
最新发布
西敏寺的乐章的博客
06-25 2046
传统的单体项目被拆分成多个微服务，一个完整的流程可能涉及到多个服务之间的调用，多个服务的入库操作，为了满足事务的ACID原则，提出了分布式事务。
分布式事务学习-LCN
Piratesa的博客
07-22 503
1、什么是分布式事务？ 分布式事务是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位 于不同的分布式系统的不同节点之上。 图中包含了库存和订单两个独立的微服务，每个微服务维护了自己的数据库。在交易系 统的业务逻辑中，一个商品在下单之前需要先调用库存服务，进行扣除库存，再调用订单服 务，创建订单记录。 正常情况下，两个数据库各自更新成功，两边数据维持着一致性。 如果在非正常情况下...
5大分布式事务框架详解(图文全面总结)
m0_60259116的博客
04-09 2295
5大分布式事务框架详解(图文全面总结)
分布式事务：seata
一条没有梦想的闲鱼的博客
01-16 1万+
seata
2023深度解读分布式事务Seata课-视频教程网盘链接提取码下载 .txt
12-22
本课程将深入探讨分布式事务管理框架Seata的核心概念和实际应用。学员将了解Seata在微服务架构中的作用、原理及实践，包括分布式事务、一致性、可靠性等方面的重要知识点。 视频大小：16.6G
seata 分布式事务框架学习
05-31
在这个“seata 分布式事务框架学习”案例中，我们将结合SpringBoot、Dubbo以及Zookeeper来理解如何整合Seata构建一个完整的分布式事务处理系统。 首先，让我们深入了解Seata的核心概念和工作原理。Seata包含了三个...
分布式事务seata安装
10-29
Seata是一个开源的分布式事务解决方案，用于解决分布式系统中的事务一致性问题。它提供了高性能和高可靠性的分布式事务支持，可以在微服务架构中保证数据的一致性和可靠性。 Seata的核心概念包括三个组件：事务协调...
分布式事务解决方案Seata 框架学习代码 Demo
02-22
分布式事务解决方案Seata 框架学习代码 Demo 。里面包含了完成的seata使用代码，包括AT、TCC、XA等模式的直接使用案例。开箱即用。 分布式事务解决方案Seata 框架学习代码 Demo 。里面包含了完成的seata使用代码，...
fescar-server-0.4.2.zip
02-13
Seata（原名Fescar） 是阿里18年开源的分布式事务的框架。Fescar的开源对分布式事务框架领域影响很大。作为开源大户，Fescar来自阿里的GTS，经历了好几次双十一的考验，一经开源便颇受关注。后来Fescar改名为Seata。解决分布式事务控制
分布式事务框架 Seata 详解（附代码）
AhangA的博客
01-13 2257
分布式事务框架Seata学习
Seata分布式事务
m0_46690280的博客
05-19 2438
Seata分布式事务Seata分布式事务1 事务概念1.1 事务简介1.2 本地事务1.3 分布式事务1.3.1 跨库事务1.3.2 分库分表事务1.3.3 跨应用事务2 分布式理论2.1 CAP原理2.2 BASE理论2.3 刚柔事务3 常用事务解决方案模型3.1 DTP模型3.2 2PC/3PC3.3 TCC3.4 MQ分布式事务4 Seata 分布式事务4.1 Seata AT模式4.1.1 AT模式工作机制4.1.2 AT模式工作流程描述4.1.3 Seata-Server安装4.1.4 Seata
分布式事务及分布式框架Seata
肥柯博客
08-17 3867
分布式事务 ==分布式事务是什么？ ==》本地事务是一个单元的sql，分布式事务也是一个单元的sql，他们区别在于，分布式事务的sql分布在了不同服务上，这里的服务指微服务和数据库服务 ==？为什么强调服务是微服务和数据库服务？ 一个服务，多个数据库是分布式事务 多个服务，一个数据库是分布式事务 多个服务，多个数据库是分布式事务 总之，分布在不同服务上的不同的事务，它们各自rollback和commit，仅凭本地事务是无法保证它们一致性的 分布式事务解决方案 分布式事务的解决方案有三种，分别是全局
Seata实现分布式事务
赵广陆
02-16 4133
目录1 分布式事务解决方案-面试1.1 本地事务与分布式事务1.1.1 事务1.1.2 本地事务1.1.3 分布式事务1.2 分布式事务相关理论1.2.1 CAP定理1.2.2 BASE理论1.2.2.1 Basically Available(基本可用)1.3 分布式事务解决方案-面试1.3.1 基于XA协议的两阶段提交1.3.2 TCC补偿机制1.3.3 消息最终一致性-重点2 基于Seata实现分布式事务2.1 Seata简介2.2 Seata事务模式-AT模式2.3 Seata Server端环境准
分布式事务--Seata
忆~遂愿的博客
04-15 1887
分布式事务--Seata
对比7种分布式事务方案，还是偏爱阿里开源的Seata，真香！(原理+实战)
承诺不过儿戏的博客
06-02 3061
主要介绍一些目前主流的几种分布式解决方案以及阿里开源的一站式分布式解决方案Seata
【2.2 分布式事务（Seata）】Seata框架入门介绍
本本本添哥
06-13 1228
一个分布式的全局事务，整体是两阶段提交的模型。全局事务是由若干分支事务组成的，分支事务要满足两阶段提交的模型要求，即需要每个分支事务都具备自己的：一阶段prepare行为二阶段commit或rollback行为根据两阶段行为模式的不同，我们将分支事务划分为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值