使用RocketMQ进行消息的发布和订阅的两种方法

星辰小赞

已于 2023-08-28 17:01:47 修改

阅读量1.8k

点赞数

文章标签： rocketmq java spring boot

于 2023-08-28 17:00:48 首次发布

本文链接：https://blog.csdn.net/qq_53799708/article/details/132541769

版权

一、docker安装nameServer和broker服务

（1）设置网络

docker network create rocketmq-network

（2）安装nameServer

docker run -d --name rmqnamesrv --network rocketmq-network -p 9876:9876 rocketmqinc/rocketmq:4.4.0 sh mqnamesrv

（3）安装broker

docker run -d --name rmqbroker --network rocketmq-network -p 10911:10911 -p 10909:10909 -e "NAMESRV_ADDR=rmqnamesrv:9876" rocketmqinc/rocketmq sh mqbroker -c /opt/rocketmq-4.4.0/conf/broker.conf

(4)配置broker.conf

docker exec -it 976e956014a8 bash
976e956014a8----是你自己安装的broker的容器id
[root@976e956014a8 bin]# vi /opt/rocketmq-4.4.0/conf/broker.conf
添加brokerIP1 = 127.0.0.1
之后重启容器

二、RocketMQ进行消息的发布和订阅的方法一

（1）配置yml

rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: your-producer-group
  consumer:
    group: your-consumer-group
    topic: your-topic

（2）创建消息的发布者

package com.example.rocketmq.producer;

import lombok.SneakyThrows;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RocketMQProducer {

    @Autowired
    private DefaultMQProducer defaultMQProducer;

    @SneakyThrows
    public void sendMessage(String message) {
        // 创建消息对象
        Message mqMessage = new Message("your-topic", null, message.getBytes());
        // 发送消息
        SendResult sendResult = defaultMQProducer.send(mqMessage);
        System.out.println("Message sent: " + sendResult);
    }
}

（3）创建消息的订阅者

package com.example.rocketmq.consumer;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "your-topic", consumerGroup = "your-consumer-group")
public class RocketMQConsumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        // 处理接收到的消息
        System.out.println("Received message: " + message);
    }
}

（4）测试结果

package com.example.rocketmq;

import com.example.rocketmq.producer.RocketMQProducer;
//import com.example.rocketmq.producer.RocketMQProducer2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MessageTest implements CommandLineRunner {
    private final RocketMQProducer producer;

    @Autowired
    public MessageTest(RocketMQProducer producer) {
        this.producer = producer;
    }

    @Override
    public void run(String... args) {
        producer.sendMessage("我想给你发消息");
    }
}

在这里插入图片描述

三、RocketMQ进行消息的发布和订阅的方法二

(1) yml配置

rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: your-producer-group
  consumer:
    group: your-consumer-group
  topic: your-topic

（2）发布者

package com.example.rocketmq.producer;

import com.example.rocketmq.JacksonUtils;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.ser.std.SerializableSerializer;
import lombok.*;
import org.apache.rocketmq.common.message.Message;

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class BaseMessage extends SerializableSerializer {
    private String topic;
    private String key;
    private String tag;

    @JsonIgnore
    public Message toRocketMessage(){
        return new Message(topic, tag, key, body());
    }
    @JsonIgnore
    protected byte[] body(){
        return JacksonUtils.toJson(this);
    }

}

package com.example.rocketmq;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonUtils {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static byte[] toJson(Object object){
        try {
            return objectMapper.writeValueAsBytes(object);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
    public static <T> T convert(byte[] bytes, Class<T> clazz) throws Exception {
        return objectMapper.readValue(bytes, clazz);
    }

}

package com.example.rocketmq.producer;

import lombok.SneakyThrows;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class RocketMQProducer2 {
    @Value("${rocketmq.topic}")
    private String topic;

    @Autowired
    private DefaultMQProducer defaultMQProducer;

    @SneakyThrows
    public void sendMessage1(String key) {
        BaseMessage baseMessage = BaseMessage.builder()
                .topic(topic)
                .key(key)
                .tag("my-tag1")
                .build();
        // 创建消息对象
        Message message = baseMessage.toRocketMessage();
        SendResult sendResult = defaultMQProducer.send(message);
        System.out.println("Message sent my-tag1: " + sendResult);
    }

    @SneakyThrows
    public void sendMessage2(String key) {
        BaseMessage baseMessage = BaseMessage.builder()
                .topic(topic)
                .key(key)
                .tag("my-tag2")
                .build();
        // 创建消息对象
        Message message = baseMessage.toRocketMessage();
        SendResult sendResult = defaultMQProducer.send(message);
        System.out.println("Message sent my-tag2: " + sendResult);
    }
}

（3）订阅者

package com.example.rocketmq.consumer;
import com.example.rocketmq.producer.BaseMessage;
import com.example.rocketmq.JacksonUtils;
import lombok.SneakyThrows;
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.apache.rocketmq.spring.autoconfigure.RocketMQProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public abstract class RocketMQConsumer2 implements MessageListenerConcurrently {
    public abstract boolean listen(String tag);
    public abstract boolean doBusiness(BaseMessage obj);

    @Value("${rocketmq.consumer.group}")
    private String consumerGroup;

    @Value("${rocketmq.topic}")
    private String topic;

    @Autowired
    private RocketMQProperties rocketMQProperties;


    @Override
    @SneakyThrows
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> messages, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        for (MessageExt message : messages) {
            BaseMessage baseMessage = JacksonUtils.convert(message.getBody(), BaseMessage.class);
            if (listen(baseMessage.getTag())) {
                doBusiness(baseMessage);
            }
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }

    @Bean(initMethod = "start", destroyMethod = "shutdown")
    public DefaultMQPushConsumer rocketMQConsumers() throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
        consumer.setNamesrvAddr(rocketMQProperties.getNameServer());
        consumer.subscribe(topic, "*");
        consumer.setMessageListener(this);
        return consumer;
    }
}

package com.example.rocketmq.consumer;

import com.example.rocketmq.producer.BaseMessage;
import org.springframework.stereotype.Component;

@Component
public class RocketMQConsumer2Impl extends RocketMQConsumer2 {
    @Override
    public boolean listen(String tag) {
        return "my-tag2".equals(tag);
    }

    @Override
    public boolean doBusiness(BaseMessage obj) {
        System.out.println("Received: my-tag2");
        return true;
    }
}

（4）测试结果

package com.example.rocketmq;

//import com.example.rocketmq.producer.RocketMQProducer;
import com.example.rocketmq.producer.RocketMQProducer2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MessageTest implements CommandLineRunner {

    private final RocketMQProducer2 producer;

    @Autowired
    public MessageTest(RocketMQProducer2 producer) {
        this.producer = producer;
    }

    @Override
    public void run(String... args) {
        producer.sendMessage1("MQ消息1");
        producer.sendMessage2("MQ消息2");
    }
}

在这里插入图片描述

@Override
public boolean listen(String tag) {
    return "my-tag2".equals(tag);
}
是为了监听和匹配上topic和tag都相同的发布者，之后去进行一些业务操作。在这个例子中我们只实现了my-tag2的监听匹配，从结果也可以看出。