RabbitMQ消息中间件（四）：工作模式之发布订阅模式 （Publish/subscribe）

---

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

• P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
• C：消费者，消息的接受者，会一直等待消息到来。
• Queue：消息队列，接收消息、缓存消息。
• Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：

（1）Fanout：广播，将消息交给所有绑定到交换机的队列
（2）Direct：定向，把消息交给符合指定routing key 的队列
（3）Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

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

发布订阅模式：

（1）每个消费者监听自己的队列。
（2）生产者将消息发给broker（中间件），由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。

说明：

• P：生产者，也就是要发送消息的程序
• X：交换机
• C：消费者：消息的接受者，会一直等待消息到来。
• queue：消息队列，图中红色部分

---

一、生产者Module

（1）pom.xml

<?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">
    <parent>
        <artifactId>rabbitmq-demo</artifactId>
        <groupId>net.xiaof</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rabbitmq-producer</artifactId>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--rabbitmq java 客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

（2）生产者类

package net.xiaof.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

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

/**
 * @author zhangxh
 * @Description: 生产者（发布订阅模式）
 * @date 2020-12-14
 */
public class Producer_PubSub {

    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂，设置相关连接参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.116.161");
        factory.setPort(5672);
        factory.setVirtualHost("/myhost");
        factory.setUsername("xiao");
        factory.setPassword("xiao");

        //2. 创建连接Connection
        Connection connection = factory.newConnection();

        //3. 创建Channel
        Channel channel = connection.createChannel();

        //4. 声明交换机exchange
        /**
         * 【API说明】：
         * exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
         * 参数：
         * （1）String exchange：交换机名称
         * （2）BuiltinExchangeType type：交换机类型
         *      DIRECT("direct")：定向
         *      FANOUT("fanout")：扇形（广播），发送消息到每一个与之绑定队列。
         *      TOPIC("topic")：通配符的方式
         *      HEADERS("headers")：参数匹配
         * （3）boolean durable：是否持久化
         * （4）boolean autoDelete：是否自动删除
         * （5）boolean internal：内部使用，一般用false
         * （6）Map<String, Object> arguments：参数
         */
        String exchangeName = "pubsub_exchange";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT, true, false, false, null);

        //5. 声明队列Queue
        /**
         * 【API说明】：
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * 参数：
         * （1）String queue：队列名称。如果当前队列名称不存在，则会创建该队列，否则不会创建
         * （2）boolean durable：是否持久化。即队列在服务器重启后是否还存在
         * （3）boolean exclusive：是否独占。只能有一个消费者监听这队列；当Connection关闭时，是否删除队列
         * （4）boolean autoDelete：是否自动删除。如果为true，至少有一个消费者连接到这个队列，之后所有与这个队列连接的消费者都断开时，队列会自动删除。
         * （5）Map<String, Object> arguments：附带参数。队列的其他属性，例如：x-message-ttl、x-expires、x-max-length、x-maxlength-bytes、x-dead-letter-exchange、x-dead-letter-routing-key、x-max-priority
         */
        String queueName1 = "pubsub_queue1";
        String queueName2 = "pubsub_queue2";
        channel.queueDeclare(queueName1, true, false, false, null);
        channel.queueDeclare(queueName2, true, false, false, null);

        //6. 绑定队列和交换机
        /**
         * 【API说明】：
         * queueBind(String queue, String exchange, String routingKey)
         * 参数：
         * （1）String queue：队列名称。
         * （2）String exchange：交换机名称
         * （3）String routingKey：路由键，绑定规则
         *      如果交换机的类型为fanout ，routingKey设置为""
         */
        channel.queueBind(queueName1,exchangeName,"");
        channel.queueBind(queueName2,exchangeName,"");

        //7. 发布消息
        /**
         * 【API说明】：
         * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         * 参数：
         * （1）String exchange：交换机名称。简单模式下交换机会使用默认的 ""
         * （2）String routingKey：路由key
         * （3）BasicProperties props：配置信息
         * （4）byte[] body：发送消息数据
         */
        String bodyMsg = "hello rabbitmq~~~好的";
        channel.basicPublish(exchangeName, "", null, bodyMsg.getBytes());

        //8. 关闭资源
        channel.close();
        connection.close();

    }

}

---

二、消费者Module

（1）pom.xml

<?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">
    <parent>
        <artifactId>rabbitmq-demo</artifactId>
        <groupId>net.xiaof</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rabbitmq-consumer</artifactId>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--rabbitmq java客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

（2）消费者类1

package net.xiaof.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author zhangxh
 * @Description: 消费者1
 * @date 2020-12-14
 */
public class Consumer_PubSub1 {

    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂，设置相关连接参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.116.161");
        factory.setPort(5672);
        factory.setVirtualHost("/myhost");
        factory.setUsername("xiao");
        factory.setPassword("xiao");

        //2. 创建连接Connection
        Connection connection = factory.newConnection();

        //3. 创建Channel
        Channel channel = connection.createChannel();

        //4. 接收消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 回调方法，当收到消息后，会自动执行该方法
             * void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
             * 参数：
             * （1）String consumerTag：标识
             * （2）Envelope envelope：获取一些信息，交换机，路由key...
             * （3）AMQP.BasicProperties properties：配置信息
             * （4）byte[] body：数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
//                System.out.println("consumerTag：" + consumerTag);
//                System.out.println("Exchange：" + envelope.getExchange());
//                System.out.println("RoutingKey：" + envelope.getRoutingKey());
//                System.out.println("properties：" + properties);
                System.out.println("body：" + new String(body));
                System.out.println("Consumer_PubSub1.class：打印日志到控制台");
            }
        };
        /**
         * 【API说明】：
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         * 参数：
         * （1）String queue：队列名称
         * （2）boolean autoAck：是否自动确认
         * （3）Consumer callback：回调对象
         */
        String queueName1 = "pubsub_queue1";
        String queueName2 = "pubsub_queue2";
        channel.basicConsume(queueName1, true, consumer);//这里消费队列“pubsub_queue1”的消息

        //5.关闭资源（消费者需要监听生产者消息，这里不关闭）

    }

}

（3）消费者类2

package net.xiaof.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author zhangxh
 * @Description: 消费者2
 * @date 2020-12-14
 */
public class Consumer_PubSub2 {

    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂，设置相关连接参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.116.161");
        factory.setPort(5672);
        factory.setVirtualHost("/myhost");
        factory.setUsername("xiao");
        factory.setPassword("xiao");

        //2. 创建连接Connection
        Connection connection = factory.newConnection();

        //3. 创建Channel
        Channel channel = connection.createChannel();

        //4. 接收消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 回调方法，当收到消息后，会自动执行该方法
             * void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
             * 参数：
             * （1）String consumerTag：标识
             * （2）Envelope envelope：获取一些信息，交换机，路由key...
             * （3）AMQP.BasicProperties properties：配置信息
             * （4）byte[] body：数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
//                System.out.println("consumerTag：" + consumerTag);
//                System.out.println("Exchange：" + envelope.getExchange());
//                System.out.println("RoutingKey：" + envelope.getRoutingKey());
//                System.out.println("properties：" + properties);
                System.out.println("body：" + new String(body));
                System.out.println("Consumer_PubSub2.class：保存日志到mysql数据库中");
            }
        };
        /**
         * 【API说明】：
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         * 参数：
         * （1）String queue：队列名称
         * （2）boolean autoAck：是否自动确认
         * （3）Consumer callback：回调对象
         */
        String queueName1 = "pubsub_queue1";
        String queueName2 = "pubsub_queue2";
        channel.basicConsume(queueName2, true, consumer);//这里消费队列“pubsub_queue2”的消息

        //5.关闭资源（消费者需要监听生产者消息，这里不关闭）


    }

}

---

三、测试

注意： 这里第一次需要先启动生产者类，队列的声明(创建)，已经交给生产者，启动后，所声明队列会注册在RabbitMq的虚拟主机中，消费者只需要从指定的队列中消费消息即可。

如果第一次先启动消费者，会报异常：找不到要消费的队列。

（1）先启动生产者类，生产者声明(创建)队列

在RabbitMQ的web管理端，查看队列情况：

---

（2）再分别启动 “消费者1 ” 和 “消费者2 ” 进行消费消息

启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息，到达广播 的效果。

---

三、小结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式 与 工作队列模式的区别:

• 1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。
• 2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。
• 3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机 。

---