MQ简介以及RabbitMQ模式具体实现
消息队列
MQ概述
MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信
应用之间的远程调用
加入MQ后应用之间的调用
MQ优势
1.应用解耦
MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合
系统的耦合性越高，容错性就越低，可维护性就越低
使用 MQ 使得应用间解耦，提升容错性和可维护性
2.任务异步处理
将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间
3.削峰填谷
如订单系统，在下单的时候就会往数据库写数据。但是数据库只能支撑每秒1000左右的并发写入，并发量再高就容易宕机。低峰期的时候并发也就100多个，但是在高峰期时候，并发量会突然激增到5000以上，这个时候数据库肯定卡死了
消息被MQ保存起来了，然后系统就可以按照自己的消费能力来消费，比如每秒1000个消息，这样慢慢写入数据库，这样就不会卡死数据库了
但是使用了MQ之后，限制消费消息的速度为1000，但是这样一来，高峰期产生的数据势必会被积压在MQ中，高峰就被“削”掉了。但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000QPS，直到消费完积压的消息,这就叫做“填谷”
常见的MQ产品
MQ实现方式
实现MQ的大致有两种主流方式：AMQP、JMS。
AMQP
AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用
层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，遵循此协议，不收客户端和中间件产品和开发语言限制。2006年，AMQP 规范发布。类比HTTP
JMS
JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间
件的API
JMS 是 JavaEE 规范中的一种，类比JDBC
很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有
AMQP与JMS区别
- JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
- JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的
- JMS规定了两种消息模式；而AMQP的消息模式更加丰富
RabbitMQ
官网地址:http://www.rabbitmq.com/
架构图:
相关概念:
- Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
- Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类
似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务
时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等 - Connection：publisher／consumer 和 broker 之间的 TCP 连接
- Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP
Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，
如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含
了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。
Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销 - Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发
消息到queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and
fanout (multicast) - Queue：消息最终被送到这里等待 consumer 取走
- Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息
被保存到 exchange 中的查询表中，用于 message 的分发依据
RabbitMQ模式
RabbitMQ提供了6种模式：简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由
模式，Topics主题模式，RPC远程调用模式（远程调用，不太算MQ；暂不作介绍）
1.简单模式
模型:
在上图的模型种，有以下概念:
- P: 生产者，就是要发送消息的程序
- C: 消费者，消息的接收者，等消息到来
- queue: 消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息
搭建工程
添加依赖
com.rabbitmq
amqp-client
5.6.0
编写工具类
创建工具类，用来给后面的几个模式的创建工程进行调用
package com.study.rabbitmq.utils;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class ConnectionUtils {
public static Connection getConnetion() throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//主机地址;默认为 localhost (这里是我的虚拟机ip)
connectionFactory.setHost("192.168.249.4");
//连接端口;默认为 5672
connectionFactory.setPort(5672);
//虚拟主机名称;默认为 / (先在rabbitmq管理台创建该虚拟机)
connectionFactory.setVirtualHost("/xzk");
//连接用户名；默认为guest (先在rabbitmq管理台创建该用户)
connectionFactory.setUsername("wx");
//连接密码；默认为guest
connectionFactory.setPassword("wx");
Connection connection = connectionFactory.newConnection();
return connection;
}
}
编写生产者
编写消息的生产者，也就是发送消息的程序
package com.study.rabbitmq.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String QUEUE_NAME="simple_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接，只能有一个Consumer监听这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//发送消息
String message = "你好:小兔子";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("已发送消息：" + message);
//释放资源
channel.close();
connection.close();
}
}
编写消费者
package com.study.rabbitmq.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
/**
* 模拟消费者
*/
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
测试
在管理台登录上述工具类当中的账号时，启动生产者程序，发现rabbitmq管理台多了一个消息,如下所示
启动消费者程序，发现队列中的消息已经被消费了
工作队列模式
Work Queues 与简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息
生产者
package com.study.rabbitmq.work;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String QUEUE_NAME="work_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(QUEUE_NAME,true,false,false,null);
//发送消息
for(int i=1;i<=30;i++){
String message = "你好,rabbit----work queue模式" + i ;
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("已发送消息" + message);
}
//释放资源
channel.close();
connection.close();
}
}
消费者1
package com.study.rabbitmq.work;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
消费者2
package com.study.rabbitmq.work;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
测试
先启动俩个消费者,再启动生产者，不然的话消息就立刻被一个消费者全部消费了, 当生产者发送消息时，俩个消费者存在竞争的关系，即一个消息被一个消费者消费后，就不能被另一个消费者消费了
Publish/Subscribe发布与订阅模式
发布订阅模式： 1、每个消费者监听自己的队列。 2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息
生产者
package com.study.rabbitmq.ps;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String FANOUT_EXCHANGE="fanout_exchange";
public static String FANOUT_QUEUE_1="fanout_queue_1";
public static String FANOUT_QUEUE_2="fanout_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout,topic,direct,headers(不常见)
*/
channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);
//队列绑定交换机
channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHANGE,"");
channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHANGE,"");
//发送消息
for(int i=1;i<=10;i++){
String message = "你好,rabbit----fanout 模式" + i ;
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(FANOUT_EXCHANGE,"",null,message.getBytes());
System.out.println("已发送消息" + message);
}
//释放资源
channel.close();
connection.close();
}
}
消费者1
package com.study.rabbitmq.ps;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.FANOUT_QUEUE_1,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.FANOUT_QUEUE_1,Producer.FANOUT_EXCHANGE,"");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.FANOUT_QUEUE_1,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
消费者2
package com.study.rabbitmq.ps;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.FANOUT_QUEUE_2,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.FANOUT_QUEUE_2,Producer.FANOUT_EXCHANGE,"");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.FANOUT_QUEUE_2,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
测试
启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息；到达广播的效果
在执行完测试代码后，其实到RabbitMQ的管理后台找到 Exchanges 选项卡，点击 fanout_exchange的交换机，可以查看到如下的绑定
小结
交换机需要与队列进行绑定，绑定之后：一个消息可以被多个消费者都收到，而不是像工作模式一样进行争夺消息
发布订阅模式与工作队列模式的区别:
- 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
- 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
- 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机
Routing路由模式
路由模式的特点:
- 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey （路由key）
- 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey
- Exchange不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列
的 Routingkey 与消息的 Routing key 完全一致，才会接收到消息
图解:
-
p: 生产者，向Exchange发送消息，发送消息时，会指定一个routing key
-
X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
-
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
-
消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息
生产者
package com.study.rabbitmq.routing;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String DIRECT_EXCHANGE="direct_exchange";
public static String DIRECT_QUEUE_INSERT="direct_queue_1";
public static String DIRECT_QUEUE_UPDATE="direct_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout(广播类型),topic,direct（路由类型）,headers(不常见)
*/
channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(DIRECT_QUEUE_INSERT,true,false,false,null);
channel.queueDeclare(DIRECT_QUEUE_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHANGE,"insert");
channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHANGE,"update");
//发送消息
String message = "新增商品 路由模式 ---- routingKey=insert";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE,"insert",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "修改商品 路由模式 ---- routingKey=update";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE,"update",null,message.getBytes());
System.out.println("已发送消息" + message);
//释放资源
channel.close();
connection.close();
}
}
消费者1
package com.study.rabbitmq.routing;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE,"insert");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.DIRECT_QUEUE_INSERT,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
消费者2
package com.study.rabbitmq.routing;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHANGE,"update");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
测试
启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达按照需要接收的效果
在执行完测试代码后，其实到RabbitMQ的管理后台找到 Exchanges 选项卡，点击 direct_exchange的交换机，可以查看到如下的绑定
小结
Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列
Topics通配符模式
模式说明：
Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型
Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如：item.insert
通配符规则:
#:匹配一个或多个词
*:匹配不多不少恰好1个词
举例:
item.#:能够匹配item.insert.abc或者item.insert
item.*:只能匹配item.insert
图解：
- 红色Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
- 黄色Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配
生产者
package com.study.rabbitmq.topic;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String TOPIC_EXCHANGE="topic_exchange";
public static String TOPIC_QUEUE_ALL="topic_queue_all";
public static String TOPIC_QUEUE_INSERT_UPDATE="topic_queue_insert_update";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout(广播类型),topic,direct（路由类型）,headers(不常见)
*/
channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
//发送消息
String message = "新增商品 topic模式 ---- routingKey=item.insert";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.insert",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "修改商品 topic模式 ---- routingKey=item.update";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.update",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "删除商品 topic模式 ---- routingKey=item.delete";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.delete",null,message.getBytes());
System.out.println("已发送消息" + message);
//释放资源
channel.close();
connection.close();
}
}
消费者1
package com.study.rabbitmq.topic;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHANGE,BuiltinExchangeType.TOPIC);
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.TOPIC_QUEUE_ALL,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.TOPIC_QUEUE_ALL, Producer.TOPIC_EXCHANGE,"item.*");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.TOPIC_QUEUE_ALL,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
消费者2
package com.study.rabbitmq.topic;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHANGE,BuiltinExchangeType.TOPIC);
//声明(创建)队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4：是否在不使用的时候自动删除队列,当没有Consumer时，自动删除
* 参数5：队列其它参数
*/
channel.queueDeclare(Producer.TOPIC_QUEUE_INSERT_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.update");
channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.insert");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为：" + new String(body, "utf-8"));
}
};
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复
会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(Producer.TOPIC_QUEUE_INSERT_UPDATE,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
测试
启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应
routing key对应队列的消息；到达按照需要接收的效果；并且这些routing key可以使用通配符
在执行完测试代码后，其实到RabbitMQ的管理后台找到 Exchanges 选项卡，点击 topic_exchange的交换机，可以查看到如下的绑定
小结
Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能；只是Topic
在配置routing key 的时候可以使用通配符，显得更加灵活
模式总结
RabbitMQ工作模式：
- 简单模式 : 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）
- 工作队列模式 Work Queue: 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）
- 发布订阅模式 Publish/subscribe :需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列
- **路由模式 Routing **:需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routingkey，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
- 通配符模式 Topic :需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列