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

最新推荐文章于 2024-09-27 14:54:31 发布
最新推荐文章于 2024-09-27 14:54:31 发布
阅读量986 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdtugfcg/article/details/87921321
版权
这篇博客详细介绍了RocketMQ的实战应用，包括集群配置、工程创建、pom.xml文件编写，以及多个生产者和消费者的实现和测试。通过实例代码展示了如何使用RocketMQ进行消息的发送和接收，涵盖了PullConsumer和PushConsumer的使用方法。
摘要由CSDN通过智能技术生成

分享一下我老师大神的人工智能教程。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow

                       

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>
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

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");    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

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

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;    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

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

在此类中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();        }    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

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

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);    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72

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

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();    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

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

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();        }    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

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

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();        }    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

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

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();    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70

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

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.");    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85

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

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();    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

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

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.");    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

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

           

分享一下我老师大神的人工智能教程。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow

这个脑子不好使的
关注
RocketMQ（四）：生产者消费者实践
qq_28834355的博客
02-01 346
文章目录准备工作同步生产异步生产有序消费并发消费 准备工作 先用命令创建Topic，执行成功后默认会创建8个队列 sh mqadmin updateTopic -b localhost:10911 -n localhost:9876 -t TopicTest Producer发送消息时，Topic不存在也会自动创建，但是一般不建议这样做。 同步生产 发送消息时，等待返回结果才发送下一条。速度相对慢一点，消息不易丢失。 public class SyncProducer { public stati
rocketmq一个消费者有多个服务器_RocketMQ入门案例
weixin_42298727的博客
01-17 855
RocketMQ入门案例发布时间：2019-03-29 11:27,浏览次数：1369, 标签：RocketMQ学习RocketMQ，先写一个Demo演示一下看看效果。一、服务端部署因为只是简单的为了演示效果，服务端仅部署单Master模式 —— 一个Name Server节点，一个Broker节点。主要有以下步骤。* 下载RocketMQ源码、编译(也可以网上下载编译好的文件)，这里使用最新的4...
华为RocketMq发送订阅普通消息Demo
qq_28058509的博客
04-21 1977
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 华为RocketMq发送订阅普通消息Demo前言一、发送普通消息（同步发送方式）准备环境示例二、订阅普通消息三、使用ACL权限访问 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、发送普通消息（同步发送方式） 准备环境 开源的Java客户端支持连接分布式消息服务RocketMQ版，推荐使用的客户端版本为4.9.0。 通过以下方式引入依赖： 使用Maven方式引入依赖。 <dependency> <g.
RocketMQ 生产者、消费者、消息示例
最新发布
小楼一夜听春雨，深巷明朝卖杏花
09-27 867
通过Java程序来实现消息的生产者，也就是程序可以使用rocketmq为Java程序提供的专有api来来将消息发送到rocketmq服务器上面。其次是消息的消费者，这也是一个Java程序，通过这个程序通过rocketmq提供的消费者相关的api从rocketmq服务器上订阅到消息。生产者需要指明nameserver的地址，不需要关心broker在哪里，因为nameserver里面会告知生产者broker的地址。在消息里面可以看到即使这些消息被消费了，依然是可以看得到的，消息是保存在broker上面。
RocketMQ生产者及消费者实现-官网实例
mlydaemon的专栏
05-05 3511
生产者有三种模式，同步，异步（提供重试机制），单向。消费者提供错误重试机制。
RocketMQ消息发送与消费示例
rzpy_qifengxiaoyue的博客
11-16 699
1.1 加入依赖： maven: <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.3.0</version> </dependency> gradle compile 'org.apache.rocketmq:rocketmq-c
使用rocketmq，rocketmq-client-python的api开发rocketmq生产者和消费者
202xxx的博客
08-17 4727
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案例实战
Romantic丶的博客
04-19 1921
假如是在同一个comsume组（consumeGroup1）里面，且topic定义的和生产者一样，之前订阅过生产者的消息，即已经注册到broker上面了，如上述有两个之前订阅过但是不在线，所以只有当消费者重启后会被消费：如果2个同时上线，则属于集群消费还是会被两个消费者均分，如果上线1个，则未消费消息将会被这一个全部消费掉。假如消费者是在同一个comsume组（consumeGroup1）里面，但是topic和生产者定义不一样，则意味着没订阅，此时即使生产者生产了消息，也不会被消费。
rocketmq python 一个进程订阅多个topic_消息队列RocketMQ性能测试案例
weixin_39883440的博客
12-11 1120
1. 消息队列RocketMQ性能测试案例1.1 RocketMQ测试分析客户场景，信息共享交换平台：1.交换平台需支持每秒万级别数据传输2.实现跨路段、跨部门、跨行业、跨区域信息即时共享，做到高可靠、低延迟客户现场展示场景设计思路：1.针对性的编写一套JAVA代码来支撑本次MQ性能POC验证。2.选择合适规格的单台ECS，在单个TOPIC下运行多线程代码实现和MQ的订阅发送，统计1分钟内订阅和发...
Rocket MQ--004--发送和消费消息示例
天地人的博客
09-18 242
消息发送模式 Rocket MQ发送消息可分为同步发送、异步发送和单向发送 同步发送：发送消息要等待，直到MQ响应 异步发送：发送消息不需要等待 单向发送：发送之后代码继续运行，无需关心发送结果，无需等待MQ响应 消息发送示例 package com.klcwqy.rocketmq; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.Defaul
rocketmq实例代码
11-09
RocketMQ是一个纯java、分布式、队列模型的开源消息中间件，前身是Metaq，当 Metaq 3.0发布时，产品名称改为 RocketMQ。
# RocketMQ 实战：模拟电商网站场景综合案例（一）
段子手168的博客
06-05 1461
# RocketMQ 实战：模拟电商网站场景综合案例（一） 一、内容介绍 二、综合案例功能介绍 三、项目技术介绍 四、SpringBoot 整合 RocketMQ ：springboot 集成 rocketmq 生产者
Rocketmq中生产者与消费者使用实例及相关问题解决
qq_37247664的博客
05-17 494
因为rocketmq执行至少发送一次的形式，所以不可避免的就会出现消息重复发送，所以在发送端无法做到，只能在消费端做端，可以采用消费端幂等性设计：实现幂等性的方式有很多，比如在业务系统中为每条消息生成唯一的处理 ID，并将处理结果保存在数据库中，当重复消费时，在数据库中查询该消息是否已经被处理过；rocketMqTemplate.syncSendOrderly(RocketTopic.SYNC_TOPIC_ORDERLY,"1001消息创建--1","1001");
快速学习-RocketMQ样例
逍遥云恋
09-20 444
样例 1 基本样例 在基本样例中我们提供如下的功能场景： 使用RocketMQ发送三种类型的消息：同步消息、异步消息和单向消息。其中前两种消息是可靠的，因为会有发送是否成功的应答。 使用RocketMQ来消费接收到的消息。 1.1 加入依赖： maven: <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifact
2.Rocket消费实例
xinanrusu的博客
03-18 898
注意： 相同group的消费客户端，属于同一个集群。相同group下的topic和tag必须一致，不然信息会丢失。 消费端的group和生产者的group没有直接关系，可以不同。 2.1 demo 2.1.1 pom.xml(我部署的mq为4.4.0版本) &lt;dependency&gt; &lt;groupId&gt;org.apach...
【SpringBoot框架篇】22.集成RocketMQ实现消息发布和订阅
皓亮君的博客
08-09 5138
集成RocketMQ实现消息的发布和订阅
RocketMQ消费者
coolshyman的博客
09-01 354
这条消息的消费过程中有4次与DB的交互，如果按照每次5ms计算，那么总共耗时20ms，假设业务计算耗时5ms，那么总过耗时25ms，所以如果能把4次DB交互优化为2次，那么总耗时就可以优化到15ms，即总体性能提高了40%。例如订单扣款类应用，一次处理一个订单耗时1 s，一次处理10个订单可能也只耗时2s，这样即可大幅度提高消费的吞吐量，通过设置consumer的consumeMessageBatchMaxSize返个参数，默认是1，即一次只消费一条消息，例如设置为N，那么每次消费的消息数小于等于N。
Springboot rockemq整合配置 发布订阅 广播
qq_35939864的博客
12-06 928
一.预备环境 1.系统 Windows 2. 环境 JDK1.8、Maven、Git 二. RocketMQ部署 1.下载 1.1地址：http://rocketmq.apache.org/release_notes/release-notes-4.7.1/ 1.2 安装 1.3 在桌面上，右键单击“计算机”图标。从上下文菜单中选择“属性”。单击高级系统设置链接。单击环境变量。然后添加或更改环境变量。 ROCKETMQ_HOME="D:\rocketmq" NAMESRV_ADDR="localhost:9
Java实现RocketMQ消息生产和消费及数据上传教程
在RocketMQ中，消息生产者（Producer）负责发送消息到消息队列中，而消费者（Consumer）则订阅相应的消息主题，并从队列中拉取消息进行处理。生产者和消费者之间的交互通常是解耦的，这样可以在不影响整体系统的情况...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值