RocketMQ 发送消息的基本案例

最新推荐文章于 2024-07-31 21:26:52 发布
最新推荐文章于 2024-07-31 21:26:52 发布
阅读量875 收藏 3
点赞数
分类专栏： MQ 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangsuhua0702/article/details/103743526
版权

RocketMQ 消息发送的基本样例

“一发、一存、一消费” 是消息中间件的本质，本文简单的记录来RocketMQ消息的基本样例，包含消息的发送（同步消息/异步消息/单向消息）、消息消费（负载均衡模式/广播模式）、顺序消息、延时消息、批量消息以及事务消息。

首先在测试项目中引入依赖

<dependency>
   <groupId>org.apache.rocketmq</groupId>
   <artifactId>rocketmq-client</artifactId>
   <version>4.3.0</version>
</dependency>

一、基本样例

1、消息的发送
消息发送可以拆分为如下几个基本步骤：

 1. 创建消息生产者producer，并制定生产者组名
 2. 指定nameserver地址
 3. 启动producter
 4. 创建消息对象，指定topic、tag和消息体
 5. 发送消息
 6. 关闭生产者
a）发送同步消息

在重要的通知消息、SMS通知，SMS营销系统等广泛的场景中使用可靠的同步传输。

public class BaseProducer {
  public static void main(String[] args) throws Exception {
    //1.创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("base-group");
    //2.指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.启动生产者
    producer.start();

    //每隔一秒发送1条消息，循环发送100条
    for (int i = 0; i < 100; i++) {
      String msgBody = "This is a msg to MQ" + i;
      System.out.println("发送消息:"+msgBody);
      //4.创建消息对象 指定主题、标签、消息体
      Message message = new Message("base-topic", "base-tag", 
      msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));
      //5.发送顺序消息
      SendResult result = producer.send(message);
      //获取发送结果
      System.err.println("发送响应：MsgId:【" + result.getMsgId() 
      	+ "】，发送状态:【" + result.getSendStatus()+"】");

      //线程休眠一秒再去发送下一条消息
      TimeUnit.SECONDS.sleep(1);
    }

    //6.关闭生产者
    producer.shutdown();
  }
}

启动执行main方法，控制台得到如下打印输出：
在这里插入图片描述

b）发送异步消息

异步传输通常用于对时间敏感的业务场景中,如果发送端不能容忍长时间的等待broker的响应的情况下可以选择发送异步消息。
与发送同步消息基本上一致，只有在第五步消息发送环节，通过提供的public void send(Message msg, SendCallback sendCallback) throws MQClientException, RemotingException, InterruptedException 方法来发送异步消息。在发送时创建一个SendCallback接口的匿名内部实现类，实现消息发送成功的回调方法onSuccess(SendResult sendResult)，以及消息发送失败出现异常时的onException(Throwable throwable)方法。

public class AsyncProducer1 {
  public static void main(String[] args) throws Exception{
    //1.创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("async-group");
    //2.指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.启动生产者
    producer.start();
    //循环发送100条消息
    for (int i = 0; i < 100; i++) {
      String msgBody = "This is an async msg to MQ" + i;
      System.out.println("发送消息:"+msgBody);
      //4.创建消息对象 指定主题、标签、消息体
      Message message = new Message("async-topic", "async-tag", 
      msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));
      //5.发送异步消息
      producer.send(message, new SendCallback() {
        /**
         * 发送成功的回调函数
         * @param sendResult
         */
        @Override
        public void onSuccess(SendResult sendResult) {
          System.out.println("发送结果："+sendResult);
        }
        /**
         * 发送异常的回调函数
         * @param throwable
         */
        @Override
        public void onException(Throwable throwable) {
          System.out.println("发送异常："+throwable);
        }
      });
    }
    //6.关闭生产者
    producer.shutdown();
  }
}

启动执行main方法，控制台得到如下打印输出：
在这里插入图片描述

c）单向发送消息

单向消息一般用于不是特别关心发送结果的场景，例如发送日志。
发送单向消息，只是在基本单顺序消息发送案例的基础上使用public void sendOneway(Message msg) throws MQClientException, RemotingException, InterruptedException 方法对消息进行发送。

public class OnewayProducer1 {
  public static void main(String[] args) throws Exception{
    //1.创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("one-way-group");
    //2.指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.启动生产者
    producer.start();

    //循环发送10条消息
    for (int i = 0; i < 10; i++) {
      String msgBody = "This is an one way msg to MQ" + i;
      System.out.println("发送消息:"+msgBody);
      //4.创建消息对象 指定主题、标签、消息体
      Message message = new Message("one-way-topic", "one-way-tag", 
      msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));
      //5.发送单向消息
      producer.sendOneway(message);
    }

    //6.关闭生产者
    producer.shutdown();
  }
}
2、消费消息
消费消息可以分为如下几个步骤：

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

消费者DefaultMQPushConsumer提供了public void setMessageModel(MessageModel messageModel)方法来设置消费的模式。

MessageModel.BROADCASTING   广播模式
MessageModel.CLUSTERING  负载均衡模式（默认）
a）负载均衡模式（默认）

负载均衡模式指的是：一个消费者组内所有对消费者，共同承担消息的消费，每一个消费者消费的消息都是不同的。

public class BaseConsumer {
  public static void main(String[] args) throws Exception{
    //1.创建消费者
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("base-group");
    //2.指定nameserver地址
    consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.订阅主题topic和tag
    consumer.subscribe("base-topic", "*");
    //4.注册消息监听器
    consumer.registerMessageListener(new MessageListenerConcurrently() {
      @Override
      public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, 
      ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        try {
          for (MessageExt messageExt : list) {
            System.err.println("消费消息: " + new String(messageExt.getBody()));
          }
        } catch (Exception e) {
          e.printStackTrace();
          return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
      }
    });

    //5.启动消费者
    consumer.start();
  }
}
c）广播模式

广播模式是指组内的所有消费者都会消费全量的消息，在在消费者启动前，设置消费模式为MessageModel.BROADCASTING即可。

public class BaseConsumer {
  public static void main(String[] args) throws Exception{
    //1.创建消费者
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("base-group");
    //2.指定nameserver地址
    consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.订阅主题topic和tag
    consumer.subscribe("base-topic", "*");

    //设定消费模式 【负载均衡模式(默认)/广播模式MessageModel.BROADCASTING】
    consumer.setMessageModel(MessageModel.BROADCASTING);

    //4.注册消息监听器
    consumer.registerMessageListener(new MessageListenerConcurrently() {
      @Override
      public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list,
       ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        try {
          for (MessageExt messageExt : list) {
            System.err.println("消费消息: " + new String(messageExt.getBody()));
          }
        } catch (Exception e) {
          e.printStackTrace();
          return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
      }
    });

    //5.启动消费者
    consumer.start();
  }
}

二、顺序消息

消息中间件在数据结构上是一种先进先出的数据结构，消息的生产者将消息发送到broker中，存储在队列中，但实际上在一个broker中队列的数量往往大于一个，例如下图即为控制台中展示的broker中拥有四个队列。
在这里插入图片描述
可以得出，当有消息发送到broker中到时候，在默认的情况下消息会采取Round Robin轮询方式把消息发送到不同的queue（分区队列）。而消费者来消费消息时，是从多个queue上拉取消息，这种情况发送和消费是不能保证顺序的，如何保证消息当顺序消费，是用户在使用时需要结合业务场景来考虑的问题之一。

果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上拉去消息，就保证了顺序。
 - 将某些需要保持顺序的局部消息放到broker的同一个队列中。
 - 用同一个线程保证其处理broker中的一个队列的消息。

订单模型类

public class OrderStep {

  private Long orderId;
  private String desc;

  public OrderStep(Long orderId, String desc) {
    this.orderId = orderId;
    this.desc = desc;
  }

  public OrderStep() {
  }

  @Override
  public String toString() {
    return "OrderStep{" +
      "orderId=" + orderId +
      ", desc='" + desc + '\'' +
      '}';
  }

  public static List<OrderStep> buildOrders(){
    List<OrderStep> orderlist = new ArrayList<>();
    Long[] ids = {1001l,1002l,1003l,1004l};
    for(Long id : ids){
      OrderStep orderStep = new OrderStep(id,"创建");
      orderlist.add(orderStep);
      OrderStep orderStep = new OrderStep(id,"付款");
      orderlist.add(orderStep);
      OrderStep orderStep = new OrderStep(id,"发货");
      orderlist.add(orderStep);
       OrderStep orderStep = new OrderStep(id,"关闭");
      orderlist.add(orderStep);
    }
    return orderlist;

  }
}

顺序消息的生产者
消息生产者通过MessageQueueSelector 分区队列选择器，通过订单ID以及自定义的规则，对消息进行分区队列对选择。

public class OrderProducer {
  public static void main(String[] args) throws Exception{
    //创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("order-group");
    //指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //启动生产者
    producer.start();
    //构建消息集合
    List<OrderStep> orderSteps = OrderStep.buildOrders();
    //发送消息
    int i = 0 ;
    for(OrderStep orderStep : orderSteps){
      String body = JSON.toJSONString(orderStep);
      Message msg = new Message("OrderTopic","order",""+(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(); //订单ID除分区队列总数取模 
          System.out.println("队列总数【"+list.size()
          +"】，当前订单ID【"+orderId+"】选择的队列下标【"+index+"】");
          return list.get((int) index);
        }
      }, orderStep.getOrderId());
      System.out.println("发送结果：" + sendResult);
    }
    producer.shutdown();
  }
}

顺序消息的消费者
顺序消息的消费者 通过MessageListenerOrderly ，让一个队列的消息用一个线程去处理。

public class OrderConsumer {
  public static void main(String[] args) throws Exception{
    //1.创建消费者
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order-group");
    //2.指定nameserver地址
    consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.订阅主题topic和tag
    consumer.subscribe("OrderTopic", "*");
    //4.注册消息监听器  MessageListenerOrderly 一个队列的消息用一个线程去处理
    consumer.registerMessageListener(new MessageListenerOrderly() {
      /**
       *
       * @param  msgs 获取到的消息
       * @param consumeOrderlyContext
       * @return
       */
      @Override
      public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs,
       ConsumeOrderlyContext consumeOrderlyContext) {

        for(MessageExt msg : msgs){
          String str = new String(msg.getBody());
          System.out.println("线程名称【"+Thread.currentThread().getName()
          +"】消费消息：" + str);
        }
        return ConsumeOrderlyStatus.SUCCESS;
      }
    });

    //5.启动消费者
    consumer.start();
  }
}

三、延时消息

当发送当消息不需要立即消费，需要设置一定当延迟时间时，可以悬着发送延迟消息，该类型当消息并不会立即被消费，会延迟一段设定好的时间后才会被消费者消费。

 RocketMq并不支持任意时间的延迟，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18
   “1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h”

通过Message类中提供的 public void setDelayTimeLevel(int level)方法来设置延迟的级别。

延迟消息的生产者：

public class DelayProducer {
  public static void main(String[] args) throws Exception{
    //创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("order-group");
    //指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //启动生产者
    producer.start();
    //构建消息集合
    List<OrderStep> orderSteps = OrderStep.buildOrders();
    //发送消息
    int i = 0 ;
    for(OrderStep orderStep : orderSteps){
      String body = JSON.toJSONString(orderStep);
      Message msg = new Message("DelayTopic","d1",""+(i++),body.getBytes());
      msg.setDelayTimeLevel(2); //设置延迟时间级别
      /**
       * 参数一：消息对象
       * 参数二：消息队列的选择器
       * 参数三：选择队列的业务表识（订单ID）
       */
      SendResult sendResult = producer.send(msg);
      System.out.println("发送结果：" + sendResult);
    }
    producer.shutdown();
  }
}

四、批量消息

当消息数量很多当时候，可以通过批量发送当形式来提高消息的发送效率。批量发送消息能够显著提高传递小消息的性能。

   限制：
   - 这批消息应该拥有相同的topic，相同分waitStoremsgOK，而且不能是延迟消息。
   - 批消息的总大小不应该超过4MB

批量消息的生产者：

public class BatchProducer {
  public static void main(String[] args) throws Exception{
    //1.创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("batch-group");
    //2.指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.启动生产者
    producer.start();
    //4.构建一个消息集合
    List<Message> msgs = new ArrayList<>();

    for(int i = 1 ; i<=10 ; i++){
      Message message = new Message("batch-topic", "batch-tag", 
      ("Hello World" + i ).getBytes());
      msgs.add(message);
    }

    //5.发送批量消息
    SendResult send = producer.send(msgs);
    System.out.println("批量发送结果：" + send);
    
    //6.关闭生产者
    producer.shutdown();
  }
}

五、事务消息

RocketMQ提供事务消息的发送，主要是为了解决本地事务执行与消息发送的原子性问题。即解决Producer执行业务逻辑成功之后投递消息可能失败的场景。
在这里插入图片描述
事务消息的状态
1.提交状态 ：允许消费者消费此消息
2.回归状态 ：消息将被删除，不允许被消费
3.中间状态 ：代表需要检查消息队列来确定状态
事务消息发送及提交
1.发送消息（half消息）
2.服务端响应写入结果
3.根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）
4.根据本地事务状态执行commit或者rollback （commit操作生成消息索引，消息对消费者可见）
事务补偿
1.对没有commit/rolback对事务消息（pending状态对消息）从服务端发起一次回查
2.Producer收到回查消息，检查回查消息对应对的本地事务的状态
3.根据本地事务状态，重新commit汇总rollback，其中，补偿阶段用于解决消息commiy或者rollback发生超时或者失败的情况。
使用的限制
1.事务消息不支持延迟消息和批量消息
2.未来避免单个消息被检查太多次而导致半队列消息积累，可以设置默认单个消息的检查次数限制为15次，但是用户可以通过Broker配置文件的transactionCheckMax参数来修改此限制。如果已检查某条消息超过N次的话（N=transactionCheckMax）则Broker将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写AbstractTransactionCheckListener类来修改这个行为。
3.事务消息将在broker配置文件中的参数transactionMsgTimeout这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性CHECK_IMMUNITY_TIME_IN_SECONDS来改变这个限制，该参数优先于transactionMsgTimeout参数。
4.事务性消息可能不止一次被检查或消费。
5.提交给用户的目标主题消费可能会失败，目前这依据日志的记录而定，它的高可用性机制来保证，如果希望确保事务消费不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
6.事务消息的生产者ID不能与其他类型消费的生产者ID共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者ID查询到消费者。

事务消息的生产者

public class Producer {
  public static void main(String[] args) throws Exception{
    //1.创建事务消息生产者producer，并制定生产者的组名
    TransactionMQProducer producer = new TransactionMQProducer("transaction-group");
    //2.指定NameServer地址
    producer.setNamesrvAddr("39.108.128.240:9876");
    //3.设置事务监听器
    producer.setTransactionListener(new MyTransactionListener());
    //4.启动生产者
    producer.start();
    //每隔一秒，循环发送5条消息
    for (int i = 0; i < 4; i++) {
      String body = "事务消息【"+i+"】";
      //创建消息对象 指定主题、标签、消息体  同步和异步是一致到
      Message message = new Message("transaction-topic", "T-"+i, body.getBytes());
      //同步发送消息
      SendResult sendResult = producer.sendMessageInTransaction(message,null);
      //打印消息发送的结果
      System.out.println("发送结果："+sendResult);
      //线程休眠一秒再去发送下一条消息
      TimeUnit.SECONDS.sleep(1);
    }
    //关闭生产者 不建议在事务消息中关闭，可能回导致事务监听器不执行
    //producer.shutdown();

  }
}

自定义的事务监听器

public class MyTransactionListener implements TransactionListener {
  //在该方法中执行本地的一些事务
  @Override
  public LocalTransactionState executeLocalTransaction(Message message, Object o) {
    if(message.getTags().equals("T-1")){
      System.out.println("tag【"+message.getTags()+"】-- 事务提交");
      return LocalTransactionState.COMMIT_MESSAGE;
    }else if(message.getTags().equals("T-2")){
      System.out.println("tag【"+message.getTags()+"】-- 事务回滚");
      return LocalTransactionState.ROLLBACK_MESSAGE;
    }else {
      System.out.println("tag【"+message.getTags()+"】-- 事务结果未知");
      return LocalTransactionState.UNKNOW;
    }
  }
  //MQ在没有接收到事务结果时，发送请求来二次核对 ，消息事务状态的回查
  @Override
  public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
    System.out.println("MQ开始事务状态的回查");
    if(messageExt.getTags().equals("T-3")){
      System.out.println("tag【"+messageExt.getTags()+"】-- 事务提交");
      return LocalTransactionState.COMMIT_MESSAGE;
    }else{
      System.out.println("tag【"+messageExt.getTags()+"】-- 仍然结果未知");
      return LocalTransactionState.UNKNOW;
    }
  }
}

事务消息的消费者

public class Consumer {
  public static void main(String[] args) throws Exception{
    //1.创建消费者
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("transaction-group");
    //2.指定nameserver地址
    consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.订阅主题topic和tag
    consumer.subscribe("transaction-topic", "*");
    //4.设置回调函数 处理消息
    consumer.registerMessageListener((MessageListenerConcurrently) (list, context) -> {
      try {
        for (MessageExt messageExt : list) {
          System.err.println("消费消息: " + new String(messageExt.getBody()));//输出消息内容
        }
      } catch (Exception e) {
        e.printStackTrace();
        return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
      }
      return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
    });
    //5.启动消费者
    consumer.start();
    //6.打印启动状态
    System.out.println("消费者启动成功");
  }
}

六、消费消息的过滤

针对消费者， 消费者来决定对哪些消息进行消费，对哪些消息不消费。
提供两种消息过滤的方式
1.依据tag来过滤
2.依据RocketMQ定义了一些基本语法来支持过滤 （只有使用push模式对消费者才能使用SQL92标准对sql语句）

数值比较 例如： > , >= ,< , <= , BETWEEN ， = ;
字符比较 例如：= ，<> ,IN;
IS NULL 或者 IS NOT NULL ；
逻辑符号 AND ， OR ，NOT；
常量支持类型：
数值 例如：123，3.1415926
字符 例如：‘abc’ 必须用单引号包裹起来
特殊字符 例如：NULL
布尔值 TRUE 或 FALSE

sql模式过滤的消息生产者
通过Message对象提供的 public void putUserProperty(String name, String value) 方法，添加自定义sql查询的标示与内容。

public class Producer {
  public static void main(String[] args) throws Exception{
    //创建消息生产者producer，并制定生产者的组名
    DefaultMQProducer producer = new DefaultMQProducer("sql-filter-group");
    //指定NameServer地址
    producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //启动生产者
    producer.start();

    //每隔一秒，循环发送5条消息
    for (int i = 0; i < 5; i++) {

      String body = "通过tag过滤消息"+i;
      //创建消息对象 指定主题、标签、消息体  同步和异步是一致到
      Message message = new Message("sql-filter-topic", "sql-filter-tag", body.getBytes());
      //设置消息 用户自定义属性
      message.putUserProperty("i",String.valueOf(i));

      //同步发送消息
      SendResult sendResult = producer.send(message);
      //打印消息发送的结果
      System.out.println("发送结果："+sendResult);
      //线程休眠一秒再去发送下一条消息
      TimeUnit.SECONDS.sleep(1);
    }

  }
}

sql模式过滤的消息消费者

public class Consumer {
  public static void main(String[] args) throws Exception{
    //1.创建消费者
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("sql-filter-group");
    //2.指定nameserver地址
    consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开
    //3.订阅主题topic和tag  依据消息sql过滤器来过滤消息
    consumer.subscribe("sql-filter-topic", MessageSelector.bySql("i>=0"));
    //4.设置回调函数 处理消息
    consumer.registerMessageListener((MessageListenerConcurrently) (list, context) -> {
      try {
        for (MessageExt messageExt : list) {

          System.err.println("消费消息:【 " + new String(messageExt.getBody())+"】");
        }
      } catch (Exception e) {
        e.printStackTrace();
        return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
      }
      return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
    });
    
    //5.启动消费者
    consumer.start();
    //6.打印启动状态
    System.out.println("消费者启动成功");
  }
}

参考学习视频 黑马程序员《RocketMQ系统精讲，经受历年双十一狂欢节考验的分布式消息中间件》，图片来源于网络侵删～

许仙许仙！
关注
专栏目录
rocketmq 消息 自定义_RocketMQ的消息发送及消费
weixin_42496673的博客
12-23 1020
RocketMQ消息支持的模式：消息支持的模式分为三种：NormalProducer(普通同步)，消息异步发送，OneWay。消息同步发送：普通消息的发送和接收在前面已经演示过了，在前面的案例中是基于同步消息发送模式。也就是说消息发送出去后，producer会等到broker回应后才能继续发送下一个消息.消息异步发送：异步发送是指发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。...
RocketMQ 消息集成：多类型业务消息 - 定时消息
阿里云云栖号
08-11 918
本篇将继续业务消息集成的场景，从使用场景、应用案例、功能原理以及最佳实践等角度介绍 RocketMQ 的定时消息功能。
RocketMQ 入门 —— 简单的消息示例
weixin_42073629的博客
08-15 138
使用 RocketMQ 以三种方式发送消息：可靠的同步，可靠的异步和单向传输。 可靠的同步传输 应用：可靠的同步传输广泛应用于重要通知消息，短信通知，短信营销系统等。 public class SyncProducer { public static void main(String[] args) throws Exception { //Instantiate with a producer group name. DefaultMQProducer pr
RocketMQ消息发送5种demo案例
weixin_40964170的博客
05-11 2942
导入pom依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析 1.创建消息生产者producer，并制定生产者组名 2.指定Nameserver地址 3
RocketMQ消息发送基本示例(推送消费者)
最新发布
tiantiantbtb的博客
07-31 361
3.单向发送:只负责发送,不管消息是否发送成功 单向发送不保证消息的送达，仅适用于对可靠性要求不高的场景。2.异步发送:不等待消息返回直接进入后续流程.broker将结果返回后调用callback函数,并使用。1.同步发送:等待消息返回后再继续进行下面的操作 同步发送保证了消息的可靠性，适用于关键业务场景。推模式:消费者等待Broker把消息推送过来。拉模式:消费者主动去Broker上拉取消息。CountDownLatch计数。事实上:尽管存在“推送消费者”（消息生产者通过三种方式发送消息。
rocketmq消息的简单示例
七月流星
09-15 4472
简单信息示例 这个页面举例说明了这三种消息发送方式。结合笔记与示例一起找出哪种方式用于您的具体用例。 使用RocketMQ以三种方式发送消息：可靠的同步，可靠的异步和单向传输。 可靠的同步传输 应用：可靠的同步传输用于广泛的场景，如重要通知信息，短信通知，短信营销系统等。 public class SyncProducer { public static vo
RocketMQ简介及发送消息样例
yanyf的博客
12-31 360
一、优缺点 二、产品比较 三、发送消息 1.基本样例：https://blog.csdn.net/yanyf2016/article/details/103786124 2.顺序消息：https://blog.csdn.net/yanyf2016/article/details/103786302 3.延时消息：https://blog.csdn.net/yanyf2016/...
rocketmq 消息指定_RocketMq 实际案例–普通消息的发送
weixin_39714015的博客
12-20 116
RocketMq 实际案例–普通消息的发送@(消息中间件)[RocketMq 实例]学习 rocketMq 最根本的是要先学会用嘛，在创建 rocketMq 的第一个案例的时候，碰到很多坑，可以记录下。第一步：启动 namesrv 和 broker官方文档未告知的坑:问题 1： 如果在单机环境下，没有 Docker 的部署环境，rocketMq 是会默认走 VIPChannel，这时候会在我们发送...
解析 RocketMQ 业务消息 - “顺序消息”
阿里云技术
08-25 910
作为金融级可靠的业务消息方案，RocketMQ 从创建之初就一直专注于业务集成领域的异步通信能力构建。本篇将继续业务消息集成的场景，从功能原理、应用案例、最佳实践以及实战等角度介绍 RocketMQ 的顺序消息功能。
RocketMQ分布式消息中间件学习
weixin_51093734的博客
07-24 114
核心进程2个：视图进程1个： 启动broker 启动rocket-dashboard rocketmq团队提供了一个查询rocket状态数据的仪表盘系统. RocketMQ案例 message: 消息数据对象 product: 程序代码,生成消息,发送消息到队列 consumer: 程序代码,监听(绑定)队列,获取消息,执行消费代码 queue: Rocketmq rabbitmq kafka这些消息队列中间件软件. Product
RocketMQ事务消息, 图文、源码学习探究~
m0_71777195的博客
08-25 177
事务消息必须设置事务监听器，依靠此事务监听器执行本地事务以及事务回查，保证消息的一致性事务消息不支持延时发送及批量发送只能保证消息发送与本地事务执行的一致性，无法保证下游消费结果一定成功。
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
springboot-rabbitMQ-websocket springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
阿里云rocketmq消息队列对接demo
01-24
该资源为在购买了阿里云中间件产品rocketmq消息队列之后，使用的连接rocketmq的demo工程，该程序以 Java 为例，包括普通消息、事务消息、定时消息的测试代码，以及相关 Spring 的配置示例，同时提供tcp连接的程序。
RocketMQ消息发送样例
mry6的博客
04-10 1136
顺序消息的原理解析：在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；消费者将接收包含TAGA或TAGC的消息，但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同。
RocketMQ(四)——常用Example(转)
学会改变自己——才能突破
03-18 1489
最近看了看RocketMQ的官方文档，感觉不错，一直在用，每看一次，深刻一次。接下几篇主要是整理转载一下！ 官方地址：http://rocketmq.apache.org/docs/motivation/ github地址：https://github.com/apache/rocketmq 当然需要我们根据实际情况，做我们想要的抽象封装! 1 基本样例 在基本样例中我们提供如下的功能场景： ...
三.RocketMQ极简入门-RocketMQ普通消息发送
墨家巨子@俏如来
09-12 1443
前言 RocketMQ已经写了两章了，一章是RocketMQ认识和安装，一章是RocketMQ的工作流程和核心概念，本章我们开始使用RocketMQ来发送和接收消息。RocketMQ的消息种类非常多，比如：普通消息，顺序消息，延迟消息，批量发送，消息过滤等等。本篇文章来探讨一下 普通消息的发送 文章目录前言普通消息发送同步发送异步发送单向发送消费者案例总结 普通消息发送 普通消息这里介绍三种发送方式，同步发送，异步发送，单向发送。我们先导入需要的依赖，版本尽量和RocketMQ的安装版本一致。 <d
RocketMQ发送消息
qq_62767608的博客
06-21 4380
MQ的消费模式可以大致分为两种，一种是，一种是。服务端 (MQ) 主动推送消息给客户端，优点是及时性较好流控客户端 需要主动到 服务端 (MQ) 取数据，优点是客户端可以依据自己的消费能力进行消费，Push模式也是基于Pull模式的，所以不管是Push模式还是Pull模式，都是Pull模式。一般情况下，优先选择Pull模式。
基于RocketMQ的推送猜想
无趣的码农
09-12 1623
RocketMQ是基于Topic的分布消息中间件，一个Topic对应多个ConsumerQueue，消费者消费指定的ConsumerQueue队列，并且消息是通过Pull方式拉取。为每个用户定义一个Topic这种方式不现实，即使为每个用户定义一个queueId也是不切实际的做法。ConsumerQueue本来是处理分布式及负载均衡，但我们可以换种思路，一个用户关联一个queueId，一个queue
rocketmq 发送消息
08-02
RocketMQ发送消息的主要步骤如下： 1. 验证消息：在发送消息之前，会对消息进行验证，包括检查消息的合法性和完整性等方面。 2. 查找路由：RocketMQ会根据消息的主题(topic)来查找路由信息，确定消息应该发送到哪个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值