常用命令
## rabbitmq 常用命令 进入到sbin目录 启用管理插件:rabbitmq-plugins enable rabbitmq_management 启动服务: net start RabbitMQ 停止服务: net stop RabbitMQ 查看rabbitmq用户列表: rabbitmqctl list_users 给用户赋管理员权限: rabbitmqctl set_user_tags 用户名 administrator
队列的几种模式
-
简单队列:一个生产者,一个消费者
-
work模式:一个生产者,两个消费者
-
订阅模式:一个生产者,多个消费者
-
路由模式:交换机
-
主题模式
work模式
生产者代码：
package com.gmh.plugs.rabbitmq.work;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Producer
* @projectName Self
* @description: 生产者(work模式)
* @date 2020/3/3 23:28
*/
@Slf4j
public class Producer {
//定义队列名称
private final static String QUEUE_NAME = "test_msg";
public static void main(String[] args) throws Exception {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//从链接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME,false,false,false,null);
/**
* exchange：交换器名称，如果设置为空字符串，则消息会被发送到RabbitMQ默认的交换器中。
* routingKey：指定路由键，交换器根据路由键将消息存储到相应的队列之中
* BasicProperties：消息的基本属性，例如路由头等
* body：msg字节
*/
for (int i = 0; i < 100; i++){
//消息内容
String msg = "hello rabbitmq"+i;
channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
log.info("发送消息: " + msg);
}
//关闭通道和链接
channel.close();
connection.close();
}
}
消费者1代码：
package com.gmh.plugs.rabbitmq.work;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(work模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer1 {
//定义队列名称
private final static String QUEUE_NAME = "test_msg";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("1接收到的消息: " +message);
//休眠
Thread.sleep(10);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
消费者2代码：
package com.gmh.plugs.rabbitmq.work;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(work模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer2 {
//定义队列名称
private final static String QUEUE_NAME = "test_msg";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("2接收到的消息: " +message);
// 休眠1秒
Thread.sleep(1000);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
测试结果说明: 1、消费者1和消费者2获取到的消息内容是不同的，同一个消息只能被一个消费者获取。 2、消费者1和消费者2获取到的消息的数量是相同的，一个是消费奇数号消息，一个是偶数。 其实，这样是不合理的，因为消费者1线程停顿的时间短。应该是消费者1要比消费者2获取到的消息多才对。 RabbitMQ 默认将消息顺序发送给下一个消费者，这样，每个消费者会得到相同数量的消息。即轮询（round-robin）分发消息。 怎样才能做到按照每个消费者的能力分配消息呢？联合使用 Qos 和 Acknowledge 就可以做到。 basicQos 方法设置了当前信道最大预获取（prefetch）消息数量为1。消息从队列异步推送给消费者，消费者的 ack 也是异步发送给队列，从队列的视角去看，总是会有一批消息已推送但尚未获得 ack 确认，Qos 的 prefetchCount 参数就是用来限制这批未确认消息数量的。设为1时，队列只有在收到消费者发回的上一条消息 ack 确认后，才会向该消费者发送下一条消息。prefetchCount 的默认值为0，即没有限制，队列会将所有消息尽快发给消费者。2个概念
轮询分发 ：使用任务队列的优点之一就是可以轻易的并行工作。如果我们积压了好多工作，我们可以通过增加工作者（消费者）来解决这一问题，使得系统的伸缩性更加容易。在默认情况下，RabbitMQ将逐个发送消息到在序列中的下一个消费者(而不考虑每个任务的时长等等，且是提前一次性分配，并非一个一个分配)。平均每个消费者获得相同数量的消息。这种方式分发消息机制称为Round-Robin（轮询）。 公平分发 ：虽然上面的分配法方式也还行，但是有个问题就是：比如：现在有2个消费者，所有的奇数的消息都是繁忙的，而偶数则是轻松的。按照轮询的方式，奇数的任务交给了第一个消费者，所以一直在忙个不停。偶数的任务交给另一个消费者，则立即完成任务，然后闲得不行。而RabbitMQ则是不了解这些的。这是因为当消息进入队列，RabbitMQ就会分派消息。它不看消费者为应答的数目，只是盲目的将消息发给轮询指定的消费者。 为了解决这个问题，我们使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈，才会进行第二次发送。 还有一点需要注意，使用公平分发，必须关闭自动应答，改为手动应答。
订阅模式
package com.gmh.plugs.rabbitmq.publish;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Producer
* @projectName Self
* @description: 生产者(订阅模式)
* @date 2020/3/3 23:28
*/
@Slf4j
public class Producer {
//定义交换机名称
private final static String EXCHANGE_NAME = "test_exchange_fanout";
public static void main(String[] args) throws Exception {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//从链接中创建通道
Channel channel = connection.createChannel();
/**
* 声明exchange交换机
*/
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
//消息内容
String msg = "hello rabbitmq";
/**
* exchange：交换机名称，如果设置为空字符串，则消息会被发送到RabbitMQ默认的交换器中。
* routingKey：指定路由键，交换器根据路由键将消息存储到相应的队列之中
* BasicProperties：消息的基本属性，例如路由头等
* body：msg字节
*/
channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());
log.info("发送消息: " + msg);
//关闭通道和链接
channel.close();
connection.close();
}
}
package com.gmh.plugs.rabbitmq.publish;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(订阅模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer1 {
//定义队列名称
private final static String QUEUE_NAME = "test_msg1";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_fanout";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("1接收到的消息: " +message);
//休眠
Thread.sleep(10);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
package com.gmh.plugs.rabbitmq.publish;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(订阅模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer2 {
//定义队列名称
private final static String QUEUE_NAME = "test_msg2";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_fanout";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("2接收到的消息: " +message);
// 休眠1秒
Thread.sleep(1000);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
测试结果: 队列名称不同时才都会接收到消息 生产者把消息发送到交换机，然后再到队列。 两个消费者如果队列名称相同则只有一个消费者实例会消费消息,如果队列名称不同则都会消费消息
路由模式
package com.gmh.plugs.rabbitmq.routing;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Producer
* @projectName Self
* @description: 生产者(路由模式)
* @date 2020/3/3 23:28
*/
@Slf4j
public class Producer {
//定义交换机名称
private final static String EXCHANGE_NAME = "test_exchange_direct";
public static void main(String[] args) throws Exception {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//从链接中创建通道
Channel channel = connection.createChannel();
/**
* 声明exchange交换机
*/
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
//消息内容
String infoMsg = "hello info";
String errorMsg = "hello error";
/**
* exchange：交换机名称，如果设置为空字符串，则消息会被发送到RabbitMQ默认的交换器中。
* routingKey：指定路由键，交换器根据路由键将消息存储到相应的队列之中
* BasicProperties：消息的基本属性，例如路由头等
* body：msg字节
*/
channel.basicPublish(EXCHANGE_NAME,"info",null,infoMsg.getBytes());
channel.basicPublish(EXCHANGE_NAME,"error",null,errorMsg.getBytes());
log.info("发送消息: " + infoMsg + " " + errorMsg);
//关闭通道和链接
channel.close();
connection.close();
}
}
package com.gmh.plugs.rabbitmq.routing;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(路由模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer1 {
//定义队列名称
private final static String QUEUE_NAME = "test_info";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_direct";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "info");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("1接收到的消息: " +message);
//休眠
Thread.sleep(10);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
package com.gmh.plugs.rabbitmq.routing;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(路由模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer2 {
//定义队列名称
private final static String QUEUE_NAME = "test_error";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_direct";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("2接收到的消息: " +message);
// 休眠1秒
Thread.sleep(1000);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
测试结果：生产者往info路由键发送消息时，只有执行消费info路由键的消费者才能接收到消息，error路由键同样。
主题模式
package com.gmh.plugs.rabbitmq.topics;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Producer
* @projectName Self
* @description: 生产者(路由模式)
* @date 2020/3/3 23:28
*/
@Slf4j
public class Producer {
//定义交换机名称
private final static String EXCHANGE_NAME = "test_exchange_topic";
public static void main(String[] args) throws Exception {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//从链接中创建通道
Channel channel = connection.createChannel();
/**
* 声明exchange交换机
*/
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
//消息内容
String infoMsg = "hello topic";
/**
* exchange：交换机名称，如果设置为空字符串，则消息会被发送到RabbitMQ默认的交换器中。
* routingKey：指定路由键，交换器根据路由键将消息存储到相应的队列之中
* BasicProperties：消息的基本属性，例如路由头等
* body：msg字节
*/
channel.basicPublish(EXCHANGE_NAME,"2.topic.1",null,infoMsg.getBytes());
log.info("发送消息: " + infoMsg);
//关闭通道和链接
channel.close();
connection.close();
}
}
package com.gmh.plugs.rabbitmq.topics;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(路由模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer1 {
//定义队列名称
private final static String QUEUE_NAME = "test_topic1";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_topic";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.topic.*");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("1接收到的消息: " +message);
//休眠
Thread.sleep(10);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
package com.gmh.plugs.rabbitmq.topics;
import com.gmh.plugs.rabbitmq.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import lombok.extern.slf4j.Slf4j;
/**
* @author GMH
* @title: Consumer
* @projectName Self
* @description: 消费者(路由模式)
* @date 2020/3/3 23:56
*/
@Slf4j
public class Consumer2 {
//定义队列名称
private final static String QUEUE_NAME = "test_topic2";
//定义交换机的名称
private final static String EXCHANGE_NAME = "test_exchange_topic";
public static void main(String[] args) throws Exception {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
// 从连接中创建通道
Channel channel = connection.createChannel();
/**
* 声明队列
* 参数1(queue):队列名称
* 参数2(durable):是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* 参数3(exclusive):排他队列
* 如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。这里需要注意三点：
* 其一，排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一个连接创建的排他队列的。
* 其二，“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
* 其三，即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的。
* 这种队列适用于只限于一个客户端发送读取消息的应用场景。
* 参数4(autoDelete):自动删除，true为自动删除，删除的前提是至少有一个消费者连接这个队列，之后所有与这个队列连接的消费者都断开时都会自动删除（并不是当连接此队列的所有客户端都断开时自动删除）
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 绑定队列到交换机
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "topic.*");
// 同一时刻服务器只会发一条消息给消费者
channel.basicQos(1);
// 定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
// 监听队列(queue:队列名;autoAck:是否自动确认消息,false需手动调用;callback:回调)
channel.basicConsume(QUEUE_NAME, false, consumer);
// 获取消息
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
log.info("2接收到的消息: " +message);
// 休眠1秒
Thread.sleep(1000);
// 返回确认状态，注释掉表示使用自动确认模式
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}
测试结果：Topic Exchange 将路由键和模式进行匹配，符号#代表可匹配一个或多个词，*符号可匹配一个词 如:生产者路由键为2.topic.1 消费者1绑定的路由键为*.topic.* 消费者2绑定的路由键为topic.* 测试结果 消费者1能接收到消息，消费者2则接收不到.
交换机类型
-
Direct Exchange：直连交换机。生产者把消息发送到交换机时会根据路由键进行匹配，然后把消息发送到对应的队列上
-
Fanout Exchange：扇型交换机。无需根据路由键匹配，只要队列绑定了该交换机就会接收到消息
-
Topic Exchange：主题交换机。路由键根据模式匹配把消息发送到对应的队列上。#代表可匹配多个词，*只能匹配一个词
-
Headers Exchange（头交换机）：头交换机类似与主题交换机，但是却和主题交换机有着很大的不同。主题交换机使用路由键来进行消息的路由，而头交换机使用消息属性来进行消息的分发，通过判断消息头的值能否与指定的绑定相匹配来确立路由规则。在头交换机里有一个特别的参数”x-match”，当”x-match”的值为“any”时，只需要消息头的任意一个值匹配成功即可， 当”x-match”值为“all”时，要求消息头的所有值都需相等才可匹配成功。
320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
