RabbitMQ 简介

1、简介

1.1、为什么使用mq

主要是解耦，只关心消息的发送和接受

1.2、MQ是什么

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

1.2.1 AMQP协议

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

1.3、MQ有哪些，特点是什么

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

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

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

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

2、RabbitMQ的安装

mac：https://blog.csdn.net/huanghuang9426/article/details/117552035?spm=1001.2014.3001.5501
linux:https://blog.csdn.net/huanghuang9426/article/details/117569012

3、 web管理界面介绍

connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况`
channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。
Exchanges：交换机，用来实现消息的路由
Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。

3.2 添加用户

上面的Tags选项，其实是指定用户的角色，可选的有以下几个：
超级管理员(administrator) 可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
监控者(monitoring) 可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
策略制定者(policymaker) 可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
普通管理者(management) 仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
其他 无法登陆管理控制台，通常就是普通的生产者和消费者。

3.2 创建虚拟主机

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

绑定虚拟主机和用户

创建好虚拟主机，我们还要给用户添加访问权限：
点击添加好的虚拟主机：

4 写个程序

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 第一种模型(直连)

4.4.1 代码实现

      //重要： 生产者和消费者，所有配置必须一样
    //生产者
    public static void shengchanzhe()throws Exception{
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");

        connectionFactory.setPassword("test");
        connectionFactory.setVirtualHost("/ems");
        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        //获取连接中通道
        Channel channel = connection.createChannel();
        /**
         * 通道绑定对应消息队列
         * 参数1:队列名称如果队列不存在自动创建
         * 参数2:用来定义队列特性是否要持久化true持久化队列 false不持久化
         * 参数3: exclusive是否独占队列true独占队列fa1se不独占
         * 参数4: autodelete:是否在消费完成后自动删除队列true自动削除 false不自动除，消费者消费的时候 队列会一直存在
         * 参数5:额外附加参数
         */
        channel.queueDeclare("hello",true,false,false,null);
        //参数1:交换机名称参数 2:队列名称参数  3:传递消息额外设置参数4:消息的具体内容
        channel.basicPublish("","hello",MessageProperties.PERSISTENT_BASIC,"ht mq".getBytes(StandardCharsets.UTF_8));
        channel.close();
        connection.close();
    }
   // 消费者
    public static void xiaofeizhe()throws Exception{
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");

        connectionFactory.setPassword("test");
        connectionFactory.setVirtualHost("/ems");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        /**
         * 通道绑定对应消息队列
         * 参数1:队列名称如果队列不存在自动创建
         * 参数2:用来定义队列特性是否要持久化true持久化队列 false不持久化
         * 参数3: exclusive是否独占队列true独占队列fa1se不独占
         * 参数4: autodelete:是否在消费完成后自动删除队列true自动削除 false不自动除
         * 参数5:额外附加参数
         */
        channel.queueDeclare("hello", false, false, false, null);
     /*   消费消息
        参数1:消费那个队列的消息队列名称
         参数2:开始消息的自动确认机制
         参数3:消费时的回调接口*/
        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(new String(body));
            }
        });
        //close 就是消费一次，没有下面的代码就是一直消费
        channel.close();
        connection.close();

    }

4.4 第二种模型(工作)

4.4.1 概述

Work queues,也被称为( Task queues),任务模型。I当消息处理比较耗时的时候,可能生产消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多, 无法及时处理。此时就可以使用wok模型:让多个消费者绑定到一个队列,共同消费队列中的消息。队列中的消息一旦消费,就会消失,因此任务是不会被重复执行的。

4.4.2 代码实现

//默认是平均分配,如果两个消费者性能不一致，一个慢一个快，会拖垮系统，底层是消息队列一次性把
//能拿到的消息拿到内存中一个一个消化
//生产者
channel.queueDeclare("hello", true, false, false, null);
for (int i = 0; i < 10; i++) {
  channel.basicPublish("", "hello", null, (i+"====>:我是消息").getBytes());
}

//消费者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));
  }
});


//消费者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 {
    System.out.println("消费者2: "+new String(body));
  }
});

4.4.3 自动确认机制

我们想要能者多劳怎么处理呐？

//消费者中修改一下，可以保证消息不丢失
channel.basicQos(1);//一次只接受一条未确认的消息
//参数2:关闭自动确认消息
channel.basicConsume("hello",false,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));
    channel.basicAck(envelope.getDeliveryTag(),false);//手动确认消息
  }
});

4.5 第三种模型( fanout 广播)

在广插模式下,消息发送流程是这样的:
可以有多个消费者
每个消费者有自己的 queue(队列)
每个队列都要绑定到 Exchange(交换机)
生产者发送的消息,只能发送到交换机,交換机来決定要发给哪个队列,生产者无法決定。
交换机把消息发送给绑定过的所有队列
队列的消费者都能拿到消息。实现一条消息被多个消费者消费

//生产者，
//将通道声明指定交換机/参数1:交换机名称参数2:交换机类型 fanout广播类型
channel.exchangeDeclare("logs","fanout");//广播 一条消息多个消费者同时消费
//发布消息
channel.basicPublish("logs","",null,"hello".getBytes());

//消费者1
//绑定交换机  参数1：交换机名称，参数2 广播类型
channel.exchangeDeclare("logs","fanout");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//将临时队列绑定exchange
channel.queueBind(queue,"logs","");
//处理消息
channel.basicConsume(queue,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));
  }
});

//消费者2
//绑定交换机
channel.exchangeDeclare("logs","fanout");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//将临时队列绑定exchange
channel.queueBind(queue,"logs","");
//处理消息
channel.basicConsume(queue,true,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));
  }
});

//消费者三
//绑定交换机
channel.exchangeDeclare("logs","fanout");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//将临时队列绑定exchange
channel.queueBind(queue,"logs","");
//处理消息
channel.basicConsume(queue,true,new DefaultConsumer(channel){
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    System.out.println("消费者3: "+new String(body));
  }
});

4.6 第四种模型( 路由)

4.6.1. Routing之订阅模型- Direct(直连）

大白话：根据路由key的不同，实现不同的消息被不同的队列消费
在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
在Direct模型下：
队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

不绑定不会被消费
生产者
//声明交换机  参数1:交换机名称 参数2:交换机类型 基于指令的Routing key转发（路由模式）
channel.exchangeDeclare("logs_direct","direct");
String key = "info";
//发布消息
channel.basicPublish("logs_direct",key,null,("指定的route key"+key+"的消息").getBytes());


 //声明交换机
channel.exchangeDeclare("logs_direct","direct");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//绑定队列和交换机
channel.queueBind(queue,"logs_direct","error");
channel.queueBind(queue,"logs_direct","info");
channel.queueBind(queue,"logs_direct","warn");

//消费消息1
channel.basicConsume(queue,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));
  }
});


//声明交换机
channel.exchangeDeclare("logs_direct","direct");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//绑定队列和交换机
channel.queueBind(queue,"logs_direct","error");
//消费消息
channel.basicConsume(queue,true,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));
  }
});

4.7 Routing 之订阅模型-Topic（动态路由）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key的时候使用通配符！这种模型Routingkey 一般都是由一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

# 统配符
		* (star) can substitute for exactly one word.    匹配不多不少恰好1个词
		# (hash) can substitute for zero or more words.  匹配一个或多个词
# 如:
		audit.#    匹配audit.irs.corporate或者 audit.irs 等
    audit.*   只能匹配 audit.irs

生产者
//生命交换机和交换机类型 topic 使用动态路由(通配符方式)
channel.exchangeDeclare("topics","topic");
String routekey = "user.save";//动态路由key
//发布消息
channel.basicPublish("topics",routekey,null,("这是路由中的动态订阅模型,route key: ["+routekey+"]").getBytes());


消费者1 Routing Key中使用*通配符方式
 //声明交换机
channel.exchangeDeclare("topics","topic");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//绑定队列与交换机并设置获取交换机中动态路由
channel.queueBind(queue,"topics","user.*");

//消费消息
channel.basicConsume(queue,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));
  }
});


消费者2  Routing Key中使用#通配符方式
//声明交换机
channel.exchangeDeclare("topics","topic");
//创建临时队列
String queue = channel.queueDeclare().getQueue();
//绑定队列与交换机并设置获取交换机中动态路由
channel.queueBind(queue,"topics","user.#");

//消费消息
channel.basicConsume(queue,true,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));
  }
});

4.8 RPC和发布订阅，后续研究

5 SpringBoot中使用RabbitMQ

5.1引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
 

5.2 编写配置文件

spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 10.15.0.9
    port: 5672
    username: ems
    password: 123
    virtual-host: /ems

5.3第一种hello world模型使用

生产者
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testHello(){
  rabbitTemplate.convertAndSend("hello","hello world");
}

消费者
@Component
@RabbitListener(queuesToDeclare = @Queue("hello"))
public class HelloCustomer {

@RabbitHandler
public void receive1(String message){
System.out.println("message = " + message);
}
}

5.4 第二种work模型使用

生产者
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testWork(){
 for (int i = 0; i < 10; i++) {
   rabbitTemplate.convertAndSend("work","hello work!");
 }
}
消费者
@Component
public class WorkCustomer {
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message){
        System.out.println("work message1 = " + message);
    }

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message){
        System.out.println("work message2 = " + message);
    }
}

5.5 Fanout 广播模型

生产者
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testFanout() throws InterruptedException {
  rabbitTemplate.convertAndSend("logs","","这是日志广播");
}
消费者
@Component
public class FanoutCustomer {

   @RabbitListener(bindings = @QueueBinding(
           value = @Queue,
           exchange = @Exchange(name="logs",type = "fanout")
   ))
   public void receive1(String message){
       System.out.println("message1 = " + message);
   }

   @RabbitListener(bindings = @QueueBinding(
           value = @Queue, //创建临时队列
           exchange = @Exchange(name="logs",type = "fanout")  //绑定交换机类型
   ))
   public void receive2(String message){
       System.out.println("message2 = " + message);
   }
}

5.6 Route 路由模型

生产者
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testDirect(){
rabbitTemplate.convertAndSend("directs","error","error 的日志信息");
}
消费者
@Component
public class DirectCustomer {

@RabbitListener(bindings ={
@QueueBinding(
    value = @Queue(),
    key={"info","error"},
    exchange = @Exchange(type = "direct",name="directs")
)})
public void receive1(String message){
System.out.println("message1 = " + message);
}

@RabbitListener(bindings ={
@QueueBinding(
    value = @Queue(),
    key={"error"},
    exchange = @Exchange(type = "direct",name="directs")
)})
public void receive2(String message){
System.out.println("message2 = " + message);
}
}

5.7 Topic 订阅模型(动态路由模型)

生产者
@Autowired
private RabbitTemplate rabbitTemplate;

//topic
@Test
public void testTopic(){
	rabbitTemplate.convertAndSend("topics","user.save.findAll","user.save.findAll 的消息");
}
消费者
   @Component
   public class TopCustomer {
       @RabbitListener(bindings = {
               @QueueBinding(
                       value = @Queue,
                       key = {"user.*"},
                       exchange = @Exchange(type = "topic",name = "topics")
               )
       })
       public void receive1(String message){
           System.out.println("message1 = " + message);
       }
   
       @RabbitListener(bindings = {
               @QueueBinding(
                       value = @Queue,
                       key = {"user.#"},
                       exchange = @Exchange(type = "topic",name = "topics")
               )
       })
       public void receive2(String message){
           System.out.println("message2 = " + message);
       }
   }

6 MQ的应用场景

6.1 异步处理

场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种 1.串行的方式 2.并行的方式
提前说下结论：由此可以看出,引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计),引入消息队列后处理后,响应时间是串行的3倍,是并行的2倍。

6.2 应用解耦

订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功。
库存系统:订阅下单的消息,获取下单消息,进行库操作。 就算库存系统出现故障,消息队列也能保证消息的可靠投递,不会导致消息丢失.

6.3 流量削峰

场景: 秒杀活动，一般会因为流量过大，导致应用挂掉,为了解决这个问题，一般在应用前端加入消息队列。