开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 14 天，点击查看活动详情

3.RabbitMQ开发

3.1.导入案例项目

我们通过案例工程来了解下RabbitMQ的工作方式：

导入工程：直接打开即可

如果导入工程显示：

转换maven工程即可：

案例工程介绍：

pom依赖：

无spring整合

<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.7.3</version>
    </dependency>
</dependencies>

springboot整合： pom

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
</parent>

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

3.2.RabbitMQ五种消息模型（了解）

RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。

但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。

3.3.基本消息模型

3.3.1说明

官方文档说明：

RabbitMQ是一个消息的代理者（Message Broker）：它接收消息并且传递消息。

你可以认为它是一个邮局：当你投递邮件到一个邮箱，你很肯定邮递员会终究会将邮件递交给你的收件人。与此类似，RabbitMQ 可以是一个邮箱、邮局、同时还有邮递员。

不同之处在于：RabbitMQ不是传递纸质邮件，而是二进制的数据

基本消息模型图：

在上图的模型中，有以下概念：

P：生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

我们在控制台先创建一个虚拟主机对象：使用默认账号和密码 guest 登录即可

确定guest用于操作虚拟主机权限

3.3.2.生产者

连接mq工具类：

public class ConnectionUtil {
    /**
     * 建立与RabbitMQ的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/itcast");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 通过工程获取连接
        return factory.newConnection();
    }
}

测试连接：
    public static void main(String[] args) throws Exception {
        System.out.println(getConnection());
    }
    
控制台：表示 连接成功！

编写生产者发送消息到mq：

package com.it.rabbitmq.simple;

import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;


/**
 * 生产者
 */
public class Send {

    public static void main(String[] argv) throws Exception {
        // 1. 建立和mq的连接
        Connection connection = ConnectionUtil.getConnection();
        // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();
        // 3. 使用信道（创建）队列
        channel.queueDeclare("simple-queue", false, false, false, null);
        // 4. 定义发送到mq的消息内容
        String message = "Hello World!";
        // 5. 向指定的队列中发送消息
        channel.basicPublish("", "simple-queue", null, message.getBytes());
        
        System.out.println(" [x] Provider Sent :" + message);
        //关闭通道和连接
        channel.close();
        connection.close();
    }
}

控制台：

3.3.3.web控制台查看消息

进入队列页面，可以看到新建了一个队列：simple-queue

等待5秒

点击队列名称，进入详情页，可以查看消息：

在控制台查看消息并不会将消息消费，所以消息还在。

至此 生产者开发完成！

3.3.4.消费者获取消息


/**
 * 消费者
 */
public class Recv {

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare("simple-queue", 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);
                System.out.println(" [x] received : " + msg + "!");
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。
        channel.basicConsume("simple-queue", true, consumer);
    }
}

控制台：

这个时候，队列中的消息就没了：

阶段小结：

上述案例，生产者发送一个消息，消费者获取消息之后，会自动删除队列里面的消息。

那么如果，消费者方由于业务代码或网络问题或其他问题导致消息获取了但是在消息处理过程中出现了异常，

此时队列里面的消息已经自动删除了，那么消费者方将无法获取之前的消息！

这样的场景，我们队列就不能进行自动删除消息，而是由消费者方来决定消息删除的时机！

消费者方代码演示：

web管理台

此时消息并未删除，而是未确认！我们可以做如下配置：

此时消息处理方案：

消息有用，重新放回消息队列 - 由于网络波动。我们还是需要此条消息的
消息无用，如果异常或网络波动，此消息及时有效，我们不需要此条消息，那么通知队列直接删除即可

package com.it.rabbitmq.simple;


import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;



/**
 * 消费者
 */
public class Recv {

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare("simple-queue", false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    // body 即消息体
                    String msg = new String(body);
                    System.out.println(1/0); // 模拟异常  表示消息未正常处理
                    System.out.println(" [x] received : " + msg + "!");
                    channel.basicAck(envelope.getDeliveryTag(),false);//  代码没有异常 手动通知队列 删除消息即可
                } catch (Exception e){
                    e.printStackTrace();  //  第三个参数  false  直接删除消息   true  表示 ：把消息重回队列
                    channel.basicNack(envelope.getDeliveryTag(),false,true);
                }
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。 false 告诉队列不要删除消息
        channel.basicConsume("simple-queue", false, consumer);
    }
}

3.4.work消息模型

3.4.1.说明

在刚才的基本模型中，一个生产者，一个消费者，生产的消息直接被消费者消费。比较简单。

Work queues，也被称为（Task queues），任务模型。

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

角色：

P：生产者：任务的发布者
C1：消费者，领取任务并且完成任务，假设完成速度较慢
C2：消费者2：领取任务并完成任务，假设完成速度快

3.4.2.生产者

生产者与案例1中的几乎一样：



// 生产者
public class Send {

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare("work-queue", false, false, false, null);
        // 循环发布任务
        for (int i = 0; i < 50; i++) {
            // 消息内容
            String message = "task .. " + i;
            channel.basicPublish("","work-queue", null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        // 关闭通道和连接
        channel.close();
        connection.close();
    }
}

我们循环发送50条消息。

3.4.3.消费者

消费者1：睡一秒较慢

// 消费者1
public class Recv {
    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare("work-queue", false, false, false, null);

        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                try {
                // body 即消息体
                    String msg = new String(body);
                    Thread.sleep(1000);
                    System.out.println(" [消费者1] received : " + msg + "!");
                    // 手动ACK
                    channel.basicAck(envelope.getDeliveryTag(), false);
                } catch (Exception e) {
                    channel.basicNack(envelope.getDeliveryTag(),false,true);
                }

            }
        };
        // 监听队列。
        channel.basicConsume("work-queue", false, consumer);
    }
}

消费者2: 较快一方

//消费者2
public class Recv2 {

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare("work-queue", false, false, false, null);

        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    // body 即消息体
                    String msg = new String(body);
                    System.out.println(" [消费者2] received : " + msg + "!");
                    // 手动ACK
                    channel.basicAck(envelope.getDeliveryTag(), false);
                } catch (Exception e) {
                    channel.basicNack(envelope.getDeliveryTag(),false,true);
                }

            }
        };
        // 监听队列。
        channel.basicConsume("work-queue", false, consumer);
    }
}

与消费者1基本类似，就是没有设置消费耗时时间。

这里是模拟有些消费者快，有些比较慢。

接下来，两个消费者一同启动，然后发送50条消息：

可以发现，两个消费者各自消费了25条消息，而且各不相同，这就实现了任务的分发。

3.4.4.能者多劳原则

刚才的实现有问题吗？

消费者1比消费者2的效率要低，一次任务的耗时较长
然而两人最终消费的消息数量是一样的
消费者2大量时间处于空闲状态，消费者1一直忙碌

现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多。

怎么实现呢？

我们可以修改设置，让消费者同一时间只接收一条消息，这样处理完成之前，就不会接收更多消息，就可以让处理快的人，接收更多消息：

再次测试：

3.5.订阅模型分类

订阅模型示意图：

前面2个案例中，只有3个角色：

P：生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

而在订阅模型中，多了一个exchange角色，而且过程略有变化：

P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
C：消费者，消息的接受者，会一直等待消息到来。
Queue：消息队列，接收消息、缓存消息。
Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

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

3.6.订阅模型-Fanout

Fanout，英文翻译是扇出，我觉得在MQ中叫广播更合适。

3.6.1.流程说明

流程图：

在广播模式下，消息发送流程是这样的：

1）可以有多个消费者
2）每个消费者有自己的queue（队列）
3）每个队列都要绑定到Exchange（交换机）
4） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
5）交换机把消息发送给绑定过的所有队列
6）队列的消费者都能拿到消息。实现一条消息被多个消费者消费

3.6.2.生产者

两个变化：

1）声明Exchange，不再声明Queue
2）发送消息到Exchange，不再发送到Queue

package com.it.rabbitmq.fanout;

import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

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

public class FanoutProducer {

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

        // 1. 建立和mq的连接
        Connection connection = ConnectionUtil.getConnection();
        // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();

        //3.声明交换器和队列
        String exchangeName = "exchange-fanout";
        channel.exchangeDeclare(exchangeName,"fanout",true); //扇形交换机类型-fanout
        //  创建多个队列
        String fanoutQueue1 = "fanout_queue1";
        //队列1
        channel.queueDeclare(fanoutQueue1, true, false, false,null);
        //队列2
        String fanoutQueue2 = "fanout_queue2";
        channel.queueDeclare(fanoutQueue2, true, false, false,null);

        //4.同一个交换机与2个队列绑定   参数3： 扇出形式 不需要路由规则   两个队列都会接受到生产投递的消息
        channel.queueBind(fanoutQueue1,exchangeName,"");//绑定第一个队列
        channel.queueBind(fanoutQueue2,exchangeName,"");//绑定第二个队列
        //5.生产消息
        for(int i=0;i<10;i++){
            channel.basicPublish(exchangeName,"", true,null,"hello fanout!".getBytes());
        }
        //6.关闭channel和连接
        channel.close();
        //关闭连接
        connection.close();

    }

}

扇出方式两个队列都会接受交换机传递过来的消息！

3.6.3.消费者

消费者1

public class FanoutConsumer1 {

    public static void main(String[] args) throws Exception {
        // 1. 建立和mq的连接
        Connection connection = ConnectionUtil.getConnection();
        // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
        final Channel channel = connection.createChannel();

        // 3. 队列名称
        String queueName = "fanout_queue1";
        // 绑定队列到交换机
        channel.queueBind(queueName, "exchange-fanout", "");

        //  4. 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    // body 即消息体
                    String msg = new String(body);
//                    System.out.println(1/0); // 模拟异常  表示消息未正常处理
                    System.out.println(" fanout-consumer 1 : [x] received : " + msg + "!");
                    channel.basicAck(envelope.getDeliveryTag(),false);//  代码没有异常 手动通知队列 删除消息即可
                } catch (Exception e){
                    e.printStackTrace();  //  第三个参数  false  直接删除消息   true  表示 ：把消息重回队列
                    channel.basicNack(envelope.getDeliveryTag(),false,true);
                }
            }
        };
        // 5. 监听队列，第二个参数：是否自动进行消息确认。 false 告诉队列不要删除消息
        channel.basicConsume(queueName, false, consumer);

    }

}

要注意代码中：队列需要和交换机绑定

// 3. 队列名称
String queueName = "fanout_queue1";
// 绑定队列到交换机
channel.queueBind(queueName, "exchange-fanout", "");

消费者2

package com.it.rabbitmq.fanout;

import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class FanoutConsumer2 {

    public static void main(String[] args) throws Exception {
        // 1. 建立和mq的连接
        Connection connection = ConnectionUtil.getConnection();
        // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
        final Channel channel = connection.createChannel();

        // 3. 队列名称
        String queueName = "fanout_queue2";
        // 绑定队列到交换机
        channel.queueBind(queueName, "exchange-fanout", "");

        //  4. 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    // body 即消息体
                    String msg = new String(body);
//                    System.out.println(1/0); // 模拟异常  表示消息未正常处理
                    System.out.println(" fanout-consumer 2 : [x] received : " + msg + "!");
                    channel.basicAck(envelope.getDeliveryTag(),false);//  代码没有异常 手动通知队列 删除消息即可
                } catch (Exception e){
                    e.printStackTrace();  //  第三个参数  false  直接删除消息   true  表示 ：把消息重回队列
                    channel.basicNack(envelope.getDeliveryTag(),false,true);
                }
            }
        };
        // 5. 监听队列，第二个参数：是否自动进行消息确认。 false 告诉队列不要删除消息
        channel.basicConsume(queueName, false, consumer);

    }

}

测试：先启动生产者发送消息

然后我们再运行消费者1，然后再运行消费者2：

扇出方式：两个队列彼此独立，互不干扰！

3.7.订阅模型-Direct

3.7.1.说明

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

流程图：

图解：

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

3.7.2.生产者

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

public class DirectProducer {

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

        // 1. 建立和mq的连接
        Connection connection = ConnectionUtil.getConnection();
        // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();
        //3.声明交换器和队列
        //3.声明交换器和队列
        String exchangeName = "exchange-direct";
        channel.exchangeDeclare(exchangeName,"direct",false); //交换机类型-direct
        //  创建2个队列
        String directQueue1 = "direct_queue1";
        //队列1
        channel.queueDeclare(directQueue1, false, false, false,null);
        //队列2
        String directQueue2 = "direct_queue2";
        channel.queueDeclare(directQueue2, false, false, false,null);

        //4.同一个交换机与2个队列绑定   参数3： 直连direct形式  定义路由规则   两个队列按照路由 接受对应的消息
        channel.queueBind(directQueue1,exchangeName,"insert");//绑定第一个队列
        channel.queueBind(directQueue2,exchangeName,"delete");//绑定第二个队列
        channel.queueBind(directQueue2,exchangeName,"update");//绑定第二个队列
        //5.生产消息  向指定的队列投递消息
        for(int i=0;i<10;i++){
            channel.basicPublish(exchangeName,"insert", true,null,"hello direct insert!".getBytes());
            channel.basicPublish(exchangeName,"delete", true,null,"hello direct delete!".getBytes());
            channel.basicPublish(exchangeName,"update", true,null,"hello direct update!".getBytes());
        }

        //6.关闭channel和连接
        channel.close();
        //关闭连接
        connection.close();
    }

}

3.7.3.消费者

我们此处假设消费者1只接收1种类型的消息：例如接受添加商品信息。

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

            // 1. 建立和mq的连接
            Connection connection = ConnectionUtil.getConnection();
            // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
            final Channel channel = connection.createChannel();

            // 3. 队列名称  insert
            String queueName = "direct_queue1";
            // 绑定队列到交换机
            channel.queueBind(queueName, "exchange-direct", "insert");

            //  4. 定义队列的消费者
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                           byte[] body) throws IOException {
                    try {
                        // body 即消息体
                        String msg = new String(body);
//                    System.out.println(1/0); // 模拟异常  表示消息未正常处理
                        System.out.println(" direct-consumer 1 : [x] received : " + msg + "!");
                        channel.basicAck(envelope.getDeliveryTag(),false);//  代码没有异常 手动通知队列 删除消息即可
                    } catch (Exception e){
                        e.printStackTrace();  //  第三个参数  false  直接删除消息   true  表示 ：把消息重回队列
                        channel.basicNack(envelope.getDeliveryTag(),false,true);
                    }
                }
            };
            // 5. 监听队列，第二个参数：是否自动进行消息确认。 false 告诉队列不要删除消息
            channel.basicConsume(queueName, false, consumer);

        }

消费者2

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

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

            // 1. 建立和mq的连接
            Connection connection = ConnectionUtil.getConnection();
            // 2. 从连接中创建通道，channel   使用通道才能完成消息相关的操作
            final Channel channel = connection.createChannel();

            // 3. 队列名称
            String queueName2 = "direct_queue2";
            // 绑定队列到交换机
            channel.queueBind(queueName2, "exchange-direct", "delete");
            channel.queueBind(queueName2, "exchange-direct", "update");

            //  4. 定义队列的消费者
            DefaultConsumer consumer = new DefaultConsumer(channel) {
                // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                           byte[] body) throws IOException {
                    try {
                        // body 即消息体
                        String msg = new String(body);
//                    System.out.println(1/0); // 模拟异常  表示消息未正常处理
                        System.out.println(" direct-consumer 2 : [x] received : " + msg + "!");
                        channel.basicAck(envelope.getDeliveryTag(),false);//  代码没有异常 手动通知队列 删除消息即可
                    } catch (Exception e){
                        e.printStackTrace();  //  第三个参数  false  直接删除消息   true  表示 ：把消息重回队列
                        channel.basicNack(envelope.getDeliveryTag(),false,true);
                    }
                }
            };
            // 5. 监听队列，第二个参数：是否自动进行消息确认。 false 告诉队列不要删除消息
            channel.basicConsume(queueName2, false, consumer);

        }

3.7.4.测试

3.8.订阅模型-Topic

3.8.1.说明

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

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

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

举例：

item.#：能够匹配item.spu.insert 或者 item.spu

item.*：只能匹配item.spu

图示：

解释：

红色Queue：绑定的是usa.# ，因此凡是以 usa.开头的routing key 都会被匹配到
黄色Queue：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配

3.8.2.生产者

使用topic类型的Exchange，发送消息的routing key

注意：此案例先启动消费端按照指定路由监听：再启动服务端，再投递消息！

可以根据 user.update product.insert user.insert 测试


public class TopicProducer {


    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 消息内容
        String message = "新增用户 : id = 1001";
        //并且指定routing key 分别使用  user.update， user.delete， product.update 三次测试
        channel.basicPublish("exchange-topic", "user.update", null, message.getBytes());
        System.out.println(" [生产者：] Sent '" + message + "'");

        channel.close();
        connection.close();
    }


}

3.8.3.消费者1

我们此处假设消费者1只接收的RoutingKey为 user.#，代表所有以user开头的key

注意：本案例：交换机和队列均由消费者创建，生产者不创建交换机和队列来演示

package com.it.rabbitmq.topic;

import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;

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

public class TopicConsumer1 {


    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明exchange，指定类型为topic
        channel.exchangeDeclare("exchange-topic", "topic");
        channel.queueDeclare("topic_queue1", false, false, false,null);
        // 绑定队列到交换机，同时指定需要订阅的routing key。订阅 user开头的
        channel.queueBind("topic_queue1", "exchange-topic", "user.#");

        // 定义队列的消费者
        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(" [topic 消费者1] received : " + msg + "!");
            }
        };
        // 监听队列，自动ACK
        channel.basicConsume("topic_queue1", true, consumer);
    }

}

3.8.4.消费者2

我们此处假设消费者2接收的消息key：*.insert，与新增有关。

package com.it.rabbitmq.topic;

import com.it.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class TopicConsumer2 {


    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();

        // 声明exchange，指定类型为topic
        channel.exchangeDeclare("exchange-topic", "topic");
        channel.queueDeclare("topic_queue2", false, false, false,null);
        // 绑定队列到交换机，同时指定需要订阅的routing key。订阅 *.insert
        channel.queueBind("topic_queue2", "exchange-topic", "#.insert");


        // 定义队列的消费者
        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(" [topic 消费者2] received : " + msg + "!");
            }
        };
        // 监听队列，自动ACK
        channel.basicConsume("topic_queue2", true, consumer);
    }

}

3.8.5.测试：先启动消费者再启动生产者

发送3个消息：生产者路由三次改动：

用户新增，RoutingKey为 user.insert
用户修改，RoutingKey为user.update
商品更新，RoutingKey为product.update

看效果！

3.9.持久化

为了提高并发能力，MQ的数据默认是在内存中存储的，包括交换机、队列、消息。

这样就会出现数据安全问题，如果服务宕机，存储在MQ中未被消费的消息都会丢失。

所以我们需要将交换机、队列、消息持久化到硬盘，以防服务宕机。

交换机持久化：

队列持久化：

消息持久化：

3.10 阶段小结

上述开发，我们得出一个结论：

mq开发时，生产者可以创建交换机，队列，消费者也同意可以创建交换机和队列，那么在开发时，极容易出现

队列或交换机名称不一致情况，为了避免开发中出现的这样的问题！

我们可以约定如下规则：

虚拟机和交换机以及队列都会在web控制台管理创建好！不要使用代码创建交换机和队列
设计好方案之后，我们代码就按照控制台定义的名称开发即可！

案例实现步骤参照：

控制台界面创建一个虚拟机 /heima
在该虚拟机下创建一个直连交换机：

创建队列

交换机绑定队列

至此准备工作完成！

交换机名称： heima.direct 虚拟主机： /heima 队列名称： heima-queue

后续不需要代码创建上述内容！

RabbitMQ开发