RabbitMQ的安装与使用(二)

其他 2021-01-23 01:19:05 阅读次数: 0

RabbitMQ的安装与使用(二）

一. 消息模型

RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。
在这里插入图片描述
我们通过一个demo工程来了解下RabbitMQ的工作方式，导入工程：
在这里插入图片描述
导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.atguigu.rabbitmq</groupId>
    <artifactId>rabbitmq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
    </parent>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

我们抽取一个建立RabbitMQ连接的工具类，方便其他程序获取连接：

package com.atuigu.rabbitmq.util;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import java.io.IOException;
public class ConnectionUtil {
    
    
    /**
     * 建立与RabbitMQ的连接
     */
    public static Connection getConnection() throws Exception {
    
    
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("192.168.137.137");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/shopping");
        factory.setUsername("zhangsan");
        factory.setPassword("123456");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
    public static void main(String[] args) throws Exception {
    
    
        Connection con = ConnectionUtil.getConnection();
        System.out.println(con);
        con.close();
    }
}

二. 消息模型的代码实现

2.1 基本消息模型

RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把邮件放在邮箱里时，你可以确定邮差先生最终会把邮件发送给你的收件人。 在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。RabbitMQ与邮局的主要区别是它不处理纸张，而是接受，存储和转发数据消息的二进制数据块。
在这里插入图片描述

  • P（producer/ publisher）：生产者，一个发送消息的用户应用程序。
  • C（consumer）：消费者，消费和接收有类似的意思，消费者是一个主要用来等待接收消息的用户应用程序
  • 队列（红色区域）：rabbitmq内部类似于邮箱的一个概念。
  • 虽然消息流经rabbitmq和你的应用程序，但是它们只能存储在队列中。
  • 队列只受主机的内存和磁盘限制，实质上是一个大的消息缓冲区。
  • 许多生产者可以发送消息到一个队列，许多消费者可以尝试从一个队列接收数据。
  • 总之：生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。
  • 我们将用Java编写两个程序;发送单个消息的生产者，以及接收消息并将其打印出来的消费者。
  • 我们将详细介绍Java API中的一些细节，这是一个消息传递的“Hello World”。
  • 我们将调用我们的消息发布者（发送者）Send和我们的消息消费者（接收者）Recv。
  • 发布者将连接到RabbitMQ，发送一条消息，然后退出。

Send

package com.atuigu.rabbitmq.simple;
import com.atuigu.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
public class Send {
    
    
   private final static String QUEUE_NAME = "simple_queue";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 从连接中创建通道，使用通道才能完成消息相关的操作
       Channel channel = connection.createChannel();
       // 声明（创建）队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 消息内容
       String message = "Hello World!";
       // 向指定的队列中发送消息
       channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
       System.out.println(" [x] Sent '" + message + "'");
       //关闭通道和连接
       channel.close();
       connection.close();
   }
}

/ **
  * 声明队列
  * @param queue队列名称
  * @param durable  如果我们声明一个持久队列，则为true（该队列将在服务器重启后继续存在）
  * @param Exclusive 如果我们声明一个排他队列，则为true（仅限此连接）
  * @param autoDelete 如果我们声明一个自动删除队列，则为true（服务器将在不再使用它时将其删除）
  * @param arguments 参数队列的其他属性（构造参数）
  * @return一个声明确认方法来指示队列已成功声明
  * /
Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,Map<String, Object> arguments) throws IOException;

console:
在这里插入图片描述
进入队列页面，可以看到新建了一个队列：simple_queue

在这里插入图片描述
点击队列名称，进入详情页，可以查看消息：
在这里插入图片描述
在控制台查看消息并不会将消息消费，所以消息还在。
Receive

package com.atuigu.rabbitmq.simple;
import com.atuigu.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
 * 消费者
 */
public class Recv {
    
    
    private final static String QUEUE_NAME = "simple_queue";
    public static void main(String[] argv) throws Exception {
    
    
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,byte[] body) throws IOException {
    
    
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

console:
在这里插入图片描述
这个时候，队列中的消息就没了：
在这里插入图片描述
我们发现，消费者已经获取了消息，但是程序没有停止，一直在监听队列中是否有新的消息。一旦有新的消息进入队列，就会立即打印

2.2 消息确认机制（ACK）

  • 通过刚才的案例可以看出，消息一旦被消费者接收，队列中的消息就会被删除。
  • 那么问题来了：RabbitMQ怎么知道消息被接收了呢？
  • 如果消费者领取消息后，还没执行操作就挂掉了呢？或者抛出了异常？消息消费失败，但是RabbitMQ无从得知，这样消息就丢失了！
  • 因此，RabbitMQ有一个ACK机制。当消费者获取消息后，会向RabbitMQ发送回执ACK，告知消息已经被接收。
  • 不过这种回执ACK分两种情况：
  • 自动ACK：消息一旦被接收，消费者自动发送ACK
  • 手动ACK：消息接收后，不会发送ACK，需要手动调用
  • 大家觉得哪种更好呢？
  • 这需要看消息的重要性：
  • 如果消息不太重要，丢失也没有影响，那么自动ACK会比较方便
  • 如果消息非常重要，不容丢失。那么最好在消费完成后手动ACK，否则接收消息后就自动ACK，RabbitMQ就会把消息从队列中删除。如果此时消费者宕机，那么消息就丢失了。
  • 我们之前的测试都是自动ACK的，如果要手动ACK，需要改动我们的代码：
public class Recv2 {
    
    
   private final static String QUEUE_NAME = "simple_queue";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 创建通道
       final Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
    
    
               // body 即消息体
               String msg = new String(body);
        //int i = 1/0;
               System.out.println(" [x] received : " + msg + "!");
               // 手动进行ACK
               channel.basicAck(envelope.getDeliveryTag(), false);
           }
       };
       // 监听队列，第二个参数false，手动进行ACK
       channel.basicConsume(QUEUE_NAME, false, consumer);
   }
}

注意到最后一行代码：

channel.basicConsume(QUEUE_NAME, false, consumer);

如果第二个参数为true，则会自动进行ACK；如果为false，则需要手动ACK
在这里插入图片描述
自动ACK存在的问题
修改消费者，添加异常，如下：
在这里插入图片描述
生产者不做任何修改，直接运行，消息发送成功：
在这里插入图片描述
运行消费者，程序抛出异常。但是消息依然被消费：
在这里插入图片描述
管理界面：
在这里插入图片描述
演示手动ACK
修改消费者，把自动改成手动（去掉之前制造的异常）
在这里插入图片描述
生产者不变，再次运行：
在这里插入图片描述
运行消费者
在这里插入图片描述
但是，查看管理界面，发现：
在这里插入图片描述
停掉消费者的程序，发现：
在这里插入图片描述
这是因为虽然我们设置了手动ACK，但是代码中并没有进行消息确认！所以消息并未被真正消费掉。
当我们关掉这个消费者，消息的状态再次称为Ready
修改代码手动ACK：
在这里插入图片描述
执行：
在这里插入图片描述
消息消费成功！

2.3 work消息模型

工作队列或者竞争消费者模式
在这里插入图片描述
工作队列，又称任务队列。主要思想就是避免执行资源密集型任务时，必须等待它执行完成。相反我们稍后完成任务，我们将任务封装为消息并将其发送到队列。 在后台运行的工作进程将获取任务并最终执行作业。当你运行许多消费者时，任务将在他们之间共享，一个消息只能被一个消费者获取。
这个概念在Web应用程序中特别有用，因为在短的HTTP请求窗口中无法处理复杂的任务。
接下来我们来模拟这个流程：

  • P：生产者：任务的发布者​
  • C1：消费者，领取任务并且完成任务，假设完成速度较快​
  • C2：消费者2：领取任务并完成任务，假设完成速度慢
    面试题：避免消息堆积？
    1）采用workqueue，多个消费者监听同一队列。
    2）接收到消息以后，通过线程池，异步消费。
    Send
public class Send {
    
    
   private final static String QUEUE_NAME = "test_work_queue";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 循环发布任务
       for (int i = 0; i < 50; i++) {
    
    
           // 消息内容
           String message = "task .. " + i;
           channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
           System.out.println(" [x] Sent '" + message + "'");​
       }
       // 关闭通道和连接
       channel.close();
       connection.close();
   }
}

Receive

public class Recv {
    
    
    private final static String QUEUE_NAME = "test_work_queue";
    public static void main(String[] argv) throws Exception {
    
    
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
    
    
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者1] received : " + msg + "!");
                try {
    
    
                    // 模拟完成任务的耗时：1000ms
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                }
                // 手动ACK
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 监听队列。
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

Receibe2

//消费者2
public class Recv2 {
    
    
    private final static String QUEUE_NAME = "test_work_queue";
    public static void main(String[] argv) throws Exception {
    
    
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
    
    
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者2] received : " + msg + "!");
                try {
    
    
                    // 模拟完成任务的耗时：200ms
                    Thread.sleep(200);
                } catch (InterruptedException e) {
    
    
                }
                // 手动ACK
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 监听队列。
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

消费者1基本类似，就是没有设置消费耗时时间。这里是模拟有些消费者快，有些比较慢。接下来，两个消费者一同启动，然后发送50条消息：

在这里插入图片描述
可以发现，两个消费者各自消费了25条消息，而且各不相同，这就实现了任务的分发。
能者多劳

  • 刚才的实现有问题吗？
    • 消费者1比消费者2的效率要低，一次任务的耗时较长
    • 然而两人最终消费的消息数量是一样的
    • 消费者2大量时间处于空闲状态，消费者1一直忙碌
  • 现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多。
  • 怎么实现呢？
    • 我们可以使用basicQos方法和prefetchCount = 1设置。
    • 这告诉RabbitMQ一次不要向工作人员发送多于一条消息。
    • 或者换句话说，不要向工作人员发送新消息，直到它处理并确认了前一个消息。
    • 相反，它会将其分派给不忙碌的下一个工作人员。
      在这里插入图片描述
      再次测试：
      在这里插入图片描述

2.4 订阅模型分类

在之前的模式中，我们创建了一个工作队列。 工作队列背后的假设是：每个任务只被传递给一个工作人员。 在这一部分，我们将做一些完全不同的事情 - 我们将会传递一个信息给多个消费者。 这种模式被称为“发布/订阅”。
在这里插入图片描述
解读：
1、1个生产者，多个消费者
2、每一个消费者都有自己的一个队列
3、生产者没有将消息直接发送到队列，而是发送到了交换机
4、每个队列都要绑定到交换机
5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的
X（Exchanges）：

  • 交换机一方面：接收生产者发送的消息。
  • 另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

Exchange类型有以下几种：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

2.5 订阅模型-Fanout

Fanout，也称为广播。
在这里插入图片描述
在广播模式下，消息发送流程是这样的：
1） 可以有多个消费者
2） 每个消费者有自己的queue（队列）
3） 每个队列都要绑定到Exchange（交换机）
4） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
5） 交换机把消息发送给绑定过的所有队列
6） 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
Send
两个变化：
1） 声明Exchange，不再声明Queue
2） 发送消息到Exchange，不再发送到Queue

public class Send {
   private final static String EXCHANGE_NAME = "fanout_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明exchange，指定类型为fanout
       channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
       // 消息内容
       String message = "Hello everyone";
       // 发布消息到Exchange
       channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
       System.out.println(" [生产者] Sent '" + message + "'");
       channel.close();
       connection.close();
   }
}

Receive1

public class Recv {
    
    
   private final static String QUEUE_NAME = "fanout_exchange_queue_1";
   private final static String EXCHANGE_NAME = "fanout_exchange_test";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body) throws IOException {
    
    
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者1] received : " + msg + "!");
           }
       };
       // 监听队列，自动返回完成
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

Receive2

public class Recv2 {
    
    
   private final static String QUEUE_NAME = "fanout_exchange_queue_2";
   private final static String EXCHANGE_NAME = "fanout_exchange_test";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
    
    
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
    
    
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者2] received : " + msg + "!");
           }
       };
       // 监听队列，手动返回完成
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

我们应该先启动生产者，否则，先启动消费者时，由于要绑定交换机，此时，交换机并不存在所以会报错。
我们运行两个消费者，然后发送1条消息：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.6 订阅模型-Direct

  • 有选择性的接收消息
  • 在订阅模式中，生产者发布消息，所有消费者都可以获取所有消息。
  • 在路由模式中，我们将添加一个功能 - 我们将只能订阅一部分消息。
    • 例如，我们只能将重要的错误消息引导到日志文件（以节省磁盘空间），同时仍然能够在控制台上打印所有日志消息。
  • 但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
  • 在Direct模型下，队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在向Exchange发送消息时，也必须指定消息的routing key。

在这里插入图片描述

  • P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
  • C1：消费者，其所在队列指定了需要routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

Send
此处我们模拟商品的增删改，发送消息的RoutingKey分别是：insert、update、delete

public class Send {
    
    
   private final static String EXCHANGE_NAME = "direct_exchange_test";
   public static void main(String[] argv) throws Exception {
    
    
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明exchange，指定类型为direct
       channel.exchangeDeclare(EXCHANGE_NAME, "direct");
       // 消息内容
       String message = "商品新增了， id = 1001";
       // 发送消息，并且指定routing key 为：insert ,代表新增商品
       channel.basicPublish(EXCHANGE_NAME, "insert", null, message.getBytes());
       System.out.println(" [商品服务：] Sent '" + message + "'");
       channel.close();
       connection.close();
   }
}

Receive1
我们此处假设消费者1只接收两种类型的消息：更新商品和删除商品。

public class Recv {
   private final static String QUEUE_NAME = "direct_exchange_queue_1";
   private final static String EXCHANGE_NAME = "direct_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机，同时指定需要订阅的routing key。假设此处需要update和delete消息
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者1] received : " + msg + "!");
           }
       };
       // 监听队列，自动ACK
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

Receive2
我们此处假设消费者2接收所有类型的消息：新增商品，更新商品和删除商品。

public class Recv2 {
   private final static String QUEUE_NAME = "direct_exchange_queue_2";
   private final static String EXCHANGE_NAME = "direct_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机，同时指定需要订阅的routing key。订阅 insert、update、delete
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "insert");
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者2] received : " + msg + "!");
           }
       };
       // 监听队列，自动ACK
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

我们分别发送增、删、改的RoutingKey，发现结果：

在这里插入图片描述
在这里插入图片描述

2.7 订阅模型-Topic

  • Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！
  • Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
  • 通配符规则：
    • #：匹配0或多个词​（含零个）
    • *：匹配不多不少恰好1个词（不含零个）
  • 举例：
    • audit.#：能够匹配audit.irs.corporate 或者 audit.irs​
    • audit.*：只能匹配audit.irs
      在这里插入图片描述
  • 在这个例子中，我们将发送所有描述动物的消息。消息将使用由三个字（两个点）组成的routing key发送。路由关键字中的第一个单词将描述速度，第二个颜色和第三个种类：“..”。
  • 我们创建三个绑定：
    Q1绑定了绑定键“* .orange.”，Q2绑定了“.*.rabbit”和“lazy.＃”。
  • Q1匹配所有的橙色动物。
  • Q2匹配关于兔子以及懒惰动物的消息。
    Send
    使用topic类型的Exchange，发送消息的routing key有3种： item.isnert、item.update、item.delete：
public class Send {
   private final static String EXCHANGE_NAME = "topic_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明exchange，指定类型为topic
       channel.exchangeDeclare(EXCHANGE_NAME, "topic");
       // 消息内容
       String message = "新增商品 : id = 1001";
       // 发送消息，并且指定routing key 为：insert ,代表新增商品
       channel.basicPublish(EXCHANGE_NAME, "item.insert", null, message.getBytes());
       System.out.println(" [商品服务：] Sent '" + message + "'");
       channel.close();
       connection.close();
   }
}

Receive1

public class Recv {
   private final static String QUEUE_NAME = "topic_exchange_queue_1";
   private final static String EXCHANGE_NAME = "topic_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机，同时指定需要订阅的routing key。需要 update、delete
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.update");
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.delete");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者1] received : " + msg + "!");
           }
       };
       // 监听队列，自动ACK
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

Receive2
我们此处假设消费者2接收所有类型的消息：新增商品，更新商品和删除商品。

/**
* 消费者2
*/
public class Recv2 {
   private final static String QUEUE_NAME = "topic_exchange_queue_2";
   private final static String EXCHANGE_NAME = "topic_exchange_test";
   public static void main(String[] argv) throws Exception {
       // 获取到连接
       Connection connection = ConnectionUtil.getConnection();
       // 获取通道
       Channel channel = connection.createChannel();
       // 声明队列
       channel.queueDeclare(QUEUE_NAME, false, false, false, null);
       // 绑定队列到交换机，同时指定需要订阅的routing key。订阅 insert、update、delete
       channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.*");
       // 定义队列的消费者
       DefaultConsumer consumer = new DefaultConsumer(channel) {
           // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                   byte[] body) throws IOException {
               // body 即消息体
               String msg = new String(body);
               System.out.println(" [消费者2] received : " + msg + "!");
           }
       };
       // 监听队列，自动ACK
       channel.basicConsume(QUEUE_NAME, true, consumer);
   }
}

在这里插入图片描述
在这里插入图片描述

三. 持久化

  • 如何避免消息丢失？
    1） 消费者的ACK机制。可以防止消费者丢失消息。
    2） 但是，如果在消费者消费之前，MQ就宕机了，消息就没了。
  • 如何将消息进行持久化呢？
    要将消息持久化，前提是：队列、Exchange都持久化

3.1 交换机持久化和消息持久化

在这里插入图片描述

3.2 队列持久化

在这里插入图片描述

四. Spring AMQP

4.1 简介

Spring有很多不同的项目，其中就有对AMQP的支持：
在这里插入图片描述
Spring-amqp是对AMQP协议的抽象实现，而spring-rabbit 是对协议的具体实现，也是目前的唯一实现。底层使用的就是RabbitMQ。

4.2 依赖和配置

添加AMQP的启动器：

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

在application.yml中添加RabbitMQ地址：

spring:
  rabbitmq:
    host: 192.168.137.137
    username: zhangsan
    password: 123456
    virtual-host: /shopping
    port: 5672

监听者
在SpringAmqp中，对消息的消费者进行了封装和抽象，一个普通的JavaBean中的普通方法，只要通过简单的注解，就可以成为一个消费者。

@Component
public class Listener {
    
    
   @RabbitListener(bindings = @QueueBinding(
           value = @Queue(value = "spring.test.queue", durable = "true"),
           exchange = @Exchange(
                   value = "spring.test.exchange",
                   ignoreDeclarationExceptions = "true",
                   type = ExchangeTypes.TOPIC
           ),
           key = {
    
    "#.#"}))
   public void listen(String msg){
    
    
       System.out.println("接收到消息：" + msg);
   }
}
  • @Componet：类上的注解，注册到Spring容器
  • @RabbitListener：方法上的注解，声明这个方法是一个消费者方法，需要指定下面的属性：
    • bindings：指定绑定关系，可以有多个。值是@QueueBinding的数组。@QueueBinding包含下面属 性：
    • value：这个消费者关联的队列。值是@Queue，代表一个队列
    • exchange：队列所绑定的交换机，值是@Exchange类型
    • key：队列和交换机绑定的RoutingKey
      类似listen这样的方法在一个类中可以写多个，就代表多个消费者。

4.3 AmqpTemplate

Spring最擅长的事情就是封装，把他人的框架进行封装和整合。Spring为AMQP提供了统一的消息处理模板：AmqpTemplate，非常方便的发送消息，其发送方法：
在这里插入图片描述
红框圈起来的是比较常用的3个方法，分别是：
- 指定消息
- 指定RoutingKey和消息，会向默认的交换机发送消息
- 指定交换机、RoutingKey和消息体

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class MqDemo {
    
    
   @Autowired
   private AmqpTemplate amqpTemplate;
   @Test
   public void testSend() throws InterruptedException {
    
    
       String msg = "hello, Spring boot amqp";
       this.amqpTemplate.convertAndSend("spring.test.exchange","a.b", msg);
       // 等待10秒后再结束
       Thread.sleep(10000);
   }
}

在这里插入图片描述
Rabbitmq课件，源码上传于gitee：链接: https://gitee.com/hdyxk/rabbit-mq-learning-source-code.

猜你喜欢

转载自blog.csdn.net/weixin_44726976/article/details/108730360
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022