【RabbitMQ】三、RabbitMQ工作模式
一、前言：
上篇文章讲述了MQ跟RabbitMQ的基本概念及相关内容，那么这篇内容就是真正的硬核知识：rabbit的工作模式及代码实现，废话不多说，开始干。。。。。。。。。。
二、准备内容：
1.作者使用的springboot项目，所以在开始前需要在pom.xml文件引入RabbitMQ的依赖，如下：
org.springframework.boot
spring-boot-starter-amqp
2.因为每次请求都需要获取连接，所以就可以把这部分代码单独拿出来写一个工具类，使用的时候直接调用就行：
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* RabbitMQ连接工具类
*/
public class ConnectionUtil {
public static Connection getConnection() throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.102.130");
factory.setPort(5672);
factory.setUsername("user");
factory.setPassword("user");
//设置虚拟机,一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//通过工厂获取连接
Connection connection = factory.newConnection();
return connection;
}
}三、工作模式：
1.Work queues（工作队列）模式：
特点：
1.一个生产者，一个队列，多个消费者同时竞争消息；
2.一条消息只会被一个消费者接收；
3.rabbit采用轮询的方式将消息平均发送给消费者的；
4.消费者在处理完某条消息后，才会收到下一条消息；而且队列中的消息一旦被消费，就会消失，因为任务是不会被重复执行的。
应用场景：
对于任务过重或任务较多时使用工作队列可以提高任务处理的速度。
生产者代码：
public class ProducerWork{
//队列名称
private static final String QUEUE_WORK = "queue_work";
public static void main(String[] args){
Connection conn = null;
Channel channel = null;
try{
//获取连接
conn = ConnectionUtil.getConnection();
//获取通道
channel = conn.createChannel();
//声明队列
channel.queueDeclare(QUEUE_WORK ,true,false,false,null);
//发送消息
//参数：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<100;i++){
String message="queue work模式:"+i;
channel.basicPublish("",QUEUE_WORK,null,messgae.getByte());
}
}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();
}
}
}
}消息接收者1：
public class ConsumerWorkOne{
//
private static final String QUEUE_WORK="queue_work";
public static void main(String[] args){
//获取连接
Connection conn = ConnectionUtil.getConnection();
//获取通道
Channel channel = conn.createChannel();
//声明队列
channel.queueDeclare(QUEUE_WORK,true,false,false,null);
//监听队列、获取消息
channel.baiscConsume("",true,new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者1接收的值："+new String(body,"utf-8"));
}
});
}
}消息接收者2(每输出一句就sleep1s)：
public class ConsumerWorkTwo{
//
private static final String QUEUE_WORK="queue_work";
public static void main(String[] args){
//获取连接
Connection conn = ConnectionUtil.getConnection();
//获取通道
Channel channel = conn.createChannel();
//声明队列
channel.queueDeclare(QUEUE_WORK,true,false,false,null);
//监听队列、获取消息
channel.baiscConsume("",true,new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者2接收的值："+new String(body,"utf-8"));
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
});
}
}输出结果：
图解：
队列均匀把消息分配给2个消费者，消费者1接收非常快；消费者2因为加了睡眠导致接收很慢，分配给消费者2的其他消息一直在等消费者2来接收，这样的话就出现了这种情况：消费者1已经接收完了，但是消费者2还在接收，也就是能者不多劳的情况，解决这种情况需要一种机制：消息自动确认机制。
消息自动确认机制：
work queue 模式是均匀分配消息的，但是每个消费者的处理能力速度不一样；所以要想实现能者多劳，就需要手动回复确认消息。
实现代码：
public class ConsumerAuto{
//
private static final String QUEUE_WORK="queue_work";
public static void main(String[] args){
//获取连接
Connection conn = ConnectionUtil.getConnection();
//获取通道
Channel channel = conn.createChannel();
//
channel.basicQos(1);
//声明队列
channel.queueDeclare(QUEUE_WORK,true,false,false,null);
//监听队列、获取消息
channel.baiscConsume("",false,new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println(new String(body));
//手动确认
/**
* 参数明细：
* deliveryTag ： 消息id
* boolean : false:每次确认一个
*/
channel.basicAck(envelope.getDeliveyTag(),false);
}
});
}
}给队列的所有消息设置过期时间TTL：
声明队列时设置1个
x-message-ttl的属性，并设置过期时间，凡是推送到该队列中的所有消息，都会有一个设定时间之后过期的属性。
代码实现：
HashMap map = new HashMap();
map.put("x-messgae-ttl",30000); //队列中的消息未被消费则30s后过期
channel.queueDeclare("work queue",true,false,false,map); 2.Publish/subscribe (发布/订阅)模式：
特点：
1.每个消费者监听自己的队列；
2.生产者将消息发送给broker，由交换机将消息转发到绑定了此交换机的每个队列，每个绑定交换机的队列都将接收到消息。
3.队列的消费者都能拿到消息，实现一条消息被多个消费者消费。
生产者代码：
** ：Publish/subscribe 模式对应交换机类型为：fanout 。
public class Producer_publish{
//队列名称
private static final String QUEUE_ONE = "queue_one";
private static final String QUEUE_TWO = "queue_two";
//交换机名称
private static final String EXCHANGE_ONE = "exchange_one";
public static void main(String[] args){
Connection connection =null;
Channel channel = null;
try{
//获取连接
connection = ConnectionUtil.getConnection();
//获取管道，生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列，如果队列在mq中没有则要创建
/**
* 参数明细：
* 1、String queue : 队列名称
* 2、boolean durable ：是否持久化，如果持久化，mq重启后队列还在
* 3、boolean exclusive：是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除，如果将此参数设置为true可用于临时队列的创建。
* 4、boolean autoDelete：自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、Map arguments : 可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
channel.queueDeclare(QUEUE_TWO,true,false,false,null);
//声明一个交换机
/**
* 参数明细：
* 1、String exchange : 交换机的名称
* 2、String type ： 交换机的类型
* fanout: 对应的rabbitmq的工作模式是：publish/subscribe
* direct: 对应的Routing模式
* topic: 对应的Topics工作模式
* headers: 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_ONE,BuiltinExchangeType.FANOUT);
//进行交换机和队列绑定
/**
* 参数明细：
* 1、String queue ：队列名称
* 2、String exchange ：交换机名称
* 3、routingkey ：路由key，作用是交换机根据路由key的值将信息转发到指定的队列，在发布订阅模式中调协为空字符串。
*/
channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE ,"");
channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE ,"");
//发送消息
/**
* 参数明细：
* String exchange : 交换机名称，如果不指定将使用mq的默认交换机（设置为“”）
* String routingKey : 路由key，交换机根据路由key来将信息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
* BasicProperties props : 消息的属性
* byte[] body ： 消息的内容
*/
for(int i=0;i<5;i++){
//消息内容
String message = "Hello World! RabbitMq......"+i;
channel.basicPublish(EXCHANGE_ONE,"",null,message.getBytes());
System.out.println("producer send to MQ ："+message);
}
}catch(Exception e){
e.printStackTrace();
}finally{
//先关闭通道
//关闭连接
try{
channel.close();
}catch(){
e.printStackTrace();
}
try{
connection.close();
}catch(){
e.printStackTrace();
}
}
}
} 消息接收者1：
public class ConsumerOne{
//队列名称
private static final String QUEUE_ONE = "queue_one";
//交换机名称
private static final String EXCHANGE_ONE = "exchange_one";
public static void main(String[] args) throws Exception{
//创建连接
Connection connection = ConnectionUtil.getConnection();
//创建通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_ONE ,BuiltinExchangeType.FANOUT);
//进行交换机和队列的绑定
channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE ,"");
//实现消费方法
DefaultConsumer consumer = 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("消费者1接收到消息："+message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细
* 1、queue : 队列名称
* 2、autoAck : 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，设置为false时要通过编程实现回复
* 3、callback : 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_ONE,true,consumer);
}
}消息接收者2：
public class ConsumerTwo{
//队列
private static final String QUEUE_TWO = "queue_one";
//交换机
private static final String EXCHANGE_ONE = "exchange_one";
public static void main(String[] args) throws Exception{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_ONE ,BuiltinExchangeType.FANOUT);
//进行交换机跟队列的绑定
channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE ,"");
//实现消费方法
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("消费者2接收到消息："+message);
}
};
//监听队列
channel.basicConsume(QUEUE_TWO ,true,defaultConsumer );
}
}3. Routing （路由）模式：
图解：
P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息
特点：
1.每个消费者监听自己的队列，并且设置routingKey；
2.生产者将消息发送给交换机，由交换机根据routingkey来转发消息到指定的队列。
生产者代码：
** ：Routing 模式对应交换机类型为：Direct
public class ProducerRouting{
//队列名称
private static final String QUEUE_ONE = "queue_one";
private static final String QUEUE_TWO = "queue_two";
// 交换机名称
private static final String EXCHANGE_ONE="exchange_one";
// 路由键名称
private static final String ROUTINGKEY_ONE="routingkey_one";
private static final String ROUTINGKEY_TWO="routingkey_two";
public static void main(String[] args) {
Connection connection = null;
Channel channel = null;
try{
//通过连接工厂创建新的连接和mq建立连接
connection = ConnoectionUtil.getConnection();
//创建会话通道,
channel = connection.createChannel();
//声明队列，如果队列在mq 中没有则要创建
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_ONE, BuiltinExchangeType.DIRECT);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
*/
channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE,ROUTINGKEY_ONE);
channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE,ROUTINGKEY_TWO);
//发送消息
//参数：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<5;i++){
//发送消息的时候指定routingKey
String message = "生产者发送消息ONE"+i;
channel.basicPublish(EXCHANGE_ONE,ROUTINGKEY_ONE,null,message.getBytes());
System.out.println("send to mq "+message);
}
for(int i=0;i<5;i++){
//发送消息的时候指定routingKey
String message = "生产者发送消息TWO"+i;
channel.basicPublish(EXCHANGE_ONE,ROUTINGKEY_TWO,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();
}
}
}
}消息接收者1：
public class ConsumerKeyOne{
//队列名称
private static final String QUEUE_ONE = "queue_one";
// 交换机名称
private static final String EXCHANGE_ONE="exchange_one";
// 路由键名称
private static final String ROUTINGKEY_ONE="routingkey_one";
public static void main(String[] args) throws IOException, TimeoutException {
//建立新连接
Connection connection = ConnectionUtil.getConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_ONE,BuiltinExchangeType.DIRECT);
//进行交换机跟队列的绑定
channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE,ROUTINGKEY_ONE);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(){
/**
* 当接收到消息后此方法将被调用
* @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("消费者1接收到的消息："+message);
}
};
//监听队列
channel.basicConsume(QUEUE_ONE ,true,defaultConsumer);
}
}消息接收者2：
public class ConsumerKeyTwo{
//队列名称
private static final String QUEUE_TWO = "queue_two";
// 交换机名称
private static final String EXCHANGE_ONE="exchange_one";
// 路由键名称
private static final String ROUTINGKEY_TWO="routingkey_two";
public static void main(String[] args) throws IOException, TimeoutException {
//建立新连接
Connection connection = ConnectionUtil.getConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TWO,BuiltinExchangeType.DIRECT);
//进行交换机跟队列的绑定
channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE,ROUTINGKEY_TWO);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(){
/**
* 当接收到消息后此方法将被调用
* @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("消费者2接收到的消息："+message);
}
};
//监听队列
channel.basicConsume(QUEUE_TWO ,true,defaultConsumer);
}
}4.Topics （通配）模式：
特点：
1.每个消费者监听自己的队列，并且设置带通配符的routingkey（ routingkey一般都是由一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert）；
2.生产者将消息发送给broker，由交换机根据routingkey来转发消息到指定的队列。
生产者代码：
public class Producer04_topics {
// 队列名称
private static final String QUEUE_ONE = "queue_one";
private static final String QUEUE_TWO = "queue_two";
// 声明交换机
private static final String EXCHANGE_TOPICS="exchange_topics";
// 使用通配符的方式来,设置路由键
private static final String ROUTINGKEY_ONE="inform.#.one.#";
private static final String ROUTINGKEY_TWO="inform.#.two.#";
public static void main(String[] args) {
Connection connection = null;
Channel channel = null;
try {
//建立新连接
connection = ConnectionUtil.getConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列，如果队列在mq 中没有则要创建
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TOPICS, BuiltinExchangeType.TOPIC);
//进行交换机和队列绑定
channel.queueBind(QUEUE_ONE ,EXCHANGE_TOPICS,ROUTINGKEY_ONE);
channel.queueBind(QUEUE_TWO ,EXCHANGE_TOPICS,ROUTINGKEY_TWO);
for(int i=0;i<5;i++){
//发送消息的时候指定routingKey
String message = "send one inform message to user";
channel.basicPublish(EXCHANGE_TOPICS,"inform.one",null,message.getBytes());
System.out.println("send to mq "+message);
}
for(int i=0;i<5;i++){
//发送消息的时候指定routingKey
String message = "send two inform message to user";
channel.basicPublish(EXCHANGE_TOPICS,"inform.two",null,message.getBytes());
System.out.println("send to mq "+message);
}
for(int i=0;i<5;i++){
//发送消息的时候指定routingKey
String message = "send sms and email inform message to user";
channel.basicPublish(EXCHANGE_TOPICS,"inform.two.email",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();
}
}
}
}消息接收者1：
public class ConsumerTopiceOne{
//队列名称
private static final String QUEUE_ONE = "queue_one";
//交换机名称
private static final String EXCHANGE_TOPICS="exchange_topics";
//路由key
private static final String ROUTINGKEY_ONE="inform.#.one.#";
public static void main(String[] args) throws Exception{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TOPICS,BuiltinExchanggeType.TOPIC);
//进行交换机跟队列的绑定
channel.queueBind(QUEUE_ONE ,EXCHANGE_TOPICS,ROUTINGKEY_ONE);
//获取消息
DefaultConsumer dafaultConsumer = 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("消费者1接收到的信息:"+message);
}
};
//监听队列
channel.basicConsume(QUEUE_ONE ,true,dafaultConsumer );
}
}消息接收者2：
public class ConsumerTopiceTwo{
//队列名称
private static final String QUEUE_TWO = "queue_two";
//交换机名称
private static final String EXCHANGE_TOPICS="exchange_topics";
//路由key
private static final String ROUTINGKEY_TWO="inform.#.two.#";
public static void main(String[] args) throws Exception{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TOPICS,BuiltinExchanggeType.TOPIC);
//进行交换机跟队列的绑定
channel.queueBind(QUEUE_TWO ,EXCHANGE_TOPICS,ROUTINGKEY_TWO);
//获取消息
DefaultConsumer dafaultConsumer = 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("消费者2接收到的信息:"+message);
}
};
//监听队列
channel.basicConsume(QUEUE_TWO ,true,dafaultConsumer );
}
}5.Header（）模式：
7.RPC模式：
