RabbitMQ快速入门Java Demo
RabbitMQ快速入门Demo
- 快速入门Demo
- direct：
- fanout
- topic
快速入门Demo
引入依赖(版本自选)：
<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.7.0</version>
</dependency>
Exchanges策略模式：
Ps：执行下面的Demo的时候，建议优先执行消费端的代码，RabbitMQ会创建对应的exchange和queue并对应绑定
当然，也可以在RabbitMQ的管理UI上进行add和绑定
direct：
消息生产者Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Producer4DirectExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.xxxx.xxx");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
// 2 创建Connection
Connection connection = connectionFactory.newConnection();
// 3 创建Channel
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_direct_exchange";
String routingKey = "test.direct";
// 5 发送
for (int i = 0; i < 5; i++) {
String msg = "Hello World RabbitMQ 4 Direct Exchange Message ... " + i;
channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());
System.out.println("send: " + msg);
}
channel.close();
connection.close();
}
}
消息消费者 Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
public class Consumer4DirectExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.xxx.xxx");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_direct_exchange";
String exchangeType = "direct";
String queueName = "test_direct_queue";
String routingKey = "test.direct";
// 表示声明了一个交换机
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
// 表示声明了一个队列
channel.queueDeclare(queueName, false, false, false, null);
// 建立一个绑定关系:
channel.queueBind(queueName, exchangeName, routingKey);
// durable 是否持久化消息
QueueingConsumer consumer = new QueueingConsumer(channel);
// 参数：队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, true, consumer);
// 循环获取消息
while (true) {
// 获取消息，如果没有消息，这一步将会一直阻塞
Delivery delivery = consumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println(queueName + " 收到消息：" + msg);
}
}
}
生产者输出：
send: Hello World RabbitMQ 4 Direct Exchange Message … 0
send: Hello World RabbitMQ 4 Direct Exchange Message … 1
send: Hello World RabbitMQ 4 Direct Exchange Message … 2
send: Hello World RabbitMQ 4 Direct Exchange Message … 3
send: Hello World RabbitMQ 4 Direct Exchange Message … 4
消费者输出：
test_direct_queue 收到消息：Hello World RabbitMQ 4 Direct Exchange Message … 0
test_direct_queue 收到消息：Hello World RabbitMQ 4 Direct Exchange Message … 1
test_direct_queue 收到消息：Hello World RabbitMQ 4 Direct Exchange Message … 2
test_direct_queue 收到消息：Hello World RabbitMQ 4 Direct Exchange Message … 3
test_direct_queue 收到消息：Hello World RabbitMQ 4 Direct Exchange Message … 4
** 经测试结果总结 **
如再起一个相同queue名称的消费：RabbitMQ会轮询方式消费，一条消息只有一个queue收到
如Copy上面的消费端代码，只修改String queueName = “test_direct_queue_2”;：RabbitMQ广播模式，1条消息,n个消费者都收到
大白话：
1生产者，n消费者(queue名相同) -> 轮询方式，一条消息只有一个queue收到
1生产者，n消费者(queue名不相同) -> 广播方式，1条消息,n个都收到
fanout
消息生产者Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Producer4FanoutExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.204.51");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
// 2 创建Connection
Connection connection = connectionFactory.newConnection();
// 3 创建Channel
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_fanout_exchange";
// 5 发送
for (int i = 0; i < 5; i++) {
String msg = "Hello World RabbitMQ 4 FANOUT Exchange Message ..." + i;
channel.basicPublish(exchangeName, "", null, msg.getBytes());
}
channel.close();
connection.close();
}
}
消息消费者 Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
public class Consumer4FanoutExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.xxx.xx");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_fanout_exchange";
String exchangeType = "fanout";
String queueName = "test_fanout_queue";
String routingKey = ""; // 不设置路由键
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
channel.queueDeclare(queueName, false, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
// durable 是否持久化消息
QueueingConsumer consumer = new QueueingConsumer(channel);
// 参数：队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, true, consumer);
// 循环获取消息
while (true) {
// 获取消息，如果没有消息，这一步将会一直阻塞
Delivery delivery = consumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println(queueName + " 收到消息：" + msg);
}
}
}
消费者输出：
test_fanout_queue 收到消息：Hello World RabbitMQ 4 FANOUT Exchange Message …0
test_fanout_queue 收到消息：Hello World RabbitMQ 4 FANOUT Exchange Message …1
test_fanout_queue 收到消息：Hello World RabbitMQ 4 FANOUT Exchange Message …2
test_fanout_queue 收到消息：Hello World RabbitMQ 4 FANOUT Exchange Message …3
test_fanout_queue 收到消息：Hello World RabbitMQ 4 FANOUT Exchange Message …4
** 经测试结果总结 **
如再起一个相同queue名称的消费：RabbitMQ会轮询方式消费，一条消息只有一个queue收到
如Copy上面的消费端代码，只修改String queueName = “test_fanout_queue_2”;：RabbitMQ广播模式，1条消息,n个消费者都收到
大白话：
1生产者，n消费者(queue名相同) -> 轮询方式，一条消息只有一个queue收到
1生产者，n消费者(queue名不相同) -> 广播方式，1条消息,n个都收到
topic
消息生产者Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Producer4TopicExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.xxx.xx");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
// 2 创建Connection
Connection connection = connectionFactory.newConnection();
// 3 创建Channel
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_topic_exchange";
String routingKey1 = "user.save";
// 5 发送
for (int i = 0; i < 5; i++) {
String msg = "Hello World RabbitMQ 4 Topic Exchange Message ..." + i;
channel.basicPublish(exchangeName, routingKey1, null, msg.getBytes());
}
channel.close();
connection.close();
}
}
消息消费者 Code：
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
public class Consumer4TopicExchange {
public static void main(String[] args) throws Exception {
// 1、创建connectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.xxx.xx");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("rabbitadmin");
connectionFactory.setPassword("123456");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
// 4 声明
String exchangeName = "test_topic_exchange";
String exchangeType = "topic";
String queueName = "test_topic_queue";
// String routingKey = "user.*";
String routingKey = "user.*";
// 1 声明交换机
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
// 2 声明队列
channel.queueDeclare(queueName, false, false, false, null);
// 3 建立交换机和队列的绑定关系:
channel.queueBind(queueName, exchangeName, routingKey);
// durable 是否持久化消息
QueueingConsumer consumer = new QueueingConsumer(channel);
// 参数：队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, true, consumer);
// 循环获取消息
while (true) {
// 获取消息，如果没有消息，这一步将会一直阻塞
Delivery delivery = consumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println(queueName + " 收到消息：" + msg);
}
}
}
消费者输出：
test_topic_queue 收到消息：Hello World RabbitMQ 4 Topic Exchange Message …0
test_topic_queue 收到消息：Hello World RabbitMQ 4 Topic Exchange Message …1
test_topic_queue 收到消息：Hello World RabbitMQ 4 Topic Exchange Message …2
test_topic_queue 收到消息：Hello World RabbitMQ 4 Topic Exchange Message …3
test_topic_queue 收到消息：Hello World RabbitMQ 4 Topic Exchange Message …4
** 经测试结果总结 **
如再起一个相同queue名称的消费：RabbitMQ会轮询方式消费，一条消息只有一个queue收到
如Copy上面的消费端代码，只修改String queueName = “test_topic_queue_2”;：RabbitMQ广播模式，1条消息,n个消费者都收到
大白话：
1生产者，n消费者(queue名相同) -> 轮询方式，一条消息只有一个queue收到
1生产者，n消费者(queue名不相同) -> 广播方式，1条消息,n个都收到