RabbitMQ

一、RabbitMQ介绍

• **介绍：**由Rabbit公司基于Erlang语言开发的，支持多协议的、性能优秀的消息队列产品。一般消息队列，俗称 消息中间件。

• **官网：**https://www.rabbitmq.com

• 主流消息中间件：

• 选择：

  • 追求可用性：Kafka、 RocketMQ 、RabbitMQ
  • 追求可靠性：RabbitMQ、RocketMQ
  • 追求吞吐能力：RocketMQ、Kafka
  • 追求消息低延迟：RabbitMQ、Kafka

• 结构：

• 1、publisher：生产者

• 用于生产消息的

• 2、consumer：消费者

• 用于消费消息的

• 3、exchange：交换机

• 按照指定的规则把消息路由到具体的队列

• 交换机只能路由信息，不能保存信息，如果路由失败则消息丢失

• 4、queue：队列

• 存储消息

• 5、VirtualHost：虚拟主机

• 对不同用户的 exchange、queue、消息 的进行隔离

• 自我理解：

RabbitMQ让消息的生产者与消费者断开联系，二者之间增加了一个Broker。

生产者只需要将通过一定的规则（交换机，路由密钥）将信息送到指定的队列。

消费者监听对应的队列，当队列有信息时，通过一定的规则判断是否可以拉取该信息。

二、RabbitMQ安装：

使用Docker在服务器安装

1，获取RabbitMQ的镜像

• 方式一：直接网上下载

  docker pull rabbitmq:3-management

• 方式二：如果本地有，加载本地的tag文件（例如mq.tag）

  docker load -i mq.tar

  如果丢失镜像名称与版本，执行命令：

  • docker tag 自定义镜像名:自定义镜像版本 镜像ID

  • 例如：docker tag rabbitmq:3-management 镜像ID

2，启动容器

docker run
-e RABBITMQ_DEFAULT_USER=用户名\ 【设置用户名与密码】
-e RABBITMQ_DEFAULT_PASS=密码
-v mq-plugins:/plugins \ 【数据卷】
–name mq \ 【容器名】
–hostname mq \ 【主机名】
–restart=always \ 【重启方式：跟随docker重启而重启】
-p 15672:15672 \ 【浏览器访问的ui界面端口】
-p 5672:5672 \ 【通信端口】
-d \ 【后台运行】
rabbitmq:3-management 【镜像名:镜像id】

==========================================

docker run
-e RABBITMQ_DEFAULT_USER=root
-e RABBITMQ_DEFAULT_PASS=123456
-v mq-plugins:/plugins
–name mq
–hostname mq
–restart=always
-p 15672:15672
-p 5672:5672
-d
rabbitmq:3-management

三、RabbitMQ入门

1，原代码

先在服务器使用Dockers开启RabbitMQ

1.1，导入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

1.2，发布消息

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

@SpringBootTest
public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {

        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.138.100");
        factory.setPort(5672);
        // 默认为你“/”
        factory.setVirtualHost("/");
        factory.setUsername("root");
        factory.setPassword("123456");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "mySimple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

1.3，接收消息

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.138.100");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("root");
        factory.setPassword("123456");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "mySimple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
                System.out.println("envelope = " + envelope.getDeliveryTag());
                System.out.println("envelope = " + envelope.getExchange());
                System.out.println("envelope = " + envelope.getRoutingKey());
            }
        });
        System.out.println("等待接收消息。。。。");
        
        // 将主线程阻塞
        // 因为RabbitMQ是异步的，线程结束的太快，看不到结果
        System.in.read();
    }
}

四、SpringAMQP

• 概述：SpringBoot整合RabbitMQ的模板，实际上就是一个起步依赖

• 网址：https://spring.io/projects/spring-amqp

• 依赖：

  <!--AMQP依赖，包含RabbitMQ-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
  </dependency>
  

• 配置文件：

  spring:
    rabbitmq:
      host: 192.168.138.100 # 主机名
      port: 5672 # 端口
      virtual-host: / # 虚拟主机
      username: root # 用户名
      password: 123456 # 密码
  

• 一些注意点：

  • 交换机只能指定路由规则，不能存储消息
  • 路由密钥（routingKey）：在没有交换机的情况写队列名，有交换机的情况写按具体情况

1，Simple

单发。

没有交换机，或者可以说默认交换机【”空串“】

简单队列需要先创建好对应的消息队列。

1.1，图解：

1.2，生产者发送消息到队列

# 生产者向哪儿发送消息
spring:
  rabbitmq:
    host: 192.168.138.100 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: root # 用户名
    password: 123456 # 密码

package cn.itcast.mq.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

1.3，消费者获取队列的消息

# 消费者从哪儿获取消息
spring:
  rabbitmq:
    host: 192.168.138.100 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: root # 用户名
    password: 123456 # 密码

package cn.itcast.mq.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SpringRabbitListener {

    // 监听的队列名称
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

2，WorkQueue

可以让多个消费者绑定一个队列。

当消息开始积压的时候，就可以使用这个WorkQueue让多个消费者同时消费。

多个消费者之间时竞争的关系。

与Simple的区别就是多加了几个消费者。

1.1，图解

1.2，生产者发送信息

• 发送50条

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message";
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

1.3，消费者获取信息

• 消费者一

  @RabbitListener(queues = "simple.queue")
  public void listenWorkQueue1(String msg) throws InterruptedException {
      System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
      // 模拟处理信息的时间
      Thread.sleep(20);
  }
  

• 消费者二

  @RabbitListener(queues = "simple.queue")
  public void listenWorkQueue1(String msg) throws InterruptedException {
      System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
      // 模拟处理信息的时间
      Thread.sleep(200);
  }
  

• 测试

  1，通过测试，我们发现一个问题。

  2，消费者一很快的处理完了25条信息，消费者二则在慢慢的处理25条信息。

  3，这说明50条信息是平均分配给两个消费者的。

  4，这是很不好的，因为不同服务器的性能是不一样的，我们希望性能好的处理的信息应该更多。

1.4，能者多劳

• 配置文件

  spring:
    rabbitmq:
      listener:
        simple:
          prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息
  

  原本50条信息是队列平均分给两个消费者，配置上面属性后，

  每个消费者一次只能获取一条信息，处理完后才能获取下一条信息。

3，Fanout

1，与上面相比，多了一个交换机。

2，消费者不在与队列直接绑定，消费者绑定交换机，并将信息发送给交换机。

3，交换机可以绑定多个队列，并将信息发送给所有的队列。

4，消费者监听队列获取信息，如果多个消费者监听一个队列，消费者之间是竞争关系。

1.1，图解

1.2，生产者发送信息

@Test
public void testFanoutExchange() {
    // 交换机名称
    String exchangeName = "exchange.fanout";
    // 消息
    String message = "hello, everyone!";
    // Fanout没有路由密钥，所以使用【""】代替
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

1.3，消费者接受信息（配置类方式）

• 配置类（在消费端配置）

  当消费端有多个时，每个配置类声明交换机相同时只会创建一个。

  package cn.itcast.mq.config;
  
  import org.springframework.amqp.core.Binding;
  import org.springframework.amqp.core.BindingBuilder;
  import org.springframework.amqp.core.FanoutExchange;
  import org.springframework.amqp.core.Queue;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class FanoutConfig {
      /**
       * 声明交换机
       * @return Fanout类型交换机
       */
      @Bean
      public FanoutExchange fanoutExchange(){
          // 交换机名称为【exchange.fanout】
          return new FanoutExchange("exchange.fanout");
      }
      
      // ========================================================================
  
      /**
       * 第1个队列 - 消费者一
       */
      @Bean
      public Queue fanoutQueue1(){
          // 队列名称【fanout.queue1】
          return new Queue("fanout.queue1");
      }
  
      /**
       * 绑定队列和交换机
       */
      @Bean
      public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
          return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
      }
  
      // ========================================================================
      /**
       * 第2个队列 - 消费者二
       */
      @Bean
      public Queue fanoutQueue2(){
          return new Queue("fanout.queue2");
      }
  
      /**
       * 绑定队列和交换机
       */
      @Bean
      public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
          return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
      }
  }
  

• 接收信息

  // 消费者一
  @RabbitListener(queues = "fanout.queue1")
  public void listenFanoutQueue1(String msg) {
      System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
  }
  

  // 消费者二
  @RabbitListener(queues = "fanout.queue2")
  public void listenFanoutQueue2(String msg) {
      System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
  }
  

1.4 消费者接受信息（注解模式）

• 通过注解便不需要配置类
• 两个消费者交换机相同，队列不同

// 消费者一
@RabbitListener(bindings = @QueueBinding(
    	// 队列名称
        value = @Queue(name = "fanout.queue1"),
    	// 交换机名称，交换机类型（加上）
        exchange = @Exchange(name = "fanout.exchange", type = ExchangeTypes.FANOUT)
))
public void decr(String msg) throws InterruptedException {
   System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
}

// 消费者二
@RabbitListener(bindings = @QueueBinding(
    	// 队列名称
        value = @Queue(name = "fanout.queue2"),
    	// 交换机名称，交换机类型（加上）
        exchange = @Exchange(name = "fanout.exchange", type = ExchangeTypes.FANOUT)
))
public void decr(String msg) throws InterruptedException {
   System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
}

4，Direct

• 与上面基本相同，但是添加了路由密钥，交换机可以通过不同的密钥将信息发送给不同的队列，

不在将信息发送给所有队列。

• Topic交换机接收的消息RoutingKey必须是多个单词，以 **.** 分割

4.1，图解

4.2，发送信息

• 将信息发送给交换机

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "exchange.direct";
    // 消息
    String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
    // 发送消息, 发送的信息路由密钥是red
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

4.3，获取信息

• 消费者一

// 队列direct.queue1与交换机exchange.direct绑定
// 当交换机中信息的路由密钥是“red或者blue”时，获取信息。
@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "exchange.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}

• 消费者二

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}

5，Topic

与Direct基本相同，只是添加了通配符。

#：匹配一个或多个词

*：匹配不多不少恰好1个词

5.1，图解

5.2，发送信息

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "exchange.direct";
    // 消息
    String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
    // 发送消息, 发送的信息路由密钥是red
    rabbitTemplate.convertAndSend(exchangeName, "red.blue.green", message);
    rabbitTemplate.convertAndSend(exchangeName, "blue.green", message);
    rabbitTemplate.convertAndSend(exchangeName, "red.blue", message);
    
}

5.3，获取信息

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red.#", "*.blue"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}

五、消息转换器

• 在生产者与消费者都添加消息转换器，可以在发送与接受对象时统一处理，

  在队列存储的消息是json字符串，不需要每次发送与接受单独处理。

依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.5</version>
</dependency>

配置类：

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}