一 工程准备
首先:启动rocketmq以及管理界面
# 进入 rocketmq 目录
cd /usr/local/rocketmq/
# rocketmq 目录下启动 name server
nohup sh bin/mqnamesrv &
#rocketmq 目录下 启动 broker, 连接name server: localhost:9876
nohup sh bin/mqbroker -n localhost:9876 &
#jps查看,如果broker没启动,就使用下面这个命令启动broker
nohup sh bin/mqbroker -n localhost:9876 -c conf/broker.conf &
# cd ~/ 再运行管理界面
nohup java -jar rocketmq-console-ng-1.0.1.jar --server.port=8080 --rocketmq.config.namesrvAddr=localhost:9876 &
第一步:新建空工程
第二步:配置maven,fend confing,Java companies ,创建maven工程
第三步:pom.xml文件添加rocketmq依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.tedu</groupId>
<artifactId>rocketmq-api</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.7.1</version>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-store</artifactId>
<version>4.7.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
二 同步消息
同步消息发送要保证强一致性,发到master的消息向slave复制后,才会向生产者发送反馈信息。
这种可靠性同步地发送方式使用的比较广泛,比如:重要的消息通知,短信通知。
1 生产者
package m1;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import java.util.Scanner;
//消息生产者
public class Producer {
public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
// 创建生产者对象
DefaultMQProducer p = new DefaultMQProducer("prod-group1");
// 设置 name server
p.setNamesrvAddr("192.168.64.141:9876");
// 启动生产者,连接消息服务器
p.start();
// 创建消息封装对象 Message(Topic,Tag,消息)
//发送
while (true) {
System.out.println("输入消息");
String s = new Scanner(System.in).nextLine();
//Topic--相当于是一级分类,Tag--相当于是二级分类,s--消息以数组的形式发送
Message msg = new Message("Topic1", "TagA", s.getBytes());
//服务器的反馈信息
SendResult r = p.send(msg);
System.out.println(r);
}
}
}
- 启动并发送消息测试
- rocketmq服务器:
- 其中:时间与北京时间提前8小时时差
2 消费者
消费者的要点:
1. push 和 pull
消费者有两种模式:push 和 pull。
push 模式由服务器主动向消费者发送消息;pull 模式由消费者主动向服务器请求消息。
在消费者处理能力有限时,为了减轻消费者的压力,可以采用pull模式。多数情况下都采用 pull 模式。
2. NameServer
消费者需要向 NameServer 询问 Topic 的路由信息。
3. Topic
从指定的Topic接收消息。Topic相当于是一级分类。
4. Tag
Topic 相当于是一级分类,Tag 相当于是2级分类。
多个 Tag 可以这样写: TagA || TagB || TagC
不指定 Tag,或者说接收所有的 Tag,可以写星号: *
package m1;
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 java.util.List;
//消息消费者
public class Consumer {
public static void main(String[] args) throws MQClientException {
// 创建消费者对象
DefaultMQPushConsumer c =
new DefaultMQPushConsumer("cons-group1");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
// 设置 name server 注册中心
c.setNamesrvAddr("192.168.64.141:9876");
// 设置从哪里订阅消息
//tag标签: * -- 星号表示所有标签 ,TagA --只接收TagA
c.subscribe("Topic1","TagA || TagB || TagC");
// 设置消息监听器
// Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
c.setMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
for (MessageExt ext : msgs) {
String s = new String(ext.getBody());
System.out.println("收到: "+s);
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消息发送成功
// return ConsumeConcurrentlyStatus.RECONSUME_LATER;//稍后重新消费
}
});
// 启动
c.start();
}
}
- 启动消费者接收生产者消息: 消费者多线程并行处理消息,无序接收消息
三 延时消息
消息发送到 Rocketmq 服务器后, 延迟一定时间再向消费者进行投递。
延时消息的使用场景:
比如电商里,提交了一个订单就可以发送一个延时消息,1h后去检查这个订单的状态,如果还是未付款就取消订单释放库存。
生产者发送消息时,对消息进行延时设置:
msg.setDelayTimeLevel(3);
其中 3 代表级别而不是一个具体的时间值,级别和延时时长对应关系是在 MessageStoreConfig 类种进行定义的:
this.messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
对应关系表:
级别 | 延时时长 |
---|---|
1 | 1s |
2 | 5s |
3 | 10s |
4 | 30s |
5 | 1m |
6 | 2m |
7 | 3m |
8 | 4m |
9 | 5m |
10 | 6m |
11 | 7m |
12 | 8m |
13 | 9m |
14 | 10m |
15 | 20m |
16 | 30m |
17 | 1h |
18 | 2h |
1 生产者--设置延时级别
package m1;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import java.util.Scanner;
//消息生产者
public class Producer {
public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
// 创建生产者对象
DefaultMQProducer p = new DefaultMQProducer("prod-group1");
// 设置 name server
p.setNamesrvAddr("192.168.64.141:9876");
// 启动生产者,连接消息服务器
p.start();
// 创建消息封装对象 Message(Topic,Tag,消息)
//发送
while (true) {
System.out.print("输入消息:");
String s = new Scanner(System.in).nextLine();
//Topic--相当于是一级分类,Tag--相当于是二级分类,s--消息以数组的形式发送
Message msg = new Message("Topic1", "TagA", s.getBytes());
//设置延时级别
msg.setDelayTimeLevel(3);//设置延时级别3--延时10秒
//服务器的反馈信息
SendResult r = p.send(msg);
System.out.println(r);
}
}
}
2 消费者--延时级别对应的时间过后才能接收到消息
package m1;
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 java.util.List;
//消息消费者
public class Consumer {
public static void main(String[] args) throws MQClientException {
// 创建消费者对象
DefaultMQPushConsumer c =
new DefaultMQPushConsumer("cons-group1");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
// 设置 name server 注册中心
c.setNamesrvAddr("192.168.64.141:9876");
// 设置从哪里订阅消息
//tag标签: * -- 星号表示所有标签 ,TagA --只接收TagA
c.subscribe("Topic1","TagA || TagB || TagC");
// 设置消息监听器
// Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
c.setMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
for (MessageExt ext : msgs) {
String s = new String(ext.getBody());
System.out.println("收到: "+s);
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消息发送成功
// return ConsumeConcurrentlyStatus.RECONSUME_LATER;//稍后重新消费
}
});
// 启动
c.start();
}
}
- 启动生产者,消费者进行测试:
消息生产者发送消息,设置延时级别对应的时间过后消费者自动收到消息
注意:如果设置稍后重新消费,接收消息失败时,服务器会按照延时级别慢慢提升而反复发送消息的时间间隔也拉长,直到18个级别都结束,就不会再发送消息,总共4个小时多;如果还没接收,该消息会被放入死信消息队列,需要其他方法处理,比如可以人工后台手动调整消息生产者和消费者一致的状态.
四 顺序消息
上图演示了 Rocketmq 顺序消息的基本原理:
- 同一组有序的消息序列,会被发送到同一个队列,按照 FIFO 的方式进行处理
- 一个队列只允许一个消费者线程接收消息,这样就保证消息按顺序被接收
下面以订单为例:
- 一个订单的顺序流程是:创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中。消费时,从同一个队列接收同一个订单的消息。
1 生产者
package m2;
import org.apache.rocketmq.client.exception.MQBrokerException;
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.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.exception.RemotingException;
import java.util.List;
//顺序消息生产者
public class Producer {
static String[] msgs = {
"15103111039,创建",
"15103111065,创建",
"15103111039,付款",
"15103117235,创建",
"15103111065,付款",
"15103117235,付款",
"15103111065,完成",
"15103111039,推送",
"15103117235,完成",
"15103111039,完成"
};
public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
// 创建生产者对象
DefaultMQProducer p = new DefaultMQProducer("prod-group2");
// 设置 name server
p.setNamesrvAddr("192.168.64.141:9876");
// 启动生产者,连接消息服务器
p.start();
// 遍历数组发送消息
for (String s : msgs) {
// s -- "15103111039,完成"
Long orderId = Long.valueOf(s.split(",")[0]);//取出订单的id
Message msg = new Message("Topic2", s.getBytes());
//p.send(消息, 队列选择器是匿名内部类, 选择依据是订单id);
SendResult r =
p.send(msg, new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> mqs, Message message, Object arg) {
Long orderId = (Long) arg;
//订单id对队列数量取余, 相同订单id得到相同的队列索引
int index = (int) (orderId % mqs.size());
return mqs.get(index);
}
}, orderId);
System.out.println(r);
}
}
}
- 启动后:
2 消费者
package m2;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.*;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;
//顺序消息消费者
public class Consumer {
public static void main(String[] args) throws MQClientException {
// 创建消费者对象
DefaultMQPushConsumer c =
new DefaultMQPushConsumer("cons-group2");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
// 设置 name server 注册中心
c.setNamesrvAddr("192.168.64.141:9876");
// 设置从哪里订阅消息
//tag标签: * -- 星号表示所有标签
c.subscribe("Topic2","*");
// 设置消息监听器
// Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
// Orderly -- 单个线程
c.setMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext consumeOrderlyContext) {
for (MessageExt ext : msgs){
String s = new String(ext.getBody());
System.out.println("收到: " +s);
}
return ConsumeOrderlyStatus.SUCCESS;
}
});
// 启动
c.start();
}
}
- 启动生产者和消费者进行测试:
服务器:
五 事务消息
RocketMQ 提供了可靠性消息,也叫事务消息。
事务消息的原理
下面来看 RocketMQ 的事务消息是如何来发送“可靠消息”的,只需要以下三步:
- 发送半消息(半消息不会发送给消费者)
- 执行本地事务
- 提交消息
完成事务消息发送后,消费者就可以以正常的方式来消费数据。
RocketMQ 的自动重发机制在绝大多数情况下,都可以保证消息被正确消费。
假如消息最终消费失败了,还可以由人工处理进行托底。
上面分析的是正常情况下的执行流程。下面再来看两种错误情况:
- 事务执行失败时回滚消息
- 服务器无法得知消息状态时,需要主动回查消息状态
回滚:
消息回查:
1 生产者
package m3;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.Scanner;
public class Producer {
public static void main(String[] args) throws MQClientException {
// 创建事务消息生产者
TransactionMQProducer p =
new TransactionMQProducer("prod-group3");
// 设置 name server
p.setNamesrvAddr("192.168.64.141:9876");
// 设置事务消息监听器
//1. 执行本地事务(调用*service.执行业务方法())
//2. 处理rocketmq的事务回查
p.setTransactionListener(new TransactionListener() {
//执行本地事务
@Override
public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
System.out.println("执行本地业务, 参数: "+arg);
if (Math.random()<0.5){
System.out.println("本地事务执行成功");
return LocalTransactionState.COMMIT_MESSAGE;// 提交消息并通知服务器,消息可以进行投递
}else {
System.out.println("本地事务执行失败");
return LocalTransactionState.ROLLBACK_MESSAGE;// 失败时,回滚消息,撤回消息
}
//return LocalTransactionState.UNKNOW; //未知,当前方法中,一般不会有此情况,
}
@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
return null;
}
});
// 启动
p.start();
// 发送事务消息,触发事务消息监听器
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
Message msg = new Message("Topic3", s.getBytes());//Tag标签可加可不加,此处省略
//p.sendMessageInTransaction(msg,arg(业务数据参数));
TransactionSendResult r = p.sendMessageInTransaction(msg, "业务数据参数");
System.out.println("---事务消息结果: "+ r);
}
}
}
- 单独启动生产者并发送消息进行测试:
-
模拟网络不稳定, 不能向服务器提交或回滚消息
package m3;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.Scanner;
public class Producer {
public static void main(String[] args) throws MQClientException {
// 创建事务消息生产者
TransactionMQProducer p =
new TransactionMQProducer("prod-group3");
// 设置 name server
p.setNamesrvAddr("192.168.64.141:9876");
// 设置事务消息监听器
//1. 执行本地事务(调用*service.执行业务方法())
//2. 处理rocketmq的事务回查
p.setTransactionListener(new TransactionListener() {
//执行本地事务
@Override
public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
/*模拟网络不稳定, 不能向服务器提交或回滚消息*/
if (Math.random() < 1) {
System.out.println("网络中断,无法向服务器提交或回滚");
return LocalTransactionState.UNKNOW;
}
System.out.println("执行本地业务, 参数: "+arg);
if (Math.random()<0.5){
System.out.println("本地事务执行成功");
return LocalTransactionState.COMMIT_MESSAGE;// 提交消息并通知服务器,消息可以进行投递
}else {
System.out.println("本地事务执行失败");
return LocalTransactionState.ROLLBACK_MESSAGE;// 失败时,回滚消息,撤回消息
}
//return LocalTransactionState.UNKNOW; //未知,当前方法中,一般不会有此情况,
}
//事务回查方法
@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
System.out.println("rocketmq 服务器正在回查事务状态");
/*上面本地事务还没有执行结束
* 无法获取事务状态
* */
return LocalTransactionState.UNKNOW; //返回未知,会一直回查下去
}
});
// 启动
p.start();
// 发送事务消息,触发事务消息监听器
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
Message msg = new Message("Topic3", s.getBytes());//Tag标签可加可不加,此处省略
//p.sendMessageInTransaction(msg,arg(业务数据参数));
TransactionSendResult r = p.sendMessageInTransaction(msg, "业务数据参数");
System.out.println("---事务消息结果: "+ r);
}
}
}
- 启动测试消息回查方法