springboot整合rocketmq
一,引入依赖
4.7.0版本引入2.1.0版本,4.8.0引入2.2.0
org.apache.rocketmq rocketmq-spring-boot-starter 2.1.0 or 2.2.0二,配置项:
生产者配置:
#消息轨迹功能,如果开启了acl控制
#在给生产者和消费者分配用户权限时需要额外分配-i PUB(defaultTopicPerm=PUB),否则默认的RMQ_SYS_TRACE_TOPIC无权限
#如果需要指定自定义消息轨迹topic,需要提前申请创建对应的topic,默认自动创建被禁用
rocketmq.producer.customized-trace-topic=RMQ_SYS_TRACE_TOPIC
rocketmq.producer.enable-msg-trace=true
#rocketmq连接地址
rocketmq.name-server=127.0.0.1:9876
#生产者组自定义即可
rocketmq.producer.group=my-group
#集群关闭自动创建topic的话topic无法自动创建,需要提前通过管理台创建
demo.rocketmq.topic=test
#配置acl用户名密码
rocketmq.producer.access-key=rocketmq02
rocketmq.producer.secret-key=12345678
#其他的NameServer地址,对于需要操作多数据源的项目配置不同于rocketmq.name-server的值即可
demo.rocketmq.extNameServer=127.0.0.1:9876
性能优化
##生产者发送消息超时时间,默认3s
rocketmq.producer.send-message-timeout=15000
##生产者消息压缩大小,默认达到4KB启用消息压缩
rocketmq.producer.compress-message-body-threshold=4096
##生产者发送消息最大字节数,默认4MB
rocketmq.producer.max-message-size=4194304
##生产者发送异步消息失败后重试次数,默认0次
rocketmq.producer.retry-times-when-send-async-failed=0
##生产者消息失败容错策略,默认false不开启,生产环境建议开启
rocketmq.producer.retry-next-server=true
##生产者发送同步消息失败后重试次数,默认2次
rocketmq.producer.retry-times-when-send-failed=2
消费者配置:
#消费端配置
#Push模式
#demo.rocketmq.topic=test5
demo.rocketmq.consumerGroup=test5_group
rocketmq.consumer.access-key=rocketmq06
rocketmq.consumer.secret-key=12345678
#性能优化 Push模式
#设置demo.rocketmq.selector-expression=order只消费tag=order的数据,消息过滤表达式
demo.rocketmq.selector-expression=*
demo.rocketmq.selector-type=TAG
demo.rocketmq.message-model=MessageModel.CLUSTERING
#pull消费模式配置,pull模式只支持2.2.0以上的版本
#rocketmq.consumer.group=test1_group
#rocketmq.consumer.topic=test1
#rocketmq.consumer.access-key=rocketmq2
#rocketmq.consumer.secret-key=12345678
#性能优化 Pull模式下
#rocketmq.consumer.selector-expression=*
#rocketmq.consumer.pull-batch-size=10
#rocketmq.consumer.message-model=CLUSTERING
#TAG or SelectorType.SQL92
#rocketmq.consumer.selector-type=TAG
三,代码展示:
生产者代码:
@SpringBootTest
class DemoApplicationTests {
@Resource
private RocketMQTemplate rocketMQTemplate;
@Resource(name = "extRocketMQTemplate")
private RocketMQTemplate extRocketMQTemplate;
@Value("${demo.rocketmq.topic}")
private String springTopic;
/\*\*
\* 发送单向消息
\* @throws Exception
\*/
@Test
void SimpleOnewayProducer() throws Exception {
rocketMQTemplate.sendOneWay(springTopic, "Hello, World!");
}
/\*\*
\* 发送同步消息
\* @throws Exception
\*/
@Test
void SimpleSyncProducer() throws Exception {
SendResult sendResult = rocketMQTemplate.syncSend(springTopic, "Hello, World!");
System.out.printf("syncSend1 to topic %s sendResult=%s %n", springTopic, sendResult);
}
/\*\*
\* 发送异步消息
\* @throws Exception
\*/
@Test
void SimpleAsyncProducer() throws Exception {
rocketMQTemplate.asyncSend(springTopic, "Hello, World!", new SendCallback() {
@Override
public void onSuccess(SendResult var1) {
System.out.printf("async onSucess SendResult=%s %n", var1);
}
@Override
public void onException(Throwable var1) {
System.out.printf("async onException Throwable=%s %n", var1);
}
});
}
/\*\*
\* 发送延时消息
\* 延时等级1到16分别表示 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h,3表示延迟10s发送
\* @throws Exception
\*/
@Test
void ScheduledSyncProducer() throws Exception {
String replyString = rocketMQTemplate.syncSend(springTopic,MessageBuilder.withPayload("request string").build(),15000,3);
System.out.printf("send %s and receive %s %n", "request string", replyString);
}
/\*\*
\* 发送顺序消息
\* @throws Exception
\*/
@Test
void OrderProducer() throws Exception {
rocketMQTemplate.setMessageQueueSelector((List<MessageQueue> mqs, Message msg, Object arg)->{
/\*\*
\* mqs:要发送消息的topic下的所有消息队列集合,集群的话默认是所有broker的队列
\* msg:发送的消息
\* arg:发送消息时传递的参数 通过该参数指定发送到哪个队列,对应 String.valueOf(i)
\*/
int queueNum = Integer.valueOf(String.valueOf(arg)) % mqs.size();
System.out.println("队列id:"+queueNum+" 消息:"+new String(msg.getBody()));
return mqs.get(queueNum);
});
for(int i=1;i<=100;i++){
String msg="type:"+i%4+" value:"+i;
rocketMQTemplate.syncSendOrderly(springTopic,msg, String.valueOf(i));
}
}
/\*\*
\* 批量发送消息
\* @throws Exception
\*/
@Test
void BatchProducer() throws Exception {
List<org.springframework.messaging.Message> msgs = new ArrayList<org.springframework.messaging.Message>();
for (int i = 0; i < 10; i++) {
msgs.add(MessageBuilder.withPayload("Hello RocketMQ Batch Msg#" + i).
setHeader(RocketMQHeaders.KEYS, "KEY\_" + i).build());
}
SendResult sr = rocketMQTemplate.syncSend(springTopic, msgs, 60000);
System.out.printf("--- Batch messages send result :" + sr);
}
/\*\*
\* 发送过滤消息
\* @throws Exception
\*/
@Test
void FilterProducer() throws Exception {
//发送带有标签的消息
rocketMQTemplate.convertAndSend(springTopic + ":tag0", "Hello, World!I'm from tag0");
}
/\*\*
\* 发送事务消息
\* 回传的事务状态:
\* TransactionStatus.CommitTransaction: 提交事务,它允许消费者消费此消息。
\* TransactionStatus.RollbackTransaction: 回滚事务,它代表该消息将被删除,不允许被消费。
\* TransactionStatus.Unknown: 中间状态,它代表需要检查消息队列来确定状态。
\* @throws Exception
\*/
@Test
void TransactionProducer() throws Exception {
String\[\] tags = new String\[\] {"TagA", "TagB", "TagC", "TagD", "TagE"};
for (int i = 0; i < 10; i++) {
try {
org.springframework.messaging.Message msg = MessageBuilder.withPayload("rocketMQTemplate transactional message " + i).
setHeader(RocketMQHeaders.TRANSACTION\_ID, "KEY\_" + i).build();
SendResult sendResult = rocketMQTemplate.sendMessageInTransaction(
springTopic + ":" + tags\[i % tags.length\], msg, null);
System.out.printf("------rocketMQTemplate send Transactional msg body = %s , sendResult=%s %n",
msg.getPayload(), sendResult.getSendStatus());
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/\*\*
\* 多数据源使用
\* @throws Exception
\*/
@Test
void ExtRocketMQTemplateProducer() throws Exception {
SendResult sendResult1 = extRocketMQTemplate.syncSend(springTopic, MessageBuilder.withPayload("Hello, World!2222".getBytes()).build());
System.out.printf("extRocketMQTemplate.syncSend1 to topic %s sendResult=%s %n", springTopic, sendResult1);
}
/\*\*
\* 事务消息监听实现
\*/
@RocketMQTransactionListener
class TransactionListenerImpl implements RocketMQLocalTransactionListener {
private AtomicInteger transactionIndex = new AtomicInteger(0);
private ConcurrentHashMap<String, Integer> localTrans = new ConcurrentHashMap<String, Integer>();
//Broker预提交成功后回调Producer的executeLocalTransaction方法
@Override
public RocketMQLocalTransactionState executeLocalTransaction(org.springframework.messaging.Message msg, Object arg) {
String transId = (String) msg.getHeaders().get(RocketMQHeaders