Java和Go利用RocketMQ实现分布式事务_rocketmq 事务 java demo-CSDN博客

本文链接：https://blog.csdn.net/weixin_43357992/article/details/134589620

1 简介

在单体应用上原本在一个本地事务中多个数据库的操作，由于服务拆分，多个操作可能会处于不同的服务中。多个操作跨进程，跨数据库是一种很常见的现象。分布式事务的目标是确保在跨多个服务或资源的操作中保持一致和可靠。

常见的解决方案：

XA模式产品：把事务操作分为预处理和提交/回滚两个阶段。不立即提交事务，由事务协调者同意管理。长事务会导致资源锁定时间太长。
saga模式产品：将长事务拆分成一个个的短事务，如果某个步骤失败，反方向补偿。
TCC模式产品：分为Try、Confirm、Cancel三个阶段。尝试执行做前置校验，预留资源。try成功之后执行Confirm，执行业务。所有try任何一个失败了就会执行Cancel。但是业务侵入性很强。
本地消息表：将分布式事务拆成本地事务执行。添加消息表，远程调用改成往本地的消息表中存储一条消息。通过定时任务扫扫描消息表发送消息。服务提供放收到消息之后处理，通知调用方处理结果。本地消息表消息可靠，但是需要注意的细节比较多，消息状态的标记，幂等的处理。超时情况的处理等等等等。
RocketMQ事务消息：上游系统在做本地的操作之前先向RocketMQ中发送一个回滚消息，发送的是事务消息，此时为半消息。本地的操作放在RocketMQ的本地事务监听器中操作。全部成功控制事务消息回滚。操作失败，返回COMMIT，控制消息提交。下游系统监听消息，对本地事务进行回滚。

2 Java实现

使用的是SpringBooot3.X，JDK17

项目目录

坑：

在SpringBoot3.X中RocketMQ的Start不能正常装配，启动时会报找不到RocketMQTemplate的Bean

解决办法：

在resources下面新建META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

org.apache.rocketmq.spring.autoconfigure.RocketMQAutoConfiguration

本地事务监听中的异常抛不出来，仅靠发送事务消息的返回的本地事务状态并不能完全确定本地事务是否执行成功，是否出现异常。

解决方案：建一个args传到本地事务监听器里面，出现异常的话，给args中的err属性赋值，就可以在外侧获取监听器中的异常。

2.1 发送事务消息

测试代码写的有点low，大概是这么个意思。公共方法没有抽出来。

package com.example.model.rocketmqdemo.controller;

import com.example.framework.common.model.resp.Result;
import com.example.model.rocketmqdemo.mq.product.RocketMqProducer;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author liu
 * @date 2023/11/23
 * description:
 */
@Slf4j
@Tag(name = "mq消息接口")
@RestController
@RequestMapping
@RequiredArgsConstructor
public class TestController {

    /**
     * SpringBoot3中RocketMQ的starter不能自动装配, 需要在项目的META-INF加个文件
     */
    private final RocketMQTemplate rocketMQTemplate;

    @Data
    public static class Args{
        private Exception e;
    }

    @Operation(summary = "事务消息测试接口")
    @Parameter(name = "key", description = "key", required = true)
    @GetMapping("transactional-demo")
    public Result<String> transactionalDemo(@RequestParam(name = "key") String key) {
        log.info("事务消息测试接口");
        Message<String> msg = MessageBuilder.withPayload("hello rocketmq")
                .setHeader(RocketMqProducer.LISTENER_KEY_HEAD_NAME, key)
                .build();
        Args args = new Args();
        // 发送消息, 判断结果时, 仅仅根据result.getLocalTransactionState().name(); 本地事务发送状态是判断不出来, 响应给前端成功还是失败的,
        // 可以借助args参数, 在里面添加一个异常属性,将本地事务中的异常传出来, 否则本地事务监听的异常, 外部是无感知的
        TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction("global_transactional_topic", msg, args);
        // 获取发送状态
        String sendStatus = result.getSendStatus().name();
        // 本地事务执行状态
        String state = result.getLocalTransactionState().name();
        log.info("发送状态: {}", sendStatus);
        log.info("本地事务执行状态: {}", state); // UNKNOW == 出异常 / ROLLBACK_MESSAGE = 回滚 / COMMIT_MESSAGE = 提交

        // 测试代码写的有点low, 如果消息提交了, 说明本地事务执行失败, 响应给前端失败
        if ("COMMIT_MESSAGE".equals(state)) {
            return Result.err("网络开小差了");
        }
        // 校验本地事务是否执行成功, 异常不为空的话, 说明本地事务执行失败了
        if (args.getE() != null) {
            log.error("", args.getE());
            return Result.err("网络开小差了");
        }
        return Result.OK();
    }


}

2.2 本地事务监听

RocketMQ的本地事务监听入口，里面会调用开发者自己注册的监听方法。

package com.example.model.rocketmqdemo.mq.product.transactional;

import com.example.model.rocketmqdemo.mq.product.RocketMqProducer;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;

/**
 * @author liu
 * @date 2023/11/23
 * description: 生产者本地事务监听器
 */
@Slf4j
@RocketMQTransactionListener
public class LocalTransactionMsgListener implements RocketMQLocalTransactionListener {


    /**
     * 执行本地事务
     *
     * @param msg 消息
     * @param arg 参数
     * @return {@link RocketMQLocalTransactionState }
     * @author liu
     * @date 2023/11/23
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        String localTransListenerKey = (String) msg.getHeaders().get(RocketMqProducer.LISTENER_KEY_HEAD_NAME);
        LocalTransactionAdapter listener = LocalTransactionAdapter
                .LOCAL_TRANSACTION_LISTENER
                .get(localTransListenerKey);
        if (listener == null) {
            // 没有获取到回调函数
            log.error("事务消息执行本地事务时,没有获取到回调函数, MQ中的消息已回滚!");
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        return listener.executeLocalTransaction(msg, arg);
    }

    /**
     * 供MQ查询本地事务状态
     *
     * @param msg 消息
     * @return {@link RocketMQLocalTransactionState }
     * @author liu
     * @date 2023/11/23
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        String localTransListenerKey = (String) msg.getHeaders().get(RocketMqProducer.LISTENER_KEY_HEAD_NAME);
        LocalTransactionAdapter listener = LocalTransactionAdapter
                .LOCAL_TRANSACTION_LISTENER
                .get(localTransListenerKey);
        if (listener == null) {
            // 没有获取到回调函数
            log.error("RocketMQ 检查本事务状态没有获取到回调函数, MQ中的消息已回滚!");
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        return listener.checkLocalTransaction(msg);
    }
}

2.3 注册自定义的监听

package com.example.model.rocketmqdemo.mq.product.transactional;

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;

import java.util.concurrent.ConcurrentHashMap;

/**
 * @author liu
 * @date 2023/11/23
 * description:
 */
@Slf4j
@SuppressWarnings("rawtypes")
public abstract class LocalTransactionAdapter {
    public static final ConcurrentHashMap<String, LocalTransactionAdapter> LOCAL_TRANSACTION_LISTENER = new ConcurrentHashMap<>();


    public abstract RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg);


    public abstract RocketMQLocalTransactionState checkLocalTransaction(Message msg);

    public abstract String getLocalTransListenerKey();


    public LocalTransactionAdapter() {
        LOCAL_TRANSACTION_LISTENER.put(getLocalTransListenerKey(), this);
    }

}

package com.example.model.rocketmqdemo.mq.product.transactional.listener;

import com.example.model.rocketmqdemo.controller.TestController;
import com.example.model.rocketmqdemo.mq.product.transactional.LocalTransactionAdapter;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

/**
 * @author liu
 * @date 2023/11/23
 * description:
 */
@Slf4j
@Component
@SuppressWarnings("rawtypes")
public class Demo1 extends LocalTransactionAdapter {


    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        log.info("-------------------------Demo1-executeLocalTransaction");
        // 远程调用 1 --> 查询操作
        try {
            // 远程调用 2 --> 更新操作
            // 如果远程调用2 出问题了 --> 下游系统不需要回滚(返回 return RocketMQLocalTransactionState.ROLLBACK;)
            // 但是需要响应前端异常, 这时候这里的异常, 外面是感知不到的, 可以将异常赋值给参数-->
            int i= 1 / 0;
        } catch (Exception e) {
            TestController.Args testArg = (TestController.Args)arg;
            testArg.setE(e);
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        // 本地事务
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    @Override
    public String getLocalTransListenerKey() {
        return "demo1";
    }
}

package com.example.model.rocketmqdemo.mq.product.transactional.listener;

import com.example.model.rocketmqdemo.mq.product.transactional.LocalTransactionAdapter;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

/**
 * @author liu
 * @date 2023/11/23
 * description:
 */
@Slf4j
@Component
@SuppressWarnings("rawtypes")
public class Demo2 extends LocalTransactionAdapter {
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        log.info("----------------------------------Demo2-executeLocalTransaction");
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    @Override
    public String getLocalTransListenerKey() {
        return "demo2";
    }
}

2.4 消费者

package com.example.model.rocketmqdemo.mq.consumer;

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * @author liu
 * @date 2023/11/23
 * description: 生产者消息监听器
 *
 */
@Slf4j
@Component
@RocketMQMessageListener(consumerGroup = "consomer",topic = "global_transactional_topic")
public class RocketMQTransationListener implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费消息 事务消息："+ message);
    }
}

3 Go的实现

// Package order
// Author 
// Date 2023/11/21
// Description 业务层代码
package order

import (
	"context"
	"encoding/json"
	"fmt"
	"gitee.com/liu_zy_developer/go_order_service/config"
	"gitee.com/liu_zy_developer/go_order_service/dao/mq"
	"gitee.com/liu_zy_developer/go_order_service/dao/mysql"
	"gitee.com/liu_zy_developer/go_order_service/model"
	"gitee.com/liu_zy_developer/go_order_service/proto"
	"gitee.com/liu_zy_developer/go_order_service/rpc"
	"gitee.com/liu_zy_developer/go_order_service/third_party/snowflake"
	"github.com/apache/rocketmq-client-go/v2"
	"github.com/apache/rocketmq-client-go/v2/primitive"
	"github.com/apache/rocketmq-client-go/v2/producer"
	"go.uber.org/zap"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"gorm.io/gorm"
	"strconv"
)

// OrderEntity 自定义结构体，实现了两个方法, 本地事务的方法和查询本地事务的方法
// 发送事务消息的时候 RocketMQ 会自动根据情况调用那两个方法
type OrderEntity struct {
	OrderId int64           // 订单号
	Param   *proto.OrderReq // RPC远程调用的参数
	err     error           // 异常信息, 记录本地事务是否执行成功
}

// ExecuteLocalTransaction 执行本地事务
// 当发送half-message成功之后, 这个方法就会被执行
func (o *OrderEntity) ExecuteLocalTransaction(*primitive.Message) primitive.LocalTransactionState {
	fmt.Println("in ExecuteLocalTransaction...")
	// 校验参数, 用于执行RPC调用的参数为空, 必要参数为空, 不能执行后续流程
	if o.Param == nil {
		zap.L().Error("ExecuteLocalTransaction param is nil")
		o.err = status.Error(codes.Internal, "invalid OrderEntity") // 给结构体中的异常赋值, 调用方可以拿到, 用于判断本地是否执行是否成功, 有没有出现问题
		return primitive.RollbackMessageState                         
	}
	param := o.Param
	ctx := context.Background()
	// 1. 查询商品金额(正常情况是请求营销中心, 但是本示例没有营销中心) ==> RPC连接 goods_service
	goodsDatail, err := rpc.GoodsCli.GetGoodsDetail(ctx, &proto.GetGoodsDetailReq{
		xxxx: param.GoodsId
	})
	if err != nil {
		zap.L().Error("GoodsCli.GetGoodsDetail failed", zap.Error(err))
		// 查询商品价格失败
		o.err = status.Error(codes.Internal, err.Error())
		// 此时此次事务中的所有远程调用还未执行操作, 哪怕是本次操作, 因为远程返回错误, 远程的本地事务也会回滚, 查询请求也不涉及事务, MQ没必要发送回滚消息
		return primitive.RollbackMessageState
	}

	payAmountStr := goodsDatail.Price
	payAmount, _ := strconv.ParseInt(payAmountStr, 10, 64)

	// 2. 库存校验以及扣减 ==> RPC连接 stock_service
	_, err = rpc.StockCli.ReduceStock(ctx, &proto.GoodsStockInfo{
		OrderId: o.OrderId,
		GoodsId: o.Param.GoodsId,
		Num:     o.Param.Num,
	})
	if err != nil {
		// 库存扣减失败，丢弃half-message, 上一步操作是查询操作, 不涉及回滚事务
		zap.L().Error("StockCli.ReduceStock failed", zap.Error(err))
		o.err = status.Error(codes.Internal, "ReduceStock failed")
		return primitive.RollbackMessageState // 丢弃半消息
	}

	// 代码能执行到这里说明 扣减库存成功了，
	// 从这里开始如果本地事务执行失败就需要回滚库存
	// 3. 创建订单
	// 创建订单对象
	orderData := model.Order{
		OrderId:        o.OrderId,
		UserId:         param.UserId,
		PayAmount:      payAmount,
		ReceiveAddress: param.Address,
		ReceiveName:    param.Name,
		ReceivePhone:   param.Phone,
		Status:         100, // 待支付
	}
	// 创建订单详情对象
	orderDetail := model.OrderDetail{
		OrderId: o.OrderId,
		UserId:  param.UserId,
		GoodsId: param.GoodsId,
		Num:     param.Num,
	}
	// 在本地事务创建订单和订单详情记录
	err = mysql.CreateOrderWithTransaction(ctx, &orderData, &orderDetail)
	if err != nil {
		// 本地事务执行失败了 ==> 需要回滚上面的操作
		// 本地事务执行失败了，上一步已经库存扣减成功
		// 就需要将库存回滚的消息投递出去，小游根据消息进行库存回滚
		zap.L().Error("CreateOrderWithTransation failed", zap.Error(err))
		return primitive.CommitMessageState // 将之前发送的hal-message 提交, 下游系统收到消息之后会进行回滚, 这一步不需要记录error了, 也就是给o.err赋值
	}

	// 发送延迟消息 --> 放在这里不合适, 提到外面去
	// 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
	data := model.OrderGoodsStockInfo{
		OrderId: o.OrderId,
		GoodsId: param.GoodsId,
		Num:     param.Num,
	}
	b, _ := json.Marshal(data)
	msg := primitive.NewMessage("xx_pay_timeout", b)
	msg.WithDelayTimeLevel(3) // 设置延时等级
	_, err = mq.Producer.SendSync(context.Background(), msg)
	if err != nil {
		// 发送延时消息失败
		zap.L().Error("send delay msg failed", zap.Error(err))
		return primitive.CommitMessageState
	}

	// 走到这里说明本地事务执行成功 ==> 丢弃掉MQ中的半消息
	return primitive.RollbackMessageState
}

// CheckLocalTransaction 检查本地事务
// 当hale-message 没有响应时, broker 会回查本地事务的状态, 此时这个方法会被执行
func (o *OrderEntity) CheckLocalTransaction(*primitive.MessageExt) primitive.LocalTransactionState {
	// 检查本地状态是否创建成功订单
	_, err := mysql.QueryOrder(context.Background(), o.OrderId)
	// 需要再查询订单详情表
	if err == gorm.ErrRecordNotFound {
		// 没查询到说明订单创建失败，需要回滚库存
		return primitive.CommitMessageState
	}
	return primitive.RollbackMessageState
}

// Create 创建订单 利用RocketMQ的半消息实现分布式事务
func Create(ctx context.Context, param *proto.OrderReq) error {
	// 1. 生成单号
	orderId := snowflake.GenID()

	//2. 发送事务half-message
	// 2.1 创还能事务监听器, 用于执行本地事务
	orderEntity := &OrderEntity{
		OrderId: orderId,
		Param:   param,
	}
	// 2.2 创建事务消息生产者
	p, err := rocketmq.NewTransactionProducer(
		orderEntity, // 事务监听器, 用于执行本地事务
		producer.WithNsResovler(primitive.NewPassthroughResolver([]string{"127.0.0.1:9876"})), // 配置nameserver
		producer.WithRetry(2),                 // 重试次数
		producer.WithGroupName("order_srv_1"), // 生产者组
	)
	if err != nil {
		zap.L().Error("NewTransactionProducer failed", zap.Error(err))
		return status.Error(codes.Internal, "NewTransactionProducer failed") // gPRC的错误响应
	}
	// 2.3 启动生产者
	p.Start()

	// 2.4 封装回滚消息 orderId GoodsId num
	data := model.OrderGoodsStockInfo{
		OrderId: orderId,
		GoodsId: param.GoodsId,
		Num:     param.Num,
	}
	b, _ := json.Marshal(data)
	msg := &primitive.Message{
		Topic: config.Conf.RocketMqConfig.Topic.StockRollback, // xx_stock_rollback
		Body:  b,
	}
	// 2.5 发送事务消息
	res, err := p.SendMessageInTransaction(context.Background(), msg)
	if err != nil {
		zap.L().Error("SendMessageInTransaction failed", zap.Error(err))
		return status.Error(codes.Internal, "create order failed")
	}
	zap.L().Info("p.SendMessageInTransaction success", zap.Any("res", res))

	// 2.6 校验事务消息是否发送成功
	// 如果回滚库存的消息被投递出去（commit）说明本地事务里面手动出发了回滚操作，也就是创建订单失败
	if res.State == primitive.CommitMessageState {
		return status.Error(codes.Internal, "create order failed")
	}

	// 3 校验本地事务是否执行成功
	// 其他内部错误
	if orderEntity.err != nil {
		return orderEntity.err
	}
	return nil
}