【Spring消息】RabbitMq安装及简单应用（二）

前言：

埋头苦写。先把官方文档翻译过来。整个流程跑一遍。上一篇文章，【Spring消息】RabbitMq安装及简单应用（一），把点对点发送消息写完了。之前虽然也可以一个生产者多个消费者，但是一条消息只能被一个消费者处理，所以是点对点。这篇文章来讲讲发布订阅，一对多。一条消息同时被多个消费者（本文称为订阅者）处理。

正文：

一、发布/订阅模式：

引入了一个新概念：Exchange（即上图的X概念）。（其实此概念，在Amqp协议中是必要的一环，暂时可无需理解，后续会提到）可简单先理解为一个路由功能。RabbitMq定义了四种路由模式，direct, topic, headers and fanout.（本文会讲到除headers外其它三种）

1、fanout广播：

由上图可知生产者和队列之间没直接关联关系，甚至不需要知道有这么个东西，所以如果看过上一篇文章的小伙伴可以删掉队列名有关的代码。

1）生产者代码

package com.haibo.future.web.rabbitmq.demo6;

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

public class RabbitProduct {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 20; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = "第"+i+"条"+"Hello World!";
            //本次新增EXCHANGE
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            //发送的时候只需要制定Exchange，不需要制定第二个参数队列名称
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

2）消费者代码

package com.haibo.future.web.rabbitmq.demo6;

import com.rabbitmq.client.*;

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

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "logs";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式广播
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //消费者需要知道队列名称，因为已知是fanout广播模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）测试执行

执行两个消费者，再执行生产者。结果：生产者消息，同时发给了两个消费者。日志略。

2、direct直连：

直连：即binding Key全匹配。上图中Binding Key即black。

1）、生产者：（不与队列直接关联，绑定binding Key）

package com.haibo.future.web.rabbitmq.demo7;

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

public class RabbitProduct {
    private final static String EXCHANGE_NAME = "logs2";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 20; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = "第"+i+"条"+"Hello World!";;
            //本次新增EXCHANGE:direct直接匹配，全匹配模式
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            //发送的时候只需要制定Exchange，不需要制定第二个参数队列名称/此处是drect模式，第二个参数为binding key
            channel.basicPublish(EXCHANGE_NAME, "black", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

2）、消费者1（与队列直接关联，绑定binding Key "black"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

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

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来
        channel.queueBind(queueName, EXCHANGE_NAME, "black");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）、消费者2（与队列直接关联，绑定binding Key "red"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

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

public class RabbitConsumer2 {
    private static final String EXCHANGE_NAME = "logs2";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来,binding key 为black
        channel.queueBind(queueName, EXCHANGE_NAME, "red");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

4）、消费者3（与队列直接关联，绑定binding Key "black"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

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

public class RabbitConsumer3 {
    private static final String EXCHANGE_NAME = "logs2";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来,binding key 为black
        channel.queueBind(queueName, EXCHANGE_NAME, "black");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

5）、执行测试：

3个消费者启动，启动生产者。日志显示：消费者1、消费者3显示收到生产者的消息，消费者2不能收到生产者的消息。日志略。

3、Topic主题：

直接上代码：

1）、消费者1:（rootingKey是*.orange.rabbit）

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

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

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.rabbit");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

2）、消费者2:(rooting key 是 *.orange.bird)

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

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

public class RabbitConsumer2 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.bird");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）、消费者3:(rooting key是lazy.#)

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

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

public class RabbitConsumer3 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定义路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消费者需要知道队列名称，因为已知是direct模式，queueName直接从channel定义中获取
        String queueName = channel.queueDeclare().getQueue();
        //将队列和Exchange绑定起来
        channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

4）、生产者：

package com.haibo.future.web.rabbitmq.demo8;

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

public class RabbitProduct {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 10; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = null;
            //P-->X :本次新增EXCHANGE:direct直接匹配，全匹配模式
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            //X-->Q :发送的时候只需要制定Exchange，不需要制定第二个参数队列名称/此处是drect模式，第二个参数为binding key/此处是topic模式，第二个参数为rooting key
            if (i == 5) {
                message = "第" + i + "条:" + "lazy.orange.rabbit" + i;
                channel.basicPublish(EXCHANGE_NAME, "lazy.orange.rabbit" + i, null, message.getBytes("UTF-8"));
            } else {
                if (i % 2 == 1) {
                    message = "第" + i + "条:" + i + ".orange." + "rabbit";
                    channel.basicPublish(EXCHANGE_NAME, i + ".orange." + "rabbit", null, message.getBytes("UTF-8"));
                } else {
                    message = "第" + i + "条:" + i + ".orange." + "bird";
                    channel.basicPublish(EXCHANGE_NAME, i + ".orange." + "bird", null, message.getBytes("UTF-8"));
                }
            }
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

5）、执行测试：

消费者1，2，3分别执行，执行生产者。结果如下：

生产者：

[x] Sent '第0条:0.orange.bird'
 [x] Sent '第1条:1.orange.rabbit'
 [x] Sent '第2条:2.orange.bird'
 [x] Sent '第3条:3.orange.rabbit'
 [x] Sent '第4条:4.orange.bird'
 [x] Sent '第5条:lazy.orange.rabbit5'
 [x] Sent '第6条:6.orange.bird'
 [x] Sent '第7条:7.orange.rabbit'
 [x] Sent '第8条:8.orange.bird'
 [x] Sent '第9条:9.orange.rabbit'

消费者1:（rootingKey是*.orange.rabbit）

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第1条:1.orange.rabbit'
 [x] Received '第3条:3.orange.rabbit'
 [x] Received '第7条:7.orange.rabbit'
 [x] Received '第9条:9.orange.rabbit'

消费者2:(rooting key 是 *.orange.bird)

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第0条:0.orange.bird'
 [x] Received '第2条:2.orange.bird'
 [x] Received '第4条:4.orange.bird'
 [x] Received '第6条:6.orange.bird'
 [x] Received '第8条:8.orange.bird'

消费者3:(rooting key是lazy.#)

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第5条:lazy.orange.rabbit5'