MQ（消息队列）的安装和简单使用
MQ的安装和使用
- 1、RabbitMQ的下载和安装
- 1.1 安装erlang语言
- 1.2 安装RabbitMQ
- 2、RabbitMQ操做java的helloworld的使用
- 2.1 导包
- 2.1 普通使用
- 2.2三种订阅模型
- 2.2.1 广播模式（FANOUT）
- 2.2.2 定向模式（Direct）
- 2.2.3 通配符模式（Topics）
- 3、集成springboot的简单使用
概念
1、MQ(消息队列)，遵循先进先出的原则
2、提高系统稳定性,操作内容放到消息队列，能有效避免访问服务压力大，导致服务挂掉到的问题
3、解耦：mq也是相当于一个中介，和redis类似，生产方通过MQ与消费方交互，它将应用程序进行解耦合。
执行流程：
用户访问服务时，他会先通过交换器来访问指定的MQ（队列），然后用户会得到一个反馈（类似于排队等待时反馈的消息：您的请求正在处理），然后队列会把这个请求给服务，等到服务处理完成后，队列就会在返回处理完请求的消息给用户。
1、RabbitMQ的下载和安装
1.1 安装erlang语言
RabbitMQ由Erlang语言开发，使用RabbitMQ前提是要安装Erlang。
注意：本人使用的是 Erlang/OTP 20.3版本和RabbitMQ3.7.3版本
下载地址：
http://erlang.org/download/otp_win64_20.3.exe
erlang安装完成需要配置erlang环境变量：
-
ERLANG_HOME（环境变量名）=D:\Program Files\erl9.3（安装的路径）
-
然后在path中添 加 %ERLANG_HOME%\bin
1.2 安装RabbitMQ
安装后
1）运行服务
rabbitmq-service.bat install 安装服务
rabbitmq-service.bat stop 停止服务
rabbitmq-service.bat start 启动服务
2）安装管理插件 安装rabbitMQ的管理插件，方便在浏览器端管理RabbitMQ ；这个目录下
管理员身份运行cmd，然后执行 rabbitmq-plugins.bat enable rabbitmq_management
重新启动
3、启动成功 登录RabbitMQ
进入浏览器，输入：http://localhost:15672
初始账号和密码：guest/guest
2、RabbitMQ操做java的helloworld的使用
2.1 导包
<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<!--和springboot2.0.5对应-->
<version>5.4.1</version>
</dependency>
工具类
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class ConnectionUtil {
/**
* 建立与RabbitMQ的连接
* @return
* @throws Exception
*/
public static Connection getConnection() throws Exception {
//定义连接工厂
ConnectionFactory factory = new ConnectionFactory();
//设置服务地址
factory.setHost("127.0.0.1");
//端口
factory.setPort(5672); //java端的端口
//设置账号信息，用户名、密码、vhost
factory.setVirtualHost("/");
factory.setUsername("guest");
factory.setPassword("guest");
// 通过工程获取连接
Connection connection = factory.newConnection();
return connection;
}
}
2.1 普通使用
生产者（用户）
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer01 {
//队列名称
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = null;
Channel channel = null;
try {
//获取连接
connection = ConnectionUtil.getConnection();
//创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
channel = connection.createChannel();
/**
* 声明队列，如果Rabbit中没有此队列将自动创建
* param1:队列名称
* param2:是否持久化
* param3:队列是否独占此连接
* param4:队列不再使用时是否自动删除此队列
* param5:队列参数
*/
channel.queueDeclare(QUEUE, true, false, false, null);
//发送的消息
String message = "helloworld小明" + System.currentTimeMillis();
/**
* 消息发布方法
* param1：Exchange的名称，如果没有指定，则使用Default Exchange
* param2:routingKey,消息的路由Key，是用于Exchange（交换机）将消息转发到指定的消息队列
* param3:消息包含的属性
* param4：消息体
*/
/**
* 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显
示绑定或解除绑定
* 默认的交换机，routingKey等于队列名称
*/
channel.basicPublish("", QUEUE, null, message.getBytes());
System.out.println("Send Message is:'" + message + "'");
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
}
消费者（服务1）
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer01 {
//从这个消息队列名里面去获取
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
//建立通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE, true, false, false, null);
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，让有延迟的处理完这个后才处理一下个消息）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(QUEUE, false, consumer);
}
}
消费者（服务2）
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer02 {
//从这个消息队列名里面去获取
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE, true, false, false, null);
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，不会让消息都堵在有延迟的里面）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
// int i = 1/0;
//模仿网络延迟
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(QUEUE, false, consumer);
}
}
2.2三种订阅模型
2.2.1 广播模式（FANOUT）
广播适合用来做群发短信等等（只要上头一发消息，下面的人就能收到一样的消息）
- 生产者（发送消息的一方）
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
/**
* 广播适合用来做群发短信等等（只要上头一发消息，下面的人就能收到一样的消息）
*/
public class Producer01 {
//交换机的名字（消费者根据交换机的名称来绑定队列（MQ））
public static final String NAME_EXCHANGE_FANOUT = "name_exchange_fanout";
public static void main(String[] args) throws Exception {
//获取连接
Connection connection = ConnectionUtil.getConnection();
//创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
Channel channel = connection.createChannel();
/*
创建交换机
参数一：交换机名
参数二：交换机类型（广播类型）
*/
channel.exchangeDeclare(NAME_EXCHANGE_FANOUT, BuiltinExchangeType.FANOUT);
//发送的消息
String message = "helloworld小明" + System.currentTimeMillis();
channel.basicPublish(NAME_EXCHANGE_FANOUT, "", null, message.getBytes());
System.out.println("Send Message is:'" + message + "'");
}
}
- 消费者1
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer01 {
//从这个消息队列名里面去获取
private static final String NAME_QUEUE1_FANOUT = "name_queue1_fanout";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
//建立通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(NAME_QUEUE1_FANOUT, true, false, false, null);
//广播的核心
//将队列绑定到交换机（消息发布的时候，队列直接从交换机里面去获取）
channel.queueBind(NAME_QUEUE1_FANOUT, Producer01.NAME_EXCHANGE_FANOUT, "");
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，让有延迟的处理完这个后才处理一下个消息）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(NAME_QUEUE1_FANOUT, false, consumer);
}
}
- 消费者2
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer02 {
//消费者的队列（到时候根据这个队列到交换机里面去获取）
private static final String NAME_QEUEUE2_FANOUT = "name_qeueue2_fanout";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
//建立通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(NAME_QEUEUE2_FANOUT, true, false, false, null);
//广播的核心
//将队列绑定到交换机（消息发布的时候，队列直接从交换机里面去获取）
channel.queueBind(NAME_QEUEUE2_FANOUT, Producer01.NAME_EXCHANGE_FANOUT, "");
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，让有延迟的处理完这个后才处理一下个消息）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(NAME_QEUEUE2_FANOUT, false, consumer);
}
}
2.2.2 定向模式（Direct）
定向模式，将消息发布给指定的消费者（1或n个）
-
生成者发布一个消息给交换机（给交换机时会指定一个路由的名称，到时候交换机就会根据这个路由的名称去匹配合适的队列），
生产者
/**
* 定向模式，将消息发布给指定的消费者（1或n个）
* 生成者发布一个消息给交换机（给交换机时会指定一个路由的名称，到时候交换机就会根据这个路由的名称去匹配合适的队列），
*/
public class Producer01 {
//交换机名称
public static final String EXCHANGE_NAME_direct = "direct_exchange_test";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = null;
Channel channel = null;
try {
//获取连接
connection = ConnectionUtil.getConnection();
//创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
channel = connection.createChannel();
//指定交换接的类型（定向类型）
channel.exchangeDeclare(EXCHANGE_NAME_direct, BuiltinExchangeType.DIRECT);
//发送的消息
String message = "helloworld小明" + System.currentTimeMillis();
channel.basicPublish(EXCHANGE_NAME_direct,"query" , null, message.getBytes());
System.out.println("Send Message is:'" + message + "'");
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
}
消费者1
public class Consumer01 {
//消息队列名
private static final String NAME_QUEUE1_DIRECT = "name_queue1_direct";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
//建立通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(NAME_QUEUE1_DIRECT, true, false, false, null);
//定向的核心
// 绑定队列到交换机，同时指定需要订阅的routing key（路由）。假设此处需要update和delete消息（接收两种路由的消息）
channel.queueBind(NAME_QUEUE1_DIRECT,Producer01.EXCHANGE_NAME_direct , "insert");
channel.queueBind(NAME_QUEUE1_DIRECT,Producer01.EXCHANGE_NAME_direct , "update");
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，让有延迟的处理完这个后才处理一下个消息）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(NAME_QUEUE1_DIRECT, false, consumer);
}
}
消费者2
public class Consumer02 {
//消息队列名
private static final String NAME_QUEUE2_DIRECT = "name_queue2_direct";
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
//建立通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(NAME_QUEUE2_DIRECT, true, false, false, null);
//定向的核心（到时候直接从交换机里面去获取值到队列里面，但要根据路由名）
// 绑定队列到交换机，同时指定需要订阅的routing key（路由）。假设此处需要update和delete消息（接收两种路由的消息）
channel.queueBind(NAME_QUEUE2_DIRECT,Producer01.EXCHANGE_NAME_direct , "insert");
channel.queueBind(NAME_QUEUE2_DIRECT,Producer01.EXCHANGE_NAME_direct , "update");
channel.queueBind(NAME_QUEUE2_DIRECT,Producer01.EXCHANGE_NAME_direct , "query");
//让这个一次只能处理（接收）一条信息（能者多劳，实现另一个消费者网络有问题时，下一次就这个来处理，让有延迟的处理完这个后才处理一下个消息）
channel.basicQos(1);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
(收到消息失败后是否需要重新发送)
* @param properties
* @param body
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String msg = new String(body, "utf8");
System.out.println("receive message.." + msg);
//手动签收消息
//参数一：消息id 参数二：是否消费完全部后才签收（false：表示消费完一单后就签收）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
/**
* 监听队列String queue, boolean autoAck,Consumer callback
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(NAME_QUEUE2_DIRECT, false, consumer);
}
}
2.2.3 通配符模式（Topics）
通配符模式（和定向模式一样，都是发送到指定的routingKey（路由）里面，但是这个消费者可以使用*来匹配）
修改生产方的模式
//指定交换机的模式（通配符）
channel.exchangeDeclare(EXCHANGE_NAME_TOPIC, BuiltinExchangeType.TOPIC);
消费方指定通配符
//通配符的核心
// 将队列绑定到交换机，同时指定需要订阅的routing key（路由）。假设此处需要update和delete消息（接收两种路由的消息）
//只要前缀匹配上，后面的都接收
channel.queueBind(NAME_QUEUE2_TOPIC,Producer01.EXCHANGE_NAME_TOPIC , "item.*");
3、集成springboot的简单使用
.SpringBoot集成RabbitMQ
1.创建项目
2.导入依赖： mq的包 ，测试包
<!--1.SpringBoot的父工程-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.5.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!--spirngboot集成rabbitmq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
</dependencies>
3.创建主配置类
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class,args);
}
}
4.创建MQ的配置类（步骤）
-
4.1.创建交换机
-
4.2.创建队列
-
4.3.队列绑定到交换机
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitmqConfig {
//队列名称（邮件）
public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
//队列名称（sms）
public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
//交换机的名称
public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
/**
1.创建交换机
* 配置交换机的bean
*
* 交换机配置
* ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
*
* @return the exchange
*/
@Bean(EXCHANGE_TOPICS_INFORM) //这个交换机配置的bean的名称（方便下面队列绑定的时候来调用）
public Exchange EXCHANGE_TOPICS_INFORM() {
//durable(true)持久化，消息队列重启后交换机仍然存在
return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
}
//------------------4.2.创建队列--------
//声明队列（配置队列）
@Bean(QUEUE_INFORM_SMS)
public Queue QUEUE_INFORM_SMS() {
Queue queue = new Queue(QUEUE_INFORM_SMS);
return queue;
}
//声明队列
@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL() {
Queue queue = new Queue(QUEUE_INFORM_EMAIL);
return queue;
}
//--------------end-----------
//--------------4.2.创建队列-----------
/**
* channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#");
* 绑定队列到交换机 .
*
* @param queue the queue
* @param exchange the exchange
* @return the binding
*/
//绑定sms的 @Qualifier(QUEUE_INFORM_SMS) Queue queue：将上面的bean的队列名绑定到这里
@Bean
public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("sms.*").noargs();
}
//绑定邮件的
@Bean
public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("email.*").noargs();
}
}
5.发送消息 : 用的是SpringBootTest
- rabbitTemplate.convertAndSend
/**
* 生产方（发送消息的一方）
*/
@SpringBootTest(classes = App.class)
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot {
@Autowired
RabbitTemplate rabbitTemplate;
@Test
public void testSendByTopics() {
for (int i = 0; i < 5; i++) {
String message = "sms email inform to user" + i;
rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM, "sms.email", message);
System.out.println("Send Message is:'" + message + "'");
}
}
}
6.接受消息 :
- 6.1.创建一个类打@Compoent
- 6.2.创建方法，通过@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})监听消息
7.手动签收
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.io.IOException;
/**
* 消费方（接收消息的一方）
*/
@Component
public class ReceiveHandler {
//监听email队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
public void receive_email(String msg, Message message, Channel channel) throws IOException {
System.out.println(msg);
//手动签收
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
//监听sms队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
public void receive_sms(String msg, Message message, Channel channel) throws IOException {
System.out.println(msg);
//手动签收
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
}
- 7.1.开启手动签收
Srping:
rabbitmq
listener:
simple:
acknowledge-mode: manual #手动签收
7.2.触发手动签收
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);