RocketMq案例，生产者，消费者，消息订阅

最新推荐文章于 2024-07-29 09:00:00 发布
最新推荐文章于 2024-07-29 09:00:00 发布
阅读量1.2w 收藏 20
点赞数 4
分类专栏： # kafka、rocketmq(消息队列) 文章标签： rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tototuzuoquan/article/details/78325189
版权

1、RocketMq集群配置参考：

http://blog.csdn.net/tototuzuoquan/article/details/78314572

使用的rocketmq的ip等是上面博文提及的ip等内容

2、创建RocketMq工程

工程目录结构如下：
这里写图片描述

3、编写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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.toto.rocketmq</groupId>
    <artifactId>rocketmq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-store</artifactId>
            <version>4.0.0-incubating</version>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.0.0-incubating</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

4、编写demo.one下的Producer，代码如下：

package demo.one;

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.UUID;

public class Producer {

    public static void main(String[] args) {
        //生成Producer
        DefaultMQProducer producer = new DefaultMQProducer("pro_qch_test");
        //配置Producer
        producer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        producer.setInstanceName(UUID.randomUUID().toString());
        //启动Producer
        try{
            producer.start();
        }catch(MQClientException e) {
            e.printStackTrace();
            return;
        }

        //生产消息
        String str = "Hello RocketMQ!------" + UUID.randomUUID().toString();
        Message msg = new Message("qch_20170706",str.getBytes());
        try{
            producer.send(msg);
        } catch(MQClientException | RemotingException | MQBrokerException | InterruptedException e){
            e.printStackTrace();
            return;
        }

        //停止Producer
        producer.shutdown();
        System.out.println("[-----------]Success\n");
    }
}

运行结果如下：
这里写图片描述

5、编写demo.one下的ProducerTest

package demo.one;

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.UUID;

public class ProducerTest {
    private static DefaultMQProducer producer = null;

    public static void main(String[] args) {
        System.out.print("[----------]Start\n");
        int pro_count = 1;
        if (args.length > 0) {
            pro_count = Integer.parseInt(args[0]);
        }
        boolean result = false;
        try {
            ProducerStart();
            for (int i = 0; i < pro_count; i++) {
                String msg = "hello rocketmq "+ i + "----" + UUID.randomUUID().toString();
                SendMessage("qch_20170706", msg);
                System.out.print(msg + "\n");
            }
        }finally {
            producer.shutdown();
        }
        System.out.print("[----------]Succeed\n");
    }

    private static boolean ProducerStart() {
        producer = new DefaultMQProducer("pro_qch_test");
        producer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        producer.setInstanceName(UUID.randomUUID().toString());
        try {
            producer.start();
        } catch(MQClientException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    private static boolean SendMessage(String topic, String str) {
        Message msg = new Message(topic, str.getBytes());
        try {
            producer.send(msg);
        } catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
}

通过这个类实现批量发送消息

在此类中args参数需要输入，接下来idea中模拟输入参数：
这里写图片描述
这里写图片描述
运行结果：
这里写图片描述

5、编写demo.one下的ConsumerTest

package demo.one;

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

import java.util.List;
import java.util.UUID;

public class ConsumerTest {

    public static void main(String[] args) {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("con_qch_test");
        consumer.setInstanceName(UUID.randomUUID().toString());
        consumer.setConsumeMessageBatchMaxSize(32);
        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(
                    List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for(MessageExt me : list) {
                    System.out.print(new String(me.getBody()) + "\n");
                }
                System.out.println("=====================================");
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        try {
            consumer.subscribe("qch_20170706", "*");
            consumer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：
这里写图片描述

6、编写demo.one下的PullConsumer

在rocketmq里，consumer被分为2类：MQPullConsumer和MQPushConsumer，其实本质都是拉模式（pull）,即consumer轮询从broker拉取消息。

区别是：
push方式里，consumer把轮询过程封装了，并注册MessageListener监听器，取到消息后，唤醒MessageListener的consumerMessage()来消费，对用户而言，感觉消息是被推送过来的。

pull方式里，取消息的过程需要用户自己写，首先通过打算消费的Topic拿到MessageQueue的集合，遍历MessageQueue集合，然后针对每个MessageQueue批量取消息，一次取完后，记录该队列下一次要取的开始offset，直到取完了，再换另一个MessageQueue.

package demo.one;

import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer;
import org.apache.rocketmq.client.consumer.PullResult;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public class PullConsumer {
    private static final Map<MessageQueue, Long> OFFSE_TABLE = new HashMap<>();

    public static void main(String[] args) {
        DefaultMQPullConsumer consumer = new DefaultMQPullConsumer("consumerGroup");
        consumer.setInstanceName(UUID.randomUUID().toString());
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        try {
            consumer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
        try {
            Set<MessageQueue> mqs = consumer.fetchSubscribeMessageQueues("qch_20170706");
            for(MessageQueue mq : mqs) {
                System.out.println("Consume from the queue: " + mq + "%n");
                SINGLE_MQ:
                while(true) {
                    try {
                        PullResult pullResult = consumer.pullBlockIfNotFound(mq,null,
                                getMessageQueueOffset(mq),32);
                        System.out.printf("%s%n", pullResult);
                        putMessageQueueOffset(mq,pullResult.getNextBeginOffset());
                        switch (pullResult.getPullStatus()) {
                            case FOUND:
                                break;
                            case NO_MATCHED_MSG:
                                break;
                            case NO_NEW_MSG:
                                break SINGLE_MQ;
                            case OFFSET_ILLEGAL:
                                break;
                            default:
                                break;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }

    private static long getMessageQueueOffset(MessageQueue mq) {
        Long offset = OFFSE_TABLE.get(mq);
        if (offset != null)
            return offset;

        return 0;
    }

    private static void putMessageQueueOffset(MessageQueue mq, long offset) {
        OFFSE_TABLE.put(mq, offset);
    }
}

运行后的结果是：
这里写图片描述

7、编写demo.one下的PushConsumer

package demo.one;

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.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.UUID;

public class PushConsumer {

    public static void main(String[] args) throws MQClientException, InterruptedException {
        //生成Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("con_group_1");
        //配置Consumer
        consumer.setInstanceName(UUID.randomUUID().toString());
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeMessageBatchMaxSize(32);
        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(
                (MessageListenerConcurrently)(list, consumeConcurrentlyContext) -> {
                    //消费消息
                    for(MessageExt me : list) {
                        System.out.print("msg=" + new String(me.getBody()) + "\n");
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; });
        //启动Consumer
        consumer.subscribe("qch_20170706", "*");
        consumer.start();
        //停止Consumer
        Thread.sleep(60000);
        consumer.shutdown();
    }
}

运行结果：
这里写图片描述

8、编写 demo.one下的PushConsumerTest

package demo.one;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;
import java.util.UUID;

public class PushConsumerTest {

    private static int count = 0;

    public static void main(String[] args) {
        System.out.print("Push Consumer main start!\n");
        count = 0;
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("con_group_1");
        consumer.setInstanceName(UUID.randomUUID().toString());
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeMessageBatchMaxSize(32);
        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(
                    List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.print("list count=" + list.size() + "\n");
                for(MessageExt me : list) {
                    count ++;
                    System.out.print("count=" + count + ", msg=" + new String(me.getBody()) + "\n");
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        try {
            consumer.subscribe("qch_20170706", "*");
            consumer.start();
            System.out.print("Push Consumer Started!\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：
这里写图片描述

9、编写PushConsumerThreadPollTest

package demo.one;

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.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class PushConsumerThreadPollTest {

    public static void main(String[] args){
        int threadCount = 3;
        int waitTime = 60000;

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        for(int i = 0; i < threadCount; i++) {
            Runnable runner = new ExecutorThread(String.valueOf(i));
            executor.execute(runner);
        }

        try {
            Thread.sleep(60000);
            executor.shutdown();
            executor.awaitTermination(waitTime, TimeUnit.MICROSECONDS);
        } catch (InterruptedException e) {}
    }

}

class ExecutorThread implements Runnable {
    private String name = "";
    private int count = 0;

    ExecutorThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        StartPushConsumer();
    }

    private void StartPushConsumer() {
        System.out.print("Consumer Name=" + name + "\n");
        count = 0;
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("con_group_1");
        consumer.setInstanceName(UUID.randomUUID().toString());
        //广播消费
        //consumer.setMessageModel(MessageModel.BROADCASTING);
        //集群消费
        consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.setConsumeMessageBatchMaxSize(32);
        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener((MessageListenerConcurrently) (list, consumeConcurrentlyContext) -> {
            System.out.print("list count=" + list.size() + "\n");
            for(MessageExt me : list) {
                count ++;
                System.out.print("name=" + name + ", count=" + count + ", msg=" + new String(me.getBody()) + "\n");
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });

        try {
            consumer.subscribe("qch_20170706", "*");
            consumer.start();
            System.out.print("Consumer started. name=" + name + "\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行的结果：
这里写图片描述

10、编写demo.two中producer

package demo.two;

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

public class Producer {

    public static void main(String[] args) throws MQClientException {
        /**
         * 一个应用创建一个Producer，由应用来维护此对象，可以设置为全局对象或者单例
         * 注意：ProducerGroupName需要由应用来保证唯一
         * ProducerGroup这个概念发送普通的消息时，作用不大，但是发送分布式事务消息时，比较关键，
         * 因为服务器会回查这个Group下的任意一个Producer
         */
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");

        /**
         * Producer对象在使用之前必须要调用start初始化，初始化一次即可
         * 注意：切记不可以在每次发送消息时，都调用start方法。
         */
        producer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        producer.start();

        /**
         * 下面这段代码表明一个Producer对象可以发送多个topic，多个tag的消息。
         * 注意：send方法是同步调用，只要不抛异常就标识成功。但是发送成功也可会有多种状态，
         * 例如消息写入Master成功，但是Slave不成功，这种情况消息属于成功，但是对于个别应用如果对消息可靠性要求极高，
         * 需要对这种情况做处理。另外，消息可能会存在发送失败的情况，失败重试由应用来处理。
         */
        try {
            {
                Message msg = new Message("TopicTest1",// topic
                        "TagA",// tag
                        "OrderID001",// key
                        ("Hello MetaQ").getBytes());// body
                SendResult sendResult = producer.send(msg);
                System.out.println(sendResult);
            }

            {
                Message msg = new Message("TopicTest2",// topic
                        "TagB",// tag
                        "OrderID0034",// key
                        ("Hello MetaQ").getBytes());// body
                SendResult sendResult = producer.send(msg);
                System.out.println(sendResult);
            }

            {
                Message msg = new Message("TopicTest3",// topic
                        "TagC",// tag
                        "OrderID061",// key
                        ("Hello MetaQ").getBytes());// body
                SendResult sendResult = producer.send(msg);
                System.out.println(sendResult);
            }
        } catch (Exception e){
            e.printStackTrace();
        }

        /**
         * 应用退出时，要调用shutdown来清理资源，关闭网络连接，从MetaQ服务器上注销自己
         * 注意：我们建议应用在JBoss、Tomcat等容器的退出钩子里调用shutdown方法。
         */
        producer.shutdown();
    }
}

运行结果：
这里写图片描述

11、编写demo.two下的consumer

package demo.two;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

public class Consumer {

    /**
     * 当前粒子是PushConsumer用法，使用方式给用户感觉消息从RocketMQ服务器推到了应用客户端。
     * 但是实际PushConsumer内部是使用长轮询Pull方法从Broker拉消息，然后再回调用户Listener方法。
     * @param args
     */
    public static void main(String[] args) throws MQClientException {
        /**
         * 一个应用创建一个Consumer，由应用来维护此对象，可以设置为全局对象或者单例
         * 注意：ConsumerGroupName需要由应用来保证唯一
         */
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");

        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");

        /**
         * 订阅指定topic下tags分别等于TagA或tagC或TagD
         */
        consumer.subscribe("TopicTest1", "TagA || TagC || TagD");

        /**
         * 订阅指定topic下所有消息<br>
         * 注意：一个consumer对象可以订阅多个topic
         */
        consumer.subscribe("TopicTest2", "*");

        consumer.subscribe("TopicTest3","*");

        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                System.out.println(Thread.currentThread().getName() + " Receive New Messages:" + msgs);

                MessageExt msg = msgs.get(0);
                System.out.println(new String(msg.getBody()));
                if (msg.getTopic().equals("TopicTest1")) {
                    //执行TopicTest1的消费逻辑
                    if (msg.getTopic() != null && msg.getTags().equals("TagA")) {
                        //执行TagA的消费
                        System.out.println("执行TagA的消费");
                    } else if(msg.getTags() != null && msg.getTags().equals("TagC")) {
                        //执行TagC的消费
                        System.out.println("执行TagC的消费");
                    } else if (msg.getTags() != null && msg.getTags().equals("TagD")) {
                        //执行TagD的消费
                        System.out.println("执行TagD的消费");
                    }
                } else if(msg.getTopic().equals("TopicTest2")) {
                    //执行TopicTest2的消费逻辑
                    System.out.println("执行TopicTest2的消费逻辑");
                } else if (msg.getTopic().equals("TopicTest3")){
                    System.out.println("执行TopicTest3的消费逻辑");
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        /**
         * Consumer对象在使用之前必须调用start初始化，初始化一次即可
         */
        consumer.start();

        System.out.println("Consumer Started.");
    }
}

运行结果：
这里写图片描述

12、编写demo.three中的producer

package demo.three;

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

import java.util.Date;

public class Producer {

    public static void main(String[] args) throws MQClientException {
        DefaultMQProducer producer = new DefaultMQProducer("rmq-group");

        /**
         * 默认情况下，一台服务器只能启动一个Producer或Consumer实例，所以如果需要在
         * 一台服务器启动多个实例，需要设置实例的名称。
         */
        producer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        producer.setInstanceName("producer");

        producer.start();
        try {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(1000); //每秒发送一次MQ
                Message msg = new Message(
                        "TopicA-test",   //topic
                        "TagA",           //tag
                        (new Date() + "Hello RocketMQ,QuickStart" + i).getBytes());
                SendResult sendResult = producer.send(msg);
                System.out.println(sendResult);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        producer.shutdown();
    }

}

运行结果：
这里写图片描述

13、编写demo.three中的consumer

package demo.three;

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

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("rmq-group");

        consumer.setNamesrvAddr("192.168.106.101:9876;192.168.106.102:9876");
        consumer.setInstanceName("consumer");
        consumer.subscribe("TopicA-test", "TagA");

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(
                    List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println(new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

运行后的代码结果是：
这里写图片描述

涂作权的博客
关注
专栏目录
RocketMQ案例实战
Romantic丶的博客
04-19 1903
假如是在同一个comsume组（consumeGroup1）里面，且topic定义的和生产者一样，之前订阅过生产者的消息，即已经注册到broker上面了，如上述有两个之前订阅过但是不在线，所以只有当消费者重启后会被消费：如果2个同时上线，则属于集群消费还是会被两个消费者均分，如果上线1个，则未消费消息将会被这一个全部消费掉。假如消费者是在同一个comsume组（consumeGroup1）里面，但是topic和生产者定义不一样，则意味着没订阅，此时即使生产者生产了消息，也不会被消费。
rocketmq 消息指定_RocketMq 实际案例–普通消息的发送
weixin_39714015的博客
12-20 116
RocketMq 实际案例–普通消息的发送@(消息中间件)[RocketMq 实例]学习 rocketMq 最根本的是要先学会用嘛，在创建 rocketMq 的第一个案例的时候，碰到很多坑，可以记录下。第一步：启动 namesrv 和 broker官方文档未告知的坑:问题 1： 如果在单机环境下，没有 Docker 的部署环境，rocketMq 是会默认走 VIPChannel，这时候会在我们发送...
RocketMQ命令介绍及RocketMQ的可视化工具部署
最新发布
小威的博客
07-29 1万+
上篇文章我们介绍了RocketMQ集群的搭建，但是我们只能通过命令来查看集群情况。所以，这篇文章我们主要介绍RocketMQ的可视化平台。RocketMQ的可视化工具主要用于监控和管理RocketMQ集群，帮助我们更加直观地了解RocketMQ的运行状态和性能指标。
Rocketmq实例以及详解
qq_33719894的博客
12-10 6318
一.为什么用Mq 服务之间通信的中间件。 可以让应用之间解耦，相互之间依赖减小，形成异步调用。还可以用来流量削峰。数据分发。 但是会有消息一致性问题，系统复杂性增加，如果Mq宕机，系统可用性会降低。 二.特点 灵活可扩展，支持海量消息单机10万级别，使用文件做持久化, 并支持分布式事务(虽然可能造成较多的写脏), 异步刷盘,内存预分配, 高可用采用了同步双写及异步复制的方式 三.介绍 RocketMQ 是阿里巴巴在2012年开源的分布式消息中间件，目前已经捐赠给 Apac...
Rocketmq 案例实战
Dream_it_possible！的博客
06-13 1006
客户端版本: 4.3.0 服务端版本: 4.3.0 一、批量发送消息 使用DefaultMQProducer批量发送消息 public class SimpleBatchProducer { public static void main(String[] args) throws Exception { DefaultMQProducer producer = new DefaultMQProducer("BatchProducerGroupName"); ..
RocketMQ 入门案例
qq_43209370的博客
03-11 320
rocketmqpom生产者 (同步)消费者生产者消费者 pom &lt;dependency&gt; &lt;groupId&gt;org.apache.rocketmq&lt;/groupId&gt; &lt;artifactId&gt;rocketmq-client&lt;/artifactId&gt; &lt;version&gt;4.3.0&lt;/version...
使用rocketmq，rocketmq-client-python的api开发rocketmq生产者和消费者
202xxx的博客
08-17 4685
rocketmq-python 是一个基于 rocketmq-client-cpp 封装的 RocketMQ Python 客户端。 rocketmq-client-python安装 目前rocketmq库只支持linux和mac。 rocketmq-client-python 的安装： pip install rocketmq 安装太慢？国内源安装： pip install rocketmq -i https://pypi.tuna.tsinghua.edu.cn/simple 示例代码
rocketmq一个消费者有多个服务器_RocketMQ入门案例
weixin_42298727的博客
01-17 830
RocketMQ入门案例发布时间：2019-03-29 11:27,浏览次数：1369, 标签：RocketMQ学习RocketMQ，先写一个Demo演示一下看看效果。一、服务端部署因为只是简单的为了演示效果，服务端仅部署单Master模式 —— 一个Name Server节点，一个Broker节点。主要有以下步骤。* 下载RocketMQ源码、编译(也可以网上下载编译好的文件)，这里使用最新的4...
RocketMQ入门案例
qq_51076413的博客
06-27 623
RocketMQ入门案例
rocketmq实例代码
11-09
RocketMQ是一个纯java、分布式、队列模型的开源消息中间件，前身是Metaq，当 Metaq 3.0发布时，产品名称改为 RocketMQ。
消息中间件 RocketMQ 发布和订阅 Demo
03-27
java编写的RocketMQ入门demo，maven 更新依赖，可直接运行Producer和Consumer 简单进行测试
# RocketMQ 实战：模拟电商网站场景综合案例（一）
段子手168的博客
06-05 1364
# RocketMQ 实战：模拟电商网站场景综合案例（一） 一、内容介绍 二、综合案例功能介绍 三、项目技术介绍 四、SpringBoot 整合 RocketMQ ：springboot 集成 rocketmq 生产者
RocketMQ的常见应用样例及其实现
weixin_45974176的博客
08-17 733
RocketMQ的常见应用样例及其实现
Alibaba阿里 RocketMQ入门实例(订阅消息)
evior
04-02 1853
订阅方式 消息队列 RocketMQ 支持以下两种订阅方式： 集群订阅：同一个 Group ID 所标识的所有 Consumer 平均分摊消费消息。 例如某个 Topic 有 9 条消息，一个 Group ID 有 3 个 Consumer 实例，那么在集群消费模式下每个实例平均分摊，只消费其中的 3 条消息。 // 集群订阅方式设置（不设置的情况下，默认为集群订阅方式） prop...
Springcloud集成RocketMQ，实现生产者和消费者案例
ytyDaMoTou的博客
06-26 5252
整合springcloud，实现生产和消费 案例实现如何携带Key和Tag的方式，请参考
RocketMQ --- 实战篇
shuai_h的博客
06-26 4559
一、案例介绍 1.1、业务分析 模拟电商网站购物场景中的【下单】和【支付】业务 1.1.1、下单 流程 用户请求订单系统下单 订单系统通过RPC调用订单服务下单 订单服务调用优惠券服务，扣减优惠券 订单服务调用调用库存服务，校验并扣减库存 订单服务调用用户服务，扣减用户余额 订单服务完成确认订单 1.1.2、支付 流程 用户请求支付系统 支付系统调用第三方支付平台API进行发起支付流程 用户通过第三方支付平台支付成功后，第三方支付平台回调通知支付系统 支付系统调用订单服务修
RocketMQ 实战 消息发送样例
LoveSummer
07-06 508
消息发送样例 导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析r 1.创建消息生产者producer，并制定生产者组名 2.指定
SpringBoot集成RocketMQ：生产者与消费者实战
首先，我们了解了如何通过`spring-boot-starter`依赖来引入RocketMQ的功能，并配置了名称服务器（NameServer）地址和生产者/消费者的组名。生产者部分，创建了一个名为`RocketMqTemplateProducer`的REST控制器，通过...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

涂作权的博客

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

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

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

打赏作者

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

抵扣说明：

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

余额充值