rabbitmq（适合初学者）
rabbitmq
rabbitmq安装
本教程安装环境centos7
安装版本3.8.9
github 地址：https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.8.9
erlang环境推荐下载地址：https://www.erlang-solutions.com/resources/download.html
因为rabbitmq依赖erlang语言版本很强，所以 erlang语言 23版本
安装erlang和rabbitmq
#erlang语言安装
rpm -ivh esl-erlang_23.2.1-1_centos_7_amd64.rpm
#rabbitmq安装
rpm -ivh rabbitmq-server-3.8.9-1.el6.noarch.rpm
#因为erlang语言环境可能会依赖一些内部环境，所以需要配置安装
#启动rabbitmq ： service rabbitmq-server start
#开启可视化界面 ： rabbitmq-plugins enable rabbitmq_management
启动
在web浏览器中输入地址：http://127.0.0.1:15672
输入默认账号: guest 密码: guest
解决客户端不能登录问题：（User can only log in via localhost） 针对最新版
1.环境变量可用于覆盖配置文件的位置：（官方推荐）
# overrides primary config file location
RABBITMQ_CONFIG_FILE=/path/to/a/custom/location/rabbitmq.conf
# overrides advanced config file location
RABBITMQ_ADVANCED_CONFIG_FILE=/path/to/a/custom/location/advanced.config
# overrides environment variable file location
RABBITMQ_CONF_ENV_FILE=/path/to/a/custom/location/rabbitmq-env.conf
rabbitmq.conf 样式地址：https://github.com/rabbitmq/rabbitmq-server/blob/v3.8.x/deps/rabbit/docs/rabbitmq.conf.example
1.在/etc/rabbitmq/目录下创建文件 rabbitmq.conf
2.编辑
## The default "guest" user is only permitted to access the server
## via a loopback interface (e.g. localhost).
## {loopback_users, [<<"guest">>]},
##
# loopback_users.guest = true
## Uncomment the following line if you want to allow access to the
## guest user from anywhere on the network.
loopback_users.guest = false
#重启即可访问
rabbitmq后台管理界面
1.添加虚拟主机
2.添加账户
3.账户设置虚拟主机
RabbitMQ模型
1. 直连
在本教程的这一部分中，我们将在 Java 中编写两个程序;发送单个消息的生产者，以及接收消息并打印出消息的使用者。我们将介绍Java API中的一些细节，专注于这个非常简单的事情，只是为了开始。这是一个"Hello World"的消息。
在下面的图中，"P"是我们的生产者，"C"是我们的消费者。中间的框是一个队列 - RabbitMQ 代表使用者保留的消息缓冲区。
（1) 整合spring依赖
<dependency>
<groupId>com.rabbitmqgroupId>
<artifactId>amqp-clientartifactId>
<version>5.7.2version>
dependency>
生产者
/**
* 生产者
* @throws IOException
* @throws TimeoutException
*/
@Test
void provider() throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
//通道绑定对应的消息队列
/*
* 参数1：队列名称， 如果队列不存在就自动创建
* 参数2：用来定义队列特性是否持久化 true 持久队列，false 不持久队列
* 参数3：exclusive 是否独占队列 true独占队列 false 不独占队列
* 参数4：autoDelete 是否在消费完成后自动删除队列，true 自动删除 false 不自动删除
* 参数5：arguments 附加参数
* */
channel.queueDeclare("hello", false, false, false, null);
//发布消息
/*
* 参数1： 交换机名称
* 参数2： 队列名称
* 参数3： 传递消息额外设置 MessageProperties.PERSISTENT_TEXT_PLAIN 消息持久化
* 参数4： 消息具体内容
* */
channel.basicPublish("", "hello", null, "hello rabbitmq".getBytes());
channel.close();
connection.close();
}
消费者
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/test");
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//创建连接对象
Connection connection = connectionFactory.newConnection();
//创建通道
Channel channel = connection.createChannel();
//通道绑定对象
channel.queueDeclare("hello", false, false, false, null);
//消费消息
/*
* 参数1： 消费那个对象的消息
* 参数2： 开始消息的自动确认机制
* 参数3： 消费时回调接口
* */
channel.basicConsume("hello", true, new DefaultConsumer(channel) {
/**
*
* @param consumerTag
* @param envelope
* @param properties
* @param body 消息队列中取出的消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消息: " + new String(body));
}
});
}
2. Work queues工作队列 （task queues）
在第一个教程中，我们编写了从命名队列发送和接收消息的程序。在本例中，我们将创建一个工作队列，用于在多个工作人员之间分配耗时的任务。
工作队列（又名：任务队列）的主要思想是避免立即执行资源密集型任务，并且必须等待任务完成。相反，我们把任务安排在以后完成。我们将任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行该作业。当您运行多个worker时，任务将在他们之间共享。
这个概念在web应用程序中特别有用，因为在短的HTTP请求窗口期间无法处理复杂的任务。
p：生产者 中间：消息队列 C：消费者
生产者
package com.nf.rabbitmq.work;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 生产者
*/
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
channel.queueDeclare("work", false, false, false, null);
for (int i = 0; i < 10; i++) {
channel.basicPublish("", "work", null, ("hello World ------------" + i).getBytes());
}
//关闭流
channel.close();
//关闭连接
connection.close();
}
}
消费者1
package com.nf.rabbitmq.work;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 第一个消费者
*/
public class Customer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
channel.queueDeclare("work", false, false, false, null);
channel.basicConsume("work", 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));
}
});
}
}
消费者2
package com.nf.rabbitmq.work;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 第二个消费者
*/
public class Customer2 {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
channel.queueDeclare("work", false, false, false, null);
channel.basicConsume("work", true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者2：" + new String(body));
}
});
}
}
演示结果：
消费者1：
消费者2：
注意：消息队列中默认情况是平均分配：即如上图所示，生产者将消息推送到队列中后，消费者1和消费者2平均消费，且消息自动确认为true（消费者自动向消息队列自动确认了消息）
让消息队列“能者多劳”：
结果：
Publish/Subscribe （发布订阅模式、广播）
在广播模式下，消息发送流程：
- 可以有多个消费者
- 每个消费者拥有自己的queue（队列）
- 每个队列都要绑定到Exchange（交换机）
- 生产者发送的消息，只能发送到交换机，交换机来决定发送给那个队列，生产者无法决定
- 交换机把消息发动给绑定过得所有队列
- 队列的消费者都能拿到消息，实现一条消息被多个消费者消费
生产者把消息发送给交换机 -> 交换机把消息发送给队列
生产者：
package com.nf.rabbitmq.fanout;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 生产者
*/
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
/*
* 参数1： 交换机的名称
* 参数2： 交换机类型 ，广播类型：fanout
*
* */
channel.exchangeDeclare("log", "fanout");
/*
* 参数1：指定的交换机
* 参数2：
* 参数3：
*
*
* */
channel.basicPublish("logs", "", null, "我是生产者 ，我在发消息".getBytes());
//关闭流
channel.close();
//关闭连接
connection.close();
}
}
消费者1
package com.nf.rabbitmq.fanout;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者1
*/
public class Customer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
//通到绑定交换机
channel.exchangeDeclare("logs", "fanout");
String queueName = channel.queueDeclare().getQueue();
channel.queueBind(queueName, "logs", "");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者1：" + new String(body));
}
});
}
}
消费者2
package com.nf.rabbitmq.fanout;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者1
*/
public class Customer2 {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接mq的连接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();
//设置连接rabbitmq主机
connectionFactory.setHost("192.168.128.144");
//设置端口号
connectionFactory.setPort(5672);
//设置虚拟主机
connectionFactory.setVirtualHost("/test");
//设置用户名和密码
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
//获取连接对象
Connection connection = connectionFactory.newConnection();
//获取连接中的通道
Channel channel = connection.createChannel();
//通到绑定交换机
channel.exchangeDeclare("logs", "fanout");
String queueName = channel.queueDeclare().getQueue();
channel.queueBind(queueName, "logs", "");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者2：" + new String(body));
}
});
}
}
结果
Routing（路由选择）
在上一个教程中，我们构建了一个简单的日志记录系统。我们可以向许多接收器广播日志信息。
在本教程中，我们将向它添加一个特性-我们将使它能够只订阅消息的一个子集。例如，我们将只能将关键错误消息定向到日志文件（以节省磁盘空间），同时仍然能够在控制台上打印所有日志消息。
生产者（产生日志）生产不同的日志，如error，info，debug，warn，fatal，让不同消费者来消费处理这些消息
生产者：
package com.nf.rabbitmq.routing;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者，只消费error
*/
public class Customer1 {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/test");
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
Connection connection = connectionFactory.newConnection();
//创建连接通道
Channel channel = connection.createChannel();
//通道声明交换机
channel.exchangeDeclare("logs_direct", "direct");
//创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
//基于route key绑定队列和交换机
channel.queueBind(queueName, "logs_direct", "error");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者1：" + new String(body));
}
});
}
}
消费者1：
package com.nf.rabbitmq.routing;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者，只消费error
*/
public class Customer1 {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/test");
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
Connection connection = connectionFactory.newConnection();
//创建连接通道
Channel channel = connection.createChannel();
//通道声明交换机
channel.exchangeDeclare("logs_direct", "direct");
//创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
//基于route key绑定队列和交换机
channel.queueBind(queueName, "logs_direct", "error");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者1：" + new String(body));
}
});
}
}
消费者2
package com.nf.rabbitmq.routing;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者，只消费info error
*/
public class Customer2 {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/test");
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
Connection connection = connectionFactory.newConnection();
//创建连接通道
Channel channel = connection.createChannel();
//通道声明交换机
channel.exchangeDeclare("logs_direct", "direct");
//创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
//基于route key绑定队列和交换机
channel.queueBind(queueName, "logs_direct", "error");
channel.queueBind(queueName, "logs_direct", "info");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
/**
* No-op implementation of {@link Consumer#handleDelivery}.
*
* @param consumerTag
* @param envelope
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者2：" + new String(body));
}
});
}
}
结果 ：
消费者1
消费者2：
Topics
topic类型的Exchange与Direct相比，都可以根据RoutingKey把消息路由到不同的队列，只不过Topic类型Exchange可以让队列在绑定Routing key的时候使用通配符！这种模型Routingkey一般都是有一个或者多个单词组成，多个单词之间以“.”分割，例如： item.insert
#:占位多个
*:只能占位一个
生产者：
package com.nf.rabbitmq.topics;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class producer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
connectionFactory.setVirtualHost("/test");
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
/*
* 参数1:交换机名称 参数2：类型
*
* */
channel.exchangeDeclare("topics", "topic");
/*
* 参数1：交换机名称
* 参数2：路由key
* 参数3：保留
* 参数4：发送的消息
*
* */
channel.basicPublish("topics", "user.save", null, ("我是生产者，我在生产消息： user.save").getBytes());
channel.basicPublish("topics", "user.save.delete", null, ("我是生产者，我在生产消息： user.save.delete").getBytes());
channel.basicPublish("topics", "person.user.save", null, ("我是生产者，我在生产消息： person.user.save").getBytes());
channel.basicPublish("topics", "user", null, ("我是生产者，我在生产消息： user").getBytes());
channel.close();
connection.close();
}
}
消费者1：
package com.nf.rabbitmq.topics;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者，只消费info error
*/
public class Customer1 {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/test");
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
Connection connection = connectionFactory.newConnection();
//创建连接通道
Channel channel = connection.createChannel();
//通道声明交换机
channel.exchangeDeclare("topics", "topic");
//创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
//绑定队列和交换机，动态通配符形式route key
channel.queueBind(queueName, "topics", "user.*");
channel.basicConsume(queueName, 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));
}
});
}
}
消费者2：
package com.nf.rabbitmq.topics;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 消费者，只消费info error
*/
public class Customer2 {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/test");
connectionFactory.setHost("192.168.128.144");
connectionFactory.setPort(5672);
connectionFactory.setUsername("nf");
connectionFactory.setPassword("123456");
Connection connection = connectionFactory.newConnection();
//创建连接通道
Channel channel = connection.createChannel();
//通道声明交换机
channel.exchangeDeclare("topics", "topic");
//创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
//绑定队列和交换机，动态通配符形式route key
channel.queueBind(queueName, "topics", "user.#");
channel.basicConsume(queueName, 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));
}
});
}
}
结果：
消费者1
消费者2
rabbit整合springboot
依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-amqpartifactId>
dependency>
配置文件
spring:
rabbitmq:
host: 192.168.16.132
port: 5672
username: nf
password: 123456
virtual-host: /test
直连
package com.nf.rabbitmq.hello;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component //默认 持久化 非独占 不是自动删除
@RabbitListener(queuesToDeclare = @Queue(value = "hello",durable = "false",autoDelete = "true"))
public class HelloCustomer {
@RabbitHandler
public void test(String message) {
System.out.println(message);
}
}
word queues 工作队列
package com.nf.rabbitmq.hello;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class WorkCustomer {
@RabbitListener(queuesToDeclare = @Queue("work"))
public void test1(String message) {
System.out.println("消费者1：" + message);
}
@RabbitListener(queuesToDeclare = @Queue("work"))
public void test2(String message) {
System.out.println("消费者2：" + message);
}
}
Publish/Subscribe （发布订阅模式、广播）**
package com.nf.rabbitmq.hello;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 广播 fanout
* Publish/Subscribe
*/
@Component
public class FanoutCustomer {
@RabbitListener(bindings = {
@QueueBinding(value = @Queue, //创建临时队列
exchange = @Exchange( //绑定交换机
value = "logs",
type = "fanout"
))
})
public void test1(String message) {
System.out.println("消费者1：" + message);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue,
exchange = @Exchange(
value = "logs",
type = ExchangeTypes.FANOUT
))
})
public void test2(String message) {
System.out.println("消费者2：" + message);
}
}
Routing（路由选择）
package com.nf.rabbitmq.hello;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
@Component
public class RouteCustomer {
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue,
exchange = @Exchange(value = "directs", type = ExchangeTypes.DIRECT),//自定义交换名称和类型
key = {
"info", "error", "warn"
}
)
})
public void test1(String message) {
System.out.println("消费者1：" + message);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue,
exchange = @Exchange(value = "directs", type = ExchangeTypes.DIRECT),//自定义交换名称和类型
key = {
"info",
}
)
})
public void test2(String message) {
System.out.println("消费者2：" + message);
}
}
Topics
**
package com.nf.rabbitmq.hello;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class TopicCustomer {
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue,
exchange = @Exchange(
name = "topics",
type = ExchangeTypes.TOPIC),
key = {
"user.save", "user.*"})
})
public void test1(String message) {
System.out.println("消费者1： " + message);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue,
exchange = @Exchange(
name = "topics",
type = ExchangeTypes.TOPIC),
key = {
"user.#"})
})
public void test2(String message) {
System.out.println("消费者2： " + message);
}
}
测试
package com.nf.rabbitmq;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(classes = RabbitmqApplication.class)
class RabbitmqApplicationTests {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
void hello() {
rabbitTemplate.convertAndSend("hello", "hello world");
}
/**
* 工作队列
*/
@Test
void work() {
for (int i = 0; i < 10; i++) {
rabbitTemplate.convertAndSend("work", "hello world + :" + i);
}
}
/**
* 广播 fanout
* Publish/Subscribe
*/
@Test
public void fanout() {
for (int i = 0; i < 10; i++) {
rabbitTemplate.convertAndSend("logs", "", "fanout");
}
}
/**
* 路由模式
*/
@Test
public void routeDirects() {
rabbitTemplate.convertAndSend("directs", "info", "发送的 info信息");
rabbitTemplate.convertAndSend("directs", "error", "发送的 error信息");
}
/**
* 动态路由
*/
@Test
public void topicRoute() {
rabbitTemplate.convertAndSend("topics", "user.save", "发送的 user.save 信息");
rabbitTemplate.convertAndSend("topics", "user.save.delete", "发送的 user.save.delete 信息");
rabbitTemplate.convertAndSend("topics", "user.delete", "发送的 user.delete 信息");
}
}
总结
rabbitmq一些配置问题
rabbitmq除了可以手动创建队列，交换机，还有两种创建方式，一种是配置类的方式，另一种是注解的方式
1.配置类方式
package com.nf.rabbitmq.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* RabbitMQ配置类
*/
@Configuration
public class RabbitMQConfig {
//交换机名称
public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";
//队列名称
public static final String ITEM_QUEUE = "item_queue";
//声明交换机
@Bean("itemTopicExchange")
public Exchange topicExchange() {
return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
}
//声明队列
@Bean("itemQueue")
public Queue itemQueue() {
return QueueBuilder.durable(ITEM_QUEUE ).build();
}
//绑定队列和交换机
@Bean
public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue,
@Qualifier("itemTopicExchange") Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("item1.#").noargs();
}
//声明队列
@Bean("itemQueue2")
public Queue itemQueue2() {
return QueueBuilder.durable(ITEM_QUEUE+ 2).build();
}
/*
* 绑定队列和交换机,"BindingBuilder.bind(queue).to(exchange).with("item2.#").noargs()"含义是将queue绑定到exchange交换机上 ，并且路由的方式为with("item2.#")
*/
@Bean
public Binding itemQueueExchange2(@Qualifier("itemQueue") Queue queue,
@Qualifier("itemTopicExchange") Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("item2.#").noargs();
}
}
2.注解方式
package com.nf.rabbitmq.config;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 消费者监听类
*/
@Component
public class MyListner {
// @RabbitListener(queues = "item_queue")
@RabbitListener(
bindings =
{
@QueueBinding(value = @Queue("item_queue"),
exchange = @Exchange(value = "item_topic_exchange", type = ExchangeTypes.TOPIC),key = {
"item1.#"})
})
public void msg(String msg) {
System.out.println("消费者消费消息了：" + msg);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue("item_queue2"),
exchange = @Exchange(value = "item_topic_exchange", type = ExchangeTypes.TOPIC),
key = {
"item2.#"}
)}
)
public void msg2(String msg) {
System.out.println("消费者消费消息了2：" + msg);
}
}