RocketMQ笔记(单机版)

MQ简介

项目工程弊端

MQ简介

MQ（Message Queue）消息队列，是一种用来保存消息数据的队列。队列：数据结构的一种，特征为 “先进先出”

何为消息？服务器间的业务请求。

• 原始架构：

  • 服务器中的A功能需要调用B、C模块才能完成

• 微服务架构：

• 服务器A向服务器B发送要执行的操作（视为消息）

• 服务器A向服务器C发送要执行的操作（视为消息）

MQ作用

优势：

• 应用解耦
• 异步提速
• 削峰填谷

劣势：

• 系统可用性降低
• 系统复杂度提高
• 一致性问题

MQ基本工作模式

应用解耦:（异步消息发送）

流量削锋:（异步消息发送）

MQ产品介绍

1. ActiveMQ
   java语言实现，万级数据吞吐量，处理速度ms级，主从架构，成熟度高
2. RabbitMQ
   erlang语言实现，万级数据吞吐量，处理速度us级，主从架构，
3. RocketMQ
   java语言实现，十万级数据吞吐量，处理速度ms级，分布式架构，功能强大，扩展性强
4. kafka
   scala语言实现，十万级数据吞吐量，处理速度ms级，分布式架构，功能较少，应用于大数据较多

RocketMQ

1. RocketMQ是阿里开源的一款非常优秀中间件产品，脱胎于阿里的另一款队列技术MetaQ，后捐赠 给Apache基金会 作为一款孵化技术，仅仅经历了一年多的时间就成为Apache基金会的顶级项 目。并且它现在已经在阿里内部被广泛 的应用，并且经受住了多次双十一的这种极致场景的压力(2017年的双十一，RocketMQ流转的消息量达到了万亿 级，峰值TPS达到5600万)
2. 解决所有缺点

环境搭建

安装顺序

1. 命名服务器
2. 消息服务器

linux安装过程

1. 步骤1：安装JDK（1.8）
2. 步骤2：上传压缩包（zip）
3. 步骤3：解压缩

unzip rocketmq-all-4.5.2-bin-release.zip

4. 步骤4：修改目录名称

mv rocketmq-all-4.5.2-bin-release rocketmq

启动服务器

1. 步骤1：启动命名服务器（bin目录下）

sh mqnamesrv

2. 步骤2：启动消息服务器（bin目录下）

sh mqbroker -n localhost:9876

修改runbroker.sh文件中有关内存的配置（调整的与当前虚拟机内存匹配即可，推荐256m-
128m）

测试服务器环境

1. 步骤1：配置命名服务器地址

export NAMESRV_ADDR=localhost:9876

2. 步骤2：启动生产者程序客户端（bin目录下）

sh tools.sh org.apache.rocketmq.example.quickstart.Producer

启动后产生大量日志信息（注意该信息是测试程序中自带的，不具有通用性，仅供学习查阅参考）

3. 步骤3：启动消费者程序客户端（bin目录下）

sh tools.sh org.apache.rocketmq.example.quickstart.Consumer

启动后产生大量日志信息

windows安装

运行

添加环境变量

启动NAMESERVER

start mqnamesrv.cmd

启动BROKER

start mqbroker.cmd -n 127.0.0.1:9876 autoCreateTopicEnable=true

注意：闪退回命令行
删除C:\Users\”当前系统用户名”\store下的所有文件。

测试

添加环境变量

NAMESRV_ADDR=localhost:9876

测试生产者发送消息

tools.cmd  org.apache.rocketmq.example.quickstart.Producer

tools.cmd org.apache.rocketmq.example.quickstart.Consumer

控制台安装

1. 下载源码

git clone https://github.com/apache/rocketmq-externals.git

2. 进入rocketmq-externals\rocketmq-console 工程，编译源码

mvn clean package -Dmaven.test.skip=true

3. 运行

java -jar rocketmq-console-ng-2.0.0.jar

消息发送（重点）

单生产者单消费者消息发送（OneToOne）

<dependency> 
    <groupId>org.apache.rocketmq</groupId> 
    <artifactId>rocketmq-client</artifactId> 
    <version>4.8.0</version> 
</dependency>

生产者

public class Producer { 
    public static void main(String[] args) throws Exception {
        /**
        1. 谁来发？
        2. 发给谁？
        3. 怎么发？
        4. 发什么？
        5. 发的结果是什么？
        4消费者
        6. 打扫战场
        **/
        //1.创建一个发送消息的对象Producer
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.设定发送的命名服务器地址
        producer.setNamesrvAddr("localhost:9876");
        //3.1启动发送的服务
        producer.start();
        //4.创建要发送的消息对象,指定topic，指定内容body
        Message msg = new Message("topic1", "hello rocketmq".getBytes("UTF-8"));
        //3.2发送消息
        SendResult result = producer.send(msg); System.out.println("返回结果：" + result);
        //5.关闭连接
        producer.shutdown();
	}
}

消费者

public class Consumer { 
    public static void main(String[] args) throws Exception {
        /**
        1. 谁来发？
        2. 发给谁？
        3. 怎么发？
        4. 发什么？
        5. 发的结果是什么？
        6. 打扫战场
        **/
        //1.创建一个接收消息的对象Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.设定接收的命名服务器地址
        consumer.setNamesrvAddr("localhost:9876");
        //3.设置接收消息对应的topic,对应的sub标签为任意
        consumer.subscribe("topic1","*");
        //3.开启监听，用于接收消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                //遍历消息
                for (MessageExt msg : list) {
                    System.out.println("收到消息："+msg);
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //4.启动接收消息的服务
        consumer.start(); System.out.println("接受消息服务已经开启！");
        //5 不要关闭消费者！
    }
}

单生产者多消费者消息发送（OneToMany）

负载均衡模式

生产者

//1.创建一个发送消息的对象Producer
DefaultMQProducer producer = new DefaultMQProducer("group1");
//2.设定发送的命名服务器地址
producer.setNamesrvAddr("localhost:9876");
//3.1启动发送的服务
producer.start();
for (int i = 0; i < 10; i++) {
    //4.创建要发送的消息对象,指定topic，指定内容body
    Message msg = new Message("topic1", ("hello
    rocketmq"+i).getBytes("UTF-8"));
    //3.2发送消息
    SendResult result = producer.send(msg); System.out.println("返回结果：" + result);
}
//5.关闭连接
producer.shutdown();

消费者（负载均衡模式：默认模式）

开启多实例运行

//1.创建一个接收消息的对象Consumer
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
//2.设定接收的命名服务器地址
consumer.setNamesrvAddr("localhost:9876");
//3.设置接收消息对应的topic,对应的sub标签为任意
consumer.subscribe("topic1","*");
//设置当前消费者的消费模式（默认模式：负载均衡）
consumer.setMessageModel(MessageModel.CLUSTERING);
//3.开启监听，用于接收消息
consumer.registerMessageListener(new MessageListenerConcurrently() {
    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        //遍历消息
        for (MessageExt msg : list) { 
            System.out.println("收到消息："+msg); System.out.println("消息是："+new String(msg.getBody()));
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
});
//4.启动接收消息的服务
consumer.start(); 
System.out.println("接受消息服务已经开启！");
//5 不要关闭消费者！

广播模式

//1.创建一个接收消息的对象Consumer
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
//2.设定接收的命名服务器地址
consumer.setNamesrvAddr("localhost:9876");
//3.设置接收消息对应的topic,对应的sub标签为任意
consumer.subscribe("topic1","*");
//设置当前消费者的消费模式（默认模式：负载均衡）
//consumer.setMessageModel(MessageModel.CLUSTERING);
//设置当前消费者的消费模式（广播模式）
consumer.setMessageModel(MessageModel.BROADCASTING);
//3.开启监听，用于接收消息
consumer.registerMessageListener(new MessageListenerConcurrently() {
    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        //遍历消息
        for (MessageExt msg : list) { 
            System.out.println("收到消息："+msg); System.out.println("消息是："+new String(msg.getBody()));
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
});
//4.启动接收消息的服务
consumer.start(); System.out.println("接受消息服务已经开启！");
//5 不要关闭消费者！

处于不同组的consumer也可以实现广播模式

消息类别

同步消息

特征：即时性较强，重要的消息，且必须有回执的消息，例如短信，通知（转账成功）

代码实现

SendResult result = producer.send(msg);

异步消息

特征：即时性较弱，但需要有回执的消息，例如订单中的某些信息

代码实现

//1.创建一个发送消息的对象Producer
DefaultMQProducer producer = new DefaultMQProducer("group1");
//2.设定发送的命名服务器地址
producer.setNamesrvAddr("localhost:9876");
//3.1启动发送的服务
producer.start();
for (int i = 0; i < 10; i++) {
//4.创建要发送的消息对象,指定topic，指定内容body
Message msg = new Message("topic1", ("hello
rocketmq"+i).getBytes("UTF-8"));
//3.2 同步消息
//SendResult result = producer.send(msg); //System.out.println("返回结果：" + result);
//异步消息
producer.send(msg, new SendCallback() {
    //表示成功返回结果
    @Override
    public void onSuccess(SendResult sendResult) { 			System.out.println(sendResult);
    }
    //表示发送消息失败
    @Override
    public void onException(Throwable throwable) { 			System.out.println(throwable);
    }
});
System.out.println("消息"+i+"发完了，做业务逻辑了！");
//休眠10秒
TimeUnit.SECONDS.sleep(10);
//5.关闭连接
producer.shutdown();

单向消息

特征：不需要有回执的消息，例如日志类消息

代码实现

producer.sendOneway(msg);

延时消息

消息发送时并不直接发送到消息服务器，而是根据设定的等待时间到达，起到延时到达的缓冲作用

Message msg = new Message("topic3",("延时消息：hello rocketmq "+i).getBytes("UTF-
8"));
//设置延时等级3,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)
msg.setDelayTimeLevel(3); SendResult result = producer.send(msg); System.out.println("返回结果："+result);

目前支持的消息时间

private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";

批量消息

批量发送消息能显著提高传递小消息的性能.

发送批量消息:

List<Message> msgList = new ArrayList<Message>();
Message msg1 = new Message("topic1", ("hello rocketmq1").getBytes("UTF-
8"));
Message msg2 = new Message("topic1", ("hello rocketmq2").getBytes("UTF-
8"));
Message msg3 = new Message("topic1", ("hello rocketmq3").getBytes("UTF-
8"));
msgList.add(msg1);                                 msgList.add(msg2); 
msgList.add(msg3);
SendResult result = producer.send(msgList);

注意限制：

1. 这些批量消息应该有相同的topic

2. 相同的waitStoreMsgOK

3. 不能是延时消息

4. 消息内容总长度不超过4M

   消息内容总长度包含如下：

   • topic（字符串字节数）
   • body （字节数组长度）
   • 消息追加的属性（key与value对应字符串字节数）
   • 日志（固定20字节）

消息过滤

分类过滤

按照tag过滤信息。

生产者

Message msg = new Message("topic6","tag2",("消息过滤按照tag：hello rocketmq 2").getBytes("UTF-8"));

消费者

//接收消息的时候，除了制定topic，还可以指定接收的tag,*代表任意tag
consumer.subscribe("topic6","tag1 || tag2");

语法过滤（属性过滤/语法过滤/SQL过滤）

基本语法

• 数值比较，比如：>，>=，<，<=，BETWEEN，=；
• 字符比较，比如：=，<>，IN；
• IS NULL 或者 IS NOT NULL；
• 逻辑符号 AND，OR，NOT；

常量支持类型为：

• 数值，比如：123，3.1415；
• 字符，比如：‘abc’，必须用单引号包裹起来； NULL，特殊的常量
• 布尔值，TRUE 或 FALSE

生产者

//为消息添加属性
msg.putUserProperty("vip","1"); 
msg.putUserProperty("age","20");

消费者

//使用消息选择器来过滤对应的属性，语法格式为类SQL语法
consumer.subscribe("topic7", MessageSelector.bySql("age >= 18")); 
consumer.subscribe("topic6", MessageSelector.bySql("name = 'litiedan'"));

注意：SQL过滤需要依赖服务器的功能支持，在broker.conf配置文件中添加对应的功能项，并开启对应功能

enablePropertyFilter=true

重启broker

start mqbroker.cmd -n 127.0.0.1:9876 autoCreateTopicEnable=true

可能存在缓存,可以使用下面命令更新broker配置

mqadmin.cmd updateBrokerConfig -blocalhost:10911 -kenablePropertyFilter -vtrue

springboot整合

导包

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

配置文件

rocketmq.name-server=localhost:9876 rocketmq.producer.group=demo_producer

生产者

@RestController 
public class DemoProducers { 
    @Autowired 
    private RocketMQTemplate template;
    
    @RequestMapping("/producer") 
    public String producersMessage() { 
    	User user = new User("sharfine", "123456789"); 
        template.convertAndSend("demo-topic", user); 
        return JSON.toJSONString(user);
	}
}

消费者

@Service 
@RocketMQMessageListener(topic = "demo-topic", consumerGroup = "demo_consumer") 
public class DemoConsumers1 implements RocketMQListener<user> {
    @Override 
    public void onMessage(user user) { 
        System.out.println("Consumers1接收消息:" + demoEntity.toString());
	}
}

其他消息

异步发送

rocketMQTemplate.asyncSend("topic9", user, new SendCallback() { 
    @Override public void onSuccess(SendResult sendResult) { 
        System.out.println(sendResult);
	}
	@Override public void onException(Throwable throwable) { 
        System.out.println(throwable);
	}
});

单向发送

rocketMQTemplate.sendOneWay("topic9",user);

延时消息

rocketMQTemplate.syncSend("topic9", MessageBuilder.withPayload("test delay").build(),2000,2);

批量

List<Message> msgList = new ArrayList<>(); 
msgList.add(new Message("topic6", "tag1", "msg1".getBytes())); 
msgList.add(new Message("topic6", "tag1", "msg2".getBytes())); 
msgList.add(new Message("topic6", "tag1", "msg3".getBytes())); rocketMQTemplate.syncSend("topic8",msgList,1000);

Tag过滤

消费者

@RocketMQMessageListener(topic = "topic9",consumerGroup = "group1",selectorExpression = "tag1")

Sql过滤

@RocketMQMessageListener(topic = "topic9",consumerGroup = "group1",selectorExpression = "age>18" ,selectorType= SelectorType.SQL92)

改消息模式

@RocketMQMessageListener(topic = "topic9",consumerGroup = "group1",messageModel = MessageModel.BROADCASTING)

消息的特殊处理

错乱的消息顺序

原因：
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为 分区有序或者全局有序。
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的 queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。 但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取， 则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分 区有序，即相对每个queue，消息都是有序的。

下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。

先读到第一个订单的创建和完成消息

想要的效果

顺序消息

发送消息

//设置消息进入到指定的消息队列中
for (final OrderStep order : orderList) { 
    Message msg = new Message("topic1", order.toString().getBytes());
    //发送时要指定对应的消息队列选择器
    SendResult result = producer.send(msg, new MessageQueueSelector() {
        //设置当前消息发送时使用哪一个消息队列
        public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
            //根据发送的信息不同，选择不同的消息队列
            //根据id来选择一个消息队列的对象，并返回->id得到int值
            long orderId = order.getOrderId(); 
            long mqIndex = orderId % list.size(); 
            return list.get((int) mqIndex);
        }
    }, null);
    System.out.println(result);
}

接收消息

//使用单线程的模式从消息队列中取数据，一个线程绑定一个消息队列
consumer.registerMessageListener(new MessageListenerOrderly() {
    //使用MessageListenerOrderly接口后，对消息队列的处理由一个消息队列多个线程服 务，转化为一个消息队列一个线程服务
    public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) { 
        for (MessageExt msg : list) { 
            System.out.println(Thread.currentThread().getName()+"。消息：" + new String(msg.getBody())+"。queueId:"+msg.getQueueId());
    	}
    	return ConsumeOrderlyStatus.SUCCESS;
    }
});

事务消息

1. 正常事务过程
2. 事务补偿过程

事务消息状态

1. 提交状态：允许进入队列，此消息与非事务消息无区别
2. 回滚状态：不允许进入队列，此消息等同于未发送过
3. 中间状态：完成了half消息的发送，未对MQ进行二次状态确认

注意：事务消息仅与生产者有关，与消费者无关

事务消息

提交状态

//事务消息使用的生产者是TransactionMQProducer
TransactionMQProducer producer = new TransactionMQProducer("group1");
producer.setNamesrvAddr("localhost:9876");
//添加本地事务对应的监听
producer.setTransactionListener(new TransactionListener() {
    //正常事务过程
    public LocalTransactionState executeLocalTransaction(Message message, Object o) {
        return LocalTransactionState.COMMIT_MESSAGE;
    }

    //事务补偿过程
    public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
        return null;
    }
});
producer.start();
Message msg = new Message("topic8", ("事务消息：hello rocketmq ").getBytes("UTF-8"));
SendResult result = producer.sendMessageInTransaction(msg, null); System.out.println("返回结果：" + result);
producer.shutdown();

回滚状态

producer.setTransactionListener(new TransactionListener() {
    //正常事务
    @Override
    public LocalTransactionState executeLocalTransaction(Message msg,
                                                         Object arg) {
        return LocalTransactionState.ROLLBACK_MESSAGE;
    }
    //事务补偿
    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt msg) {
        return null;
    }
});

中间状态

public static void main (String[]args) throws Exception {
    TransactionMQProducer producer = new TransactionMQProducer("group1");
    producer.setNamesrvAddr("localhost:9876");
    producer.setTransactionListener(new TransactionListener() {
        //正常事务
        @Override
        public LocalTransactionState executeLocalTransaction(Message msg,
                                                             Object arg) {
            return LocalTransactionState.UNKNOW;
        }

        //事务补偿 正常执行UNKNOW才会触发
        @Override
        public LocalTransactionState checkLocalTransaction(MessageExt msg) {
            System.out.println("事务补偿");
            return LocalTransactionState.COMMIT_MESSAGE;
        }
    });
    producer.start();
    Message msg = new Message("topic13", "hello rocketmq".getBytes("UTF-8"));
    SendResult result = producer.sendMessageInTransaction(msg, null);
    System.out.println("返回结果：" + result);
    //事务补偿生产者一定要一直启动着
    //producer.shutdown();
}