RocketMQ 发送普通消息
文章目录
- 普通消息的应用场景
- 1. 创建主题
- rocketmq-client-java 示例（gRPC 协议）
-
- 生产者示例代码
-
- 生产者异步发送消息
- 生产者注意事项
- 消费者示例代码
-
- 消费者注意事项
- rocketmq-client 示例（Remoting 协议）
-
- 生产者
- 消费者
普通消息的应用场景
普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有可靠传输的能力，且对消息的处理时机、处理顺序没有特别要求。如：上游订单系统支付后，下游的物流配送系统、用户积分系统的相关操作。
1. 创建主题
主题的类型与消息的类型要对应，所以普通消息的主题类型为 Normal
./mqadmin updatetopic -n localhost:9876 -c DefaultCluster -t MY_NORMAL_TOPIC -a +message.type=NORMAL
示例中创建了一个名为 MY_NORMAL_TOPIC 的普通消息主题
注：我们的入门示例其实就是一个普通消息，只是我们没有设置消息类型，不设置默认就是NORMAL
rocketmq-client-java 示例（gRPC 协议）
生产者示例代码
import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.Producer;
import org.apache.rocketmq.client.apis.producer.SendReceipt;
import java.io.IOException;
public class NormalProducerDemo {
public static void main(String[] args) throws ClientException {
// 用于提供：生产者、消费者、消息对应的构建类 Builder
ClientServiceProvider provider = ClientServiceProvider.loadService();
// 构建配置类（包含端点位置、认证以及连接超时等的配置）
ClientConfiguration configuration = ClientConfiguration.newBuilder()
// endpoints 即为 proxy 的地址，多个用分号隔开。如：xxx:8081;xxx:8081
.setEndpoints(MyMQProperties.ENDPOINTS)
.build();
// 构建生产者
Producer producer = provider.newProducerBuilder()
// Topics 列表：生产者和主题是多对多的关系，同一个生产者可以向多个主题发送消息
.setTopics("MY_NORMAL_TOPIC","TestTopic")
.setClientConfiguration(configuration)
// 构建生产者，此方法会抛出 ClientException 异常
.build();
// 构建消息类
Message message = provider.newMessageBuilder()
// 设置消息发送到的主题
.setTopic("MY_NORMAL_TOPIC")
// 设置消息索引键，可根据关键字精确查找某条消息。其一般为业务上的唯一值。如：订单id
.setKeys("order_id_1001")
// 设置消息Tag，用于消费端根据指定Tag过滤消息。其一般用作区分不同的业务，最好给它定义好命名规范
.setTag("ORDER_SUBMIT")
// 消息体，单条消息的传输负载不宜过大。所以此处的字节大小最好有个限制
.setBody("{\"success\":true}".getBytes())
.build();
// 发送消息（此处最好进行异常处理，对消息的状态进行一个记录）
try {
SendReceipt sendReceipt = producer.send(message);
System.out.println("Send message successfully, messageId=" + sendReceipt.getMessageId());
} catch (ClientException e) {
System.out.println("Failed to send message");
}
// 发送完，关闭生产者
try {
producer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
生产者异步发送消息
final CompletableFuture<SendReceipt> future = producer.sendAsync(message);
ExecutorService sendCallbackExecutor = Executors.newCachedThreadPool();
future.whenCompleteAsync((sendReceipt, throwable) -> {
if (null != throwable) {
System.out.println("Failed to send message" + throwable.getMessage());
// Return early.
return;
}
System.out.println("Send message successfully, messageId={}" + sendReceipt.getMessageId());
}, sendCallbackExecutor);
生产者注意事项
- 消息体有最大大小限制，不建议传输大负载
RocketMQ 一般传输的是都是业务事件数据。单个原子消息事件的数据大小需要严格控制，如果单条消息过大容易造成网络传输层压力，不利于异常重试和流量控制。
系统默认的消息最大限制如下：
- 普通和顺序消息：4 MB
- 事务和定时或延时消息：64 KB
生产环境中如果需要传输超大负载，建议按照固定大小做报文拆分，或者结合文件存储等方法进行传输。
- 不建议单一进程创建大量生产者
RocketMQ 的生产者和主题是多对多的关系，支持同一个生产者向多个主题发送消息。对于生产者的创建和初始化，建议遵循够用即可、最大化复用原则，如果有需要发送消息到多个主题的场景，无需为每个主题都创建一个生产者。
- 不建议频繁创建和销毁生产者
RocketMQ 的生产者是可以重复利用的底层资源，类似数据库的连接池。因此不需要在每次发送消息时动态创建生产者，且在发送结束后销毁生产者。这样频繁的创建销毁会在服务端产生大量短连接请求，严重影响系统性能。
综上，我们的示例仅为示例，请勿轻易在生产环境中直接使用。实际中可能需要将其定义为一个线程安全的单例，更复杂一点可能需要定义为对象池的方式来提供生产者实例。
消费者示例代码
import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.consumer.ConsumeResult;
import org.apache.rocketmq.client.apis.consumer.FilterExpression;
import org.apache.rocketmq.client.apis.consumer.FilterExpressionType;
import org.apache.rocketmq.client.apis.consumer.PushConsumer;
import java.nio.ByteBuffer;
import java.util.Collections;
public class NormalConsumerDemo {
public static void main(String[] args) throws ClientException {
// 用于提供：生产者、消费者、消息对应的构建类 Builder
ClientServiceProvider provider = ClientServiceProvider.loadService();
// 构建配置类（包含端点位置、认证以及连接超时等的配置）
ClientConfiguration configuration = ClientConfiguration.newBuilder()
// endpoints 即为 proxy 的地址，多个用分号隔开。如：xxx:8081;xxx:8081
.setEndpoints(MyMQProperties.ENDPOINTS)
.build();
// 设置过滤条件（这里为使用 tag 进行过滤）
String tag = "ORDER_SUBMIT";
FilterExpression filterExpression = new FilterExpression(tag, FilterExpressionType.TAG);
// 构建消费者
PushConsumer pushConsumer = provider.newPushConsumerBuilder()
.setClientConfiguration(configuration)
// 设置消费者分组
.setConsumerGroup("MY_ORDER_SUBMIT_GROUP")
// 设置主题与消费者之间的订阅关系
.setSubscriptionExpressions(Collections.singletonMap("MY_NORMAL_TOPIC", filterExpression))
.setMessageListener(messageView -> {
System.out.println(messageView);
ByteBuffer rs = messageView.getBody();
byte[] rsByte = new byte[rs.limit()];
rs.get(rsByte);
System.out.println("Message body：" + new String(rsByte));
// 处理消息并返回消费结果。
System.out.println("Consume message successfully, messageId=" + messageView.getMessageId());
return ConsumeResult.SUCCESS;
}).build();
// 如果不需要再使用 PushConsumer，可关闭该实例。
// pushConsumer.close();
}
}
messageView 对象还可以获取 messageId 、Topic 等信息。
这里有消费者分组、消息过滤等知识点，我们后续都会提到，这里先有个体验即可。
消费者注意事项
- 不建议单一进程创建大量消费者
RocketMQ 的消费者在通信协议层面支持非阻塞传输模式，网络通信效率较高，并且支持多线程并发访问。因此，大部分场景下，单一进程内同一个消费分组只需要初始化唯一的一个消费者即可，开发过程中应避免以相同的配置初始化多个消费者。
- 不建议频繁创建和销毁消费者
RocketMQ 的消费者是可以重复利用的底层资源，类似数据库的连接池。因此不需要在每次接收消息时动态创建消费者，且在消费完成后销毁消费者。这样频繁地创建销毁会在服务端产生大量短连接请求，严重影响系统性能。
rocketmq-client 示例（Remoting 协议）
生产者
import com.yyoo.mq.rocket.MyMQProperties;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
public class NormalProducerDemo {
/**
* 生产者分组
*/
private static final String PRODUCER_GROUP = "NORMAL_PRODUCER_GROUP";
/**
* 主题
*/
private static final String TOPIC = "MY_NORMAL_TOPIC";
public static void main(String[] args) throws MQClientException {
/*
* 创建生产者，并使用生产者分组初始化
*/
DefaultMQProducer producer = new DefaultMQProducer(PRODUCER_GROUP);
/*
* NamesrvAddr 的地址，多个用分号隔开。如：xxx:9876;xxx:9876
*/
producer.setNamesrvAddr(MyMQProperties.NAMESRV_ADDR);
/*
* 发送消息超时时间，默认即为 3000
*/
producer.setSendMsgTimeout(3000);
/*
* 启动生产者，此方法抛出 MQClientException
*/
producer.start();
/*
* 发送消息
*/
for (int i = 1; i <= 2; i++) {
try {
Message msg = new Message();
msg.setTopic(TOPIC);
// 设置消息索引键，可根据关键字精确查找某条消息。
msg.setKeys("messageKey");
// 设置消息Tag，用于消费端根据指定Tag过滤消息。
msg.setTags("messageTag");
// 设置消息体
msg.setBody(("messageBody" + i).getBytes());
// 此为同步发送方式
/*SendResult rs = producer.send(msg);
System.out.printf("%s%n",rs);*/
producer.send(msg, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
System.out.printf("消息发送成功：%s%n", sendResult);
}
@Override
public void onException(Throwable e) {
System.out.println("消息发送失败：" + e.getMessage());
}
});
} catch (Exception e) {
e.printStackTrace();
System.out.println("消息发送失败！i = " + i);
}
}
// 如果生产者不再使用，则调用关闭
// 异步发送消息注意：异步发送消息，建议此处不关闭或者在sleep一段时间后再关闭
// 因为异步 SendCallback 执行的时候，shutdow可能已经执行了，生产者被关闭了
// producer.shutdown();
}
}
消费者
import com.yyoo.mq.rocket.MyMQProperties;
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;
public class NormalConsumerDemo {
/**
* 设置消费者分组
*/
public static final String CONSUMER_GROUP = "NORMAL_CONSUMER_GROUP";
/**
* 主题
*/
public static final String TOPIC = "MY_NORMAL_TOPIC";
public static void main(String[] args) throws MQClientException {
/*
* 通过消费者分组，创建消费者
*/
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(CONSUMER_GROUP);
/*
* NamesrvAddr 的地址，多个用分号隔开。如：xxx:9876;xxx:9876
*/
consumer.setNamesrvAddr(MyMQProperties.NAMESRV_ADDR);
/*
* 指定从哪一个消费位点开始消费 CONSUME_FROM_FIRST_OFFSET 表示从第一个开始
*/
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
/*
* 消费者订阅的主题，和过滤条件
* 我们这里使用 * 表示，消费者消费主题下的所有消息，多个tag 使用 || 隔开
*/
consumer.subscribe(TOPIC, "*");
/*
* 注册消费监听
*/
consumer.registerMessageListener((MessageListenerConcurrently) (msg, context) -> {
System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msg);
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
/*
* 启动消费者.
*/
consumer.start();
System.out.printf("Consumer Started.%n");
// 如果消费者不再使用，关闭
// consumer.shutdown();
}
}