RabbitMQ6种消息模型
简单队列
- 在简单队列中有三种角色
- ①生产者 P(消息的产生方)
- ②消息队列(queue用来存放生产者所发送的消息,容量大小依据服务器存储大小)
- ③消费者 C(消息的使用方)
- 不足之处:生成者发送的消息数量很大,大于消费者的接收数量,就容易将队列强制刷新,丢失消息。
生成者
package com.xxxx.simple.send;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 简单队列-消息生成者
*/
public class Send {
//定义队列名称
private final static String QUEUE_NAME = "hello";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
/**
* 声明队列
* 第一个参数queue:队列名称
* 第二个参数durable:是否持久化
* 第三个参数Exclusive:排他队列,如果一个队列被声明为排他队列,该队列仅对首次声明它的连接可见,并在连接断开后自动删除。
* 注意点:
* 1、排他队列是基于连接可见的,同一连接的不同通道是可以访问同一个连接创建的排他队列的。
* 2、如果一个连接已声明了一个排他队列,其他连接是不允许建立同名的排他队列,这个与普通队列不同
* 3、即使队列是持久化的,一旦连接关闭或客户端退出,该排他队列都会被自动删除。
* 这种队列只适用于一个客户端读取消息的应用场景。
* 第四个参数Auto-delete:自动删除,如果该队列没有任何订阅的消费者的话,该队列会被自动删除。
* 这种适合于临时队列。
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
String message = "Hello World!";
//发送消息
channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + message + "'");
}
}
}
消费者
package com.xxxx.simple.recv;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.nio.charset.StandardCharsets;
/**
*简单队列-消息消费者
*/
public class Recv {
//定义队列名称
private final static String QUEUE_NAME = "hello";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
}
}
运行截图
生产者
消费者
工作队列
- 在工作队列中有三种角色
- ①生产者 P(消息的产生方)
- ②消息队列(queue用来存放生产者所发送的消息,容量大小依据服务器存储大小)
- ③消费者 C(有多个消息的使用方)
第一种循环调度(Round-robin dispatching)
- 特点:有两个消费者,当一个消费者接收消息后,才到另一个消费者接收消息,以此类推。
生成者
package com.xxxx.work.rr.send;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 工作队列-轮询-消息生成者
*/
public class Send {
//定义队列名称
private final static String QUEUE_NAME = "work_rr";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
/**
* 声明队列
* 第一个参数queue:队列名称
* 第二个参数durable:是否持久化
* 第三个参数Exclusive:排他队列,如果一个队列被声明为排他队列,该队列仅对首次声明它的连接可见,并在连接断开后自动删除。
* 注意点:
* 1、排他队列是基于连接可见的,同一连接的不同通道是可以访问同一个连接创建的排他队列的。
* 2、如果一个连接已声明了一个排他队列,其他连接是不允许建立同名的排他队列,这个与普通队列不同
* 3、即使队列是持久化的,一旦连接关闭或客户端退出,该排他队列都会被自动删除。
* 这种队列只适用于一个客户端读取消息的应用场景。
* 第四个参数Auto-delete:自动删除,如果该队列没有任何订阅的消费者的话,该队列会被自动删除。
* 这种适合于临时队列。
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//模拟发送20条消息
for(int i=0;i<20;i++) {
String message = "Hello World!"+i;
//发送消息
channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + message + "'"+i);
}
}
}
}
消费者1
package com.xxxx.work.rr.recv;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.nio.charset.StandardCharsets;
/**
*工作队列-轮询-消息消费者
*/
public class Recv01 {
//定义队列名称
private final static String QUEUE_NAME = "work_rr";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
//模拟消费耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
//手动确认
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
}
}
消费者2
package com.xxxx.work.rr.recv;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.nio.charset.StandardCharsets;
/**
*工作队列-轮询-消息消费者
*/
public class Recv02 {
//定义队列名称
private final static String QUEUE_NAME = "work_rr";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
//模拟消费耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
//手动确认
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
}
}
运行截图
生成者
消费者1
消费者2
第二种公平调度(Fair dispatch)
- 特点:不同于循环调度,二者对消息的接收是“能者多劳”。
生成者
package com.xxxx.work.fair.send;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 工作队列-公平-消息生成者
*/
public class Send {
//定义队列名称
private final static String QUEUE_NAME = "work_fair";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
/**
* 声明队列
* 第一个参数queue:队列名称
* 第二个参数durable:是否持久化
* 第三个参数Exclusive:排他队列,如果一个队列被声明为排他队列,该队列仅对首次声明它的连接可见,并在连接断开后自动删除。
* 注意点:
* 1、排他队列是基于连接可见的,同一连接的不同通道是可以访问同一个连接创建的排他队列的。
* 2、如果一个连接已声明了一个排他队列,其他连接是不允许建立同名的排他队列,这个与普通队列不同
* 3、即使队列是持久化的,一旦连接关闭或客户端退出,该排他队列都会被自动删除。
* 这种队列只适用于一个客户端读取消息的应用场景。
* 第四个参数Auto-delete:自动删除,如果该队列没有任何订阅的消费者的话,该队列会被自动删除。
* 这种适合于临时队列。
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//模拟发送20条消息
for(int i=0;i<20;i++) {
String message = "Hello World!"+i;
//发送消息
channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + message + "'"+i);
}
}
}
}
消费者1
package com.xxxx.work.fair.recv;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.nio.charset.StandardCharsets;
/**
*工作队列-公平-消息消费者
*/
public class Recv01 {
//定义队列名称
private final static String QUEUE_NAME = "work_fair";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
int prefetchCount=1;
//限制消费者每次只能接受一条消息,处理完才能接受下一条消息
channel.basicQos(prefetchCount);
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
//模拟消费耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
//手动确认
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
}
}
消费者2
package com.xxxx.work.fair.recv;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.nio.charset.StandardCharsets;
/**
*工作队列-公平-消息消费者
*/
public class Recv02 {
//定义队列名称
private final static String QUEUE_NAME = "work_fair";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
int prefetchCount=1;
//限制消费者每次只能接受一条消息,处理完才能接受下一条消息
channel.basicQos(prefetchCount);
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
//模拟消费耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
//手动确认
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
}
}
运行截图
生产者
消费者1
消费者2
发布与订阅队列
- 在发布与订阅队列中有四种角色
- ①生产者 P(消息的产生方)
- ②消息队列(queue用来存放生产者所发送的消息,容量大小依据服务器存储大小)
- ③消费者 C(多个消息的使用方)
- ④交换机
- 特点:不同于以上的消息队列模型,在发布与订阅队列中,同一个消息可以被不同的消费者接收。
生产者
package com.xxxx.fanout.send;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 发布/订阅队列-消息生成者
*/
public class Send {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange-fanout";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
String message = "Hello World!";
channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + message + "'");
}
}
}
消费者1
package com.xxxx.fanout.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
*发布/订阅队列-消息消费者
*/
public class Recv01 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange-fanout";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,"");
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
消费者2
package com.xxxx.fanout.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
*发布/订阅队列-消息消费者
*/
public class Recv02 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange-fanout";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,"");
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
运行截图
生产者
消费者1
消费者2
路由队列
- 在路由队列中有四种角色
- ①生产者 P(消息的产生方)
- ②消息队列(queue用来存放生产者所发送的消息,容量大小依据服务器存储大小)
- ③消费者 C(多个消息的使用方)
- ④交换机
- 特点:可以根据不同的routerkey去向不同的消息队列发送消息,可以指定那些消费者可以接收到消息。
生产者
package com.xxxx.direct.send;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 路由队列-消息生成者
*/
public class Send {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_direct";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
String infoMessage = "普通消息";
String errorMessage = "错误消息";
String warningMessage = "警告消息";
String infoRoutingKey="info";
String errorRoutingKey="error";
String warningRoutingKey="warning";
channel.basicPublish(EXCHANGE_NAME, infoRoutingKey, null, infoMessage.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, errorRoutingKey, null, errorMessage.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, warningRoutingKey, null, warningMessage.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + infoMessage + "'");
System.out.println(" [x] Sent '" + errorMessage + "'");
System.out.println(" [x] Sent '" + warningMessage + "'");
}
}
}
消费者1
package com.xxxx.direct.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
* 路由队列-消息消费者
*/
public class Recv01 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_direct";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
String errorRoutingKey="error";
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,errorRoutingKey);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
消费者2
package com.xxxx.direct.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
*路由队列-消息消费者
*/
public class Recv02 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_direct";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
String errorRoutingKey="error";
String infoRoutingKey="info";
String warningRoutingKey="warning";
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,infoRoutingKey);
channel.queueBind(queueName,EXCHANGE_NAME,warningRoutingKey);
channel.queueBind(queueName,EXCHANGE_NAME,errorRoutingKey);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
运行截图
生产者
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
消费者1
消费者2
主题队列
- 在发布与订阅队列中有四种角色
- ①生产者 P(消息的产生方)
- ②消息队列(queue用来存放生产者所发送的消息,容量大小依据服务器存储大小)
- ③消费者 C(多个消息的使用方)
- ④交换机
- 特点:主题队列集合了所有的队列模型的特点,可以实现所有队列模型的功能,是最常用的队列模型。
- *与#的讲解:*只能匹配一个,而#可以匹配零个或多个。
生产者
package com.xxxx.topic.send;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
/**
* 主题队列-消息生成者
*/
public class Send {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
try (
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
String infoMessage = "普通消息";
String errorMessage = "错误消息";
String warningMessage = "警告消息";
String infoRoutingKey="info.message.orange";
String errorRoutingKey="error.rabbit.lazy";
String warningRoutingKey="orange.warning.message";
channel.basicPublish(EXCHANGE_NAME, infoRoutingKey, null, infoMessage.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, errorRoutingKey, null, errorMessage.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, warningRoutingKey, null, warningMessage.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + infoMessage + "'");
System.out.println(" [x] Sent '" + errorMessage + "'");
System.out.println(" [x] Sent '" + warningMessage + "'");
}
}
}
消费者1
package com.xxxx.topic.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
* 主题队列-消息消费者
*/
public class Recv01 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
String routingKey="#.message.#";
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,routingKey);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
消费者2
package com.xxxx.topic.recv;
import com.rabbitmq.client.*;
import java.nio.charset.StandardCharsets;
/**
* 主题队列-消息消费者
*/
public class Recv02 {
//定义队列名称
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.47.128");
factory.setUsername("yeb");
factory.setVirtualHost("/yeb");
factory.setPassword("123");
factory.setPort(5672);
//连接工厂创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
//交换机生成排他队列
String queueName = channel.queueDeclare().getQueue();
String routingKey="*.rabbit.*";
//交换机与队列绑定
channel.queueBind(queueName,EXCHANGE_NAME,routingKey);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + message + "'");
};
//监听队列消费消息
//第二个参数autoAck:自动回执,告诉生产者收到消息了。
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}