本文详细介绍了RabbitMQ的五种工作模式：简单模式、工作队列、发布/订阅、路由和通配符模式，并通过代码示例进行演示。在发布/订阅模式与工作队列模式的区别中，强调了发布/订阅模式的灵活性和实用性。
利用放假的时间，回顾一下消息队列RabbitMq，做个笔记和大家交流一下。写的不好请见谅！！！！！
1、RabbitMQ的介绍和安装
（参考：https://blog.youkuaiyun.com/qq_31634461/article/details/79377256）
2、创建一个Maven工程
在这里就不介绍了，网上有很多的资料。创建好工程后创建两个包producer（放生产者代码），consumer（放消费者代码）；并且在pom.xml中添加rabbitmq依赖
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.6.0</version>
</dependency>3、RabbitMQ各种模式详解
1、简单模式
功能：一个生产者P发送消息到队列Q,一个消费者C接收
代码：
生产者代码：在producer包下创建生产者类Producer01：
package com.lhm.rabbitmq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* rabbitmq入门程序----生产者
*/
public class Producer01 {
//声明一个队列
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException,TimeoutException{
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置Host
connectionFactory.setHost("127.0.0.1");
//设置端口
connectionFactory.setPort(5672);
//设置用户名
connectionFactory.setUsername("guest");
//设置密码
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，每个虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//创建连接
Connection connection = null;
//创建通道
Channel channel = null;
try {
//利用连接工厂创建一个连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数详情：
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE,true,false,false,null);
//发送消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数详情：
* 1、 exchange 交换机，如果不指定将使用mq默认的交换机(设置为"")
* 2、 routingKey 路由key，交换机根据路由key来将消息转发到指定队列，如果使用默认交换机就设置为队列的名称
* 3、 props 消息的属性
* 4、 body 消息内容
*/
//设置消息的内容
String message = "Hello world!";
channel.basicPublish("",QUEUE,null,message.getBytes());
System.out.println("send to mq："+message);
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭，要先关闭通道再关闭连接
channel.close();
connection.close();
}
}
}
消费者代码：在consumer包下创建消费者类Consumer01：
package com.lhm.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* rabbitmq入门程序----消费者
*/
public class Consumer01 {
//声明一个队列
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置Host
connectionFactory.setHost("127.0.0.1");
//设置端口
connectionFactory.setPort(5672);
//设置用户名
connectionFactory.setUsername("guest");
//设置密码
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，每个虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建通道
Channel channel = connection.createChannel();
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE,true,false,false,null);
//实现消费方法
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE,true,defaultConsumer);
}
}
测试：
启动Producer01，输入http://localhost:15672进入rabbitmq管理界面发现成功创建队列helloworld,并且有一条消息未被消费
启动Consumer01，控制就会打印消息内容，不要关闭Consumer01，每运行一次Producer01，消费者就会消费一次，观察Consumer01控制台。
2、工作队列模式Work Queue
功能：work queues与简单模式相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。
应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
测试：
1、使用简单模式的程序，启动多个消费者（Consumer01）。
2、生产者发送多个消息（多运行几次Producer01）。
结果（观察各个Consumer01的控制台）：
1、一条消息只会被一个消费者接收；
2、rabbit采用轮询的方式将消息是平均发送给消费者的；
3、消费者在处理完某条消息后，才会收到下一条消息。
3、发布/订阅模式Publish/Subscribe
功能：每个消费者监听自己的队列。生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。
案例：用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法 。
代码：
生产者代码：在producer包下创建Producer02_publish生产者类：
package com.xuecheng.test.rabbitmq;
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 Producer02_publish {
//声明email队列名称
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){
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//简历新连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
//发送消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数明细
* 1、 exchange 交换机，如果不指定将使用mq默认的交换机(设置为"")
* 2、 routingKey 路由key，交换机根据路由key来将消息转发到指定队列，如果使用默认交换机就设置为队列的名称
* 3、 props 消息的属性
* 4、 body 消息内容
*/
for (int i =0;i<5;i++){
//消息内容
String message = "send inform message to user";
channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
System.out.println("send to mq："+message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//先关闭通道
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
}
消费者代码：在consumer包下创建消费者Consumer02_subscribe_email和Consumer02_subscribe_sms
Consumer02_subscribe_email:
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer02_subscribe_email {
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";
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");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
//实现消费方法
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
Consumer02_subscribe_sms:
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer02_subscribe_sms {
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) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
//实现消费方法
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
测试：
打开rabbitmq管理界面，观察交换机绑定情况：
使用生产者发送若干条消息，每条消息都转发到各各队列，每个消费者都接收到了消息。启动消费者Consumer02_subscribe_email和Consumer02_subscribe_sms，然后启动生产者Producer02_publish,观察各个消费的的控制台得到测试结果。
publish/subscribe与work queues区别。
区别：
1）work queues不用定义交换机，而publish/subscribe需要定义交换机。
2）publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认交换机)。
3）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机 。
相同点：
所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。（启动两个Consumer02_subscribe_email或者Consumer02_subscribe_sms，然后启动生产者Producer02_publish观察结果）
2、实质工作用什么 publish/subscribe还是work queues。
建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换
机。
4、路由模式Routing
功能：
1、每个消费者监听自己的队列，并且设置routingkey。
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。
代码：
生产者代码：在producer包下创建生产者类Producer03_routing:
package com.xuecheng.test.rabbitmq;
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_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";
private static final String ROUTINGKEY_EMAIL="inform_email";
private static final String ROUTINGKEY_SMS="inform_sms";
public static void main(String[] args){
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//简历新连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
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来将消息转发到指定队列，如果使用默认交换机就设置为队列的名称
* 3、 props 消息的属性
* 4、 body 消息内容
*/
for (int i =0;i<5;i++){
//消息内容
String message = "send email inform message to user";
channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL,null,message.getBytes());
System.out.println("send to mq："+message);
}
for (int i =0;i<5;i++){
//消息内容
String message = "send sms inform message to user";
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();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
}
消费者代码：在consumer包下创建消费者类Consumer03_routing_email和Consumer03_routing_sms:
Consumer03_routing_email：
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer03_routing_email {
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
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");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
Consumer03_routing_sms：
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer03_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");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
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_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
//实现消费方法
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
测试：
打开rabbitmq管理界面，观察交换机绑定情况：
使用生产者发送若干条消息，交换机根据routingkey转发消息到指定的队列。启动消费者Consumer03_routing_email和Consumer03_routing_sms，然后启动生产者Producer03_routing，观察消费者控制台。
Routing模式和Publish/subscibe的区别
Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。
5、通配符模式/Topics
功能：
1、每个消费者监听自己的队列，并且设置带统配符的routingkey。
2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。
代码：
案例：根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种
通知类型都接收的则两种通知都有效。
生产者代码：在producer包下创建Producer04_topics：
package com.xuecheng.test.rabbitmq;
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_INFORM_EMAIL = "queue_inform_email";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
private static final String ROUTINGKEY_EMAIL="inform.#.email.#";
private static final String ROUTINGKEY_SMS="inform.#.sms.#";
public static void main(String[] args){
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//简历新连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM,BuiltinExchangeType.TOPIC);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
//发送消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数明细
* 1、 exchange 交换机，如果不指定将使用mq默认的交换机(设置为"")
* 2、 routingKey 路由key，交换机根据路由key来将消息转发到指定队列，如果使用默认交换机就设置为队列的名称
* 3、 props 消息的属性
* 4、 body 消息内容
*/
for (int i =0;i<5;i++){
//消息内容
String message = "send email inform message to user";
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());
System.out.println("send to mq："+message);
}
for (int i =0;i<5;i++){
//消息内容
String message = "send sms inform message to user";
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());
System.out.println("send to mq："+message);
}
for (int i =0;i<5;i++){
//消息内容
String message = "send sms and email inform message to user";
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms.email",null,message.getBytes());
System.out.println("send to mq："+message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//先关闭通道
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
}
消费者代码：在consumer包下创建Consumer04_topics_email和Consumer04_topics_sms：
Consumer04_topics_email：
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer04_topics_email {
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
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");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM,BuiltinExchangeType.TOPIC);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
Consumer04_topics_sms：
package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer04_topics_sms {
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_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");
//设置虚拟机,一个mq的服务可以设置多个虚拟机，没虚拟机相当于一个独立的mq
connectionFactory.setVirtualHost("/");
//简历新连接
Connection connection = connectionFactory.newConnection();
//创建会话通道,生产者和消费者所有的通信都在channel通道中完成
Channel channel = connection.createChannel();
//监听队列
//声明队列,如果队列在mq中没有就创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、 queue 队列名称
* 2、 durable 是否持久化，如果持久化，mq重启后队列还在
* 3、 exclusive 是否独占连接，队列只允许在该连接中访问，如果连接关闭队列自动删除，如果将此参数设置true可用于临时队列的创建
* 4、 autoDelete 自动删除，队列不再使用时是否自动删除，如果将此参数和exclusive参数设置为true就可以实现临时队列（不用了就自动删除）
* 5、 arguments 参数，可以设置一个队列的扩展参数，比如，可设置存活时间
*/
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数：String exchange String type
/**
* 参数明细
* 1、exchange 交换机名称
* 2、type 交换机类型
* fanout:对应的rabbitmq的工作模式是publish/subscribe
* dircet:对应的是路由Routing模式
* topic:对应的是Topices工作模式
* headers:对应的是header工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM,BuiltinExchangeType.TOPIC);
//进行交换机队列绑定
//参数：String queue,String exchange,String routingKey
/**
* 参数明细
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中设置为空字符串
*/
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
//实现消费方法
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在channl中用来标识消息的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 自动回复
* 3、callback 消费方法，当消费者接受到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
测试：
打开rabbitmq管理界面，观察交换机绑定情况：
使用生产者发送若干条消息，交换机根据routingkey统配符匹配并转发消息到指定的队列。启动消费者Consumer04_topics_email和Consumer04_topics_sms，然后启动生产者Producer04_topics，观察消费者控制台。
注：RabbitMq消息队列常用模式介绍到这里，建议从以简单模式开始测试，测试时仔细观察控制台，方便理解各个模式之间的区别，通过字面的意思不太好理解各个模式之间的差别。动动手映象会更加深刻哦！！！！
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
