五阶段--分布式事务（八）Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务

最新推荐文章于 2024-05-01 16:49:56 发布
最新推荐文章于 2024-05-01 16:49:56 发布
阅读量198 收藏
点赞数
文章标签： spring maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58580280/article/details/120483765
版权

1 导入订单业务模块

1. seata-at/无事务版本.zip 解压到 rocketmq-dtx 工程目录

2. 在idea通过maven导入pom文件的方式导入7个模块

2 在订单添加事务消息发送--生产者

1. order-parent父工程的pom.xml 添加 rocketmq 依赖

       <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

2. order工程的.yml配置文件添加 rocketmq 连接 name server

rocketmq:   #连接rocketmq中 name server服务
  name-server: 192.168.64.141:9876
  producer:  #生产者组名
    group: order-group

3. order.sql添加新的表 tx_table, 执行dbinit工程创建该表,用来保存事务执行状态,应对事务回查

CREATE TABLE tx_table(
            `xid` char(32) PRIMARY KEY COMMENT '事务id',
            `status` int COMMENT '0-提交，1-回滚，2-未知',
            `created_at` BIGINT UNSIGNED NOT NULL COMMENT '创建时间'
);

4.order工程下entity包添加实体类:TxInfo

package cn.tedu.order.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class TxInfo {
    String xid;     //事务id
    Integer status; //事务状态,成功/失败
    Long created;   //时间--毫秒值
}

5.order工程的mapper包下添加TxMapper

package cn.tedu.order.mapper;

import cn.tedu.order.entity.TxInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface TxMapper extends BaseMapper<TxInfo> {
    // 插入 insert()
    // 查询 selectById()
}
  • resources包下的mapper包添加TxMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.tedu.order.mapper.TxMapper" >
    <resultMap id="BaseResultMap" type="cn.tedu.order.entity.TxInfo" >
        <id column="xid" property="xid" jdbcType="CHAR" />
        <result column="created_at" property="created" jdbcType="BIGINT" />
        <result column="status" property="status" jdbcType="INTEGER"/>
    </resultMap>

    <insert id="insert">
        INSERT INTO `tx_table`(`xid`,`created_at`,`status`) VALUES(#{xid},#{created},#{status});
    </insert>
    <select id="selectById" resultMap="BaseResultMap">
        SELECT `xid`,`created_at`,`status` FROM tx_table WHERE xid=#{xid};
    </select>
</mapper>

6.order工程entity包下添加消息数据封装对象: AccountMessage

package cn.tedu.order.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

//封装发送给账户的消息数据
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AccountMessage {
    private Long userId;
    private BigDecimal money;
    private String xid;  //事务id

}

7.order工程添加util包并添加处理Json的工具类: JsonUtil

package cn.tedu.order.util;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class JsonUtil {
    private static ObjectMapper mapper;
    private static JsonInclude.Include DEFAULT_PROPERTY_INCLUSION = JsonInclude.Include.NON_DEFAULT;
    private static boolean IS_ENABLE_INDENT_OUTPUT = false;
    private static String CSV_DEFAULT_COLUMN_SEPARATOR = ",";
    static {
        try {
            initMapper();
            configPropertyInclusion();
            configIndentOutput();
            configCommon();
        } catch (Exception e) {
            log.error("jackson config error", e);
        }
    }

    private static void initMapper() {
        mapper = new ObjectMapper();
    }

    private static void configCommon() {
        config(mapper);
    }

    private static void configPropertyInclusion() {
        mapper.setSerializationInclusion(DEFAULT_PROPERTY_INCLUSION);
    }

    private static void configIndentOutput() {
        mapper.configure(SerializationFeature.INDENT_OUTPUT, IS_ENABLE_INDENT_OUTPUT);
    }

    private static void config(ObjectMapper objectMapper) {
        objectMapper.enable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);
        objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        objectMapper.enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
        objectMapper.enable(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY);
        objectMapper.enable(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS);
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        objectMapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
        objectMapper.disable(JsonGenerator.Feature.ESCAPE_NON_ASCII);
        objectMapper.enable(JsonGenerator.Feature.IGNORE_UNKNOWN);
        objectMapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        objectMapper.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);
        objectMapper.registerModule(new ParameterNamesModule());
        objectMapper.registerModule(new Jdk8Module());
        objectMapper.registerModule(new JavaTimeModule());
    }
    public static void setSerializationInclusion(JsonInclude.Include inclusion) {
        DEFAULT_PROPERTY_INCLUSION = inclusion;
        configPropertyInclusion();
    }

    public static void setIndentOutput(boolean isEnable) {
        IS_ENABLE_INDENT_OUTPUT = isEnable;
        configIndentOutput();
    }

    public static <V> V from(URL url, Class<V> c) {
        try {
            return mapper.readValue(url, c);
        } catch (IOException e) {
            log.error("jackson from error, url: {}, type: {}", url.getPath(), c, e);
            return null;
        }
    }

    public static <V> V from(InputStream inputStream, Class<V> c) {
        try {
            return mapper.readValue(inputStream, c);
        } catch (IOException e) {
            log.error("jackson from error, type: {}", c, e);
            return null;
        }
    }

    public static <V> V from(File file, Class<V> c) {
        try {
            return mapper.readValue(file, c);
        } catch (IOException e) {
            log.error("jackson from error, file path: {}, type: {}", file.getPath(), c, e);
            return null;
        }
    }

    public static <V> V from(Object jsonObj, Class<V> c) {
        try {
            return mapper.readValue(jsonObj.toString(), c);
        } catch (IOException e) {
            log.error("jackson from error, json: {}, type: {}", jsonObj.toString(), c, e);
            return null;
        }
    }

    public static <V> V from(String json, Class<V> c) {
        try {
            return mapper.readValue(json, c);
        } catch (IOException e) {
            log.error("jackson from error, json: {}, type: {}", json, c, e);
            return null;
        }
    }

    public static <V> V from(URL url, TypeReference<V> type) {
        try {
            return mapper.readValue(url, type);
        } catch (IOException e) {
            log.error("jackson from error, url: {}, type: {}", url.getPath(), type, e);
            return null;
        }
    }

    public static <V> V from(InputStream inputStream, TypeReference<V> type) {
        try {
            return mapper.readValue(inputStream, type);
        } catch (IOException e) {
            log.error("jackson from error, type: {}", type, e);
            return null;
        }
    }

    public static <V> V from(File file, TypeReference<V> type) {
        try {
            return mapper.readValue(file, type);
        } catch (IOException e) {
            log.error("jackson from error, file path: {}, type: {}", file.getPath(), type, e);
            return null;
        }
    }

    public static <V> V from(Object jsonObj, TypeReference<V> type) {
        try {
            return mapper.readValue(jsonObj.toString(), type);
        } catch (IOException e) {
            log.error("jackson from error, json: {}, type: {}", jsonObj.toString(), type, e);
            return null;
        }
    }

    public static <V> V from(String json, TypeReference<V> type) {
        try {
            return mapper.readValue(json, type);
        } catch (IOException e) {
            log.error("jackson from error, json: {}, type: {}", json, type, e);
            return null;
        }
    }

    public static <V> String to(List<V> list) {
        try {
            return mapper.writeValueAsString(list);
        } catch (JsonProcessingException e) {
            log.error("jackson to error, obj: {}", list, e);
            return null;
        }
    }

    public static <V> String to(V v) {
        try {
            return mapper.writeValueAsString(v);
        } catch (JsonProcessingException e) {
            log.error("jackson to error, obj: {}", v, e);
            return null;
        }
    }

    public static <V> void toFile(String path, List<V> list) {
        try (Writer writer = new FileWriter(new File(path), true)) {
            mapper.writer().writeValues(writer).writeAll(list);
            writer.flush();
        } catch (Exception e) {
            log.error("jackson to file error, path: {}, list: {}", path, list, e);
        }
    }

    public static <V> void toFile(String path, V v) {
        try (Writer writer = new FileWriter(new File(path), true)) {
            mapper.writer().writeValues(writer).write(v);
            writer.flush();
        } catch (Exception e) {
            log.error("jackson to file error, path: {}, obj: {}", path, v, e);
        }
    }

    public static String getString(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).asText();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get string error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static Integer getInt(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).intValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get int error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static Long getLong(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).longValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get long error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static Double getDouble(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).doubleValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get double error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static BigInteger getBigInteger(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return new BigInteger(String.valueOf(0.00));
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).bigIntegerValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get biginteger error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static BigDecimal getBigDecimal(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).decimalValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get bigdecimal error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static boolean getBoolean(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return false;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).booleanValue();
            } else {
                return false;
            }
        } catch (IOException e) {
            log.error("jackson get boolean error, json: {}, key: {}", json, key, e);
            return false;
        }
    }

    public static byte[] getByte(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        try {
            JsonNode node = mapper.readTree(json);
            if (null != node) {
                return node.get(key).binaryValue();
            } else {
                return null;
            }
        } catch (IOException e) {
            log.error("jackson get byte error, json: {}, key: {}", json, key, e);
            return null;
        }
    }

    public static <T> ArrayList<T> getList(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        String string = getString(json, key);
        return from(string, new TypeReference<ArrayList<T>>() {});
    }

    public static <T> String add(String json, String key, T value) {
        try {
            JsonNode node = mapper.readTree(json);
            add(node, key, value);
            return node.toString();
        } catch (IOException e) {
            log.error("jackson add error, json: {}, key: {}, value: {}", json, key, value, e);
            return json;
        }
    }

    private static <T> void add(JsonNode jsonNode, String key, T value) {
        if (value instanceof String) {
            ((ObjectNode) jsonNode).put(key, (String) value);
        } else if (value instanceof Short) {
            ((ObjectNode) jsonNode).put(key, (Short) value);
        } else if (value instanceof Integer) {
            ((ObjectNode) jsonNode).put(key, (Integer) value);
        } else if (value instanceof Long) {
            ((ObjectNode) jsonNode).put(key, (Long) value);
        } else if (value instanceof Float) {
            ((ObjectNode) jsonNode).put(key, (Float) value);
        } else if (value instanceof Double) {
            ((ObjectNode) jsonNode).put(key, (Double) value);
        } else if (value instanceof BigDecimal) {
            ((ObjectNode) jsonNode).put(key, (BigDecimal) value);
        } else if (value instanceof BigInteger) {
            ((ObjectNode) jsonNode).put(key, (BigInteger) value);
        } else if (value instanceof Boolean) {
            ((ObjectNode) jsonNode).put(key, (Boolean) value);
        } else if (value instanceof byte[]) {
            ((ObjectNode) jsonNode).put(key, (byte[]) value);
        } else {
            ((ObjectNode) jsonNode).put(key, to(value));
        }
    }

    public static String remove(String json, String key) {
        try {
            JsonNode node = mapper.readTree(json);
            ((ObjectNode) node).remove(key);
            return node.toString();
        } catch (IOException e) {
            log.error("jackson remove error, json: {}, key: {}", json, key, e);
            return json;
        }
    }

    public static <T> String update(String json, String key, T value) {
        try {
            JsonNode node = mapper.readTree(json);
            ((ObjectNode) node).remove(key);
            add(node, key, value);
            return node.toString();
        } catch (IOException e) {
            log.error("jackson update error, json: {}, key: {}, value: {}", json, key, value, e);
            return json;
        }
    }

    public static String format(String json) {
        try {
            JsonNode node = mapper.readTree(json);
            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(node);
        } catch (IOException e) {
            log.error("jackson format json error, json: {}", json, e);
            return json;
        }
    }

    public static boolean isJson(String json) {
        try {
            mapper.readTree(json);
            return true;
        } catch (Exception e) {
            log.error("jackson check json error, json: {}", json, e);
            return false;
        }
    }

    private static InputStream getResourceStream(String name) {
        return JsonUtil.class.getClassLoader().getResourceAsStream(name);
    }

    private static InputStreamReader getResourceReader(InputStream inputStream) {
        if (null == inputStream) {
            return null;
        }
        return new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    }
}

8.修改业务代码,不直接存储订单,而是改为发送事务消息

  • 调整OrderServiceImpl
package cn.tedu.order.service;

import cn.tedu.order.entity.AccountMessage;
import cn.tedu.order.entity.Order;
import cn.tedu.order.feign.AccountClient;
import cn.tedu.order.feign.EasyIdClient;
import cn.tedu.order.feign.StorageClient;
import cn.tedu.order.mapper.OrderMapper;
import cn.tedu.order.util.JsonUtil;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import java.util.Random;
import java.util.UUID;

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private EasyIdClient easyIdClient;
    @Autowired
    private RocketMQTemplate t;

    @Override
    public void create(Order order){
        // "xxx-xxx-xxx-xxx-xxx" 有4个减号,共36位
        //这里把减号去掉,保留32位
        String xid = UUID.randomUUID().toString().replace("-","");
        AccountMessage am =
                new AccountMessage(order.getUserId(), order.getMoney(), xid);
        // am --> json
        String json = JsonUtil.to(am);
        /** spring封装的通用message对象,payload会自动被转换成 byte[]*/
        Message<String> message = MessageBuilder.withPayload(json).build();
        //发送事务消息
        /*如果添加标签,格式: "orderTopic:TagA"*/
        //t.sendMessageInTransaction("orderTopic",message,业务数据参数);
        t.sendMessageInTransaction("orderTopic",message,order);
    }
    // 在监听器中会调用这个业务方法
    public void doCreate(Order order) {
        //  远程调用发号器，获取订单id
        String s = easyIdClient.nextId("order_business");
        Long orderId = Long.valueOf(s);

        order.setId(orderId);
        orderMapper.create(order);//保存订单

    }
}

9.实现监听器,在监听器中执行本地事务,完成订单存储,在监听器中实现事务状态回查--可以专门写个类也可以在订单实现类添加

package cn.tedu.order.service;

import cn.tedu.order.entity.AccountMessage;
import cn.tedu.order.entity.Order;
import cn.tedu.order.entity.TxInfo;
import cn.tedu.order.feign.AccountClient;
import cn.tedu.order.feign.EasyIdClient;
import cn.tedu.order.feign.StorageClient;
import cn.tedu.order.mapper.OrderMapper;
import cn.tedu.order.mapper.TxMapper;
import cn.tedu.order.util.JsonUtil;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Random;
import java.util.UUID;
@RocketMQTransactionListener //监听器注解
@Service
public class OrderServiceImpl implements OrderService, RocketMQLocalTransactionListener {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private EasyIdClient easyIdClient;
    @Autowired
    private RocketMQTemplate t;
    @Autowired
    private TxMapper txMapper;

    @Override
    public void create(Order order){
        // "xxx-xxx-xxx-xxx-xxx" 有4个减号,共36位
        //这里把减号去掉,保留32位
        String xid = UUID.randomUUID().toString().replace("-","");
        AccountMessage am =
                new AccountMessage(order.getUserId(), order.getMoney(), xid);
        // am --> json
        String json = JsonUtil.to(am);
        /** spring封装的通用message对象,payload会自动被转换成 byte[]*/
        Message<String> message = MessageBuilder.withPayload(json).build();
        //发送事务消息
        /*如果添加标签,格式: "orderTopic:TagA"*/
        //t.sendMessageInTransaction("orderTopic",message,业务数据参数);
        t.sendMessageInTransaction("orderTopic",message,order);
    }
    // 在监听器中会调用这个业务方法
    public void doCreate(Order order) {
        //  远程调用发号器，获取订单id
        String s = easyIdClient.nextId("order_business");
        Long orderId = Long.valueOf(s);

        order.setId(orderId);
        orderMapper.create(order);//保存订单
    }

    @Transactional
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        RocketMQLocalTransactionState state;  //用于返回
        int status; //用于存储到数据库

        try {
            Order order = (Order) o;
            doCreate(order);
            state=RocketMQLocalTransactionState.COMMIT;
            status=0; //代表提交
        } catch (Exception e) {
            e.printStackTrace();
            state=RocketMQLocalTransactionState.ROLLBACK;
            status=1; //代表回滚
        }
        // TxInfo 封装事务状态
        String json = new String((byte[]) message.getPayload());
        // {"xid":"33d3d2d", "userId":7,....}
        String xid = JsonUtil.getString(json, "xid");//xid从消息队列中取出来
        TxInfo txInfo = new TxInfo(xid, status, System.currentTimeMillis());
        txMapper.insert(txInfo);
        return state;
    }
    //在监听器中实现事务状态回查
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        // TxInfo 封装事务状态
        String json = new String((byte[]) message.getPayload());
        // {"xid":"33d3d2d", "userId":7,....}
        String xid = JsonUtil.getString(json, "xid");//xid从消息队列中取出来
        TxInfo txInfo = txMapper.selectById(xid);
        if (txInfo == null) {
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        switch (txInfo.getStatus()) {
            case 0: return RocketMQLocalTransactionState.COMMIT;
            case 1: return RocketMQLocalTransactionState.ROLLBACK;
            default: return RocketMQLocalTransactionState.UNKNOWN;
        }
    }
}

10. 启动订单项目进行测试

按顺序启动项目：

  1. Eureka
  2. Easy Id Generator
  3. Order

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

观察控制台日志：

3 Account账户接收消息

1.账户配置文件.yml配置rocketmq连接

2.新建消费者类

package cn.tedu.account;

import cn.tedu.account.entity.AccountMessage;
import cn.tedu.account.service.AccountService;
import cn.tedu.account.util.JsonUtil;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@RocketMQMessageListener(topic = "orderTopic",consumerGroup = "account-group")//从orderTopic接收消息
@Component
public class AccountConsumer implements RocketMQListener<String> {
    @Autowired
    private AccountService accountService;

    @Override
    public void onMessage(String json) {///从orderTopic接收消息
        // json --> AccountMessage
        AccountMessage am = JsonUtil.from(json,AccountMessage.class);
        accountService.decrease(am.getUserId(), am.getMoney());
    }
}

3.entity包添加封装消息对象

package cn.tedu.account.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

//封装发送给账户的消息数据
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AccountMessage {
    private Long userId;
    private BigDecimal money;
    private String xid;  //事务id

}

4.util包添加转换Json的工具类,可以从order工程的util包复制

5.按顺序启动测试

  1. Eureka
  2. Easy Id Generator
  3. Account
  4. Order
  • 查看账户控制台:account 项目启动时，会立即从 Rocketmq 收到消息，执行账户扣减业务：

心猿意码~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot2.X基于可靠消息rabbitmq最终一致性分布式事务+分布式全局唯一ID生成器
08-04
1、代码未实现部分      a、积分、红包相关代码未实现，按照下单逻辑操作即可      b、quatz调度未实现，这个相当简单，可以通过dubbo等rpc方式、或者httpclient方式进行远程调度，相关代码：            https://download.csdn.net/download/qq_22049773/12540998      c、其他均已实现      d、分布式全局ID生成器，ID生成非绝对递增有序，是趋向有序，这一点如果能接受，可以直接copy使用 2、事务回滚机制说明        a、每个消费端的事务处理都由本地事务负责        b、基于下单队列消费端临时表，查询红包、积分两个队列消费端的临时表中该订单的处理的状态，如果全部为消费成功，则更新业务订单表中的订单状态由  下单中  --》 待付款并删除所有临时表数据，如果非全部消费成功，则将定性为异常单并写入补单队列，并删除所有临时表数据。该逻辑有定时调度完成。
一文讲透微服务下如何保证事务的一致性
Hello World
01-17 1949
文章目录 从本地事务到分布式事务的演变 强一致性解决方案2.1. 二阶段提交协议2.2. 三阶段提交协议 最终一致性解决方案3.1. TCC 模式3.2. 补偿模式3.3. 可靠事件模式 开源项目的分布式事务实现解读4.1. RocketMQ4.2. ServiceComb 1.从本地事务到分布式事务的演变 什么是事务？回答这个问题之前，我们先来看一个经典的场景：支付宝等交易平台的转账。假...
分布式事务轻量化解决方案
夏天吹雪的博客
08-19 275
背景：遇到一个分布式事务问题，A->B,A->C,A->D,几个远程服务需要在一个事务里面。 由于业务量小，所以达到最终一致性即可，如果引入其他分布式事务框架，太重量级。 方案： 1.消息重发机制 2.spring-retry重试框架 官网地址：https://github.com/spring-projects/spring-retry ...
yy-job分布式链式异步任务组件，分布式事务之最终一致性的完美方案
lilawen0823的博客
10-25 676
一个轻量级的分布式异步任务组件，分布式事务之最终一致性的完美解决方案，spring-boot项目直接引入即可使用，无需部署或者依赖任何第三方的中间件
.Net Core with 微服务 - 可靠消息最终一致性分布式事务
dotNET跨平台
09-24 402
前面我们讲了分布式事务的2PC、3PCTCC 的原理。这些事务其实都在尽力的模拟数据库的事务，我们可以简单的认为他们是一个同步行的事务。特别是 2PC,3PC 他们完全利用数据库的事务能力...
分布式事务（八）Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
qq_54781283的博客
06-15 432
搭建单机 Rocketmq 服务器笔记： 《RocketMQ (一) 安装》搭建双主双从同步复制 Rocketmq 服务器笔记： 《RocketMQ (二) 双主双从同步复制集群方案》Rocketmq事务消息笔记： 《RocketMQ 发送事务消息原理分析和代码实现》新建 Empty Project： 工程命名为 ，存放到任意文件夹下：压缩文件中的 7 个项目目录解压缩到 目录：在 idea 中按两下 键，搜索 ，打开 maven 工具： 然后选择 工程目录下的 7 个项目的 导入：Rocketm
Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
望山。
11-01 298
文章目录一.订单使用事务消息，异步调用账户1.父项目添加spring Rocketmq依赖2.yml配置rocket连接和生产者组名3.添加新的数据表tx_table,用来存储事务的执行状态4.添加实体类TxInfo和TxMapper5.新建AccountMessage，用来封装发给账户的调用信息：userId，money，txId6.工具类：JsonUtil7.OrderServiceImpl发送事务消息8.实现事务监听器9.测试二.账户接收消息，扣减账户1.依赖2.yml配置name server3.A
五阶段--分布式事务--Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
weixin_58580280的博客
09-24 66
一安装搭建 Rocketmq 服务器 搭建单机 Rocketmq 服务器笔记： 《RocketMQ (一) 安装》 搭建双主双从同步复制 Rocketmq 服务器笔记： 《RocketMQ (二) 双主双从同步复制集群方案》 二基于 Rocketmq 可靠消息的分布式事务方案原理 Rocketmq事务消息笔记： 《RocketMQ 发送事务消息原理分析和代码实现》 ...
基于SpringCloud实现的电影院购票系统设计-微服务-分布式
10-30
基于SpringCloud实现的电影院购票系统设计-微服务-分布式+适用于毕设，可用于毕设参考和练习，也可用于其它。 项目资源适用于大三、大四的同学，可用于毕设参考和练习，也可用于商用。 软件开发环境及开发工具： ...
基于SpringCloud实现的图书馆管理系统的设计与实现-微服务-分布式
10-30
基于SpringCloud实现的图书馆管理系统的设计与实现-微服务-分布式+适用于毕设，可用于毕设参考和练习，也可用于其它。 项目资源适用于大三、大四的同学，可用于毕设参考和练习，也可用于商用。 软件开发环境及开发...
基于SpringCloud实现的家教信息平台系统的设计与实现-微服务-分布式
10-30
基于SpringCloud实现的家教信息平台系统的设计与实现-微服务-分布式+适用于毕设，可用于毕设参考和练习，也可用于其它。 项目资源适用于大三、大四的同学，可用于毕设参考和练习，也可用于商用。 软件开发环境及开发...
基于Vue+SpringCloud博客的设计与实现-微服务-分布式.zip
最新发布
05-03
基于Vue+SpringCloud博客的设计与实现---微服务基础版本组件1.0版本 博客采用Vue+SpringCloud前后分离的方式。博客采用了高可用Eureka（可以替换成其他微服务组件）以及高可用Zuul，使用以Es搜索引擎作为Zpkin的存储...
whc的毕业设计：基于Vue SpringCloud博客的设计与实现-微服务-分布式
03-21
whc的毕业设计：基于Vue SpringCloud博客的设计与实现-微服务-分布式
RocketMQ (五)Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
꯭ 瞎꯭扯꯭蛋꯭的博客
11-05 142
Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
阿里巴巴云原生的博客
04-29 1046
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
SpringBoot中实现发送邮件
hac1322的博客
04-30 751
当你添加了spring-boot-starter-mail依赖后，Spring Boot会自动配置JavaMailSender实例，并根据application.yml文件中的属性来配置这个实例。你可以直接在需要发送邮件的地方通过@Autowired注解将JavaMailSender实例注入到你的类中，然后使用它来发送邮件。：首先，需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。，简化了在Spring Boot应用程序中发送电子邮件的设置过程。Spring Boot的。
SpringBoot指标监控
刘浩琦的博客
05-01 433
SpringBoot指标监控添加Actuator功能SpringBoot指标监控添加Actuator功能。
Spring Cloud+Spring Boot+Nacos+Dubbo+mybatis plus+RocketMQ+Seata+Sentinel
05-10
Seata是阿里巴巴开源的一个分布式事务解决方案，它提供了全局事务管理、分布式锁、数据源代理等功能，可以保证分布式系统的数据一致性和事务的可靠性。 Sentinel是阿里巴巴开源的一个流量控制和服务降级框架，它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值