RabbitMQ笔记

Posted 吹灭读书灯 一身都是月

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了RabbitMQ笔记相关的知识，希望对你有一定的参考价值。

RabbitMQ

1 MQ引言

1.1 什么是MQ

MQ(Message Quene) : 翻译为消息队列,通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。

1.2 MQ有哪些

当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、 RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。

1.3 不同MQ特点

  1. ActiveMQ
    ActiveMQ 是Apache出品，最流行的，能力强劲的开源
    消息总线。它是一个完全支持JMS规范的的消息中间件。
    丰富的API,多种集群架构模式让ActiveMQ在业界成为老
    牌的消息中间件,在中小型企业 颇受欢迎!

  2. Kafka
    Kafka是LinkedIn开源的分布式发布-订阅消息系统，目
    前归属于Apache顶级项目。Kafka主要特点是基于Pull
    的模式来处理消息消费，追求高吞吐量，一开始的目的
    就是用于日志收集和传输。0.8版本开始支持复制，不支
    持事务，对消息的重复、丢失、错误没有严格要求，
    适合产生大量数据的互联网服务的数据收集业务。

  3. RocketMQ
    RocketMQ是阿里开源的消息中间件，它是纯Java开发，
    具有高吞吐量、高可用性、适合大规模分布式系统应用
    的特点。RocketMQ思路起源于Kafka，但并不是Kafka
    的一个Copy，它对消息的可靠传输及事务性做了优化，
    目前在阿里集团被广泛应用于交 易、充值、流计算、
    消息推送、日志流式处理、binglog分发等场景。

  4. RabbitMQ
    RabbitMQ是使用Erlang语言开发的开源消息队列系统，
    基于AMQP协议来实现。AMQP的主要特征是面向消息、
    队列、路由（包括点对点和发布/订阅）、可靠性、安全。
    AMQP协议更多用在企业系统内对数据一致性、稳定性和
    可靠性要求很高的场景，对性能和吞吐量的要求还在
    其次。

RabbitMQ比Kafka可靠，Kafka更适合IO高吞吐的处理，一般应用
在大数据日志处理或对实时性（少量延迟），可靠性（少量丢数据）
要求稍低的场景使用，比如ELK日志收集。

2 RabbitMQ 的引言

2.1 RabbitMQ

基于AMQP协议，erlang语言开发，是部署最广泛的开源 消息中间件,是最受欢迎的开源消息中间件之一。

AMQP 协议
AMQP（advanced message queuing protocol）在2003年
时被提出，最早用于解决金融领不同平台之间的消息传递
交互问题。顾名思义，AMQP是一种协议，更准确的说是
一种binary wire-level protocol（链接协议）。这是其和
JMS的本质差别，AMQP不从API层进行限定，而是直接
定义网络交换的数据格式。这使得实现了AMQP的
provider天然性就是跨平台的。以下是AMQP协议模型:

2.2 RabbitMQ 的安装

1、下载

官网下载地址：https://www.rabbitmq.com/download.html

这里我们选择的版本号（注意这两版本要求）

2、安装

将两个rpm上传到 /usr/local/software 目录下(如果没有 software 需要自己创建)

rpm -ivh erlang-21.3.8.21-1.el7.x86_64.rpm
yum install socat -y
rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm

3、启动

# 启动服务
systemctl start rabbitmq-server
# 查看服务状态
systemctl status rabbitmq-server
# 开机自启动
systemctl enable rabbitmq-server
# 停止服务
systemctl stop rabbitmq-server
# 重启服务
systemctl restart rabbitmq-server

Web管理界面及授权操作

1、安装

默认情况下，是没有安装web端的客户端插件，需要安装才可以生效

rabbitmq-plugins enable rabbitmq_management

安装完毕以后，重启服务即可

systemctl restart rabbitmq-server

开启防火墙：

firewall-cmd --zone=public --add-port=15672/tcp --permanent
firewall-cmd --reload\\

访问 http://ip:15672 ，用默认账号密码(guest)登录，出现权限问题

默认情况只能在 localhost 本机下访问，所以需要添加一个远程登录的用户

2、添加用户

# 创建账号和密码
rabbitmqctl add_user admin 123456

# 设置用户角色
rabbitmqctl set_user_tags admin administrator

# 为用户添加资源权限
# set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"
# 添加配置、写、读权限

用户级别：

  1. administrator：可以登录控制台、查看所有信息、可以对 rabbitmq 进行管理
  2. monitoring：监控者 登录控制台，查看所有信息
  3. policymaker：策略制定者 登录控制台，指定策略
  4. management：普通管理员 登录控制台

再次登录，用 admin 用户

  • 关闭应用的命令为：rabbitmqctl stop_app

  • 清除的命令为：rabbitmqctl reset

  • 重新启动命令为：rabbitmqctl start_app

（失败原因：使用油猴插件开启了倍速播放）

# 1.将rabbitmq安装包上传到linux系统中
	erlang-22.0.7-1.el7.x86_64.rpm  #l7表示是Centosl7,Centosl8表示Centos8
	rabbitmq-server-3.7.18-1.el7.noarch.rpm

# 2.安装Erlang依赖包
	rpm -ivh erlang-22.0.7-1.el7.x86_64.rpm

# 3.安装RabbitMQ安装包(需要联网)
	yum install -y rabbitmq-server-3.7.18-1.el7.noarch.rpm
	注意:默认安装完成后配置文件模板在:/usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example目录中,需要	
	将配置文件复制到/etc/rabbitmq/目录中,并修改名称为rabbitmq.config
# 4.复制配置文件
	cp /usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

# 5.查看配置文件位置
	ls /etc/rabbitmq/rabbitmq.config

# 6.修改配置文件(参见下图:)
	vim /etc/rabbitmq/rabbitmq.config 
# 7.执行如下命令,启动rabbitmq中的插件管理
	rabbitmq-plugins enable rabbitmq_management
	
	出现如下说明:
		Enabling plugins on node rabbit@localhost:
    rabbitmq_management
    The following plugins have been configured:
      rabbitmq_management
      rabbitmq_management_agent
      rabbitmq_web_dispatch
    Applying plugin configuration to rabbit@localhost...
    The following plugins have been enabled:
      rabbitmq_management
      rabbitmq_management_agent
      rabbitmq_web_dispatch

    set 3 plugins.
    Offline change; changes will take effect at broker restart.

# 8.启动RabbitMQ的服务
	systemctl start rabbitmq-server
	systemctl restart rabbitmq-server
	systemctl stop rabbitmq-server
	

# 9.查看服务状态(见下图:)
	systemctl status rabbitmq-server
  ● rabbitmq-server.service - RabbitMQ broker
     Loaded: loaded (/usr/lib/systemd/system/rabbitmq-server.service; disabled; vendor preset: disabled)
     Active: active (running) since 三 2019-09-25 22:26:35 CST; 7s ago
   Main PID: 2904 (beam.smp)
     Status: "Initialized"
     CGroup: /system.slice/rabbitmq-server.service
             ├─2904 /usr/lib64/erlang/erts-10.4.4/bin/beam.smp -W w -A 64 -MBas ageffcbf -MHas ageffcbf -
             MBlmbcs...
             ├─3220 erl_child_setup 32768
             ├─3243 inet_gethost 4
             └─3244 inet_gethost 4
      .........
      
# 10.关闭防火墙服务
	systemctl disable firewalld  # 需要关闭防火墙，否则访问不了
    Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
    Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
	systemctl stop firewalld   

# 11.访问web管理界面
	http://10.15.0.8:15672/

3 RabbitMQ 配置

3.1 RabbitMQ 管理命令行

  1. 服务启动相关

    systemctl start|restart|stop|status rabbitmq-server

  2. 管理命令行 用来在不使用web管理界面情况下命令操作RabbitMQ

    rabbitmqctl help 可以查看更多命令

  3. 插件管理命令行

    rabbitmq-plugins enable|list|disable

3.2 web管理界面介绍

3.2.1 overview概览

  • connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才
    可以完成消息的生产和消费，在这里可以查看连接情况`

  • channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。

  • Exchanges：交换机，用来实现消息的路由

  • Queues：队列，即消息队列，消息存放在队列中，等待消费，
    消费后被移除队列。

3.2.2 Admin用户和虚拟主机管理

3.2.2.1 添加用户

上面的Tags选项，其实是指定用户的角色，可选的有以下几个：

超级管理员(administrator)

可登陆管理控制台，可查看所有的信息，并且可以对用户，
策略(policy)进行操作。

监控者(monitoring)

可登陆管理控制台，同时可以查看rabbitmq节点的相关信息
(进程数，内存使用情况，磁盘使用情况等)

策略制定者(policymaker)

可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的
相关信息(上图红框标识的部分)。

普通管理者(management)

仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。

其他

无法登陆管理控制台，通常就是普通的生产者和消费者。

3.2.2.2 创建虚拟主机

虚拟主机
为了让各个用户可以互不干扰的工作，RabbitMQ添加了虚拟主机（Virtual Hosts）的概念。其实就是一个独立的访问路径，不同用户使用不同路径，各自有自己的队列、交换机，互相不会影响。相当于关系型中的数据库

3.2.2.3 绑定虚拟主机和用户

4 RabbitMQ 的第一个程序

可以直接查看官方文档，讲的更加清楚：https://www.rabbitmq.com/getstarted.html

4.1 AMQP协议的回顾

4.2 RabbitMQ支持的消息模型

4.3 引入依赖

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.7.2</version>
</dependency>

4.4 第一种模型(直连)

在上图的模型中，有以下概念：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接受者，会一直等待消息到来。
  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

4.4.1 开发生产者

public class Provider {

    //生产消息
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
/*
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq主机
        connectionFactory.setHost("192.168.11.143");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接那个虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();*/

        //通过工具类获取连接对象
        Connection connection = RabbitMQUtils.getConnection();

        //获取连接中通道
        Channel channel = connection.createChannel();

        //通道绑定对应消息队列
        //参数1:  队列名称 如果队列不存在自动创建
        //参数2:  用来定义队列特性是否要持久化 true 持久化队列   false 不持久化
        //参数3:  exclusive 是否独占队列  true 独占队列   false  不独占
        //参数4:  autoDelete: 是否在消费完成后自动删除队列  true 自动删除  false 不自动删除
        //参数5:  额外附加参数
        channel.queueDeclare("hello",true,false,false,null);

        //发布消息

        //参数1: 交换机名称 参数2:队列名称  参数3:传递消息额外设置  参数4:消息的具体内容
        channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());


        /*channel.close();
        connection.close();*/
        //调用工具类来关闭连接
     RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

4.4.2 开发消费者

public class Provider {

    //生产消息
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
/*
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq主机
        connectionFactory.setHost("192.168.11.134");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接那个虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();*/

        //通过工具类获取连接对象
        Connection connection = RabbitMQUtils.getConnection();

        //获取连接中通道
        Channel channel = connection.createChannel();

        //通道绑定对应消息队列
        //参数1:  队列名称 如果队列不存在自动创建
        //参数2:  用来定义队列特性是否要持久化 true 持久化队列   false 不持久化
        //参数3:  exclusive 是否独占队列  true 独占队列   false  不独占
        //参数4:  autoDelete: 是否在消费完成后自动删除队列  true 自动删除  false 不自动删除
        //参数5:  额外附加参数
        channel.queueDeclare("hello",true,false,false,null);

        //发布消息

        //参数1: 交换机名称 参数2:队列名称  参数3:传递消息额外设置  参数4:消息的具体内容
        channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());


        /*channel.close();
        connection.close();*/

        //调用工具类
                      RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

4.4.3 参数的说明

channel.queueDeclare("hello",true,false,false,null);
'参数1':用来声明通道对应的队列
'参数2':用来指定是否持久化队列
'参数3':用来指定是否独占队列
'参数4':用来指定是否自动删除队列
'参数5':对队列的额外配置

4.4.4 工具类的包装

package utils;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.Properties;

public class RabbitMQUtils {

    private static ConnectionFactory connectionFactory;
    private static Properties properties;
    static{
        //重量级资源  类加载执行之执行一次
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.42.134");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
    }

    //定义提供连接对象的方法
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //关闭通道和关闭连接工具方法
    public static void closeConnectionAndChanel(Channel channel, Connection conn) {
        try {
            if(channel!=null) channel.close();
            if(conn!=null)   conn.close();
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

    public static void main(String[] args) {
        //System.out.println("RabbitMQUtils.getConnection() = " + RabbitMQUtils.getConnection());
    }
}

4.5 第二种模型(work quene)

Work queues，也被称为（Task queues），任务模型。

工作队列（又名：任务队列）背后的主要思想是避免立即执行资源密集型任务而不得不等待它完成。相反，我们安排任务稍后完成。我们将任务封装 为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当您运行许多工人时，任务将在他们之间共享。

让多个消费者绑定到一个队列，共同消费队列中的消息。
队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。

角色：

  • P：生产者：任务的发布者
  • C1：消费者-1，领取任务并且完成任务，假设完成速度较慢
  • C2：消费者-2：领取任务并完成任务，假设完成速度快

4.5.1 开发生产者

channel.queueDeclare("hello", true, false, false, null);
for (int i = 0; i < 10; i++) {
  channel.basicPublish("", "hello", null, (i+"====>:我是消息").getBytes());
}

4.5.2 开发消费者-1

channel.queueDeclare("hello",true,false,false,null);
channel.basicConsume("hello",true,new DefaultConsumer(channel){
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    System.out.println("消费者1: "+new String(body));
  }
});

4.5.3 开发消费者-2

channel.queueDeclare("hello",true,false,false,null);
channel.basicConsume("hello",true,new DefaultConsumer(channel){
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    try {
      Thread.sleep(1000);   //处理消息比较慢 一秒处理一个消息
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("消费者2: "+new String(body));  
  }
});

4.5.4 测试结果

默认情况下，RabbitMQ 将按顺序将每条消息发送给下一个消费者。平均而言，每个消费者将获得相同数量的消息。这种分发消息的方式称为轮询。

4.5.5 消息自动确认机制

自动确认只要消息发送到了消费者，消息就会从队列中删除。

完成一项任务可能需要几秒钟。您可能想知道，如果其中一个消费者
开始了一项长期任务，但只完成了一部分就挂掉，会发生什么情况。
在我们当前的代码中，一旦RabbitMQ将消息传递给使用者，
它就会立即将其标记为删除。在这种情况下，
如果您杀死一个worker，我们将丢失它刚刚处理的消息。
我们还将丢失发送给该特定工作进程但尚未处理的所有消息。

但我们不想失去任何任务。如果一个worker死了，我们希望把
任务交给另一个worker。

即：比如我分配了5个消息，但是只消费了3个消息就宕机了，2个消息就丢失。

为了确保消息永远不会丢失，RabbitMQ 支持 消息确认。消费者发回确认消息，告诉 RabbitMQ 特定消息已被接收、处理，并且 RabbitMQ 可以自由删除它。

如果消费者在没有发送 ack 的情况下死亡（其通道关闭、连接关闭或 TCP 连接丢失），RabbitMQ 将理解消息未完全处理并将重新排队。如果有其他消费者同时在线，它会迅速将其重新交付给另一个消费者。这样您就可以确保不会丢失任何消息，即使工作人员偶尔会死亡。

4.5.5.1 开发生产者

目的：实现能者多劳的策略。

        //通过通道声明队列
        channel.queueDeclare("work", true, false, false, null);

        for (int i = 1; i <=20; i++) {
            //生产消息
            channel.basicPublish("", "work", null, (i + "hello work quene").getBytes());
        }
4.5.5.2 开发消费者-1

线程sleep 1000 ms

public class Customer1 {
    public static void main(String[] args) throws IOException {

        //获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.basicQos(1);//每一次只能消费一个消息
        channel.queueDeclare("work",true,false,false,null);
        //参数1:队列名称  参数2:消息自动确认 true  消费者自动向rabbitmq确认消息消费  false 不会自动确认消息
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try{
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("消费者-1: "+new String(body));
                // 参数1:确认队列中那个具体消息 参数2:是否开启多个消息同时确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}
4.5.5.3 开发消费者-2
public class Customer2 {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();

        channel.basicQos(1);
        channel.queueDeclare("work",true,false,false,null);

        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-2: "+new String(body));
                //【进行手动确认】  参数1:手动确认消息标识  参数2:false 每次确认一个
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

设置通道一次只能消费一个消息 关闭消息的自动确认,开启手动确认消息。

4.5.6 公平调度

您可能已经注意到调度仍然不能完全按照我们想要的方式工作。例如，在有两个 worker 的情况下，当所有奇数消息都很重，偶数消息很轻时，一个 worker 会一直很忙，而另一个几乎不做任何工作。好吧，RabbitMQ 对此一无所知，仍然会均匀地发送消息。

发生这种情况是因为 RabbitMQ 只是在消息进入队列时分派消息。它不考虑消费者未确认消息的数量。它只是盲目地将每条第 n 条消息分派给第 n 条消费者。

为了解决这个问题，我们可以使用带有prefetchCount = 1设置的basicQos方法 。这告诉 RabbitMQ 一次不要给一个工人多个消息。或者，换句话说，在处理并确认前一条消息之前，不要向工作人员发送新消息。相反，它会将它分派给下一个不忙的工人。

int prefetchCount = 1 ;
channel.basicQos(prefetchCount);

4.5 第三种模型(fanout) Publish/Subscribe

生产者只能将消息发送到交换机。交换是一件非常简单的事情。一方面它接收来自生产者的消息，另一方面将它们推送到队列中。交易所必须确切地知道如何处理它收到的消息。它应该附加到特定

以上是关于RabbitMQ笔记的主要内容，如果未能解决你的问题，请参考以下文章

学习笔记：python3，代码片段（2017）

Rabbitmq的一些笔记

RabbitMQ框架学写笔记-20161201

rabbitmq - 不会获取队列中的所有消息

RabbitMQ安装笔记

RabbitMQ简单学习笔记