RabbitMQ（二）——RabbitMQ的工作模式

在RabbitMQ（一）——入门中我们简单的介绍了一下RabbitMQ的入门知识，这节我们针对RabbitMQ的几种常见的工作模式展开来讲解一下。RabbitMQ有以下几种工作模式 ：

目录

一、简单模式

二、工作队列模式

三、发布/订阅模式

四、路由模式

五、主题模式

六、Header模式

七、RPC模式

---

一、简单模式

这种模式是RabbitMQ中最简单的一种工作模式，我们在RabbitMQ（一）——入门中“RabbitMQ入门测试”编写的案例就是这种模式。它只要有一个消费端、一个生产端和一个指定的队列。具体的代码演示可以返回去看上一节的内容，这里就不在赘述了。

二、工作队列模式

工作队列模式与简单模式相比，仅仅是多了一个（或多个）消费端，多个消费端共同消费同一个队列中的消息。对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度，因为对于多个任务，MQ可以把它们分别交给不同的消费端同时进行处理，这样就提高了任务处理的效率。

在这种模式下RabbitMQ会采用“轮询”的方式将消息队列中的消息平均地发送给每个消费者（假如有n个消费者，则第一条消息发给第一个消费者，第二条消息发给第二个消费者......第n条消息发给第n个消费者，第n+1条消息发给第1个消费者），并且一条消息只会被一个消费者接收，不会存在同一条消息被两个或以上的消费者都接受到的情况，当消费者在处理完某条消息后，才会收到下一条消息。

三、发布/订阅模式

此种模式下生产者将消息发给broker，broker中的由交换机将消息转发到绑定到此交换机上的每个队列中（假如交换机收到10条消息，它会把这10条消息分别发给每个队列，如下图两个队列中，每个都会收到相同的10条消息），而消费者这边去监听自己的队列。

那发布/订阅模式和上面的工作队列模式有什么异同吗？主要有以下几点

不同点：

• work queues不用定义交换机，而publish/subscribe需要定义交换机。
• publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认交换机)。
• publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机 。

相同点：

• 同工作队列工作模式一样，发布订阅模式也可以实现多个消费端共同监听同一个队列，并且不会重复消费消息的功能。从这一点可以看出发布订阅模其实比工作队列模式功能更强大，因为工作队列模式可以实现的功能，发布订阅模式也完全可以实现，并且发布订阅模式可以指定自己专用的交换机，而工作队列模式只能使用默认的交换机，所以在实际工作中发布订阅模式用的更多一些。

下面通过代码来具体的看一下这种模式（代码是在RabbitMQ（一）——入门中的“RabbitMQ入门测试”的工程基础上进行编写）。我们设想这样一种场景：用户通知，当用户充值成功或转账完成后，系统通过“短信”和“邮件”这两种方式通知用户交易完成，这样用户就可以在手机短信上和电子邮箱中同时收到交易完成的提醒了。

3.1生产者

声明Exchange_fandout_inform交换机，并且声明两个队列并且绑定到此交换机上。

public class Producer_Publish {
    //队列名称
    //专门用于接收邮箱通知的队列
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    //专门用于接收短信通知的队列
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机
    private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;

        try {
            //通过连接工厂创建新的连接和mq建立连接
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("127.0.0.1");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建与交换机的通道，每个通道代表一个会话
            channel = connection.createChannel();
            //声明交换机
            /**
             * 参数明细:String exchange, BuiltinExchangeType type
             * exchange:交换机名称，这个我们在上面已经定义好了
             * type:有四种类型fanout、topic、direct、headers，发布订阅工作模式下选择fanout
             */
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
            //声明队列
            /**
             * 参数明细:(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,Object> arguments)
             * String queue:队列名称
             * boolean durable:是否持久化
             * boolean exclusive:是否独占此队列
             * boolean autoDelete:队列不用是否自动删除
             * Map<String,Object> arguments:参数，可以设置一个队列的扩展参数，比如：可设置存活时间等
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //将交换机和队列绑定
            /**
             * 参数明细:String queue, String exchange, String routingKey
             * String queue:队列名称
             * String exchange:交换机名称
             * String routingKey:路由key，这个我们暂时用不到为空即可，在路由模式中会讲解
             */
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
            //发送消息
            for (int i = 0;i < 10;i++){
                String message = "inform to user"+i;
                //向交换机发送消息
                /**
                 * 参数明细:String exchange, String routingKey, BasicProperties props,byte[] body
                 * String exchange:交换机名称，不指定的话就会使用默认交换机Default Exchange
                 * tring routingKey:routingKey（路由key），根据key名称将消息转发到具体的队列，暂时用不到。
                 * 如果这个字段填写队列名，则称表示消息将发到此队列
                 * BasicProperties props:消息属性
                 * byte[] body:消息内容
                 */
                channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
                System.out.println("Send Message is:'"+message+"'");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            //先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2消费者

1）邮件发送消费者

public class Consumer_Subscribe_Email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_FANOUT_INFORM="inform_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建一个与MQ的连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");

        //创建一个连接
        Connection connection = factory.newConnection();
        //创建与交换机的通道，每个通道代表一个会话
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
        //声明队列，只监听邮件的对列即可
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
        //定义消费方法，这里就是接收到MQ中对列发来的消息后需要做的事情，即把收到的信息发给用户的邮箱
        //我们这里就简单的把收到的消息打印出来即可
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                long deliveryTag = envelope.getDeliveryTag();
                String exchange = envelope.getExchange();
                //消息内容
                String message = new String(body, "utf‐8");
                System.out.println(message);
            }
        };

        //监听队列
        /**
         * 参数明细:String queue, boolean autoAck,Consumer callback
         * String queue:队列名称
         * boolean autoAck:是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，
         * mq接收到回复会删除消息，设置为false则需要手动回复
         * Consumer callback:消费消息的方法，消费者接收到消息后调用此方法
         */
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    }
}

2）短信发送消费者

短信发送消费者的代码几乎同上边邮件发送消费者的代码一模一样，我们只需把需要绑定和监听的队列换为QUEUE_INFORM_EMAIL即可

public class Consumer_Subscribe_SMS {
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM="inform_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");
        
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                long deliveryTag = envelope.getDeliveryTag();
                String exchange = envelope.getExchange();
                String message = new String(body, "utf-8");
                System.out.println(message);
            }
        };
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}

3.3测试

运行Producer_Publish类后，打开RabbitMQ的管理后台可以发现一共有20条待发送的消息（每个对列中10条），并多了两个队列。之后我们分别运行Consumer_Subscribe_Email和Consumer_Subscribe_SMS，MQ就会把消息发给这二者。

四、路由模式

路由模式相较于发布订阅模式的不同点在于，路由模式要求队列在绑定交换机的时候要指定routingkey，这个routingkey的主要作用就是让交换机根据不同的routingkey把消息发送到不同的队列中。不像发布订阅模式那样，如果交换机收到了10条消息，它会把这10条消息不加筛选的一股脑全部发给每个队列。而对于路由模式，生产者将消息发给交换机，由交换机会根据routingkey来转发消息到指定的队列，同时每个消费者也会监听自己的队列，并且设置相应的routingkey进而只接收指定队列发来的消息。

下面我们依旧通过代码来演示一下：

4.1生产者

声明exchange_routing_inform交换机；声明两个队列并且绑定到此交换机，绑定时需要指定routingkey；发送消息时需要指定routingkey。

public class Producer_Routing {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机名称
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
    //routingKey
    private static final String ROUTINGKEY_EMAIL="inform_email";
    private static final String ROUTINGKEY_SMS="inform_sms";
    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            connection = connectionFactory.newConnection();
            channel = connection.createChannel();

            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            /**
             * 参数明细：String exchange, String type
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing	工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
            //进行交换机和队列绑定
            /**
             * 参数明细：String queue, String exchange, String routingKey
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
            //发送消息
            /**
             * 参数明细：String exchange, String routingKey, BasicProperties props, byte[] body
             * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
             * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
             * 3、props，消息的属性
             * 4、body，消息内容
             */
            for(int i=0;i<10;i++){
                //发送消息的时候指定routingKey
                if(i < 5){
                    String message = "send inform message to email";
                    channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL,null,message.getBytes());
                    System.out.println("send to mq "+message);
                }else {
                    String message = "send inform message to sms";
                    channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS,null,message.getBytes());
                    System.out.println("send to mq "+message);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.2消费者

1）邮件发送消费者

public class Consumer_Routing_Email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    //交换机名称
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
    //routingkey
    private static final String ROUTINGKEY_EMAIL="inform_email";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        //建立新连接
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //进行交换机和队列绑定
        /**
         * 参数明细：String queue, String exchange, String routingKey
         * 1、queue 队列名称
         * 2、exchange 交换机名称
         * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
         */
        channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("receive message:"+message);
            }
        };
        //监听队列
        /**
         * 参数明细：String queue, boolean autoAck, Consumer callback
         * 1、queue 队列名称
         * 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
         * 3、callback，消费方法，当消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    }
}

2）短信发送消费者

public class Consumer_Routing_SMS {
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
    private static final String ROUTINGKEY_SMS="inform_sms";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);

        channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("receive message:"+message);
            }
        };
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}

五、主题模式

主题工作模式其实和路由模式很相似，在交换机和队列进行绑定的时候也需要指定routingkey，只不过主题模式中的routingkey可以带有通配符，而路由模式的routingkey必须精确指定。另外一点不同的地方就是交换机的type类型，路由模式的交换机type类型为direct，而主题模式的交换机type类型为topic。但Topic模式功能更多加强大，它可以实现Routing、publish/subscirbe模式的功能。

下面我们将上面路由模式中的应用场景稍作需改，根据用户的通知设置去通知用户交易信息：设置Email通知的用户只通过Email接收交易信息，设置SMS通知的用户只通过SMS接收交易信息，设置两种通知类型都接收的则两种通知都有效。

因为这部分的代码与上面路由模式的代码很相识，这里就不给出完整代码，只贴出部分代码：

5.1生产者

/**
 * 声明交换机
 * param1：交换机名称
 * param2:交换机类型 四种交换机类型：direct、fanout、topic、headers
 */
 channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//Email通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.email", null, message.getBytes());
//sms通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms", null, message.getBytes());
//两种都通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms.email", null, message.getBytes());

5.2消费者

队列绑定交换机指定通配符：
统配符规则：中间以“.”分隔；符号#可以匹配多个词，符号*可以匹配一个词语。

//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
//声明交换机
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//绑定email通知队列
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,"inform.#.email.#");
//绑定sms通知队列
 channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,"inform.#.sms.#");

5.3总结

其实本案例的需求使用Routing工作模式也可以实现，但是一共需要设置三个 routingkey，分别是email、sms、all。email队列绑定email和
all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂一些。

六、Header模式

header模式与routing不同的地方在于，header模式取消了routingkey，使用header中的 key/value（键值对）匹配
队列。

我们还是以上面的案例为基础，根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms。

下面给出部分代码片段：

6.1生产者

队列与交换机绑定的代码与之前不同，如下：

Map<String, Object> headers_email = new Hashtable<String, Object>();
headers_email.put("inform_type", "email");
Map<String, Object> headers_sms = new Hashtable<String, Object>();
headers_sms.put("inform_type", "sms");
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_HEADERS_INFORM,"",headers_sms);

通知部分的代码（只给出邮件部分，短信部分类似）：

String message = "email inform to user"+i;
Map<String,Object> headers =  new Hashtable<String, Object>();
headers.put("inform_type", "email");//匹配email通知消费者绑定的header
//headers.put("inform_type", "sms");//匹配sms通知消费者绑定的header
AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();
properties.headers(headers);
//Email通知
channel.basicPublish(EXCHANGE_HEADERS_INFORM, "", properties.build(), message.getBytes());

6.2.消费者（只给出邮件部分，短信部分类似）：

channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS);
Map<String, Object> headers_email = new Hashtable<String, Object>();
headers_email.put("inform_email", "email");
//交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
//指定消费队列
channel.basicConsume(QUEUE_INFORM_EMAIL, true, consumer);

七、RPC模式

这一种模式代码实现起来比较多，就不给大家展示代码了

RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：
1、客户端即是生产者也是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
3、服务端将RPC方法 的结果发送到RPC响应队列
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

 

关于RabbitMQ的工作模式就介绍这么多吧，谢谢大家的耐心阅读。