rocketMq

 

rocketmq集群 rabbitmq集群
RabbitMQ 基于erlang语言开发，因此响应速度快些
RocketMQ 阿里 基于Java开发 高级特性： 普通消息、顺序消息、延迟消息、事务消息 可靠性强 吞吐量 高
activemq Apache java实现 实现JMS消息集成框架 吞吐量低

https://wenku.baidu.com/view/37933508e1bd960590c69ec3d5bbfd0a7956d5f5.html

使用命令java -version查看使用的jdk
由于使用的是openjdk，故需要在mq的bin\tools.sh中添加/usr/lib/jvm/jre-1.8.0-openjdk/lib/ext
JAVA_OPT="${JAVA_OPT} -server -Xms1g -Xmx1g -Xmn256m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m"
JAVA_OPT="${JAVA_OPT} -Djava.ext.dirs=${BASE_DIR}/lib:${JAVA_HOME}/jre/lib/ext:${JAVA_HOME}/lib/ext:/usr/lib/jvm/jre-1.8.0-openjdk/lib/ext"
JAVA_OPT="${JAVA_OPT} -cp ${CLASSPATH}"

unzip 解压zip包

?
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
86
问题解决-重启虚拟机
 
启动日志
service iptables stop
tail -f /home/xmh/logs/rocketmqlogs/namesrv.log
tail -f ~/logs/rocketmqlogs/broker.log
cd /home/xmh/soft/mq/rocketmq/rocketmq/rocketmq-all-4.8.0-bin-release
 
启动
nohup ./mqnamesrv &
nohup ./mqbroker -n 127.0.0.1:9876 autoCreateTopicEnable=true &
 
手动创建topic
./mqadmin updateTopic -c DefaultCluster -n 127.0.0.1:9876 -t TopicTest
./mqadmin topicList
 
关闭
./mqshutdown namesrv
./mqshutdown broker集群消费
实际使用中，一台服务用一个消费者，其他业务需要接收消息，单独建消费者
1，默认是集群消费
2，不设置group直接设置MessageModel即可生效
BROADCASTING 广播
CLUSTERING 集群
3.集群模式，一条消息只会被同Group中的一个Consumer消费
4.集群模式，多个Group同时消费一个Topic时，每个Group都会有一个Consumer消费到数据
 
广播消费
   消息将对一 个Consumer Group 下的各个 Consumer 实例都消费一遍。即即使这些 Consumer 属于同一个Consumer Group ，消息也会被 Consumer Group 中的每个 Consumer 都消费一次。
 
 
实现顺序消费 https://blog.csdn.net/yanwendonge/article/details/109188473
   将orderId取模，同一个订单的消息会放到同一个队列里。
生产者
SendResult sendResult = producer.send(msg,messageQueueSelector,"");
    private static MessageQueueSelector messageQueueSelector = new MessageQueueSelector() {
        @Override
        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
            try {
                int id = arg.hashCode();
                int index = Math.abs(id) % mqs.size();
                return mqs.get(index);
            } catch (Exception e) {
                e.printStackTrace();
                return mqs.get(0);
            }
        }
    };
 
消费者
        //单线程顺序消费
        consumer.setConsumeThreadMin(1);
        consumer.setConsumeThreadMax(1);
            consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                int i =0;
                for (MessageExt msg:msgs){
                    System.out.println((i++)+" "+new String(msg.getBody())+"*****"+msg);
                }
                // 标记该消息已经被成功消费
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
 
        //多线程顺序消费
        consumer.setConsumeThreadMin(4);
        consumer.setConsumeThreadMax(8);
        consumer.registerMessageListener( new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                                int i =0;
                for (MessageExt msg:msgs){
                    System.out.println((i++)+" "+new String(msg.getBody())+"*****"+msg);
                }
                // 标记该消息已经被成功消费
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
 
经试验：多个消费者无法实现顺序消费，最终由一个消费者接收所有消息
 
 
注意：
1，producer.send(msg, new SendCallback() { 该写法时常报错
2，出现消息没有被消费者接收的现象，重启客户端，mq服务器

　　

?
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
public static void main(String[] args) throws Exception {
            // 实例化消息生产者Producer
            DefaultMQProducer producer = new DefaultMQProducer("xmhProducer2");
            // 设置NameServer的地址
            producer.setNamesrvAddr("192.168.89.137:9876");
            // 启动Producer实例s
            producer.start();
            SimpleDateFormat df = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss:SSS");
 
            int messageCount =100;
            // 根据消息数量实例化倒计时计算器
            final CountDownLatch2 countDownLatch = new CountDownLatch2(messageCount);
            for (int i = 0; i < messageCount; i++) {
                final int index = i;
                Message msg = new Message("TopicTest",
                        "TagA",
                        ("xmh1******************helloworld"+i+"-"+df.format(new Date())).getBytes(RemotingHelper.DEFAULT_CHARSET));
                // 发送消息到一个Broker
//                SendResult sendResult = producer.send(msg,messageQueueSelector,"");
                SendResult sendResult = producer.send(msg);
//                // 通过sendResult返回消息是否成功送达
                System.out.println(new String(msg.getBody())+" "+sendResult);
//                producer.send(msg, new SendCallback() {//,messageQueueSelector
//                    @Override
//                    public void onSuccess(SendResult sendResult) {
//                        System.out.println(new String(msg.getBody()));
//                    }
//                    @Override
//                    public void onException(Throwable e) {
//                        System.out.printf("%-10d Exception %s %n", index, e);
//                        e.printStackTrace();
//                    }
//                });
 
            }
            // 等待5s
            countDownLatch.await(5, TimeUnit.SECONDS);
            // 如果不再发送消息，关闭Producer实例。
            producer.shutdown();
        }
 
 
    public static void main(String[] args) throws InterruptedException, MQClientException {
        // 实例化消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("xmhgroup");
        // 设置NameServer的地址
        consumer.setNamesrvAddr("192.168.89.137:9876");
        // 订阅一个或者多个Topic，以及Tag来过滤需要消费的消息
        consumer.subscribe("TopicTest", "*");
        consumer.setMessageModel(MessageModel.CLUSTERING);//BROADCASTING 广播 或 集群
        consumer.setConsumerGroup("group1");
        //单线程顺序消费
//        consumer.setConsumeThreadMin(1);
//        consumer.setConsumeThreadMax(1);
        // 注册回调实现类来处理从broker拉取回来的消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                int i =0;
                for (MessageExt msg:msgs){
                    System.out.println((i++)+" "+new String(msg.getBody())+"*****"+msg);
                }
                // 标记该消息已经被成功消费
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //多线程顺序消费
//        consumer.registerMessageListener( new MessageListenerOrderly() {
//            @Override
//            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//                                int i =0;
//                for (MessageExt msg:msgs){
//                    System.out.println((i++)+" "+new String(msg.getBody())+"*****"+msg);
//                }
//                // 标记该消息已经被成功消费
//                return ConsumeOrderlyStatus.SUCCESS;
//            }
//        });
        // 启动消费者实例
        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
 
 
 
默认配置
brokerClusterName = DefaultCluster
brokerName = broker-a
brokerId = 0
deleteWhen = 04
fileReservedTime = 48
brokerRole = ASYNC_MASTER
flushDiskType = ASYNC_FLUSH
 
  
 
#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样  例如：在a.properties 文件中写 broker-a  在b.properties 文件中写 broker-b
brokerName=broker-a
#0 表示 Master，>0 表示 Slave
brokerId=0
#nameServer地址，分号分割
namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=10911
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#存储路径
storePathRootDir=/usr/local/rocketmq/store
#commitLog 存储路径
storePathCommitLog=/usr/local/rocketmq/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/usr/local/rocketmq/store/consumequeue
#消息索引存储路径
storePathIndex=/usr/local/rocketmq/store/index
#checkpoint 文件存储路径
storeCheckpoint=/usr/local/rocketmq/store/checkpoint
#abort 文件存储路径
abortFile=/usr/local/rocketmq/store/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=ASYNC_MASTER
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH
#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

　　

 

posted @   XUMT111  阅读(58)  评论(0)  编辑  收藏  举报
相关博文：
·  rabbitMq
·  kafka、选型
·  RocketMQ
·  RocketMQ
·  RocketMQ系列1：基础介绍
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 2025年我用 Compose 写了一个 Todo App
· 张高兴的大模型开发实战：（一）使用 Selenium 进行网页爬虫
点击右上角即可分享
微信分享提示
SQL AI 助手