RabbitMQ的使用二_Java Client方式使用发布订阅模式

RabbitMQ的使用二_Java Client方式使用发布/订阅模式

1.发布订阅模式：使用了Fanout交换机。它是将它接收到的所有消息广播到它知道的所有队列。感觉上类似设计模式中的观察者模式

前面的简单模式和Work模式。生产者的每一条消息都是被多个消费者中的一个消费掉。现在的publish/subscribe发布订阅模式。生产者的一条消息，将被多个消费者接收。

RabbitMQ消息传递模型的核心思想是：生产者永远不会直接向队列发送任何消息。实际上，生产者常常根本不知道消息是否会被传递到任何队列。相反，生产者只能将消息发送到交换机。

交换机的职责：一方面，它接收来自生产者的消息，另一方面，它将消息推入队列。交换机必须明确地知道如何处理接收到的消息。

 P：表示生产者  X：表示交换机   交换机连着两个队列

交换机有direct、topic、 headers、fanout四种

发布订阅模式使用的是fanout交换机

channel.exchangeDeclare(交换机的名称, "fanout");

前面的例子中，使用“”来表示交换机。这是使用的默认的交换机。

channel.basicPublish("", WORK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, sendMsg.getBytes());

消息将使用routingKey指定的名称路由到队列

2.临时队列

 　临时队列：1.有一个随机的队列名称。

　　　　　　 2.一旦断开使用者的连接，队列应该被自动删除。

在Java客户端中，当我们不为queueDeclare()提供参数时，我们会创建一个非持久的、排他的、自动删除队列，并生成一个名称 

String queueName = channel.queueDeclare().getQueue();

交换机和队列需要绑定起来，可通过如下方式：

channel.queueBind(queueName, 交换机的名称, "");

交换机的图示：

代码实现如下：

  创建一个生产者。

  创建一个Fanout交换机

  创建2个临时队列，然后和Fanout交换机绑定起来，用户验证发布订阅模式。

  创建1个普通队列。给这个队列添加2个消费者。用来实现WORK模式

1.创建一个生产者

public class FanoutExchangeSender {
    //1.声明一个交换机
    private static final String FANOUT_EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.获取一个链接
        Connection rabbitMQConnections = RabbitMQConnectionFactory.getRabbitMQConnections();
        // 2.获取一个通道
        Channel channel = rabbitMQConnections.createChannel();
        // 3.声明一个Fanout交换机
        channel.exchangeDeclare(FANOUT_EXCHANGE_NAME, "fanout");
        // 发送数据到交换机中
        for (int i = 1; i <= 100; i++) {
            String msg = new Date() + "小河流水哗啦啦============>" + i;
            // 发送消息
            // 第一个参数表示交换机的名称 第二个参数表示routingKey 交换机是通过routingKey进行选择队列的。这里使用的交换机是fanout交换机，所以routingKey不管用。所以不配置。
            channel.basicPublish(FANOUT_EXCHANGE_NAME, "", null, msg.getBytes());
        }
        channel.close();
        rabbitMQConnections.close();
        System.out.println(new Date() + "消息发行成功");
    }
}

2.创建消费者1号

public class FanoutExchangeReceiver {

    private static final String FANOUT_EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection rabbitMQConnections = RabbitMQConnectionFactory.getRabbitMQConnections();
        Channel channel = rabbitMQConnections.createChannel();
        // 声明一个交换机
        channel.exchangeDeclare(FANOUT_EXCHANGE_NAME,"fanout");
        // 声明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        System.out.println("临时队列的名称"+queueName);
        // 将队列和交换机绑定起来
        channel.queueBind(queueName,FANOUT_EXCHANGE_NAME,"");
        System.out.println("==========队列绑定了交换机====================");
        // 消费回调
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery delivery) throws IOException {
                String receiverMessage = new String(delivery.getBody(),"UTF-8");
                System.out.println(new Date()+"1号队列接收到的消息=======>"+receiverMessage);
                // 手动提供一个应答
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,deliverCallback,consumerTag -> {});
    }
}

3.创建消费者2号

public class FanoutExchangeReceiver2 {

    private static final String FANOUT_EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection rabbitMQConnections = RabbitMQConnectionFactory.getRabbitMQConnections();
        Channel channel = rabbitMQConnections.createChannel();
        // 声明一个交换机
        channel.exchangeDeclare(FANOUT_EXCHANGE_NAME,"fanout");
        // 声明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        System.out.println("临时队列的名称"+queueName);
        // 将队列和交换机绑定起来
        channel.queueBind(queueName,FANOUT_EXCHANGE_NAME,"");
        System.out.println("==========队列绑定了交换机====================");
        // 消费回调
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery delivery) throws IOException {
                String receiverMessage = new String(delivery.getBody(),"UTF-8");
                System.out.println(new Date()+"2号队列接收到的消息=======>"+receiverMessage);
                // 手动提供一个应答
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,deliverCallback,consumerTag -> {});
    }
}

4.创建消费者3号

public class FanoutExchangeReceiver3 {

    private static final String FANOUT_EXCHANGE_NAME = "fanout_exchange";
    private static final String FANOUT_EXCHANGE_QUEUE_NAME = "fanout_exchange_queue_name";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection rabbitMQConnections = RabbitMQConnectionFactory.getRabbitMQConnections();
        Channel channel = rabbitMQConnections.createChannel();
        System.out.println("队列名称"+FANOUT_EXCHANGE_QUEUE_NAME);
        // 声明一个交换机
        channel.exchangeDeclare(FANOUT_EXCHANGE_NAME,"fanout");
        // 声明一个队列
        channel.queueDeclare(FANOUT_EXCHANGE_QUEUE_NAME,false,false,false,null);
        // 将队列和交换机绑定起来
        channel.queueBind(FANOUT_EXCHANGE_QUEUE_NAME,FANOUT_EXCHANGE_NAME,"");
        System.out.println("==========队列绑定了交换机====================");
        // 消费回调
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery delivery) throws IOException {
                String receiverMessage = new String(delivery.getBody(),"UTF-8");
                System.out.println(new Date()+"3号队列接收到的消息=======>"+receiverMessage);
                // 手动提供一个应答
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
            }
        };
        channel.basicConsume(FANOUT_EXCHANGE_QUEUE_NAME,false,deliverCallback,consumerTag -> {});
    }
}

5.创建消费者4号

public class FanoutExchangeReceiver4 {

    private static final String FANOUT_EXCHANGE_NAME = "fanout_exchange";
    private static final String FANOUT_EXCHANGE_QUEUE_NAME = "fanout_exchange_queue_name";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection rabbitMQConnections = RabbitMQConnectionFactory.getRabbitMQConnections();
        Channel channel = rabbitMQConnections.createChannel();
        System.out.println("队列名称"+FANOUT_EXCHANGE_QUEUE_NAME);
        // 声明一个交换机
        channel.exchangeDeclare(FANOUT_EXCHANGE_NAME,"fanout");
        // 声明一个队列
        channel.queueDeclare(FANOUT_EXCHANGE_QUEUE_NAME,false,false,false,null);
        // 将队列和交换机绑定起来
        channel.queueBind(FANOUT_EXCHANGE_QUEUE_NAME,FANOUT_EXCHANGE_NAME,"");
        System.out.println("==========队列绑定了交换机====================");
        // 消费回调
        DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery delivery) throws IOException {
                String receiverMessage = new String(delivery.getBody(),"UTF-8");
                System.out.println(new Date()+"4号队列接收到的消息=======>"+receiverMessage);
                // 手动提供一个应答
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
            }
        };
        channel.basicConsume(FANOUT_EXCHANGE_QUEUE_NAME,false,deliverCallback,consumerTag -> {});
    }
}

生产者发送消息到交换机，消费者受到消息如下：

　　　　　　　　　　　　　　　　　　　　　　　　图一：消费者1号

　　　　　　　　　　　　　　　　　　　　　　　　　　图二：消费者2号

由上面图一和图二，可以看出，2个队列的名字，都是Rabbitmq创建的临时队列的名字。由于交换机是Fanout模式，故每一个消费者，收到的消息数和生产者发送的消息数一样。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　图三：消费者3号

　　　　　　　　　　　　　　　　　　　　　　　　　　图四 消费者4号

上面图三和图四，使用的是同一个队列。但是有2个不同的消费者，这是WORK模式。

可以明显的看出。消息号为奇数的由3号消费者消费了。消息数为偶数的由4号消费者消费了。使用了轮询的方式