本文详细介绍了如何在VMware中配置和启动Docker容器来部署RabbitMQ，以及使用Spring Cloud搭建配置中心，实现配置的动态刷新。同时，通过实例展示了RabbitMQ的多种工作模式，包括简单模式、工作队列、发布订阅和主题模式，讲解了消息的发送和接收。此外，还涵盖了配置中心客户端的设置以及RabbitMQ在服务解耦、流量削峰和异步调用等场景的应用。
文章目录
一.VMware
-
VMware 版本： 16+
-
NAT网络网段使用 64 网段
- 编辑 – 虚拟网络编辑器 – 选择 vmnet8 – 左下角修改：
192.168.64.0
- 编辑 – 虚拟网络编辑器 – 选择 vmnet8 – 左下角修改：
虚拟机镜像
- 课前资料\虚拟机\
- centos-7-1908.zip
- centos-8-2105.zip
- 已经做了几步基础设置：
- yum源和扩展源，使用阿里镜像
- 安装了工具： python、pip、ansible
- 方便设置ip地址的脚本：
- ip-static 设置固定ip
- ip-dhcp 自动获取ip
加载虚拟机
- 解压缩 centos-8-2105.zip
- 双击 centos-8-2105.vmx 加载镜像
- 启动虚拟机，按提示选择“已复制虚拟机”
- 用户名密码都是
root
网卡不可用
# centos 7 禁用 NetworkManager 系统服务
systemctl stop NetworkManager
systemctl disable NetworkManager
# centos 8 开启 VMware 托管
nmcli n on
systemctl restart NetworkManager
# 还原 VMware 虚拟网络
# VMware 虚拟网络不稳定，经常出现故障
# 编辑 -- 虚拟网络编辑器 -- 左下角按钮“还原默认设置” -- 设置 VMnet8 的 64 网段
# 会删除所有虚拟网络，重新创建
二.离线安装 Docker
-
上传离线文件到 /root/
- \DevOps课前资料\docker\docker-install 文件夹
-
参考笔记，从第三步开始安装
https://wanght.blog.csdn.net/article/details/117327543
三.配置中心
1.准备Git仓库
把sp02，sp03，sp04三个项目的配置，存放到git仓库
-
在springcloud·下创建文件夹：config
-
把sp02，sp03，sp04三个项目的配置文件，复制到config(配置中心的优先级高于本地配置文件，回覆盖)
- item-service-dev.yml
- user-service-dev.yml
- order-service-dev.yml
-
添加ovverride-none-true 防止配置中心的配置，覆盖本地命令参数
-
有仓库的不用重复创建
-
VCS-CREATE GIT REPOSITORY
或double shift，搜索create git repository
-
选择spring cloud1工程目录作为仓库目录
-
commit提交本地仓库，ctrl+k，右上角对钩按钮，double shift搜索commit
-
选择所有文件，填写提交信息，提交
-
-
在gitee点右上角加号新建仓库
spring clou1
设置开源项
-
CTRL+SHIFT+K,右上角向上箭头按钮，double shift搜索push
2.搭建配置中心
1.新建模块：sp09-config
2.添加依赖
- eureka client
- config server
<?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">
<parent>
<artifactId>springcloud1</artifactId>
<groupId>cn.tedu</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>sp09-config</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>sp09-config</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
3.yml
spring:
application:
name: config-server
# eureka2001 zuul3001 dashboard4001 turbine5001
cloud:
config:
server:
git:
uri: https://gitee.com/E-Levin/spring-cloud1 #https://gitee.com/用户名/仓库
search-paths: /config #/子目录/子目录/子目录
server:
port: 6001
eureka:
client:
service-url:
defaultZone: http://eureka1:2001/eureka,http://eureka2:2002/eureka
- 仓库的地址
- 存放配置文件夹路径
- 之后测试如果有问题，果断换仓库
4.启动类添加注解：@EnableConfigServer
package cn.tedu.sp09;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@EnableConfigServer
@SpringBootApplication
public class Sp09ConfigApplication {
public static void main(String[] args) {
SpringApplication.run(Sp09ConfigApplication.class, args);
}
}
3.确认配置中心服务是否正确
-
添加链接描述检查是否有config-service注册信息
-
访问配置中心的配置文件
4.配置中心的客户端
1.把sp02，sp03，sp04配置文件全部注释掉
例如：
2.添加依赖：config client
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
3.新建配置文件：bootstrap.yml
# bootstrap
eureka:
client:
service-url:
defaultZone: http://eureka1:2001/eureka,http://eureka2:2002/eureka
spring:
cloud:
config:
discovery:
enabled: true #从注册表发现配置中心的地址
service-id: config-server
name: user-service
profile: dev
4.添加配置：
- eureka地址
- 指定配置中心服务id：CONFIG-SERVER
- 指定下载下载的配置文件和profile
启动控制台中心，要看到连接 6001 的日志
四.Rabbitmq
1.RabbitMQ 使用场景
服务解耦
假设有这样一个场景, 服务A产生数据, 而服务B,C,D需要这些数据, 那么我们可以在A服务中直接调用B,C,D服务,把数据传递到下游服务即可
但是,随着我们的应用规模不断扩大,会有更多的服务需要A的数据,如果有几十甚至几百个下游服务,而且会不断变更,再加上还要考虑下游服务出错的情况,那么A服务中调用代码的维护会极为困难
这是由于服务之间耦合度过于紧密
来考虑用RabbitMQ解耦的情况
A服务只需要向消息服务器发送消息,而不用考虑谁需要这些数据;下游服务如果需要数据,自行从消息服务器订阅消息,不再需要数据时则取消订阅即可
流量削峰
假设我们有一个应用,平时访问量是每秒300请求,我们用一台服务器即可轻松应对
而在高峰期,访问量瞬间翻了十倍,达到每秒3000次请求,那么单台服务器肯定无法应对,这时我们可以考虑增加到10台服务器,来分散访问压力
但如果这种瞬时高峰的情况每天只出现一次,每次只有半小时,那么我们10台服务器在多数时间都只分担每秒几十次请求,这样就有点浪费资源了
这种情况,我们就可以使用RabbitMQ来进行流量削峰,高峰情况下,瞬间出现的大量请求数据,先发送到消息队列服务器,排队等待被处理,而我们的应用,可以慢慢的从消息队列接收请求数据进行处理,这样把数据处理时间拉长,以减轻瞬时压力
这是消息队列服务器非常典型的应用场景
异步调用
考虑定外卖支付成功的情况
支付后要发送支付成功的通知,再寻找外卖小哥来进行配送,而寻找外卖小哥的过程非常耗时,尤其是高峰期,可能要等待几十秒甚至更长
这样就造成整条调用链路响应非常缓慢
而如果我们引入RabbitMQ消息队列,订单数据可以发送到消息队列服务器,那么调用链路也就可以到此结束,订单系统则可以立即得到响应,整条链路的响应时间只有200毫秒左右
寻找外卖小哥的应用可以以异步的方式从消息队列接收订单消息,再执行耗时的寻找操作
2.rabbitmq 基本概念
RabbitMQ是一种消息中间件，用于处理来自客户端的异步消息。服务端将要发送的消息放入到队列池中。接收端可以根据RabbitMQ配置的转发机制接收服务端发来的消息。RabbitMQ依据指定的转发规则进行消息的转发、缓冲和持久化操作，主要用在多服务器间或单服务器的子系统间进行通信，是分布式系统标准的配置。
Exchange
接受生产者发送的消息，并根据Binding规则将消息路由给服务器中的队列。ExchangeType决定了Exchange路由消息的行为。在RabbitMQ中，ExchangeType常用的有direct、Fanout和Topic三种。
Message Queue
消息队列。我们发送给RabbitMQ的消息最后都会到达各种queue，并且存储在其中(如果路由找不到相应的queue则数据会丢失)，等待消费者来取。
Binding Key
它表示的是Exchange与Message Queue是通过binding key进行联系的，这个关系是固定。
Routing Key
生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则。这个routing key需要与Exchange Type及binding key联合使用才能生，我们的生产者只需要通过指定routing key来决定消息流向哪里。
消息队列、消息服务、消息中间件、Broker
- Rabbitmg
- Activemq
- Rocketmq 阿里
- Kafka
- Tubemq腾讯
3.rabbitmq安装
Docker 启动Rabbitmq
搭建Rabbitmq服务器
-
克隆 docker-base： rabbitmq
-
设置ip
./ip-static ip: 192.168.64.140 ifconfig -
下载 rabbitmq 镜像
docker pull rabbitmq:management
或者从 code 下载 rabbit-image.gz
上传到服务器，然后执行镜像导入
docker load -i rabbit-image.gz
- 启动rabbitmq容器
关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
重启 docker 系统服务
systemctl restart docker
mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf
# 添加两行配置：
default_user = admin
default_pass = admin
docker run -d --name rabbit \
-p 5672:5672 \
-p 15672:15672 \
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf \
rabbitmq:management
访问管理控制台 http://192.168.64.140:15672
用户名密码是 admin
4.Yum在线安装
以下内容来自 RabbitMQ 官方手册
rpm --import https://github.com/rabbitmq/signing-keys/releases/download/2.0/rabbitmq-release-signing-key.asc
# centos7 用这个
cat <<EOF > /etc/yum.repos.d/rabbitmq.repo
[bintray-rabbitmq-server]
name=bintray-rabbitmq-rpm
baseurl=https://dl.bintray.com/rabbitmq/rpm/rabbitmq-server/v3.8.x/el/7/
gpgcheck=0
repo_gpgcheck=0
enabled=1
EOF
# centos6 用这个
cat <<EOF > /etc/yum.repos.d/rabbitmq.repo
[bintray-rabbitmq-server]
name=bintray-rabbitmq-rpm
baseurl=https://dl.bintray.com/rabbitmq/rpm/rabbitmq-server/v3.8.x/el/6/
gpgcheck=0
repo_gpgcheck=0
enabled=1
EOF
yum makecache
yum install socat
wget https://github.com/rabbitmq/erlang-rpm/releases/download/v21.3.8.12/erlang-21.3.8.12-1.el7.x86_64.rpm
rpm -ivh erlang-21.3.8.12-1.el7.x86_64.rpm --force --nodeps
yum install rabbitmq-server
启动rabbitmq服务器
# 设置服务,开机自动启动
systemctl enable rabbitmq-server
#启动服务
systemctl start rabbitmq-server
rabbitmq管理界面
启用管理界面
#开启管理界面插件
rabbitmq-plugins enable rabbitmq_management
# 防火墙打开 15672 管理端口
firewall-cmd --zone=public --add-port=15672/tcp --permanent
firewall-cmd --reload
重启RabbitMQ服务
systemctl restart rabbitmq-server
访问
访问服务器的15672端口,例如:
http://192.168.64.140:15672
添加用户
添加用户
# 添加用户
rabbitmqctl add_user admin admin
# 新用户设置用户为超级管理员
rabbitmqctl set_user_tags admin administrator
设置访问权限
用户管理参考
添加链接描述
开放客户端连接端口
# 打开客户端连接端口
firewall-cmd --zone=public --add-port=5672/tcp --permanent
firewall-cmd --reload
主要端口介绍
- 4369 – erlang发现口
- 5672 – client端通信口
- 15672 – 管理界面ui端口
- 25672 – server间内部通信口
5.rabbitmq六种工作模式
1.简单模式
RabbitMQ是一个消息中间件，你可以想象它是一个邮局。当你把信件放到邮箱里时，能够确信邮递员会正确地递送你的信件。RabbitMq就是一个邮箱、一个邮局和一个邮递员。
发送消息的程序是生产者
队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序，但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制，它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息，多个消费者也可以从同一个队列接收消息.
消费者等待从队列接收消息
pom.xml
添加rabbitmq amqp 依赖
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.tedu</groupId>
<artifactId>rabbitmq-api</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.4.3</version>
</dependency>
</dependencies>
</project>
生产者发送消息
package m1;
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 {
//1.连接服务器
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140");
f.setPort(5672);//5672收发信息的通信端口，像数据库的3306
f.setUsername("admin");
f.setPassword("admin");
Connection con = f.newConnection();
Channel c = con.createChannel();
//2.在服务器上创建队列helloworld，helloworld-xxx
//如果队列已经存在，不会重复创建
c.queueDeclare("helloworld",false,false,false,null);
//3.向 helloworld队列发送消息
c.basicPublish("", "helloworld", null,"Hello World".getBytes());
System.out.println("消息已发送");
}
}
消费者接收消息
package m1;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
//1.连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140");
f.setPort(5672);//5672收发信息的通信端口，像数据库的3306
f.setUsername("admin");
f.setPassword("admin");
Connection con = f.newConnection();
Channel c = con.createChannel();//通信通道
//2.创建队列
c.queueDeclare("helloworld", false, false,false,null);
//3.回调对象
DeliverCallback deliverCallback = (consumerTag,message) -> {
byte[] body = message.getBody();
String s = new String(body);
System.out.println("收到："+s);
};
CancelCallback cancelCallback = consumerTag -> {};
//3.开始接受消息，消费消息，收到的消息会传递到一个回调对象处理
//c.basicConsume("helloworld", true,"处理消息的回调对象，取消处理消息的回调对象");
c.basicConsume("helloworld", true,deliverCallback,cancelCallback);
}
}
2.工作模式
工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。
我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时，任务将在它们之间分发。
使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务，我们可以添加更多工作进程，这样就可以轻松扩展。
生产者发送消息
这里模拟耗时任务,发送的消息中,每个点使工作进程暂停一秒钟,例如"Hello…"将花费3秒钟来处理
package m2;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
// 连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
// 创建队列： helloworld
/*
参数：
1.队列名
2.是否是持久队列
3.是否是排他队列、独占队列
4.是否自动删除
5.队列的其他参数属性
*/
c.queueDeclare("helloworld", false,false,false,null);
// 循环数据消息，发送
while (true) {
System.out.print("输入消息：");
String s = new Scanner(System.in).nextLine();
/*
参数：
1. 交换机， 空串是默认交换机
3. 消息的属性数据
*/
c.basicPublish("", "helloworld", null, s.getBytes());
}
}
}
消费者接收消息
package m2;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
c.queueDeclare("helloworld-wht", false,false,false,null);
// 回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s = new String(message.getBody());
System.out.println("收到："+s);
//处理消息，遍历字符串，字符就暂停1秒，来模拟耗时消息
for(int i = 0;i<s.length();i++){
if('.' == s.charAt(i)){
try {
Thread.sleep(1000);
}catch (InterruptedException e){
}
}
}
System.out.println("-------------消息处理完成");
};
CancelCallback cancelCallback = consumerTag -> {};
// 消费消息
/**
* 第二个参数：autoAck
* true -自动确认
* false -手动确认 手动发送回执，可以保证消息被正确处理
*/
c.basicConsume("helloworld-wht", true, deliverCallback, cancelCallback);
}
}
运行测试
运行:
一个生产者
两个消费者
生产者发送多条消息,
如: 1,2,3,4,5. 两个消费者分别收到:
消费者一: 1,3,5
消费者二: 2,4
rabbitmq在所有消费者中轮询分发消息,把消息均匀地发送给所有消费者
消息确认
一个消费者接收消息后,在消息没有完全处理完时就挂掉了,那么这时会发生什么呢?
就现在的代码来说,rabbitmq把消息发送给消费者后,会立即删除消息,那么消费者挂掉后,它没来得及处理的消息就会丢失
如果生产者发送以下消息:
1…
2
3
4
5
两个消费者分别收到:
消费者一: 1…, 3, 5
消费者二: 2, 4
当消费者一收到所有消息后,要话费7秒时间来处理第一条消息,这期间如果关闭该消费者,那么1未处理完成,3,5则没有被处理
我们并不想丢失任何消息, 如果一个消费者挂掉,我们想把它的任务消息派发给其他消费者
为了确保消息不会丢失，rabbitmq支持消息确认(回执)。当一个消息被消费者接收到并且执行完成后，消费者会发送一个ack (acknowledgment) 给rabbitmq服务器, 告诉他我已经执行完成了，你可以把这条消息删除了。
如果一个消费者没有返回消息确认就挂掉了（信道关闭，连接关闭或者TCP链接丢失），rabbitmq就会明白，这个消息没有被处理完成，rebbitmq就会把这条消息重新放入队列，如果在这时有其他的消费者在线，那么rabbitmq就会迅速的把这条消息传递给其他的消费者，这样就确保了没有消息会丢失。
这里不存在消息超时, rabbitmq只在消费者挂掉时重新分派消息, 即使消费者花非常久的时间来处理消息也可以
手动消息确认默认是开启的，前面的例子我们通过autoAck=ture把它关闭了。我们现在要把它设置为false，然后工作进程处理完意向任务时,发送一个消息确认(回执)。
package m2;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
c.queueDeclare("helloworld-wht", false,false,false,null);
// 回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s = new String(message.getBody());
System.out.println("收到："+s);
//处理消息，遍历字符串，字符就暂停1秒，来模拟耗时消息
for(int i = 0;i<s.length();i++){
if('.' == s.charAt(i)){
try {
Thread.sleep(1000);
}catch (InterruptedException e){
}
}
}
//手动发送回执 c.basicAck(回执数据（msg封装的数据），boolean（是否确认之前收到的所有消息）);
c.basicAck(message.getEnvelope().getDeliveryTag(),false);
System.out.println("-------------消息处理完成");
};
CancelCallback cancelCallback = consumerTag -> {};
//每次只接受一条，处理完之前，不收下一条
//手动ack模式下才有效
c.basicQos(1);
// 消费消息
/**
* 第二个参数：autoAck ACK -Acknow|edgement 确认
* true -自动确认
* false -手动确认 手动发送回执，可以保证消息被正确处理
*/
c.basicConsume("helloworld-wht", false, deliverCallback, cancelCallback);
}
}
使用以上代码，就算杀掉一个正在处理消息的工作进程也不会丢失任何消息，工作进程挂掉之后，没有确认的消息就会被自动重新传递。
忘记确认(ack)是一个常见的错误, 这样后果是很严重的, 由于未确认的消息不会被释放, rabbitmq会吃掉越来越多的内存
可以使用下面命令打印工作队列中未确认消息的数量
rabbitmqctl list_queues name messages_ready messages_unacknowledged
当处理消息时异常中断, 可以选择让消息重回队列重新发送.
nack 操作可以是消息重回队列, 可以使用 basicNack() 方法:
// requeue为true时重回队列, 反之消息被丢弃或被发送到死信队列
c.basicNack(tag, multiple, requeue)
合理地分发
rabbitmq会一次把多个消息分发给消费者, 这样可能造成有的消费者非常繁忙, 而其它消费者空闲. 而rabbitmq对此一无所知, 仍然会均匀的分发消息
我们可以使用 basicQos(1) 方法, 这告诉rabbitmq一次只向消费者发送一条消息, 在返回确认回执前, 不要向消费者发送新消息. 而是把消息发给下一个空闲的消费者
消息持久化
当rabbitmq关闭时, 我们队列中的消息仍然会丢失, 除非明确要求它不要丢失数据
要求rabbitmq不丢失数据要做如下两点: 把队列和消息都设置为可持久化(durable)
队列设置为可持久化, 可以在定义队列时指定参数durable为true
//第二个参数是持久化参数durable
ch.queueDeclare("helloworld", true, false, false, null);
由于之前我们已经定义过队列"hello"是不可持久化的, 对已存在的队列, rabbitmq不允许对其定义不同的参数, 否则会出错, 所以这里我们定义一个不同名字的队列"task_queue"
//定义一个新的队列,名为 task_queue
//第二个参数是持久化参数 durable
ch.queueDeclare("task_queue", true, false, false, null);
生产者和消费者代码都要修改
这样即使rabbitmq重新启动, 队列也不会丢失. 现在我们再设置队列中消息的持久化, 使用MessageProperties.PERSISTENT_TEXT_PLAIN参数
//第三个参数设置消息持久化
ch.basicPublish("", "task_queue",
MessageProperties.PERSISTENT_TEXT_PLAIN,
msg.getBytes());
下面是"工作模式"最终完成的生产者和消费者代码
生产者代码
package m2;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
// 连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
// 创建队列： helloworld
/*
参数：
1.队列名
2.是否是持久队列
3.是否是排他队列、独占队列
4.是否自动删除
5.队列的其他参数属性
*/
c.queueDeclare("task_queue", true,false,false,null);
// 循环数据消息，发送
while (true) {
System.out.print("输入消息：");
String s = new Scanner(System.in).nextLine();
/*
参数：
1. 交换机， 空串是默认交换机
3. 消息的属性数据 MessageProperties.PERSISTENT_BASIC--消息持久化
*/
c.basicPublish("", "task_queue", MessageProperties.PERSISTENT_BASIC, s.getBytes());
}
}
}
消费者代码
package m2;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
/*
服务器端已经存在的队列，属性不允许修改
*/
c.queueDeclare("task_queue", true,false,false,null);
// 回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s = new String(message.getBody());
System.out.println("收到："+s);
//处理消息，遍历字符串，字符就暂停1秒，来模拟耗时消息
for(int i = 0;i<s.length();i++){
if('.' == s.charAt(i)){
try {
Thread.sleep(1000);
}catch (InterruptedException e){
}
}
}
//手动发送回执 c.basicAck(回执数据（msg封装的数据），boolean（是否确认之前收到的所有消息）);
c.basicAck(message.getEnvelope().getDeliveryTag(),false);
System.out.println("-------------消息处理完成");
};
CancelCallback cancelCallback = consumerTag -> {};
//每次只接受一条，处理完之前，不收下一条
//手动ack模式下才有效
c.basicQos(1);
// 消费消息
/**
* 第二个参数：autoAck ACK -Acknow|edgement 确认
* true -自动确认
* false -手动确认 手动发送回执，可以保证消息被正确处理
*/
c.basicConsume("task_queue", false, deliverCallback, cancelCallback);
}
}
3.发布订阅模式
在前面的例子中，我们任务消息只交付给一个工作进程。在这部分，我们将做一些完全不同的事情——我们将向多个消费者传递同一条消息。这种模式称为“发布/订阅”。
为了说明该模式，我们将构建一个简单的日志系统。它将由两个程序组成——第一个程序将发出日志消息，第二个程序接收它们。
在我们的日志系统中，接收程序的每个运行副本都将获得消息。这样，我们就可以运行一个消费者并将日志保存到磁盘; 同时我们可以运行另一个消费者在屏幕上打印日志。
最终, 消息会被广播到所有消息接受者
Exchanges 交换机
RabbitMQ消息传递模型的核心思想是，生产者永远不会将任何消息直接发送到队列。实际上，通常生产者甚至不知道消息是否会被传递到任何队列。
相反，生产者只能向交换机(Exchange)发送消息。交换机是一个非常简单的东西。一边接收来自生产者的消息，另一边将消息推送到队列。交换器必须确切地知道如何处理它接收到的消息。它应该被添加到一个特定的队列中吗?它应该添加到多个队列中吗?或者它应该被丢弃。这些规则由exchange的类型定义。
有几种可用的交换类型:direct、topic、header和fanout。我们将关注最后一个——fanout。让我们创建一个这种类型的交换机，并称之为 logs: ch.exchangeDeclare(“logs”, “fanout”);
fanout交换机非常简单。它只是将接收到的所有消息广播给它所知道的所有队列。这正是我们的日志系统所需要的。
我们前面使用的队列具有特定的名称(还记得hello和task_queue吗?)能够为队列命名对我们来说至关重要——我们需要将工作进程指向同一个队列,在生产者和消费者之间共享队列。
但日志记录案例不是这种情况。我们想要接收所有的日志消息，而不仅仅是其中的一部分。我们还只对当前的最新消息感兴趣，而不是旧消息。
要解决这个问题，我们需要两件事。首先，每当我们连接到Rabbitmq时，我们需要一个新的空队列。为此，我们可以创建一个具有随机名称的队列，或者，更好的方法是让服务器为我们选择一个随机队列名称。其次，一旦断开与使用者的连接，队列就会自动删除。在Java客户端中，当我们不向queueDeclare()提供任何参数时，会创建一个具有生成名称的、非持久的、独占的、自动删除队列
//自动生成队列名
//非持久,独占,自动删除
String queueName = ch.queueDeclare().getQueue();
绑定 Bindings
我们已经创建了一个fanout交换机和一个队列。现在我们需要告诉exchange向指定队列发送消息。exchange和队列之间的关系称为绑定。
//指定的队列,与指定的交换机关联起来
//成为绑定 -- binding
//第三个参数时 routingKey, 由于是fanout交换机, 这里忽略 routingKey
ch.queueBind(queueName, "logs", "");
现在, logs交换机将会向我们指定的队列添加消息
列出绑定关系:
rabbitmqctl list_bindings
完成的代码
生产者
生产者发出日志消息，看起来与前一教程没有太大不同。最重要的更改是，我们现在希望将消息发布到logs交换机，而不是无名的日志交换机。我们需要在发送时提供一个routingKey，但是对于fanout交换机类型，该值会被忽略。
package m3;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
{
// 连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//创建fanout类型交换机：logss 是否持久化，
/*
1.队列名
2.是否是持久队列
3.是否是排他队列、独占队列
4.是否自动删除
5.队列的其他参数属性
*/
//c.exchangeDeclare("logs", "fanout",false,false,null);两种写法都可以
c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
//
// 循环数据消息，发送
while (true) {
System.out.print("输入消息：");
String s = new Scanner(System.in).nextLine();
c.basicPublish("logs","",null,s.getBytes());//""表示无效
}
}
}
}
消费者
如果还没有队列绑定到交换器，消息就会丢失，但这对我们来说没有问题;如果还没有消费者在听，我们可以安全地丢弃这些信息。
ReceiveLogs.java代码:
package m3;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
//连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//1创建队列 2.创建交换机 3.绑定
String queue = UUID.randomUUID().toString();
c.queueDeclare(queue,false, true, true,null);//非持久，独占 自动删除
c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
c.queueBind(queue,"logs","");//第三个参数对fanout交换无效
//回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s = new String(message.getBody());
System.out.println("收到："+s);
};
CancelCallback cancelCallback = consumerTag -> {};
//消费消息
c.basicConsume(queue,true,deliverCallback,cancelCallback);
}
}
4.路由模式
在上一小节，我们构建了一个简单的日志系统。我们能够向多个接收者广播日志消息。
在这一节，我们将向其添加一个特性—我们将只订阅所有消息中的一部分。例如，我们只接收关键错误消息并保存到日志文件(以节省磁盘空间)，同时仍然能够在控制台上打印所有日志消息。
绑定 Bindings
在上一节，我们已经创建了队列与交换机的绑定。使用下面这样的代码:
ch.queueBind(queueName, "logs", "");
绑定是交换机和队列之间的关系。这可以简单地理解为:队列对来自此交换的消息感兴趣。
绑定可以使用额外的routingKey参数。为了避免与basic_publish参数混淆，我们将其称为bindingKey。这是我们如何创建一个键绑定:
ch.queueBind(queueName, EXCHANGE_NAME, "black");
bindingKey的含义取决于交换机类型。我们前面使用的fanout交换机完全忽略它。
直连交换机 Direct exchange
上一节中的日志系统向所有消费者广播所有消息。我们希望扩展它，允许根据消息的严重性过滤消息。例如，我们希望将日志消息写入磁盘的程序只接收关键error，而不是在warning或info日志消息上浪费磁盘空间。
前面我们使用的是fanout交换机，这并没有给我们太多的灵活性——它只能进行简单的广播。
我们将用直连交换机(Direct exchange)代替。它背后的路由算法很简单——消息传递到bindingKey与routingKey完全匹配的队列。为了说明这一点，请考虑以下设置
其中我们可以看到直连交换机X，它绑定了两个队列。第一个队列用绑定键orange绑定，第二个队列有两个绑定，一个绑定black，另一个绑定键green。
这样设置，使用路由键orange发布到交换器的消息将被路由到队列Q1。带有black或green路由键的消息将转到Q2。而所有其他消息都将被丢弃。
多重绑定 Multiple bindings
使用相同的bindingKey绑定多个队列是完全允许的。如图所示，可以使用binding key black将X与Q1和Q2绑定。在这种情况下，直连交换机的行为类似于fanout，并将消息广播给所有匹配的队列。一条路由键为black的消息将同时发送到Q1和Q2。
发送日志
我们将在日志系统中使用这个模型。我们把消息发送到一个Direct交换机，而不是fanout。我们将提供日志级别作为routingKey。这样，接收程序将能够选择它希望接收的级别。让我们首先来看发出日志。
和前面一样，我们首先需要创建一个exchange:
//参数1: 交换机名
//参数2: 交换机类型
ch.exchangeDeclare("direct_logs", "direct");
接着来看发送消息的代码
//参数1: 交换机名
//参数2: routingKey, 路由键,这里我们用日志级别,如"error","info","warning"
//参数3: 其他配置属性
//参数4: 发布的消息数据
ch.basicPublish("direct_logs", "error", null, message.getBytes());
订阅
接收消息的工作原理与前面章节一样，但有一个例外——我们将为感兴趣的每个日志级别创建一个新的绑定, 示例代码如下:
ch.queueBind(queueName, "logs", "info");
ch.queueBind(queueName, "logs", "warning");
完整的代码
生产者
package m4;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.sql.SQLOutput;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//创建direct类型交换机：direct_logs
c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);//DIRECT通过关键字匹配
//向direct_logs 交换机发送消息，携带路由关键词
while (true){
System.out.println("输入消息：");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键：");
String k = new Scanner(System.in).nextLine();
//第二个参数是路由键
//对默认交换机，路由键就是队列名
c.basicPublish("direct_logs", k,null, s.getBytes());
}
}
}
消费者
package m4;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
//连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
Channel c = f.newConnection().createChannel();
//1.随机队列 2.交换机 3.使用绑定键绑定
//使用UUID方法
//String queue = UUID.randomUUID().toString();
//c.queueDeclare(queue,false, true,true , null);
//无参方法 由服务器来自定随机命名,非持久，独占，自动删除
String queue = c.queueDeclare().getQueue();
//创建交换机
c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
//输入 绑定
System.out.println("输入绑定键，用空格隔开：");//"aa bb cc"
String s = new Scanner(System.in).nextLine();
String[] a = s.split("\\s+");//正则表达式 \转译 \s空白字符 + 一到多个
for (String k : a){
c.queueBind(queue, "direct_logs",k);
}
//回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s1 = new String(message.getBody());
System.out.println("收到："+s1);
};
CancelCallback cancelCallback = consumerTag -> {};
//消费消息
c.basicConsume(queue,true,deliverCallback,cancelCallback);
}
}
5.主题模式
在上一小节，我们改进了日志系统。我们没有使用只能进行广播的fanout交换机，而是使用Direct交换机，从而可以选择性接收日志。
虽然使用Direct交换机改进了我们的系统，但它仍然有局限性——它不能基于多个标准进行路由。
在我们的日志系统中，我们可能不仅希望根据级别订阅日志，还希望根据发出日志的源订阅日志。
这将给我们带来很大的灵活性——我们可能只想接收来自“cron”的关键错误，但也要接收来自“kern”的所有日志。
要在日志系统中实现这一点，我们需要了解更复杂的Topic交换机。
主题交换机 Topic exchange
发送到Topic交换机的消息,它的的routingKey,必须是由点分隔的多个单词。单词可以是任何东西，但通常是与消息相关的一些特性。几个有效的routingKey示例:“stock.usd.nyse”、“nyse.vmw”、“quick.orange.rabbit”。routingKey可以有任意多的单词，最多255个字节。
bindingKey也必须采用相同的形式。Topic交换机的逻辑与直连交换机类似——使用特定routingKey发送的消息将被传递到所有使用匹配bindingKey绑定的队列。bindingKey有两个重要的特殊点:
* 可以通配单个单词。
# 可以通配零个或多个单词。
用一个例子来解释这个问题是最简单的
在本例中，我们将发送描述动物的消息。这些消息将使用由三个单词(两个点)组成的routingKey发送。routingKey中的第一个单词表示速度，第二个是颜色,第三个是物种:“<速度>.<颜色>.<物种>”。
我们创建三个绑定:Q1与bindingKey “.orange.” 绑定。和Q2是 “..rabbit” 和 “lazy.#” 。
这些绑定可概括为:
Q1对所有橙色的动物感兴趣。
Q2想接收关于兔子和慢速动物的所有消息。
将routingKey设置为**“quick.orange.rabbit"的消息将被发送到两个队列。消息 "lazy.orange.elephant“也发送到它们两个。另外”quick.orange.fox“只会发到第一个队列，”lazy.brown.fox“只发给第二个。”lazy.pink.rabbit“将只被传递到第二个队列一次，即使它匹配两个绑定。”quick.brown.fox”**不匹配任何绑定，因此将被丢弃。
如果我们违反约定，发送一个或四个单词的信息，比如**“orange“或”quick.orange.male.rabbit”**，会发生什么?这些消息将不匹配任何绑定，并将丢失。
另外，“lazy.orange.male.rabbit”，即使它有四个单词，也将匹配最后一个绑定，并将被传递到第二个队列。
完成的代码
生产者
package m5;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Producer {
public static void main(String[] args) throws IOException, TimeoutException {
//连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
f.setVirtualHost("Levin");
Channel c = f.newConnection().createChannel();
//创建direct类型交换机：direct_logs
c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
//向direct_logs 交换机发送消息，携带路由关键词
while (true){
System.out.println("输入消息：");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键：");
String k = new Scanner(System.in).nextLine();
//第二个参数是路由键
//对默认交换机，路由键就是队列名
c.basicPublish("topic_logs", k,null, s.getBytes());
}
}
}
消费者
package m5;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
//连接
ConnectionFactory f = new ConnectionFactory();
f.setHost("192.168.64.140"); // 192.168.64.140
f.setPort(5672);
f.setUsername("admin");
f.setPassword("admin");
f.setVirtualHost("Levin");
Channel c = f.newConnection().createChannel();
//1.随机队列 2.交换机 3.使用绑定键绑定
//使用UUID方法
//String queue = UUID.randomUUID().toString();
//c.queueDeclare(queue,false, true,true , null);
//无参方法 由服务器来自定随机命名,非持久，独占，自动删除
String queue = c.queueDeclare().getQueue();
//创建交换机
c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
//输入 绑定
System.out.println("输入绑定键，用空格隔开：");//"aa bb cc"
String s = new Scanner(System.in).nextLine();
String[] a = s.split("\\s+");//正则表达式 \转译 \s空白字符 + 一到多个
for (String k : a){
c.queueBind(queue, "topic_logs",k);
}
//回调对象
DeliverCallback deliverCallback = (consumerTag, message) -> {
String s1 = new String(message.getBody());
System.out.println("收到："+s1);
};
CancelCallback cancelCallback = consumerTag -> {};
//消费消息
c.basicConsume(queue,true,deliverCallback,cancelCallback);
}
}
6.config bus + rabbitmq 消息总线配置刷新
post 请求消息总线刷新端点，服务器会向 rabbitmq 发布刷新消息，接收到消息的微服务会向配置服务器请求刷新配置信息
1.修改2，3，4，9 添加依赖
- Bus
- Rabbitmq
- binder-rabbit
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>
2.09添加依赖：actuator
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
3.09的yml配置
- 暴露bus-refresh
m.e.w.e.i =bus-refresh
management:
endpoints:
web:
exposure:
include: bus-refresh
- rabbitmq连接
4.修改2，3，4的yml配置，修改config目录逇三个文件并提交
- rabbitmq的连接
spring:
rabbitmq:
host: 192.168.64.140 # wht6.cn
port: 5672
username: admin
password: admin
virtual-host: Levin
5.启动项目测试
-
启动5，耐心等待完全启动完成
-
启动9，耐心等待完全启动完成
-
--------- http://eureka1:2001 注册表中存在 config-server
http://localhost:6001/item-service/dev
http://localhost:6001/user-service/dev
http://localhost:6001/order-service/dev
-
启动 2,3
-
启动 4
-
--------- 查看 2,3,4 的控制台，要看到连接 6001
-
启动6
-
--------- http://localhost:6001/actuator 这里面要看到 bus-refresh
-
使用 postman 向
http://localhost:6001/actuator/bus-refresh提交 post 请求
-
观察 2,3,4 的控制台，要看到重新连接 6001 刷新配置的日志
6.把刷新到的配置信息，重新注入到对象中
@RefreshScope
在需要重新注入配置数据的对象上添加这个注解，重启启动类，刷新的配置才能重新注入到对象中；
如果加这个注解，即使刷新到新配置，也不会重新向对象注入
配置类加入新用户
只需postman 向 bus-refresh 刷新端点发送 post 请求
http://localhost:6001/actuator/bus-refresh
注意:
在新标签中测试
不需要启动配置类，就可以访问
7.sleuth 链路跟踪
随着系统规模越来越大，微服务之间调用关系变得错综复杂，一条调用链路中可能调用多个微服务，任何一个微服务不可用都可能造整个调用过程失败
spring cloud sleuth 可以跟踪调用链路，分析链路中每个节点的执行情况
-
sleuth
产生链路跟踪日志
-
zipkin
日志的可视化
sleuth
A --> B --> C --> D
A, U5HG4HG456UYU, U5HG4HG456UYU, true
B, U5HG4HG456UYU, O7IUYH45TY34Y45, true
C, U5HG4HG456UYU, U56YU4Y344U456, true
D, U5HG4HG456UYU, 34T345Y456U56U5, true
修改 2,3,4,6 添加 sleuth 产生链路跟踪日志
- 2,3,4,6只需要添加sleuth依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
- sleuth是自动配置，不需要添加任何其他配置
2，3，4，6，向rabbitmq发送日志数据
- 添加zipkin客户端依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
- 在06添加rabbitmq依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
-
yml配置发送方式：rabbit
-
修改06的yml，添加rabbitmq连接配置
自动zipkin服务器
# 使用 140 服务器，没有 virtual host
java -jar zipkin-server-2.23.4-exec.jar --
zipkin.collector.rabbitmq.uri=amqp://admin:admin@192.168.64.140:5672
# 使用 140 服务器，有 virtual host=Levin
java -jar zipkin-server-2.23.4-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:admin@192.168.64.140:5672/Levin
# 使用我的服务器，有 virtual host
java -jar zipkin-server-2.23.4-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:admin@wht6.cn:5672/vh0
8.向eureka注册正确的ip地址
eureka客户端向eureka注册时, 会自动选择网卡, 并可能注册主机名而不是ip地址.
下面配置可以选择正确网卡的ip向eureka进行注册.
选择网卡
bootstrap.yml
spring:
cloud:
inetutils:
ignored-interfaces:
- VM.*
preferred-networks:
- 192\.168\.114\..+ #\进行转译， .+ 表示一个或多个
注册IP地址，而不注册主机名
application.yml
eureka:
instance:
prefer-ip-address: true
9.订单流量削峰
导入项目
- 课前资料\elasticsearch\pd-商城项目案例.zip
压缩文件\pd\pd-web 文件夹，解压到 rabbitmq 工程目录
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
-
pd-web\pom.xml 鼠标拖拽到 idea，springboot 版本改成 2.3.2.RELEASE
-
pom.xml编辑器中，右键–add as maven project， 导入 pd-web 模块
导入数据库
-
sqlyog， 右键点连接， 从 sql 转储文件导入，选择 pd-web 目录中的 pd.sql
-
如果导入失败，可以增大 mysql 缓存大小
如果导入失败，可以增大mysql缓存区
set global max_allowed_packet=100000000;
set global net_buffer_length=100000;
SET GLOBAL interactive_timeout=28800000;
SET GLOBAL wait_timeout=28800000
启动项目测试
测试现有订单系统
- 删除数据库中的所有注册用户和订单
delete from pd_user;
delete from pd_order;
delete from pd_order_item;
向Rabbitmq发送订单
-
pom.xml添加rabbitmq依赖
-
yml添加rabbitmq连接
spring:
rabbitmq:
host: 192.168.64.140
port: 5672
username: admin
password: admin
virtual-host: Levin #使用自己的空间，需要在rabbitmq服务器手动创建
- 在启动类，或者添加自动配置类，给出使用的队列参数：orderQueue，false，false，false
/*
新建que实例，用来封装队列的参数
Rabbitmq的自动配置类会自动发现Queue实例
根据其中的参数，连接服务器创建队列
*/
@Bean
public Queue orderQueue(){
return new Queue("orderQueue",true,false,false);
}
- 修改OrderServiceImpl，使用AmqpTemplate工具类，向orderQueue队列发送订单消息
/*
在RabbitAutoConfiguration中自动创建AmqpTemplate
*/
@Autowired
private AmqpTemplate t;
public String saveOrder(PdOrder pdOrder) throws Exception {
String orderId = generateId();
pdOrder.setOrderId(orderId);//orderId，addId，userId，itemIdList
//转换并发送
//自动把数据变成byte[] 数组，再发送 convertAndSend封装了序列化数组
t.convertAndSend("orderQueue",pdOrder);
扫一扫
3494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
