SpringBoot集成RocketMQ

已于 2024-09-14 14:36:27 修改
阅读量2.8k 收藏 27
点赞数 21
分类专栏： 消息队列 文章标签： rocketmq
于 2024-09-13 02:25:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_15752347/article/details/142105622
版权

一、软件版本

  • jdk 1.8
  • RocketMQ 4.4.0
  • SpringBoot 2.3.2.RELEASE

二、步骤分析

2.1 消息发送者步骤分析

1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer

2.2 消息消费者步骤分析

1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer

三、导入MQ客户端依赖

我们在Pom文件中导入对应的依赖

<!-- rocketmq -->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.4.0</version>
</dependency>
 <!-- lombok -->
<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <scope>provided</scope>
 </dependency>

四、消息发送示例

4.1 基本样例

4.1.1 消息发送

发送同步消息

这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

/**
 * 发送同步消息
 */
public class SyncProducer {
    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
        // 2.设置NameServer的地址
        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.128:9876");
        // 3.启动Producer实例
        producer.start();
        for (int i = 0; i < 10; i++) {
            // 4.创建消息，并指定Topic，Tag和消息体
            Message msg = new Message("testTopic" /* Topic */,
                    "OneTag" /* Tag */,
                    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
            );
            // 5.发送消息到一个Broker
            SendResult sendResult = producer.send(msg);
            // 通过sendResult返回消息是否成功送达
            System.out.printf("%s%n", sendResult);
        }
        // 6.如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

发送成功截图如下
在这里插入图片描述

发送异步消息

异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class AsyncProducer {
	public static void main(String[] args) throws Exception {
    	// 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("group1");
    	// 设置NameServer的地址
        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
    	// 启动Producer实例
        producer.start();
        //producer.setRetryTimesWhenSendAsyncFailed(0);
    	for (int i = 0; i < 10; i++) {
            // 创建消息，并指定Topic，Tag和消息体
                Message msg = new Message("testTopic1",
                    "Tag2 ",
                    "OrderId888",
                    "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
                // SendCallback接收异步返回结果的回调

            producer.send(msg, new SendCallback() {
                    @Override
                    public void onSuccess(SendResult sendResult) {
                        System.out.println("发送结果"+sendResult);
                    }
                    @Override
                    public void onException(Throwable e) { 
      	              e.printStackTrace();
                    }
            	});
    	}
        //暂停一秒钟 防止出现Producer被提前关闭
        Thread.sleep(1000);
    	// 如果不再发送消息，关闭Producer实例。
    	producer.shutdown();
    }
}

发送成功截图如下
在这里插入图片描述

单向发送消息

这种方式主要用在不特别关心发送结果的场景，例如日志发送。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class OnewayProducer {
	public static void main(String[] args) throws Exception{
    	// 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("group1");
    	// 设置NameServer的地址
		producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
    	// 启动Producer实例
        producer.start();
    	for (int i = 0; i < 10; i++) {
        	// 创建消息，并指定Topic，Tag和消息体
        	Message msg = new Message("testTopic2" /* Topic */,
                "Tag1" /* Tag */,
                ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
        	);
        	// 发送单向消息，没有任何返回结果
        	producer.sendOneway(msg);
    	}
    	// 如果不再发送消息，关闭Producer实例。
    	producer.shutdown();
    }
}

发送成功截图如下
在这里插入图片描述

4.1.2 消费消息

RocketMQ的默认消费模式是负载均衡模式

负载均衡模式

负载均衡模式就是会自动的帮你选择消费者处理消息

public static void main(String[] args) throws Exception {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        // 指定Namesrv地址信息.
        consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        // 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
        consumer.subscribe("testTopic", "Tag1");
        //负载均衡模式消费
        consumer.setMessageModel(MessageModel.CLUSTERING);
        // 注册回调函数，处理消息
        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            msgs.forEach(temp -> {
                System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
            });
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        //启动消息者
        consumer.start();
        System.out.printf("消费端已启动---%n");
    }

启动两个客户端，消费成功截图如下

  • 客户端一
    在这里插入图片描述

  • 客户端二
    在这里插入图片描述

广播模式

广播模式就是所有的消费者都会收到一样的消息

public static void main(String[] args) throws Exception {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        // 指定Namesrv地址信息.
        consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        // 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
        consumer.subscribe("testTopic", "Tag1");
        //广播模式消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        // 注册回调函数，处理消息
        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            msgs.forEach(temp -> {
                System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
            });
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        //启动消息者
        consumer.start();
        System.out.printf("消费端已启动---%n");
    }

再次启动两个客户端，消费成功截图如下

  • 客户端一

在这里插入图片描述

  • 客户端二
  • 在这里插入图片描述

4.2 顺序消息

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。
在这里插入图片描述

4.2.1 顺序消费生产

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue; 

import java.util.List;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        // 2.设置NameServer的地址
        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        // 3.启动Producer实例
        producer.start();
        //构建消息集合
        List<OrderStep> orderStepList = OrderStep.buildOrders();
        for (int i = 0; i < orderStepList.size(); i++) {
            String body = orderStepList.get(i) + "";
            Message msg = new Message("orderTopic", "Order", "i" + i, body.getBytes());
            /**
             * 参数一：消息对象
             * 参数二：消息队列的选择器
             * 参数三：选择队列的业务标识（订单id）
             */
            SendResult sendResult =  producer.send(msg, new MessageQueueSelector() {
                /**
                 *
                 * @param list 队列集合
                 * @param message 消息对象
                 * @param o 业务标识参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    long orderId = (long)o;
                    long index = orderId % list.size();
                    return list.get((int)index);
                }
            }, orderStepList.get(i).getOrderId());
            System.out.println(String.format("返回状态为:%s, 队列id为:%d, body数据为:%s",
                    sendResult.getSendStatus(),
                    sendResult.getMessageQueue().getQueueId(),
                    body));
        }

        // 6.如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

4.2.2 顺序消费消费

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.message.MessageExt;



/**
* 顺序消息消费，带事务方式（应用可控制Offset什么时候提交）
*/
public class ConsumerInOrder {

   public static void main(String[] args) throws Exception {
       DefaultMQPushConsumer consumer = new  DefaultMQPushConsumer("group1");
       consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
       consumer.subscribe("orderTopic", "*");

       consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
           for (MessageExt msg : msgs) {
               // 可以看到每个queue有唯一的consume线程来消费, 订单对每个queue(分区)有序
               System.out.println("线程名称=" + Thread.currentThread().getName() + "队列id=" + msg.getQueueId() + ", 消息内容:" + new String(msg.getBody()));
           }
           return ConsumeOrderlyStatus.SUCCESS;
       });
       consumer.start();
       System.out.println("消费者启动 ");
   }
}

4.2.3 测试

我们启动 OrderProducer 和 ConsumerInOrder

OrderProducer

在这里插入图片描述

ConsumerInOrder

在这里插入图片描述

4.3 延迟消息

比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存

4.3.1 使用限制

现在RocketMq并不支持任意时间的延时，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18

private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";

4.3.2 消息消费者

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;


public class ScheduledMessageConsumer {
   public static void main(String[] args) throws Exception {
      // 实例化消费者
      DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ScheduledGroup1");
       consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
      // 订阅Topics
      consumer.subscribe("TestTopic", "*");
      // 注册消息监听者
      consumer.registerMessageListener((MessageListenerConcurrently) (messages, context) -> {
          for (MessageExt message : messages) {
              // 打印延迟时间
              System.out.println("接收到消息[msgId=" + message.getMsgId() + "] " + (System.currentTimeMillis() - message.getStoreTimestamp()) + "ms 延迟");
          }
          return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
      });
      // 启动消费者
      consumer.start();
      System.out.println("延迟消息消费者启动");
  }
}

4.3.3 消息发送者

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;

public class ScheduledMessageProducer {
   public static void main(String[] args) throws Exception {
      // 实例化一个生产者来产生延时消息
      DefaultMQProducer producer = new DefaultMQProducer("ScheduledGroup1");
       producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
      // 启动生产者
      producer.start();
      int totalMessagesToSend = 10;
      for (int i = 0; i < totalMessagesToSend; i++) {
          Message message = new Message("TestTopic", ("成功发送延迟消息 " + i).getBytes());
          // 设置延时等级3,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)
          message.setDelayTimeLevel(3);
          // 发送消息
          producer.send(message);
      }
       // 关闭生产者
      producer.shutdown();
  }
}

4.3.4 测试

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

4.4 批量消息

批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB。

import org.apache.rocketmq.client.producer.DefaultMQProducer; 
import org.apache.rocketmq.common.message.Message; 

import java.util.ArrayList;
import java.util.List;

public class BatchProducer {
    public static void main(String[] args) throws Exception {

        DefaultMQProducer producer = new DefaultMQProducer("BatchGroup");

        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");

        producer.start();
        List<Message> messages = new ArrayList<>();
        messages.add(new Message("batchTopic", "Tag1", "OrderID001", "Hello world 0".getBytes()));
        messages.add(new Message("batchTopic", "Tag1", "OrderID002", "Hello world 1".getBytes()));
        messages.add(new Message("batchTopic", "Tag1", "OrderID003", "Hello world 2".getBytes()));
        producer.send(messages);

        producer.shutdown();
    }
}

在这里插入图片描述

在这里插入图片描述

4.5 过滤消息

在大多数情况下，TAG是一个简单而有用的设计，其可以来选择您想要的消息。例如：

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");

消费者将接收包含TAGA或TAGB或TAGC的消息。但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。

在这种情况下，可以使用SQL表达式筛选消息。SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下，可以实现一些简单的逻辑。下面是一个例子：

------------
| message  |
|----------|  a > 5 AND b = 'abc'
| a = 10   |  --------------------> 找到
| b = 'abc'|
| c = true |
------------
------------
| message  |
|----------|   a > 5 AND b = 'abc'
| a = 1    |  --------------------> 未找到
| b = 'abc'|
| c = true |
------------

4.5.1 消息消费者

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;

public class FilterConsumer {
    public static void main(String[] args) throws Exception {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("FilterGroup");

        // 指定Namesrv地址信息.
        consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        // 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
        consumer.subscribe("testTopic", MessageSelector.bySql("i > 5"));
        //负载均衡模式消费
//        consumer.setMessageModel(MessageModel.BROADCASTING);
        // 注册回调函数，处理消息
        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            msgs.forEach(temp -> {
                System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
            });
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        //启动消息者
        consumer.start();
        System.out.printf("消费端已启动%n");
    }
}

4.5.2 消息生产者

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;


public class FilterProducer {
    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("FilterGroup");
        // 2.设置NameServer的地址
        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        // 3.启动Producer实例
        producer.start();
        for (int i = 0; i < 10; i++) {
            Message msg = new Message("testTopic",
                    "Tag1" ,
                    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)
            );
            // 设置一些属性
            msg.putUserProperty("i", String.valueOf(i));
            // 5.发送消息到一个Broker
            SendResult sendResult = producer.send(msg);
            // 通过sendResult返回消息是否成功送达
            System.out.printf("%s%n", sendResult);
        }
        // 6.如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

4.5.3 测试

在这里插入图片描述
消费者端只能接收到i>5的消息
在这里插入图片描述

4.6 事务消息

4.6.1流程分析

在这里插入图片描述
上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。

事务消息发送及提交

(1) 发送消息（half消息）。

(2) 服务端响应消息写入结果。

(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。

(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）

事务补偿

(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”

(2) Producer收到回查消息，检查回查消息对应的本地事务的状态

(3) 根据本地事务状态，重新Commit或者Rollback

其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。

事务消息状态

事务消息共有三种状态，提交状态、回滚状态、中间状态：

(1) TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
(2) TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
(3) TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。

4.6.2 发送事务消息

事务监听接口

当发送半消息成功时，我们使用 executeLocalTransaction 方法来执行本地事务。它返回前一节中提到的三个事务状态之一。checkLocalTranscation 方法用于检查本地事务状态，并回应消息队列的检查请求。它也是返回前一节中提到的三个事务状态之一。

public class TransactionListenerImpl implements TransactionListener {

    @Override
    public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        System.out.println("执行本地事务");
        if (StringUtils.equals("TagA", msg.getTags())) {
            return LocalTransactionState.COMMIT_MESSAGE;
        } else if (StringUtils.equals("TagB", msg.getTags())) {
            return LocalTransactionState.ROLLBACK_MESSAGE;
        } else {
            return LocalTransactionState.UNKNOW;
        }

    }

    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt msg) {
        System.out.println("MQ检查消息Tag【"+msg.getTags()+"】的本地事务执行结果");
        return LocalTransactionState.COMMIT_MESSAGE;
    }
}
事务性生产者

使用 TransactionMQProducer类创建生产者，并指定唯一的 ProducerGroup，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。回传的事务状态在请参考前一节。

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.io.UnsupportedEncodingException;
import java.util.concurrent.TimeUnit;

public class Producer {
    public static void main(String[] args) throws MQClientException, InterruptedException {
        //创建事务监听器
        TransactionListener transactionListener = new TransactionListenerImpl();
        //创建消息生产者
        TransactionMQProducer producer = new TransactionMQProducer("TransactionGroup");
        producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
        //生产者这是监听器
        producer.setTransactionListener(transactionListener);
        //启动消息生产者
        producer.start();
        String[] tags = new String[]{"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            try {
                Message msg = new Message("TransactionTopic", tags[i % tags.length], "KEY" + i,
                        ("Transaction RocketMQ Message" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
                SendResult sendResult = producer.sendMessageInTransaction(msg, null);
                System.out.printf("%s%n", sendResult);
                TimeUnit.SECONDS.sleep(1);
            } catch (MQClientException | UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产者端已启动");
        //producer.shutdown();
    }
}
测试

在这里插入图片描述

4.6.3 使用限制

  1. 事务消息不支持延时消息和批量消息。
  2. 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = transactionCheckMax ） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 AbstractTransactionCheckListener 类来修改这个行为。
  3. 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 transactionMsgTimeout 参数。
  4. 事务性消息可能不止一次被检查或消费。
  5. 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
  6. 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。
SpringBoot整合RocketMq，rocketMq
08-24
SpringBoot整合RocketMq
RocketMQ实战
qq_38900306的博客
01-25 406
1.新建开发环境 新建一个maven工程,在pom.xml文件中加入如下依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org
Spring Boot集成RocketMQ
BugMan的博客
04-26 1198
详解Spring Boot集成RocketMQ以及报错处理
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
qq_51447436的博客
08-21 6385
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
Springboot整合RocketMQ
GSON的博客
04-17 4301
顺序消息是 Apache RocketMQ 提供的一种高级消息类型，支持消费者按照发送消息的先后顺序获取消息，从而实现业务场景中的顺序处理。普通消息为 Apache RocketMQ 中最基础的消息 ， 普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有可靠传输的能力，且对消息的处理时机、处理顺序没有特别要求。封装了RocketMQ的生产者API，提供了一系列简单易用的方法，用于发送不同类型的消息， 后面的例子都会用到它。
SpringBoot集成RocketMQ示例代码
09-14
在SpringBoot集成RocketMQ的过程中，首先需要在项目中引入RocketMQ的依赖。这一过程可以通过编辑pom.xml文件来完成。在pom.xml文件中，添加相关的依赖配置，如rocketmq-spring-boot-starter，这是一个专为SpringBoot...
springboot集成rocketMQ，包含RocketMQ的部署以及测试，还有可视化的dashboard展示消息
最新发布
05-22
SpringBoot集成RocketMQ实践指南 SpringBoot作为Java领域的微服务开发框架，因其轻量级和快速开发的特点而受到广泛欢迎。RocketMQ作为阿里巴巴开源的消息中间件，广泛应用于高并发场景下的消息系统构建。本文将详细...
RocketMQ入坑指南（五）：SpringBoot集成RocketMQ和具体使用方式
u014374743的博客
02-23 3119
经过前面几章的学习，本章内容着重介绍了Springboot如何集成RocketMQ，如何发送普通消息、顺序消息、延时消息和事务消息，示例代码已上传优快云
SpringBoot集成rocketmq-client
Lyhdreamer的博客
03-05 1126
SpringBoot集成rocketmq-client的生产者和消费者demo
Springboot集成RocketMQ并配置access-key和secret-key鉴权
lq732830792的专栏
12-12 1772
4、启动RocketMQ，首先需运行mqnamesrv.cmd，再运行mqbroker.cmd，我为了方便启动，自己编写了一个启动.bat文件，每次只需运行启动.bat；2、RocketMQ鉴权问题，我知道了mq服务器地址，是不是谁都可以连上去呢，当然不是，这里我们可以添加鉴权，只有通过认证才能连接到RocketMQ。1、我这边为了测试，生产者和消费者都在同一个项目下，如果生产者和消费者不在同一个项目中，需像第二点步骤1和2导入依赖和配置mq地址。1、首先需要下载RocketMQ，下载地址。
SpringBoot整合RocketMQ
java程序员的蜕变之路
12-22 2363
1、实现SpringBoot与RocketMQ的整合2、解决在使用RocketMQ过程中可能遇到的一些问题3、介绍如何封装RocketMQ以便更好地使用。
【SpringBoot高级篇】SpringBoot集成RocketMQ消息队列
热门推荐
输入技术、输出想法
01-18 1万+
RocketMQ是阿里巴巴2016年MQ中间件，使用Java语言开发，在阿里内部，RocketMQ承接了例如“双11”等高并发场景的消息流转，能够处理万亿级别的消息。
Springboot整合RocketMq
xdscode的博客
07-30 1273
如果业务需要高性能、灵活的路由配置和对在线业务的响应时延有较高要求，可以考虑使用RocketMQ；如果业务需要高并发、高吞吐量、健壮稳定且易于使用和管理的消息队列产品，可以考虑使用RabbitMQ。@RocketMQMessageListener表示这是一个rocketmq的消费者，该注解只能用在类上面 topic：指定需要消费的队列。解决办法：https://blog.youkuaiyun.com/LLittleF/article/details/130689449。解释一下消费者中的代码。
spring boot 集成rocketmq
orton777的博客
08-02 8335
springboot rocketmq
RocketMQ（一）：Linux安装RocketMQ和常用命令
qq_28834355的博客
01-30 1376
下载安装 版本：4.8.0 下载地址：https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.8.0/rocketmq-all-4.8.0-source-release.zip 下载成功后，上传到 /opt 目录，并解压
SpringBoot 集成rocketmq
07-28
SpringBoot集成RocketMQ可以通过引入RocketMQ的相关依赖和配置来实现。在启动类中，需要添加@SpringBootApplication注解，并在main方法中调用SpringApplication.run方法来启动应用。同时，还需要在启动类中添加@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每天吃八顿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值