[心得体会]RabbitMQ

RabbitMQ是什么?

消息队列, 基于AMQP(高级消息队列), 使用Erlang语言编写, 收发消息使用

有什么用? 有什么应用场景?

1. 任务异步处理

2. 应用程序解耦

为什么使用RabbitMQ?

1. 使用简单

2. 基于AMQP

3. 社区活动

4, 高并发性能好(Erlang语言)

5. springboot默认集成RabbitMQ

AMQP是什么?

AMQP，即Advanced Message Queuing Protocol，

一个提供统一消息服务的应用层标准高级消息队列协议，

是应用层协议的一个开放标准，为面向消息的中间件设计。

基于此协议的客户端与消息中间件可传递消息，

并不受客户端/中间件不同产品，不同的开发语言等条件的限制。

AMQP，即Advanced Message Queuing Protocol，

一个提供统一消息服务的应用层标准高级消息队列协议，

是应用层协议的一个开放标准，为面向消息的中间件设计。

基于此协议的客户端与消息中间件可传递消息，

并不受客户端/中间件不同产品，不同的开发语言等条件的限制。

AMQP的应用场景

存储转发（多个消息发送者，单个消息接收者）。

分布式事务（多个消息发送者，多个消息接收者）。

发布订阅（多个消息发送者，多个消息接收者）。

基于内容的路由（多个消息发送者，多个消息接收者）。

文件传输队列（多个消息发送者，多个消息接收者）。

点对点连接（单个消息发送者，单个消息接收者）。

RabbitMQ安装
Linux安装

rpm -Uvh http://www.rabbitmq.com/releases/erlang/erlang-18.1-1.el7.centos.x86_64.rpm

rpm -Uvh http://www.rabbitmq.com/releases/erlang/erlang-18.1-1.el7.centos.x86_64.rpm

rpm -Uvh http://www.rabbitmq.com/releases/rabbitmq-server/v3.5.6/rabbitmq-server-3.5.6-1.noarch.rpm

rpm -Uvh http://www.rabbitmq.com/releases/rabbitmq-server/v3.5.6/rabbitmq-server-3.5.6-1.noarch.rpm

rpm -qa|grep rabbitmq

rpm -qa|grep rabbitmq

$ sudo chkconfig rabbitmq-server on  # 添加开机启动RabbitMQ服务

$ sudo /sbin/service rabbitmq-server start # 启动服务

$ sudo /sbin/service rabbitmq-server status  # 查看服务状态

$ sudo /sbin/service rabbitmq-server stop   # 停止服务

# 查看当前所有用户

$ sudo rabbitmqctl list_users

# 查看默认guest用户的权限

$ sudo rabbitmqctl list_user_permissions guest

# 由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户

$ sudo rabbitmqctl delete_user guest

# 添加新用户

$ sudo rabbitmqctl add_user username password

# 设置用户tag

$ sudo rabbitmqctl set_user_tags username administrator

# 赋予用户默认vhost的全部操作权限

$ sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"

# 查看用户的权限

$ sudo rabbitmqctl list_user_permissions username

$ sudo chkconfig rabbitmq-server on  # 添加开机启动RabbitMQ服务

$ sudo /sbin/service rabbitmq-server start # 启动服务

$ sudo /sbin/service rabbitmq-server status  # 查看服务状态

$ sudo /sbin/service rabbitmq-server stop   # 停止服务

# 查看当前所有用户

$ sudo rabbitmqctl list_users

# 查看默认guest用户的权限

$ sudo rabbitmqctl list_user_permissions guest

# 由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户

$ sudo rabbitmqctl delete_user guest

# 添加新用户

$ sudo rabbitmqctl add_user username password

# 设置用户tag

$ sudo rabbitmqctl set_user_tags username administrator

# 赋予用户默认vhost的全部操作权限

$ sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"

# 查看用户的权限

$ sudo rabbitmqctl list_user_permissions username

开启web管理接口

如果只从命令行操作RabbitMQ，多少有点不方便。幸好RabbitMQ自带了web管理界面，只需要启动插件便可以使用。

$ sudo rabbitmq-plugins enable rabbitmq_management

$ sudo rabbitmq-plugins enable rabbitmq_management

然后通过浏览器访问

http://localhost:15672

输入用户名和密码访问web管理界面了。

配置RabbitMQ

关于RabbitMQ的配置，可以下载RabbitMQ的配置文件模板到/etc/rabbitmq/rabbitmq.config, 然后按照需求更改即可。

关于每个配置项的具体作用，可以参考官方文档。

更新配置后，别忘了重启服务哦！

开启用户远程访问

默认情况下，RabbitMQ的默认的guest用户只允许本机访问，如果想让guest用户能够远程访问的话，只需要将配置文件中的loopback_users列表置为空即可，如下：

{loopback_users, []}

{loopback_users, []}

另外关于新添加的用户，直接就可以从远程访问的，如果想让新添加的用户只能本地访问，可以将用户名添加到上面的列表, 如只允许admin用户本机访问。

{loopback_users, ["admin"]}

{loopback_users, ["admin"]}

更新配置后，别忘了重启服务哦！

window安装方法

1. 安装erlang

创建 ERLANG_HOME=D:\Program Files\erl9.3 和 %ERLANG_HOME%/bin 环境变量

2. 安装RabbitMQ

进入rabbitMQ安装目录, 执行bat批处理文件

注意事项

怎么没HelloWorld??? 别急, 在后面

rabbitMQ消息确认

1) 生产者发送消息到消息队列后, 消费者收到消息后, 消费者将会返回一个Ack进行响应, 确认消息是否传达完毕, 但是如果消费者意外关闭了, 生产者无法收取到Ack, 则RabbitMQ将会将这个消息保留下来并传达给另外的一个目标消费者

2) 消息确认必须在相同的一个通道上

channel.basicQos(1); // accept only one unack-ed message at a time (see below)

DeliverCallback deliverCallback = (consumerTag, delivery) -> {

  String message = new String(delivery.getBody(), "UTF-8");

  System.out.println(" [x] Received '" + message + "'");

  try {

    doWork(message);

  } finally {

    System.out.println(" [x] Done");

    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

  }

};

boolean autoAck = false; // 手动Ack功能开始

channel.basicConsume(TASK_QUEUE_NAME, autoAck, deliverCallback, consumerTag -> { });

发现消息队列中的消息过多的话, 需要删除

window

rabbitmqctl.bat list_queues name messages_ready messages_unacknowledged

linux

sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged

消息持久化

将消息队列中的消息持久化到磁盘中, 但是它还是有可能丢失的, 当消息在消息队列中但是又没持久化到磁盘中时, RabbitMQ如果意外关闭了, 那么这个消息将丢失, 如果需要做到消息不丢失的话, 必须使用publisher confirms

boolean durable = true;

channel.queueDeclare("task_queue", durable, false, false, null);

公平调度

RabbitMQ无法知道哪个消费者是否有空, 都会按照顺序交给消费者, 如果有一个消费者太过于忙碌, RabbitMQ也不知道, 照样会发布消息给那个消费者

解决方法:

int prefetchCount = 1;

channel.basicQos(prefetchCount);

prefetchCount = 1, 调用basicQos方法这个消费者就会只拿出一个消息进行操作, 其他的消息它都拒绝掉, 拒绝的消息将被滞留带消息队列中, 但是这个消息将会丢给新的消费者

新的问题:

所有的消费者都忙碌了, 那么生产者产生的消息一直滞留在消息队列中, 这样消息队列会出现更多的消息, 直达消息队列爆了

下面是第一阶段学习完成的最终代码:

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.MessageProperties;

public class NewTask {

  private static final String TASK_QUEUE_NAME = "task_queue";

  public static void main(String[] argv) throws Exception {

    ConnectionFactory factory = new ConnectionFactory();

    factory.setHost("localhost");

    try (Connection connection = factory.newConnection();

         Channel channel = connection.createChannel()) {

        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

        String message = String.join(" ", argv);

        channel.basicPublish("", TASK_QUEUE_NAME,

                MessageProperties.PERSISTENT_TEXT_PLAIN,

                message.getBytes("UTF-8"));

        System.out.println(" [x] Sent '" + message + "'");

    }

  }

}

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.DeliverCallback;

public class Worker {

  private static final String TASK_QUEUE_NAME = "task_queue";

  public static void main(String[] argv) throws Exception {

    ConnectionFactory factory = new ConnectionFactory();

    factory.setHost("localhost");

    final Connection connection = factory.newConnection();

    final Channel channel = connection.createChannel();

    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    channel.basicQos(1);

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {

        String message = new String(delivery.getBody(), "UTF-8");

        System.out.println(" [x] Received '" + message + "'");

        try {

            doWork(message);

        } finally {

            System.out.println(" [x] Done");

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        }

    };

    channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });

  }

  private static void doWork(String task) {

    for (char ch : task.toCharArray()) {

        if (ch == '.') {

            try {

                Thread.sleep(1000);

            } catch (InterruptedException _ignored) {

                Thread.currentThread().interrupt();

            }

        }

    }

  }

}

第一阶段学习完成了, 现阶段, 我们总结下:

1. 消息确认

RabbitMQ 存在消息确认机制, 防止消息轻易丢失, 详细过程是:

生产者标记生产的消息需要消费者ack(应答)的消息, 将消息体发送到消息队列中, 消费者收到消息后, 发现这个消息需要手动应答的消息后, 关闭自动消息应答, 将消息应答的权利交给程序员手动调用, 应答或者拒绝, 拒绝的话, 有两种情况, 一种是拒绝并将消息丢弃或者拒绝将消息重新放入消息队列中, 如果消费者在应答的时候突然崩溃, 则生产者不会讲该消息销毁掉, 而是重新进入消息队列中, 传达给其他消费者, 如果生产者突然崩了, 则需要靠持久化来解决

2. 消息的持久化

RabbitMQ为了防止消息在消息队列中丢失, 所以使用了, 消息持久化, 但是它不是实时持久化的, 有时间间隙还是容易丢失消息, 后面有解决方案

3. 公平调度原则

RabbitMQ为了防止一些消费者过于忙碌而另一些消费者过于空闲的情况, 引入了公平调度原则, 你忙着就不给你排任务了, 将任务丢给消息队列, 让闲着的人去那任务, 但是导致了新的问题, 就是消息队列中的消息一直滞留消息队列中, 导致消息队列过于庞大, 导致RabbitMQ崩溃, 解决方案引入新的消费者或者使用TTL

至于啥是TTL???

想打人, 又是专业又简约的单词.......................... 尽给我瞎整些专业名词...................

TTL === Time-To-Live and Expiration

人话就是: 给消息/队列加上寿命

1. 如何给消息加上TTL?

* 为消息添加TTL时间的方式有两种
* (1) 为添加进入队列的每个消息都加上TTL
* (2) 在消息即将公布的时候, 给消息添加上消息的ttl

(1) 为添加进入队列的每个消息都加上TTL

Map<String, Object> arg = new HashMap<>();
arg.put("x-message-ttl", 60000);
channel.queueDeclare(QUEUE, true, false, false, arg);

(2) 在消息即将公布的时候, 给消息添加上消息的ttl

AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("600000").build();
channel.basicPublish("my-exchange", QUEUE, properties, message.getBytes());

同一个消息在不同消息队列中是否会同时寿终正寝?

发送到多个队列中的同一个消息可能在不同的时刻消失, 一个消息队列中的消息死亡不会影响其他队列中的这个消息队列, TTL的时间单位是毫秒, 且这个参数的值不能是非负数的

如何修改TTL的时间?

linux:

rabbitmqctl set_policy TTL ".*" '{"message-ttl":60000}' --apply-to queues

window:

rabbitmqctl set_policy TTL ".*" "{""message-ttl"":60000}" --apply-to queues

上面的命令将是 60 秒

还可以使用

Map<String, Object> args = new HashMap<String, Object>();

args.put("x-message-ttl", 60000);

channel.queueDeclare("myqueue", false, false, false, args);

临时修改60秒时间

需要注意:

①如果这个时候, 队列被加上TTL时间, 则不影响原本处于队列的那个消息的TTL失效时间

②如果同时给队列和消息加上TTL时间时, 则选择TTL较小的那个

在消息即将公布的时候, 给消息添加上ttl时间

2. 如何给队列加上TTL?

(1) 给队列加上TTL的话, 只有队列在空闲或者消费者没有连接到队列的时候才会开始使用TTL的时间

(2) 使用x-expires和expires可以设置队列的TTL

(3) 单位是毫秒

(4) 具体使用的方法

linux:

rabbitmqctl set_policy expiry ".*" '{"expires":1800000}' --apply-to queues

window:

rabbitmqctl.bat set_policy expiry ".*" "{""expires"":1800000}" --apply-to queues

也可以在消息队列声明的时候为队列加上TTL

Map<String, Object> args = new HashMap<String, Object>();

args.put("x-expires", 1800000);

channel.queueDeclare("myqueue", false, false, false, args);

// 为添加进入队列的每个消息都加上TTL
// Map<String, Object> arg = new HashMap<>();
// arg.put("x-message-ttl", 60000);
// 为队列添加TTL , 半个小时的时间
Map<String, Object> arg = new HashMap<>();
arg.put("x-expires", 1800000);
channel.queueDeclare(QUEUE, true, false, false, arg);
String message = "Hello World";
// 在消息即将公布的时候, 给消息添加上消息的ttl
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("600000").build();
channel.basicPublish("my-exchange", QUEUE, properties, message.getBytes());

下面是我写的第一阶段的代码, 不包含TTL

package com.xuecheng.manage_cms.rabbit;

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

/**
 * @author zhengwei
 * @version 1.0.0
 * @date 2019/12/4 20:29
 * @msg
 **/
public class Producer01 {
   
   private final static String QUEUE = "helloworld";
   
   public static void main(String[] args) throws Exception {
      Connection connection = null;
      Channel channel = null;
      try {
         ConnectionFactory factory = new ConnectionFactory();
         factory.setHost("localhost");
         connection = factory.newConnection();
         channel = connection.createChannel();
         channel.queueDeclare(QUEUE, true, false, false, null);
         String message = "Hello World";
         // 将生产者的通道设置为持久化状态
         channel.basicPublish("", QUEUE, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
         System.out.println("[x] Sent'" + message + "'");
      } catch (Exception e) {
          e.printStackTrace();
      } finally {
         if (channel != null) {
            channel.close();
         }
         if (connection != null) {
             connection.close();
         }
      }
   }

}

package com.xuecheng.manage_cms.rabbit;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author zhengwei
 * @version 1.0.0
 * @date 2019/12/4 20:50
 * @msg
 **/
public class Consumer01 {
   
   private static final String QUEUE = "helloworld";
   
   public static void main(String[] args) throws Exception {
      func1();
   }
   
   public static void func1() throws Exception {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
      Connection connection = factory.newConnection();
      Channel channel = connection.createChannel();
      channel.queueDeclare(QUEUE, true, false, false, null);
      channel.basicQos(1);
      DeliverCallback deliverCallback = (consumerTag, delivery) -> {
         String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
         System.out.println("receive message..." + message);
         try {
            doWork(message);
         } catch (InterruptedException e) {
            e.printStackTrace();
         } finally {
            System.out.println(" [x] Done");
            // 应答
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
         }
      };
      // 开启消费者的自动 Ack 功能
      boolean autoAck = false;
      channel.basicConsume(QUEUE, autoAck, deliverCallback, (consumerTag) -> {
         System.out.println("consumerTag: " + consumerTag);
      });
   }
   
   public static void doWork(String task) throws InterruptedException {
      for (char ch : task.toCharArray()) {
         if (ch == '.') {
            Thread.sleep(1000);
         }
      }
   }
   
   public static void func() throws Exception {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
      Connection connection = factory.newConnection();
      Channel channel = connection.createChannel();
      channel.queueDeclare(QUEUE, true, false, false, null);
      DefaultConsumer consumer = new DefaultConsumer(channel) {
         @Override
         public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String exchange = envelope.getExchange();
            String routingKey = envelope.getRoutingKey();
            long deliveryTag = envelope.getDeliveryTag();
            String msg = new String(body, "utf-8");
            System.out.println("receive message..." + msg);
            channel.basicAck(envelope.getDeliveryTag(), false);
            //true if the rejected message should be requeued rather than discarded/dead-lettered
            // 如果拒绝的方式是 true 则这个消息不被丢弃, false的话直接丢弃消息
            channel.basicReject(envelope.getDeliveryTag(), true);
         }
      };
      channel.basicConsume(QUEUE, true, consumer);
   }
}

第二阶段学习

前言, 了解学习第二阶段的目标是什么???

上面第一阶段的学习, 我们最终创建并完成了, 将一个消息通过消息队列传递给另一个消费者, 接下来, 我们将学习的目标是, 将一个消息, 传递给多个消费者, 也就是传说中的消息的发布和订阅

1. 发布和订阅

1. Exchanges交换器

(1) rabbitMQ的生产者不知道自己发送的消息是否成功, 它将自己的消息发送到exchanges交换器上, 交换器负责接收生产者的所有消息, 然后由他分配消息将传递给哪个队列并创建管道发送给消费者

(2) 列出服务器上的所有交换器

sudo rabbitmqctl list_exchanges

exchanges和Queue之间使用routingKey进行路由选取哪个队列

(3) 发布命名交换器

channel.basicPublish( "logs", "", null, message.getBytes());

2. Temporary queues

是什么?

临时队列就是一个非持久的、独占的、自动删除的队列,

作用

获取当前最新的消息, 而不是包括旧的信息的消息

3. Bindings

(1) 用于交换机和队列之间的绑定

(2) 如何绑定:

channel.queueBind(queueName, "logs", "");

(3) 查看先有的绑定

rabbitmqctl list_bindings

4. Putting it all together

public class EmitLog {

   private static final String EXCHANGE_NAME = "logs";
   
   public static void main(String[] args) throws Exception {
      ConnectionFactory factory = new ConnectionFactory();
      Connection connection = null;
      Channel channel = null;
      try {
         connection = factory.newConnection();
         channel = connection.createChannel();
         // 声明一个扇形交换机, 向所有的消费者发布消息
         channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
         String message = "zhazha Hello World";
         // 指定 logs(EXCHANGE_NAME) 交换器, 将消息发布出去
         channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
      } catch (Exception e) {
          e.printStackTrace();
      } finally {
         if (channel != null) {
            channel.close();
         }
         if (connection != null) {
            connection.close();
         }
      }
   }
   
}

public class ReceiveLogs {
   
   private static final String EXCHANGE_NAME = "logs";
   
   public static void main(String[] args) throws Exception {
      ConnectionFactory factory = new ConnectionFactory();
      Connection connection = factory.newConnection();
      Channel channel = connection.createChannel();
      String queueName = channel.queueDeclare().getQueue();
      channel.queueBind(queueName, EXCHANGE_NAME, "");
      DeliverCallback deliverCallback = (consumerTag, message) -> {
         System.out.println("message = " + new String(message.getBody(), StandardCharsets.UTF_8));
      };
      channel.basicConsume(queueName, true, deliverCallback, (consumerTag) -> {
      });
   }
   
}

路由选择

直接交换

1. 是什么?

是一个算法, 消息发送到与其binding key与消息routing key完成匹配的队列

绑定键就是图中的orange, black, green, 直接交换就是图中的 direct 就是那个 X

核心: 关注routing key, 这个就是将消息传递到这个绑定键的东西

多重绑定

一个绑定键可以和多个queue进行绑定

发出日志

emmmmmmmmmmmm
订阅

绑定键 == 路由键 + 某些操作

可以说绑定键 ≈ 路由键

总结

也就是说, 路由键相当于频道, 生产者就是新闻工作者, 消费者就是观众

public class EmitLogDirect {
   
   private static final String EXCHANGE_NAME = "direct_logs";
   
   public static void main(String[] args) throws Exception {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
      Connection connection = factory.newConnection();
      Channel channel = connection.createChannel();
      channel.exchangeDeclare(EXCHANGE_NAME, "direct");
      String routingKey = "info";
      String message = "zhazha";
      channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes(StandardCharsets.UTF_8));
      System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
   }

}

public class ReceiveLogsDirect {
   
   private static final String EXCHANGE_NAME = "direct_logs";
   
   public static void main(String[] args) throws IOException, TimeoutException {
      String[] argv = new String[]{"info", "warning", "error"};
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
      Connection connection = factory.newConnection();
      Channel channel = connection.createChannel();
      channel.exchangeDeclare(EXCHANGE_NAME, "direct");
      String queueName = channel.queueDeclare().getQueue();
      for (String routingKey : argv) {
         channel.queueBind(queueName, EXCHANGE_NAME, routingKey);
      }
      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
      DeliverCallback deliverCallback = (consumerTag, delivery) -> {
         String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
         System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
      };
      channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
      });
   }
   
}

主题 -- Topics

1. 主题交换机

主题交换的 routing_key 不能随便命名, 可以是以quick.rabbit这种 "."的方式作为routing_key

且这个routing_key还能使用 * 和 # 进行配对, * 是匹配一个单词使用, # 表示一群单词和字符匹配

设置为“ quick.orange.rabbit”的路由键的消息将被传递到两个队列。信息“ lazy.orange.elephant”也会发给他们两个。另一方面，“ quick.orange.fox”只会出现在第一个队列中，而“ lazy.brown.fox”只出现在第二个队列中。 “ lazy.pink.rabbit”只会被传递到第二个队列一次，即使它匹配两个绑定。 “ quick.brown.fox”不符合任何装订，所以它会被丢弃。

其他不匹配的全部丢弃

来自为知笔记(Wiz)