rabbitmq几种工作模式_RabbitMQ的六种工作模式总结

最新推荐文章于 2024-07-10 13:22:05 发布
最新推荐文章于 2024-07-10 13:22:05 发布
阅读量575 收藏 5
点赞数 1
文章标签： rabbitmq几种工作模式 rabbitmq工作模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39746229/article/details/111295724
版权

精品推荐

  • 国内稀缺优秀Java全栈课程-Vue+SpringBoot通讯录系统全新发布!

作者：侧身左睡

https://www.cnblogs.com/xyfer1018/p/11581511.html

最近学习RabbitMQ的使用方式，记录下来，方便以后使用，也方便和大家共享，相互交流。

RabbitMQ的六种工作模式：

1、Work queues2、Publish/subscribe3、Routing4、Topics5、Header 模式6、RPC

一、Work queues

多个消费端消费同一个队列中的消息，队列采用轮询的方式将消息是平均发送给消费者；

0078808d58267f79257cb40cbae8c606.png

 特点：

1、一条消息只会被一个消费端接收；

2、队列采用轮询的方式将消息是平均发送给消费者的；

3、消费者在处理完某条消息后，才会收到下一条消息

生产端：

1、声明队列

2、创建连接

3、创建通道

4、通道声明队列

5、制定消息

6、发送消息，使用默认交换机

消费端：

1、声明队列

2、创建连接

3、创建通道

4、通道声明队列

5、重写消息消费方法

6、执行消息方法

新建两个maven工程，生产消息的生产端，消费消息的消费端；

pom.xml文件中依赖坐标如下：

<dependencies>    <dependency>            <groupId>org.springframework.bootgroupId>            <artifactId>spring-boot-starter-loggingartifactId>            <version>2.1.0.RELEASEversion>        dependency>        <dependency>            <groupId>com.rabbitmqgroupId>            <artifactId>amqp-clientartifactId>            <version>5.7.0version>        dependency>dependencies>

 生产端的代码如下：

package com.xyfer;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;/*1、声明队列2、创建连接3、创建通道4、通道声明队列5、制定消息6、发送消息，使用默认交换机*/public class Producer02 {    //声明队列    private static final String QUEUE ="queue";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");//mq服务ip地址            connectionFactory.setPort(5672);//mq client连接端口            connectionFactory.setUsername("guest");//mq登录用户名            connectionFactory.setPassword("guest");//mq登录密码            connectionFactory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器            //创建与RabbitMQ服务的TCP连接            connection = connectionFactory.newConnection();            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务            channel = connection.createChannel();            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE,true,false,false,null);//通道绑定邮件队列            for(int i = 0;i<10;i++){                String message = new String("mq 发送消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                channel.basicPublish("",QUEUE,null,message.getBytes("utf-8"));                System.out.println("mq消息发送成功！");            }        } 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();            }        }    }}

消费端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;/*1、声明队列2、创建连接3、创建通道4、通道声明队列5、重写消息消费方法6、执行消息方法*/public class Consumer02 {    private static final String QUEUE ="queue";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE,true,false,false,null);//通道绑定邮件队列            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

生产端启动后，控制台打印信息如下：

a060b11f43e40169a2d64cca4643f17a.png

 RabbitMQ中的已有消息：

f723c0610186e4f61c0d5322b8e8dea0.png

 queue中的消息正是生产端发送的消息：

bfd84c6f1156138f59e66fc38f5dd5ea.png

 二、Publish/subscribe 模式

这种模式又称为发布订阅模式，相对于Work queues模式，该模式多了一个交换机，生产端先把消息发送到交换机，再由交换机把消息发送到绑定的队列中，每个绑定的队列都能收到由生产端发送的消息。

8897b4ce870a761d4d988b7c80f0adda.png

发布订阅模式：

1、每个消费者监听自己的队列；

2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

应用场景：用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法；

生产端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机

7、制定消息

8、发送消息

消费端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机

7、重写消息消费方法

8、执行消息方法

Publish/subscribe 模式绑定两个消费端，因此需要有两个消费端，一个邮件消费端，一个短信消费端；

生产端的代码如下：

package com.xyfer;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;public class Producer01 {    //声明两个队列和一个交换机    //Publish/subscribe发布订阅模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");//mq服务ip地址            connectionFactory.setPort(5672);//mq client连接端口            connectionFactory.setUsername("guest");//mq登录用户名            connectionFactory.setPassword("guest");//mq登录密码            connectionFactory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器            //创建与RabbitMQ服务的TCP连接            connection = connectionFactory.newConnection();            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Publish/subscribe发布订阅模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.FANOUT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Publish/subscribe发布订阅模式            channel.queueBind(QUEUE_EMAIL,EXCHANGE,"");            channel.queueBind(QUEUE_SMS,EXCHANGE,"");            for(int i = 0;i<10;i++){                String message = new String("mq 发送消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                //Publish/subscribe发布订阅模式                channel.basicPublish(EXCHANGE,"",null,message.getBytes());                System.out.println("mq消息发送成功！");            }        } 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();            }        }    }}

邮件消费端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer01 {    //Publish/subscribe发布订阅模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Publish/subscribe发布订阅模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.FANOUT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Publish/subscribe发布订阅模式            channel.queueBind(QUEUE_EMAIL,EXCHANGE,"");            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {            /**              * 消费者接收消息调用此方法              * @param consumerTag 消费者的标签，在channel.basicConsume()去指定              * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                (收到消息失败后是否需要重新发送)              * @param properties              * @param body              * @throws IOException              * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body              */            @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                //交换机                String exchange = envelope.getExchange();                //路由key                String routingKey = envelope.getRoutingKey();                envelope.getDeliveryTag();                String msg = new String(body,"utf-8");                System.out.println("mq收到的消息是："+msg );            }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_EMAIL,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

短信消费端的代码如下：

package xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer01 {    //Publish/subscribe发布订阅模式    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Publish/subscribe发布订阅模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.FANOUT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Publish/subscribe发布订阅模式            channel.queueBind(QUEUE_SMS,EXCHANGE,"");            DefaultConsumer consumer = new DefaultConsumer(channel) {            /**              * 消费者接收消息调用此方法              * @param consumerTag 消费者的标签，在channel.basicConsume()去指定              * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                (收到消息失败后是否需要重新发送)              * @param properties              * @param body              * @throws IOException              * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body              */            @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                //交换机                String exchange = envelope.getExchange();                //路由key                String routingKey = envelope.getRoutingKey();                envelope.getDeliveryTag();                String msg = new String(body,"utf-8");                System.out.println("mq收到的消息是："+msg );            }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_SMS,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

三、Routing 路由模式

Routing 模式又称路由模式，该种模式除了要绑定交换机外，发消息的时候还要制定routing key，即路由key，队列通过通道绑定交换机的时候，需要指定自己的routing key，这样，生产端发送消息的时候也会指定routing key，通过routing key就可以把相应的消息发送到绑定相应routing key的队列中去。

2a95fa90d0a4b33389f2cf101678e856.png

路由模式：

1、每个消费者监听自己的队列，并且设置routingkey；2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列；

应用场景：用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法；

生产端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机并指定该队列的routingkey

7、制定消息

8、发送消息并指定routingkey

消费端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机并指定routingkey

7、重写消息消费方法

8、执行消息方法

按照假设的应用场景，同样，Routing 路由模式也是一个生产端，两个消费端，所不同的是，声明交换机的类型不同，队列绑定交换机的时候需要指定Routing key，发送消息的时候也需要指定Routing key，这样根据Routing key就能把相应的消息发送到相应的队列中去。

生产端的代码如下：

package com.xyfer;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;public class Producer03 {    //声明两个队列和一个交换机    //Routing 路由模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");//mq服务ip地址            connectionFactory.setPort(5672);//mq client连接端口            connectionFactory.setUsername("guest");//mq登录用户名            connectionFactory.setPassword("guest");//mq登录密码            connectionFactory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器            //创建与RabbitMQ服务的TCP连接            connection = connectionFactory.newConnection();            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务            channel = connection.createChannel();            //通道绑定交换机            /**             * 参数明细             * 1、交换机名称             * 2、交换机类型，fanout、topic、direct、headers             */            //Routing 路由模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.DIRECT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Routing 路由模式            channel.queueBind(QUEUE_EMAIL,EXCHANGE,QUEUE_EMAIL);            channel.queueBind(QUEUE_SMS,EXCHANGE,QUEUE_SMS);            //给email队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送email消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                //Routing 路由模式                channel.basicPublish(EXCHANGE,QUEUE_EMAIL,null,message.getBytes());                System.out.println("mq消息发送成功！");            }            //给sms队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送sms消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                //Routing 路由模式                channel.basicPublish(EXCHANGE,QUEUE_SMS,null,message.getBytes());                System.out.println("mq消息发送成功！");            }        } 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();            }        }    }}

邮件消费端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer03 {    //Routing 路由模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Routing 路由模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.DIRECT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Routing 路由模式            channel.queueBind(QUEUE_EMAIL,EXCHANGE,QUEUE_EMAIL);            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_EMAIL,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

短信消费端的代码如下：

package xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer03 {    //Routing 路由模式    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Routing 路由模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.DIRECT);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            //Routing 路由模式            channel.queueBind(QUEUE_SMS,EXCHANGE,QUEUE_SMS);            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_SMS,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

四、Topics 模式

Topics 模式和Routing 路由模式最大的区别就是，Topics 模式发送消息和消费消息的时候是通过通配符去进行匹配的。

b4c8df2914b0a16b2d721c1e13906178.png

路由模式：

1、每个消费者监听自己的队列，并且设置带统配符的routingkey

2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列

应用场景：用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法；

生产端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机并指定该队列的routingkey(通配符)

7、制定消息

8、发送消息并指定routingkey(通配符)

消费端：

1、声明队列，声明交换机

2、创建连接

3、创建通道

4、通道声明交换机

5、通道声明队列

6、通过通道使队列绑定到交换机并指定routingkey(通配符)

7、重写消息消费方法

8、执行消息方法

按照假设的应用场景，Topics 模式也是一个生产端，两个消费端，生产端队列绑定交换机的时候，需要指定的routingkey是通配符，发送消息的时候绑定的routingkey也是通配符，消费端队列绑定交换机的时候routingkey也是通配符，这样就能根据通配符匹配到消息了。

生产端的代码如下：

package com.xyfer;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;public class Producer04 {    //声明两个队列和一个交换机    //Topics 模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");//mq服务ip地址            connectionFactory.setPort(5672);//mq client连接端口            connectionFactory.setUsername("guest");//mq登录用户名            connectionFactory.setPassword("guest");//mq登录密码            connectionFactory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器            //创建与RabbitMQ服务的TCP连接            connection = connectionFactory.newConnection();            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Topics 模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.TOPIC);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            channel.queueBind(QUEUE_EMAIL,EXCHANGE,"inform.#.email.#");            channel.queueBind(QUEUE_SMS,EXCHANGE,"inform.#.sms.#");            //给email队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送email消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                channel.basicPublish(EXCHANGE,"inform.email",null,message.getBytes());                System.out.println("mq email 消息发送成功！");            }            //给sms队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送sms消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                channel.basicPublish(EXCHANGE,"inform.sms",null,message.getBytes());                System.out.println("mq sms 消息发送成功！");            }            //给email和sms队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送email sms消息。。。");                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                channel.basicPublish(EXCHANGE,"inform.email.sms",null,message.getBytes());                System.out.println("mq email sms 消息发送成功！");            }        } 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();            }        }    }}

邮件消费端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer04 {    private static final String QUEUE_EMAIL ="queueEmail";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.TOPIC);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            channel.queueBind(QUEUE_EMAIL,EXCHANGE,"inform.#.email.#");            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_EMAIL,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

短信消费端的代码如下：

package xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.concurrent.TimeoutException;public class Consumer04 {    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.TOPIC);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             */            channel.queueBind(QUEUE_SMS,EXCHANGE,"inform.#.sms.#");            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_SMS,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

由于生产端同时发送了email的消息(10条)，sms的消息(10条)，email和sms同时收到的消息(10条)，所以每个消费端都应收到各自的10条消息，加上同时都能收到的10条消息，每个消费端应该收到20条消息；

生产端控制台打印：

1d56e749f7f5a0ddb3cc32851d1207f2.png

 邮件消费端控制台打印：

8b19245e27264680446405bf2662b43b.png

 短信消费端的控制台打印：

7b103e49ab5e5339ffa64e5ff5b6a0ea.png

 生产端执行后，RabbitMQ上的消息队列情况：

137c05c73bf52584c2f534c65d838ad5.png

 两个消费端执行完后，RabbitMQ上的消息队列情况：

123cb4fbb2612960e85ca81cc607e3d6.png

 五、Header 模式

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

案例：

根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种通知类型都接收的则两种通知都有效。

根据假设使用场景，需要一个生产端，两个消费端，不同的是，生产端声明交换机时，交换机的类型不同，是headers类型，生产端队列绑定交换机时，不使用routingkey，而是使用header中的 key/value(键值对)匹配队列，发送消息时也是使用header中的 key/value(键值对)匹配队列。

消费端同样是声明交换机时，交换机的类型不同，是headers类型，消费端队列绑定交换机时，不使用routingkey，而是使用header中的 key/value(键值对)匹配队列，消费消息时也是使用header中的 key/value(键值对)匹配队列。

生产端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.Hashtable;import java.util.Map;import java.util.concurrent.TimeoutException;public class Producer05 {    //声明两个队列和一个交换机    //Header 模式    private static final String QUEUE_EMAIL ="queueEmail";    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");//mq服务ip地址            connectionFactory.setPort(5672);//mq client连接端口            connectionFactory.setUsername("guest");//mq登录用户名            connectionFactory.setPassword("guest");//mq登录密码            connectionFactory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器            //创建与RabbitMQ服务的TCP连接            connection = connectionFactory.newConnection();            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            //Header 模式            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.HEADERS);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定短信队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             * 4、             * String queue, String exchange, String routingKey, Map arguments             */            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_EMAIL,EXCHANGE,"",headers_email);            channel.queueBind(QUEUE_SMS,EXCHANGE,"",headers_sms);            //给email队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送email消息。。。");                Map<String,Object> headers = new Hashtable<String,Object>();                headers.put("inform_type","email");//匹配email通知消费者绑定的header                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();                properties.headers(headers);                //Email通知                channel.basicPublish(EXCHANGE,"",properties.build(),message.getBytes());                System.out.println("mq email 消息发送成功！");            }            //给sms队列发消息            for(int i = 0;i<10;i++){                String message = new String("mq 发送sms消息。。。");                Map<String,Object> headers = new Hashtable<String,Object>();                headers.put("inform_type","sms");//匹配sms通知消费者绑定的header                /**                  * 消息发布方法                  * param1：Exchange的名称，如果没有指定，则使用Default Exchange                  * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列                  * param3:消息包含的属性                  * param4：消息体                  * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定                  * 默认的交换机，routingKey等于队列名称                 */                //String exchange, String routingKey, BasicProperties props, byte[] body                AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();                properties.headers(headers);                //sms通知                channel.basicPublish(EXCHANGE,"",properties.build(),message.getBytes());                System.out.println("mq sms 消息发送成功！");            }        } 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();            }        }    }}

邮件消费端的代码如下：

package com.xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.Hashtable;import java.util.Map;import java.util.concurrent.TimeoutException;public class Consumer05 {    private static final String QUEUE_EMAIL ="queueEmail";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**                          * 参数明细                          * 1、交换机名称                          * 2、交换机类型，fanout、topic、direct、headers                          */            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.HEADERS);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_EMAIL,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             * 4、             * String queue, String exchange, String routingKey, Map arguments             */            Map<String,Object> headers_email = new Hashtable<String,Object>();            headers_email.put("inform_email","email");            channel.queueBind(QUEUE_EMAIL,EXCHANGE,"",headers_email);            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_EMAIL,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

短信消费端的代码如下：

package xyfer;import com.rabbitmq.client.*;import java.io.IOException;import java.util.Hashtable;import java.util.Map;import java.util.concurrent.TimeoutException;public class Consumer05 {    private static final String QUEUE_SMS ="queueSms";    private static final String EXCHANGE = "messageChange";    public static void main(String[] args) {        Connection connection = null;        Channel channel = null;        try {            ConnectionFactory connectionFactory = new ConnectionFactory();            connectionFactory.setHost("127.0.0.1");            connectionFactory.setPort(5672);            connection = connectionFactory.newConnection();            channel = connection.createChannel();            //通道绑定交换机            /**              * 参数明细              * 1、交换机名称              * 2、交换机类型，fanout、topic、direct、headers              */            channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.HEADERS);            //通道绑定队列            /**             * 声明队列，如果Rabbit中没有此队列将自动创建             * param1:队列名称             * param2:是否持久化             * param3:队列是否独占此连接             * param4:队列不再使用时是否自动删除此队列             * param5:队列参数             * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments             *             */            channel.queueDeclare(QUEUE_SMS,true,false,false,null);//通道绑定邮件队列            //交换机和队列绑定            /**             * 参数明细             * 1、队列名称             * 2、交换机名称             * 3、路由key             * 4、             * String queue, String exchange, String routingKey, Map arguments             */            Map<String,Object> headers_email = new Hashtable<String,Object>();            headers_email.put("inform_email","sms");            channel.queueBind(QUEUE_SMS,EXCHANGE,"",headers_email);            //String consumerTag, Envelope envelope, BasicProperties properties, byte[] body            DefaultConsumer consumer = new DefaultConsumer(channel) {                /**                  * 消费者接收消息调用此方法                  * @param consumerTag 消费者的标签，在channel.basicConsume()去指定                  * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志                    (收到消息失败后是否需要重新发送)                  * @param properties                  * @param body                  * @throws IOException                 * String consumerTag, Envelope envelope, BasicProperties properties, byte[] body                 */                @Override                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                    //交换机                    String exchange = envelope.getExchange();                    //路由key                    String routingKey = envelope.getRoutingKey();                    envelope.getDeliveryTag();                    String msg = new String(body,"utf-8");                    System.out.println("mq收到的消息是："+msg );                }            };            System.out.println("消费者启动成功！");            channel.basicConsume(QUEUE_SMS,true,consumer);        } catch (IOException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

生产端启动后RabbitMQ上面的消息队列情况：

585981bd05987b99c56db3f5edc681e2.png

六、RPC 模式

a10a8e9829590ea3f383a5a161bd40d3.png

 RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：

1、客户端即是生产者也是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。

2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果。

3、服务端将RPC方法 的结果发送到RPC响应队列。

4、客户端(RPC调用方)监听RPC响应队列，接收到RPC调用结果。

至此，RabbitMQ的六种工作模式已经介绍完毕，手动代码实现，实际体验六种工作模式的不同。

长按关注锋哥微信公众号，非常感谢；

dfe365bcbf43b0c2d29e000a3e17b3ec.png

weixin_39746229
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ五种模式
07-01
没有1个积分的私聊我哈，我给你免费 消息队列中间件（简称消息中间件）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下提供**应用解耦**(降偶)、**弹性伸缩、冗余存储、流量削峰、异步通信、数据同步等等功能**，其作为分布式系统架构中的一个重要组件，有着举足轻重的地位。 **基本模型： 消息发布者 --> 消息中间件 ---> 消息消费者** 同步调用是 A调用B后阻塞等待，此时A的后续操作是不能进行。异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息内容执行。此时A不再需要等待B。 这个前提下，**就可以实现异步调用**，**冗余存储**（指可以在MQ中多存一些数据，等待B来消费，MQ可以看作是个缓冲区）、**流量削峰**（如果A的调用请求数量大于B的消费能力，则消息中间件可以通过冗余存储来缓冲，B可以按照以比较慢的速度来处理请求）等等功能。
RabbitMq工作模式
@王某人
11-10 2459
rabbitMq工作模式 Work queues工作队列模式 模式说明 Work Queues 与入门程序的 简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 订阅模式概述 订阅模式示例图： 前面2个案例中，只有3个角色： P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。 queue：消息队列，图中红色部分 而在订阅模型中，多了一个exchange角色，而且过程略有变化
RabbitMQ工作模式详解，以及Java实现
最新发布
qq_69331283的博客
07-10 976
RabbitMQ共有六种工作模式：简单模式（Simple）、工作队列模式（Work Queue）、发布订阅模式（Publish/Subscribe）、路由模式（Routing）、通配符模式（Topics）、远程调用模式（RPC，不常用，不做讲解说明）
RabbitMQ的几种工作模式
热门推荐
Lovnx
04-29 3万+
maven： <dependencies> <!-- RabbitMQ的客户端 --> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>3.4.1</vers
RabbitMQ 的六种工作模式，看这一篇就够了（附 Python 代码）
AlwaysBeta 的专栏
04-07 393
技术博客：https://github.com/yongxinz/tech-blog 同时，也欢迎关注我的微信公众号 AlwaysBeta，更多精彩内容等你来。 上一篇介绍了在 Mac 环境下，RabbitMQ 的安装，这篇来详细介绍一下 RabbitMQ 的六种工作模式。 其实，这篇文章中的大部分内容都可以从 RabbitMQ 官网得到，包括每种工作模式的说明，以及多种语言的代码实例。 但是，...
RabbitMQ的6种工作模式---简单模式
qq_32923295的博客
04-06 695
上次说了交换机的四种绑定模式，这篇说一下RabbitMQ的6种工作模式，代码基于spring boot + JDK1.8 1.简单模式 望文生义，也就是RabbitMQ中最简单的一种，只适合demo级别的。 生产者把消息放入队列，消费者获取消息。这个模式只有一个消费者，一个生产者，一个队列，只需要配置主机参数，其他参数使用默认即可通信 代码： pom文件：（注意：如果引入jar包，但是在代码里面不能引入的，1重启IDEA，2更换springboot版本，我用的是2.1.4.RELEASE）
基于RabbitMQ几种Exchange 模式详解
08-28
基于RabbitMQ几种Exchange模式详解 本文将详细介绍RabbitMQ中四种Exchange模式：fanout、direct、topic、header。在实际应用中，header模式使用较少，本文将对前三种模式进行比较。 一、Fanout Exchange Fanout ...
springboot+RabbitMQ三种模式demo
07-03
首先，让我们了解这三种模式的基本概念： 1. **Direct模式**： Direct模式是最简单的模式，类似于邮局的信件分发。消息发送者（Producer）定义一个路由键（Routing Key），接收者（Consumer）定义一组绑定键...
掌握RabbitMQ几种常用模式的思想。本文将基于RabbitMQ官网提供相关的代码案例。
01-21
本文将深入探讨RabbitMQ的几种核心工作模式，并通过官方提供的代码示例进行解析，帮助读者理解和掌握其精髓。 一、简单模式（Simple） 在简单模式中，生产者发送消息到一个特定的队列，消费者则从这个队列接收并...
rabbitMq三种模式入门测试
09-28
本文将深入探讨RabbitMQ的三种基本交换机模式：Direct、Topic和Fanout，这些都是在实际开发中常见的应用场景。 首先，我们从"Hello, World!"开始。在RabbitMQ中，发送和接收消息的基本流程包括创建连接、通道、...
errol：以OTP方式编排RabbitMQ消费者:open_mailbox_with_raised_flag:
02-04
标题中的"errol"是一个基于Elixir的库...同时，熟悉Elixir的OTP原则以及RabbitMQ的工作原理是构建高效、可靠的RabbitMQ消费者的基石。通过这种方式，我们可以构建出能够处理大量并发消息，同时保持健壮性和弹性的系统。
04. RabbitMQ的几种工作模式
程序员阿红的博客
03-20 1788
04. RabbitMQ的几种工作模式 🍎姓名:程序员阿红🍎 🍊喜欢:Java编程🍊 🍉重要的事情说三遍!!!🍉 🍓欢迎大家关注哦,互相学习🍓 🍋欢迎大家访问哦,互相学习🍋 🍑欢迎大家收藏哦,互相学习🍑 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🍟🍟🍟RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此我们只学习前5种 🍗🍗🍗在线手册：https://www.rabbitmq.com/getstarted.htm 5种消息模型，大体分为两类： 1和2属于点对点 3、4
RabbitMQ二、RabbitMQ的六种模式
学习笔记
06-01 1507
主要了解rabbitmq的六种模式
rabbitmq几种工作模式
xxy55895的博客
04-10 245
一.基于erlang语言： 是一种支持高并发的语言 RabbitMQ的六种工作模式： 1.1 simple简单模式 消息产生着§将消息放入队列 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端) 1....
RabbitMQ 几种模式
weixin_45336205的博客
01-08 271
普通模式 一个生产者,一个交换机,一个队列,一个消费者. 生产者 public class Send { private final static String QUEUE_NAME = "hello"; public static void main(String[] args) throws IOException, TimeoutException { /...
RabbitMQ 的五种工作模式
每日一记，每周一结。
07-13 1128
Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
RabbitMQ的几种模式(二)
Mensonge的博客
12-03 145
接着上篇 pubsub发布订阅模式 一个生产者通过交换机发布到队列中再分别传输给消费者。即生产者P发出的消息传输到交换机，交换机再分发给绑定在它身上的队列，再发送给消费者，C1和C2都会接收到。交换机类型为Fanout(广播型)。 建立一个Producer和多个Consumer 来模拟一个Producer发送天气信息 分别分发到消费端。 package com.orange.rabbitmq.pubsub; import com.orange.rabbitmq.utils.MQConstant; i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值