RocketMQ在Windows下的安装与使用

1、安装与启动

1.1.版本：4.7.1

1.2.系统要求（http://rocketmq.apache.org/docs/quick-start/）

1.3.下载（https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.7.1/rocketmq-all-4.7.1-bin-release.zip）

可以从以下地址下载：

https://mirror.bit.edu.cn/apache/rocketmq/4.7.1/rocketmq-all-4.7.1-bin-release.zip

https://mirrors.bfsu.edu.cn/apache/rocketmq/4.7.1/rocketmq-all-4.7.1-bin-release.zip

https://mirrors.tuna.tsinghua.edu.cn/apache/rocketmq/4.7.1/rocketmq-all-4.7.1-bin-release.zip

1.4.启动

1.4.1.将1.3下载的压缩包解压到安装目录，我本地是C:\software

1.4.2.添加环境变量ROCKETMQ_HOME，变量值为RocketMQ的目录，我本地的目录为：

1.4.3.先启动mqnamesrv.cmd

1.4.4.再启动mqbroker.cmd

若发送消息失败，报错“No route info of this topic, xxxx See http://rocketmq.apache.org/docs/faq/ for further details.”，综合网上的资料和实践，一般是两个原因：

a.RocketMQ版本较低，autoCreateTopicEnable开关默认关闭，添加启动参数autoCreateTopicEnable=true，但是较高版本（如4.7.1）已默认开启

b.RocketMQ服务端和客户端不兼容，详见：RocketMQ一个不兼容BUG: No route info for this topic

 

2.使用（以Spring Boot项目为例）

2.1.在pom.xml添加RocketMQ客户端依赖

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

2.2.代码

配置类：

package com.example.study.mq;

import lombok.Data;
import org.springframework.context.annotation.Configuration;

/**
 * RocketMQ配置类
 */
@Data
@Configuration
public class RocketMqConfiguration {
    /**
     * RocketMQ服务端地址
     */
    private String mqAddr = "127.0.0.1:9876";
    /**
     * 消费组名称
     */
    private String consumerGroup = "consumer-test";
    /**
     * 生产组名称
     */
    private String producerGroup = "producer-test";
}

工厂类：

package com.example.study.mq;

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.annotation.PostConstruct;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * RocketMQ工厂类
 */
@Slf4j
@Component
public class RocketMqFactory {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private DefaultMQProducer producer;
    /**
     * DefaultMQPushConsumer和DefaultMQPullConsumer的区别是：
     * push由RocketMQ服务器主动下发消息给消费者，而pull是由消费者自己去拉取RocketMQ的消息
     * 实际上push也是由消费者定时pull，只是这个动作由client定时执行，在使用者看来就和push一样的效果
     */
    private DefaultMQPushConsumer consumer;

    @Autowired
    private RocketMqConfiguration configuration;

    /**
     * 初始化消费者
     */
    @PostConstruct
    private void initConsumer() {
        consumer = new DefaultMQPushConsumer();
        consumer.setNamesrvAddr(configuration.getMqAddr());
        consumer.setConsumerGroup(configuration.getConsumerGroup());
    }

    /**
     * 初始化生产者
     */
    @PostConstruct
    private void initProducer() {
        producer = new DefaultMQProducer();
        producer.setNamesrvAddr(configuration.getMqAddr());
        producer.setProducerGroup(configuration.getProducerGroup());
        try {
            // 在发送消息前启动Producer
            producer.start();
            log.info("producer start success. start time:{}", sdf.format(new Date()));
        } catch (MQClientException e) {
            log.error("start producer failed. error message:{}", e.getErrorMessage());
        }
    }

    /**
     * 发送消息
     *
     * @param topic topic
     * @param tag   tag
     * @param msg   发送的消息
     */
    public void sendMsg(String topic, String tag, String msg) {
        Assert.hasText(topic, "topic not blank");
        Assert.hasText(tag, "tag not blank");
        Assert.hasText(msg, "msg not blank");
        Message message = new Message(topic, tag, msg.getBytes());
        try {
            producer.send(message);
        } catch (Exception e) {
            log.error("send message failed. error message:{}", e.getMessage());
        }
    }

    /**
     * 获取消费者
     * 例：订阅topic_1的tag_0,tag_1，topic_2的tag_2,tag_3，则入参为：
     * topic=topic_1,topic_2
     * tag=tag_0||tag_1,tag_2||tag_3
     *
     * @param topic 支持订阅多个topic，多个topic之间以","分隔
     * @param tag   支持订阅多个tag，不同topic之间的tag用","分隔，相同topic下的tag以"||"分隔
     * @return 消费者
     */
    public DefaultMQPushConsumer getConsumer(String topic, String tag) {
        Assert.hasText(topic, "topics not blank");
        Assert.hasText(tag, "tags not blank");
        try {
            String[] topics = topic.split(",");
            String[] tags = tag.split(",");
            if (topics.length != tags.length) {
                String errorMsg = String.format("The number of topic and tag does not match. topic:%s, tag:%s", topic, tag);
                log.warn(errorMsg);
                throw new IllegalArgumentException(errorMsg);
            }
            for (int i = 0; i < topics.length; i++) {
                Assert.hasText(topics[i], "topic not blank");
                Assert.hasText(tags[i], "tag not blank");
            }
            for (int i = 0; i < topics.length; i++) {
                consumer.subscribe(topics[i], tags[i]);
                log.info("subscribe -> topic:{}, tag:{}", topics[i], tags[i]);
            }
        } catch (MQClientException e) {
            log.error("subscribe fail. topic:{}, tag:{}, error message:{}", topic, tag, e.getErrorMessage());
        }
        return consumer;
    }
}

生产者-测试类：

package com.example.study.mq.test;

import com.example.study.mq.RocketMqFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Scheduled;

/**
 * 生产者测试类
 */
@Configuration
public class ProducerTest {
    private static final String TOPIC_PRE = "test_topic_";
    private static final String TAG_PRE = "test_tag_";
    private static int index = 0;

    @Autowired
    private RocketMqFactory mq;

    /**
     * @Schedule需要生效的话，需要在启动类加上@EnableScheduling注解
     */
    @Scheduled(cron = "0/5 * * * * ?")
    private void sendMsg() {
        String topic = TOPIC_PRE + (index / 2);
        String tag = TAG_PRE + (index);
        String msg = topic + " -> " + tag;
        mq.sendMsg(topic, tag, msg);
        System.out.println("        发送消息:" + msg);
        if (++index >= 4) {
            index = 0;
        }
    }
}

消费者-测试类：

package com.example.study.mq.test;

import com.example.study.mq.RocketMqFactory;
import lombok.extern.slf4j.Slf4j;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import java.util.List;

/**
 * 消费者测试类
 */
@Slf4j
@Configuration
public class ConsumerTest {
    @Autowired
    private RocketMqFactory mq;
    private String topic = "test_topic_0,test_topic_1";
    private String tag = "test_tag_0||test_tag_1,test_tag_3";

    /**
     * 订阅消息，在程序启动时订阅
     */
    @PostConstruct
    private void listenMessage() {
        System.out.println("listen mq msg");
        DefaultMQPushConsumer mqConsumer = mq.getConsumer(topic, tag);
        mqConsumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                if (list == null || list.isEmpty()) {
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
                MessageExt ext = list.get(0);
                if (ext == null || ext.getBody() == null || ext.getBody().length == 0) {
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
                // 消费消息;
                consumeMsg(new String(ext.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        try {
            mqConsumer.start();
        } catch (MQClientException e) {
            log.error("订阅topic失败. msg:{}", e.getErrorMessage());
        }
    }

    /**
     * 消费消息
     *
     * @param msg 待消费的消息
     */
    private void consumeMsg(String msg) {
        System.out.println("消费消息:" + msg);
    }
}

测试结果：

 

3.RocketMQ可视化控制台

3.1.下载地址：https://github.com/apache/rocketmq-externals/tree/release-rocketmq-console-1.0.0

若没有登录github账号，直接下载zip包也可以，解压后用maven打包，打包时会跑不少测试用例，直接跳过测试用例（mvn clean install -Dmaven.test.skip=true）

3.2.使用java -jar 启动，默认端口为8080，需要更改端口请在启动时通过--server.port=xxx注入端口属性；另外，直接修改xxx文件的rocketmq.config.namesrvAddr指定RocketMQ地址，或者通过配置参数注入rocketmq.config.namesrvAddr属性。

比如我的启动参数为：java -jar rocketmq-console-ng-1.0.0.jar --server.port=10010 --rocketmq.config.namesrvAddr=127.0.0.1:9876

3.3.在浏览器打开对应端口