消息队列中间件RocketMQ

1.RocketMQ介绍

RocketMQ是一个纯Java、分布式、队列模型的开源消息中间件，前身是MetaQ，是阿里参考Kafka特点研发的一个队列模型的消息中间件，后开源给apache基金会成为了apache的顶级开源项目，具有高性能、高可靠、高实时、分布式特点。
四大核心组成部分：NameServer、Broker、Producer以及Consumer四部分。
NameServer：

主要负责对于源数据的管理，包括了对于Topic和路由信息的管理。

Broker:

消息中转角色，负责存储消息，转发消息。具体提供业务的服务器，并会定时将Topic信息注册到NameServer

Topic:

看做消息的规类，它是消息的第一级类型。

Tag:

可以看作子主题，它是消息的第二级类型，用于为用户提供额外的灵活性。使用标签，同一业务模块不同目的的消息就可以用相同 Topic 而不同的 Tag 来标识。

Group:

分组，一个组可以订阅多个Topic。

2.Linux 环境下启动 rocketmq

先启动 name server
再启动 broker

cd /usr/local/rocketmq/

# 启动 name server
nohup sh bin/mqnamesrv &
# 查看运行日志, 看到"The Name Server boot success."表示启动成功

#再启动 broker
nohup sh bin/mqbroker -n localhost:9876 &
# 查看运行日志, 看到"The broker[......:10911] boot success."表示启动成功

jps
#查看服务状态

运行测试, 启动生产者发送消息, 启动消费者接收消息

# 通过环境变量, 告诉客户端程序name server的地址
export NAMESRV_ADDR=localhost:9876

# 启动生产者来测试发送消息
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

# 启动消费者来测试接收消息
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

3. 关闭 broker | nameserver

mqshutdown broker
mqshutdown namesrv

4. 管理界面

在开源项目 rocketmq-externals 中提供了rocketmq 的管理界面: 地址为: https://github.com/apache/rocketmq-externals

4.1运行启动管理界面

# 运行管理界面
nohup java -jar rocketmq-console-ng-1.0.1.jar --server.port=8080 --rocketmq.config.namesrvAddr=localhost:9876 &

访问管理界面:

http://192.168.64.141:8080

4.2 收发消息出现超时

cd /usr/local/rocketmq/

vim conf/broker.conf

末尾添加
brokerIP1=192.168.64.141

关闭 broker 服务
mqshutdown broker

重新使用 broker.conf 配置启动 broker
nohup sh bin/mqbroker -n localhost:9876 -c conf/broker.conf &

5. Topic 基本原理

生产者的负载均衡

生产者以轮询的方式向所有写队列发送消息，这些队列可能会分布在多个broker实例上。

消费者的负载均衡

AllocateMessageQueueAveragely 平均分配
AllocateMessageQueueAveragelyByCircle 环形分配
AllocateMessageQueueConsistentHash 一致性哈希

6.NameServer 基本原理

NameServer 是 rocketmq 自己开发的一个轻型注册中心，他的作用相当于是 zk、eureka等
rocketmq 为什么不使用 zk 呢？实际上 rocketmq 的早期版本使用的就是 zookeeper。

1.NameServer主要用于存储Topic，Broker关系信息，功能简单，稳定性高。
2.各个NameServer节点之间不相关，不需要通信，单台宕机不影响其它节点。
3.NameServer集群整体宕机不影响已建立关系的Concumer，Producer，Broker。

7.同步消息

同步消息发送要保证强一致性，发到master的消息向slave复制后，才会向生产者发送反馈信息。

这种可靠性同步地发送方式使用的比较广泛

7.1 pom.xml

<?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>

7.2 生产者发送消息

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, RemotingException, InterruptedException, MQBrokerException {
        //创建生产者对象
        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 相当于二级分类
            Message msg = new Message("Topic1", "TagA", s.getBytes());
            //msg.setDelayTimeLevel(3);   //加上就变成延时消息,3为等级3,10s
            SendResult r = p.send(msg);
            System.out.println(r);
        }

    }
}

7.3 消费者接收消息

1. push 和 pull

消费者有两种模式：push 和 pull。

push 模式由服务器主动向消费者发送消息；pull 模式由消费者主动向服务器请求消息。

在消费者处理能力有限时，为了减轻消费者的压力，可以采用pull模式。多数情况下都采用 pull 模式。

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");
        //
        c.setNamesrvAddr("192.168.64.141:9876");
        //设置从哪里订阅消息 "*" 接收所有标签
        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();
    }
}

8.顺序消息

Rocketmq 顺序消息的基本原理：

同一组有序的消息序列，会被发送到同一个队列，按照 FIFO 的方式进行处理
一个队列只允许一个消费者线程接收消息，这样就保证消息按顺序被接收

8.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;
import java.util.Scanner;

public class Producer {
    static String[] msgs = {
            "15103111039,创建",
            					"15103111065,创建",
            "15103111039,付款",
           											 "15103117235,创建",
            					"15103111065,付款",
           											 "15103117235,付款",
            					"15103111065,完成",
            "15103111039,推送",
            										 "15103117235,完成",
            "15103111039,完成"
    };

    public static void main(String[] args) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
        //创建生产者对象
        DefaultMQProducer p = new DefaultMQProducer("prod-group1");
        //设置 name server 注册中心
        p.setNamesrvAddr("192.168.64.141:9876");
        //启动,连接
        p.start();
        //创建消息封装对象 Message(Topic,Tag,消息数据)
        //遍历数组发送消息
        for (String s : msgs){
            // s--"15103111039,完成"
            Long orderId = Long.valueOf(s.split(",")[0]);
            Message msg = new Message("Topic2", s.getBytes());
            //p.send(消息, 队列选择器,选择依据);
            SendResult r = p.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Long orderId = (Long) arg;
                    int index = (int) (orderId % mqs.size());
                    return mqs.get(index);
                }
            }, orderId);
            System.out.println(r);
        }

    }

}

8.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");
        //
        c.setNamesrvAddr("192.168.64.141:9876");
        //设置从哪里订阅消息  * 接收所有标签
        c.subscribe("Topic2", "*");
        //设置消息监听器
        //Concurrently--启动多个线程处理消息
        //Orderly--单个线程
        c.setMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                for(MessageExt ext : list){
                    String s = new String(ext.getBody());
                    System.out.println(s);
                }
                return ConsumeOrderlyStatus.SUCCESS;

            }
        });
        //启动
        c.start();
    }
}

9. RocketMQ 发送事务消息原理

RocketMQ 提供了可靠性消息，也叫事务消息。

9.1 RocketMQ 的事务消息,以下三步：

1.发送半消息（半消息不会发送给消费者）
2.执行本地事务
3.提交消息

然后执行本地事务成功后,提交给RocketMQ
完成事务消息发送后，消费者就可以以正常的方式来消费数据。

1.事务执行失败时回滚消息
2.服务器无法得知消息状态时，需要主动回查消息状态

9.2 生产者发送消息

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 message, 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 messageExt) {
                    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());
            TransactionSendResult r = p.sendMessageInTransaction(msg, "业务数据参数");//(msg,业务数据参数)
            System.out.println("===事务消息结果"+r);
        }


    }
}

9.3 消费者接收消息

package m3;

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 {
        //获取RocketMq 组名,创建消费者对象
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("cons-group3");
        // 设置 name server
        c.setNamesrvAddr("192.168.64.141:9876");
        //设置从哪里订阅消息  * 接收所有标签
        c.subscribe("Topic3", "*");
        //设置消息监听器
        //Concurrently--启动多个线程处理消息
        c.setMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List 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();
    }
}