【无标题】

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.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;
import java.util.List;

public class RocketMQUtil {

private static final Logger LOG = LoggerFactory.getLogger(RocketMQUtil.class);

// 生产者和消费者默认的名称服务器地址
private static final String DEFAULT_NAME_SERVER = "127.0.0.1:9876";

/**
 * 创建一个默认的生产者实例
 *
 * @param producerGroup 生产者组名
 * @return 生产者实例
 */
public static DefaultMQProducer createDefaultProducer(String producerGroup) {
    return createProducer(producerGroup, DEFAULT_NAME_SERVER);
}

/**
 * 创建一个默认的Push消费者实例
 *
 * @param consumerGroup 消费者组名
 * @param topic         订阅的主题
 * @param listener      消息监听器
 * @return 消费者实例
 */
public static DefaultMQPushConsumer createDefaultPushConsumer(String consumerGroup, String topic, MessageListener listener) {
    return createPushConsumer(consumerGroup, topic, DEFAULT_NAME_SERVER, listener);
}

/**
 * 创建一个默认的Pull消费者实例
 *
 * @param consumerGroup 消费者组名
 * @param topic         订阅的主题
 * @return 消费者实例
 */
public static DefaultMQPushConsumer createDefaultPullConsumer(String consumerGroup, String topic) {
    return createPullConsumer(consumerGroup, topic, DEFAULT_NAME_SERVER);
}

/**
 * 创建一个生产者实例
 *
 * @param producerGroup 生产者组名
 * @param nameServer    NameServer地址
 * @return 生产者实例
 */
public static DefaultMQProducer createProducer(String producerGroup, String nameServer) {
    DefaultMQProducer producer = new DefaultMQProducer(producerGroup);
    producer.setNamesrvAddr(nameServer);
    try {
        producer.start();
        LOG.info("Producer started, group = {}, namesrvAddr = {}", producerGroup, nameServer);
    } catch (MQClientException ex) {
        LOG.error("Failed to start producer.", ex);
        throw new RuntimeException("Failed to start producer.", ex);
    }
    return producer;
}

/**
 * 创建一个Push消费者实例
 *
 * @param consumerGroup 消费者组名
 * @param topic         订阅的主题
 * @param nameServer    NameServer地址
 * @param listener      消息监听器
 * @return 消费者实例
 */
public static DefaultMQPushConsumer createPushConsumer(String consumerGroup, String topic, String nameServer, MessageListener listener) {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
    consumer.setNamesrvAddr(nameServer);
    try {
        consumer.subscribe(topic, "*");
        consumer.registerMessageListener(listener);
        consumer.start();
        LOG.info("Push consumer started, group = {}, topic = {}, namesrvAddr = {}", consumerGroup, topic, nameServer);
    } catch (MQClientException ex) {
        LOG.error("Failed to start push consumer.", ex);
        throw new RuntimeException("Failed to start push consumer.", ex);
    }
    return consumer;
}

/**
 * 创建一个Pull消费者实例
 *
 * @param consumerGroup 消费者组名
 * @param topic         订阅的主题
 * @param nameServer    NameServer地址
 * @return 消费者实例
 */
public static DefaultMQPushConsumer createPullConsumer(String consumerGroup, String topic, String nameServer) {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
    consumer.setNamesrvAddr(nameServer);
    try {
        consumer.subscribe(topic, "*");
        consumer.start();
        LOG.info("Pull consumer started, group = {}, topic = {}, namesrvAddr = {}", consumerGroup, topic, nameServer);
    } catch (MQClientException ex) {
        LOG.error("Failed to start pull consumer.", ex);
        throw new RuntimeException("Failed to start pull consumer.", ex);
    }
    return consumer;
}

/**
 * 发送一个普通的RocketMQ消息
 *
 * @param producer 生产者实例
 * @param topic    主题名
 * @param body     消息正文
 * @throws InterruptedException 操作被中断异常
 * @throws RemotingException     远程连接异常
 * @throws MQClientException     客户端异常
 */
public static void send(DefaultMQProducer producer, String topic, String body) throws InterruptedException, RemotingException, MQClientException {
    Message message = new Message(topic, body.getBytes(StandardCharsets.UTF_8));
    SendResult result = producer.send(message);
    LOG.debug("Sent message: {}, result: {}", message, result);
}

/**
 * 发送一个顺序的RocketMQ消息
 *
 * @param producer 生产者实例
 * @param topic    主题名
 * @param tags     消息标签
 * @param body     消息正文
 * @param key      消息关键字
 * @throws InterruptedException 操作被中断异常
 * @throws RemotingException     远程连接异常
 * @throws MQClientException     客户端异常
 */
public static void sendOrderly(DefaultMQProducer producer, String topic, String tags, String body, String key) throws InterruptedException, RemotingException, MQClientException {
    Message message = new Message(topic, tags, key, body.getBytes(StandardCharsets.UTF_8));
    SendResult result = producer.send(message, new MessageQueueSelector() {
        @Override
        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
            String key = (String) arg;
            int index = Math.abs(key.hashCode()) % mqs.size();
            return mqs.get(index);
        }
    }, key);
    LOG.debug("Sent message: {}, result: {}", message, result);
}

/**
 * 发送一个延迟的RocketMQ消息
 *
 * @param producer 生产者实例
 * @param topic    主题名
 * @param body     消息正文
 * @param delay    延迟时间，单位：毫秒
 * @throws InterruptedException 操作被中断异常
 * @throws RemotingException     远程连接异常
 * @throws MQClientException     客户端异常
 */
public static void sendDelay(DefaultMQProducer producer, String topic, String body, int delay) throws InterruptedException, RemotingException, MQClientException {
    Message message = new Message(topic, body.getBytes(StandardCharsets.UTF_8));
    message.setDelayTimeLevel(delay / 1000);
    SendResult result = producer.send(message);
    LOG.debug("Sent message: {}, result: {}", message, result);
}

/**
 * 发送一个事务型的RocketMQ消息
 *
 * @param producer          生产者实例
 * @param transactionListener 事务监听器
 * @param topic             主题名
 * @param body              消息正文
 * @throws InterruptedException 操作被中断异常
 * @throws RemotingException     远程连接异常
 * @throws MQClientException     客户端异常
 */
public static void sendTransaction(TransactionMQProducer producer, TransactionListener transactionListener, String topic, String body) throws InterruptedException, RemotingException, MQClientException {
    Message message = new Message(topic, body.getBytes(StandardCharsets.UTF_8));
    producer.sendMessageInTransaction(message, transactionListener, null);
}

/**
 * 关闭一个生产者实例
 *
 * @param producer 生产者实例
 */
public static void shutdown(DefaultMQProducer producer) {
    producer.shutdown();
    LOG.info("Producer shutdown.");
}

/**
 * 关闭一个消费者实例
 *
 * @param consumer 消费者实例
 */
public static void shutdown(DefaultMQPushConsumer consumer) {
    consumer.shutdown();
    LOG.info("Consumer shutdown.");
}

/**
 * 处理接收到的RocketMQ消息
 *
 * @param message 消息对象
 */
public static void handleMessage(MessageExt message) {
    LOG.info("Received message: {}", new String(message.getBody()));
}

}