【博学谷学习记录】超强总结，用心分享 。RabbitMQ的相关知识点

RabbitMQ

　　　　1.概念：MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

　　　　　　常见的MQ实现

　　　　　ActiveMQ

　　　　　RabbitMQ

　　　　　RocketMQ

　　　　　Kafka

　　　　　　几种常见MQ的对比：

 

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP，XMPP，SMTP，STOMP	OpenWire,STOMP，REST,XMPP,AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

　　　　　　追求可用性：Kafka、 RocketMQ 、RabbitMQ

　　　　　　追求可靠性：RabbitMQ、RocketMQ

　　　　　　追求吞吐能力：RocketMQ、Kafka

　　　　　　追求消息低延迟：RabbitMQ、Kafka

　　2.快速入门

　　基本结构

　　　　

 

 

 　　RabbitMQ中的一些角色：

　　　　publisher：生产者

　　　　consumer：消费者

　　　　exchange：交换机，负责消息路由

　　　　queue：队列，存储消息　　

　　　　virtualHost：虚拟主机，隔离不同租户的exchange、queue、消息的隔离

　　3.RabbitMQ消息模型

　　　　1）基本消息队列（BasicQueue）

　　　　2）工作消息队列（WorkQueue）

　　　　3）Fanout Exchange：广播

　　　　4）Direct Exchange：路由

　　　　5）Topic Exchange：主题

　　4.publisher实现

　　　　思路：

• 建立连接

• 创建Channel

• 声明队列

• 发送消息

1. 关闭连接和channel

   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 java.io.IOException;
   import java.util.concurrent.TimeoutException;
   
   public class PublisherTest {
       @Test
       public void testSendMessage() throws IOException, TimeoutException {
           // 1.建立连接
           ConnectionFactory factory = new ConnectionFactory();
           // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
           factory.setHost("192.168.150.101");
           factory.setPort(5672);
           factory.setVirtualHost("/");
           factory.setUsername("itcast");
           factory.setPassword("123321");
           // 1.2.建立连接
           Connection connection = factory.newConnection();
   
           // 2.创建通道Channel
           Channel channel = connection.createChannel();
   
           // 3.创建队列
           String queueName = "simple.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();
   
       }
   }

   5.consumer实现

 

public class ConsumerTest {

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

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

        // 3.创建队列
        String queueName = "simple.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("等待接收消息。。。。");
    }
}

 

　　　　6.SpringAMQP

               SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。

　　          SpringAMQP提供了三个功能：

  　　　　    　　   自动声明队列、交换机及其绑定关系

　　　　　　　　基于注解的监听器模式，异步接收消息

　　　　　　　　封装了RabbitTemplate工具，用于发送消息

　　　　7.Basic Queue 简单队列模型

　　　　　　在父工程mq-demo中引入依赖

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

　　　　　　消息发送：首先配置MQ地址，在publisher服务的application.yml中添加配置：

　　　　　　　　

spring:
  rabbitmq:
    host: 192.168.130.100 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

　　　　　　然后在publisher服务中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

　　　　　　　　

@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);
    }
}

　　　　　　消息接收：首先配置MQ地址，在consumer服务的application.yml中添加配置：

　　　　　　　　

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

　　　　然后在consumer服务的cn.itcast.mq.listener包中新建一个类SpringRabbitListener，代码如下：

　　　　　　

@Component
public class SpringRabbitListener {

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

　　　　　　7.WorkQueue

　　　　　　　　Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

　　　　　　　　

 

 

 

　　　　　　　　

　　　　当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

　　　　　　　　消息发送：在publisher服务中的SpringAmqpTest类中添加一个测试方法：

　　　　　　

@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);
    }
}

　　　　消息接收：要模拟多个消费者绑定同一个队列，我们在consumer服务的SpringRabbitListener中添加2个新的方法：

　　　　　　

@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 listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);
}

　　　　　　问题：测试中发现消息是平均分配的，没有考虑消费者处理能力，是不合理的，因此要使消费者每次只能获取一条消息，处理完成才能获取下一个消息，也就是能者多劳

　　　　　　　　

spring:
  rabbitmq:
    host: 192.168.73.100 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /
    listener:
      simple:
        prefetch: 1

　　　　　　简单来说，work模型就是多个消费者绑定到一个队列，对队列中的消息进行处理，通过设置prefetch来控制消费者预取消息的数量。

　　　　8.发布（publish）、订阅（subscribe）

　　　　发布订阅模式与之前案例的区别就是允许将统一消息发送给多个消费者。实现方式就是加入了exchange（交换机）

　　　　　　　常见交换机类型包括：

　　　　　　　　Fanout：广播

　　　　　　　　Direct：路由

　　　　　　　　Topic：话题

 

 

 

　　　　　　8.SpringAMQP-FanoutExchange的实现

　　　　　　　　1.将两个消息队列绑定到同一个交换机中

　　　　　　

@Configuration
public class FanoutConfig {
    // itcast.fanout 定义交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }

    // fanout.queue1 消息队列一
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    // 绑定队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder
                .bind(fanoutQueue1)
                .to(fanoutExchange);
    }

    // fanout.queue2
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    // 绑定队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder
                .bind(fanoutQueue2)
                .to(fanoutExchange);
    }

    @Bean
    public Queue objectQueue(){
        return new Queue("object.queue");
    }
}

　　　　 2.在消费者中定义监听消息的两个队列接收消息

　　　　　　

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

　　　　 3.在发送中定义发送消息

　　　　　　

@Test
public void testSendFanoutExchange() {
    // 交换机名称
    String exchangeName = "itcast.fanout";
    // 消息
    String message = "hello, every one!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

　　　　9.SpringAMQP-FanoutExchange

　　　　　　描述下Direct交换机与Fanout交换机的差异

　　　　　　　　Fanout交换机将消息路由给每一个与之绑定的队列

　　　　　　　　Direct交换机根据RoutingKey判断路由给哪个队列

　　　　　　　　如果多个队列具有相同的key，则与Fanout功能相同

　　　　10.Direct:在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

　　　　　　　　队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

　　　　　     　消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。

　　　　　    　Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

　　　　　　

 

 　　　　　　　　　　　　1.在消费者中添加两个消费者同时使用注解声明交换机和队列

　　　　

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "itcast.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 + "】");
}

　　2.消息发送　　　　　　　　

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "itcast.direct";
    // 消息
    String message = "hello, red!";
    // 发送消息
           rabbitTemplate.convertAndSend(exchangeName, "red", message);

　　　　　　10.SpringAMQP-TopicExchange

　　　　　　　　Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key` 的时候使用通配符

　　　　　　　　通配符规则：

　　　　　　　　#：匹配一个或多个词

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

 

 　　　　　　　　

　　　　　　　　　　在发送者中添加测试方法

　　　　　　

@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "itcast.topic";
    // 消息
    String message = "今天天气不错，我的心情好极了!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
}

　　　　　　　　在消费者中添加方法

　　　　

 @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }

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

   
}

　　　　　　　　Direct交换机与Topic交换机的差异

　　　　　　　　1.交换机的类型不同

　　　　　　　　ExchangeTypes.DIRECT

　　　　　　　　ExchangeTypes.TOPIC

　　　　　　　　Topic交换机接收的消息RoutingKey必须是多个单词，

　　　　　　　　以 **.** 分割Topic交换机与队列绑定时的bindingKey可以指定通配符#：代表0个或多个词*：代表1个词

 

　总结

　　　　　以上就是一些关于MQ的知识点。