1. 正文–rabbitMQ–消息中间件
1. 什么MQ?
2. MQ的优缺点
3. 常见的MQ有哪些?
4. 什么是rabbitMQ?
5. RabbitMQ的结构?
6. RabbitMQ的安装?
7. RabbitMQ的五种模式?
(1)简单模式
(2)工作者模式:
(3)发布订阅模式
(4)路由模式
(5)topic主体模式。
8. Springboot整合rabbitMQ
2.什么MQ?
MQ全称 Message Queue(消息队列),是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。
3. MQ的优缺点
优点:
应用解耦:提高系统容错性和可维护性
异步提速:提升用户体验和系统吞吐量
削峰填谷:提高系统稳定性
缺点:
系统可用性降低
系统引入的外部依赖越多,系统稳定性越差。一旦 MQ 宕机,就会对业务造成影响。如何保证MQ的高可用?
系统复杂度提高
MQ 的加入大大增加了系统的复杂度,以前系统间是同步的远程调用,现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费?怎么处理消息丢失情况?那么保证消息传递的顺序性?
一致性问题
A 系统处理完业务,通过 MQ 给B、C、D三个系统发消息数据,如果 B 系统、C 系统处理成功,D 系统处理失败。如何保证消息数据处理的一致性?
4. 常见的MQ有哪些?
5. 安装rabbitMQ
1. 上传安装软件(1.erlang 2.rabbitmq)
2. 安装rabbitmq依赖的环境
yum install -y gcc socat openssl openssl-devel
3. 安装erlang 和 rabbitMQ
rpm -ivh erlang-22.0.7-1.el7.x86_64.rpm
rpm -ivh rabbitmq-server-3.7.17-1.el7.noarch.rpm
4. 开启管理界面及配置 ---理解为图形化界面
rabbitmq-plugins enable rabbitmq_management
开设一个用户用来访问rabbitMQ
进入rabbitMQ的配置目录
cd /usr/share/doc/rabbitmq-server-3.7.17
cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config
5. 开启rabbitMQ服务器。
systemctl start rabbitmq-server
6. systemctl restart rabbitmq-server 重启
6. rabbitMQ的结构以及每个组件的作用
Broker:接收和分发消息的应用,RabbitMQ Server就是 Message Broker
Virtual host:出于多租户和安全因素设计的,把 AMQP 的基本组件划分到一个虚拟的分组中,类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时,可以划分出多个vhost,每个用户在自己的 vhost 创建 exchange/queue 等
Connection:publisher/consumer 和 broker 之间的 TCP 连接
Channel:如果每一次访问 RabbitMQ 都建立一个 Connection,在消息量大的时候建立 TCP Connection的开销将是巨大的,效率也较低。Channel 是在 connection 内部建立的逻辑连接,如果应用程序支持多线程,通常每个thread创建单独的 channel 进行通讯,AMQP method 包含了channel id 帮助客户端和message broker 识别 channel,所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
Exchange:message 到达 broker 的第一站,根据分发规则,匹配查询表中的 routing key,分发消息到queue 中去。常用的类型有:direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
Queue:消息最终被送到这里等待 consumer 取走
Binding:exchange 和 queue 之间的虚拟连接,binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中,用于 message 的分发依据
7. rabbitMQ的模式
(1)简单模式
从图上可以看到只有三个角色:
p 【product】: 生产者 发生消息的
红色[queue]: 队列。 存储消息的
C [consumer]: 消费者 消费消息
生产者的代码:
package com.kh;
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 hello {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//创建队列
/**
* String queue,队列的名称
* boolean durable,是否持久化 rabbitMQ服务器重启以后该存放是否还存在
* boolean exclusive,是否独占false
* boolean autoDelete,是否自动删除(如果长时间没有发送消息 则自动删除)
* Map<String, Object> arguments 额外参数 先给null
*/
try {
channel.queueDeclare("kh_queue",true,false,false,null);
} catch (IOException e) {
e.printStackTrace();
}
//发送信息
/**
* String exchange,交换机的名称 如果没有就选择"" 它会自动选择默认
* String routingKey,路由key 如果没有交换机的绑定 使用队列的名称
* BasicProperties props,消息的一些额外配置 目前先不加 null
* byte[] body 消息的内容
*/
String msg="孔昊加油!!";
try {
channel.basicPublish("","kh_queue",null,msg.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
消费者代码:
package com.kh.hello;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接收信息
/**
* String consumerTag,消费者标签
* Envelope envelope, 信封
* AMQP.BasicProperties properties,
* byte[] body
*/
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body: 接受的信息
System.out.println("消息的内容:"+new String(body));
}
};
/*
* String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数
*/
try {
channel.basicConsume("kh_queue",true,callback);
} catch (IOException e) {
e.printStackTrace();
}
}
}
(2)工作者模式
特点:
1. 一个生产者
2. 由多个消费。
3. 统一个队列。
4. 这些消费者之间存在竞争关系。
用处:
比如批量处理上. rabbitMQ里面积压了大量的消息。
生产者
package com.kh;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
public class work {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//创建队列
/**
* String queue, 队列的名称
* boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
* boolean exclusive, 是否独占 false
* boolean autoDelete, 是否自动删除 如果长时间没有发生消息 则自动删除
* Map<String, Object> arguments 额外参数 先给null
*/
try {
channel.queueDeclare("kh_queue_work",true,false,false,null);
} catch (IOException e) {
e.printStackTrace();
}
//发送消息
/**
* String exchange,
* String routingKey,
* BasicProperties props,
* byte[] body
*/
try {
for (int i = 1; i < 10; i++) {
String msg="陈星霓szz!!!"+i;
channel.basicPublish("","kh_queue_work",null,msg.getBytes());
}
} catch (IOException e) {
e.printStackTrace();
}
//生产者这里可以管理资源 消费者不能关闭资源。
try {
channel.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
消费者01:
package com.kh.work;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer01 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接收消息
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者01:"+new String(body));
}
};
try {
channel.basicConsume("kh_queue_work",true,callback);
} catch (Exception e) {
e.printStackTrace();
}
}
}
消费者02:
package com.kh.work;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer02 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接收消息
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("消费者02:"+new String(body));
}
};
try {
channel.basicConsume("kh_queue_work",true,callback);
} catch (Exception e) {
e.printStackTrace();
}
}
}
(3) 发布订阅模式
1. 特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机 转发消息。
生产者:
package com.kh;
import com.rabbitmq.client.BuiltinExchangeType;
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 fanout {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//创建队列
/**
* String queue, 队列的名称
* boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
* boolean exclusive, 是否独占 false
* boolean autoDelete, 是否自动删除 如果长时间没有发生消息 则自动删除
* Map<String, Object> arguments 额外参数 先给null
*/
try {
channel.queueDeclare("kh_queue_fanout01",true,false,false,null);
channel.queueDeclare("kh_queue_fanout02",true,false,false,null);
} catch (Exception e) {
e.printStackTrace();
}
//创建交换机
/**
* String exchange,交换机的名称
* BuiltinExchangeType type, 交换机的类型
* boolean durable:是否持久化
*/
try {
channel.exchangeDeclare("kh_exchange", BuiltinExchangeType.FANOUT,true);
} catch (Exception e) {
e.printStackTrace();
}
//绑定交换机与队列
/**
* String queue, 队列名
* String exchange, 交换机的名称
* String routingKey:路由key 如果交换机为fanout模式则不需要路由key
*/
try {
channel.queueBind("kh_queue_fanout01","kh_exchange","");
channel.queueBind("kh_queue_fanout02","kh_exchange","");
} catch (Exception e) {
e.printStackTrace();
}
try {
for (int i = 0; i <= 10; i++) {
String msg = "khszz";
channel.basicPublish("kh_exchange", "", null, msg.getBytes());
}
}catch (IOException e) {
e.printStackTrace();
}
//生产者这里可以管理资源 消费者不能关闭资源。
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
消费者01代码:
package com.kh.fanout;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer01 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接受消息
/**
* (String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数。
*/
DefaultConsumer callback=new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body 接受的信息
System.out.println("消费者01:"+new String(body));
}
};
try {
channel.basicConsume("kh_queue_fanout01",true,callback);
} catch (IOException e) {
e.printStackTrace();
}
}
}
消费者02代码
package com.kh.fanout;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer02 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接收信息
/**
* String consumerTag,消费者标签
* Envelope envelope, 信封
* AMQP.BasicProperties properties,
* byte[] body
*/
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body: 接受的信息
System.out.println("消息的内容:"+new String(body));
}
};
/*
* String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数
*/
try {
channel.basicConsume("kh_queue_fanout02",true,callback);
} catch (IOException e) {
e.printStackTrace();
}
}
}
(4)路由模式
特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机 转发消息。
5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。
package com.kh;
import com.rabbitmq.client.BuiltinExchangeType;
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 LuYou {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//创建队列
/**
* String queue, 队列的名称
* boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
* boolean exclusive, 是否独占 false
* boolean autoDelete, 是否自动删除 如果长时间没有发生消息 则自动删除
* Map<String, Object> arguments 额外参数 先给null
*/
try {
channel.queueDeclare("kh_queue_Luyou01",true,false,false,null);
channel.queueDeclare("kh_queue_Luyou02",true,false,false,null);
} catch (IOException e) {
e.printStackTrace();
}
//创建交换机
/**
* String exchange,交换机的名称
* BuiltinExchangeType type, 交换机的类型
* boolean durable:是否持久化
*/
try {
channel.exchangeDeclare("kh_exchange_Luyou", BuiltinExchangeType.DIRECT,true);
} catch (IOException e) {
e.printStackTrace();
}
//绑定交换机与队列
/**
* String queue, 队列名
* String exchange, 交换机的名称
* String routingKey:路由key 如果交换机为fanout模式则不需要路由key
*/
try {
channel.queueBind("kh_queue_Luyou01","kh_exchange_Luyou","error");
channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","info");
channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","error");
channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","warning");
} catch (IOException e) {
e.printStackTrace();
}
//发生消息
/**
* String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
* String routingKey, 路由key 如果没有交换机的绑定 使用队列的名称
* BasicProperties props, 消息的一些额外配置 目前先不加 null
* byte[] body 消息的内容
*/
try {
for (int i = 0; i <= 10; i++) {
String msg = "khszz";
channel.basicPublish("kh_exchange_Luyou", "info", null, msg.getBytes());
}
}catch (IOException e) {
e.printStackTrace();
}
//生产者这里可以管理资源 消费者不能关闭资源。
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
(5)topic主体模式
1. 绑定按照通配符的模式。
*: 统配一个单词。
#: 统配n个单词
hello.orange.rabbit
lazy.orange
生产者:
package com.kh;
import com.rabbitmq.client.BuiltinExchangeType;
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 Topic {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//创建队列
/**
* String queue, 队列的名称
* boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
* boolean exclusive, 是否独占 false
* boolean autoDelete, 是否自动删除 如果长时间没有发生消息 则自动删除
* Map<String, Object> arguments 额外参数 先给null
*/
try {
channel.queueDeclare("kh_queue_Topic01",true,false,false,null);
channel.queueDeclare("kh_queue_Topic02",true,false,false,null);
} catch (IOException e) {
e.printStackTrace();
}
//创建交换机
/**
* String exchange,交换机的名称
* BuiltinExchangeType type, 交换机的类型
* boolean durable:是否持久化
*/
try {
channel.exchangeDeclare("kh_exchange_Topic", BuiltinExchangeType.TOPIC,true);
} catch (IOException e) {
e.printStackTrace();
}
//绑定交换机与队列
/**
* String queue, 队列名
* String exchange, 交换机的名称
* String routingKey:路由key 如果交换机为fanout模式则不需要路由key
*/
try {
channel.queueBind("kh_queue_Topic01","kh_exchange_Topic","*.orange.*");
channel.queueBind("kh_queue_Topic02","kh_exchange_Topic","*.*.rabbit");
channel.queueBind("kh_queue_Topic02","kh_exchange_Topic","lazy.#");
} catch (IOException e) {
e.printStackTrace();
}
//发生消息
/**
* String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
* String routingKey, 路由key 如果没有交换机的绑定 使用队列的名称
* BasicProperties props, 消息的一些额外配置 目前先不加 null
* byte[] body 消息的内容
*/
try {
for (int i = 0; i <= 10; i++) {
String msg = "cxnszz";
channel.basicPublish("kh_exchange_Topic", "lazy.orange.rabbit", null, msg.getBytes());
}
}catch (IOException e) {
e.printStackTrace();
}
//生产者这里可以管理资源 消费者不能关闭资源。
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
消费者01代码:
package com.kh.topic;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer01 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接受消息
/**
* (String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数。
*/
DefaultConsumer callback=new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body 接受的信息
System.out.println("消费者01:"+new String(body));
}
};
try {
/*
* String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数
*/
channel.basicConsume("kh_queue_Topic01",true,callback);
} catch (IOException e) {
e.printStackTrace();
}
}
}
消费者02代码
package com.kh.topic;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer02 {
public static void main(String[] args) {
//创建链接工厂 --配置连接信息
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.31.98");
Connection connection= null;
Channel channel = null;
try {
//创建连接对象Connection
connection = factory.newConnection();
//创建信道
channel = connection.createChannel();
} catch (Exception e) {
e.printStackTrace();
}
//接受消息
/**
* (String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数。
*/
DefaultConsumer callback=new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body 接受的信息
System.out.println("消费者01:"+new String(body));
}
};
try {
/*
* String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数
*/
channel.basicConsume("kh_queue_Topic02",true,callback);
} catch (IOException e) {
e.printStackTrace();
}
}
}
8.springboot整合RamubbitMQ
目录结构:
springboot引入了相关的依赖后,提供一个工具类RabbitTemplate.使用这个工具类可以发送消息。
(1)父工程引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<packaging>pom</packaging>
<modules>
<module>product</module>
<module>consumer</module>
<module>Consumer01</module>
</modules>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.kh</groupId>
<artifactId>spring-boot-rabbit</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-rabbit</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--Rabbit依赖 启动类加载 读取配置文件:
springboot自动装配原理: 引用starter启动依赖时,把对应的自动装配类加载进去,
该自动加载装配类可以读取application配置文件中的内容 DispatherServlet
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<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>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.72</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
(2)相应的生产者和消费的配置
server:
port: 8888
#rabbit的配置
spring:
rabbitmq:
host: 192.168.31.98
(3)生产者代码
package com.kh
import com.alibaba.fastjson.JSON;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@RestController
public class HelloController {
@Autowired
private RabbitTemplate rabbitTemplate;
@GetMapping("hello")
public String hello(){ //业务层
System.out.println("下单成功");
//String exchange, String routingKey, Object message
Map<String,Object> map=new HashMap<>();
map.put("productId",1);
map.put("num",10);
map.put("price",12);
rabbitTemplate.convertAndSend("ban129_exchange","", JSON.toJSONString(map)); //序列化过程
return "下单成功";
}
}
(4)监听者代码
package com.kh.listen
import com.alibaba.fastjson.JSON;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @Author 闫克起
* @Date 2021/4/20 17:06
* @Version 1.0
*/
@Component
public class MyRabbitListener {
//队列中存在消息则立即回调该方法
@RabbitListener(queues = {"ban129_queue_fanout01"})
public void listener(String msg){
Map map = JSON.parseObject(msg, Map.class);
System.out.println(map);
}
}