RabbitMQ - 工作模式

RabbitMQ - 工作模式

---

---

1. RabbitMQ 工作模式

1.1 Work queues 工作队列模式

1.1.1 模式说明

Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景 ：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

1.1.2 代码

Work Queues与入门程序的简单模式的代码是几乎一样的；可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。

1. 生产者

/**
 * 生产者
 *
 * @author murphy
 */
public class Producer {

    public static String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        for (int i = 1; i <= 30; i++) {
            // 发送消息
            String message = "Hello! RabbitMQ - Work Queue - " + i;
            /**
             * 参数1: 交换机名称，如果没有指定则使用默认Default Exchange
             * 参数2: 路由key，简单模式可以传递队列名称
             * 参数3: 消息其它属性
             * 参数4: 消息内容
             */
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("Send Successful —— " + message);
        }
        // 释放资源
        channel.close();
        connection.close();
    }
}

2. 消费者 1

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerOne {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者1 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.QUEUE_NAME, true, consumer);
    }
}

2. 消费者 2

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerTwo {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者2 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.QUEUE_NAME, true, consumer);
    }
}

1.1.3 测试

• 启动两个消费者，然后再启动生产者发送消息；到IDEA的两个消费者对应的控制台查看是否竞争性的接收到消息。

1.1.4 小结

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

1.2 订阅模式概述

订阅模式示例图：

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

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

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

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

1.3 Publish/Subscribe 发布与订阅模式

1.3.1 模式说明

发布订阅模式：

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

1.3.2 代码

1. 生产者

/**
 * 生产者
 *
 * @author murphy
 */
public class Producer {

    /**
     * 1 交换机 + 2 消息队列
     */
    public static String FANOUT_EXCHANGE = "fanout_exchange";
    public static String FANOUT_QUEUE_1 = "fanout_queue_1";
    public static String FANOUT_QUEUE_2 = "fanout_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        /**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型 - fanout/direct/topic/headers
         */
        channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);

        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
        channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHANGE,"");
        channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHANGE,"");

        for (int i = 1; i <= 10; i++) {

            String message = "Hello! RabbitMQ - Fanout - " + i;
            /**
             * 发送消息 - 发送给交换机(不用写消息队列)
             * 参数1: 交换机名称，如果没有指定则使用默认Default Exchange
             * 参数2: 路由key，简单模式可以传递队列名称
             * 参数3: 消息其它属性
             * 参数4: 消息内容
             */
            channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());
            System.out.println("Send Successful —— " + message);
        }
        // 释放资源
        channel.close();
        connection.close();
    }
}

2. 消费者 1

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerOne {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHANGE,"");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者1 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.FANOUT_QUEUE_1, true, consumer);
    }
}

3. 消费者 2

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerTwo {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.FANOUT_QUEUE_2, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.FANOUT_QUEUE_2, Producer.FANOUT_EXCHANGE,"");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者2 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.FANOUT_QUEUE_2, true, consumer);
    }
}

1.3.3 测试

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

执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击fanout_exchange的交换机，可以查看到如下的绑定：

1.3.4 小结

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

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

1. 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2. 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。

3. 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机。

1.4 Routing 路由模式

1.4.1 模式说明

路由模式特点：

• 队列与交换机的绑定，不能是任意绑定了，而是要指定一个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的消息

1.4.2 代码

编码与Publish/Subscribe发布与订阅模式的区别是交换机的类型为：Direct，且队列绑定交换机的时候需要指定routing key。

1. 生产者

/**
 * 生产者
 *
 * @author murphy
 */
public class Producer {

    /**
     * 1 交换机 + 2 消息队列
     */
    public static String DIRECT_EXCHANGE = "direct_exchange";
    public static String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    public static String DIRECT_QUEUE_UPDATE = "direct_queue_update";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        /**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型 - fanout/direct/topic/headers
         */
        channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);

        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHANGE, "insert");
        channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHANGE, "update");


        String message = "Insert - Routing：routingKey - INSERT";
        /**
         * 发送消息 - 发送给交换机(不用写消息队列)
         * 参数1: 交换机名称，如果没有指定则使用默认Default Exchange
         * 参数2: 路由key，简单模式可以传递队列名称
         * 参数3: 消息其它属性
         * 参数4: 消息内容
         */
        channel.basicPublish(DIRECT_EXCHANGE, "insert", null, message.getBytes());
        System.out.println("Send Successful —— " + message);

        message = "Update - Routing：routingKey - UPDATE";
        channel.basicPublish(DIRECT_EXCHANGE, "update", null, message.getBytes());
        System.out.println("Send Successful —— " + message);

        // 释放资源
        channel.close();
        connection.close();
    }
}

2. 消费者 1

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerOne {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE,"insert");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者1 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, consumer);
    }
}

3. 消费者 2

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerTwo {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHANGE,"update");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者2 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE, true, consumer);
    }
}

1.4.3 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达按照需要接收的效果。

执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击direct_exchange的交换机，可以查看到如下的绑定：

1.4.4 小结

Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。

1.5 Topic 通配符模式

1.5.1 模式说明

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

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

通配符规则：

• #：匹配一个或多个词
• *：匹配不多不少，恰好 1 个词

举例：

• item.#：能够匹配item.insert.abc或者item.insert
• item.*：只能匹配item.insert

图解：

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

1.5.2 代码

1. 生产者

使用topic类型的Exchange，发送消息的routing key有 3 种：item.insert、item.update、item.delete

/**
 * 生产者
 *
 * @author murphy
 */
public class Producer {

    /**
     * 1 交换机 + 2 消息队列
     */
    public static String TOPIC_EXCHANGE = "topic_exchange";
    public static String TOPIC_QUEUE_ALL = "topic_queue_all";
    public static String TOPIC_QUEUE_INSERT_UPDATE = "topic_queue_insert_update";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        /**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型 - fanout/direct/topic/headers
         */
        channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);

        String message = "Insert - Topic：routingKey - item.insert";
        /**
         * 发送消息 - 发送给交换机(不用写消息队列)
         * 参数1: 交换机名称，如果没有指定则使用默认Default Exchange
         * 参数2: 路由key，简单模式可以传递队列名称
         * 参数3: 消息其它属性
         * 参数4: 消息内容
         */
        channel.basicPublish(TOPIC_EXCHANGE, "item.insert", null, message.getBytes());
        System.out.println("Send Successful —— " + message);

        message = "Update - TOPIC：routingKey - item.update";
        channel.basicPublish(TOPIC_EXCHANGE, "item.update", null, message.getBytes());
        System.out.println("Send Successful —— " + message);

        message = "Delete - TOPIC：routingKey - item.delete";
        channel.basicPublish(TOPIC_EXCHANGE, "item.delete", null, message.getBytes());
        System.out.println("Send Successful —— " + message);

        // 释放资源
        channel.close();
        connection.close();
    }
}

2. 消费者 1

接收全部类型的消息：更新商品、删除商品、添加商品 - item.*

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerOne {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);

        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.TOPIC_QUEUE_ALL, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.TOPIC_QUEUE_ALL, Producer.TOPIC_EXCHANGE,"item.*");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者1 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.TOPIC_QUEUE_ALL, true, consumer);
    }
}

3. 消费者 2

接收两种类型的消息：新增商品、更新商品 - item.insert / item.update

/**
 * 消费者
 *
 * @author murphy
 */
public class ConsumerTwo {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
        // 声明(创建)队列
        /**
         * 参数1: 队列名称
         * 参数2: 是否定义持久化队列
         * 参数3: 是否独占本次连接，只能有一个Consumer监听这个队列
         * 参数4: 是否在不使用的时候自动删除队列，当没有Consumer的时候，自动删除
         * 参数5: 队列其它参数
         */
        channel.queueDeclare(Producer.TOPIC_QUEUE_INSERT_UPDATE, true, false, false, null);

        // 队列绑定交换机 - 所有的广播机制都可以接收到小心 - 不用输入routingKey
        channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.update");
        channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.insert");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 接收到消息执行的回调
             *
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routing key，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 路由 key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                // 交换机
                System.out.println("交换机为：" + envelope.getExchange());
                // 消息ID
                System.out.println("消息ID为：" + envelope.getDeliveryTag());
                // 收到的消息内容
                System.out.println("消费者2 - 接收到的消息为：" + new String(body, "UTF-8"));
            }
        };
        /**
         * 参数1: 队列名称
         * 参数2: 是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复后会删除消息，设置为false则需要手动确认
         * 参数3: 消息接收到后回调 - 接收到消息的做法
         */
        channel.basicConsume(Producer.TOPIC_QUEUE_INSERT_UPDATE, true, consumer);
    }
}

1.5.3 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达按照需要接收的效果；并且这些routing key可以使用通配符。

执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击topic_exchange的交换机，可以查看到如下的绑定：

1.5.4 小结

Topic主题模式可以实现Publish/Subscribe发布与订阅模式和Routing路由模式的功能；只是Topic在配置routing key的时候可以使用通配符，显得更加灵活。

1.6 模式总结

RabbitMQ工作模式：

1. 简单模式 - HelloWorld - 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

2. 工作队列模式 - Work Queue - 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）

3. 发布订阅模式 - Publish/Subscribe - 需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列

4. 路由模式 - Routing - 需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routingkey，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

5. 通配符模式 - Topic - 需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

---