Firefly

微服务阶段介绍

Sun, 14 Jun 2026 00:00:00 GMT

微服务阶段介绍

自我介绍#

“雪茄”（王道花名是这个、微信昵称也是这个）

湖南人

“卖彩票的”- 新浪

内推“东南亚捞钱”

19年加入王道

微服务阶段重要吗？#

19年：9天

20年：12天

21年：15天

22年：16天

23年：26天

24年: 33天

结论：根据授课安排的时间可以看出来，微服务越来越重要，成为工作和面试的必备技能。

内容出处:王道论坛往期道友贴

帖子一：45th

image-20230426233500453

帖子二：46th

image-20230426233602784

帖子三：43th

image-20230426234139957

帖子四：37th

image-20230426234353912

微服务阶段课程安排#

总体：大概33天

第一阶段#

大概7天

项目准备阶段：主要是介绍一些项目三中，或者是以后工作中可能会用到的知识，为做项目做准备

Linux
Nginx
Docker
Redis
微服务架构
SpringCloud（LoadBalancer、Eureka、Nacos、OpenFeign、Gateway）
MybatisPlus
MapStruct

第二阶段#

大约23天

项目阶段：开始做项目三，除了完成项目的业务以外，还会穿插介绍一些其他的项目中用到的技能

Maven工程聚合
Minio
布隆过滤器
分布式锁
异步编排
缓存优化
索引以及优化
ElasticSearch
RocketMQ
内网穿透
支付SDK接入
设计模式以及实战
单点登录
定时任务

……

项目演示

说明：整个项目三不再进行小组合作开发，而是需要大家独立完成。哪块没听懂，一定要及时问，避免掉队

第三阶段#

面试指导相关的内容，大约3天

面试题讲解
往期真实案例分析
简历指导

微服务阶段特点#

做项目的时候没有作业，但是上课讲知识点的时候会有作业
上课不再做随堂笔记
- 会给md版本的课件，大家可以自行修改补充
- 会画图，辅助大家理解
- 希望大家养成自己做笔记的好习惯
学习内容以“用” 为主，原理为辅
- 从进入JavaEE阶段（servlet）阶段以后，不再像JavaSE那样每一行代码，每一个小细节都去扣，没有那么细了。因为基本上都是在学习和使用别人写好的代码或者是框架。
- 对于这些框架而言，目前我们作为初中级程序员的要求，就是熟练使用，掌握基本原理。
- 在整个微服务阶段，会学习很多框架，类似与Spring、Mybatis、SpringMVC这样的框架。我们对于这些框架的第一学习目标，就是熟练使用，在项目中熟练运用。
- 熟练运用之后，需要大家以后在工作中不断提高
知识密度大，理解难度升级（如果大家听不懂了，及时给我反馈，及时沟通，多问问题）
紧靠面试（面试中问的特别多）

微服务阶段纪律要求#

不能在教室玩游戏（4km*4），看与学习无关的视频
上课不能睡觉
上课不能戴耳机（特殊情况可以跟我说明）
不能无故请假，请假需要通知班主任和我，企业微信抄送+单独说明
自习的时候不能玩手机，尤其是看视频和玩游戏

再次强调：最后一个阶段非常重要，希望大家不要懈怠，继续严格要求自己。

行百里者半九十。

Linux

Sun, 14 Jun 2026 00:00:00 GMT

Linux介紹#

Linux的前世今生#

Linux操作系统，被称之为类Unix操作系统，因此，要了解Linux的诞生就得先了解Unix操作系统

1
1. 1965 年开始的 Multics 工程计划，该计划由贝尔实验室、美国麻省理工学院和通用电⽓公司联合发起，目标是开发⼀种交互 式的、具有多道程序处理能⼒的分时操作系统，以取代当时⼴泛使用的批处理操作系统。
2
2. 在此期间，贝尔实验室的肯•汤普森，在Multics操作系统上开发了一款名为太空遨游的游戏，回到贝尔实验室之后，他也想在自己的计算机上玩这款游戏，于是就自己开发出了一个简化的分时操作系统，这就是Unix操作系统的雏形。
3
3. 为了提高操作系统的可移植性，肯•汤普森和丹尼斯•里奇共同发明了C语言

Linux 内核最初只是由芬兰人林纳斯·托瓦兹（Linus Torvalds）在赫尔辛基大学上学时出于个人爱好而编写的
Linux 是⼀套免费使用和自由传播的类 Unix 操作系统，是一个支持多用户、多任务、支持多线程和多 CPU 的操作系统
Linux 继承了 Unix 以网络为核心的设计思想，Linux 的初衷就是要替代UNIX，并在功能和用户体验上进行优化，所以 Linux 模仿了 UNIX（但并没有抄袭UNIX 的源码），使得Linux在外观和交互上与UNIX非常类似。

Linux的发行版本#

目前市面上较知名的发行版有：Ubuntu、RedHat、CentOS、Debian、Fedora、SuSE、OpenSUSE、Arch Linux、SolusOS、Deepin 等。

MIUI和colorOS有什么不同？

UI不一样
预装的软件不一样
应用市场（包管理器）不一样

Linux操作系統的組成#

UNIX或者Linux系统大致可以分为以下几个部分

硬件交互的操作系统内核
中间层是shell层
最外层是应用层

内核层: 内核层是 UNIX/Linux 系统的核心和基础，它直接附着在硬件平台之上，控制和管理系统内各种资源（硬件资源和软件资源），有效地组织进程的运行，从而扩展硬件的功能，提高资源的利用效率，为用户提供方便、高效、安全、可靠的应用环境。

Shell层: Shell 层是与用户直接交互的界面。用户可以在提示符下输入命令行，由 Shell 解释执行并输出相应结果或者有关信息，所以我们也把 Shell 称作命令解释器，利用系统提供的丰富命令可以快捷而简便地完成许多工作。

Linux的文件系统#

Linux操作系统中的文件类型#

在linux中，⼀切皆为文件。文件分为下面的⼀些类型

普通文件(-)
目录文件(d)
链接文件(l)
设备文件(b/c)
管道文件(p)

Linux操作系统的组织结构#

Linux文件系统目录结构和熟知的windows系统有较大区别，没有各种盘符的概念。根目录只有⼀个/，采用层级式的树状目录结构。

/：根目录，所有的目录、文件、设备都在/之下，/就是Linux文件系统的组织者，也是最上级的领导者。
/bin：bin 就是⼆进制（binary）英文缩写。在⼀般的系统当中，都可以在这个目录下找到linux常用的命令。系统所需要的那些命令位于此目录。
/boot：Linux的内核及引导系统程序所需要的文件目录。
/dev：dev 是设备（device)的英文缩写。这个目录对所有的用户都十分重要。因为在这个目录中包含了所有linux系统中使用的外部设备。但是这里并不是放的外部设备的驱动程序。这⼀点和常用的windows,dos操作系统不⼀样。它实际上是⼀个访问这些外部设备的端⼝。可以非常方便地去访问这些外部设备，和访问⼀个文件，⼀个目录没有任何区别。
/etc：管理所有的配置文件的目录，比如安装mysql的配置文件my.conf
/home：如果建立⼀个用户，用户名是”xx”,那么在/home目录下就有⼀个对应的/home/xx路径，用来存放用户的主目录。
/lib：lib是库（library）英文缩写。这个目录是用来存放系统动态连接共享库的。几乎所有的应用程序都会用到这个目录下的共享库。因此，千万不要轻易对这个目录进行什么操作，⼀旦发生问题，系统就不能工作了。
/mnt：可供系统管理员使用，手动挂载⼀些临时设备媒体设备的目录。
/root：Linux超级权限用户root的家目录。
/sbin：这个目录是用来存放系统管理员的系统管理程序。大多是涉及系统管理的命令的存放，是超级权限用户root的可执行命令存放地，普通用户⽆权限执行这个目录下的命令，sbin中包含的都是root权限才能执行的。
/usr：这是linux系统中占用硬盘空间最大的目录。用户的很多应用程序和文件都存放在这个目录下。 Unix software resource usr。类似windows系统的program files
/usr/local：这⾥主要存放那些手动安装的软件，即不是通过或apt-get安装的软件。它和/usr目录具有相类似的目录结构。
/usr/share ：系统共用的东西存放地，比如 /usr/share/fonts 是字体目录，/usr/share/doc和/usr/share/man帮助文件。
/media：是自动挂载的目录。当把U盘插入到系统中，会自动挂载到该目录下。比如插入⼀个U盘，会自动到/media目录中挂载。
/opt：额外安装软件存放的目录。比如mysql的安装包就可以放在该目录。
/proc：存储的是当前内核运行状态的⼀系列特殊文件，用户可以通过这些文件查看有关系统硬件及当前正在运行进程的信息，甚⾄可以通过更改其中某些文件来改变内核的运行状态。此外还有/srv /sys三个目录，内核相关目录，不要动。

Linux vs Windows#

目前国内 Linux 更多的是应用于服务器上，而桌面操作系统更多使用的是 Windows，主要区别如下

Linux安装#

云服务器#

自⼰安装服务器还是麻烦了些，现在⼀般都推荐大家使用云服务器，比较⽅便，价格也不贵。目前国内三家主流云服务器⼚商，阿⾥云、腾讯云、华为云

大家在选择操作系统镜像的时候，最好选择Ubuntu 18.04这个版本，内存选择4G或以上的版本

虚拟机#

软硬件准备#

软件：推荐使用VMware，服务器上有相关安装包，安装
镜像: 推荐使用ubuntu 18.04
因为是在宿主机上运行虚拟化软件安装ubuntu，所以对宿主机的配置有⼀定的要求。最起码I5CPU 双核，内存16G及以上。

安装步骤#

安装VMWare
打开VMWare，创建新的虚拟机
可以设置虚拟机的配置，内存，CPU，网络以及操作系统镜像等，其中我们将网络连接模式，我们使用NAT模式(默认就是这种模式)

有几点需要注意：
1. 磁盘空间-50G
2. 内存：4G（windows有16G的时候）或以上
3. 网络模式：NAT
启动虚拟机(启动安装过程可能需要等待)

设置静态IP#

说明，NAT模式默认情况下是DHCP模式，是自动获取IP的，导致每次虚拟机开启之后获取的IP可能会变化，假如项目中后续连接的是虚拟机上面的MySQL，那么MySQL的HOST地址可能会经常改变，这就需要我们经常去改项目中的MySQL的连接地址，比较麻烦。所以需要改为静态IP，也就是每次开机之后IP不会变，这样才能方便我们后面项目的开发。

首先查看虚拟机本地的IP地址，执行命令

Terminal window

1
# 查看本地IP地址
2
ifconfig
3

4
# 如果提示没有找到这个命令，那么首先需要安装工具
5
sudo apt install net-tools

image-20230320230756033

查看网关地址

编辑 ⇒ 虚拟网络编辑器 ⇒ VMnet8 ⇒ NAT设置

image-20230320232059604

点击NAT设置，即可看到如下图所示

image-20230320232229532
设置静态IP

设置 ⇒ Network ⇒ 点击齿轮

image-20230320232430561

设置为下图所示

image-20230320232846295

重启虚拟机，查看IP地址是否变化，如果未变，那么设置成功。

Linux Shell命令#

预备知识#

我们知道Linux的目录结构为树状结构，最顶级的目录为根目录 /，我们需要先知道什么是绝对路径与相对路径。

绝对路径：路径的写法，由根目录 / 写起，例如： /usr/share/doc 这个目录。

相对路径：路径的写法，不是由 / 写起，例如由 /usr/share/doc 要到 /usr/share/man 底下时，可以写成：cd ../man或cd man

实用高频命令#

pwd ：显示当前目录路径
ls: list directory contents，显示当前文件夹下的目录或文件

1
常用选项：
2
 -a 显示所有的文件夹和文件，包括隐藏文件
3
 -l 以详细的形式显示
4
例如：
5
[root@www /]# ls -l
6
total 12
7
drwxr-xr-x 2 cskaoyan cskaoyan 4096 Aug 2 20:58 cskaoyan
8
-rw-r--r-- 1 cskaoyan cskaoyan 0    Aug 2 20:47 main.txt
9
-rw-r--r-- 1 cskaoyan cskaoyan 14   Aug 2 20:11 test.txt

cd : 进入⼀个路径或者目录，绝对路径或者相对路径都可以

1
用法： cd [路径]
2
cd ~(代表进入当前登录用户的家目录)
3
cd . 进入当前目录
4
cd .. 进入上⼀级目录
5
cd /home 进入根目录下的home目录

Linux文件与目录管理#

目录文件#

mkdir: 创建新目录

1
mkdir 目录的相对路径或绝对路径

rmdir: 删除空目录

1
rmdir 目标目录的相对路径或绝对路径

rm: 移除文件或目录

1
-f ：就是 force 的意思，忽略不存在的文件，不会出现警告信息；
2
-i ：互动模式，在删除前会询问使用者是否动作
3
-r ：递归删除啊！最常用在目录的删除了！这是非常危险的选项！！！

cp: 复制文件或目录

1
 cp [-adfilprsu] 来源档(source) 目标档(destination)
2
 -a：相当於 -pdr 的意思，⾄於 pdr 请参考下列说明；(常用)
3
 -d：若来源档为连结档的属性(link file)，则复制连结档属性而非文件本身
4
 -p：连同文件的属性⼀起复制过去，而非使用默认属性(备份常用)
5
 -r：递归持续复制，用於目录的复制行为；(常用)

mv: 移动文件与目录，或修改文件与目录的名称(重命名)

1
 mv [-fiu] source destination
2
 -f ：force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖；
3
 -i ：若目标文件 (destination) 已经存在时，就会询问是否覆盖！
4
 -u ：若目标文件已经存在，且 source 比较新，才会覆盖 (update)

我们可以使用 man [命令] 来查看各个命令的使用文档，如：man cp。

普通文件#

创建文件

1
touch: 目标文件的相对路径或绝对路径

查看文件内容

cat命令：以只读的⽅式打开⼀个文件。可以加 -n 表示带上行号(适合查看文件内容比较少的)

more命令：和cat功能类似，不过是以分⻚的形式⼀⻚⼀⻚显示数据

1
cat [选项]  目标文件
2
选项:
3
    +n: 从笫n行开始显示
4
    -c: 从顶部清屏，然后显示
5
分页查看命令:
6
空格: 向后翻一页
7
b: 键就会往回（back）⼀⻚显示

less: 也用来分⻚显示数据，但是功能比more强大。并不会⼀次性将全部文件读取才显示，而是根据显示

的需要加载对应的数据。

1
less [选项] 目标文件
2
选项:
3
    -f ：强迫打开特殊文件，例如外围设备代号、目录和⼆进制文件
4
    -m ：显示类似more命令的百分比
5
    -N ：显示每行的行号
6
分页查看命令:
7
    f 向后翻⼀⻚
8
    d 向后翻半⻚
9
    h 显示帮助界面
10
    q 退出less 命令
11
    u 向前滚动半⻚
12
    b 向前滚动一页
13
    y 向前滚动⼀行

head: 查看⼀个文件，取开头的⼀部分内容

1
head -n 目标文件，表示查看目标文件的前n行内容，比如 head -5 a.txt

tail:查看⼀个文件的尾部内容

1
tail -n 目标文件，查看文件的最后n行内容，比如 tail -5 a.txt
2
tail -f filename,尾部持续不断地输出内容。Control + c退出
3
例如：tail -5f filename（在以后的工作中，查看系统，应用程序的日志最常见的一个命令）

重定向和追加

echo: 输出内容到控制台。

1
echo $PATH 输出Linux的环境变量到控制台

>命令：输出重定向（会将原来的内容覆盖）

Terminal window

1
echo hello > a.txt 将字符串hello, 写入a.txt文件
2
ls -l > a.txt 将目录信息，写入a.txt文件
3
cat a.txt > b.txt(文件可以存在，可以不存在) 将a.txt文件内容写入b.txt文件中

>>命令：追加（不会覆盖原文件的内容，追加到底部）

Terminal window

1
echo hello >> a.txt 将字符串hello, 追加 写入到a.txt文件
2
ls -l >> a.txt  将目录信息，追加 写入a.txt文件
3
cat a.txt >> b.txt(文件可以存在，可以不存在) 将a.txt文件内容写入b.txt文件中

压缩与解压缩

tar是用来建立，还原备份文件的工具程序，它可以加入，解开备份文件内的文件。

Terminal window

1
tar
2
-c:产⽣.tar文件
3
-v:显示详细信息
4
-z:打包同时压缩
5
-f:指定压缩后的文件名
6
-x:解压.tar文件
7
压缩: tar -zcvf combine.tar.gz 1.txt
8
解压: tar -zxvf combine.tar.gz -C java/
9
-C 表示解压到指定目录

如果需要解压和压缩为 .zip 格式的文件，那么需要安装zip和unzip命令

Terminal window

1
sudo apt install zip
2

3
# .zip文件的压缩(如果是目录文件的压缩，需要参数 -r)
4
zip (-r) xxx.zip xxx
5

6
# 解压
7
unzip xxx.zip

文本编辑#

Ubuntu默认没有安装vim，需要先安装vim工具。

1
sudo apt install vim

vim有三种模式：命令模式（Command mode）、插入模式（Insert mode）、末行模式（Last Linemode）。

命令模式

1
通过指令 vim filename 进入命令模式。除此之外，还有⼀些其他的参数，比如：
2
-R: 把指定的文件以只读的⽅式放入vim编辑器中
3
+: 打开文件，并把光标置于最后⼀行的⾸部
4
+n: 打开文件，并把光标置于第n行的⾸部
5

6
命令模式快捷键：
7

8
删除：
9
  x: 删除光标所在位置的字符
10
    dd: 删除光标所在行
11
    ndd: 删除当前行后n行文本（包括此行）
12
    dG: 删除光标所在行⼀直到文件末尾的所有内容
13
    D: 删除光标位置到行尾的所有内容
14
删除的内容此时并没有被真正删除，而是在剪切版中，按下 p 键，可以将删除的内容粘贴回来。
15

16
光标移动:
17
  w: 光标移动⾄下⼀个单词⾸
18
    e: 光标移动⾄下⼀个单词尾
19
    b: 光标移动⾄上⼀个单词⾸
20
    gg: 光标移动到文件开头
21
    G: 光标移动⾄文件末尾
22
    nG: 光标移动到第n行，n为数字
23
    0或^:光标移动⾄当前行的行⾸
24
    $: 光标移动⾄当前行的行尾

展开收起

插入模式

1
在命令模式下，通过按下i、I、a、A、o、O这6个字⺟进入插入模式，不同的字⺟代表不同的进入⽅式。
2
i: 在当前光标位置前面插入随后输入的文本，光标后的文本相应向右移动
3
I: 在光标所在行的行首插入随后输入的文本
4
o: 在光标所在行下面插入新的⼀行，然后光标停在空行⾸，等待输入文本
5
O: 在光标所在行上面插入新的⼀行，然后光标停在空行⾸，等待输入文本
6
a: 在当前光标位置后面插入随后输入的文本，光标后的文本相应向右移动
7
A: 在光标所在行的行尾插入随后输入的文本

按下ESC键离开插入模式，进入命令模式

末行模式

1
在命令模式下，按下: 键进入末行模式。
2
在该模式下，可以使用⼀系列的指令，完成保存、离开vim编辑器等功能。
3

4
:wq 保存并退出vim编辑器
5
:wq! 保存并强制退出vim编辑器
6
:q 不保存退出
7
:q! 不保存强制退出
8
:w 保存不退出
9
:w! 强制保存不退出
10
:w filename 另存到filename文件
11
ZZ 直接退出

三种模式之间的关系

用户管理#

Linux系统是⼀个多用户、多任务的操作系统。多用户是指在linux操作系统中可以创建多个用户，而这些多用户⼜可以同时执行各自不同的任务，而互不影响

在Linux系统中，会存在着以下几个概念:

用户名: 每个用户在操作系统中，都具有唯一用户名
用户所属的组：多个用户可以属于同一个用户组。
用户的家目录：在/home目录下，与该用户的用户名一致的目录。

添加用户#

sudo useradd [选项] 用户名

1
sudo useradd test
2
注意这种⽅式创建出来的没有家目录，我们创建的时候需要带参数
3
sudo useradd -m test: -m 表示在 /home目录下创建⼀个家目录
4
sudo useradd -m -s /bin/bash test: 表示指定shell版本是我们熟悉的bash

设置用户密码
```
1
sudo passwd [用户名]
```
切换用户
```
1
su [用户名]
```

删除用户#

sudo userdel [用户名]

-r: 不仅会删除该用户，还会删除该用户对应的家目录

用户组管理#

添加组

groupadd [groupname]

1
创建用户的时候加入组： useradd -m -s /bin/bash -g [groupname] [username]

查看用户及组信息

id 用户名
修改用户所属组

usermod -g [groupname] [username]

文件权限管理#

权限及命令#

1
ls -l
2
total 40
3
#文件信息 文件数 用户      组名   大⼩  ⽉份 ⽇期 时间 文件名
4
drwxr-xr-x 2   cskaoyan cskaoyan 4096  Aug  2  23:52 cskaoyan
5
prw-r--r-- 1   cskaoyan cskaoyan 0     Aug  2  23:43 fifo_file
6
-rw-r--r-- 1   cskaoyan cskaoyan 26825 Aug  3  00:25 main.txt
7
-rw-r--r-- 1   cskaoyan cskaoyan 33    Aug  3  00:37 test.txt
8
drwxr-xr-x 3   cskaoyan cskaoyan 4096  Aug  3  01:27 xxx

前10位字符的说明：

第1位：-表示是⼀个普通的文件；d表示是⼀个目录；
rwx：分别代表Read、Write、Execute即读、写、执行权限，这个顺序不会变，如果没有权限的话就用-代替
第2-4位：表示文件所有者的对于文件所具有的权限
第5-7位：表示和文件所有者同组的其他用户对文件所具有的权限
第8-10位：文件其他组用户拥有的权限

我们可以使用chmod命令，手动修改文件权限

第一种方式

1
chmod u=rwx,g=rw,o=r filename
2
u:所有者 g:所有组 o:其他组,a代表全部，没有就用空格替代

第二中方式

1
r=4,w=2,x=1 rwx = 4 + 2 + 1 = 7
2
chmod 751 等价于 u=rwx,g=rx,o=x

案例#

新建⼀个police组和⼀个gang组
police组新增⼀个成员叫刘⼩磊，另⼀个成员⼩警，gang组新增⼀个成员叫张大松，另⼀个成员强哥
将刘⼩磊和张大松的分组对调
刘⼩磊创建⼀个文件，写下：葵涌码头，⻰⿎滩收货。该文件权限自⼰可以读写，同组其他人员没有权限读写，其他组可以查看
张大松创建⼀个文件，写下：有内⻤，终⽌交易。该文件权限自⼰可以读写，同组其他人员没有权限读写，其他组可以读写
将刘⼩磊的账号销毁

1
#第⼀步
2
sudo groupadd police
3
sudo groupadd gang
4
#第⼆步
5
sudo useradd -m -s /bin/bash -g police liuxiaolei
6
sudo useradd -m -s /bin/bash -g police xiaojing
7
sudo useradd -m -s /bin/bash -g gang zhangdasong
8
sudo useradd -m -s /bin/bash -g gang qiangge
9
#给定密码
10
sudo passwd liuxiaolei
11
sudo passwd xiaojing
12
sudo passwd zhangdasong
13
sudo passwd qiangge
14
#第三步 卧底
15
sudo usermod -g police zhangdasong
16
sudo usermod -g gang liuxiaolei
17
#第四步 卧底传递情报
18
su liuxiaolei
19
sudo echo "葵涌码头，⻰⿎滩收货" > liuxiaolei.txt
20
chmod 704 liuxiaolei.txt
21
su zhangdasong
22
sudo echo "有内⻤，终⽌交易" > zhangdasong.txt

展开收起

进程管理#

查看进程#

Linux系统中查看进程使用情况的命令是ps命令，但是ps命令一般都不会单独使用

1
常⻅选项：
2
-e：显示所有进程
3
-f：全格式
4
a:显示终端上的所有进程
5
u:以用户的格式来显示进程信息
6
x:显示后台运行的进程

⼀般常用格式为ps -ef或者ps aux两种。显示的信息大体⼀致，略有区别。

1
UID：用户ID
2
PID：进程ID
3
PPID：⽗进程ID
4
C：CPU用于计算执行优先级的因⼦。数值越大，表明进程是CPU密集型运算，执行优先级会降低；数值越
5
   ⼩，表明进程是I/O密集型运算，执行优先级会提高
6
STIME：进程启动的时间
7
TTY：完整的终端名称
8
TIME：CPU时间
9
CMD：完整的启动进程所用的命令和参数

image-20210712175605494

1
USER：用户名称
2
PID：程号
3
%CPU：进程占用CPU的百分比
4
%MEM：进程占用物理内存的百分比
5
VSZ：进程占用的虚拟内存大⼩（单位：KB）
6
RSS：进程占用的物理内存大⼩（单位：KB）
7
TT：终端名称（缩写），若为？，则代表此进程与终端⽆关，因为它们是由系统启动的
8
STAT：进程状态，其中S-睡眠，s-表示该进程是会话的先导进程，N-表示进程拥有比普通优先级更低的
9
优先级，R-正在运行，D-短期等待，Z-僵死进程，T-被跟踪或者被停⽌等
10
STARTED：进程的启动时间
11
TIME：CPU时间，即进程使用CPU的总时间
12
COMMAND：启动进程所用的命令和参数，如果过⻓会被截断显示

ps -ef 与 ps aux的区别：

如果想查看进程的⽗进程ID和完整的CMD命令，可以使用ef
如果想查看进程的CPU占用率和内存占用率，可以使用aux

如果还想进一步筛选想要查询的目标进程信息，可以使用管道命令

1
#搜索匹配进程
2
ps -ef | grep [搜索内容]

终止进程#

kill [选项] 进程号

1
选项：
2
-9：操作系统从内核级别强制杀死⼀个进程
3
-15：可以理解为操作系统发送⼀个通知告诉应用主动关闭

服务管理#

服务本质上来说也是⼀个进程，只不过是在后台运行。监听着某⼀端⼝，等待该端⼝的请求到来，比如ssh服务监听着22端⼝，mysql服务监听着3306端⼝；

systemctl start/stop/restart/status/reload 服务名称

1
#比如关闭ssh服务
2
systemctl stop sshd

网络管理#

查看网络设置#

Terminal window

1
ifconfig
2

3
# 如果提示没有该命令，可以安装该命令
4
sudo apt install net-tools

查看网络端口占用#

netstat

Terminal window

1
 -a:显示全部
2
 -n:以数字的形式显示
3
 -p:显示该连接被哪个应用程序占用PID
4
eg:
5
netstat -anp | grep 3306

lsof -i: 端⼝号

测试网络是否正常#

Terminal window

1
ping [目的ip或者域名]

Terminal window展开收起

1
# 在Linux操作系统中，应该要掌握的一些常见的命令（面试中可能会问的）
2
pwd ls cd
3

4
# 1. vim的掌握是必须的
5
# 2. 权限的掌握是必须的
6
# 3. 日志的查看是必须要会的（工作中经常会用的）
7
cat | less more | tail -nf xxx.log
8

9
# 4. 搜索进程
10
ps -ef | grep pid|name
11
ps aux | grep pid|name
12
# 5. 关闭进程
13
kill -9
14

15
# 6. 查看端口号是否被占用
16
netstat -anp | grep port
17
(windows: netstat -ano | findstr 3306)
18

19
# 7. 类似于任务管理器，查看当前系统的运行情况
20
top

展开收起

Linux 远程软件的安装#

远程连接软件#

安装软件，使得我们可以通过ssh协议远程连接Linux服务器。

什么是ssh协议？

SSH 为 Secure Shell 的缩写，由 IETF 的⽹络工作⼩bai组(Network Working Group)所制定;SSH为建⽴在应用层和传输层基础之上的安全协议。SSH 是目前较可靠，专为远程登录会话和其他⽹络服务提供安全性的协议

如何使用ssh协议远程连接服务器？

⾸先需要在目标服务器上安装ssh服务（Ubuntu 16 默认自带了这个服务）

Terminal window

1
#查看ssh服务是否启动
2
ps -aux|grep sshd
3
#如果出现sshd进程则表示已经启动，如果没有出现那么执行下面的命令
4
#更新apt源
5
sudo apt update
6
#安装ssh
7
sudo apt install openssh-server
8
#安装完之后再次查看sshd是否已经启动，如果没有启动的话执行以下命令启动
9
sudo service ssh restart
10

11

12
# 注意，如果是刚装的新的虚拟机执行sudo apt update命令报错，执行如下命令之后在执行update命令即可
13
sudo apt-get install --reinstall libappstream4

在目标服务器上安装ssh服务之后需要在本机也安装ssh客户端的软件，可以安装的ssh协议客户端软件有很多，例如xshell、SecrueCRT、Iterm、Iterm2等等

远程文件传输#

需要使用ftp软件实现，本地主机和远程服务器主机的文件传输。

FTP（File Transfer Protocol，文件传输协议）是 TCP/IP 协议组中的协议之⼀。FTP协议包括两个组成部分，其⼀为FTP服务器，其⼆为FTP客户端。其中FTP服务器用来存储文件，用户可以使用FTP客户端，通过FTP协议访问位于FTP服务器上的资源

如何使用？安装 winscp ， filezila 或者是 transmit 软件即可。

开发环境的搭建#

在Linux上安装应用程序，一般有这几种方式

Terminal window

1
# 1. 通过包管理器来安装
2

3

4
# 2. 通过解压包来安装
5

6

7
# 3. 通过源码来安装（需要先下载源码，然后自己编译）

JDK环境搭建#

从oracle官网下载linux的jdk17，之后用winscp工具等将jdk17上传到linux机器上
解压tar.gz到某个目录下

Terminal window

1
sudo mkdir /usr/local/java
2
cd /usr/local/java
3
sudo tar -zxvf jdk-17_linux-x64_bin.tar.gz
4
sudo mv jdk-17.0.10/ jdk

配置JDK的环境变量
1. 进入配置文件 sudo vim /etc/profile
2. 编辑文件，在文件末尾添加环境变量
  Terminal window
```
1
export JAVA_HOME=/usr/local/java/jdk
2
export CLASSPATH=.:$JAVA_HOME/lib
3
export PATH=$JAVA_HOME/bin:$PATH
```

退出文件编译之后，执行如下命令，让配置文件生效
```
1
  source /etc/profile
```
执行命令 java -version 查看JDK环境变量是否已经搭建好

Tomcat的安装#

Terminal window

1
#先把tomcat压缩包丢进服务器⾥面去
2
mkdir /usr/local/java/tomcat
3
# 进入/usr/local/java/tomcat 目录
4
sudo tar -zxvf apache-tomcat-9.0.87.tar.gz
5

6
# 赋予权限
7
sudo chmod -R 777 /usr/local/java/tomcat
8

9
cd bin
10
#启动tomcat
11
./startup.sh

MySQL环境搭建#

使用apt工具安装mysql

Terminal window

1
sudo apt update
2
sudo apt install mysql-server
3
#如果是ubuntu 16.04 那么此时会要求你输入密码，如果是18.04，那么就直接完成安装了

本地连接修改ROOT密码#

Ubuntu18.04 安装完之后修改mysql密码，我们先使用mysql的一个默认用户名和密码登录，需要先找到这个用户名和密码

1
sudo cat /etc/mysql/debian.cnf

image-20210713105119021

以上一步中得到的用户名和密码登录mysql，修改root用户的密码为我们想要的密码

1
#登陆mysql5.7
2
mysql -u debian-sys-maint -p
3
#修改用户名密码
4
use mysql;#连接到mysql数据库
5
update user set authentication_string=password('123456') where
6
user='root' and Host ='localhost' #修改密码123456是密码
7
update user set plugin="mysql_native_password"
8
flush privileges;
9
quit
10

11
#如果是mysql8则执行以下语句
12
mysql -u debian-sys-maint -p
13
#修改用户名密码
14
use mysql;#连接到mysql数据库
15
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码';
16
flush privileges;
17
quit

展开收起

重启mysql服务

1
#重启mysql
2
systemctl restart mysql

远程连接#

如果我们需要，远程用navicat基于mysql协议连接，虚拟机中的mysql怎么办呢？

基于MySQL协议#

修改被连接的mysql服务的配置，进入/etc/mysql/mysql.conf.d目录，用vim打开配置文件

在mysql数据库中，增加远程连接的root用户，并赋予其权限

mysql5.7

1
mysql -uroot -p
2
use mysql;
3
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;
4
flush privileges;
5
exit;
6

7
# mysql8
8
create user 'root'@'%' identified by '123456';
9
grant all privileges on *.* to 'root'@'%';
10
FLUSH PRIVILEGES;
11
exit;

重启MySQL服务

1
#重启mysql
2
systemctl restart mysql

然后就可以通过navicat，基于mysql协议远程连接mysql服务了

基于SSH协议#

我们还可以基于ssh协议，远程连接Mysql，此时

然后点击测试连接，测试连接是否成功

Nginx

Sun, 14 Jun 2026 00:00:00 GMT

Nginx简介#

什么是Nginx#

Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambler.ru站点（俄文：Рамблер）开发的，第一个公开版本0.1.0发布于2004年10月4日。

Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，在BSD-like 协议下发行。其特点是占有内存少，并发能力强，事实上nginx的并发能力在同类型的网页服务器中表现较好，中国大陆使用nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等。

Nginx的核心功能#

Nginx最核心的两个功能：

高性能的静态web服务器
反向代理

正向代理vs反向代理

image-20210713152405322

1
如上图，上边边是正向代理，下边边是反向代理
2
正向代理：代理服务器是代表用户客户端去访问后端服务器，代理的对象是前面的用户
3
反向代理：代理服务器是代表后端服务器供客户端去访问，对于前面的用户来说是无感知的，代理的对象是后面的后台服务器

Nginx的优势#

高并发、高性能
扩展性好（模块化设计）
异步非阻塞的事件驱动模型
高可靠性（热部署、7*24）

Ngnix的使用#

Nginx的安装#

Ubuntu安装Nginx 非常方便，可以直接使用apt源来安装

Terminal window

1
sudo add-apt-repository ppa:nginx/stable
2
sudo apt-get update
3
sudo apt-get install nginx

执行以上三条指令即可完成安装

执行命令查看是否安装成功

Terminal window

1
nginx -v

安装之后Nginx的目录组成

在 /etc/nginx 目录下可以看到nginx的配置文件nginx.conf

如上图所示，主配置文件是nginx.conf，而Nginx的指令放在/usr/sbin/nginx，日志文件放在/var/log/nginx中

Terminal window

1
# 程序的路径
2
/usr/sbin/nginx
3

4
# 配置文件的路径
5
/etc/nginx/nginx.conf
6

7
# 日志文件的路径
8
/var/log/nginx

Nginx常用命令#

找到Nginx执行命令，以Ubuntu18.04为例

Terminal window

1
#启动命令
2
sudo nginx
3
#关闭命令
4
sudo nginx -s stop
5
#重载命令
6
sudo nginx -s reload

Nginx配置文件#

核心配置文件就是nginx.conf，打开这个核心配置文件
配置文件中有很多#，开头的表示注释内容，我们去掉所有以 # 开头的段落，精简之后的内容如下：

根据上述文件，我们可以很明显的将 nginx.conf 配置文件分为三部分：

全局配置#

从配置文件开始到 events 块之间的内容，主要会设置一些影响 nginx 服务器整体运行的配置指令，主要包括配置运行 Nginx 服务器的用户（组）、允许生成的 worker process 数，进程 PID 存放路径、日志存放路径和类型以及配置文件的引入等。

比如上面第一行配置的：

Terminal window

1
user www-data;  #运行worker子进程的用户
2
worker_processes auto; #子进程的个数
3
pid /run/nginx.pid; #运行master的pid文件存放的路径
4
include /etc/nginx/modules-enabled/*.conf; #将其他配置文件包含进来

这是 Nginx 服务器并发处理服务的关键配置，worker_processes 值越大，可以支持的并发处理量也越多，但是会受到硬件、软件等设备的制约

events配置#

比如上面的配置：

1
events {
2
  worker_connections 768;
3
}

events 块涉及的指令主要影响 Nginx 服务器与用户的网络连接，常用的设置包括是否开启对多 work process 下的网络连接进行序列化，是否允许同时接收多个网络连接，选取哪种事件驱动模型来处理连接请求，每个 word process 可以同时支持的最大连接数等。上述例子就表示每个 work process 支持的最大连接数为 768，这部分的配置对 Nginx 的性能影响较大，在实际中应该灵活配置。

http配置#

这算是 Nginx 服务器配置中最频繁的部分，代理、缓存和日志定义等绝大多数功能和第三方模块的配置都在这里。需要注意的是：http 块也可以包括 http 全局块、server 块。

1. http全局块

http 全局块配置的指令包括文件引入、MIME-TYPE 定义、日志自定义、连接超时时间、单链接请求数上限等。

2. server块

这块和虚拟主机有密切关系，虚拟主机从用户角度看，和一台独立的硬件主机是完全一样的，该技术的产生是为了节省互联网服务器硬件成本。
每个 http 块可以包括多个 server 块，而每个 server 块就相当于一个虚拟主机。
而每个 server 块也分为全局 server 块，以及可以同时包含多个 locaton 块。

配置详解

Terminal window展开收起

1
########### 每个指令必须有分号结束。#################
2
#user administrator administrators;  #配置用户或者组，默认为nobody nobody。
3
#worker_processes 2;  #允许生成的进程数，默认为1
4
#pid /nginx/pid/nginx.pid;   #指定nginx进程运行文件存放地址
5
error_log log/error.log debug;  #制定日志路径，级别。这个设置可以放入全局块，http块，server块，级别以此为：debug|info|notice|warn|error|crit|alert|emerg
6
events {
7
    accept_mutex on;   #设置网路连接序列化，防止惊群现象发生，默认为on
8
    multi_accept on;  #设置一个进程是否同时接受多个网络连接，默认为off
9
    #use epoll;      #事件驱动模型，select|poll|kqueue|epoll|resig|/dev/poll|eventport
10
    worker_connections  1024;    #最大连接数，默认为512
11
}
12
http {
13
    include       mime.types;   #文件扩展名与文件类型映射表
14
    default_type  application/octet-stream; #默认文件类型，默认为text/plain
15
    #access_log off; #取消服务日志
16
    log_format myFormat '$remote_addr–$remote_user [$time_local] $request $status $body_bytes_sent $http_referer $http_user_agent $http_x_forwarded_for'; #自定义格式
17
    access_log log/access.log myFormat;  #combined为日志格式的默认值
18
    sendfile on;   #允许sendfile方式传输文件，默认为off，可以在http块，server块，location块。
19
    sendfile_max_chunk 100k;  #每个进程每次调用传输数量不能大于设定的值，默认为0，即不设上限。
20
    keepalive_timeout 65;  #连接超时时间，默认为75s，可以在http，server，location块。
21

22
    upstream mysvr {
23
      server 127.0.0.1:7878;
24
      server 192.168.10.121:3333 backup;  #热备
25
    }
26
    error_page 404 https://www.baidu.com; #错误页
27
    server {
28
        keepalive_requests 120; #单连接请求上限次数。
29
        listen       4545;   #监听端口
30
        server_name  127.0.0.1;   #监听地址
31
        location  ~*^.+$ {       #请求的url过滤，正则匹配，~为区分大小写，~*为不区分大小写。
32
           #root path;  #根目录
33
           #index vv.txt;  #设置默认页
34
           proxy_pass  http://mysvr;  #请求转向mysvr 定义的服务器列表
35
           deny 127.0.0.1;  #拒绝的ip
36
           allow 172.18.5.54; #允许的ip
37
        }
38
    }
39
}

展开收起

Nginx核心功能#

反向代理#

反向代理配置

Terminal window展开收起

1
http{
2
  ...
3
  ...
4
  #这部分是nginx作为反向代理服务器的配置
5
  server{
6
      #nginx监听的端口
7
      listen  80;
8
      #虚拟服务器的识别标记，一般配置为本机ip
9
      server_name 192.168.45.151;
10
      #代理设置地址
11
      location / {
12
          proxy_pass http://192.168.45.151:8080;
13
      }
14
  }
15
}

展开收起

集群及负载均衡配置

Terminal window

1
#负载均衡策略
2
# 1 轮询（默认）
3
# 2 weight
4
# 3 ip_hash
5
# 4 least_conn 最少连接方式
6
# 5 fair(第三方) 响应时间
7
# 6 url_hash (第三方)

Terminal window

1
#weight weight 代表权重,默认为 1,权重越高被分配的客户端越多
2
...
3
  upstream cskaoyan{
4
    server 192.168.45.151:8080 weight=2;
5
    server 192.168.45.151:8081 weight=1;
6
  }
7
...

Terminal window

1
#ip_hash 每个请求按访问 ip 的 hash 结果分配，这样每个访客固定访问一个后端服务器，可以解决 session 的问题。例如：
2
...
3
  upstream cskaoyan{
4
    ip_hash;
5
    server 192.168.45.151:8080;
6
    server 192.168.45.151:8081;
7
  }
8
...

注意，这里为了不让，浏览器自动发起的，获取应用图标的请求，干扰我们的测试结果，我们给server添加如下的location映射

1
    location /favicon.ico {
2
    }

Docker

Sun, 14 Jun 2026 00:00:00 GMT

image-20230322004354440

背景介绍#

容器技术的起源#

假如我们正在开发一个名叫“谁是小黑子”的应用，程序员自己从头到尾搭建了一套环境开始写代码，写完代码后程序员要把代码交给测试同学测试，这时测试同学开始从头到尾搭建这套环境，测试同学测完后终于可以上线了，这时运维同学又要重新从头到尾搭建这套环境，费了九牛二虎之力搭建好环境开始上线，糟糕，上线系统就崩溃了。

image-20230321173307331

不难看出，不管是开发，还是测试，还是运维，想要运行我们的应用程序，都需要从头开始搭建环境，如果环境没有搭建好，那么我们的应用程序就运行不起来。这种做法，不仅仅会大大增加各个岗位的工作量，还可能引发一些不必要的…

image-20230321173518316

从以上整个过程可以看到，在从开发到上线的过程中，反复搭建了三套环境，这个过程十分浪费时间与效率，而聪明的程序员们是永远不会满足现状的。所以，容器技术应运而生。

虚拟机技术#

针对以上的情况，聪明的同学可以想到，其实可以使用VMware虚拟机，先搭建好一套虚拟机环境，然后克隆出来分别交给开发、测试和运维，这样就可以解决反复搭建环境的痛点了。

image-20230321175700983

通过上图可以知道，这确实是一个不错的办法，不过也不是一个完美的解决办法。

因为我们的本意是在开发环境、测试环境和生产环境，部署并运行我们JAVA应用程序所依赖的其他应用，如上图中的MySQL、Nginx和Redis，但是现在我们在这三个环境中都运行了一个虚拟机，在这个虚拟机中运行了我们所需要的应用。

而虚拟机本身又运行了一个操作系统，操作系统是很笨重的，需要消耗更多的资源。

image-20230321231902929

在上面的案例中，以开发环境为例

image-20230321232442604

由上图不难看出，因为虚拟机的存在，消耗了更多的内存资源，其实不仅仅是内存资源，还有CPU和磁盘等资源。

在这里有同学可能会有疑问：那我在右边的图中对虚拟机分配3G内存不就行了吗？其实不行，因为在这个虚拟机操作系统中，不光光要运行MySQL、Nginx、Redis等应用程序（也可以简单理解为进程），还需要运行一些额外的系统进程，比如说会话管理器、登录服务、任务管理器
以下以windows操作系统为例，举例说明一些额外的系统进程，Linux等操作系统也是类似的。
image-20230321234009210

那么有没有一种技术，既能获得虚拟机的好处（只需要部署一次，部署快速简单），又能克服虚拟机的缺点（操作系统笨重，需要消耗更多的资源）呢？

答案是肯定的，这就是容器技术。

容器#

容器，英文是container，其实container还有集装箱的意思。

集装箱的特点：

集装箱之间互相隔离
长期反复使用
快速装载与卸载
规格标准，在任何码头上都可以摆放

image-20230322000113660

其实容器和集装箱的概念特别类似，集装箱是为了货物之间的隔离，容器也是为了应用程序之间的隔离。其实虚拟机本质上也是一个隔离技术，隔离出宿主机的各个操作资源。

image-20230322003051606

不过与虚拟机技术不同的是，虚拟机是在操作系统层面实现的隔离，而容器技术只隔离应用程序的运行时环境，但容器之间可以共享同一个操作系统。 通过上图不难看出，容器更加轻量而且占用的资源更少，与宿主机的交互更快更直接，所以容器内的应用启动更加迅速，容器相比较与虚拟机是一种更加高效的技术。

我们要学习的Docker就是是容器引擎的一种实现，除了Docker之外，容器引擎还有很多，比如podman（开源），pouch(阿里)

Docker介绍#

Docker是一个开源的应用容器引擎，基于Go（协程）语言并且遵从Apache2.0协议开源。

Docker将程序以及程序所有的依赖都打包在一起，运行在一个Docker容器中，这样你的程序可以在任何环境都会有一致的表现，这里程序运行的依赖也就是容器就好比集装箱，容器所处的操作系统环境就好比货船或港口，程序的表现只和集装箱有关系(容器)，和集装箱放在哪个货船或者哪个港口(操作系统)没有关系。

Docker的口号：“build once, run everywhere”。一次构建，处处运行。

核心概念#

镜像（Image）

Docker镜像就类似于操作系统的镜像（比如之前安装虚拟机使用到的Ubuntu18），是一个只读的模版。一个镜像中包含了一个或多个特定的应用程序以及运行他们所依赖的应用程序。
容器（Container)

把镜像下载到本地，容器就是从镜像创建的应用运行实例。它可以启动、开始、停止、删除，而这些容器都是彼此相互隔离、互不可见的。
仓库（Repository）

仓库是集中存放镜像文件的场所。推荐使用的是官方仓库地址，网易云仓库。当然，企业也可以搭建自己的仓库。

image-20230322101913959

安装#

准备工作#

Terminal window

1
# 需要先执行更新命令
2
sudo apt-get update
3

4
# 如果是新安装的虚拟机，执行失败，那么执行以下命令
5
sudo apt-get install --reinstall libappstream4

如果虚拟机上已经存在docker，那么需要先卸载可能存在的旧版本

Terminal window

1
# 查找docker相关的软件
2
dpkg -l |grep docker

image-20230322005325805

如上图所示，查到一个docker，还有一个docker.io，需要删除掉

Terminal window

1
# --purge: 删除软件以及相关的配置文件
2
sudo apt-get remove --purge docker docker.io

安装docker#

安装docker的方式有很多种，这里推荐大家采用shell脚本的方式进行安装

Terminal window展开收起

1
# 下载curl工具
2
sudo apt install curl
3

4

5
####################################################### 弃用了##############################################
6
# 安装方式1
7
# 安装docker
8
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
9

10
# 安装方式2
11
# 下载安装脚本
12
curl -fsSL https://get.docker.com -o get-docker.sh
13
# 执行安装脚本
14
sudo sh ./get-docker.sh
15

16
####################################################### 现在的安装方式  ##############################################
17
sudo apt install ca-certificates curl gnupg lsb-release
18

19
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
20

21
# 新增软件源，并下载docker
22
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
23
sudo apt install docker-ce docker-ce-cli containerd.io
24

25
# 检查docker是否安装完成，先切换到root用户
26
sudo -i

展开收起

查看docker版本

Terminal window

1
docker version

image-20230322005352532

出现上图，表示docker安装成功。

docker配置#

权限配置#

注意上面查看docker版本的执行命令结果的图中，出现了一个permission denied ... 的报错，此时是因为当前用户对docker命令没有执行权限造成的，那么可以在docker version 这个命令的前面添加sudo解决这个问题，不过每次执行都添加sudo比较麻烦，而且后续使用docker下载镜像，运行容器，还需要大量的执行docker ... 命令，可以在这里执行以下命令将当前用户添加到docker组，来获取权限

Terminal window

1
# 添加docker用户组
2
sudo groupadd docker
3

4
# 将当前登录用户添加到docker用户组中
5
sudo gpasswd -a $USER docker
6

7
#更新用户组
8
newgrp docker
9

10
# 测试docker命令是否可以在当前用户下正常使用
11
docker version

image-20230322005405297

如上图所示，docker权限配置好了之后，会显示出更多更完整的信息

如果出现以下提示，那么需要/var/run/docker.sock的 777权限

image-20230322005420325

Terminal window

1
# 添加权限
2
sudo chmod a+rw /var/run/docker.sock

设置开机自启

Terminal window

1
sudo systemctl enable docker

镜像仓库加速#

由于国内用户下载Docker镜像文件的速度太慢（因为Docker官方镜像仓库的服务器地址在国外），所以我们需要配置Docker镜像加速地址，提高镜像文件下载速度，就像MAVEN镜像仓库一样。

这里推荐使用阿里云镜像仓库加速配置。【官方配置地址】

Terminal window

1
# 修改docker配置文件
2
sudo vim /etc/docker/daemon.json

在文件中，输入上面官方配置地址中的以下内容（不同用户的加速地址不一致）

Terminal window

1
{
2
  "registry-mirrors": ["https://b66kcrvu.mirror.aliyuncs.com"]
3
}

Terminal window

1
# 加载新的配置文件
2
sudo systemctl daemon-reload
3

4
# 重启docker
5
sudo systemctl restart docker

验证docker镜像加速配置是否成功

Terminal window

1
# 查看docker详细信息
2
docker info

image-20230322005743946

补充说明：docker镜像加速地址有很多，也可以配置别的镜像加速地址

Docker官方：https://registry.docker-cn.com

网易：http://hub-mirror.c.163.com

中科大：https://docker.mirrors.ustc.edu.cn

腾讯云：https://mirror.ccs.tencentyun.com

如果速度不如预期，也可以在daemon.json中配置其他的镜像加速地址
说明：由于政策原因，上面的加速地址暂时都不可用了
大家可以使用这个加速地址:
https://docker.m.daocloud.io/
https://dockerpull.com

使用#

镜像相关的命令#

想要启动一个容器，首先需要找到它的镜像的。镜像相关的命令如下：

列出本机的所有镜像：
Terminal window
```
1
docker images
2
#REPOSITORY     TAG       ID           CREATED     SIZE
3
#nginx         1.21.6       0e901e68141f     6 weeks ago   142MB
```
这个命令会展示镜像的信息：包括镜像的仓库源(REPOSITORY)、标签(TAG)、镜像ID(IMAGE ID)、创建时间和大小。-

从仓库当中拉取镜像到本地：

Terminal window

1
docker pull nginx:1.21.6
2
#1.21.6: Pulling from library/nginx
3
#42c077c10790: Pull complete
4
#62c70f376f6a: Pull complete
5
#915cc9bd79c2: Pull complete
6
#75a963e94de0: Pull complete
7
#7b1fab684d70: Pull complete
8
#db24d06d5af4: Pull complete
9
#Digest: sha256:2bcabc23b45489fb0885d69a06ba1d648aeda973fae7bb981bafbb884165e514
10
#Status: Downloaded newer image for nginx:1.21.6
11
#docker.io/library/nginx:1.21.6

拉取镜像的来源地是仓库——一般使用的是公共仓库，比如默认的hub.docker.com，团队自己也可以建立私有仓库。

删除本地镜像：
Terminal window
```
1
docker rmi 镜像id | nginx:1.21.6
```

容器相关的命令#

创建并启动容器#

通过docker run命令可以从镜像当中启动容器。

Terminal window

1
docker run 镜像的名称

默认情况，执行docker run的效果会寻找镜像，如果相应的镜像不存在，那么会自动从公开仓库当中拉取；然后启动运行容器；随后附加的命令，在本例中附加命令为空。对应nginx容器，就会进入容器内部nginx的交互终端，可以使用ctrl+c从容器当中退出，但是同时也会停止容器。

如果给容器指定附加指令，对于nginx容器而言，会直接执行该指令，随后容器就停止了。

Terminal window

1
docker run nginx echo hello
2
hello

使用—help选项可以获取命令的简明帮助：

Terminal window

1
docker run --help
2
# -i, 以交互模式运行容器，通常与 -t 同时使用
3
# -t, 为容器重新分配一个伪输入终端，通常与 -i 同时使用
4
# -d, 后台运行容器，并返回容器ID
5
# --name="nginx-cskaoyan": 为容器指定一个名称
6
# -e username="cskaoyan": 设置环境变量参数

Terminal window

1
# -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
2
# -v: 文件挂载，映射文件

假如需要进入容器内部，通过shell命令和容器交互

Terminal window

1
docker run -it nginx /bin/bash

上述命令执行之后，用户就可以进入容器内部，像使用一个普通的shell操作容器内部文件系统。使用ctrl+d可以退出容器并停止容器。

使用-d选项可以以守护进程的形式运行容器：

Terminal window

1
docker run -d nginx

查看容器#

我们还可以查看容器

Terminal window

1
docker ps  # 列出运行当中的容器
2
docker ps -a  # 列出所有的容器
3

4
docker rm 容器名|ID  # 删除停止状态的容器

Terminal window

1
# 容器id        镜像      启动命令                 创建时间          状态       端口映射      容器的名字
2
#CONTAINER ID      IMAGE     COMMAND                 CREATED         STATUS    PORTS       names
3
#d05375d418cf     nginx     "/docker-entrypoint.."  9 seconds ago   Exited    0.0.0.0:80->80    57th-first-nginx

进入运行中的容器#

假若一个容器已经存在并且正在运行，使用docker exec 进入容器

Terminal window

1
docker exec -it 容器名 /bin/bash
2

3
# 如何退出呢？
4
ctrl + d

查看容器日志#

Terminal window

1
# 容器日志查看
2
docker logs [-f] 容器ID|容器名

容器的启停命令#

当然也可以停止、启动、重启或者是删除容器

Terminal window

1
# 停止容器
2
docker stop 容器ID|容器名
3

4
# 启动容器
5
docker start 容器ID|容器名
6

7
# 重启容器
8
docker restart 容器ID|容器名

容器的删除命令#

Terminal window

1
# 删除容器
2
docker rm 容器ID|容器名

端口映射#

容器天生具有隔离的特性，所以不同的容器拥有独立的网络系统。这样的话，两个不同的容器在容器内部完全可以使用相同的端口，并且可以使用宿主机当中已经使用的端口——这些相同的端口号实际上是毫无关联的，彼此之间也无法进行网络通信。如果希望通过容器来对外提供服务，就需要为容器的端口和宿主机的端口建立映射。

使用docker run的-p选项可以实现端口映射：

Terminal window

1
# 将宿主机的8080端口映射到容器的80
2
# -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
3
docker run -d -p 8080:80 nginx

image-20230322120548829

文件映射#

容器天生具有隔离的特性，所以不同的容器拥有独立的文件系统。在容器内部做任何的修改，都不会影响到宿主机或者其他容器。如果容器一旦被删除，那么容器中的一切数据就都不存在了，所以如果想要让容器再被删除之后，仍然可以访问到容器中的数据（比如对于数据库类型中的数据），就需要将容器内部的某个目录映射到宿主机文件系统当中，从而让数据保存到宿主机，这样一来，即使容器被删除了，我们也可以在宿主机中访问到之前容器中的数据

使用docker run 的-v可以实现数据持久化：

Terminal window

1
docker run -d -p 8081:80 -v /tmp/test:/usr/share/nginx/html nginx

image-20230322135343202

容器中访问的/usr/share/nginx/html和宿主系统的/tmp/test的内容是一致，并且任何形式的修改都会在宿主系统和容器当中共享。

Terminal window

1
# 在容器内部执行
2
echo "<html>hello world</html>" > /usr/share/nginx/html/index.html
3
# 相当于在宿主系统当中执行
4
sudo echo "<html>hello world</html>" > /tmp/test/index.html

Redis

Sun, 14 Jun 2026 00:00:00 GMT

引入#

迄今为止，互联网的发展已经经历了两个阶段web1.0和web2.0

web 1.0时代，网站是静态的(通常是一些简单的文字和图片)，也就是网站创建什么内容，用户就获取什么内容，这是一个单方面的信息传递，没有任何互动，比如以前的中国三大门户网站：搜狐、新浪、网易，就是Web1.0的典型代表。
Web2.0 强调内容的互动，用户不再只是内容接收方，而可以成为内容的提供方，平台的共建者，于是我们就进入了数据爆炸的时代

传统的关系型数据库在应付web2.0网站，特别是超大规模和高并发的web2.0纯动态网站已经显得力不从心，暴露了难以克服的问题：

High performance 对数据库高并发写的需求。web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，因此数据库并发负载非常高，往往要达到每秒上万次读写请求，关系型数据库应付上万次的SQL查询还勉强顶得住，但是应付上万次的SQL写数据请求，硬盘IO就已经无法承受了
Huge Storage 对海量数据的高效存储和访问的需求。对于大型的SNS网站，每天用户产生海量的用户动态信息，以国外的Friend feed为例子，一个月就达到了2.5亿条用户动态，对于关系型数据库来说，在一张2.5亿条记录的表里进行SQL查询，效率是极其低下乃至不可忍受的，再如大型web网站用户登录系统，比如腾讯、盛大、动辄数亿计的账号、关系数据库也很难以应付。

同时，对于web2.0网站来说，关系数据库的很多主要特性却往往无用武之地。比如：

很多web实时系统并不要求严格的数据库事务，对读一致性的要求很低，有些场合对写一致性要求也不高，因此数据库事务管理成了数据库高负载下一个沉重的负担。
任何大量数据的web系统，都非常忌讳多个大表的关联查询，以及复杂的数据分析类型的复杂SQL报表查询，从需求以及产品设计角度，我们也会尽量避免这种情况的产生，往往更多的只是单表的主键查询，以及单表条件分页查询，SQL功能的被极大的弱化了

因此关系数据库在这些越来越多的应用场景下显得不那么合适了，为了解决这一问题的NoSQL数据库应运而生。而Redis就是一个典型的NoSQL数据库。和传统的关系数据库相比，Redis是一个纯内存数据库，存储非结构化的key-value键值对。

介绍#

Redis是一个NoSQL数据库。

NoSQL: not only SQL。表示非关系型数据库（不支持SQL标准语法）。

Redis是一个使用C语言编写的、免费的、开源的、支持网络、可基于内存、亦可持久化的日志型，key-value 非关系型数据库，并且提供多种语言的API

C语言编写的

开源的（https://github.com/redis）中文官网:https://www.redis.net.cn/ 命令参考网站：http://doc.redisfans.com/

可基于内存：是把数据存在到内存上的

可持久化：可以把内存里面的数据持久化到磁盘(为了实现数据恢复)

key-value：数据在内存中是以键值对的方式来存储的

支持网络：客户端是通过网络连接服务端的

支持多种语言：可以在各种语言的代码中操作Redis

安装#

Redis官方其实是不支持windows操作系统的。

但是windows的工作团队给redis提供了适配，让Redis能够支持windows。

下载#

image-20221019114805584

解压#

image-20221019115320041

启动#

启动服务端#

打开Redis的解压目录

在此处打开cmd命令行

执行命令

redis-server.exe redis.windows.conf#

image-20221020093334606

启动客户端#

进入解压路径

输入cmd

执行命令

redis-cli.exe [-h localhost] [-p 6379]

Redis核心配置#

常规配置#

1
# 表示redis服务端是不是以守护进程（后台进程）的方式运行
2
daemonize no
3

4
# 客户端和服务端之间建立连接，假如超过多长时间没有进行通信那么就断开连接
5
# 0表示不关闭连接
6
timeout 0
7

8
# 端口号（一般不用去改）
9
port 6379
10

11
# 绑定的主机地址
12
bind 127.0.0.1
13
# 所有人都可以连接
14
# bind 0.0.0.0
15

16
# 日志级别
17
loglevel notice
18

19
# 数据库的数量设置
20
databases 16
21

22
# 密码设置
23
requirepass cskaoyan

展开收起

持久化配置#

RDB#

RDB是指Redis通过内存快照的形式来持久化内存中的数据到磁盘中。

RDB是Redis默认的持久化策略，没有提供开关关闭。

快照：其实就是一种内存技术，就可以像对内存进行拍照一样，保存内存当时的完整的状态。

快照的速度很快

快照保存的一种数据的状态，占用的磁盘空间比较小

快照会保存完整的数据

1
# 内存快照保存文件的位置
2
dir D:\tmp
3

4
# 内存快照保存文件的名字
5
dbfilename dump.rdb
6

7
# 快照触发的策略
8
save <seconds> <changes>
9
# 在多少秒之后，检查有多少次改变，如果达到设置的条件，那么就触发持久化
10
save 900 1
11
save 300 10
12
save 60 10000

image-20221020102122917

总结：

RDB每次保存的是触发RDB时刻的完整的数据

RDB可能丢失数据，可能会丢失上一次持久化之后所有写入的数据

RDB保存数据的速度很快，还原数据也很快

AOF#

Append only file。AOF这种持久化的机制是通过追加(写操作命令)日志文件的方式来保存数据的。

AOF会把用户输入的每一个写入命令保存到文件中，后续恢复数据的时候可以通过执行这个文件中的所有的命令来恢复数据。

1
# 总开关
2
# AOF默认是关闭的
3
appendonly no
4

5
# 保存文件的路径
6
# 配置和RDB是同一个配置
7
dir D:\tmp
8

9
# 保存文件的名字
10
appendfilename "appendonly.aof"
11

12
# 保存的策略
13

14
# 每收到一条写入的命令，就把命令保存到文件中
15
# appendfsync always
16

17
# 每秒保存一次（推荐使用的）
18
appendfsync everysec
19

20
# 依赖于操作系统的策略
21
# appendfsync no

展开收起

AOF持久化机制的总结：

AOF可以做到不丢失数据（appendfsync always）

AOF保存数据生成的文件会越来越大，占用磁盘空间比较大

AOF还原数据要通过执行文件中的所有的命令来还原数据，还原数据比较慢

AOF和RDB是可以同时运行的。
当两种机制都开启的时候，恢复数据的时候，优先从AOF生成的文件来恢复数据。

数据结构#

推荐命令学习网站：http://doc.redisfans.com/

1
# 切换数据库（index从0开始）
2
select index
3

4
# 认证密码
5
auth password
6

7
# 搜索key (pattern 是一个正则表达式)
8
keys pattern
9
# 常用的是：keys * （查看所有的key）
10

11
# 清空数据库（删库）
12
# 清空所有的数据库（16个）
13
flushall
14

15
# 清空当前的数据库
16
flushdb
17

18
# 删除一个键值对
19
del key

展开收起

string#

string数据结构是Redis中最基本的数据结构，包含（String + 数字类型）

image-20221020112310089

1
# 设置一个键值对（如果key存在，会覆盖）
2
set key value
3

4
# 获取一个键值对的值
5
get key
6

7
# 批量的设置键值对
8
mset key1 value1 key2 value2 ...
9

10
# 批量的获取键值对
11
mget key1 key2 key3 ...
12

13
# 给指定的key的value +1 value必须得是一个数值
14
incr key
15

16
# 给指定的key增加指定的步长
17
incrby key increment
18

19
# 给指定的key的value -1
20
decr key
21

22
# 给指定的key减去指定的步长
23
decrby key decrement
24

25
# 设置一个key-value，并且指定过期时间
26
setex key seconds value
27

28
# set not exists,设置一个键值对，不会覆盖原来的值
29
# 当key不存在的时候，再去设值，不会覆盖原来的值
30
setnx key value

展开收起

使用场景：

利用incr命令可以统计网站的访问量 (日PV)

利用incr和decr统计游戏的在线人数

list#

list的本质是一个双向链表。Redis支持用户从list的两端推入或者是弹出元素。

可重复
有序

image-20221020142318075

1
# 从队列的左端推入元素（当list不存在的时候，会自动创建一个新的list，然后来推入）
2
lpush key value1 value2 ...
3

4
# 从队列的左端弹出一个元素
5
lpop key
6

7
# 从队列的右端推入元素
8
rpush key value1 value2 ...
9

10
# 从队列的右端弹出一个元素
11
rpop key
12

13
# 查看链表的元素数量
14
llen key
15

16
# 查看某一个范围内的元素(start、stop指元素的下标，最左边的元素下标为0)
17
lrange key start stop
18

19
# 求指定下标的元素值
20
lindex key index
21

22
# 插入一个元素(在指定的元素pivot 前面或者是后面插入一个指定的元素 value )
23
# 如果指定的元素pivot有重复，那么就会在第一个值前面或者是后面插入
24
linsert key before|after pivot value
25

26
# 正常的从左端推入，当list存在的时候才会生效
27
lpushx key value
28

29
# 修改指定位置元素的值
30
lset key index value
31

32
# 删除前几个指定的元素
33
lrem key count value

展开收起

应用场景：

消息队列

最新动态（消息）排行榜（eg：B站的动态）

set#

无序的集合。

无序

不可重复

无序集合这种数据结构，最大的特点是可以利用Redis给我们提供的命令，去求多个无序集合的交集、并集、差集

image-20221020144947339

1
# 往无序集合中添加元素
2
sadd key member1 member2 ...
3

4
# 查看无序集合中元素的个数
5
scard key
6

7
# 查看无序集合中所有的元素
8
smembers key
9

10
# 判断某个元素在不在指定的集合中
11
sismember key member
12

13
# 随机弹出一个元素(取出并删除)
14
spop key
15

16
# 随机从集合中取出一个元素的值（取出不删除）
17
srandmember key [count]
18

19
# 求交集
20
sinter key1 key2 ...
21

22
# 求出交集并保存
23
sinterstore destination key1 key2 ...
24

25
# 求并集
26
sunion key1 key2 ...
27

28
# 求出并集并保存
29
sunionstore destination key1 key2 ...
30

31
# 求差集
32
sdiff key1 key2 ...
33

34
# 求出差集并保存
35
sdiffstore destination key1 key2 ...
36

37
# 移动元素
38
smove source destination  member
39

40
# 删除元素
41
srem key member1 member2 ...

展开收起

应用场景：

求共同好友

好友推荐

hash#

hash叫做二维表，类似于map。

Hash这种数据结构可以看作是一个map，可以存储多个键值对。

image-20221020151528685

1
# 设置一个键值对
2
hset key field value
3

4
# 获取指定二维表中field的值
5
hget key field
6

7
# 设置多个键值对
8
hmset key field1 value1 field2 value2 ...
9

10
# 获取多个键值对的值
11
hmget key field1 field2 ...
12

13
# 判断二维表中有没有指定的field
14
hexists key field
15

16
# 获取二维表中所有的键值对
17
hgetall key
18

19
# 获取二维表中所有的键
20
hkeys key
21

22
# 获取二维表中所有的值
23
hvals key
24

25
# 求出二维表中 键值对的个数
26
hlen key
27

28
# 给键值对的值 增加指定的长度
29
hincrby key field increment
30

31
# 设置值，不覆盖(二维表不存在的时候，也可以设置成功)
32
hsetnx key field value

展开收起

应用场景：

存储商城中的购物车

sortedset(zset)#

有序的集合。

image-20221020155415981

有序集合的最大特点是：可以任意的取出有序集合中指定排名区间内的成员、以及指定分数区间内的成员。

1
# 往有序集合中添加成员以及他的分数（注意：分数在前，成员在后）
2
zadd key score1 member1 score2 member2 ...
3

4
# 计算集合中元素的总个数
5
zcard key
6

7
# 求指定分数区间内成员的个数（分数是闭区间）
8
zcount key min max
9

10
# 求出指定成员的分数
11
zscore key member
12

13
# 给指定的成员增加分数
14
zincrby key score member
15

16
# 求出指定排名区间内的成员(排名从0开始，默认按照分数的升序排列)
17
zrange key start stop [withscores]
18

19
# 求出指定排名区间内的成员(排名从0开始，默认按照分数降序排列)
20
zrevrange key start stop [withscores]
21

22
# 求指定分数区间内的成员-按照分数的升序排列
23
zrangebyscore key min max [withscores]
24

25
# 求指定分数区间内的成员-按照分数的降序排列
26
zrevrangebyscore key max min [withscores]
27

28
# 求出指定成员的排名（按照分数的升序排名）
29
zrank key member
30

31
# 求出指定成员的排名（按照分数的降序排名）
32
zrevrank key member
33

34
# 删除指定的成员
35
zrem key member1 member2 ...
36

37
# 删除指定排名区间内的所有成员
38
zremrangebyrank key start stop [withscores]
39

40
# 删除指定分数区间内的所有成员
41
zremrangebyscore key min max [withscores]

展开收起

应用场景：

游戏中积分”排行榜”

内存淘汰策略#

Redis是一个基于内存来存储的数据库，而内存资源是十分宝贵且有限的。那么当内存满了之后，Redis又需要存储新的数据的时候，该怎么办呢？

这个时候，Redis会触发内存淘汰策略，来淘汰老的数据，保证写入的成功。

volatile-lru（least recent used）

从已经设置了过期时间的数据集中，选择最近最少使用的数据进行淘汰。
volatile-lfu

从已经设置了过期时间的数据集中，选择一段时间内使用最少的key进行淘汰
volatile-random

从已经设置了过期时间的数据集中，随机选择数据进行淘汰
volatile-ttl

从已经设置了过期时间的数据集中，选择最近将要过期的数据进行淘汰
allkeys-lru

从所有的数据集中，选择最近最少使用的数据进行淘汰。
allkeys-random

从所有的数据集中，随机选择数据进行淘汰
allkeys-lfu

从所有的数据集中，选择一段时间内使用最少的key进行淘汰
no-evication

禁止淘汰数据，如果有新的数据需要写入，那么就直接报错

在以后的工作中，选择哪一种更加合理呢？

从效率的角度出发：allkeys-random

从合理性的角度从出发：volatile-lru

那么优先保证淘汰的效率还是保证淘汰数据的合理性呢？

一般是保证效率

什么样的数据适合存储在Redis上面呢？

用户不敏感的
访问量比较大的（速度要求比较高的）

客户端#

Redis和MySQL一样，也是一个C/S架构的应用。

Redis也和MySQL是类似的，存在各种各样的客户端。

命令行客户端#

图形化界面客户端#

AnnotherRedisDeskTopManager。

image-20221020162526011

image-20221020162820531

Java客户端#

官方推荐的Java客户端是：

Redisson
Jedis

Jedis#

Jedis全称叫做Java for Redis，使用非常简单，因为Jedis的每一个方法都和Redis的相关的命令名字是一致的。

如何使用呢？

导包

1
<dependency>
2
    <groupId>redis.clients</groupId>
3
    <artifactId>jedis</artifactId>
4
    <version>2.9.0</version>
5
</dependency>

配置

Jedis不需要任何配置

使用

1
 // 1. 创建一个Jedis对象
2
        Jedis jedis = new Jedis("localhost",6379);
3

4
        // 认证密码
5
        // jedis.auth("cskaoyan");
6

7
        // 2. 使用Jedis
8
//        String value = jedis.get("shuaige");
9
//        System.out.println("value:" + value);
10

11
//        jedis.hset()
12
//        jedis.rpush
13
//        jedis.sismember()
14
//        jedis.zrank()
15
//        jedis.zrevrank()

展开收起

Redisson#

redisson和 redis命令匹配列表

和Jedis不同，Redisson不仅仅实现了我们前面所学习过得所有的Redis命令对应的功能，它自己对Redis的功能做了很多的封装，提供了很多更为好用，更为强大的功能，比如说我们后面要学习的，基于Redis实现的分布式锁等等。

使用Redisson我们首先需要引入依赖，然后我们就可以开始使用Redisson了。

1
    <dependencies>
2
        <dependency>
3
                <groupId>org.redisson</groupId>
4
                <artifactId>redisson</artifactId>
5
                <version>3.11.1</version>
6
        </dependency>
7
    </dependencies>

首先，使用Redisson访问Redis之前，我们得首先构造出一个RedssonClient对象

1
        // 1. new 出一个config对象
2
        Config config = new Config();
3
        // 2. 配置Config对象
4
        SingleServerConfig serverConfig = config.useSingleServer()
5
                // 这里设置访问Redis的地址
6
                .setAddress("redis://localhost:6379");
7

8
        // 设置序列化方式，使用jackson实现序列化和反序列化
9
        config.setCodec(new JsonJacksonCodec());
10

11
        // 3. 创建redis客户端 该对象在创建的时候，就会像redis-server发起连接请求
12
        RedissonClient redissonClient = Redisson.create(config);

需要注意的是，RedissonClient对象在创建的时候就会向Redis Server发起连接请求了，所以如果和Redis Server建立连接失败，那么RedissonClient对象也会创建失败！

创建好RedissonClient对象之后，我们就可以基于ReidssonClient对象实现对Redis中5种基本数据类型的访问了。

1
   /*
2
       该方法主要演示对于Redis，string类型数据的访问
3

4
   */
5
   private static void string(RedissonClient redissonClient) {
6
    /*
7
         1. number表示String类型的值对应的Redis中的key
8
         2. 通过redissonClient获取存放key对应值的Bucket桶
9
         3. 桶中放的就是key对应的Redis中的string类型的值
10
         4. 对于桶的基本操作就是get/set，获取桶中的值/设置桶中的值
11
         5. 对桶中值的操作都相当于是对Redis中key对应的string类型的值的操作
12

13
         */
14
        RBucket<Integer> bucket = redissonClient.getBucket("number");
15
        bucket.set(0);
16

17
        // 获取对应的String数据类型的值
18
       Integer result = bucket.get();
19
        System.out.println(result);
20

21
        // 获取obj对应的存放String类型值的Bucket桶(这里其实对象被转化成了json字符串)
22
        RBucket<Person> personBucket = redissonClient.getBucket("obj");
23
        Person person = new Person();
24
        person.setName("长风");
25
        // 向桶中放入对象
26
        personBucket.set(person);
27

28
        // 从桶中获取对象
29
        Person newPerson = personBucket.get();
30
        System.out.println(newPerson.getName());
31

32

33

34
    }

展开收起

访问List类型的值

1
    private static void list(RedissonClient redissonClient) {
2

3
        /*
4
            1. 调用redissonClient的getList方法，根据指定的key获取List类型的值
5
            2. 对于我们而言List类型的值就相当于内存中的一个List，所以之前怎么访问List，现在完全一样
6
            3. List中可以放基本数据类型及其包装类的值，也可以放对象
7
            4. 如果要修改Redis中List数据类型中的元素的值，还得把修改后的元素重新调用add方法
8
               添加到List才行
9
        */
10
        List<Person> list = redissonClient.getList("listKey");
11

12
        // ...
13

14
    }

访问Set类型的值

1
    private static void set(RedissonClient redissonClient) {
2
        /*
3
            1. 调用redissonClient的getList方法，根据指定的key获取Set类型的值
4
            2. 对于我们而言List类型的值就相当于内存中的一个Set，所以之前怎么访问Set，现在完全一样
5
            3. Set中可以放基本数据类型及其包装类的值，也可以放对象
6
            4. 因为Set无序，所以仍然和之前一样，可以用迭代器或者stream流来访问
7
        */
8
        Set<String> set = redissonClient.getSet("setKey");
9
        set.add("setValue");
10

11
        Iterator<String> iterator = set.iterator();
12
        while (iterator.hasNext()) {
13
            String next = iterator.next();
14
            System.out.println(next);
15
        }
16
    }

展开收起

访问SortedSet类型的值

1
     private static void sortedSet(RedissonClient redissonClient) {
2
        /*
3
           1. 调用RedissonClient的getScoredSortedSet获取指定key对应的一个SortedSet
4
           2. Redisson用RScoredSortedSet对象表示一个SortedSet，该类所持有的泛型表示SortSet中元素对应的Java类型
5

6
           3. RScoredSortedSet中的每一个元素都绑定分数，所以添加的时候既要添加元素还要添加元素的score
7
           4. 可以获取元素的分数，排名...
8
           5. RScoredSortedSet中也可以放Java对象
9

10
        */
11
        RScoredSortedSet<String> sortedSet
12
                = redissonClient.getScoredSortedSet("sortedKey");
13

14
        sortedSet.add(1.0, "zs");
15
        sortedSet.add(2.0, "lisi");
16

17
        Double score = sortedSet.getScore("zs");
18
        System.out.println(score);
19
        Integer rank = sortedSet.rank("zs");
20
        System.out.println(rank);
21
    }

展开收起

访问hash数据类型的值

1
    private static void map(RedissonClient redissonClient) {
2

3
        /*
4
            1. 在redis中获取名为mapKey的名称的hash数据结构的值
5
            2. 获取到的是一个Map，就可以把它当做内存中的一个Map，所以之前怎么用Map现在还是一样
6
            3. Map中的key为String类型，Value可以是基本数据类型及其包装类的值，也可以是对象
7
            4. 如果要修改Redis中hash数据类型中的元素的值，还得把修改后的元素重新调用Map的put方法
8
               添加到Map中才行
9

10
        */
11
        Map<String, String> map = redissonClient.getMap("mapKey");
12

13
        //         "field"      "value"
14
        // 添加
15
        map.put("mapField", "mapValue");
16
        // 修改
17
        map.put("mapField", "v1");
18

19
       //获取
20
        String mapField = map.get("mapField");
21
        System.out.println(mapField);
22
       //删除
23
       map.remove("mapField");
24

25
    }

展开收起

SpringCloud-1

Sun, 14 Jun 2026 00:00:00 GMT

从单体应用到微服务#

单体架构#

到目前为止，我们所实现的web应用都有一个共同的特点，所有的代码最终打包成一个文件(jar包)，整个系统的所有功能单元整体部署到同一个进程，这种软件架构的风格，即所谓的”单体架构”

单体架构的扩容#

一个单体应用在运行时，会部署在一台云服务器上，但是随着用户体量的增长，一台云服务器上运行的一个单体应用，已经无法承载日益增长的请求量，怎么办呢？我们可以对单体应用实现扩容，即使用单体应用集群

通过使用单体应用的集群，可以一定程度上，很好的应对日益增长的用户请求，但是这样就完美了吗？当然不是

单体架构的优势和弊端#

在单体应用的早期，应用程序相对较小，单体架构的好处：

应用的开发很简单
易于对应用程序进行大规模的更改
测试相对直观简单
部署简单明了
横向扩容不费吹灰之力

但是，随着时间的推移，随着单体应用中包含的功能越来越多，应用的”体积”越来越大，单体应用的弊端就会逐渐体现出来。

代码过度复杂且严重耦合，导致难以维护

1
1. 由于系统本身过于庞大和复杂，以至于任何一个开发者都很难理解它的全部，因此，修复软件中的问题和正确实现新功能就变得困难且耗时
2
2. 更糟糕的是，这种极度的复杂性，可能会形成一个恶性循环: 由于代码难以理解，因此开发者在更改时更容易出错，每一次更改都会让代码库变得更复杂，更难懂

从代码提交到实际部署的周期很长

1
从代码完成到运行在生产环境，是一个漫长且费力的过程。
2
1. 众多开发人员都向同一个代码库提交代码，常常使得代码库的构建结构处于无法交付的状态。当采用了分支来解决这个问题，又必须忍受漫长且痛苦的合并过程
3
2. 因为代码库中的代码十分复杂，以至于任何一个更改可能引起的影响是未知的，为了避免牵一发而动全身的后果，即使是一个微小的更改，也必须执行全部的测试

扩展性受限

1
1. 如果单体应用中的某一个功能点存在性能问题，那么就需要多部署几个单体应用的实例，再加上负载均衡的设备(比如nginx)，才能保证整个应用的性能能够支撑用户的使用
2
2. 在某些情况下，应用的不同模块对资源的需求是相互冲突的，比如某些模块需要高效的IO，某些模块需要高性能的CPU, 而这些模块都在一个单体应用之内，因此其所部署的服务器必须满足所有的需求

开发慢，启动慢，严重影响开发效率
交付可靠的单体应用困难

1
1. 单体应用体积庞大，难以进行全面和彻底的测试，而缺乏可靠的测试意味着代码中的错误会进入生产环境
2
2. 缺乏故障隔离，因为所有的模块都在同一个进程中运行，每隔一段时间，在一个模块中的代码错误，将会导致整个应用程序的崩溃

微服务架构#

我们看到，随着单体应用的发展，最终会变得难以维护，难以实现及时可靠的交付，且开发效率低。那么怎么解决这个问题呢？解决之道就在于微服务架构。

要理解微服务架构，我们得首先理解微服务，那什么是微服务呢？

简单理解一个微服务的本质就是一个麻雀虽小但五脏俱全的应用程序，它按照单一职责原则实现了特定的一组功能。

因为每个微服务的本质都可以是一个应用程序，这就要求，微服务可以独立部署，独立运行，独立对外提供服务(运行在一个独立的进程中)
每个微服务，根据单一职责原则，实现一组相关功能

在此基础上，什么是微服务架构呢？简单理解，就是把应用程序功能写分解为一组服务的架构风格。实际上，微服务架构是模块化开发的一种形式。

模块化是开发大型，复杂应用程序的基础。当一个单体应用程序的规模太大的时候，是很难作为一个整体开发，也很难让一个人完全理解的。为了让不同的人开发和理解(不同的部分)，大型应用需要拆分模块。

在单体架构中，模块通常由一组编程语言所提供的的结构(例如Java中的包，或者jar文件)来定义，但是通过这种方式得到的模块，不同模块的代码还是可以相互引用，导致模块中对象依赖关系的混乱
而微服务架构，使用微服务作为模块化的单元，要访问服务，只能通过服务对外提供的API，于是服务的API为它自身构筑了一个不可逾越的边界，你无法越过API去访问服务内部的类。

微服务的优势和弊端#

使用微服务架构，可以解决庞大的单体应用的痛点，带来很多好处：

每个服务都相对较小，容易维护
使得大型的应用程序实现快速的持续交付和持续部署

1
1. 每一个服务相对较小，编写全面的测试代码和执行自动化测试都变得相对容易
2
2. 每个服务都独立于其他服务部署，如果负责服务的开发人员，需要部署对该服务的更改，不需要与其他开发人员协商，因此将更改频繁部署到生产中要容易的多

应用扩展灵活

1
1. 应用被拆分为不同的微服务，而微服务可以独立部署，因此，扩容就不在针对整个应用了，哪里出现性能瓶颈，对哪个服务扩容即可
2
2. 即使不同的的服务需要资源存在冲突，也没有关系，把它们分别部署到具有拥有各自所需要资源的机器上即可

更好的容错

1
相比于单体架构中，一个故障拖垮整个系统的情况，一个服务的故障，并不会影响想到其他服务的正常运行。

当然，使用微服务也会带来一些弊端

分布式系统可能复杂难以管理
分布式部署追踪问题难
分布式事务比较难处理
服务数量增加，管理复杂性增加

微服务的拆分#

image-20210922143348626

服务拆分的注意事项:

每个服务的功能有边界，因此每个服务访问的数据也是有边界的，所以每个服务都有自己的数据库
每个服务的数据库只限于该服务自己直接访问，其他服务不能直接访问
如果一个服务需要其他服务的数据，则可以通过调用其他服务对外暴露的接口，访问到其他服务的数据

微服务的实现#

一个微服务架构的项目，大致结构如上图所示，因为每个服务独立运行，独立部署，所以想要将微服务架构在项目中落地，还需要解决一些其他问题，服务之间的调用，服务的治理，比如服务的注册与自动发现，服务调用的负载均衡，API网关等等

而这些问题，都由相应的服务框架，已经帮助我们实现了，所以我们在实现微服务架构的项目，都需要基于某个微服务的框架，目前比较流行的有大概有两种SpringCloud和Dubbo，我们的学习主要基于框架SpringCloud。

SpringCloud 基于SpringBoot提供了一套微服务架构实现的解决方案，包括服务的注册与自动发现，面向接口的服务调用，服务调用的负载均衡，服务网关，服务熔断等等组件，它利用SpringBoot开发的便利性，巧妙的简化了分布式系统的基础设施搭建，使开发者可以基于SpringBoot的开发风格做到快速启动和部署。

中文官网：https://www.springcloud.cc/

英文官网：https://spring.io/projects/spring-cloud

服务调用的场景#

在下单的时候，我们除了需要给用户展示待下单的商品数据，通常我们还需要给用户展示其地址信息，以供其选择。而订单由订单服务管理，用户的地址信息由用户服务管理。

这也就意味着，在下单之前，订单服务不仅需要查询出订单信息，还需要调用用户服务获取用户的地址信息，于是这里就出现了服务调用

服务间的调用#

实际上，在基于SpringCloud实现的微服务架构中，一个微服务实例(进程)的本质，就是一个部署在Tomcat中的，满足单一职责原则的应用程序。

服务调用的理论#

实际上，服务间的调用，基于我们以前学习过的知识，就可以轻松解决：

基于SpringCloud实现的微服务，支持基于Http协议的通信，因此服务间的调用就变成了一次基于Http的通信
在这次服务调用过程中，调用的目标是谁呢？可以是Controller方法，因为一个Http请求刚好可以被一个Controller方法接收处理，就相当于调用到了这个Controller方法
但是请注意，我们能且只能调用另外一个服务的Controller方法(一个Controller方法就处理一个Http请求，相当于一个服务对外暴露的一个接口)，所以说一个服务只能调用另外一个服务对外暴露的接口！

在一次服务调用过程中，我们称调用者为服务消费者(使用或者消费另一个服务的功能)，我们称被调用者为服务提供者(提供被消费的功能)

实现服务调用的准备#

通过服务调用的理论分析，我们知道服务调用其实就是发送Http请求，接收Http响应的过程，在实现服务调用之前，我们还存在一个问题，就是如何通过代码发送Http请求——使用RestTemplate。

RestTemplate是一个专门用来发送Http请求的工具，通过封装JDK中的HttpURLConnection类库，提供简单易用的模板方法API，它所提供的模板方法几乎覆盖了常用的所有Http请求类型的场景。

我们通常使用其无参构造方法，来获取一个RestTemplate对象：

1
RestTemplate()
2
Create a new instance of the RestTemplate using default settings.

同时，我们可以通过一个RestTempate对象，发起POST,GET,DELETE,PUT,PATCH等不同种类的Http请求，我们以最常用的GET和POST两种方式为例来学习RestTemplate的用法。

1
/*
2
  当我们只想要获取一个GET请求的结果的时候，可以调用其getForObject方法，其中
3
  String url: 发起请求的url
4
  Class<T> responseType: 响应体返回值类型
5
  第三个参数: 表示GET请求携带的参数
6
*/
7
public <T> T getForObject(String url, Class<T> responseType, Map<String,?> uriVariables)
8
public <T> T getForObject(String url,Class<T> responseType, Object... uriVariables)
9

10
/*
11
    如果我们不仅想要获取GET请求的响应体数据，还想获取响应头，以及响应码等信息，那么可以使用getForEntity方法，其中
12
  String url: GET请求的url
13
  Class<T> responseType： 响应体返回值类型
14
  第三个参数: 表示GET请求携带的参数
15
*/
16
public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)
17
public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String,?> uriVariables)

展开收起

1
/*
2
  当我们只想要获取一个POST请求的结果的时候，可以调用其postForObject方法，其中
3
  String url: 发起请求的url
4
  request：表示post请求的请求体数据，也可以不传这个参数
5
  Class<T> responseType: 响应体返回值类型
6
  第三个参数: 表示GET请求携带的参数
7
*/
8
public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String,?> uriVariables)
9
public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType)
10

11
/*
12
    如果我们不仅想要获取GET请求的响应体数据，还想获取响应头，以及响应码等信息，那么可以使用getForEntity方法，其中
13
  String url: POST请求的url
14
  Object request： 表示post请求的请求体数据，也可以不传这个参数
15
  Class<T> responseType： 响应体返回值类型
16
  第三个参数: 表示GET请求携带的参数
17
*/
18
public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables)
19
public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String,?> uriVariables)

展开收起

我们以发送GET请求为例来说明：

1
       // 准备好请求的url，携带名为name的请求参数，占位符的名称为name
2
     String url = "http://localhost:9001/user/address/{userId}";
3
        // map中参数值的key一定要和url中参数的占位符同名
4
        HashMap<String, Object> param = new HashMap<>();
5
        param.put("userId", userId);
6
         //map参数方式
7
        String rest = restTemplate.getForObject(url, String.class, param);

1
/*
2
    准备好请求的url，携带名为name的请求参数，占位符的名称就不重要了，
3
    因为通过可变参数可以通过参数位置确定请求参数对应参数值
4
*/
5
String url = "http://localhost:9001/user/address/{userId}";
6
// 用可变参数的方式来传递请求参数, 这里只有一个参数值name
7
String rest = restTemplate.getForObject(url,String.class, userId);

1
        // 获取更完整的响应信息
2
        ResponseEntity<String> forEntity = restTemplate.getForEntity(url, String.class);
3
        // 获取http响应的响应码
4
        HttpStatus statusCode = forEntity.getStatusCode();
5
        System.out.println(statusCode);
6
        // 返回响应体数据
7
        return forEntity.getBody();

通常我们还可以用

服务调用的实现#

被调用接口#

那么接下来，我们来实现一个服务消费者调用服务提供者的例子，假设服务提供者对外暴露的接口为

入参	类型
userId	Long

请求路径：/user/address/{userId}

请求类型: GET

请求示例：

http://localhost:9001/user/address/{userId}

出参	类型
address	String

父工程依赖#

因为代码包含多个maven工程，因此我们使用父子工程来实现，创建父工程，父工程中并不包含代码，主要用来管理子Maven工程

1
 <properties>
2
        <java.version>17</java.version>
3
        <spring-boot.version>2.7.17</spring-boot.version>
4
        <spring-cloud.version>2021.0.9</spring-cloud.version>
5
        <spring-cloud-alibaba.version>2021.0.5.0</spring-cloud-alibaba.version>
6
        <mysql.version>8.0.20</mysql.version>
7
        <mybatis.version>2.3.1</mybatis.version>
8
        <lombok.verion>1.18.24</lombok.verion>
9
    </properties>
10
    <dependencyManagement>
11
        <dependencies>
12
            <!-- spring-boot -->
13
            <dependency>
14
                <groupId>org.springframework.boot</groupId>
15
                <artifactId>spring-boot-dependencies</artifactId>
16
                <version>${spring-boot.version}</version>
17
                <type>pom</type>
18
                <scope>import</scope>
19
            </dependency>
20

21
            <!--spring cloud alibaba-->
22
            <dependency>
23
                <groupId>com.alibaba.cloud</groupId>
24
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
25
                <version>${spring-cloud-alibaba.version}</version>
26
                <type>pom</type>
27
                <scope>import</scope>
28
            </dependency>
29

30
            <!--spring cloud-->
31
            <dependency>
32
                <groupId>org.springframework.cloud</groupId>
33
                <artifactId>spring-cloud-dependencies</artifactId>
34
                <version>${spring-cloud.version}</version>
35
                <type>pom</type>
36
                <scope>import</scope>
37
            </dependency>
38

39
            <!-- mysql驱动 -->
40
            <dependency>
41
                <groupId>mysql</groupId>
42
                <artifactId>mysql-connector-java</artifactId>
43
                <version>${mysql.version}</version>
44
            </dependency>
45
            <!--mybatis-->
46
            <dependency>
47
                <groupId>org.mybatis.spring.boot</groupId>
48
                <artifactId>mybatis-spring-boot-starter</artifactId>
49
                <version>${mybatis.version}</version>
50
            </dependency>
51

52
            <dependency>
53
                <groupId>org.projectlombok</groupId>
54
                <artifactId>lombok</artifactId>
55
                <version>${lombok.verion}</version>
56
            </dependency>
57
        </dependencies>
58
    </dependencyManagement>

展开收起

服务提供者实现#

依赖如下

1
<dependencies>
2
        <dependency>
3
            <groupId>org.springframework.boot</groupId>
4
            <artifactId>spring-boot-starter-web</artifactId>
5
        </dependency>
6

7
        <dependency>
8
            <groupId>mysql</groupId>
9
            <artifactId>mysql-connector-java</artifactId>
10
        </dependency>
11
        <!--mybatis-->
12
        <dependency>
13
            <groupId>org.mybatis.spring.boot</groupId>
14
            <artifactId>mybatis-spring-boot-starter</artifactId>
15
        </dependency>
16

17
        <dependency>
18
            <groupId>org.projectlombok</groupId>
19
            <artifactId>lombok</artifactId>
20
        </dependency>
21
    </dependencies>

展开收起

配置如下

1
server:
2
  port: 9001
3
spring:
4
  datasource:
5
    url: jdbc:mysql://localhost:3306/demo_user?useSSL=false&serverTimezone=Asia/Shanghai
6
    username: root
7
    password: xxxxxx
8
    driver-class-name: com.mysql.cj.jdbc.Driver

代码如下(SpringBoot工程的启动类就不展示了)

1
@RestController
2
@RequestMapping("/user")
3
public class UserController {
4

5
    @Autowired
6
    private UserService userService;
7

8
    /**
9
     * @param id 用户id
10
     * @return 用户
11
     */
12
    @GetMapping("/address/{id}")
13
    public String queryById(@PathVariable("id") Long id) {
14
        // 根据id查询用户的地址信息
15
        return userService.queryById(id);
16
    }
17
}

展开收起

1
@Service
2
public class UserService {
3

4
    @Autowired
5
    private UserMapper userMapper;
6

7
    public String queryById(Long id) {
8
        User user = userMapper.findById(id);
9
        return user.getAddress();
10
    }
11
}

服务消费者实现#

依赖如下

1
    <dependencies>
2
        <dependency>
3
            <groupId>org.springframework.boot</groupId>
4
            <artifactId>spring-boot-starter-web</artifactId>
5
        </dependency>
6

7
        <dependency>
8
            <groupId>mysql</groupId>
9
            <artifactId>mysql-connector-java</artifactId>
10
        </dependency>
11
        <!--mybatis-->
12
        <dependency>
13
            <groupId>org.mybatis.spring.boot</groupId>
14
            <artifactId>mybatis-spring-boot-starter</artifactId>
15
        </dependency>
16

17
        <dependency>
18
            <groupId>org.projectlombok</groupId>
19
            <artifactId>lombok</artifactId>
20
        </dependency>
21
    </dependencies>

展开收起

配置如下

1
server:
2
  port: 9002
3
spring:
4
  datasource:
5
    url: jdbc:mysql://localhost:3306/demo_order?useSSL=false&serverTimezone=Asia/Shanghai
6
    username: root
7
    password: xxxxxx
8
    driver-class-name: com.mysql.cj.jdbc.Driver

代码如下

先准备好一个用于发起Http请求的RestTemplate对象

1
@Configuration
2
public class ClientConfig {
3

4
    @Bean
5
    @LoadBalanced
6
    public RestTemplate template() {
7
        return new RestTemplate();
8
    }
9
}

1
@RestController
2
@RequestMapping("order")
3
public class OrderController {
4

5
   @Autowired
6
   private OrderService orderService;
7

8
    @GetMapping("{orderId}")
9
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
10
        // 根据id查询订单并返回
11
        return orderService.queryOrderById(orderId);
12
    }
13
}

1
@Service
2
public class OrderService {
3

4
    @Autowired
5
    private OrderMapper orderMapper;
6

7

8
    @Autowired
9
    private RestTemplate restTemplate;
10

11
    public Order queryOrderById(Long orderId) {
12
        // 1.查询订单
13
        Order order = orderMapper.findById(orderId);
14
        // 2.利用RestTemplate发起http请求，查询用户
15
        // 2.1.url地址
16
        String url = "http://localhost:9001/user/address/{userId}";
17
        // 2.2.发送http请求，实现远程调用
18
        String userAddress = restTemplate.getForObject(url, String.class,order.getUserId());
19
        // 3.封装user到Order
20
        order.setUserAdress(userAddress);
21
        // 4.返回
22
        return order;
23
    }
24
}

展开收起

服务的注册与发现#

服务间调用的问题，但是仅仅实现到这种程度，还远远不够

问题的引出#

首先回顾一下，对于服务消费者而言，它如何知道服务提供者的信息，从而调用远程服务的功能呢? 再来看看代码

1
String url = "http://localhost:9001/user/address/{userId}";
2
// 实现远程调用
3
String userAddress = restTemplate.getForObject(url, String.class, order.getUserId());

但是，将服务消费者要调用的服务提供者地址写死，这样好吗？我们来设想如场景

假设对于用户服务的请求量很大，一个用户服务实例(进程)处理不了这么多的请求了，此时我们就可以启动多个用户服务实例(进程)，此时，这多个用户服务实例就组成了用户服务的集群
但是我们如果写死了调用的服务提供者的地址，即使有用户服务的集群，有意义吗？没有，因为写死了服务调用的地址，所以我们永远只能调用到集群中的一个服务实例！

此时矛盾就出现了，服务调用时必须知道服务提供者的地址，但是在代码里把改地址写死，就永远只能调用确定的那一个服务实例，但是如果不在代码里写服务调用的地址，我们又从哪里得到服务提供者实例的地址呢？

服务注册中心#

如果在定义服务消费者的时候，不指明服务消费者调用的服务提供者地址，那么服务消费者怎么知道去哪里调用服务提供者呢？此时，我们就需要引入一个新的角色——服务注册中心，由服务注册中心来统一管理服务的状态和信息，那么这个问题就可以解决了。

服务注册中心

对于每一个服务

在服务启动时，会将自己的信息，注册到服务注册中心，其中就包括，ip地址，端口号等信息。即实现服务的注册
在服务运行过程中，会时时向服务注册中心”报告”自己的状态，因此服务注册中心就可以实时感知到服务的运行状态
同时，在服务启动时，也会去注册中心拉取，其他服务信息，即将服务注册表信息下载到本地，这样一来一个服务就可以知道，其他服务调用地址等信息
在服务运行的过程中，服务会从注册中心时时拉取最新的服务注册表信息，从而实现服务的实时发现

那么服务注册中心需要我们自己去实现吗？不是，已经有很多的注册中心实现供我们使用了，比如SpringCloud Alibaba中的Nacos，以及SpringCloud Netflix中的Eureka等等

Nacos 注册中心#

Nacos(Dynamic Naming and Configuration Service)是SpringCloud Alibaba中包含的注册中心组件，实现服务的注册与自动发现功能，Nacos主要采用C-S架构实现

NacosServer实现注册中心的功能，可以直接独立运行
NacosDiscovertyClient负责帮助服务实例访问NacosServer，实现服务的注册和自动发现

启动Nacos Server#

首先，下载好Nacos安装包(.zip压缩包)，解压后，如下图

进入bin目录，打开命令行，输入如下命令

1
windows: startup.cmd -m standalone
2
linux 或 mac: ./startup.sh -m standalone

启动之后看到如下界面，这里上面的部分没截全

nacos启动

启动Nacos Server之后，我们就可以通过localhost:8848/nacos 访问Naocs自带的控制台查看注册中心了。

![](/assets/firefly-docs/microservice/microservice-05-springcloud-1/nacos sever.png)

下面我们使用Nacos作为服务注册中心，实现服务的注册与自动发现。

服务的注册#

首先改造用户服务和订单服务。

在用户服务中，添加如下依赖

1
<!--Nacos注册中心客户端-->
2
<dependency>
3
    <groupId>com.alibaba.cloud</groupId>
4
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
</dependency>

添加如下配置指定Nacos Server地址

1
spring:
2
  cloud:
3
    nacos:
4
      discovery:
5
       # nacos server地址
6
        server-addr: localhost:8848

在启动类上加注解@EnableDiscoveryClient

1
@SpringBootApplication
2
@EnableDiscoveryClient
3
@MapperScan("com.cskaoyan.user.mapper")
4
public class UserServiceApplication {
5

6
    public static void main(String[] args) {
7
        SpringApplication.run(UserServiceApplication.class, args);
8
    }
9
}

用户服务的其他代码不需要做任何改变

在订单服务中，添加如下依赖

1
<!--Nacos注册中心客户端-->
2
    <dependency>
3
        <groupId>com.alibaba.cloud</groupId>
4
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
    </dependency>

在订单服务中，添加如下配置

1
spring:
2
  cloud:
3
    nacos:
4
      discovery:
5
       # nacos server地址
6
        server-addr: localhost:8848

在启动类上加注解@EnableDiscoveryClient

1
@SpringBootApplication
2
@EnableDiscoveryClient
3
@MapperScan("com.cskaoyan.order.mapper")
4
public class OrderServiceApplication {
5

6
    public static void main(String[] args) {
7
        SpringApplication.run(OrderServiceApplication.class, args);
8
    }
9
}

做完以上工作之后，我们只需要分别启动用户服务和订单服务，查看Nacos Server

![](/assets/firefly-docs/microservice/microservice-05-springcloud-1/nacos 服务注册.png)

服务的发现#

在服务成功注册到服务注册中心之后，我们如何动态的发现服务的信息，获取到服务运行所在的IP地址和端口号，从而根据服务的IP和端口号，利用RestTemplate发起服务调用请求呢，代码如下：

1
// 注入服务发现的客户端对象，通过该对象访问从注册中心下载的服务信息
2
    @Autowired
3
    DiscoveryClient discoveryClient;
4

5
    public Order queryOrderById(Long orderId) {
6
         // 1.查询订单
7
        Order order = orderMapper.findById(orderId);
8

9
        // 2. 调用用户服务
10
        // 2.1 获取指定服务名称的服务实例列表
11
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
12
        // 2.2 选择服务实例，获取uri(格式为http://服务实例ip:服务实例启动端口)
13
        URI uri = instances.get(0).getUri();
14
      // 2.3 向用户服务发起服务调用请求(注意，这里没有写死ip地址和端口号了！！！)
15
        ResponseEntity<String> response = template.getForEntity(uri.toString() + "/user/address/{userId}", String.class, order.getUserId());
16
        String result = response.getBody();
17
        return result;
18
    }

展开收起

服务集群#

其实，我们上面所说的运行一个服务，严格来说，运行的应该是一个服务实例，对应的是一个独立的JAVA进程。每个服务实例都有自己所对应的服务名称，多个服务实例运行相同的代码，且具有相同的服务名称，我们就称这些服务实例组成了一个服务集群。比如，我们可以把同一个user-service工程启动两次，那么我们就有了两个用户服务实例，它们组成了一个用户服务集群。

本来没什么可说的，但是在上课期间需要在同一台电脑上启动user-service工程启动两次，它们使用相同的代码，相同的配置文件，直接启动会出现端口冲突，所以我们需要学习在IDEA中如何实现该功能。

先修改第一个用户服务实例的启动脚本名称

紧接着，将第一个用户服务实例的启动脚本复制一份，作为第二个用户服务实例的启动脚本并修改启端口为9003

Eureka 注册中心(了解)#

Eureka是SpringCloud Netflix中包含的注册中心的组件，Eureka也采用了C-S的架构设计，其中

EurekaServer作为服务器端，它具体就实现了服务注册中心的功能
EurekaClient作为客户端，帮助服务实例提完成服务的注册与自动发现

接下来，我们就基于Eureka服务注册中心，实现服务的注册与自动发现。

配置并启动EurekaServer#

与nacos不同，我们需要新建一个子eureka-server工程，这个工程仅仅只是为了启动一个EurekaServer进程(注册中心)

在该工程中添加依赖

1
<dependency>
2
    <groupId>org.springframework.cloud</groupId>
3
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
4
    </dependency>

在eureka-server子工程中的application.yml配置文件中添加如下配置

1
server:
2
  port: 7001
3
# Eureka配置
4
eureka:
5
  instance:
6
    # Eureka服务端的实例名字
7
    hostname: localhost
8
  client:
9
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
10
    register-with-eureka: false
11
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
12
    fetch-registry: false
13
    service-url:
14
      defaultZone: http://localhost:7001/eureka/

启动类上添加注解@EnableEurekaServer

1
@SpringBootApplication
2
@EnableEurekaServer
3
public class EurekaServer {
4

5
    public static void main(String[] args) {
6
        SpringApplication.run(EurekaServer.class, args);
7
    }
8
}

一旦运行eureka-server工程，我们就可以通过 localhost:7001(这里的端口号就是我们server.port配置的端口)访问Eureka自带的控制台了

服务注册#

在user-service的Maven工程中原有依赖的基础上，注释nacos-discovery依赖，添加如下依赖

1
        <!--Eureka Client依赖-->
2
        <dependency>
3
            <groupId>org.springframework.cloud</groupId>
4
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5
        </dependency>

添加如下配置

1
eureka:
2
  client:
3
    service-url:
4
      defaultZone: http://localhost:7001/eureka/
5
  instance:
6
    instance-id: user-instance-1
7
    hostname: localhost

主启动类添加注解@EnableEurekaClient

1
@SpringBootApplication
2
@EnableEurekaClient
3
@MapperScan("com.cskaoyan.user.mapper")
4
public class UserServiceApplication {
5
    public static void main(String[] args) {
6
        SpringApplication.run(UserServiceApplication.class, args);
7
    }
8
}

在order-service的Maven工程中原有依赖的基础上，注释nacos-discovery依赖，添加如下依赖

1
<!--Eureka Client依赖-->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5
</dependency>

添加如下配置

1
# Eureka配置
2
eureka:
3
  client:
4
    service-url:
5
      defaultZone: http://localhost:7001/eureka/
6
  instance:
7
    instance-id: order-instance
8
    hostname: localhost

主启动类，添加注解

1
@SpringBootApplication
2
@EnableEurekaClient
3
@MapperScan("com.cskaoyan.order.mapper")
4
public class OrderServiceApplication {
5

6
    public static void main(String[] args) {
7
        SpringApplication.run(OrderServiceApplication.class, args);
8
    }
9
}

接下来，我们只需要分别启动用户服务实例和订单服务实例，即可观察到服务注册效果

服务发现#

在服务消费者的OrderService中添加测试代码

1
// 注入服务发现的客户端对象，通过该对象访问从注册中心下载的服务信息
2
    @Autowired
3
    DiscoveryClient discoveryClient;
4

5
    public Order queryOrderById(Long orderId) {
6
         // 1.查询订单
7
        Order order = orderMapper.findById(orderId);
8

9
        // 2. 调用用户服务
10
        // 2.1 获取指定服务名称的服务实例列表
11
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
12
        // 2.2 选择服务实例，获取uri(格式为http://服务实例ip:服务实例启动端口)
13
        URI uri = instances.get(0).getUri();
14
      // 2.3 向用户服务发起服务调用请求(注意，这里没有写死ip地址和端口号了！！！)
15
        ResponseEntity<String> response = template.getForEntity(uri.toString() + "/user/address/{userId}", String.class, order.getUserId());
16
        String result = response.getBody();
17
        return result;
18
    }

展开收起

服务集群#

在Eureka 中我们同样也可以有多个服务实例组成的服务集群，通过相同的方式，我们同样可以启动两个用户服务实例，并向Eureka注册中心注册，但是对于第二个服务实例，我们需要再启动脚本中，在添加一个instance-id

Eureka的自我保护机制#

![](/assets/firefly-docs/microservice/microservice-05-springcloud-1/eureka self protection.png)

自我保护机制触发的场景如下:

默认情况下，当eureka server在一定时间内没有收到服务实例的心跳，便会把该实例从注册表中删除（默认是90秒）
但是，如果短时间内丢失大量的服务实例心跳数据，这意味着短时间内大量的服务连接丢失了，此时就会触发Eureka的自我保护机制
触发自我保护机制的结果就是，Eureka认为虽然收不到实例的心跳，但它认为实例还是健康的，eureka会保护这些实例，不会把它们从注册表中删掉。

那么Eureka的自我保护机制的意义在哪里呢？

该保护机制的目的是避免网络连接故障，在发生网络故障时，微服务和注册中心之间无法正常通信，但服务本身是健康的
此时，为了避免注册中心同时删除大量本来是正常运行(健康的)的服务实例，于是就会自动触发自我保护机制
这样一来，即使注册中心和某个或者某些服务实例的网络出现问题，其他服务实例还是可以通过注册中心，获取到其地址，正常发起调用请求

但是我们在开发测试阶段，需要频繁地重启发布，如果触发了保护机制，则旧的服务实例没有被删除，这时服务消费者按照注册表中的服务提供者信息，发出服务调用请求，会因为该实例关闭而失败，这就导致请求错误，影响开发测试。

所以，在开发测试阶段，我们可以把自我保护模式关闭，只需在eureka server配置文件中加上如下配置即可

1
eureka:
2
  server:
3
    enable-self-preservation: false

![](/assets/firefly-docs/microservice/microservice-05-springcloud-1/Eureka self protection-2.png)

SpringCloud-2

Sun, 14 Jun 2026 00:00:00 GMT

服务调用的负载均衡#

问题引出#

学习完了注册中心相关知识，在微服务架构中，我们已经可以实现服务的注册与自动发现了。但是再来看看我们的代码

1
        // 1 获取指定服务名称的服务实例列表
2
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
3
        // 2 选择服务实例，获取uri(格式为http://服务实例ip:服务实例启动端口)
4
        URI uri = instances.get(0).getUri();
5
      // 3 向用户服务发起服务调用请求(注意，这里没有写死ip地址和端口号了！！！)
6
        String address = template.getForObject(uri.toString() + "/user/address/{userId}", String.class, order.getUserId());

服务是可以有集群的，在发现了一个服务所有的实例之后，在一次服务调用过程中，我们还需要选择其中一个服务实例，发起调用请求，所以发起调用之前还存在着一个选择过程，这就涉及到了选择的策略问题，如何选择出集群中的一个实例呢？在SpringCloud中有LoadBalancer和Ribbon帮我们完成这一选择过程。

LoadBalancer#

LoadBalancer是SpringCloud自己实现的客户端负载均衡器。由于从Spring Cloud 2020.0.0 版本开始，Ribbon 正式进入维护模式，所以 Spring Cloud 逐步放弃Ribbon的使用，并且将 LoadBalancer 被推荐为主要的负载均衡解决方案，所以接下来我们在学习一下LoadBalancer。

基本使用#

首先我们需要在项目中引入如下依赖：

1
        <dependency>
2
            <groupId>org.springframework.cloud</groupId>
3
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
4
        </dependency>

接下来，我们就可以开始使用了

1
@Configuration
2
public class RestTemplateConfig {
3

4
    @Bean
5
    // 只需要加上该注解，即可完成LoadBalancer的整合
6
    @LoadBalanced
7
    public RestTemplate restTemplate() {
8
        return new RestTemplate();
9
    }
10
}

1
  // 查询订单数据
2
        Order order = orderMapper.findById(orderId);
3
    // 注意url中无需写ip:port,而变成了服务名称
4
        String url = "http://user-service/user/address/{id}";
5
        String address = restTemplate.getForObject(url, String.class, order.getUserId());
6

7
        order.setAddress(address);
8

9
        // 返回服务调用的结果
10
        return order;

我们发现，项目中整合了LoadBalancer之后，服务调用根据服务名称即可实现。

负载均衡策略#

简单使用LoadBalancer之后，选择已经很好的实现了。同时，我们也会发现LoadBalancer默认实现的负载均衡策略是轮训策略(Round-Robin)。那么问题来了，LoadBalancer只能使用轮训策略吗? 当然不是，LoadBalancer本身还支持如下两种种常用的负载均衡策略:

策略	实现类	描述
轮训策略	RoundRobinLoadBalancer	轮训选择
随机策略	RandomLoadBalancer	随机选择

那么如何指定不同的负载均衡策略呢，通过配置类即可，可以分为两步：

第一步：定义所要使用的负载均衡类

1
public class CustomLoadBalancerConfiguration {
2

3
    /*
4
          environment：包含了一些配置信息
5
          loadBalancerClientFactory：创建LoadBalancerClient对象的工厂
6
     */
7
    @Bean
8
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
9

10
        // 获取目标服务名称
11
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
12
        // 创建用于获取目标服务实例列表的工厂对象
13
        ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSuppliers
14
                = loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class);
15
        // 创建随机负载均衡器
16
        return new RandomLoadBalancer(serviceInstanceListSuppliers, name);
17
    }
18
}

展开收起

第二步，通过@LoadBalancerClient注解使其生效，完成与RestTemplate的整合

1
@LoadBalancerClient(value = "user-service", configuration = CustomLoadBalancerConfiguration.class)
2
@Configuration
3
public class RestTemplateConfig {
4

5
    @Bean
6
    @LoadBalanced
7
    public RestTemplate restTemplate() {
8
        return new RestTemplate();
9
    }
10
}

LoadBalancerClient注解中的 value值表示负载均衡策略所针对的服务名称，因为我们可以对不同的服务配置不同的负载均衡策略
configuration引入value所表示的服务的，所使用的负载均衡配置类

当然，上述的方式还可以使用另外一个注解完成，统一声明针对所有服务的负载均衡配置：

1
@LoadBalancerClients(
2
        @LoadBalancerClient(value = "user-service", configuration = CustomLoadBalancerConfiguration.class)
3
)
4
public class OrderServiceApplication {
5

6
    public static void main(String[] args) {
7
        SpringApplication.run(OrderServiceApplication.class, args);
8
    }
9
}

当然，有的同学可能会问了，如果我想让针对所有服务的负载均衡都是用相同的负载均衡策略可以吗？当然可以

1
@LoadBalancerClients(
2
        defaultConfiguration = CustomLoadBalancerConfiguration.class
3
)
4
public class OrderServiceApplication {
5

6
    public static void main(String[] args) {
7
        SpringApplication.run(OrderServiceApplication.class, args);
8
    }
9
}

LoadBalancer缓存#

本来我们每次在调用一个服务的时候，LoadBalancer都应该通过注册中心的客户端，获取当前被调用服务的服务实例列表然后选择。但是，为了一定程度提高效率，LoadBalancer的默认实现在有一个自己的缓存，用来缓存服务实例列表。关于这个缓存，在实际生产环境开启是可以提升效率的，但是在我们讲课的时候，为了测试方便，我们需要关闭它。

1
spring:
2
  cloud:
3
    loadbalancer:
4
      cache:
5
        enabled: false

自定义负载均衡策略#

当然，由于LoadBalancer本身提供的负载均衡策略比较少，所以实际开发中，有可能我们会根据需要自己实现自定义的负载均衡策略。

1
public class MyLoadBalancer implements ReactorServiceInstanceLoadBalancer {
2

3
    // 服务名称
4
    final String serviceId;
5

6
    // 获取ServiceInstanceListSupplier对象的工厂
7
    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
8

9
    public MyLoadBalancer(String serviceId, ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
10
        this.serviceId = serviceId;
11
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
12
    }
13

14
    /*
15
        我们需要实现该方法，实现自己的自定义负载均衡策略
16
    */
17
    @Override
18
    public Mono<Response<ServiceInstance>> choose(Request request) {
19

20
    }
21
}

展开收起

1
public class MyLoadBalancer implements ReactorServiceInstanceLoadBalancer {
2

3
    // 服务名称
4
    final String serviceId;
5

6
    // 获取ServiceInstanceListSupplier对象的工厂
7
    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
8

9
    public MyLoadBalancer(String serviceId, ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
10
        this.serviceId = serviceId;
11
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
12
    }
13

14
    @Override
15
    public Mono<Response<ServiceInstance>> choose(Request request) {
16
        // 得到获取服务实例列表的supplier对象
17
        ServiceInstanceListSupplier serviceInstanceListSupplier = serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
18
        //
19
        return serviceInstanceListSupplier
20
                // 获取目标服务实例列表
21
                .get(request)
22
                // 取出第一个列表(实际上)
23
                .next()
24
                // 将服务列表转化为一个服务实例(其实就是选择一个服务实例)
25
                .map(serviceInstances -> doChooseSingleServer(serviceInstances));
26
    }
27

28
    /*
29
         通过这个方法时实际完成服务实例的选择
30
     */
31
    private Response<ServiceInstance> doChooseSingleServer(List<ServiceInstance> serviceInstances) {
32

33
        // 选择策略简单粗暴，选择列表中的第一个服务实例
34
        ServiceInstance serviceInstance = serviceInstances.get(0);
35

36
        // 将选择结果封装到DefaultResponse中返回
37
        return new DefaultResponse(serviceInstance);
38
    }
39

40
}

展开收起

Ribbon负载均衡(知道)#

Ribbon也是是一个客户端负载均衡器，能够给HTTP客户端带来灵活的控制。在SpringCloud2020之前的版本中默认使用的是Ribbon，所以我们也需要知道。它所支持的负载均衡策略如下:

策略	实现类	描述
随机策略	RandomRule	随机选择server
轮训策略	RoundRobinRule	轮询选择
重试策略	RetryRule	对选定的负载均衡策略(轮训)之上的重试机制，在一个配置时间段内当选择服务不成功，则一直尝试使用该策略选择一个可用的服务；
最低并发策略	BestAvailableRule	逐个考察服务，如果服务断路器打开，则忽略，再选择其中并发连接最低的服务
可用过滤策略	AvailabilityFilteringRule	过滤掉因一直失败并被标记为circuit tripped的服务，过滤掉那些高并发链接的服务（active connections超过配置的阈值)
响应时间加权重策略	WeightedResponseTimeRule	根据server的响应时间分配权重，响应时间越长，权重越低，被选择到的概率也就越低。响应时间越短，权重越高，被选中的概率越高，这个策略很贴切，综合了各种因素，比如：网络，磁盘，io等，都直接影响响应时间
区域权重策略	ZoneAvoidanceRule	综合判断服务所在区域的性能，和服务的压力，轮询选择server并且判断一个AWS Zone的运行性能是否可用，剔除不可用的Zone中的所有server

RestTemplate整合Ribbon#

因为在SpringCloud2020之前，nacos客户端已经自己整合了ribbon依赖，所以实际上我们并不需要去添加该依赖就可以使用Ribbon了，仍然是使用@LoadBalanced注解

1
@Configuration
2
public class ClientConfig {
3

4
    @Bean
5
    @LoadBalanced
6
    public RestTemplate template() {
7
        return new RestTemplate();
8
    }
9
}

然后在使用RestTemplate发起调用的时候，直接使用服务名进行调用即可

1
        // 1.查询订单
2
        Order order = orderMapper.findById(orderId);
3
        // 2.利用RestTemplate发起http请求，查询用户
4
        // 2.1.url路径
5
        String url = "http://user-service/user/address/{userId}";
6
        // 2.2.发送http请求，实现远程调用
7
        String userAddress = restTemplate.getForObject(url, String.class, order.getUserId());
8
        // 3.封装user到Order
9
        order.setAddress(userAddress);
10
        // 4.返回
11
        return order;

指定Ribbon负载均衡策略#

和Spring Cloud LoadBalancer的使用方式类似

Ribbon也可以指定针对某个服务或所有服务使用的负载均衡策略
我们也可以实现Ribbon的自定义负载均衡策略

声明式接口调用#

现在我们的服务调用过程，又变得简单了一些，因为LoadBalancer帮助我们解决了，服务调用过程中的选择问题。再来看一下我们的服务调用代码

1
        // 2.1.url路径
2
        String url = "http://user-service/user/address/{userId}";
3
        // 2.2.发送http请求，实现远程调用
4
        String userAddress = restTemplate.getForObject(url, String.class, order.getUserId());

我们觉得以上的代码还是不够简洁，如果我们希望对于服务(服务中的Controller方法)调用，就像对普通方法一样的简单？就类似下面的代码一样：

1
public interface RemoteUserService {
2

3
    @GetMapping("/user/address/{id}")
4
    public String queryById(@PathVariable("id") Long id);
5
}

1
// 就像调用普通方法一样，调用到用户服务中的方法
2
String userAddress = remoteUserService.queryById(1);

OpenFeign就可以帮助我们实现这样的功能，进一步简化服务调用的代码。

OpenFeign 客户端#

OpenFeign是一个实现Java代码和Http客户端绑定的绑定器，通俗的来解释，它可以帮助我们以统一的方式，将接口”翻译”成Restful风格的请求。

OpenFeign的使用#

因为OpenFeign本身，充当着一个“翻译”的角色，可以将我们的Java接口翻译为对应的Http APIs，所以对于我们来说，OpenFeign也可以理解为一种服务调用的客户端，正因为是服务调用的客户端，所以只在服务消费者一端使用。

简单参数(返回值)#

虽然，OpenFeign本身仅仅只是在客户端使用，但是因为使用了OpenFeign意味着服务的调用是面向Java接口的，而非HTTP API的，调用方式发生了改变。所以我们需要给order-service添加OpenFeign依赖

添加如下依赖

1
        <dependency>
2
            <groupId>org.springframework.cloud</groupId>
3
            <artifactId>spring-cloud-starter-openfeign</artifactId>
4
        </dependency>

定义用来调用用户服务的OpenFeign接口

1
// 接口需要加FeignClient指定该接口中的方法，所调用的目标服务
2
@FeignClient("user-service")
3
public interface UserFeignClient {
4

5
    /* 接口方法上的注解以及方法参数主机，用来表示调用该方法时
6
        所发起的http请求的pah路径，以及参数
7
     */
8
    @GetMapping("user/address/{id}")
9
    public String queryById(@PathVariable("id") Long id);
10
}

在启动类上加注解@EnableFeignClients，才能让我们定义的FeignClient生效

1
@SpringBootApplication
2
@EnableDiscoveryClient
3
@EnableFeignClients
4
@MapperScan("com.cskaoyan.order.mapper")
5
public class OrderServiceApplication {
6

7
    public static void main(String[] args) {
8
        SpringApplication.run(OrderServiceApplication.class, args);
9
    }
10
}

以上的OpenFeign的依赖，接口定义，以及生效注解都准备好了，我们就可以开始使用OpenFeign了，在订单服务中，我们的服务调用代码可以修改如下：

1
        // 1.查询订单
2
        Order order = orderMapper.findById(orderId);
3
        // 2.利用OpenFeign接口发起http请求，查询用户
4
        String userAddress = userFeignClient.queryById(order.getUserId());
5
        // 3.封装user到Order
6
        order.setAddress(userAddress);
7
        // 4.返回
8
        return order;

注意事项

OpenFeign接口中定义的方法名，不需要和被调用的，目标服务的Controller方法的方法名相同，只要请求的path部分以及参数对应即可
如果需要传递请求参数，比如http://ip:port/path?arg1=value1&arg1=value2，此时我们需要给OpenFeign接口的方法参数加上@RequestParam注解

1
@FeignClient("test-service")
2
public interface TestArgFeignClient {
3

4
    @GetMapping("test/arg")
5
    public String testOpenFeignArg(@RequestParam("arg1") Long arg1,
6
                                   @RequestParam("arg2") Long arg2);
7
}

对象参数(返回值)#

刚才我们测试了，简单参数(Jdk中本身就有的数据类型)，现在我们来看看另一种情况，当我们被调用的目标服务方法需要返回(或接收)一个自定义对象User的时候，实现如下：

1
@RestController
2
@RequestMapping("/user")
3
public class UserController {
4

5
    @Autowired
6
    private UserService userService;
7

8
    /**
9
     * @param id 用户id
10
     * @return 用户
11
     */
12
    @GetMapping("/address/{id}")
13
    public User queryObjectById(@PathVariable("id") Long id) {
14
        // 根据id查询用户的地址信息
15
        return userService.queryObjectById(id);
16
    }
17
}

展开收起

此时，在订单服务中，我们的OpenFeign接口方法也就要做出相应的改变

1
@FeignClient("user-service")
2
public interface UserFeignClient {
3

4
    @GetMapping("user/address/{id}")
5
    public User queryObjectById(@PathVariable("id") Long id);
6
}

但是，真的这么简单就可以了吗？当然不是

我们很明显的看到报错了，原因是Order-Service和User-Service是两个独立的Maven工程，因此Order-Service并不认识在User-Service中定义的User类，那怎么解决这个问题呢？

让Order-Service也认识User-Service中定义的即可
因此我们在添加一个Maven工程，在该工程中，定义User，在让Order-Service和User-Service都依赖这个Maven工程即可

同时，分别在Order-Service和UserService中添加User-service-api的依赖即可

这里要注意，为什么我们不直接让Order-Service直接依赖UserService，这样不是也可以让Order-Service认识在User-Service中定义的User类吗？

因为一旦Order-Service依赖了User-Service那么OrderService在打包的时候，就会把User-Service的代码直接打包在一起
两个服务打成一个jar包，一旦运行起来，两个服务的代码运行在同一个进程中，这违反了微服务的理念

FeignClient日志输出#

当我们调用FeignClient发出请求的时候，如果我们希望能看到其发出的具体Http请求，我们可以通过配置来实现。

1
# 这里的xxx表示我们自己的定义的FeignClient所在包的包名(比如: com.cskaoyan.feign.consumer.api)
2
logging:
3
  level:
4
    xxx: debug

定义配置类，在配置类中，配置Feign的日志输出级别

1
@Configuration
2
public class FeignConfig {
3

4
    @Bean
5
    public Logger.Level logLevel() {
6
        return Logger.Level.FULL;
7
    }
8
}

这样当我们，通过在对应的FeignClient对象上，调动方法，发起http请求的时候，对应的请求就会打印在控制体

服务调用的超时设置#

通常，一次远程调用过程中，服务消费者不可能无限制的等待服务提供者返回的结果，正常情况下，服务提供者的一次调用执行过程也不会执行很长时间(除非出现网络故障，或者服务提供者宕机等问题)，所以为防止，在非正常情况下服务消费者在调用过程中的长时间阻塞等待，对于一次服务调用过程，我们会设置其超时时间。一次服务调用，超时未返回即认为调用失败。在使用Feign的时候，我们可以配置其超时时间，OpenFeign默认的超时时间是60s。

image-20240506015134414

1
feign:
2
  client:
3
    config:
4
    # default表示设置对所有服务设置调用超时时间的，如果想要设置某个服务的，将default改为对应服务名即可
5
      default:
6
        connectTimeout: 5000 # 连接超时时间
7
        readTimeout: 5000 # 调用超时时间

配置中心#

问题引出#

设想一下，如果每个服务都有自己的配置，比如服务访问的数据库地址等，但是某一天，数据库部署的服务器地址变了，此时会发生什么呢？为了让服务能够正确访问到数据库，我们得停止每一个服务，重新修改每一个服务的配置文件，然后在重新启动每个服务，在这个过程中就会出现两个问题：

修改配置文件的工作繁琐，工作量大，尤其当服务数量较多的时候
要让新的配置生效，得重启服务

配置中心#

如果要解决以上问题，那么在我们微服务架构的项目中，我们就得引入一个新的角色——配置中心来解决这个问题了，类似于注册中心，配置中心的实现也有多种，而Nacos同时也实现了配置中心的角色。

使用配置中心可以让您以中心化、外部化和动态化(动态化即可以实时刷新配置)的方式管理所有环境的应用配置和服务配置。
动态配置消除了配置变更时重新部署应用和服务的需要，让配置管理变得更加高效和敏捷。

Nacos 配置中心#

Nacos除了可以作为服务注册中心之外，还可以实现服务配置中心的功能。

在使用Nacos配置中心之前，我们必须对于配置中心的配置信息有一个清楚的认识：

配置中心中的配置，主要是以键值对的形式存在的，即每条配置都以key-value的形式存储，key是配置的名称，value才是配置的值
所以，很明显，不同配置的key值应该有所区别，或者即使key值相同，我们也应该有办法区分他们，即给key值划分不同的维度。

所以接下来，我们得介绍一下Nacos中定义的基本概念：

配置项: 一个具体的可配置的参数与其值域，通常以 param-key=param-value 的形式存在。例如我们常配置系统的日志输出级别（logLevel=INFO|WARN|ERROR）就是一个配置项。
配置集：一组相关或者不相关的配置项的集合称为配置集。在系统中，一个配置文件通常就是一个配置集，包含了系统各个方面的配置，每一个配置集都对应一个唯一的DataId，DataId必须由我们自己定义。
配置分组: Nacos 中的一组配置集，是组织配置的维度之一，每一个分组都有一个唯一的组名，如果我们未定义，则默认使用DEFAULT-GROUP分组
命名空间: 用于进行用户粒度的配置隔离，每一个命名空间都有一个唯一的Id值，如果我们未定义，则默认使用public命名空间

以上几个概念其实就是在告诉我们区分不同配置项的维度，Nacos提供多个维度帮助我们区分不同的配置，它们的关系如下图所示

有了以上不同的配置项的划分维度，我们就可以灵活定义我们的配置项了。其中

配置项中的key值，以及配置分组的组名都由我们自己根据场景去定义
命名空间的Id值，在我们定义命名空间的时候，由Nacos帮我们生成

Nacos配置中心的使用#

服务配置#

在用户服务中添加如下，访问nacos配置中心的依赖

1
        <dependency>
2
            <groupId>com.alibaba.cloud</groupId>
3
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
4
        </dependency>

每个服务都可以在配置中心中管理每个服务自己的配置(Profile配置)。可以指定每个服务所要读取的配置集名称

1
spring:
2
  cloud:
3
    nacos:
4
      config:
5
    # 配置中心地址
6
        server-addr: 192.168.153.130:8848
7
        # 配置集的文件格式
8
        file-extension: yml
9
  config:
10
    import:
11
      - nacos:配置集名称
12
      - nacos:配置集名称?group=MY_GROUP # 覆盖默认上面的group, 读取MY_GROUP的配置集

虽然这里的配置集id的定义可以是任意字符串，但是推荐大家使用如下公式生成目标配置集id即dataId

1
${spring.application.name}-${spring.profiles.active}.yml

spring.profiles.active 即为当前环境对应的 profile
最后的yml在说明配置文件的格式

这样一来，类比于上一个阶段我们在项目中通过修改spring.profiles.active配置值，我们就可以在配置中心实现多环境配置了。当然，除此之外，我们还可以通过制定namespace和group实现环境配置

1
spring:
2
  application:
3
  name: xxx
4
  profiles:
5
    active: dev
6
  cloud:
7
    nacos:
8
      config:
9
        #namespace: xxx
10
        #group: xxx
11
        server-addr: 127.0.0.1:8848
12
        file-extension: yaml
13
  config:
14
    import:
15
      - nacos:配置集名称
16
      - nacos:配置集名称?group=MY_GROUP # 覆盖默认上面的group, 读取MY_GROUP的配置集

展开收起

在nacos-config的目录下添加application.yml，在application.yml配置文件中的配置如下

1
# 项目中的其他配置都包含在application.yml文件中
2
server:
3
  port: 3377
4
spring:
5
  application:
6
    name: nacos-config-client
7
  profiles:
8
    active: dev # 表示开发环境
9
  cloud:
10
    nacos:
11
      config:
12
        #Nacos作为配置中心地址
13
        server-addr: localhost:8848
14
        name: xxx
15
        # 配置集的文件格式
16
        file-extension: yml
17
        # 指定配置所属的配置分组
18
        # group: DEV_GROUP
19
        # 指定配置所属的命名空间
20
        # namespace: 7d8f0f5a-6a53-4785-9686-dd460158e5d4
21
  config:
22
    import:
23
      - nacos:配置集名称
24
      - nacos:配置集名称?group=MY_GROUP # 覆盖默认上面的group, 读取MY_GROUP的配置集

展开收起

测试代码如下：

1
@RestController
2
public class ConfigController {
3

4
    @Value("${nacos.config}")
5
    String config;
6

7

8
    @GetMapping("/nacos/config")
9
    public String nacosCofnig() {
10
        return config;
11
    }
12
}

服务配置的动态刷新#

配置存储在配置中心之后，如果配置值发生了改变，是否必须重启服务才能让配置生效呢？当然不是，基于Nacos配置中心，我们可以实现配置的动态刷新。只需在需要使用配置值的类上加上@RefreshScope注解即可

1
@RestController
2
// 在使用配置的类上加该注解才能实现配置的动态刷新
3
@RefreshScope
4
public class UserController {
5

6
    @Value("${nacos.config}")
7
    String config;
8

9

10
    @GetMapping("/nacos/config")
11
    public String nacosCofnig() {
12
        return config;
13
    }
14
}

注意:

配置中心的配置优先级高于本地配置

Nacos 配置的持久化#

我们在Nacos服务器上写入的配置，会被持久化保存到Nacos自带的一个嵌入式数据库derby中，因此当我们重启Nacos之后，仍然可以看到之前的配置信息。但是，使用嵌入式数据库实现数据的存储，不方便观察数据存储的基本情况，因此，Nacos还支持将配置信息写入Mysql中：

在数据库中，创建名为nacos的数据库
在nacos数据库中，执行数据库初始化文件：mysql-schema.sql(改文件在conf目录下已经提供)
.修改conf/application.properties文件，增加支持mysql数据源配置（目前只支持mysql），添加mysql数据源的url、用户名和密码。

1
spring.datasource.platform=mysql
2
db.num=1
3
# 这里的url要改成你自己的mysql数据库地址，并在你的mysql中创建名为nacos的数据库
4
db.url.0=jdbc:mysql://11.162.196.16:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
5
# 这里要改成你自己登录mysql的用户名和密码
6
db.user.0=nacos_devtest
7
db.password.0=youdontknow

在配置了mysql数据库之后，我们会发现，之前配置中心的配置信息全部消失了，那是因为我们之前使用的是nacos的内嵌数据库derby，现在切换到mysql之后数据存储在nacos这个数据库中，而该数据库现在是没有数据的。

但是当我们，在nacos的控制台重新添加配置数据之后，我们就可以在mysql中看到了

网关#

网关介绍#

如果没有网关，难道不行吗？功能上是可以的，我们直接调用提供的接口就可以了。那为什么还需要网关？

因为网关的作用不仅仅是转发请求而已。我们可以试想一下，如果需要做一个请求认证功能，我们可以接入到 API 服务中。但是倘若后续又有服务需要接入，我们又需要重复接入。这样我们不仅代码要重复编写，而且后期也不利于维护。

由于接入网关后，网关将转发请求。所以在这一层做请求认证，天然合适。这样这需要编写一次代码，在这一层过滤完毕，再转发给下面的 API。

所以 API 网关的通常作用是完成一些通用的功能，如请求认证，请求记录，请求限流，黑白名单判断等。

API网关是一个服务器，是系统的唯一入口。 API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。通常，网关提供REST/HTTP的访问API。

image-20210713164010226

多入口：

image-20210713164033533

网关使用#

Spring Cloud Gateway是一个基于Spring生态的API网关，基于WebFlux框架实现。它旨在以简单高效的方式实现，请求路由，以及一些其他的边缘功能，比如，安全，监控等功能。

通用的网关框架除了Gateway之外，还有Zuul，Zuul2等框架。其中，Zuul是由Netflix公司开发出的最早的通用网关框架，功能丰富，但是基于同步阻塞式Servlet API实现，性能不佳。Zuul2可以理解为Zuul的升级版，它基于异步非阻塞模式实现，但是由于zuul2在开发过程中一直延期，所以Spring Coud官方并未采用Zuul2最为自己的通用网关，而是自己推出了自己的基于异步非阻塞实现的第二代服务网关Gateway。

核心概念#

Predicate：表示路由规则的匹配条件
Filter：过滤器，在请求处理之前(Pre)实现队请求的拦截处理，在请求处理之后(Post)实现对响应的拦截处理
Route：定义请求和路由目标之间的映射，它由一个唯一ID(自定义)，一个目标地址URI，表示路由条件Predicate集合，以及一个Filter集合组成。对于一个请求而言，如果它满足一个路由的全部路由条件(Predicate)，那么该请求就会按照该路由(Route)规则，向目标地址URI转发。

1
spring:
2
  cloud:
3
    gateway:
4
     #定义多个路由
5
      routes:
6
      # 一个路由route的id
7
      - id:  test_route
8
        # 该路由转发的目标URI
9
        uri: https://example.org
10
        # 路由条件集合
11
        predicates:
12
        - Path=/red/**
13
        # 过滤器集合
14
        filters:
15
        - AddRequestParameter=color, red

展开收起

我们再来看一看Gateway是如何工作的

客户端向Gateway发起请求
Gateway的Handler Mapping组件，会对请求做路由匹配，如果请求和某个路由规则匹配，则把该请求交给Web Handler处理
在将请求转发给目标之前，Web Handler会将请求，交给满足请求过滤条件的一系列过滤器，即一个过滤器链对该请求进行过滤处理
过滤器链，被虚线分隔，是因为过滤器既可以在转发请求前拦截请求，也可以在请求处理之后对响应进行拦截处理。

网关路由配置#

SpringCloud Gateway的网关配置有两种方式，配置文件配置和代码配置两种方式。

在使用Gateway之前，我们得单独创建一个Maven工程，引入Gateway依赖，之后将其独立启动。需要的依赖如下

1
<dependencies>
2
        <!--gateway-->
3
        <dependency>
4
            <groupId>org.springframework.cloud</groupId>
5
            <artifactId>spring-cloud-starter-gateway</artifactId>
6
        <!--loadbalancer依赖-->
7
        </dependency>
8
                <dependency>
9
            <groupId>org.springframework.cloud</groupId>
10
            <artifactId>spring-cloud-loadbalancer</artifactId>
11
        </dependency>
12
        <!--单元测试依赖-->
13
        <dependency>
14
            <groupId>org.springframework.boot</groupId>
15
            <artifactId>spring-boot-starter-test</artifactId>
16
        </dependency>
17
    </dependencies>

展开收起

配置文件配置#

假设现在我们在基于Gateway的网关中，添加路由配置，实现如下功能：

将URI匹配/routeconfig/rest/**的请求，转发给某一个服务或应用(将请求路由到服务或应用)
将URI匹配/guonei/**的请求，转发给另一个服务或应用(将请求路由到服务或应用)

1
spring:
2
  application:
3
    name: cloud-gateway
4
  cloud:
5
    gateway:
6
      routes:
7
         #路由的ID，没有固定规则但要求唯一，建议配合服务名
8
        - id: config_route
9
          #匹配后提供服务的路由地址
10
          uri: http://localhost:8002
11
           # 断言，路径相匹配的条件
12
          predicates:
13
            - Path=/routeconfig/rest/**
14
    #路由的ID，没有固定规则但要求唯一，建议配合服务名
15
        - id: config_news
16
          #匹配后提供服务的路由地址
17
          uri: http://news.baidu.com
18
          # 断言，路径相匹配的进行路由
19
          predicates:
20
            - Path=/guonei/**

展开收起

代码配置（不建议）#

1
@Configuration
2
public class GateWayConfig
3
{
4
    @Bean
5
    public RouteLocator customRouteLocator(RouteLocatorBuilder routeLocatorBuilder)
6
    {
7
        RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
8

9
        // route方法的第一个参数表示新建的routeID
10
        // 第二个参数表示Route对象对应的的Builder对象
11
        routes.route("code_route_config",
12
                r -> r.path("/guonei")
13
                        .uri("http://news.baidu.com")).build();
14

15
        return routes.build();
16
    }
17
}

展开收起

动态路由#

网关接收外部请求，按照一定的规则，将请求转发给其他服务或者应用。如果站在服务调用的角度，网关就扮演着服务消费者的角色，此时，如果我们再来看看服务调用的目标URI配置，就会很自然的发现一个问题，服务提供者调用的地址是写死的，即网关没有动态的发现服务，这就有涉及到了我们之前解决过的服务的自动发现问题，以及发现服务后，所涉及到的服务调用的负载均衡的问题。

回忆一下，我们之前是如何解决这些问题的？通过Nacos或者Eureka注册中心动态发现服务，通过Ribbon进行服务调用的负载均衡。同样，Gateway也可以整合Nacos或者Eureka，Ribbon从而实现，动态路由的功能。

想要使用动态路由的功能，首先我们要整合注册中心，这里我们以Nacos为例

1
        <!--SpringCloud ailibaba nacos -->
2
        <dependency>
3
            <groupId>com.alibaba.cloud</groupId>
4
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
        </dependency>

然后在配置文件中，添加注册中心的配置

1
spring:
2
  cloud:
3
    nacos:
4
      discovery:
5
        server-addr: localhost:8848

还要修改路由配置，使用动态路由

1
spring:
2
  application:
3
    name: cloud-gateway
4
  cloud:
5
    nacos:
6
      discovery:
7
        server-addr: localhost:8848
8
    gateway:
9
      routes:
10
         #路由的ID，没有固定规则但要求唯一，建议配合服务名
11
        - id: config_route
12
          #匹配后提供服务的路由地址, 这里lb之后，跟的是要调用的服务名称
13
          uri: lb://nacos-provider-8002
14
           # 断言，路径相匹配的条件
15
          predicates:
16
            - Path=/routeconfig/rest/**

展开收起

此时，当id为config_route的路由规则匹配某个请求后，在调用该请求对应的服务时，就会从nacos注册中心自动发现服务，并在服务调用的时候实现负载均衡。

Predicate#

在Gateway中，有一些的内置Predicate Factory，有了这些Pridicate Factory，在运行时，Gateway会自动根据需要创建其对应的Pridicate对象测试路由条件。

具体的有兴趣的话大家可以去查看官网: https://spring.io/projects/spring-cloud-gateway

Path 路由断言 Factory: 根据请求路径匹配的路由条件工厂

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
      - id: path_route
6
        uri: https://example.org
7
        predicates:
8
        # 如果可以匹配的PathPattern有多个，则每个路径模式以，分开
9
        - Path=/red/{segment},/blue/{segment}

After 路由断言 Factory：在指定日期时间之后发生的请求都将被匹配

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
      - id: after_route
6
        uri: http://example.org
7
        predicates:
8
        - After=2017-01-20T17:42:47.789-07:00[America/Denver]

Cookie 路由断言 Factory

Cookie 路由断言 Factory有两个参数，cookie名称和正则表达式。请求包含次cookie名称且正则表达式为真的将会被匹配。

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
      - id: cookie_route
6
        uri: http://example.org
7
        predicates:
8
        - Cookie=chocolate, ch.p

Header 路由断言 Factory

Header 路由断言 Factory有两个参数，header名称和正则表达式。请求包含次header名称且正则表达式为真的将会被匹配。

1
spring:
2
 cloud:
3
   gateway:
4
     routes:
5
     - id: header_route
6
       uri: http://example.org
7
       predicates:
8
       - Header=X-Request-Id, \d+

Host 路由断言 Factory

Host 路由断言 Factory包括一个参数：host name列表。使用Ant路径匹配规则，.作为分隔符。

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
      - id: host_route
6
        uri: http://example.org
7
        predicates:
8
        - Host=**.somehost.org,**.anotherhost.org

Method 路由断言 Factory

Method 路由断言 Factory只包含一个参数: 需要匹配的HTTP请求方式

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
      - id: method_route
6
        uri: http://example.org
7
        predicates:
8
        - Method=GET

所有GET请求都将被路由

Filter#

Gateway内置了很多的Filter这里就不再一一列举了。我们重点来学习下自定义Filter。

1
@Component
2
public class MyGatewayFilter implements GlobalFilter, Ordered {
3

4
    @Override
5
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
6
        ServerHttpRequest request = exchange.getRequest();
7
        MultiValueMap<String, HttpCookie> cookies = request.getCookies();
8
        List<HttpCookie> tokens = cookies.get("access_token");
9
        if (tokens == null || tokens.size() == 0) {
10
            throw new RuntimeException("少了cookie！");
11
        }
12

13
        return chain.filter(exchange);
14
    }
15

16
    @Override
17
    public int getOrder() {
18
       return 0;
19
    }
20
}

展开收起

基础技术

Sun, 14 Jun 2026 00:00:00 GMT

MyBatis-Plus#

简介#

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生（官方网址)，它具有如下特性：

愿景
我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分，CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库

环境准备#

要是用MyBatis-Plus我们得准备好数据库中的表数据，所需的依赖，以及部分相关代码。

数据准备#

以一张简单的单表User表为例，其结构如下

id	name	age	email
1	Jone	18	test1@baomidou.com
2	Jack	20	test2@baomidou.com
3	Tom	28	test3@baomidou.com
4	Sandy	21	test4@baomidou.com
5	Billie	24	test5@baomidou.com

对应建表语句如下

1
DROP TABLE IF EXISTS user;
2

3
CREATE TABLE user
4
(
5
    id BIGINT(20) NOT NULL COMMENT '主键ID',
6
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
7
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
8
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
9
    PRIMARY KEY (id)
10
);

对应数据如下

1
DELETE FROM user;
2

3
INSERT INTO user (id, name, age, email) VALUES
4
(1, 'Jone', 18, 'test1@baomidou.com'),
5
(2, 'Jack', 20, 'test2@baomidou.com'),
6
(3, 'Tom', 28, 'test3@baomidou.com'),
7
(4, 'Sandy', 21, 'test4@baomidou.com'),
8
(5, 'Billie', 24, 'test5@baomidou.com');

工程依赖准备#

创建一个SpringBoot工程(可以使用Spring Initializer)，引入如下依赖

1
<parent>
2
  <groupId>org.springframework.boot</groupId>
3
  <artifactId>spring-boot-starter-parent</artifactId>
4
  <version>2.7.17</version>
5
</parent>
6
<dependencies>
7
    <dependency>
8
        <groupId>org.springframework.boot</groupId>
9
        <artifactId>spring-boot-starter</artifactId>
10
    </dependency>
11
    <dependency>
12
        <groupId>org.springframework.boot</groupId>
13
        <artifactId>spring-boot-starter-test</artifactId>
14
        <scope>test</scope>
15
    </dependency>
16
    <dependency>
17
        <groupId>com.baomidou</groupId>
18
        <artifactId>mybatis-plus-boot-starter</artifactId>
19
        <version>3.5.3.1</version>
20
    </dependency>
21
     <dependency>
22
         <groupId>mysql</groupId>
23
         <artifactId>mysql-connector-java</artifactId>
24
         <version>8.0.20</version>
25
         <scope>runtime</scope>
26
     </dependency>
27
      <dependency>
28
            <groupId>org.projectlombok</groupId>
29
            <artifactId>lombok</artifactId>
30
            <optional>true</optional>
31
        </dependency>
32
</dependencies>

展开收起

在application.yml中添加如下配置

1
spring:
2
  datasource:
3
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
4
    driver-class-name: com.mysql.cj.jdbc.Driver
5
    username: root
6
    password: 1234
7
# 在日志中显示实际执行的sql语句
8
logging:
9
  level:
10
    com.cskaoyan.mybatis.plus.mapper: debug

代码准备#

在启动类上加MapperScan注解

1
@SpringBootApplication
2
@MapperScan("com.cskaoyan.mybatisplus.mapper")
3
public class Application {
4
    public static void main(String[] args) {
5
        SpringApplication.run(Application.class, args);
6
    }
7
}

定义user表对应的映射实体类User

1
@Data //lombok注解
2
public class User {
3
    private Long id;
4
    private String name;
5
    private Integer age;
6
    private String email;
7
}

定义Mapper

BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的实体类型

1
public interface UserMapper extends BaseMapper<User> {
2
}

1.3. 基本CRUD#

定义一个用于测试的测试类，其中包含基本CRUD的代码

1
@SpringBootTest(classes = SpringBoot的启动类.class)
2
public class TestBasic {
3
    @Autowired
4
    private UserMapper userMapper;
5

6
}

新增数据#

1
   @Test
2
    public void testInsert() {
3
        User user = new User();
4
        user.setName("zs");
5
        user.setEmail("abcd@xxx.com");
6
        user.setAge(100);
7

8
        int effectiveRow = userMapper.insert(user);
9
        // 输出受影响的行数
10
        System.out.println("受影响行数：" + effectiveRow);
11
        // 输出自动生成的id
12
        System.out.println(user.getId());
13
    }

注意： MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id

删除数据#

根据id删除#

1
    @Test
2
    public void testDeleteById() {
3
        int effectiveRow = userMapper.deleteById(1630492821798178818L);
4
        System.out.println("受影响行数: " + effectiveRow);
5
    }

根据id批量删除#

1
    @Test
2
    public void testDeleteBatchByIds() {
3
        List<Long> ids = Arrays.asList(1L, 2L);
4
        int effectiveRow = userMapper.deleteBatchIds(ids);
5
        System.out.println("受影响行数: " + effectiveRow);
6
    }

根据Map条件删除#

注意Map中放的是where条件中包含的多个条件字段，以及条件字段对应的值(比较的关系是相等关系)

1
@Test
2
public void testDeleteByMap(){
3
    //根据map集合中所设置的条件删除记录
4
    //DELETE FROM user WHERE name = ? AND age = ?
5
    Map<String, Object> param = new HashMap<>();
6
    // age = 21
7
    param.put("age", 21);
8
    // name=sandy
9
    param.put("name", "Sandy");
10
    int effectiveRow = userMapper.deleteByMap(map);
11
    System.out.println("受影响行数：" + effectiveRow);
12
}

修改数据#

1
@Test
2
public void testUpdateById(){
3
    User user = new User();
4
    user.setId(6L);
5
    user.setName("changfeng");
6
    user.setAge(20);
7
    //UPDATE user SET name=?, age=? WHERE id=?
8
    int effectiveRow = userMapper.updateById(user);
9
    System.out.println("受影响行数：" + effectiveRow);
10
}

查询数据#

根据id查询#

1
@Test
2
public void testSelectById(){
3
    User user = userMapper.selectById(4L);
4
    System.out.println(user);
5
}

根据id批量查询#

1
@Test
2
public void testSelectBatchByIds(){
3
    //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
4
    List<Long> ids = Arrays.asList(3L, 4L， 5L);
5
    List<User> result = userMapper.selectBatchIds(ids);
6
    result.forEach(System.out::println);
7
}

根据Map条件查询#

1
@Test
2
public void testSelectByMap(){
3
    //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
4
    Map<String, Object> map = new HashMap<>();
5
    map.put("age", 24);
6
    map.put("name", "Billie");
7
    List<User> result = userMapper.selectByMap(map);
8
    result.forEach(System.out::println);
9
}

查询全表数据#

1
@Test
2
public void testSelectAll(){
3
    // 这里null代表没有where条件
4
    //SELECT id,name,age,email FROM user
5
    List<User> result = userMapper.selectList(null);
6
    result.forEach(System.out::println);
7
}

常用注解#

@TableName注解#

刚才我们已经，学习了MyBatis-Plus基本的CRUD，但是其实还有一个遗留问题。我们知道，在数据库中是同时存在多张表的，我们怎么控制使用Mapper，操作某一张表的呢？这其实就和@TableName注解有关系了。

可以使用@TableName注解，定义数据库表和实体类的关系(默认情况下，会根据实体类的类名访问数据库中的表，所以如果当表名和类名相同时，不加@TableName注解，也不会报错)

1
@Data
2
@TableName(value = "user")
3
public class User {
4
    private Long id;
5
    private String name;
6
    private Integer age;
7
    private String email;
8
}

@TableId注解#

在我们单表中，可以同时定义多个字段，在我们的映射实体类中，也可以同时定义多个属性。在单表中，我们通常都会定义主键字段，那么主键字段是如何和实体类中的某个属性对应起来的呢？这就和@TableId注解有关系了。

可以使用@TableId注解，定义数据库中的主键字段和实体类中的主键属性之间的映射关系。(默认情况下，MyBatis-Plus会根据主键名来映射，映射到同名实体类属性)

1
@Data
2
@TableName(value = "user")
3
public class User implements Serializable {
4
    @TableId(value = "id", type = IdType.ASSIGN_ID)
5
    private Long id;
6
    private String name;
7
    private Integer age;
8
    private String email;
9
}

其中，value属性指的是数据库主键字段的名称，IdType表示主键的类型。在MyBatis-Plus中主键类型有以下几种

值	描述
AUTO	数据库 ID 自增
NONE	无状态，该类型为未设置主键类型（注解里等于跟随全局，全局里约等于 INPUT）
INPUT	insert 前自行 set 主键值
ASSIGN_ID	分配 ID(主键类型为 Number(Long 和 Integer)或 String)(since 3.3.0),使用接口`IdentifierGenerator`的方法`nextId`(默认实现类为`DefaultIdentifierGenerator`雪花算法)
ASSIGN_UUID	分配 UUID,主键类型为 String(since 3.3.0),使用接口`IdentifierGenerator`的方法`nextUUID`(默认 default 方法)

@TableField注解#

类似于@TableId注解，@TableField注解在实体类中用来定义实体类中的普通属性和数据库字段的映射(默认情况下，MyBatis-Plus会根据字段名来映射，映射到同名实体类属性)

1
@Data
2
@TableName(value = "user")
3
public class User implements Serializable {
4
    @TableId(value = "id", type = IdType.ASSIGN_ID)
5
    private Long id;
6
    @TableField(value = "name")
7
    private String name;
8
    @TableField(value = "age")
9
    private Integer age;
10
    @TableField(value = "email")
11
    private String email;
12
}

@TableField注解需要注意：

若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格（例如实体类属性userName，表中字段user_name），此时MyBatis-Plus会自动将驼峰命名风格转化为下划线命名风格
若实体类中的属性和表中的字段不满足上述情况，例如实体类属性name，表中字段username，此时需要在实体类属性上使用@TableField(“username”)设置属性所对应的字段名

除此之外，@TableField注解，如果我们如果不想让实体类中的某个属性，映射到数据库中的某个字段，我们可以给@TableField注解的exist属性赋值false，这样一来，在利用实体类对象的做增删改查的时候，就会忽略实体类对象的该属性值

1
@Data
2
@TableName(value = "user")
3
public class User implements Serializable {
4
    @TableId(value = "id", type = IdType.ASSIGN_ID)
5
    private Long id;
6
    @TableField(value = "name")
7
    private String name;
8
    // 忽略age属性，不让其映射到数据库的age字段
9
    @TableField(exist = false)
10
    private Integer age;
11
    @TableField(value = "email")
12
    private String email;
13
}

@TableLogic#

为了实现逻辑删除，我们可以在表示删除状态的实体类属性上添加@TableLogic注解，从而实现逻辑删除的功能。当然，在使用之前，我们要先给数据库user表增加is_deleted属性并给该字段赋默认初值0表示未删除，以及在实体类中添加isDeleted属性。

image-20230301005215922

1
@Data
2
@TableName(value = "user")
3
public class User implements Serializable {
4
    @TableId(value = "id", type = IdType.ASSIGN_ID)
5
    private Long id;
6
    @TableField(value = "name")
7
    private String name;
8
    @TableField(value = "age")
9
    private Integer age;
10
    @TableField(value = "email")
11
    private String email;
12
    @TableLogic
13
    private Integer isDeleted;
14
}

这样一来，当我们执行删除语句的时候，实际执行的就是一条set语句，比如当我们根据id删除一条记录时，实际执行的是

1
UPDATE user SET is_deleted=1 WHERE id=? AND is_deleted=0

当我们执行查询语句的时候，会自动附带逻辑删除状态的判断，查询结果中不会包含已经被逻辑删除的记录

1
SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0

条件构造器Wrapper#

在我们对数据库做增删改查操作的时候，往往需要附带一些条件即where条件，这些条件就是用条件构造器Wrapper来构造和表示的。

Wrapper ：条件构造抽象类，最顶端父类

AbstractWrapper ：用于查询条件的封装，生成 sql 的 where 条件

QueryWrapper ：查询条件的封装

UpdateWrapper ： Update 条件封装(除了包含更新条件，还可以指定更新的字段和对应的新值)

AbstractLambdaWrapper ： Lambda 语法使用的Wrapper，统一处理解析 lambda 获取 column

LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper

LambdaUpdateWrapper ：用于Lambda语法使用的更新Wrapper(除了包含更新条件，还可以指定更新的字段和对应的新值)

QueryWrapper#

QueryWrapper中提供了多个方法，每个方法都代表了一种条件。可以在Wrapper对象上调用多个方法，从而组装多个具体的查询条件，这些条件可以AND关系，也可以是OR关系。

调用多个方法，这些方法表示的条件默认是AND关系

1
  @Test
2
    public void testAnd(){
3
        //查询用户名包含a，年龄在20到30之间，邮箱不为null的用户信息，并且按照年龄的升序排序
4
        //SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 AND (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL) ORDER BY age DESC
5
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
6
        queryWrapper.like("name", "a")
7
                .between("age", 20, 30)
8
                .isNotNull("email")
9
                .orderByDesc("age");
10
        List<User> result = userMapper.selectList(queryWrapper);
11
        result.forEach(System.out::println);
12
    }

如果要想表示条件之间的OR关系，必须调用or()方法来表示OR运算符

1
    @Test
2
    public void testOr(){
3
        //查询用户名包含a 或者 年龄大于20，并且按照年龄的升序排序
4
        // SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 AND (name LIKE ? OR age > ?) ORDER BY age DESC
5
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
6
        queryWrapper.like("name", "a")
7
                .or()
8
                .gt("age", 20)
9
                .orderByDesc("age");
10
        List<User> result = userMapper.selectList(queryWrapper);
11
        result.forEach(System.out::println);
12
    }

除了针对where中的条件，我们还可以指定select中查询的字段

1
    @Test
2
    public void testSelect() {
3
        //查询用户id > 3 且 年龄在18-30之间的用户的名字
4
        // SELECT name FROM user WHERE is_deleted=0 AND (id > ? AND age BETWEEN ? AND ?)
5
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
6
        queryWrapper.gt("id", 3)
7
                .between("age", 18, 30)
8
                .select("name");
9
        List<User> list = userMapper.selectList(queryWrapper);
10
        list.forEach(System.out::println);
11
    }

当然QueryWrapper还可以使用在删除语句中，表示删除条件

1
    @Test
2
    public void testWrapperWithDelete() {
3
        // 删除age < 20的用户
4
        // Delete from user WHERE age < ?
5
        // update user set is_deleted = 1 where is_deleted = 0 and (age < ?)
6
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
7
        queryWrapper.lt("age", 20);
8
        int deleteRow = userMapper.delete(queryWrapper);
9
        System.out.println("影响行数： " + deleteRow);
10
    }

UpdateWrapper#

我们可以使用UpdateWrapper来实现数据的修改，在使用UpdateWrapper修改的时候，我们可以使用User对象的非空属性值，表示通过set 语句修改的目标字段及其新值 set 字段1 = 新值1，…

1
    @Test
2
    public void updateWrapperWithUserObj() {
3

4
        // 将Jone的年龄改为29，邮箱改为 Jone@cskaoyan.com
5
        // UPDATE user SET age=?, email=? WHERE name = ?
6
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
7
        userUpdateWrapper.eq("name", "Jone");
8
        // 创建User对象，该对象的非空属性，对应着set语句修改的数据库字段，以及对应的字段值
9
        User user = new User();
10
        // 设置email属性为待修改的新值
11
        user.setEmail("Jone@cskaoyan.com");
12
        // 设置age属性为待修改的新值
13
        user.setAge(29);
14
        // update
15
        userMapper.update(user, userUpdateWrapper);
16
    }

展开收起

在使用UpdateWrapper的时候，我们也可以直接使用UpdateWrapper的set方法，设置set语句修改的目标字段及其新值

1
    @Test
2
    public void updateWrapperWithoutObj() {
3
        // 将Jone的年龄改为29，邮箱改为 Jone@cskaoyan.com
4
        // UPDATE user SET age=?, email=? WHERE name = ?
5
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
6
        userUpdateWrapper.eq("name", "Jone");
7
        // 设置email属性为待修改的新值
8
        userUpdateWrapper.set("email","Jone@cskaoyan.com");
9
        // 设置age属性为待修改的新值
10
        userUpdateWrapper.set("age", 29);
11

12
        // update, 不需要传递user对象，因为使用UpdateWrapper的set方法来设置值
13
        userMapper.update(null, userUpdateWrapper);
14

15
    }

展开收起

Condition#

在实际开发中，有时需要根据条件来决定是否在SQL语句中添加条件，即需要实现动态SQL的功能，此时我们可以使用带condition参数的重载方法来实现。该condition参数是一个boolean值，表示是否在SQL语句中拼接条件。

1
    @Test
2
    public void testCondition () {
3
        String name = null;
4
        Integer minAge = null;
5
        Integer maxAge = 25;
6

7
        // 查询指定name，年龄在指定范围的用户
8
        // Preparing: SELECT id,name,age,email FROM user WHERE age <= ?
9
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
10
        // 每一个条件，都可以调用其有condition参数的重载方法(都是第一个参数)
11
        userQueryWrapper.eq(null != name && !name.isEmpty(), "name", name)
12
                .ge(minAge != null, "age", minAge)
13
                .le(maxAge != null, "age", maxAge);
14

15
        List<User> users = userMapper.selectList(userQueryWrapper);
16
    }

展开收起

LambdaQueryWrapper#

LambdaQueryWrapper 的本质和QueryWrapper是相同的，都主要表示where中的条件，唯一不同的是，在指定条件字段的时候，不是直接指定字段的名称，而是通过Lambda表达式(实体类中对应属性的getXxx方法或者isXxx方法)来指定。

1
    @Test
2
    public void testLambdaQueryWrapper() {
3
        String name = null;
4
        Integer minAge = null;
5
        Integer maxAge = 25;
6

7
        // 查询name为zs，年龄在18-25岁的用户
8
        // Preparing: SELECT id,name,age,email FROM user WHERE age <= ? AND name=?
9
        LambdaQueryWrapper<User> userQueryWrapper = new LambdaQueryWrapper<>();
10
        // 和QueryWrapper的不同之处就在于，列名使用一个Lambda表达式来表示的(属性对应的get方法)
11
        userQueryWrapper.eq(null != name && !name.isEmpty(), User::getName, "zs")
12
                .ge(minAge != null, User::getAge, minAge)
13
                .le(maxAge != null, User::getAge, maxAge);
14

15
        List<User> users = userMapper.selectList(userQueryWrapper);
16
    }

展开收起

LambdaUpdateWrapper#

1
    @Test
2
    public void testLambdaUpdateWrapper() {
3
        // 将Jone的年龄改为29，邮箱改为 Jone@cskaoyan.com
4
        // UPDATE user SET age=?, email=? WHERE name = ?
5
        LambdaUpdateWrapper<User> userUpdateWrapper = new LambdaUpdateWrapper<>();
6
        // 列名使用一个Lambda表达式来表示的(属性对应的get方法)
7
        userUpdateWrapper.eq(User::getName, "Jone");
8
        // 设置email属性为待修改的新值（列名使用一个Lambda表达式来表示的(属性对应的get方法)）
9
        userUpdateWrapper.set(User::getEmail,"Jone@cskaoyan.com");
10
        // 设置age属性为待修改的新值(列名使用一个Lambda表达式来表示的(属性对应的get方法))
11
        userUpdateWrapper.set(User::getAge, 29);
12

13
        // update, 不需要传递user对象，因为使用UpdateWrapper的set方法来设置值
14
        userMapper.update(null, userUpdateWrapper);
15

16
    }

展开收起

分页插件#

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

添加配置类

1
@Configuration
2
//@MapperScan("com.cskaoyan.mybatisplus.mapper") //可以将主类中的注解移到此处
3
public class MybatisPlusConfig {
4
    @Bean
5
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
6
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
7
        // 添加针对Mysql数据库的分页拦截器
8
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
9
        return interceptor;
10
  }
11
}

1
@Test
2
public void testPage(){
3
    //设置分页参数
4
    // 注意页数从1开始
5
    Page<User> page = new Page<>(1, 2);
6
    userMapper.selectPage(page, null);
7
    //获取分页中的每一条记录
8
    List<User> list = page.getRecords();
9
    list.forEach(System.out::println);
10
    System.out.println("当前页：" + page.getCurrent());
11
    System.out.println("每页显示的条数：" + page.getSize());
12
    System.out.println("总记录数：" + page.getTotal());
13
    System.out.println("总页数：" + page.getPages());
14
    System.out.println("是否有上一页：" + page.hasPrevious());
15
    System.out.println("是否有下一页：" + page.hasNext());
16
}

展开收起

Mapstruct#

引入#

在实际开发中，一个web应用通常会被分为三层，分别为持久层，业务层，控制层，每层各有各的职责，所以针对同一个请求，每层返回的对象应该是不同的。

持久层：主要负责访问数据库中的数据，并将数据库中的数据封装为PO对象，对上层屏蔽数据访问细节。持久层不关心业务，只关心数据，因此对象属性和数据库表字段一一对应
业务层：业务层从持久层获取封装数据，并根据具体的业务逻辑计算，得到业务层的计算结果，用DTO对象来封装。DTO对象的全称是 Data Tranfer Object。
控制层：控制层获取业务层的业务处理结果之后，还可能需要将其加工成前端所需要的格式，封装成VO对象返回给前端显示。

所以，在处理一个请求的时候业务层需要完成PO—>DTO对象的转化，控制层需要完成DTO—>VO对象的转化。而对象转化本身就是纯粹的“体力活”没有任何技术含量。

1
  // 待转化的PO对象
2
  XxxPO sourcePO = ...
3

4
  // 目标DTO对象
5
  XxxDTO destDTO = new XxxDTO();
6

7
  //通过一堆get/set方法完成转化
8
  destDTO.setXxx(sourcePO.getXxx());
9
  ...

对于这种没有技术含量的活，有追求的程序员是不屑做的，但是在项目中我们又必须要完成，怎么办呢？于是就有了Mapstruct来帮我们完成对象转化的工作。

使用#

导入依赖

1
<dependencies>
2
        <!--spring-boot-->
3
        <dependency>
4
            <groupId>org.springframework.boot</groupId>
5
            <artifactId>spring-boot-starter</artifactId>
6
            <version>2.7.17</version>
7
        </dependency>
8

9
        <dependency>
10
            <groupId>org.springframework.boot</groupId>
11
            <artifactId>spring-boot-starter-test</artifactId>
12
            <version>2.7.17</version>
13
        </dependency>
14

15
        <!--mapstruct-->
16
        <dependency>
17
            <groupId>org.mapstruct</groupId>
18
            <artifactId>mapstruct</artifactId>
19
            <version>1.5.5.Final</version>
20
        </dependency>
21
        <dependency>
22
            <groupId>org.mapstruct</groupId>
23
            <artifactId>mapstruct-processor</artifactId>
24
            <version>1.5.5.Final</version>
25
        </dependency>
26

27
        <!--lombok-->
28
        <dependency>
29
            <groupId>org.projectlombok</groupId>
30
            <artifactId>lombok</artifactId>
31
            <version>1.18.24</version>
32
        </dependency>
33
    </dependencies>
34

35
    <build>
36
        <plugins>
37
            <plugin>
38
                <groupId>org.apache.maven.plugins</groupId>
39
                <artifactId>maven-compiler-plugin</artifactId>
40
                <version>3.8.1</version>
41
                <configuration>
42
                    <source>17</source>
43
                    <target>17</target>
44
                    <annotationProcessorPaths>
45
                        <path>
46
                            <groupId>org.mapstruct</groupId>
47
                            <artifactId>mapstruct-processor</artifactId>
48
                            <version>1.5.5.Final</version>
49
                        </path>
50
                        <path>
51
                            <groupId>org.projectlombok</groupId>
52
                            <artifactId>lombok</artifactId>
53
                            <version>1.18.24</version>
54
                        </path>
55
                        <path>
56
                            <groupId>org.projectlombok</groupId>
57
                            <artifactId>lombok-mapstruct-binding</artifactId>
58
                            <version>0.2.0</version>
59
                        </path>
60
                    </annotationProcessorPaths>
61
                </configuration>
62
            </plugin>
63
        </plugins>
64
    </build>

展开收起

定义转化器接口

1
@Mapper(componentModel = "spring")
2
public interface XxxConverter {
3
   // 定义转化方法将source原对象转化为目标对象
4
   目标类 方法名(待转化类 source);
5
}

使用定义的转化器接口

1
   @Autowired
2
   XxxConverter xxxConverter;
3

4
    @Test
5
    public void testMapStruct() {
6
     目标类 dest = xxxConverter.方法(users);
7
    }

简单对象的转化#

1
@Data
2
public class Doctor {
3
    private int id;
4
    private String name;
5
}
6
@Data
7
public class DoctorDTO {
8
    private int id;
9
    private String name;
10
}

在源对象(Doctor)和目标对象(DoctorDTO)的属性完全相同，我们可以简单定义转化器接口如下

1
@Mapper(componentModel = "spring")
2
public interface DoctorConverter {
3
    DoctorDTO doctorPO2DTO(Doctor doctor);
4
}

然后再需要的地方注入Converter对象，调用转化方法即可

1
   @Autowired
2
   DocterConverter docterConverter;
3

4
    @Test
5
    public void testSimpleObj() {
6
     Doctor docter = ...
7
     // 完成转化
8
     DoctorDTO destDTO = docterConverter.doctorPO2DTO(docter);
9
    }

不同属性名的映射#

假设我们给医生增加一个薪资属性，该属性在Doctor类中叫pay，在DoctorDTO中叫salary，属性名不一致，我们仍然可以完成转化

1
@Data
2
public class Doctor {
3
    private Integer id;
4
    private String name;
5
    // 薪资
6
    private String pay;
7
}

1
@Data
2
public class DoctorDTO {
3
    private Integer id;
4
    private String name;
5
    // 薪资
6
    private String salary;
7
}

定义转化器接口

1
@Mapper(componentModel = "spring")
2
public interface DoctorConverter {
3
    @Mapping(source="pay", target="salary")
4
    DoctorDTO doctorPO2DTO(Doctor doctor);
5
}

1
   @Autowired
2
   DocterConverter docterConverter;
3

4
    @Test
5
    public void testFieldMappingObj() {
6
     Doctor doctor = ...
7
     // 完成转化
8
     DoctorDTO destDTO = docterConverter.doctorPO2DTO(docter);
9
    }

多个不同类型源对象的转化#

有时候在转化一个对象的时候，涉及另外的多个对象的属性值，此时我们就可以把多个对象的属性值，赋值给目标对象

1
@Data
2
public class Education {
3
    // 学位
4
    private String degreeName;
5
    // 学校
6
    private String institute;
7
    // 毕业年份
8
    private Integer yearOfPassing;
9
}

1
@Data
2
public class Doctor {
3
    private int id;
4
    private String name;
5
    // 薪资
6
    private String pay;
7
}
8

9
@Data
10
public class DoctorDto {
11
    private int id;
12
    private String name;
13
    // 学历
14
    private String degree;
15
    private String salary;
16
}

展开收起

定义转化器接口

1
@Mapper(componentModel = "spring")
2
public interface DoctorConverter {
3
    // 多个源对象的话，在指定源对象属性时 通过对象名.属性名的方式指定
4
    @Mapping(source = "doctor.id", target = "id")
5
    @Mapping(source = "doctor.name", target = "name")
6
    @Mapping(source = "doctor.pay", target = "salary")
7
    @Mapping(source = "education.degreeName", target = "degree")
8
    DoctorDTO doctorPO2DTO(Doctor doctor, Education education);
9
}

1
   @Autowired
2
   DocterConverter docterConverter;
3

4
    @Test
5
    public void testFieldMappingObj() {
6
     Doctor doctor = ...
7
     Education education = ...
8
     // 完成转化
9
     DoctorDTO destDTO = docterConverter.doctorPO2DTO(docter, education);
10
    }

转化复杂对象#

如果一个对象持有了另外一个对象，或者另外一个对象的List，Mapstruct还可以帮我们实现类似“深度克隆”的”深度转化“。

1
@Data
2
public class Patient {
3
    private int id;
4
    private String name;
5
}
6

7
@Data
8
public class PatientDTO {
9
    private int id;
10
    private String name;
11
}

1
public class Doctor {
2
    private int id;
3
    private String name;
4
    private String pay;
5
    // 医生有患者
6
    private Patient patient;
7
}

1
public class DoctorDTO {
2
    private int id;
3
    private String name;
4
    private String salary;
5
    // 医生有患者
6
    private PatientDTO patientDTO;
7
}

定义转化器Converter

1
@Mapper(componentModel = "spring")
2
public interface DoctorConverter {
3
    @Mapping(source="pay", target="salary")
4
    DoctorDTO doctorPO2DTO(Doctor doctor);
5

6
    PatientDTO patientPO2DTO(Patient patient);
7
}

1
   @Autowired
2
   DocterConverter docterConverter;
3

4
    @Test
5
    public void testComplicatedObj() {
6
     Doctor doctor = ...
7
     Patient patient = ...
8
     doctor.setPatient(patient);
9
     // 完成转化
10
     DoctorDTO destDTO = docterConverter.doctorPO2DTO(docter);
11
    }

这里要注意的是，在Doctor对象持有了一个Patient，但是当我们调用Converter转化器的doctorPO2DTO方法时，Mapstruct在转化Doctor对象的时候，也会把Patient对象转化为PatientDTO对象。原因是：

我们在Converter转化器中定义了如下转化方法

1
 PatientDTO patientPO2DTO(Patient patient);

当转化器在Converter在执行complicatedDoctorPO2DTO方法转化Doctor对象的过程中，遇到Patient patient属性时，Converter会“自动发现”patientPO2DTO方法，将源对象中的Patient 对象转化为PatientDTO对象
“自动发现”其实就是用Doctor的源对象目标属性patient的类型，和某个Converter转化器中方法的入参做类型匹配，同时，用目标对象的目标属性patientDTO和该方法的返回值类型做类型匹配
如果类型都匹配上了，就会自动使用这个转化器方法来完成源对象属性和目标对象属性之间的转化

其实，当Doctor对象中有属性List patientList， DoctorDTO对象中有属性List 的时候Mapstrut也会对List中的对象类型和转化器方法的入参和返回值类型，做类型匹配，从而使用patientPO2DTO方法，完成将List patientList转化为List的工作。

转化List#

1
@Data
2
public class Doctor {
3
    private int id;
4
    private String name;
5
    // 薪资
6
    private String pay;
7
}

1
public class DoctorDTO {
2
    private int id;
3
    private String name;
4
    private String salary;
5
}

如果我们想一次性的将多个Doctor对象转化成多个DoctorDTO对象，此时我们可以定义如下Converter转化器方法

1
@Mapper(componentModel = "spring")
2
public interface DoctorConverter {
3
    @Mapping(source="pay", target="salary")
4
    DoctorDTO doctorPO2DTO(Doctor doctor);
5

6
    List<DoctorDTO> doctorPOs2DTOs(List<Doctor> doctors);
7
}

1
   @Autowired
2
   DocterConverter docterConverter;
3

4
    @Test
5
    public void testFieldMappingObj() {
6
     List<Doctor> doctor = ...
7
     // 完成转化
8
     List<DoctorDTO> destDTOs = docterConverter.doctorPOs2DTOs(docter);
9
    }

环境搭建

Sun, 14 Jun 2026 00:00:00 GMT

虚拟机环境#

虚拟机安装#

软硬件准备#

软件：推荐使用VMware，服务器上有相关安装包。

镜像：推荐使用ubuntu 18.04，本文也是以ubuntu18.04 为例进行说明

硬件：因为是在宿主机上运⾏虚拟化软件安装ubuntu，所以对宿主机的配置有⼀定的要求。最起码I5CPU 双核，内存4G及以上。

虚拟机安装#

安装VMware
打开VMware创建新的虚拟机

image-20230320213838425
选择自定义安装或者是典型安装模式
- 典型安装：VMware会将主流的配置应⽤在虚拟机的操作系统上，对于新手来很友好
- 自定义安装：⾃定义安装可以针对性的把⼀些资源加强，把不需要的资源移除。避免资源的浪费
  
  推荐使用典型安装即可，需要注意的是，网络适配器选择NAT模式。
  
  image-20230320225922056
安装完虚拟机之后开启虚拟机，稍微等待一会即可安装完成

静态IP设置#

说明，NAT模式默认情况下是DHCP模式，是自动获取IP的，导致每次虚拟机开启之后获取的IP可能会变化，假如项目中后续连接的是虚拟机上面的MySQL，那么MySQL的HOST地址可能会经常改变，这就需要我们经常去改项目中的MySQL的连接地址，比较麻烦。所以需要改为静态IP，也就是每次开机之后IP不会变，这样才能方便我们后面项目的开发。

首先查看虚拟机本地的IP地址，执行命令

Terminal window

1
# 查看本地IP地址
2
ifconfig
3

4
# 如果提示没有找到这个命令，那么首先需要安装工具
5
sudo apt install net-tools

image-20230320230756033

查看网关地址

编辑 ⇒ 虚拟网络编辑器 ⇒ VMnet8 ⇒ NAT设置

image-20230320232059604

点击NAT设置，即可看到如下图所示

image-20230320232229532
设置静态IP

设置 ⇒ Network ⇒ 点击齿轮

image-20230320232430561

设置为下图所示

image-20230320232846295

重启虚拟机，查看IP地址是否变化，如果未变，那么设置成功。

docker安装#

准备工作#

Terminal window

1
# 需要先执行更新命令
2
sudo apt-get update
3

4
# 如果是新安装的虚拟机，执行失败，那么执行以下命令
5
sudo apt-get install --reinstall libappstream4

如果虚拟机上已经存在docker，那么需要先卸载可能存在的旧版本

Terminal window

1
# 查找docker相关的软件
2
dpkg -l |grep docker

image-20230320235033617

如上图所示，查到一个docker，还有一个docker.io，需要删除掉

Terminal window

1
# --purge: 删除软件以及相关的配置文件
2
sudo apt-get remove --purge docker docker.io

安装docker#

安装docker的方式有很多种，这里推荐大家采用shell脚本的方式进行安装

Terminal window

1
# 下载curl工具
2
sudo apt install curl
3

4
# 安装docker
5
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
6

7
# 下面这两个命令也可以安装docker
8
# 下载安装脚本
9
curl -fsSL https://get.docker.com -o get-docker.sh
10
# 执行安装脚本
11
sudo sh ./get-docker.sh

查看docker版本

Terminal window

1
docker version

image-20230321000157819

出现上图，表示docker安装成功。

设置docker开机启动

Terminal window

1
sudo systemctl enable docker

docker配置#

权限配置#

注意上面查看docker版本的执行命令结果的图中，出现了一个permission denied ... 的报错，此时是因为当前用户对docker命令没有执行权限造成的，那么可以在docker version 这个命令的前面添加sudo解决这个问题，不过每次执行都添加sudo比较麻烦，而且后续使用docker下载镜像，运行容器还需要大量的执行docker ... 命令，可以在这里执行以下命令将当前用户添加到docker组，来获取权限

Terminal window

1
# 添加docker用户组
2
sudo groupadd docker
3

4
# 将当前登录用户添加到docker用户组中
5
sudo gpasswd -a $USER docker
6

7
#更新用户组
8
newgrp docker
9

10
# 测试docker命令是否可以在当前用户下正常使用
11
docker version

image-20230321001210059

如上图所示，docker权限配置好了之后，会显示出更多更完整的信息

如果出现以下提示，那么需要/var/run/docker.sock权限

image-20230321005105875

Terminal window

1
# 添加权限
2
sudo chmod a+rw /var/run/docker.sock

镜像仓库加速#

这里推荐使用阿里云镜像仓库加速配置。【官方配置地址】

Terminal window

1
# 修改docker配置文件
2
sudo vim /etc/docker/daemon.json

输入上面官方配置地址中的以下内容（每个人的有点区别）

image-20230321005920257

Terminal window

1
cskaoyan@ubuntu:~$ cat /etc/docker/daemon.json
2
{
3
  "registry-mirrors": ["https://b66kcrvu.mirror.aliyuncs.com"]
4
}
5
cskaoyan@ubuntu:~$

Terminal window

1
# 加载新的配置文件
2
sudo systemctl daemon-reload
3

4
# 重启docker
5
sudo systemctl restart docker

验证docker镜像加速配置是否成功

Terminal window

1
# 查看docker详细信息
2
docker info

image-20230321010916711

补充说明：docker镜像加速地址有很多，也可以配置别的镜像加速地址

Docker官方：https://registry.docker-cn.com

网易：http://hub-mirror.c.163.com

中科大：https://docker.mirrors.ustc.edu.cn

腾讯云：https://mirror.ccs.tencentyun.com

如果速度不如预期，也可以在daemon.json中配置其他的镜像加速地址
说明：由于政策原因，上面的加速地址暂时都不可用了
大家可以使用这个加速地址:
https://docker.m.daocloud.io/
https://dockerpull.com

软件安装#

1
# 说明：由于政策原因，导致docker镜像可能会下载失败或者是下载非常慢，所以我们在此采用 导入本地文件的方式 导入Docker镜像
2

3
# 1. 把 images.tar.gz 上传到 Linux服务器的桌面
4

5
# 2. 导入镜像
6
docker load -i ~/Desktop/images.tar.gz
7

8
# 3. 查看镜像是否导入成功
9
docker images

MySQL#

Terminal window展开收起

1
# 拉取镜像
2
# docker pull mysql:8.0.35
3

4
# 1. 先看看之前在linux上运行的mysql服务是否正在运行
5
sudo netstat -anp | grep 3306
6

7
# 2. 如果正在运行，那么停止linux上运行的mysql
8
systemctl stop mysql.service
9

10
# 3. 如果之前在linux上安装过mysql，那么删除相关的数据库文件
11
sudo rm -rf /home/ljaer/mysql
12

13
# 安装运行(如果不映射到宿主机的3306端口，那么跳过1,2步骤； 如果不需要删除之前的数据，那么跳过步骤)
14
docker run --name mysql --restart=always -v /home/winter/mysql:/var/lib/mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e TZ=Asia/Shanghai -d  mysql:8.0.35
15

16
docker run --name mysql --restart=always -v /home/winter/mysql:/var/lib/mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e TZ=Asia/Shanghai -d  mysql:la

展开收起

查看MySQL是否启动

Terminal window

1
docker ps

image-20230321101402217

使用Navicat测试连接，注意需要把主机地址改为虚拟机IP地址，用户名和密码均为root

redis#

Terminal window

1
# 拉取镜像
2
# docker pull redis:6.2
3

4
# 运行容器
5
docker run --name=redis-server -d -p 6379:6379  --restart=always redis:6.2
6

7
# 使用云服务器的同学
8
docker run --name=redis-server -d -p 6379:6379  --restart=always redis:6.2 redis-server "--requirepass 你自己的redis密码"
9

10
docker run --name=redis-server -d -p 6379:6379  --restart=always redis:latest redis-server "--requirepass 123456"
11

12
# 测试验证
13
docker exec -it redis-server redis-cli

nacos#

Terminal window

1
# 拉取镜像
2
# docker pull nacos/nacos-server:v2.2.0-slim
3

4
# 运行容器
5
docker run --env MODE=standalone --name nacos --restart=always -d -p 8848:8848 -p 9848:9848 -e JVM_XMS=128m -e JVM_XMX=128m -e JVM_XMN=64m nacos/nacos-server:v2.2.0-slim
6

7
docker run --env MODE=standalone --name nacos --restart=always -d -p 8848:8848 -p 9848:9848 -e JVM_XMS=128m -e JVM_XMX=128m -e JVM_XMN=64m nacos/nacos-server:latest
8

9
# 测试验证
10
# 访问Nacos, http://ip:8848/nacos

elasticsearch#

Terminal window展开收起

1
# 拉取镜像
2
# docker pull elasticsearch:7.8.0
3
# 注意如果是ARM架构的计算机，那么下载的ES镜像的版本如下：
4
docker pull elasticsearch:7.13.1
5

6
# 准备工作
7
sudo mkdir -p /mydata/elasticsearch/plugins /mydata/elasticsearch/data
8
sudo chmod -R 777 /mydata/elasticsearch
9

10
# 运行容器
11
docker run \
12
-p 9200:9200 -p 9300:9300 \
13
--name elasticsearch \
14
--restart=always \
15
-e "discovery.type=single-node" \
16
-e ES_JAVA_OPTS="-Xms256m -Xmx256m" \
17
-v /mydata/elasticsearch/plugins/:/usr/share/elasticsearch/plugins \
18
-v /mydata/elasticsearch/data/:/usr/share/elasticsearch/data \
19
-d elasticsearch:7.8.0
20
# 注意，ARM架构的计算机，使用的镜像版本为elasticsearch:7.13.1
21
# 测试验证，访问http://ip:9200

展开收起

ES安装完成之后，还需要安装IK分词器。

Terminal window

1
# 1. 上传资料中的IK分词器压缩包到Linux主机
2

3
# 2. 解压
4
unzip elasticsearch-analysis-ik-7.8.0.zip -d ik-analyzer
5
# 注意如果是ARM架构的计算机，那么使用的ik分词器的版本也要是7.13.1，所以命令如下：
6
unzip elasticsearch-analysis-ik-7.13.1.zip -d ik-analyzer
7

8
# 3. 上传到ES容器
9
docker cp ./ik-analyzer elasticsearch:/usr/share/elasticsearch/plugins
10

11
# 4. 重启ES
12
docker restart elasticsearch

这里需要注意一下，如果使用的是

kibana#

Terminal window展开收起

1
# 拉取镜像
2
# docker pull kibana:7.8.0
3
# 注意如果计算机为ARM架构的铜须，如果使用的ES版本为7.13.1那么，Kibaba的版本也要相应使用7.13.1
4
docker pull kibana:7.13.1
5
# 运行容器
6
docker run --name kibana --restart=always -e ELASTICSEARCH_URL=http://虚拟机ip或者云服务器ip:9200 -p 5601:5601 -d kibana:7.8.0
7
docker run --name kibana --restart=always -e ELASTICSEARCH_URL=http://192.168.31.117:9200 -p 5601:5601 -d kibana:7.8.0
8

9
# ARM架构的计算机，使用如下命令
10
docker run --name kibana --restart=always -e ELASTICSEARCH_URL=http://虚拟机ip或者云服务器ip:9200 -p 5601:5601 -d kibana:7.13.1
11

12
# 修改配置
13
docker exec -it kibana /bin/bash
14
vi config/kibana.yml
15
elasticsearch.hosts: [ "http://这里改为你自己的虚拟机IP:9200" ]
16
elasticsearch.hosts: [ "http://192.168.253.132:9200" ]
17

18
# 保存退出并且 重启kibana
19
docker restart kibana
20

21
# 测试验证，访问http://ip:5601
22
# 测试IK分词器
23
GET /_analyze
24
{
25
  "text": "我是一只因为有光，所以有梦想的鱼",
26
  "analyzer": "ik_max_word"
27
}

展开收起

minio#

Terminal window展开收起

1
# 拉取镜像
2
# docker pull minio/minio
3

4
# 创建文件夹
5
sudo mkdir -p /home/data /home/config
6
# 运行容器
7
docker run \
8
  -p 9000:9000 \
9
  -p 9001:9001 \
10
  --name minio \
11
  -d --restart=always \
12
  -e "MINIO_ROOT_USER=admin" \
13
  -e "MINIO_ROOT_PASSWORD=admin123456" \
14
  -v /home/data:/data \
15
  -v /home/config:/root/.minio \
16
  minio/minio server /data --console-address ":9001"

展开收起

Terminal window

1
# 测试验证，访问http://ip:9001

RocketMQ#

拉取镜像#

Terminal window

1
# docker pull rocketmqinc/rocketmq
2
# 如果是arm架构则下载如下镜像
3
docker pull king019/rocketmq

创建namesrv数据存储路径#

Terminal window

1
sudo mkdir -p  /docker/rocketmq/data/namesrv/logs   /docker/rocketmq/data/namesrv/store

运行NameServer容器#

Terminal window

1
docker run -d \
2
--restart=always \
3
--name rmqnamesrv \
4
-p 9876:9876 \
5
-v /docker/rocketmq/data/namesrv/logs:/root/logs \
6
-v /docker/rocketmq/data/namesrv/store:/root/store \
7
-e "MAX_POSSIBLE_HEAP=100000000" \
8
rocketmqinc/rocketmq \
9
sh mqnamesrv
10
# 使用arm架构计算机的同学使用如下命令
11
docker run -d --restart=always --name rmqnamesrv -p 9876:9876 -v /docker/rocketmq/data/namesrv/logs:/root/logs -v /docker/rocketmq/data/namesrv/store:/root/store -e JAVA_OPT_EXT='-Xms128m -Xmx128m -Xmn64m -XX:MetaspaceSize=32m -XX:MaxMetaspaceSize=32m' -e "MAX_POSSIBLE_HEAP=100000000" king019/rocketmq sh opt/soft/rocketmq/bin/mqnamesrv

创建broker数据存储路径#

Terminal window

1
sudo mkdir -p  /docker/rocketmq/data/broker/logs   /docker/rocketmq/data/broker/store /docker/rocketmq/conf

创建broker配置文件#

Terminal window

1
sudo vim /docker/rocketmq/conf/broker.conf

文件内容

Terminal window展开收起

1
# 所属集群名称，如果节点较多可以配置多个
2
brokerClusterName = DefaultCluster
3
#broker名称，master和slave使用相同的名称，表明他们的主从关系
4
brokerName = broker-a
5
#0表示Master，大于0表示不同的slave
6
brokerId = 0
7
#表示几点做消息删除动作，默认是凌晨4点
8
deleteWhen = 04
9
#在磁盘上保留消息的时长，单位是小时
10
fileReservedTime = 48
11
#有三个值：SYNC_MASTER，ASYNC_MASTER，SLAVE；同步和异步表示Master和Slave之间同步数据的机制；
12
brokerRole = ASYNC_MASTER
13
#刷盘策略，取值为：ASYNC_FLUSH，SYNC_FLUSH表示同步刷盘和异步刷盘；SYNC_FLUSH消息写入磁盘后才返回成功状态，ASYNC_FLUSH不需要；
14
flushDiskType = ASYNC_FLUSH
15
# 设置broker节点所在服务器的ip地址
16
brokerIP1 = 192.168.153.143
17
# 磁盘使用达到95%之后,生产者再写入消息会报错 CODE: 14 DESC: service not available now, maybe disk full
18
diskMaxUsedSpaceRatio=95
19
# 定义延迟级别对应的延迟时间
20
messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h

展开收起

运行broker容器#

Terminal window展开收起

1
docker run -d  \
2
--restart=always \
3
--name rmqbroker \
4
--link rmqnamesrv:namesrv \
5
-p 10911:10911 \
6
-p 10909:10909 \
7
-v  /docker/rocketmq/data/broker/logs:/root/logs \
8
-v  /docker/rocketmq/data/broker/store:/root/store \
9
-v /docker/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf \
10
-e "NAMESRV_ADDR=namesrv:9876" \
11
-e "MAX_POSSIBLE_HEAP=200000000" \
12
rocketmqinc/rocketmq \
13
sh mqbroker -c /opt/rocketmq-4.4.0/conf/broker.conf
14

15
# 如果是arm架构计算机的同学运行如下docker run命令
16
docker run -d  --restart=always --name rmqbroker --link rmqnamesrv:namesrv -p 10911:10911 -p 10909:10909 -v  /docker/rocketmq/data/broker/logs:/root/logs -v  /docker/rocketmq/data/broker/store:/root/store -v /docker/rocketmq/conf/broker.conf:/opt/soft/rocketmq/conf/broker.conf -e "NAMESRV_ADDR=namesrv:9876" -e "MAX_POSSIBLE_HEAP=200000000" -e JAVA_OPT_EXT='-Xms128m -Xmx128m -Xmn64m -XX:MetaspaceSize=32m -XX:MaxMetaspaceSize=32m' king019/rocketmq sh opt/soft/rocketmq/bin/mqbroker -c /opt/soft/rocketmq/conf/broker.conf

展开收起

项目介绍

Sun, 14 Jun 2026 00:00:00 GMT

1. Maven父子工程#

随着微服务架构的流行，多模块开发成为开发的日常。那么如何统一的控制和管理多个微服务项目的依赖和版本成为了一个难题。Maven父子工程很好了给了我们解决方案。

场景一#

image-20230410110215417

解决方案

image-20230410110252883

通过上面这个案例我们不难发现，使用Maven的父子工程，可以有效的管理子工程的依赖和版本。

但是目前的功能还不够强大。

场景二#

image-20230410110449625

解决方案

image-20230410110623487

项目结构#

2.1 代码结构#

duolaimall 是所有其他maven工程的父工程，不包含任何代码，集中管理我们项目中所使用到的，第三方开源框架的版本。
duolaimall-common

common项目的父工程，管理下面各个common项目的依赖
```
1
<modules>
2
    <module>common-util</module>
3
    <module>common-service</module>
4
    <module>common-mq</module>
5
</modules>
```
- common-util
  
  1）放了一些公共的请求，响应的公共类等
  1. 自定义异常及异常相关工具类
  2. 公共的系统响应码
  3. Redis的自动装配相关类
  4. MybatisPlus配置类
  5. 公共的工具类
  6. 公共的实体类
- common-service
  
  管理了xxx-service服务可能会用到的一些依赖
  1. Redis常量类
  2. 各个服务中可能会用到的其他公共类
- common-mq
  
  公共消息模块
duolaimall-gateway: 基于Spring Cloud Gateway
duolaimall-product、duolaimall-order、duolaimall-user、duolaimall-xxx
- 它们都各自代表一个服务
- xxx-api 该服务对外暴露的公共的请求和响应的实体类
- xxx-service 该工程中的代码是真正的服务实现代码
- xxx-service 一定依赖于 xxx-api

代码细节#

注意：在我们的整个项目，不会有任何一个maven工程依赖于xxx-service。比如说 user-service肯定不会依赖于 order-service。

xxx-api

服务提供者和服务的消费者，都需要使用到的一些数据流转对象（Data Transfer Object）
xxx-service
- XxxApplication 服务启动的主类
model：里面放的是数据库映射对象，每一个po对象都会映射到数据库中的一张表

config：相关配置

controller：相关controller类，提供给外部通过web访问
dto：数据流转对象
query：请求入参
service：服务相关接口以及实现
converter：MapStruct转换器相关的类
client：该包下放的是这个服务用来调用其他服务时所使用的FeignClient

数据库#

项目会用到的数据库如下

image-20230410114456368

只需要创建数据库，然后导入对应的SQL文件即可。

1
# 比如导入product服务的数据库
2
# 1. 创建创建数据库
3
create database mall_product character set utf8 collate utf8_bin;
4

5
# 2. 导入数据 mall_product (也可以使用navicat直接导入)
6
use mall_product;
7
source mall_product.sql

配置的管理#

为了方便对于配置的管理，我们统一将各种服务的配置统一放到Nacos配置中心中来管理，为了方便起见，我们给大家提供了一个Nacos的配置导出文件nacos_config_export_xxxxxx.zip，该配置文件里包含了我们的所有配置，我们只需要将其导入到Nacos配置中心即可。

关于配置中心的配置，我们还需要注意：

有一个common.yaml的配置集，其中放的都是一些公共配置，如果有需要，各个服务可以使用share-configs的方式使用该配置集中的配置
如果某个服务还需要使用自己的配置，那么和之前一样，可以把自己独有的配置放到spring.application.name−{spring.application.name}-spring.application.name−{spring.profiles.avtive}.${file-extention}这个配置集中即可
因为所有的配置都放到了配置中心，所以各个服务只需要有application.yml这个配置文件即可
在配置中心中，我们还需要把所有配置文件中，将所有的Redis，Mysql，Nacos，MinIO等的地址改为虚拟机的IP地址

gateway的application.yml配置文件内容

1
spring:
2
  application:
3
    name: server-gateway
4
  profiles:
5
    active: dev
6
  cloud:
7
    nacos:
8
      discovery:
9
        server-addr: 你的虚拟机的ip:8848
10
      config:
11
        server-addr: 你的虚拟机的ip:8848
12
        file-extension: yaml
13
  config:
14
    import:
15
      - nacos:${spring.application.name}-${spring.profiles.active}.yaml
16
      - nacos:common.yaml

展开收起

product-service的application.yml配置文件内容

1
spring:
2
  application:
3
    name: service-product
4
  profiles:
5
    active: dev
6
  cloud:
7
    nacos:
8
      discovery:
9
        server-addr: 你的虚拟机的ip:8848
10
      config:
11
        server-addr: 你的虚拟机的ip:8848
12
        file-extension: yaml
13
  config:
14
    import:
15
      - nacos:${spring.application.name}-${spring.profiles.active}.yaml
16
      - nacos:common.yaml

展开收起

网关搭建#

为了解决跨域问题，我们可以在网关中添加一个自定义Filter，在所有返回的请求中，添加HTTP CORS响应头解决跨域问题。

1
@Configuration
2
public class CorsConfig {
3
    @Bean
4
    public CorsWebFilter corsWebFilter(){
5

6
        // cors跨域配置对象
7
        CorsConfiguration configuration = new CorsConfiguration();
8
        configuration.addAllowedOrigin("*"); //设置允许访问的网络
9
        configuration.setAllowCredentials(true); // 设置是否从服务器获取cookie
10
        configuration.addAllowedMethod("*"); // 设置请求方法 * 表示任意
11
        configuration.addAllowedHeader("*"); // 所有请求头信息 * 表示任意
12

13
        // 配置源对象
14
        UrlBasedCorsConfigurationSource configurationSource = new UrlBasedCorsConfigurationSource();
15
        // 对所有请求设置该跨域配置
16
        configurationSource.registerCorsConfiguration("/**", configuration);
17
        // cors过滤器对象
18
        return new CorsWebFilter(configurationSource);
19
    }
20
}

展开收起

前端（后台）启动#

为了让大家方便的启动后台管理系统的前端项目，我们给大家提供了一个jar包，我们只需执行如下命令即可启动

1
java -jar  jar包名称(jar包名称带.jar后缀)

需要注意的是，后台项目监听本机的8888端口

测试#

在测试的时候，不要动不动就打开前端测试，那样的话测试效率很低，建议：

用单元测试测试对数据库的访问，服务的业务，以及服务的调用，用postman或者RestTemplate测试服务的Controller

1
// 测试数据库访问
2
@Autowired
3
xxxMapper xxxMapper;
4

5
@Test
6
public void testMapper() {
7
// 可能自己造数据
8
}
9

10

11
// 测试微服务的各个业务类
12
@AutoWired
13
ITestProductDetailService productDetailService;
14
@Test
15
public void testService() {
16
 // 我们可能要自己造数据
17
  Long id = xxx;
18
  productDetailService.getXXX(id)
19

20
// 需要自己造数据
21
}
22

23

24
// 在订单服务中，测试对于商品服务的调用
25
@Autowired
26
ProductFeignClient productClient; // FeignClient
27
public void testCallRemoteService() {
28

29
}
30

31

32
// 测试服务的Controller 直接使用Postman发送http请求即可

展开收起

平台属性与品牌管理

Sun, 14 Jun 2026 00:00:00 GMT

业务知识#

商品类目#

商城中的商品都是有其所属类目的。在我们的商城中，商品的类目分成了三级，包括一级类目，二级类目，三级类目

比如，手机/运营商/数码就是一级类目，手机通讯就是二级类目，手机就是三级类目

平台属性和平台属性值#

平台属性和平台属性值主要用于商品的搜索，平台属性是属于商品类目的，不同的商品类目具有不同的平台属性。比如，牛仔裤这个商品类目就有尺码，腰型等平台属性，而手机这个商品类目就具有机身内存，运行内存，CPU型号等平台属性。

不同的层级的类目也都可能具有平台属性，但是在我们的项目中平台属性属于三级类目

SPU 与 SKU#

SPU(Standard Product Unit)：标准化产品单元。是商品信息聚合的最小单位，是一组可复用、易检索的标准化信息的集合，该集合描述了一个产品的特性。通俗点讲，属性值、特性相同的商品就可以称为一个SPU。

换言之，SPU通常表示的是具有相同特征的商品集合，而不是某一个具体的商品，比如荣耀V30 PRO手机就是一个SPU，所有的荣耀V30 PRO手机这有这些相同的特征：它们都是双模5G手机通用芯片，使用麒麟990处理器，机身尺寸和重量相同等等。但是荣耀V30 PRO手机是一个具体的商品吗？因为不同的荣耀V30 PRO手机还具有不同的颜色(比如，冰岛幻境，幻夜星河等等)，还有不同的版本(比如，8G + 256G，8G + 128G)

SKU(Stock Keeping Unit)库存量单位，即库存进出计量的单位，可以是以件、盒、托盘等为单位。SKU是物理上不可分割的最小存货单元。

和SPU不同，一个SKU可以表示一个具体的商品，比如荣耀V30 PRO幻夜星河 8+128GB。我们在电商网站中检索，在详情页中查看，以及最终下单购买的都是SKU商品

销售属性与销售属性值#

是组成SKU的特殊属性，一旦我们确定了商品的SPU，在结合SPU的不同销售属性取值，就能得到不同的SKU。

因为商品的价格和商品的库存都是针对商品SKU的，不同的销售属性取值确定的是不同的商品SKU，以及其售价和库存。

商品服务#

工程结构#

![](/assets/firefly-docs/microservice/microservice-10-platform-attr-brand/duolaimall-common structure.png)

![](/assets/firefly-docs/microservice/microservice-10-platform-attr-brand/duolaimall-gateway init.png)

![](/assets/firefly-docs/microservice/microservice-10-platform-attr-brand/product-service structure.png)

分类信息查询#

1
// 查询一级分类
2
@GetMapping("admin/product/getCategory1")
3
public Result<List<FirstLevelCategoryDTO>> getCategory1(){
4

5

6
}
7

8
// 根据一级分类查询二级分类
9
@GetMapping("/admin/product/getCategory2/{firstLevelCategoryId}")
10
public Result<List<SecondLevelCategoryDTO>> getCategory2(@PathVariable Long firstLevelCategoryId){
11
}
12

13
// 根据二级分类，查询三级分类
14
@GetMapping("/admin/product/getCategory3/{category2Id}")
15
public Result<List<ThirdLevelCategoryDTO>> getCategory3(@PathVariable Long category2Id){
16
}

展开收起

1
    /**
2
     * 查询所有的一级分类信息
3
     * @return
4
     */
5
    List<FirstLevelCategoryDTO> getFirstLevelCategory();
6

7
    /**
8
     * 根据一级分类Id 查询二级分类数据
9
     */
10
    List<SecondLevelCategoryDTO> getSecondLevelCategory(Long firstLevelCategoryId);
11

12
    /**
13
     * 根据二级分类Id 查询三级分类数据
14
     */
15
    List<ThirdLevelCategoryDTO> getThirdLevelCategory(Long secondLevelCategoryId);

展开收起

以上三个接口定义在CategoryService中，是对三张商品类目表的单表查询，非常简单。

平台属性的查询#

1
// 根据分类Id查询平台属性以及平台属性值
2
// http://localhost/admin/product/attrInfoList/3/20/149
3
@GetMapping("/admin/product/attrInfoList/{firstLevelCategoryId}/{secondLevelCategoryId}/{thirdLevelCategoryId}")
4
public Result getAttrInfoList(@PathVariable Long firstLevelCategoryId,
5
                              @PathVariable Long secondLevelCategoryId,
6
                              @PathVariable Long thirdLevelCategoryId){
7

8

9
}

要实现三级类目下平台属性的查询，必须实现以下定义在CategoryService中的方法

1
 /**
2
     * 根据分类Id 获取平台属性数据
3
     * 接口说明：
4
     *      1，平台属性可以挂在一级分类、二级分类和三级分类
5
     *      2，查询一级分类下面的平台属性，传：firstlevelCatogoryId，0，0；   取出该分类的平台属性
6
     *      3，查询二级分类下面的平台属性，传：firstlevelCatogoryId，category2Id，0；
7
     *         取出对应一级分类下面的平台属性与二级分类对应的平台属性
8
     *      4，查询三级分类下面的平台属性，传：firstlevelCatogoryId，category2Id，category3Id；
9
     *         取出对应一级分类、二级分类与三级分类对应的平台属性
10
     */
11
    List<PlatformAttributeInfoDTO> getPlatformAttrInfoList(Long firstLevelCategoryId, Long secondLevelCategoryId, Long thirdLevelCategoryId);

1
@Data
2
public class PlatformAttributeInfoDTO {
3
    @ApiModelProperty(value = "平台属性id")
4
    private Long id;
5

6
    @ApiModelProperty(value = "属性名称")
7
    private String attrName;
8

9
    @ApiModelProperty(value = "分类id")
10
    @TableField("category_id")
11
    private Long categoryId;
12

13
    @ApiModelProperty(value = "分类层级")
14
    private Integer categoryLevel;
15

16
    /*
17
        平台属性值集合，这里注意一个平台属性，有多个属性取值
18
     */
19
    private List<PlatformAttributeValueDTO> attrValueList;
20
}

展开收起

这里要注意的是，返回的PlatformAttributeInfoDTO包含完整的平台属性信息，即既包含平台属性名又包含平台属性值，所以在查询数据库中的平台属性时，就不可避免的涉及到 platform_attr_info(平台属性) 和 platform_attr_value(平台属性值表)的连表查询，查询的SQL语句如下：

1
    <resultMap id="platformAttrInfoMap" type="com.cskaoyan.mall.product.model.PlatformAttributeInfo" autoMapping="true">
2
        <id column="id" property="id"></id>
3
        <!--
4
        property: 实体类属性名
5
        ofType: 实体类属性名对应的类型
6
        -->
7
        <collection property="attrValueList" ofType="com.cskaoyan.mall.product.model.PlatformAttributeValue" autoMapping="true">
8
            <id column="attr_value_id" property="id"></id>
9
        </collection>
10

11
    </resultMap>
12

13
    <!--根据分类id查询平台属性集合-->
14
    <select id="selectPlatFormAttrInfoList" resultMap="platformAttrInfoMap" >
15

16
        select
17
        pai.id,
18
        pai.attr_name,
19
        pai.category_id,
20
        pai.category_level,
21
        pav.id attr_value_id,
22
        pav.value_name,
23
        pav.attr_id
24
        from platform_attr_info pai inner join platform_attr_value pav
25
        on pai.id=pav.attr_id
26
        <where>
27
            <if test="firstLevelCategoryId !=null and firstLevelCategoryId !=0">
28
                or ( pai.category_level=1 and pai.category_id=#{firstLevelCategoryId})
29
            </if>
30
            <if test="secondLevelCategoryId !=null and secondLevelCategoryId !=0">
31
                or (pai.category_level=2 and pai.category_id=#{secondLevelCategoryId})
32
            </if>
33
            <if test="thirdLevelCategoryId !=null and thirdLevelCategoryId !=0">
34
                or (pai.category_level=3 and pai.category_id=#{thirdLevelCategoryId})
35
            </if>
36
        </where>
37
        order by pai.category_level ,pai.id
38
    </select>

展开收起

平台属性的添加#

1
// 保存平台属性
2
//  http://localhost/admin/product/saveAttrInfo
3
@PostMapping("/admin/product/saveAttrInfo")
4
public Result saveAttrInfo(@RequestBody PlatformAttributeParam platformAttributeParam) {
5

6

7
}

要实现给三级类目添加平台属性以及属性值的功能，必须实现以下定义在PlatformAttributeService中的接口方法

1
void savePlatformAttrInfo(PlatformAttributeParam platformAttributeParam);

1
@Data
2
public class PlatformAttributeParam {
3

4
    private Long id;
5

6
    private String attrName;
7

8
    private Long categoryId;
9

10
    private Integer categoryLevel;
11

12
    /*
13
        平台属性值集合，这里注意一个平台属性，有多个属性取值
14
     */
15
    private List<PlatformAttributeValueParam> attrValueList;
16
}

展开收起

在向数据库中保存一条平台属性信息信息的时候，有一点需要格外注意：

无论是新增，还是修改一条平台属性(包括修改其平台属性值)，我们都是跳转到平台属性的页面，添加或者修改数据，最后点击保存，发送保存平台属性信息的请求
但是，后端需要区分到底是新增，还是修改平台属性，因为这涉及到在数据库中，到底是插入还是更新的问题
对于平台属性而言，如果是修改的话，那么前端的保存请求会携带被修改的平台属性的id，如果是新增的话则不会，所以基于平台属性id是否为null，我们可以判断对于平台属性究竟是添加还是更新
但是，一条平台属性包含多个属性值，可以通过判断前端传递的参数中每个平台属性值id对否为null确定是平台属性值的新增或更新，但是比较麻烦，所以我们换种思路，对于平台属性值，我们不做判断，先删除数据库中可能已经存在的目标平台属性的属性值，然后将前端传递的参数中包含的平台属性值全部插入数据库
同时，因为对于平台属性值不区分新增或修改，统一先删除在插入，如果前端而言如果是新增的话，在平台属性插入数据库前，前端是不知道平台属性id的，因此，在处理完平台属性后，在插入平台属性值之前，我们需要统一给每一个平台属性值，设置其对应的平台属性id，即attrId属性值，然后再将其插入数据库

保存平台属性及其属性值方法的核心逻辑如下：

1
 // 将前端参数转化为
2
 PlatformAttributeInfo platformAttributeInfo
3
               = platformAttributeInfoParamConverter.attributeInfoParam2Info(platformAttributeParam);
4

5
        // 判断平台属性
6
        if (platformAttributeInfo.getId() != null) {
7
            // 修改数据
8
            platformAttrInfoMapper.updateById(platformAttributeInfo);
9
        } else {
10
            // 新增
11
            platformAttrInfoMapper.insert(platformAttributeInfo);
12
        }
13

14
        // platformAttrValue平台属性值，先删除，在新增的方式！
15
        LambdaQueryWrapper<PlatformAttributeValue> platformAttributeValueQueryWrapper = new LambdaQueryWrapper<>();
16
        // 删除平台属性原本在数据库中对应的属性值
17
        platformAttributeValueQueryWrapper.eq(PlatformAttributeValue::getAttrId, platformAttributeInfo.getId());
18
        platformAttrValueMapper.delete(platformAttributeValueQueryWrapper);
19

20
        // 获取页面传递过来的所有平台属性值数据
21
        List<PlatformAttributeValue> attrValueList = platformAttributeInfo.getAttrValueList();
22
        if (!CollectionUtils.isEmpty(attrValueList)) {
23
            // 循环遍历
24
            for (PlatformAttributeValue platformAttributeValue : attrValueList) {
25
                // 获取平台属性Id 给attrId
26
                platformAttributeValue.setAttrId(platformAttributeInfo.getId());
27
                platformAttrValueMapper.insert(platformAttributeValue);
28
            }
29
        }

展开收起

平台属性的回显值#

1
// http://localhost/admin/product/getAttrValueList/106
2
// 平台属性值回显
3
@GetMapping("/admin/product/getAttrValueList/{attrId}")
4
public Result<List<PlatformAttributeValueDTO>> getAttrInfoDTO(@PathVariable Long attrId) {
5

6
}

当我们在某一个平台属性上点击修改的时候，会跳转到平台属性对应的界面，显示当前平台属性以及属性值信息。为了实现这一功能，我们必须实现定义在PlatformAttributeService中的如下接口方法：

1
 List<PlatformAttributeValueDTO> getPlatformAttrInfo(Long attrId);

该方法的实现就比较简单了，根据平台属性id查询其对应的属性值列表即可。

图片上传#

在我们的电商网站中，不论是品牌logo，还是商品图片，商品的海报，都是一些需要保存的图片数据，这些图片数据都是需要给用户展示的，所以我们必须在后台完成全部的图片上传工作。

既然要上传图片，随之而来的问题就是图片存储在哪里？和上一个项目类似，我们仍然采用OSS的方式来存储，但稍有不同的是，我们不在使用阿里云，而是本地的对象存储服务器MinIO来存储。

MinIO介绍#

MinIO 是一个基于Apache License v2.0开源协议的对象存储服务器。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件等，而一个对象文件可以是任意大小，从几kb到最大5T[不等]。详情参见官方文档地址

MinIO作为一个优秀的开源对象存储服务器具有如下特征：

高性能：作为高性能对象存储，在标准硬件条件下它能达到55GB/s的读、35GB/s的写速率
可扩容：不同MinIO集群可以组成联邦，并形成一个全局的命名空间，并跨越多个数据中心
SDK支持: 它有类似Java、Python或Go等语言的sdk支持
支持纠删码: MinIO使用纠删码、Checksum来防止硬件错误和静默数据污染。在最高冗余度配置下，即使丢失1/2的磁盘也能恢复数据。
有控制台界面
功能简单: 这一设计原则让MinIO不容易出错、更快启动

安装#

在这里我们使用Docker来安装，参考环境搭建文档。

MinIO Server启动启动后，我们可以通过浏览器访问控制台界面，但是需要登录，登录时默认的用户名是admin，密码是admin123456

要是用MinIo我们还必须了解两个基本概念：

对象: 在MinIO中对象指的是二进制数据，甚至有时指的是Blob(Binary Large OBject)，二进制数据可以是图片，音视频文件，可执行文件等等
桶(bucket): MinIO用桶来组织对象，一个桶类似于操作系统中的一个目录，一个桶中可以存储任意多个对象

所以，要是用MinIO必须首先创建桶，向桶中存取对象，同时还要注意，如果要想访问到桶中的数据，我们得把桶的权限设置为public

MinIO的Java客户端#

我们还可以使用MinIO提供的Java语言客户端，通过Java语言操作MinIO实现文件上传。

在工程中导入MinIO客户端依赖如下

1
        <dependency>
2
            <groupId>io.minio</groupId>
3
            <artifactId>minio</artifactId>
4
            <version>8.2.0</version>
5
        </dependency>

基于客户端依赖，即可以实现文件上传功能，我们定义FilepuloadController代码如下：

1
@RestController
2
@RequestMapping("admin/product")
3
public class FileUploadController {
4

5
    //  获取文件上传对应的地址
6
    @Value("${minio.endpointUrl}")
7
    public String endpointUrl;
8

9
    @Value("${minio.accessKey}")
10
    public String accessKey;
11

12
    @Value("${minio.secreKey}")
13
    public String secreKey;
14

15
    @Value("${minio.bucketName}")
16
    public String bucketName;
17

18
    //  文件上传控制器
19
    @PostMapping("fileUpload")
20
    public Result fileUpload(MultipartFile file) throws Exception{
21
        //  准备获取到上传的文件路径！
22
        String url = "";
23

24
        // 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
25
        MinioClient minioClient =
26
                MinioClient.builder()
27
                        .endpoint(endpointUrl)
28
                        .credentials(accessKey, secreKey)
29
                        .build();
30
        // 检查存储桶是否已经存在
31
        boolean isExist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
32
        if(isExist) {
33
            System.out.println("Bucket already exists.");
34
        } else {
35
            // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
36
            minioClient.makeBucket(MakeBucketArgs.builder()
37
                    .bucket(bucketName)
38
                    .build());
39
        }
40
        //  定义一个文件的名称 : 文件上传的时候，名称不能重复！
41
        String fileName = System.currentTimeMillis()+ UUID.randomUUID().toString();
42
        // 使用putObject上传一个文件到存储桶中。
43
        minioClient.putObject(
44
                PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
45
                        file.getInputStream(), file.getSize(), -1)
46
                        .contentType(file.getContentType())
47
                        .build());
48
        url = endpointUrl+"/"+bucketName+"/"+fileName;
49

50
        System.out.println("url:\t"+url);
51
        //  将文件上传之后的路径返回给页面！
52
        return Result.ok(url);
53
    }
54

55

56
}

展开收起

品牌管理#

业务分析#

在我们的电商网站中，还涉及到了品牌数据的管理

关于品牌管理，我们需要实现品牌的增删改查功能

代码实现#

1
// http://localhost/admin/product/baseTrademark/1/10
2
// 查看品牌列表
3
@GetMapping("/admin/product/baseTrademark/{pageNo}/{pageSize}")
4
public Result<TrademarkPageDTO> getTradeMarkDTOList(@PathVariable Long pageNo, @PathVariable Long pageSize) {
5

6
}
7

8

9
// 保存品牌
10
//http://localhost/admin/product/baseTrademark/save
11
@PostMapping("/admin/product/baseTrademark/save")
12
public Result save(@RequestBody TrademarkParam trademarkParam){
13

14
}
15

16
// http://localhost/admin/product/baseTrademark/remove/10
17
// 删除品牌
18
@DeleteMapping("/admin/product/baseTrademark/remove/{tradeMarkId}")
19
public Result deleteById(@PathVariable Long tradeMarkId){
20

21
}
22

23

24
// http://localhost/admin/product/baseTrademark/get/17
25
// 查询品牌
26
@GetMapping("/admin/product/baseTrademark/get/{tradeMarkId}")
27
public Result<TrademarkDTO> getTradeMarkDTO(@PathVariable Long tradeMarkId) {
28

29
}
30

31
// 修改品牌
32
// http://localhost/admin/product/baseTrademark/update
33
@PutMapping("/admin/product/baseTrademark/update")
34
public Result updateTradeMark(@RequestBody TrademarkParam trademarkParam){
35

36

37
}

展开收起

其中查询又分成了根据id查询和分页查询(根据id查询的效果，主要用于修改品牌信息时数据的回显)，对应TrademarkService中的5个方法

1
public interface TrademarkService {
2
    /*
3
        根据品牌id，查询品牌
4
     */
5
    TrademarkDTO getTrademarkByTmId(Long tmId);
6
    /**
7
     * 根据分页参数，分页查询品牌列表
8
     */
9
    TrademarkPageDTO getPage(Page<Trademark> pageParam);
10
    /*
11
         保存品牌
12
     */
13
    void save(TrademarkParam trademarkParam);
14
    /*
15
          更新品牌
16
     */
17
    void updateById(TrademarkParam trademarkParam);
18
    /*
19
        删除品牌
20
     */
21
    void removeById(Long id);
22
}

展开收起

其中，我们需要注意的一点是，在新增品牌的时候，我们是需要存储品牌logo的图片的url的，这个url怎么来呢？

![](/assets/firefly-docs/microservice/microservice-10-platform-attr-brand/商品图片logo url.png)

其实，当我们在前端选择logo图片上传的时候，前端就会向后端发起请求，从而将图片保存到minio，并在响应中获取保存图片的url，因此我们接收到的保存品牌的参数中，包含的是品牌logo的url。

SPU

Sun, 14 Jun 2026 00:00:00 GMT

目录品牌管理#

在实际生活中，我们知道品牌往往是和商品类目联系起来的，比如，手机品牌，电脑品牌，汽车品牌等等，不同的商品类目包含不同的品牌，所以用户在查询商品类目的时候，我们同时也应该展示，该类目下的商品品牌。

关于目录品牌管理，我们需要实现查询商品类目品牌，添加商品类目品牌，删除商品类目品牌的功能。

添加商品类目品牌#

1
@PostMapping("admin/product/baseCategoryTrademark/save")
2
public Result save(@RequestBody CategoryTrademarkParam categoryTrademarkVo){
3
}

1
    /**
2
     * 保存分类与品牌关联
3
     */
4
    void save(CategoryTrademarkParam categoryTrademarkParam);

1
@Data
2
public class CategoryTrademarkParam {
3

4
  private Long category3Id;
5

6
  private List<Long> trademarkIdList;
7

8
}
9
这里就是对category_trademark表的单表插入

查询商品类目品牌#

1
@GetMapping("admin/product/baseCategoryTrademark/findTrademarkList/{thirdLevelCategoryId}")
2
public Result findTrademarkList(@PathVariable Long thirdLevelCategoryId){
3
}

1
    /**
2
     * 根据三级分类获取品牌
3
     */
4
    List<TrademarkDTO> findTrademarkList(Long category3Id);

先根据三级类目id，在类目品牌关联表category_trademark中，找到属于该类目的所有品牌的id即trademark_id集合
然后，在根据trademark_id集合，在trademark表中查询出每个品牌的详细信息

查询未关联商品类目的品牌#

在给一个商品类目添加品牌的时候，添加的一定是没有关联到当前商品类目的品牌，所以需要先查出未关联到该类目的品牌，然后选择一个或多个品牌关联的类目。

1
    @GetMapping("admin/product/baseCategoryTrademark/findCurrentTrademarkList/{thirdLevelCategoryId}")
2
    public Result findCurrentTrademarkList(@PathVariable Long thirdLevelCategoryId){
3
    }

1
    /**
2
     * 获取当前未被三级分类关联的所有品牌
3
     */
4
    List<TrademarkDTO> findUnLinkedTrademarkList(Long thirdLevelCategoryId);

这里的实现思路其实也并不困难：

首先查询出当前类目已经关联的品牌列表(在trademark_category中)
查询所有品牌的品牌列表，过滤掉已经关联到当前类目的品牌即可

删除目录品牌关联#

1
    @DeleteMapping("admin/product/baseCategoryTrademark/remove/{thirdLevelCategoryId}/{trademarkId}")
2
    public Result remove(@PathVariable Long thirdLevelCategoryId, @PathVariable Long trademarkId){
3

4
    }

1
    /**
2
     * 删除关联
3
     */
4
    void remove(Long thirdLevelCategoryId, Long trademarkId);

SPU#

SPU数据#

之前我们已经讲解过SPU，它表示具有相同特征和属性值的一组商品。如果要完整的描述一个SPU他应该包含那些数据呢？简单总结一下：

类目信息：一个SPU中所包含的商品，都应该是具有所属类目的
品牌信息: 一个SPU中所包含的商品，都应该是具有品牌的
图片信息: 一个SPU中所包含的每一个商品，都应该具有一组图片
海报信息: 一个SPU中的所有商品，具有统一的展示海报
销售属性：一个SPU中的所有商品，具有相同的销售属性，但是具有不同的销售属性取值集合

![](/assets/firefly-docs/microservice/microservice-11-spu/spu data final.png)

SPU操作#

查询销售属性

所有的销售属性定义在sale_attr_info表中的，所以要给SPU选择销售属性，就必须查询出所有的销售属性。

1
@GetMapping("admin/product/baseSaleAttrList")
2
public Result SaleAttrList(){
3
}

1
    /*
2
          查询所有的销售属性
3
     */
4
    List<SaleAttributeInfoDTO> getSaleAttrInfoList();

本质还是一个单表查询，很简单。

SPU列表的查询#

1
    @GetMapping("admin/product/{page}/{size}")
2
    public Result getSpuInfoPage(@PathVariable Long page,
3
                                 @PathVariable Long size,
4
                                 Long category3Id){
5
    }

1
    /*
2
         根据分页参数查询spu分页数据
3
     */
4
    SpuInfoPageDTO getSpuInfoPage(Page<SpuInfo> pageParam, Long category3Id);

这里要注意，我们查询的SPU列表，其实是某一个三级类目下的Spu列表，我们主要使用三级类目id，作为查询条件来查询。

SPU保存#

从页面上来看，我们需要保存的数据比较多，主要分成了如下几个部分：

SPU所属类目，名称，SPU的品牌，以及SPU的文字描述
SPU中所包含的不同商品的图片集合
SPU中所包含的多个属性和属性值集合
SPU商品的海报集合

所以，接下来我们就需要实现以下接口方法，实现SPU的保存

1
    @PostMapping("admin/product/saveSpuInfo")
2
    public Result saveSpuInfo(@RequestBody SpuInfoParam spuInfoParam){
3
    }

1
    /*
2
        保存完整的SPU信息
3
     */
4
    void saveSpuInfo(SpuInfoParam spuInfo);

1
@Data
2
public class SpuInfoParam {
3

4
    private Long id;
5

6
    private String spuName;
7

8
    private String description;
9

10
    /*
11
      三级分类id
12
    */
13
    private Long category3Id;
14

15
    private Long tmId;
16
    /*
17
      销售属性集合
18
    */
19
    private List<SpuSaleAttributeInfoParam> spuSaleAttrList;
20
    /*
21
      商品的图片集合
22
    */
23
    private List<SpuImageParam> SpuImageList;
24
  /*
25
      商品的海报图片集合
26
    */
27
    private List<SpuPosterParam> SpuPosterList;
28
}

展开收起

1
@Data
2
public class SpuSaleAttributeInfoParam {
3

4
    private Long id;
5

6
    private Long spuId;
7
    /*
8
      销售属性id
9
    */
10
    private Long baseSaleAttrId;
11

12
    /*
13
      销售属性名称
14
    */
15
    private String saleAttrName;
16

17
    // 销售属性值对象集合
18
    List<SpuSaleAttributeValueParam> spuSaleAttrValueList;
19
}

展开收起

实现代码如下：

1
     // 现将参数对象转化为PO对象
2
        SpuInfo spuInfo = spuInfoParamConverter.spuInfoParam2Info(spuInfoParam);
3
        // 插入基本的spu信息
4
        spuInfoMapper.insert(spuInfo);
5

6
        //  获取到spuImage 集合数据
7
        List<SpuImage> spuImageList = spuInfo.getSpuImageList();
8

9
    /*
10
       循环遍历spuImageList
11
       1. 给spuImage的spuId属性赋值因为只有将spu基本信息插入数据库spuInfo的id才有值
12
       2. 保存spuImge
13
          */
14

15
        //  获取销售属性集合
16
        List<SpuSaleAttributeInfo> spuSaleAttributeInfoList = spuInfo.getSpuSaleAttributeInfoList();
17

18
        //  判断
19
        if (!CollectionUtils.isEmpty(spuSaleAttributeInfoList)) {
20
            //  循环遍历
21
            for (SpuSaleAttributeInfo spuSaleAttrInfo : spuSaleAttributeInfoList) {
22
                /*
23
                    给spuSaleAttrInfo的spuId赋值，并保存spuSaleAttrInfo到数据库
24
                    SpuSaleAttrInfoMapper
25
                */
26

27
                //  再此获取销售属性值集合
28
                List<SpuSaleAttributeValue> spuSaleAttributeValueList = spuSaleAttrInfo.getSpuSaleAttrValueList();
29

30
                /*
31
                  遍历销售属性值集合spuSaleAttributeValueList
32
                  1. 给spuSaleAttrValue的spuId赋值
33
                  2. 给spuSaleAttrValue的spuSaleAttrId赋值
34
                  3. 保存spuSaleAttrValue到数据库
35
                */
36
            }
37
        }
38

39
        //  获取到posterList 集合数据
40
        List<SpuPoster> spuPosterList = spuInfo.getSpuPosterList();
41
        /*
42
           遍历销售属性值集合spuPosterList
43
           1. 给spuPoster的spuId赋值
44
            3. 保存spuPoster到数据库
45
         */

展开收起

SKU

Sun, 14 Jun 2026 00:00:00 GMT

基本介绍#

学习了SPU相关的数据和操作，我们接着学习SKU，相比于SPU而言，SKU表示更为具体的商品，包含了更多的数据。

SKU商品具有价格，以及默认的显示图片，以及所属的spu，所属类目，品牌等等
属于SPU的一组确定的销售属性取值(对于一个手机sku来说，比如具体的颜色值幻夜星河，具体的版本值8G+256G)
因为SKU仍然属于某一个商品类目，所以还具有一组平台属性取值
属于一个sku商品的一组图片集合

数据准备#

平台属性及属性值#

销售属性及属性值#

销售属性是在sale_attr_info表中定义

而销售属性的销售属性值，使我们在添加SPU的时候，给选定的销售属性添加属性值，这些属性和对应的属性值被分别存储到了spu_sale_attr_info 和 spu_sale_attr_value中

功能实现#

商品图片的回显#

在添加SPU的时候，我们上传了所有SPU商品对应的多组商品图片，在我们给SPU商品添加SKU的时候，在这些图片中选择属于当前SKU商品的图片作为该SKU展示的图片集合。

所以为了实现商品图片的回显即查询，我们需要实现以下接口

1
@GetMapping("admin/product/spuImageList/{spuId}")
2
public Result<List<SpuImageDTO>> getSpuImageList(@PathVariable("spuId") Long spuId) {
3
}

1
    /*
2
         根据spuId获取指定spu中包含的图片集合
3
     */
4
    List<SpuImageDTO> getSpuImageList(Long spuId);

实现该接口仍然只需要一次单表查询即可。

查询销售属性及属性值集合#

在给SPU添加SKU的时候，还需要在SPU的销售属性以及属性值集合中，选择当前SKU对应的销售属性以及属性值

所以我们还需要查询SPU中包含的销售属性，以及其对应的属性值。为此我们需要实现以下接口

1
    @GetMapping("admin/product/spuSaleAttrList/{spuId}")
2
    public Result<List<SpuSaleAttributeInfoDTO>> getSpuSaleAttrList(@PathVariable("spuId") Long spuId) {
3
    }

1
    /*
2
         根据SpuId查询SPU中包含的销售属性以及销售属性值集合
3
     */
4
    List<SpuSaleAttributeInfoDTO> getSpuSaleAttrList(Long spuId);

1
@Data
2
public class SpuSaleAttributeInfoDTO {
3

4
    private Long id;
5

6
    private Long spuId;
7

8
    private Long saleAttrId;
9

10
    private String saleAttrName;
11

12
    // 销售属性值对象集合
13
    List<SpuSaleAttributeValueDTO> spuSaleAttrValueList;
14
}

很显然，这里为了查询出销售属性及其对应的属性值，又会涉及到多表查询。查询的SQL语句如下：

1
    <resultMap id="spuSaleAttrMap" type="com.cskaoyan.mall.product.model.SpuSaleAttributeInfo" autoMapping="true">
2

3
        <id column="id" property="id"></id>
4
        <collection property="spuSaleAttrValueList" ofType="com.cskaoyan.mall.product.model.SpuSaleAttributeValue" autoMapping="true">
5
            <id column="sale_attr_value_id" property="id"></id>
6
        </collection>
7
    </resultMap>
8
    <!-- 根据spuId获取销售属性数据 -->
9
    <select id="selectSpuSaleAttrList"  resultMap="spuSaleAttrMap">
10
        select
11
                ssai.id,
12
                ssai.spu_id,
13
                ssai.sale_attr_id,
14
                ssai.sale_attr_name,
15
                ssav.id sale_attr_value_id,
16
                ssav.spu_sale_attr_id,
17
                ssav.spu_sale_attr_value_name
18
         from  spu_sale_attr_info ssai inner  join  spu_sale_attr_value ssav
19
                      on ssai.id=ssav.spu_sale_attr_id
20
                  where ssai.spu_id=#{spuId}
21
    </select>

展开收起

SKU数据的保存#

要保存SKU数据，需要实现以下接口方法

1
    @PostMapping("admin/product/saveSkuInfo")
2
    public Result saveSkuInfo(@RequestBody SkuInfoParam skuInfo) {
3
        // 调用服务层
4
        skuService .saveSkuInfo(skuInfo);
5
        return Result.ok();
6
    }

1
    /*
2
         保存SKU
3
     */
4
    void saveSkuInfo(SkuInfoParam skuInfo);

1
@Data
2
public class SkuInfoParam {
3

4
    private Long id;
5

6
    private Long spuId;
7

8
    private BigDecimal price;
9

10
    private String skuName;
11

12
    private String skuDesc;
13

14
    private String weight;
15

16
    private Long tmId;
17
    /*
18
        三级分类id
19
    */
20
    private Long category3Id;
21

22
    private String skuDefaultImg;
23

24
    /*
25
      是否销售
26
    */
27
    private Integer isSale;
28

29
    /*
30
         sku商品的图片列表
31
     */
32
    List<SkuImageParam> skuImageList;
33
    /*
34
         sku商品平台属性集合
35
     */
36
    List<SkuPlatformAttributeValueParam> skuAttrValueList;
37
    /*
38
         sku商品销售属性集合
39
     */
40
    List<SkuSaleAttributeValueParam> skuSaleAttrValueList;
41
}

展开收起

接口的实现逻辑如下：

1
      /*
2
         1. 保存SKU基本信息
3
         2. 保存SKU图片
4
         3. 保存销售属性值
5
         4. 保存平台属性值
6
      */
7

8
    // 将sku参数对象，转化为PO对象
9
       SkuInfo skuInfo = skuInfoParamConverter.SkuInfoParam2Info(skuInfoParam);
10

11
        // 保存sku基本信息保存到sku_info
12
        skuInfoMapper.insert(skuInfo);
13
    // 获取sku图片列表
14
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
15
        if (skuImageList != null && skuImageList.size() > 0) {
16
            // 循环遍历
17
            for (SkuImage skuImage : skuImageList) {
18
                skuImage.setSkuId(skuInfo.getId());
19
                // 保存sku的多张图片信息, 保存到sku_img
20
                skuImageMapper.insert(skuImage);
21
            }
22
        }
23

24
        List<SkuSaleAttributeValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttributeValueList();
25
        // 调用判断集合方法
26
        if (!CollectionUtils.isEmpty(skuSaleAttrValueList)) {
27
            for (SkuSaleAttributeValue skuSaleAttrValue : skuSaleAttrValueList) {
28
                skuSaleAttrValue.setSkuId(skuInfo.getId());
29
                skuSaleAttrValue.setSpuId(skuInfo.getSpuId());
30
                // 保存sku销售属性值
31
                skuSaleAttrValueMapper.insert(skuSaleAttrValue);
32
            }
33
        }
34

35
        List<SkuPlatformAttributeValue> skuAttrValueList = skuInfo.getSkuPlatformAttributeValueList();
36
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
37
            for (SkuPlatformAttributeValue skuAttrValue : skuAttrValueList) {
38
                skuAttrValue.setSkuId(skuInfo.getId());
39
                // 保存sku平台属性值
40
                skuPlatformAttrValueMapper.insert(skuAttrValue);
41
            }
42
        }

展开收起

SKU基本信息列表查询#

实现SKU基本信息列表的查询，需要实现以下接口方法：

1
    @GetMapping("admin/product/list/{page}/{limit}")
2
    public Result index(
3
            @PathVariable Long page,
4
            @PathVariable Long limit) {
5
    }

1
    /*
2
         根据分页参数查询SKU分页数据
3
     */
4
    SkuInfoPageDTO getPage(Page<SkuInfo> pageParam);

1
@Data
2
public class SkuInfoPageDTO {
3

4
     /*
5
        查询到的一页sku数据
6
     */
7
    private List<SkuInfoDTO> records;
8
     /*
9
        查询到的总条数
10
     */
11
    private Integer total;
12
}

SKU商品的上下架#

在我们的后台管理系统中，我们还可以控制商品的上下架，只有上架的商品才能够被用户浏览，添加购物车和购买，下架的商品，用户是浏览不到的。

1
    @GetMapping("admin/product/onSale/{skuId}")
2
    public Result onSale(@PathVariable("skuId") Long skuId) {
3
    }
4

5
    /*
6
         SKU商品上架
7
     */
8
    void onSale(Long skuId);

1
    @GetMapping("admin/product/cancelSale/{skuId}")
2
    public Result cancelSale(@PathVariable("skuId") Long skuId) {
3
    }
4

5
    /*
6
        SKU商品下架
7
     */
8
    void offSale(Long skuId);

上架商品我们只需要讲sku商品的is_sale字段值设置为1，下架商品设置为0即可(暂时)

商品详情页

Sun, 14 Jun 2026 00:00:00 GMT

功能介绍#

数据#

在商品详情页中除了以上数据，还包含SKU所属的SPU商品海报集合

简单总结下，商品详情页应该包含如下数据：

SKU商品基本信息，包括名称，重量，默认图片
SKU商品所属的三级类目信息
SKU商品价格
SKU所属SPU商品的销售属性以及销售属性值的组合
SKU商品的图片集合
SKU商品的平台属性，以及属性取值集合(规格参数)
SKU所属SPU的商品海报

请求链路#

实现#

在商品服务中，我们需要接收前端发送的获取商品详情的请求，我们还需要重点实现以下接口，在业务层面处理商品详情页的服务调用请求

1
    @GetMapping("goods/{skuId}")
2
    public Result<ProductDetailDTO> getItem(@PathVariable Long skuId){
3
        ProductDetailDTO itemBySkuId = productDetailService.getItemBySkuId(skuId);
4
        return Result.ok(itemBySkuId);
5
    }

1
public interface ProductDetailService {
2

3
    /**
4
     * 获取sku详情信息
5
     * @param skuId
6
     * @return
7
     */
8
    ProductDetailDTO getItemBySkuId(Long skuId);
9
}

1
/*
2
     该类封装了商品详情页所需的所有数据
3
 */
4
@Data
5
public class ProductDetailDTO {
6
    // 商品sku 信息 + sku图片集合
7
    SkuInfoDTO skuInfo;
8

9
    // 获取指定的sku完整的销售属性值
10
    List<SpuSaleAttributeInfoDTO> spuSaleAttrList;
11

12
    // 获取spu中包含的所有的不同销售属性取值的组合
13
    String valuesSkuJson;
14

15
    // 获取sku商品的价格
16
    BigDecimal price;
17

18
    // 获取完整的三级类目信息
19
    CategoryHierarchyDTO categoryHierarchy;
20
    // 获取sku所属的SPU商品的海报列表
21
    List<SpuPosterDTO> spuPosterList;
22
    // 获取sku商品对应的平台属性集合(规格参数)
23
    List<SkuSpecification> skuAttrList;
24
}

展开收起

获取SKU及其图片列表#

在SkuService中，我们实现如下方法。

1
    SkuInfoDTO getSkuInfo(Long skuId);

这里，我们既需要查询，sku_info表中sku的基本信息，还需要查询出sku商品的图片列表，这里需要注意:

而在sku_image表中并没有存储sku商品图片对应的url，图片的url是存储在spu_image表中
所以要获取到sku商品的url，需要做联表查询，连接spu_image和sku_image两张表
通过联表查询，查询出sku商品图片的名称和url，封装在SkuImage对象中，得到List

1
    <resultMap id="skuImage" type="com.cskaoyan.mall.product.model.SkuImage" autoMapping="true">
2

3
    </resultMap>
4

5
    <!-- 根据spuId 获取到销售属性值Id 与skuId 组成的数据集 -->
6
    <select id="getSkuImages" resultMap="skuImage">
7
        select
8
          ski.id,
9
          ski.sku_id,
10
          ski.spu_img_id,
11
          ski.is_default,
12
          spi.img_name,
13
          spi.img_url
14
        from sku_image ski
15
        inner  join spu_image spi on ski.spu_img_id=spi.id
16
        where ski.sku_id=#{skuId}
17
    </select>

展开收起

获取SKU所属的SPU销售属性集合#

在SkuService中我们实现如下方法

1
List<SpuSaleAttributeInfoDTO> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId);

当点击某一个SKU商品，就会进入到商品详情页，在商品详情页中，可以显示该SKU商品对应的SPU中，所有销售属性值。这里，关于销售属性值，我们需要注意的是

我们需要获取当前SKU所属的SPU中，包含的所有销售属性和销售属性值
我们还要知道，当前浏览的这个SKU商品对应的销售属性值，并将其默认选中

如何实现呢？其实我们在查询销售属性值的时候，利用左外连接，就可以很快找到当前sku商品对应的所有销售属性值，并对其加以标记

首先，将spu_sale_attr_info与spu_sale_attr_value两张表做内连接, 其结果就包含指定了SPU所有销售属性及销售属性对应的销售属性值

1
      select
2
          ssai.id,
3
          ssai.spu_id,
4
          ssai.sale_attr_id,
5
          ssai.sale_attr_name,
6
          spsav.id  sale_attr_value_id,
7
          spsav.spu_sale_attr_id,
8
          spsav.spu_sale_attr_value_name
9
       from spu_sale_attr_info ssai
10
        inner  join  spu_sale_attr_value spsav
11
          on ssai.id = spsav.spu_sale_attr_id
12
       where ssai.spu_id=#{spuId}

紧接着，再用上一步的结果，与sku_sale_attr_value 做内连接，在这次内连接之后，我们就能SPU中包含的每个SKU商品的每个销售属性，以及销售属性值了

1
    select
2
      ssai.id,
3
          ssai.spu_id,
4
          ssai.sale_attr_id,
5
          ssai.sale_attr_name,
6
          spsav.id  sale_attr_value_id,
7
          spsav.spu_sale_attr_id,
8
          spsav.spu_sale_attr_value_name,
9
      sksav.sku_id
10
       from spu_sale_attr_info ssai
11
        inner  join  spu_sale_attr_value spsav on ssai.id = spsav.spu_sale_attr_id
12
        inner join sku_sale_attr_value sksav  on sksav.spu_sale_attr_value_id = spsav.id
13
    where ssai.spu_id=24

但是这样还不够：

因为我们不仅仅要查询SPU中的每一个SKU商品的属性值
我们还想知道哪些销售属性值，是当前SKU的，因为前端需要默认选中它们，所以我们修改以上连接的SQL，修改连接方式为左外连接，并且增加连接条件

1
select
2
      ssai.id,
3
          ssai.spu_id,
4
          ssai.sale_attr_id,
5
          ssai.sale_attr_name,
6
          spsav.id  sale_attr_value_id,
7
          spsav.spu_sale_attr_id,
8
          spsav.spu_sale_attr_value_name,
9
          sksav.sku_id
10
       from spu_sale_attr_info ssai
11
        inner  join  spu_sale_attr_value spsav on ssai.id = spsav.spu_sale_attr_id
12
         left join sku_sale_attr_value sksav on sksav.spu_sale_attr_value_id = spsav.id and sksav.sku_id=#{skuId}
13
where ssai.spu_id=#{spuId}

因为左外连接，有以下特征：

在SPU中包含的SKU属性值即使不满足连接条件，也会出现在连接结果中
不过不满足连接条件的那些SKU属性值的行，其sku_sale_attr_value表中字段值为null

所以利用这个特征，再结合第二个连接条件，我们就可以快速知道，哪些SKU属性值属于指定的SKU，因为只有指定的SKU销售属性值才会满足第二个连接条件，即sku_id这个字段值不会为null。完整的SQL如下：

1
       <resultMap id="spuSaleAttrMap" type="com.cskaoyan.mall.product.model.SpuSaleAttributeInfo" autoMapping="true">
2

3
        <id column="id" property="id"></id>
4
        <collection property="spuSaleAttrValueList" ofType="com.cskaoyan.mall.product.model.SpuSaleAttributeValue" autoMapping="true">
5
            <id column="sale_attr_value_id" property="id"></id>
6
        </collection>
7
    </resultMap>
8

9

10
   <select id="selectSpuSaleAttrListCheckedBySku" resultMap="spuSaleAttrMap">
11

12
        select
13
          ssai.id,
14
          ssai.spu_id,
15
          ssai.sale_attr_id,
16
          ssai.sale_attr_name,
17
          spsav.id  sale_attr_value_id,
18
          spsav.spu_sale_attr_id,
19
          spsav.spu_sale_attr_value_name,
20
          if(sksav.sku_id is null,0,1) is_checked
21

22
        from spu_sale_attr_info ssai
23
        inner  join  spu_sale_attr_value spsav
24
          on ssai.spu_id = spsav.spu_id and ssai.id = spsav.spu_sale_attr_id
25
        left join sku_sale_attr_value sksav
26
          on  sksav.spu_sale_attr_value_id = spsav.id and sksav.sku_id =#{skuId}
27
        where ssai.spu_id=#{spuId}
28
        order by  ssai.id ,spsav.id
29
    </select>

展开收起

if(condition，true value，false value)是mysql中的一个函数，接收三个参数，第一个参数表示判断条件，在我们的SQL语句中，对应sksav.sku_id is null，第二个参数是判断条件为true时的结果，第三个参数是判断条件为false时的结果。

所以最终，我们的SQL语句执行结果中，只有指定SKU商品销售属性行的is_checked值为1，其他均为0

不同销售属性值组合#

我们需要实现定义在SpuService接口中的方法

1
Map<String, Long> getSkuValueIdsMap(Long spuId);

当点击某一个SKU商品，就会进入到商品详情页，在商品详情页中，可以显示该SKU商品对应的SPU中，所有销售属性值。这里，关于销售属性值，我们还需要注意，我们也可以在页面中，修改选中的销售属性值组合，从而跳转到不同的SKU商品详情页

所以，随之而来的问题就是，SKU商品所属的SPU销售属性值有多种不同的组合，而不同的SPU销售属性组合对应不同的SKU商品，我们如何让前端快速确定，什么销售属性组合对应那个SKU商品从而实现商品详情页的跳转呢？

首先，我们可以先获取，SPU中每一个SKU商品对应的所有销售属性值

1
       select
2
          spsav.spu_sale_attr_id,
3
          sksav.spu_sale_attr_value_id,
4
          sksav.sku_id
5
        from sku_sale_attr_value sksav
6
        inner  join spu_sale_attr_value spsav on spsav.id=sksav.spu_sale_attr_value_id
7
        where sksav.spu_id=#{spuId}

很显然，我们查询出的SKU商品属性值，应该不包含下架商品，所以还需要和sku_info表做连接查询，过滤下架商品

1
        select
2
          spsav.spu_sale_attr_id,
3
          sksav.spu_sale_attr_value_id,
4
          sksav.sku_id
5
        from sku_sale_attr_value sksav
6
        inner  join spu_sale_attr_value spsav on spsav.id=sksav.spu_sale_attr_value_id
7
        inner join sku_info on sksav.sku_id=sku_info.id and sku_info.is_sale=1
8
        where sksav.spu_id=#{spuId}

但是还不够，我们希望得到的是，SPU中销售属性组合与 SKU的对应关系，所以继续修改SQL如下：

1
        select
2
          group_concat(sksav.spu_sale_attr_value_id order by spsav.spu_sale_attr_id asc  separator '|' ) sku_sale_attr_value_permutation,
3
          sku_id
4
        from sku_sale_attr_value sksav
5
        inner  join spu_sale_attr_value spsav on spsav.id=sksav.spu_sale_attr_value_id
6
        inner join sku_info on sksav.sku_id=sku_info.id and sku_info.is_sale=1
7
        where sksav.spu_id=#{spuId}
8
        group by sksav.sku_id

在以上SQL中，我们又给大家引入了mysql中的一个函数group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator 分隔符])。

这个函数到底做什么呢，就是对指定字段的分组内，将字段值按照指定的顺序，用指定的分隔符拼接成一个字符串即可。假如有学生表student如下所示：

id	name	class
1	长风	1
2	景天	1
3	天明	2
4	空灵	2
5	远志	3
6	石头	3

如果我想查询出每个班级(class)对应的所有学生，可以定义如下SQL:

1
create table student (
2
 id bigint primary key,
3
 name varchar(20),
4
 class int
5
);
6

7
insert into student values(1, '长风', 1),(2, '景天', 1),(3, '天明', 2),(4, '空灵', 2),(5, '远志', 3),(6, '石头', 3);

1
select  group_concat(student.name order by id asc separator '|') names,class from student group by class;

相似的道理，如果我们能查询出一张类似的表，就可以清楚的知道销售属性值组合与sku的对应关系了

销售属性值组合	sku_id
销售属性值1\|销售属性值2\|…	1
销售属性值1\|销售属性值2\|…	2
…	…

所以，我们查询出的结果如下：

![](/assets/firefly-docs/microservice/microservice-13-product-detail/group_concat sku查询示例.png)

完整的sql定义以及结果映射如下：

1
    <resultMap id="skuSaleAttrValuePermutation" type="com.cskaoyan.mall.product.model.SkuSaleAttributeValuePermutation" autoMapping="true">
2

3
    </resultMap>
4

5
    <!-- 根据spuId 获取到销售属性值Id 与skuId 组成的数据集 -->
6
    <select id="selectSaleAttrValuesBySpu" resultMap="skuSaleAttrValuePermutation">
7
        select
8
          group_concat(sksav.spu_sale_attr_value_id order by spsav.spu_sale_attr_id asc  separator '|' ) sku_sale_attr_value_permutation,
9
          sku_id
10
        from sku_sale_attr_value sksav
11
        inner  join spu_sale_attr_value spsav on spsav.id=sksav.spu_sale_attr_value_id
12
        inner join sku_info on sksav.sku_id=sku_info.id and sku_info.is_sale=1
13
        where sksav.spu_id=#{spuId}
14
        group by sksav.sku_id
15
    </select>

展开收起

获取SKU平台属性集合#

在SkuService中实现如下方法

1
 List<PlatformAttributeInfoDTO> getPlatformAttrInfoBySku(Long skuId);

1
    <resultMap id="platformAttrInfoMap" type="com.cskaoyan.mall.product.model.PlatformAttributeInfo" autoMapping="true">
2
        <id column="id" property="id"></id>
3
        <!--
4
        property: 实体类属性名
5
        ofType: 实体类属性名对应的类型
6
        -->
7
        <collection property="attrValueList" ofType="com.cskaoyan.mall.product.model.PlatformAttributeValue" autoMapping="true">
8
            <id column="attr_value_id" property="id"></id>
9
        </collection>
10

11
    </resultMap>
12

13

14
   <select id="selectPlatformAttrInfoListBySkuId" resultMap="platformAttrInfoMap">
15

16
        select   pai.id,
17
                 pai.attr_name,
18
                 pai.category_id,
19
                 pai.category_level,
20
                 pav.id attr_value_id,
21
                 pav.value_name,
22
                 pav.attr_id
23

24
        from platform_attr_info pai
25
               inner join  platform_attr_value pav  on pai.id=pav.attr_id
26
               inner join  sku_platform_attr_value spav on spav.value_id=pav.id
27
        where spav.sku_id=#{skuId}
28

29
    </select>

展开收起

三级类目#

在skuinfo表中，针对每一个SKU商品，我们都记录了其对应的第三级类目的id，所以我们就可以顺藤摸瓜，查询出该SKU商品所属的第一，二级目录，这样我们就可以查询出，包含该SKU商品的三级目录信息了。为此，我们需要实现CategoryService中以下接口方法

1
    /*
2
        获取和该三级类目相关完整信息(包括它所属的一级类目和二级类目）
3
     */
4
    CategoryHierarchyDTO getCategoryViewByCategoryId(Long thirdLevelCategoryId);

1
@Data
2
public class CategoryHierarchyDTO {
3
    // 一级类目id
4
    private Long firstLevelCategoryId;
5
    // 一级类目名称
6
    private String firstLevelCategoryName;
7
    // 二级类目id
8
    private Long secondLevelCategoryId;
9
   // 二级类目名称
10
    private String secondLevelCategoryName;
11
  // 三级类目id
12
    private Long thirdLevelCategoryId;
13
    // 三级类目名称
14
    private String thirdLevelCategoryName;
15
}

展开收起

这里我们可以定义定义多表查询

1
<resultMap id="skuCategoryHierarchyInfo" type="com.cskaoyan.mall.product.model.CategoryHierarchy" autoMapping="true">
2

3
    </resultMap>
4

5
    <!--
6
         1. 若thirdLevelCategoryId为null，则查询所有三级类目对应的一二级目录
7
         2. 若thirdLevelCategoryId不为null，则查询指定三级类目对应的一二级类目
8
      -->
9
    <select id="selectCategoryHierarchy" resultMap="skuCategoryHierarchyInfo">
10
        select
11
        c1.id as first_level_category_id, c1.name as first_level_category_name,
12
        c2.id as second_level_category_id, c2.name as second_level_category_name,
13
        c3.id as third_level_category_id, c3.name as third_level_category_name
14
        from first_level_category c1
15
        inner join second_level_category c2 on c2.first_level_category_id = c1.id
16
        inner join third_level_category c3 on c3.second_level_category_id = c2.id
17
        <where>
18
          <if test="thirdLevelCategoryId != null">
19
              c3.id=#{thirdLevelCategoryId}
20
          </if>
21
        </where>
22
    </select>

展开收起

总代码流程梳理#

1
    @Autowired
2
    SpuService spuService;
3

4
    @Autowired
5
    SkuService skuService;
6

7
    @Autowired
8
    CategoryService categoryService;
9

10
    @Override
11
    public ProductDetailDTO getItemBySkuId(Long skuId) {
12
     // 封装商品详情页中所有的数据
13
        ProductDetailDTO productDetailDTO = new ProductDetailDTO();
14

15

16
        // 通过skuId 查询skuInfo(还需要包含sku商品的图片列表)
17
        SkuInfoDTO skuInfo = ...;
18
        productDetailDTO.setSkuInfo(skuInfo);
19

20
        // 根据spuI的查询SPU所有销售属性及销售属性值，根据skuId默认选中指定的SKU商品属性值
21
        List<SpuSaleAttributeInfoDTO> spuSaleAttrListCheckBySku = ...;
22
        productDetailDTO.setSpuSaleAttrList(spuSaleAttrListCheckBySku);
23

24

25
        // 根据spuId 查询销售属性值组合与sku_id对应关系
26
        Map<String, Long> skuValueIdsMap = ...;
27
        // 将map转化为json字符串
28
        String valuesSkuJson = JSON.toJSONString(skuValueIdsMap);
29
        // 保存valuesSkuJson
30
       productDetailDTO.setValuesSkuJson(valuesSkuJson);
31

32

33
        //获取商品最新价格
34
        BigDecimal skuPrice = ...;
35
        productDetailDTO.setPrice(skuPrice);
36

37

38
        //获取sku商品的三级类目信息
39
        CategoryHierarchyDTO categoryViewByCategory = ...;
40
        //分类信息
41
        productDetailDTO.setCategoryHierarchy(categoryViewByCategory);
42

43
         //  获取spu海报数据
44
         List<SpuPosterDTO> spuPosterBySpuId = ...;
45
         productDetailDTO.setSpuPosterList(spuPosterBySpuId);
46

47
        //  获取sku平台属性
48
            List<PlatformAttributeInfoDTO> platformAttrInfoBySku = ...;
49
        // 将平台属性转化为规格数据
50
            List<SkuSpecification> skuAttrList = platformAttrInfoBySku.stream().map((baseAttrInfo) -> {
51
                // 创建封装规格数据的对象
52
                SkuSpecification skuSpecification = new SkuSpecification();
53
                // 设置属性名
54
                skuSpecification.setAttrName(baseAttrInfo.getAttrName());
55
                // 设置属性值
56
                skuSpecification.setAttrValue(baseAttrInfo.getAttrValueList().get(0).getValueName());
57

58
                return skuSpecification;
59
            }).collect(Collectors.toList());
60
            productDetailDTO.setSkuAttrList(skuAttrList);
61

62
        // 商品被浏览了一次，可以增加它的热度积分(后面实现)
63

64
        return productDetailDTO;
65
    }

展开收起

商品详情异步与首页

Sun, 14 Jun 2026 00:00:00 GMT

商品详情的异步#

问题的引出#

到目前位置，我们已经完成了获取商品详情的功能，代码如下：

1
public ProductDetailDTO getItemBySkuId(Long skuId) {
2

3
        ProductDetailDTO productDetailDTO = new ProductDetailDTO();
4
        // 1. 获取sku基本信息 + 图片列表
5
        SkuInfoDTO skuInfo = skuService.getSkuInfo(skuId);
6
        if (skuInfo.getId() == null) {
7
            return productDetailDTO;
8
        }
9
        productDetailDTO.setSkuInfo(skuInfo);
10

11
        // 2. 获取SKU所属的SPU中包含的销售属性及销售属性值(包含目标sku的销售属性值)
12
        List<SpuSaleAttributeInfoDTO> spuSaleAttrListCheckBySku = skuService.getSpuSaleAttrListCheckBySku(skuId, skuInfo.getSpuId());
13
        productDetailDTO.setSpuSaleAttrList(spuSaleAttrListCheckBySku);
14

15
        // 3. 获取 销售属性值组合 与 skuId对应关系的 Json字符串
16
        Map<String, Long> skuValueIdsMap = spuService.getSkuValueIdsMap(skuInfo.getSpuId());
17
        String skuValueIdsJson = JSON.toJSONString(skuValueIdsMap);
18
        productDetailDTO.setValuesSkuJson(skuValueIdsJson);
19

20
        // 4. 获取商品价格
21
        BigDecimal skuPrice = skuService.getSkuPrice(skuId);
22
        productDetailDTO.setPrice(skuPrice);
23

24
        // 5. 获取sku对应三级类目
25
        CategoryHierarchyDTO categoryView = categoryService.getCategoryViewByCategoryId(skuInfo.getThirdLevelCategoryId());
26
        productDetailDTO.setCategoryHierarchy(categoryView);
27

28
        // 6. 查询海报集合
29
        List<SpuPosterDTO> spuPosterBySpuId = spuService.findSpuPosterBySpuId(skuInfo.getSpuId());
30
        productDetailDTO.setSpuPosterList(spuPosterBySpuId);
31

32
        // 7. 查询SKU商品的规格参数(平台属性 对应的那个 平台属性值)
33
        List<PlatformAttributeInfoDTO> platformAttrInfoBySku = skuService.getPlatformAttrInfoBySku(skuId);
34
        List<SkuSpecification> skuSpecifications = platformAttrInfoBySku.stream().map(platformAttributeInfoDTO -> {
35
            SkuSpecification skuSpecification = new SkuSpecification();
36
            // 获取平台属性名称
37
            String attrName = platformAttributeInfoDTO.getAttrName();
38
            // 设置平台属性名称
39
            skuSpecification.setAttrName(attrName);
40
            // 获取平台属性值的名称
41
            String valueName = platformAttributeInfoDTO.getAttrValueList().get(0).getValueName();
42

43
            // 设置平台属性值的名称
44
            skuSpecification.setAttrValue(valueName);
45
            return skuSpecification;
46
        }).collect(Collectors.toList());
47
        productDetailDTO.setSkuAttrList(skuSpecifications);
48

49

50
        return productDetailDTO;
51
    }

展开收起

稍微思考以下，从执行效率上来看，以上的代码是否还有优化的空间呢？回答当然是肯定的

sku基本信息，spu销售属性值集合，sku_id与其对应的销售属性值组合，…，这些商品详情页中的各项数据，目前我们是依次先后获取的。但是，如果可以可以分别同时获取，那么获取数据的效率肯定会大大提升。于是，我们马上就想到了线程池，代码改造如下：

1
// 创建线程池
2
ExecutorService executor = ...;
3

4

5
// 向线程池中提交异步任务
6
executor.submit(获取skuInfo的异步任务);
7
executor.submit(获取sku对应的spu销售属性值集合的异步任务);
8
....

看起来似乎非常的简单，但是仔细一想，又有两个难以解决的问题：

获取详情页数据的这些异步任务之间，并非完全没有关系，它们是有明显的逻辑顺序的

我们需要等待所有的异步任务都执行完毕，将数据封装到ProductDetailDTO对象中，从而给前端返回完整的详情页数据

1
// 创建线程池
2
ExecutorService executor = ...;
3

4
// 向线程池中提交异步任务
5
executor.submit(获取skuInfo的异步任务);
6
executor.submit(获取sku对应的spu销售属性值集合的异步任务);
7
....
8
// 即使不考虑异步任务之间的先后逻辑关系，也需要在最后等待所有异步任务执行完毕，返回ProductDetailDTO对象

以上两个问题，我们如何解决呢？这就涉及到了异步任务的编排问题了，通过JDK8引入的CompletableFuture就可以帮我们实现异步任务的编排。

CompletableFuture#

一个CompletableFuture对象主要有两个功能:

表示一个Future对象，即可以表示一个异步任务的执行结果
可以实现多个异步任务之间的功能依赖，对多个异步任务之间进行”组合”。

什么是组合呢？比如”异步任务A需要在异步任务B之后执行，那么可以通过CompletableFuture实现任务A执行完毕后，自动触发任务B的执行”

image-20240519161150253

如上图所示，这里描绘的是一个业务接口的流程，其中包括CF1\CF2\CF3\CF4\CF5\CF6 共6个步骤，并描绘了这些步骤之间的依赖关系，每个步骤可以是一次数据库操作或者是一次本地方法调用，或者是一次服务间的调用等，在使用CompletableFuture进行异步化编程时，图中的每个步骤都会产生一个CompletableFuture对象，最终结果也会用一个CompletableFuture来进行表示。

根据CompletableFuture依赖数量，可以分为以下几类：零依赖、一元依赖、二元依赖和多元依赖。

零依赖#

零依赖，其实也就是CompletableFuture对象的创建，我们可以先来看看如何不依赖其他的CompletableFuture对象来创建新的CompletableFuture。

image-20240519161519164

如上图CF1和CF2的创建，其实就是直接创建CompletableFuture对象。

runAsync-无返回值#

第一种方式是获取一个表示无返回值异步任务执行结果的CompletableFuture对象

接口#

1
// 获取一个异步任务CompletableFuture对象
2
// 这里没有指定线程池，默认会把当前任务交给CompletableFuture内部的线程池来执行
3
static CompletableFuture<Void> runAsync(Runnable runnable)
4

5
// 在指定的线程池中，执行下一个异步任务
6
static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

使用案例#

1
// runAsync案例
2
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> System.out.println("hello,world"));
3

4
// 创建线程池
5
Executor executor = ...
6
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> System.out.println("hello,world"), executor);

注意事项#

CompletableFuture，泛型类型为Void，表示异步任务没有执行结果
一个异步任务虽然没有返回值，但是会有执行状态，而这个执行状态，也被封装在CompletableFuture对象中，因此我们可以做如下操作

1
// 异步任务是否被取消了
2
boolean isCancelled = CompletableFuture.isCancelled();
3
// 是否在执行过程中出现了异常
4
boolean isExceptional = CompletableFuture.isCompletedExceptionally();
5
// 是否正常执行完毕了
6
boolean done = CompletableFuture.isDone();

supplyAsync-有返回值#

第二种方式是获取一个表示有返回值的异步任务执行结果的CompletableFuture对象、

接口#

1
/*
2
  Supplier<U> supplier 提供者接口，产生一个结果
3
  CompletableFuture<U> 表示supplier在子线程中执行的结果，包含U类型的对象
4
*/
5
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
6

7

8
// 在指定的线程池中，执行下一个异步任务
9
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

1
public interface Supplier<T> {
2
    T get();
3
}

使用案例#

1
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "hello,world");
2
// 在当前线程中，获取异步任务执行的结果
3
String result = completableFuture.get();
4

5
Executor executor = ...
6
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "hello,world", executor);
7

8
// 在当前线程中，获取异步任务执行的结果
9
String result = completableFuture.get();

注意事项#

CompletableFuture, 泛型类型为String，表示异步任务最终返回的结果是一个String对象
CompletableFuture中除了封装异步任务执行的状态，还封装了异步任务的执行结果，可以通过如下方式获取

1
// CompletableFuture的泛型是什么类型，get方法获取的就是什么类型的值，若为Void，则get的结果是null
2
String result = CompletableFuture.get();

关于CompletableFuture.get()方法，是一个阻塞方法，会阻塞调用线程，直到CompletableFuture对象所代表的的异步任务执行结束。

一元依赖#

image-20240519162415395

如上图所示，CF3和CF5都需要依赖于前一个CompletableFuture对象。

thenRun & thenRunAsync#

接口#

1
// thenRun方法：在当前异步任务结束后，触发下一个异步任务（thenRun方法传递的参数）无参且没有返回值的异步任务
2
CompletableFuture<Void> thenRun(Runnable action)
3

4
// thenRunAync方法：方法参数和执行结果同thenRun，区别是thenRunAsync方法传递的异步任务所执行的线程是一个新的线程.
5
// thenRunAsync方法还有一个重载方法，executor指定下一个异步任务执行所使用的线程池
6
CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor)

使用案例#

1
// 异步执行第一个异步任务，得到代表第一个异步任务执行结果的CompletableFuture<Void>对象
2
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> System.out.println("first"));
3

4
// 指定在当前任务(completableFuture代表当前的异步任务)执行完毕后，执行下一个异步任务
5
CompletableFuture thenCompletableFuture = completableFuture.thenRun(() -> System.out.println("second"));
6

7
// 在当前线程中等待执行完毕(join并非必须, 只是上课演示的需要)
8
thenCompletableFuture.join();

或者我们可以使用链式调用的方式，重新书写以上的代码(效果等效)，实际开发中我们通常习惯使用链式调用方式

1
CompletableFuture.runAsync(() -> System.out.println("first"))
2
    // 指定下一个要执行的异步任务
3
    .thenRun(() -> System.out.println("second")).join();

thenAccept & thenAcceptAsync#

接口#

thenAccept方法: 在当前异步任务执行结束后，触发下一个异步任务的执行，且下一个异步任务，接收当前异步任务的结果作为参数执行，下一个异步任务无返回值

1
/*
2
  参数：
3
   action的accept方法的参数表示下一个异步任务所接受的当前异步任务执行的结果
4
  返回值:
5
   CompletableFuture<Void>表示下一个异步任务的执行结果无返回值
6
*/
7
CompletableFuture<Void> thenAccept(Consumer<? super T> action)
8

9
// thenAcceptAsync方法: 方法参数和执行结果同thenAccept，区别是thenAcceptAsync方法传递的异步任务所执行的线程是一个新的线程
10
CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)
11

12
// thenAcceptAsync还有一个重载方法，executor指定下一个异步任务执行所使用的线程池
13
CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor)

1
public interface Consumer<T> {
2

3
    void accept(T t);
4
}

1
CompletableFuture.supplyAsync(() -> "hello,world")
2
    // 下一个异步任务接收当前异步任务的结果并处理
3
    .thenAccept(r -> System.out.println(r.length()));

使用案例#

1
Executor executor = ...
2

3
    CompletableFuture.supplyAsync(() -> {
4
        // 输出线程名称
5
        System.out.println(Thread.currentThread().getName());
6
        try {
7
            TimeUnit.SECONDS.sleep(1);
8
        } catch (InterruptedException e) {
9
            throw new RuntimeException(e);
10
        }
11
        return "hello,world";
12
    }, executor).thenAcceptAsync(s -> {
13
    // 输出线程名称
14
    System.out.println(Thread.currentThread().getName());
15
    try {
16
        TimeUnit.SECONDS.sleep(1);
17
    } catch (InterruptedException e) {
18
        throw new RuntimeException(e);
19
    }
20
    System.out.println(s.length());
21
 }, executor).join();

展开收起

thenApply & thenApplyAsync#

接口#

thenApply方法: 在当前异步任务执行结束后，触发下一个异步任务的执行，下一个异步任务接收当前异步任务的结果作为参数，且下一个异步任务有自己的返回值

thenApplyAsync方法：方法参数和执行结果同thenApply，区别是thenApplyAsync方法传递的异步任务所执行的线程是一个新的线程

1
/*
2
  参数：
3
   Function的apply方法第一个参数表示接收的当前异步的结果
4
   Function的apply方法返回值表示下一个异步任务的结果
5
  返回值:
6
   CompletableFuture<U>表示下一个异步任务的执行结果包含下一个异步任务的返回值
7
*/
8
<U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
9

10
// 把异步任务交给默认的线程池来执行
11
<U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
12

13
// 把异步任务交给指定的线程池来执行
14
CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)

1
public interface Function<T, R> {
2
    // 将一个参数值转化为另一个类型的值并返回
3
    R apply(T t);
4
}

使用案例#

1
// thenApply案例
2
CompletableFuture<String> completableFuture = CompletableFuture
3
    .supplyAsync(() -> new Random().nextInt(1000))
4
    // 下一个异步任务接收当前异步任务的结果并返回处理结果
5
    .thenApply((r) -> r % 2 == 0 ? "奇数" : "偶数");
6
// 通过completableFuture获取异步任务返回的结果
7
String result = completableFuture.get();
8
// 输出结果
9
System.out.println(result);
10

11

12
// thenApplyAsync案例
13
CompletableFuture<String> completableFutureResult = CompletableFuture
14
.supplyAsync(() -> {
15
    try {
16
    //休眠三秒中
17
    TimeUnit.SECONDS.sleep(3);
18
    } catch (InterruptedException e) {
19
    throw new RuntimeException(e);
20
    }
21
    // 返回随机数
22
    return new Random().nextInt(1000);
23
})
24
// 下一个异步任务接收当前异步任务的结果并返回处理结果
25
.thenApplyAsync((r) -> r % 2 == 0 ? "奇数" : "偶数");
26
String result = completableFuture.get();
27
System.out.println(result);
28

29

30
// thenApplyAsync案例
31
 Executor  executor = ...;
32

33
CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
34
    // 输出线程名称
35
    System.out.println(Thread.currentThread().getName());
36
    try {
37
        //休眠三秒中
38
        TimeUnit.SECONDS.sleep(3);
39
    } catch (InterruptedException e) {
40
        throw new RuntimeException(e);
41
    }
42
    int i = new Random().nextInt(1000);
43
    System.out.println(i);
44
    // 返回随机数
45
    return i;
46
}, executor)
47
   // 下一个异步任务接收当前异步任务的结果并返回处理结果
48
    .thenApplyAsync(v -> {
49
        // 输出线程名称
50
        System.out.println(Thread.currentThread().getName());
51
        try {
52
            TimeUnit.SECONDS.sleep(3);
53
        } catch (InterruptedException e) {
54
            throw new RuntimeException(e);
55
        }
56
        return v % 2 == 0 ? "偶数" : "奇数";
57
    }, executor);
58

59
String s = stringCompletableFuture.get();
60
System.out.println(s);

展开收起

二元依赖#

image-20240519201159136

如上图红色链路所示，CF4同时依赖于两个CF1和CF2，这种二元依赖可以通过thenCombine等方法来实现，如下代码所示

thenCombine & thenCombineAsync#

接口#

1
/*
2
  参数：
3
   other: 待合并的另一个异步任务
4
   T: 第一个任务的返回结果
5
   U: 第二个任务的返回结果
6
   fn: 组合之后的返回类型
7
  返回值:
8
   CompletableFuture<U>表示下一个异步任务的执行结果包含下一个异步任务的返回值
9
*/
10
public <U,V> CompletableFuture<V> thenCombine( CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn);
11

12
public <U,V> CompletableFuture<V> thenCombineAsync( CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
13

14
public <U,V> CompletableFuture<V> thenCombineAsync( CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)

1
@FunctionalInterface
2
public interface BiFunction<T, U, R> {
3
  // T 第一个任务的返回结果
4
  // U 第二个任务的返回结果
5
  // R 组合之后的返回类型
6
  R apply(T t, U u);
7
}

使用#

1
CompletableFuture<String> firstCompletableFuture = CompletableFuture.supplyAsync(() -> "first");      //创建第一个异步任务
2
CompletableFuture<String> secondCompletableFuture = CompletableFuture.supplyAsync(() -> "second");      // 创建第二个异步任务
3

4
// 组合第一个和第二个异步任务的结果
5
CompletableFuture<String> combineCompletableFuture = firstCompletableFuture.thenCombine(secondCompletableFuture, (firstRet, secondRet) -> firstRet + secondRet);
6

7
// 获得结果
8
String ret = combineCompletableFuture.get();

多元依赖#

image-20240519202449036

如上图红色链路所示，整个流程的结束依赖于三个步骤CF3、CF4、CF5，这种多元依赖可以通过allOf或anyOf方法来实现，区别是当需要多个依赖全部完成时使用allOf，当多个依赖中的任意一个完成即可时使用anyOf。

allOf#

allOf方法: 可以将多个异步任务合并为一个新的异步任务，当且仅当所有的异步任务都执行完，新的异步任务才算执行完

1
/*
2
   参数表示待合并的多个异步任务
3
   返回值为CompletableFuture<Void>类型，说明合并之后的异步任务不包含任何返回值
4
*/
5
CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

1
User user = new User();
2

3
// 第一个异步任务
4
CompletableFuture<Void> cf1 = CompletableFuture.runAsync(() -> {
5
    try {
6
        TimeUnit.SECONDS.sleep(3);
7
    } catch (InterruptedException e) {
8
        throw new RuntimeException(e);
9
    }
10
    user.setId(1001);
11
});
12

13
// 第二个异步任务
14
CompletableFuture<Void> cf2 = CompletableFuture.runAsync(() -> {
15
    try {
16
        TimeUnit.SECONDS.sleep(2);
17
    } catch (InterruptedException e) {
18
        throw new RuntimeException(e);
19
    }
20
    user.setName("张三");
21
});
22

23
// 第三个异步任务
24
CompletableFuture<Void> cf3 = CompletableFuture.runAsync(() -> {
25
    try {
26
        TimeUnit.SECONDS.sleep(1);
27
    } catch (InterruptedException e) {
28
        throw new RuntimeException(e);
29
    }
30
    user.setAge(30);
31
});
32

33
// 组合，等待所有的异步任务执行完
34
CompletableFuture<Void> cfAll = CompletableFuture.allOf(cf1, cf2, cf3);
35
// 可以调用join方法阻塞到所有任务都执行完毕
36
cfAll.join();
37
System.out.println(user);

展开收起

anyOf （了解）#

allOf方法: 可以将多个异步任务合并为一个新的异步任务，其中只要有一个任务执行完，新的异步任务就算执行完，且会将该任务的执行结果，作为新的异步任务的结果

1
/*
2
   参数表示待合并的多个异步任务
3
   返回值为CompletableFuture<Object> 合并之后的异步任务的结果，同先执行完的那个异步任务的结果
4
*/
5
CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

注意：如果这些待合并的异步任务中，同时有多个异步任务执行完毕，那么合并之后的新的异步任务的执行结果就是不确定的，具有很大的不确定性，所以实际开发中很少用。

异常处理#

CompletableFuture还给我们提供了一个专门用来处理异常的方法：exceptionally

1
/*
2
  注意，该方法当且仅当 当前异步任务出现异常的时候才会执行
3
  作用:
4
    通过执行fn，将当前异步任务的异常转化为某一个默认值返回
5
  返回值：异常处理的结果，即当发生异常时所返回的默认值，默认值的数据类型同当前异步任务的返回值类型
6
*/
7
CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)

1
CompletableFuture<int[]> exceptionally = CompletableFuture.supplyAsync(() -> {
2
    int[] a = null;
3
    // 数组越界异常
4
    System.out.println(a[3]);
5
    return a;
6
    })
7
// 当前异步任务返回数组出现了异常，则就返回长度为0的数组
8
.exceptionally(e -> new int[0]);
9

10
int[] ints = exceptionally.get();
11
System.out.println(ints.length);

项目中的使用#

在1.1的问题引出中，我们所遇到的问题，其实都可以通过CompletableFuture的异步编排来实现。

1
ProductDetailDTO productDetailDTO = new ProductDetailDTO();
2

3
// 通过skuId 查询skuInfo
4
CompletableFuture<SkuInfoDTO> skuCompletableFuture = CompletableFuture.supplyAsync(() -> {
5
    SkuInfoDTO skuInfo = skuService.getSkuInfo(skuId);
6
    // 保存skuInfo
7
    productDetailDTO.setSkuInfo(skuInfo);
8
    return skuInfo;
9
}, threadPoolExecutor);
10

11

12
// 销售属性-销售属性值回显并锁定 thenAcceptAsync 串行化
13
CompletableFuture<Void> spuSaleAttrCompletableFuture = skuCompletableFuture.thenAcceptAsync(skuInfo -> {
14
    List<SpuSaleAttributeInfoDTO> spuSaleAttrListCheckBySku
15
        = skuService.getSpuSaleAttrListCheckBySku(skuInfo.getId(), skuInfo.getSpuId());
16

17
    // 保存数据
18
    productDetailDTO.setSpuSaleAttrList(spuSaleAttrListCheckBySku);
19
}, threadPoolExecutor);
20

21
//根据spuId 查询map 集合属性
22
// 销售属性-销售属性值回显并锁定 thenAcceptAsync 串行化
23
CompletableFuture<Void> skuValueIdsMapCompletableFuture = skuCompletableFuture.thenAcceptAsync(skuInfo -> {
24
    Map<String, Long> skuValueIdsMap = spuService.getSkuValueIdsMap(skuInfo.getSpuId());
25

26
    String valuesSkuJson = JSON.toJSONString(skuValueIdsMap);
27
    // 保存valuesSkuJson
28
    productDetailDTO.setValuesSkuJson(valuesSkuJson);
29

30
}, threadPoolExecutor);
31

32

33
//获取商品最新价格
34
CompletableFuture<Void> skuPriceCompletableFuture = CompletableFuture.runAsync(() -> {
35
    BigDecimal skuPrice = skuService.getSkuPrice(skuId);
36
    productDetailDTO.setPrice(skuPrice);
37

38
}, threadPoolExecutor);
39

40

41
//获取分类信息 thenAcceptAsync 串行化
42
CompletableFuture<Void> categoryViewCompletableFuture = skuCompletableFuture.thenAcceptAsync(skuInfo -> {
43
    CategoryHierarchyDTO categoryViewByCategory = categoryService.getCategoryViewByCategoryId(skuInfo.getThirdLevelCategoryId());
44
    //分类信息
45
    productDetailDTO.setCategoryHierarchy(categoryViewByCategory);
46

47
}, threadPoolExecutor);
48

49
//  获取海报数据 thenAcceptAsync 串行化
50
CompletableFuture<Void> spuPosterListCompletableFuture = skuCompletableFuture.thenAcceptAsync(skuInfo -> {
51
    //  spu海报数据
52
    List<SpuPosterDTO> spuPosterBySpuId = spuService.findSpuPosterBySpuId(skuInfo.getSpuId());
53
    productDetailDTO.setSpuPosterList(spuPosterBySpuId);
54

55
}, threadPoolExecutor);
56

57
//  获取sku平台属性，即规格数据
58
CompletableFuture<Void> skuAttrListCompletableFuture = CompletableFuture.runAsync(() -> {
59
    List<PlatformAttributeInfoDTO> platformAttrInfoBySku = skuService.getPlatformAttrInfoBySku(skuId);
60
    List<SkuSpecification> skuAttrList = platformAttrInfoBySku.stream().map((baseAttrInfo) -> {
61
        //
62
        SkuSpecification skuSpecification = new SkuSpecification();
63
        skuSpecification.setAttrName(baseAttrInfo.getAttrName());
64
        skuSpecification.setAttrValue(baseAttrInfo.getAttrValueList().get(0).getValueName());
65
        return skuSpecification;
66
    }).collect(Collectors.toList());
67
    productDetailDTO.setSkuAttrList(skuAttrList);
68
}, threadPoolExecutor);
69

70
// 等待所有异步任务执行完毕
71
CompletableFuture.allOf(skuCompletableFuture, spuSaleAttrCompletableFuture,
72
                        skuValueIdsMapCompletableFuture, skuPriceCompletableFuture,
73
                        categoryViewCompletableFuture, spuPosterListCompletableFuture, skuAttrListCompletableFuture).join();
74
return productDetailDTO;

展开收起

通过CompletableFuture的异步编排功能，既可以实现异步，还可以保证异步任务的执行流程，在保证正确性的前提下，提升商品详情页数据的获取效率。

首页功能#

在电商页面首页，我们会展示电商网站中所有的一级商品类目，一级商品类目对应的二级商品类目，二级商品类目对应的三级商品类目。

所以我们必须在访问首页时，查询到所有商品类目，一级对应的层级关系，具体的请求链路如下：

首页返回的完整的三级类目及层级关系的json数据

1
[
2
  {
3
    "categoryId": 1,
4
    "categoryName": "图书、音像、电子书刊",
5
    "categoryChild": [{
6
      "categoryId": 1,
7
      "categoryName": "电子书刊",
8
      "categoryChild": [{
9
        "categoryId": 1,
10
        "categoryName": "电子书"
11
      }, {
12
        "categoryId": 2,
13
        "categoryName": "网络原创"
14
      }, {
15
        "categoryId": 3,
16
        "categoryName": "数字杂志"
17
      }, {
18
        "categoryId": 4,
19
        "categoryName": "多媒体图书"
20
      }]
21
    },
22
    ...
23
    ]
24
  }, {
25
    "categoryId": 2,
26
    "categoryName": "手机",
27
    "categoryChild": [{
28
      "categoryId": 13,
29
      "categoryName": "手机通讯",
30
      "categoryChild": [{
31
        "categoryId": 61,
32
        "categoryName": "手机"
33
      }, {
34
        "categoryId": 62,
35
        "categoryName": "对讲机"
36
      }]
37
    },
38
    ...
39
    ]
40
  }
41
  ....
42
]

展开收起

在service-product中，我们需要定义Controller，来接收处理获取首页分类数据请求的Controller

1
    /**
2
     * 获取全部分类信息
3
     * @return
4
     */
5
    @GetMapping("/index")
6
    public Result getBaseCategoryList(){
7
        List<FirstLevelCategoryNodeDTO> categoryTreeList = categoryService.getCategoryTreeList();
8
        return Result.ok(categoryTreeList);
9
    }

还要定义业务层接口，以及业务层实现类

1
    /*
2
          获取完整的三级类目信息
3
     */
4
    List<FirstLevelCategoryNodeDTO> getCategoryTreeList();

1
@Data
2
public class FirstLevelCategoryNodeDTO {
3
    // 一级目录id
4
    Long categoryId;
5

6
    // 一级目录名称
7
    String categoryName;
8

9
    // 一级目录的位序
10
    Integer index;
11

12
    // 一级目录所属的二级目录列表
13
    List<SecondLevelCategoryNodeDTO> categoryChild;
14

15
}

展开收起

1
@Data
2
public class SecondLevelCategoryNodeDTO {
3

4
    // 二级目录id
5
    Long categoryId;
6

7
    // 二级目录名称
8
    String categoryName;
9

10
    // 二级目录所包含的三级目录列表
11
    List<ThirdLevelCategoryNodeDTO> categoryChild;
12
}

1
public class ThirdLevelCategoryNodeDTO {
2
  // 三级目录id
3
    private Long categoryId;
4
    // 三级目录名称
5
    private String categoryName;
6
}

在实现代码之前我们先梳理写思路：

先查询出所有的一二三级类目的关联关系，得到 List

1
        select
2
        c1.id as first_level_category_id, c1.name as first_level_category_name,
3
        c2.id as second_level_category_id, c2.name as second_level_category_name,
4
        c3.id as third_level_category_id, c3.name as third_level_category_name
5
        from first_level_category c1
6
        inner join second_level_category c2 on c2.first_level_category_id = c1.id
7
        inner join third_level_category c3 on c3.second_level_category_id = c2.id
8
        <where>
9
          <if test="thirdLevelCategoryId != null">
10
              c3.id=#{thirdLevelCategoryId}
11
          </if>
12
        </where>

将上述表示所有一二三级关联关系的List，根据一级类目Id分组得到Map<Long, List，Map中的key表示一级类目Id，value表示一级类目所包含的二级类目信息集合。
针对Map中的每一个key，以及Map的value，我们可以构造出表示一级类目的FirstLevelCategoryNodeDTO对象，以及构造出属于该一级类目的二级类目集合，即List
同理，二级类目还包含多个三级类目，如何得到二级类目包含的三级类目集合呢？继续针对属于同一个一级类目的List，继续根据二级类目Id分组，分组之后，又得到一个Map<Long, List>，Map中的key表示二级类目Id，value表示二级目录所包含的三级类目信息集合
针对该Map中的每一个Key，以及Map中的value，我们可以构造出表示二级类目的SecondLevelCategoryNodeDTO对象，以及二级类目所属的三级类目集合，即List
这样一来，一级类目FirstLevelCategoryNodeDTO，一级类目包含的二级类目集合List，以及每一个二级类目SecondLevelCategoryNodeDTO，二级类目包含的三级类目集合List就都有了

1
    @Override
2
    @RedisCache(prefix = "category")
3
    public List<FirstLevelCategoryNodeDTO> getCategoryTreeList() {
4
        // 声明几个json 集合
5
        ArrayList<FirstLevelCategoryNodeDTO> firstLevelCategoryTreeNodes = new ArrayList<>();
6
        // 声明获取所有分类数据集合
7
        List<CategoryHierarchy> categoryHierarchyList = categoryHierarchyMapper.selectCategoryHierarchy(null);
8
        // 循环上面的集合并安一级分类Id 进行分组
9
        Map<Long, List<CategoryHierarchy>> firstLevelCategoryMap  = categoryHierarchyList.stream().collect(Collectors.groupingBy(CategoryHierarchy::getFirstLevelCategoryId));
10
        int index = 1;
11
        // 获取一级分类下所有数据
12
        for (Map.Entry<Long, List<CategoryHierarchy>> firstLevelEntry  : firstLevelCategoryMap.entrySet()) {
13
            // 获取一级分类Id
14
            Long firstLevelCategoryId  = firstLevelEntry.getKey();
15
            // 获取一级分类下面的所有集合
16
            List<CategoryHierarchy> firstLevelCategories  = firstLevelEntry.getValue();
17
            //
18
            FirstLevelCategoryNodeDTO firstLevelCategoryNode = new FirstLevelCategoryNodeDTO();
19
            firstLevelCategoryNode.setIndex(index);
20
            firstLevelCategoryNode.setCategoryId(firstLevelCategoryId);
21
            firstLevelCategoryNode.setCategoryName(firstLevelCategories.get(0).getFirstLevelCategoryName());
22
            // 变量迭代
23
            index++;
24
            List<SecondLevelCategoryNodeDTO> secondLevelCategoryNodes = buildSecondLevelCategoryNodeDTOs(firstLevelCategories);
25

26
            // 将二级数据放入一级里面
27
            firstLevelCategoryNode.setCategoryChild(secondLevelCategoryNodes);
28
            // 将一级类目放入最终结果集
29
            firstLevelCategoryTreeNodes.add(firstLevelCategoryNode);
30
        }
31
        return firstLevelCategoryTreeNodes;
32
    }

展开收起

1
 private List<SecondLevelCategoryNodeDTO> buildSecondLevelCategoryNodeDTOs(List<CategoryHierarchy> firstLevelCategories) {
2

3
        // 声明二级分类对象集合
4
        List<SecondLevelCategoryNodeDTO> secondLevelCategoryNodes = new ArrayList<>();
5

6
        // 循环获取二级分类数据
7
        Map<Long, List<CategoryHierarchy>> firstLevelCategoryChildrenMap  = firstLevelCategories.stream()
8
                .collect(Collectors.groupingBy(CategoryHierarchy::getSecondLevelCategoryId));
9

10
        // 循环遍历
11
        for (Map.Entry<Long, List<CategoryHierarchy>> secondLevelEntry  : firstLevelCategoryChildrenMap.entrySet()) {
12
            // 获取二级分类Id
13
            Long secondLevelCategoryId  = secondLevelEntry.getKey();
14
            // 获取二级分类下的所有集合
15
            List<CategoryHierarchy> secondLevelCategories  = secondLevelEntry.getValue();
16
            // 声明二级分类对象
17
            SecondLevelCategoryNodeDTO secondLevelCategoryNode = new SecondLevelCategoryNodeDTO();
18
            secondLevelCategoryNode.setCategoryId(secondLevelCategoryId);
19
            secondLevelCategoryNode.setCategoryName(secondLevelCategories.get(0).getSecondLevelCategoryName());
20

21
            List<ThirdLevelCategoryNodeDTO> thirdLevelCategoryNodes = buildThirdLevelCategoryNodes(secondLevelCategories);
22
            // 将三级类目列表放入二级类目中
23
            secondLevelCategoryNode.setCategoryChild(thirdLevelCategoryNodes);
24

25
            // 添加到二级分类集合
26
            secondLevelCategoryNodes.add(secondLevelCategoryNode);
27
        }
28
        return secondLevelCategoryNodes;
29
    }

展开收起

1
    private List<ThirdLevelCategoryNodeDTO> buildThirdLevelCategoryNodes(List<CategoryHierarchy> secondLevelCategories) {
2
        // 循环三级分类数据, 封装为ThirdLevelCategoryNodeDTO
3
        List<ThirdLevelCategoryNodeDTO> thirdLevelCategoryNodeDTOs = secondLevelCategories.stream().map(categoryHierarchy -> {
4
            ThirdLevelCategoryNodeDTO thirdLevelCategoryNode = new ThirdLevelCategoryNodeDTO();
5
            thirdLevelCategoryNode.setCategoryId(categoryHierarchy.getThirdLevelCategoryId());
6
            thirdLevelCategoryNode.setCategoryName(categoryHierarchy.getThirdLevelCategoryName());
7
            return thirdLevelCategoryNode;
8
        }).collect(Collectors.toList());
9

10
        return thirdLevelCategoryNodeDTOs;
11
    }

商品详情优化

Sun, 14 Jun 2026 00:00:00 GMT

优化思路#

在电商网站中，用户在购买一件商品之前，往往会多次浏览商品详情页，所以商品详情页的访问量通常是比较大的，所以我们需要优化商品详情页的性能。这里的性能优化，主要针对数据库的访问，因为限制系统性能的瓶颈的，往往是数据库的IO操作。

所以，我们的优化思路就是，通过引入缓存，来减少对于数据库的访问，同时为了加快对于缓存数据的访问，我们可以采用内存数据库Redis来存储缓存数据。

在引入基于Redis实现的缓存之后，对于后端数据的访问过程如下：

缓存问题分析#

但是，我们如果一旦使用了Redis缓存，随之而来，就会引出三个问题：

缓存穿透
缓存雪崩
缓存击穿

下面，我们就分别分析以上三个问题出现的场景及其解决方案。

缓存穿透#

缓存穿透是指查询数据库中不存在的数据。由于数据库中不存在，所以缓存中自然也不存在，这将导致这个不存在的数据每次请求都要到数据库中去查询。如果查询这种不存在的数据的请求量很大(比如受到了攻击)，很容易就可能导致数据库宕机。

针对缓存穿透问题的解决方案是，针对这种数据库中查询不到结果的请求，将其结果定义为null或者其他的默认值，缓存在redis中，并给该缓存结果定义一个过期时间(最长不超过5分钟)。

缓存雪崩#

缓存雪崩是指，在redis中具有过期时间的数据在同一时刻失效，导致大量的请求(就像雪崩一样)同时访问数据库，导致数据库的瞬时压力过大甚至宕机

针对缓存雪崩问题的解决方案是，在redis中给所有具有过期时间的数据，在设置过期时间时增加一个随机值，比如1-5分钟，这样每一个缓存数据的过期时间相同的概率就会降低，就很难引发集体失效的事件。

缓存击穿#

缓存击穿是指，针对单个具有过期时间的热点key数据，被高并发的请求访问的情况，如果这个热点key数据过期时间到，就会导致，针对这个热点key数据的高并发请求都访问数据库。

这里需要注意下，缓存击穿针对的是单个热点key失效的情况，而缓存雪崩针对的是大量key失效的情况。

针对缓存击穿的解决方案是，通过加锁来解决

压测工具#

为了能够模拟高并发场景，我们先来介绍一个压测工具jmeter。

Apache Jmeter是Apache组织的一个开源项目，是一个100%纯java桌面应用，它可以为目标应用模拟巨大的负载量，用以测试性能。它是一个多线程工具，允许多个线程并发取样，并支持多种不同的协议比如，HTTP，JDBC，TCP等等，可以用于多种不同的领域。

把压缩包解压之后，进入bin目录，windows操作系统双击jmeter.bat即可运行，类unix操作系统执行 sh ./jmeter.sh即可执行

启动之后我们可以，调整界面为简体中文

要发起测试，首先必须先创建一个线程组(可以理解为一个线程池)，有了这个线程组，我们就可以通过该线程组中的多个线程模拟并发请求。

同时，我们还可以自定义，线程组中的线程数，多个线程启动的时间，以及每个线程发起多少次请求

接着，我们可以在线程组中定义要发起的请求

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/jmeter http取样器.png)

在添加完请求之后，如果我们想看到请求结果，我们还需要添加查看结果树，和聚合报告。

添加完查看结果树和聚合报告之后，我们就可以在线程组中执行请求了

在查看结果树中，我们可以看到所发的几乎每一次请求对应的请求和响应

在聚合报告中，我们可以看到，对于多次请求的统计数据，通过聚合报告中的统计数据，我们可以评估接口性能

如果在请求中，我们需要添加cookie，那我们需要添加HTTP Cookie管理器

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/jmeter-http cookie管理器界面.png)

有时，我们再发起请求时，还需要添加请求头，比如发送json，需要添加ContentType: application/json，此时我们可以通过HTTP 信息头管理器来添加

锁#

本地锁#

测试单个服务实例#

继续上面的问题，为了避免发生缓存击穿的问题，所以需要访问数据库之前需要加锁，加的是什么样的锁呢？我们先使用synchronized锁对象。

在product-service中定义TestController如下：

1
@RestController
2
public class TestController {
3

4
    @Autowired
5
    TestService testService;
6

7
    @GetMapping("admin/product/lock")
8
    public Result testLock() {
9
        testService.incrWithLock();
10
        return Result.ok();
11
    }
12
}

1
public interface TestService {
2

3
    void incrWithLock();
4
}

1
@Service
2
public class TestServiceImpl implements TestService {
3

4
    @Autowired
5
    RedissonClient redissonClient;
6

7
    @Override
8
    public synchronized void incrWithLock() {
9
            RBucket<Integer> bucket = redissonClient.getBucket("number");
10
            // 获取key为number的value值
11
            int number = bucket.get();
12
            // 自增1
13
            number++;
14
            // 在放回redis
15
            bucket.set(number);
16
    }
17
}

展开收起

在测试之前，我们还要注意，需要使用redissonclient向redis中添加key为number的一个string类型的值，设置其值为0

然后，我们就可以使用jmeter发起请求来测试了

启动多个服务实例#

看起来结果是没有问题的，我们发了5000次请求，每一次给number的值自增1(初值为0)，结果为5000。但是真的就没什么问题了吗？我们分别在8216,8226两个端口在启动两个商品服务，共三个商品服务继续测试。

首先，我们需要将配置中心中配置的商品服务端口号，注释掉

接着修改原来在8206端口启动的第一个商品服务的启动配置，增加server.port启动参数

复制第一个商品服务的配置，增加server.port启动参数，让第二个服务的启动端口为8216

然后，可以在Rundashborad(高版本的IDEA中是services)中，运行这个启动配置，我们就启动了第二个商品服务

和启动第二个商品服务相同的步骤，我们可以启动第三个商品服务(启动端口8226)，这里就不在截图了

测试多个服务实例#

为了方便测试多个服务实例，我们还需要启动网关，通过网关将请求转发给商品服务集群。同时，我们还需要将redis中key为number的值改为0.

为什么当我们访问服务集群，结果就不正确了呢？

问题核心原因在于，多个服务实例中的线程，各用各的一把锁，访问共享数据时，没有实现并发请求的同步，所以导致了数据安全问题。

怎么解决这个问题呢？加锁的思路是没有问题的，但是问题的关键在于不应该加本地锁。我们应该让三个服务实例使用同一把锁，即这把锁不属于任何一个服务实例，而是独立于服务实例之外的一把锁，这把锁即分布式锁。

分布式锁#

分布式锁不存在于Java服务实例进程，那么它可以存在于哪里呢？根据分布式锁的实现方式不同，它可以存在于

MySQL中
Redis中
Zookeeper中

存在于不同的地方，就对应这不同的分布式锁的实现方式，我们最常使用的是基于Redis和基于Zookeeper的分布式锁实现方案，基于Redis实现的分布式锁性能最好，基于Zookeeper实现的分布式锁可靠性最好。在我们的项目中，我们就使用基于Redis实现的分布式锁。

基于SETNX实现#

要实现一把锁，最主要是要模拟一把锁加锁和释放锁的状态。我们可以在Redis中定义一个string类型的值，把这个值的key当做是锁的名字，于是我们可以用是否有该key对应的值，当做是锁是否上锁的状态：

key对应的value值存在，说明锁被上锁了，不能重复加锁
key对应的value值不存在，说明锁还没有被上锁，可以加锁(就是在redis中添加该key对应的value值)

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/商品详情页-setnx 加锁.png)

所以这样的加锁操作，刚刚好可以用SETNX来完成，所以可以改造我们的代码如下：

1
@Service
2
public class TestServiceImpl implements TestService {
3

4
    @Autowired
5
    RedissonClient redissonClient;
6

7
    @Override
8
    public void incrWithLock() {
9
        // 在操作Redis中的数据之前先加锁, lock:number 对应的值可以是任意的
10
        RBucket<String> lockBucket = redissonClient.getBucket("lock:number");
11
        // trySet方法等价于SETNX
12
        boolean exists = lockBucket.trySet("lockObj");
13
        if (!exists) {
14
            // 如果锁已存在，即已经加锁, 则稍后重试
15
            try {
16
                Thread.sleep(100);
17
                incrWithLock();
18
                return;
19
            } catch (InterruptedException e) {
20
                e.printStackTrace();
21
            }
22
        }
23

24
        // 如果加锁成功，则自增key number对应的值
25
        try {
26
            RBucket<Integer> bucket = redissonClient.getBucket("number");
27
            // 获取key为number的value值
28
            int number = bucket.get();
29
            // 自增1
30
            number++;
31
            // 在放回redis
32
            bucket.set(number);
33
        } finally {
34
            // 访问完数据之后，释放锁，即删除lock:number这个key
35
            lockBucket.delete();
36
        }
37

38
    }
39
}

展开收起

看起来，好像也没啥问题，但是这种实现方式有一个潜在的问题，就是如果在某一个商品服务实例中，加锁成功之后，因为某些原因，在还未释放锁之前，该实例挂了(java进程挂了)，那就意味着这把锁永远不会被释放，那么其他服务实例就再也访问不到这把锁了。

增加过期时间#

针对上述的可能存在的问题，我们可以增加一个解决方案就是，在利用SETNX加锁成功之后，给锁(给key)设置过期时间，这样一来，如果因为意外情况没有释放锁，到了锁的过期时间，其他服务实例，依然可以加锁成功。

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/setnx 增加过期时间.png)

所以，结合过期时间，我们改造代码如下：

1
@Service
2
public class TestServiceImpl implements TestService {
3

4
    @Autowired
5
    RedissonClient redissonClient;
6

7
    @Override
8
    public void incrWithLock() {
9
        // 在操作Redis中的数据之前先加锁, lock:number 对应的值可以是任意的
10
        RBucket<String> lockBucket = redissonClient.getBucket("lock:number");
11
        // trySet方法等价于SETNX
12
        boolean exists = lockBucket.trySet("lockObj", 3, TimeUnit.SECONDS);
13
        if (!exists) {
14
            // 如果锁已存在，即已经加锁, 则稍后重试
15
            try {
16
                Thread.sleep(100);
17
                incrWithLock();
18
                return;
19
            } catch (InterruptedException e) {
20
                e.printStackTrace();
21
            }
22

23
        }
24

25
        // 如果加锁成功
26
        try {
27
            RBucket<Integer> bucket = redissonClient.getBucket("number");
28
            // 获取key为number的value值
29
            int number = bucket.get();
30
            // 自增1
31
            number++;
32
            // 在放回redis
33
            bucket.set(number);
34
        } finally {
35
            // 访问完数据之后，释放锁，即删除lock:number这个key
36
            lockBucket.delete();
37
        }
38

39
    }
40
}

展开收起

以上代码如果测试是没问题的。但是这种实现方式，仍然有潜在的问题：

假设商品服务实例1先加锁成功，开始执行了，但是它执行4秒中，才会释放锁
但是过了3秒后，锁过期了，商品服务实例2加锁成功
又过了1s商品服务实例1执行完，释放锁，但是服务实例2还在执行，此时相当于没加锁

增加UUID防止误删#

所以，为了防止锁被误删，所以在加锁的时候，我们给锁key对应的value，设置为一个uuid，并保存这个uuid。在释放锁的时候，如果获取到了锁，还要看看锁的value

如果锁key对应的value和释放锁的线程锁持有的uuid是不是同一个，说明是加锁线程在释放锁没有问题
但是如果不一致，说明加锁线程和释放锁的线程不是同一个，不能释放锁

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/商品详情页增加uuid.png)

这样一来，就可以解决，锁的误删问题，代码如下

1
@Service
2
public class TestServiceImpl implements TestService {
3

4
    @Autowired
5
    RedissonClient redissonClient;
6

7
    @Override
8
    public void incrWithLock() {
9
        // 在操作Redis中的数据之前先加锁, lock:number 对应的值可以是任意的
10
        RBucket<String> lockBucket = redissonClient.getBucket("lock:number");
11
        String uuid = UUID.randomUUID().toString();
12
        // trySet方法等价于SETNX，设置锁key对应的值
13
        boolean exists = lockBucket.trySet(uuid, 3, TimeUnit.SECONDS);
14
        if (!exists) {
15
            // 如果锁已存在，即已经加锁, 则稍后重试
16
            try {
17
                Thread.sleep(100);
18
                incrWithLock();
19
                return;
20
            } catch (InterruptedException e) {
21
                e.printStackTrace();
22
            }
23

24
        }
25

26
        // 如果加锁成功
27
        try {
28
            RBucket<Integer> bucket = redissonClient.getBucket("number");
29
            // 获取key为number的value值
30
            int number = bucket.get();
31
            // 自增1
32
            number++;
33
            // 在放回redis
34
            bucket.set(number);
35
        } finally {
36
            // 不一定要在java代码里成为一个原子操作
37
            if (uuid.equals(lockBucket.get())) {
38
                // 说明是加锁线程在释放锁，可以正确释放
39
                lockBucket.delete();
40
            }
41

42
        }
43

44
    }
45
}

展开收起

但是增加uuid防止误删就完美了吗？当然不是，因为还是有可能会有问题：

假设商品服务实例1，先加锁，访问完Redis数据后，刚刚执行完uuid.equals(lockBucket.get())发现结果为true，准备释放锁了
但是在释放锁之前，刚好锁也过期了，商品服务实例2继续加锁成功
然后，商品服务实例1删除锁，测试商品服务实例2在访问Redis数据时相当于没有加锁

究其原因，就是因为判断和释放锁不是原子操作。

Redisson实现的分布式锁#

所以，我们还需要让判断和释放锁成为原子操作，怎么样让它们成为原子操作呢？用Lua脚本来实现它们即可。因为Redis的工作线程是单线程，且Lua脚本可以直接在Redis中运行，所以一段Lua脚本中运行的必然是一个原子操作。而Redisson底层，就是利用Lua脚本来加锁和释放锁的。

如果使用Redisson，则代码如下：

1
@Service
2
public class TestServiceImpl implements TestService {
3

4
    @Autowired
5
    RedissonClient redissonClient;
6

7
    @Override
8
    public void incrWithLock() {
9
        // 获取锁
10
        RLock redisLock = redissonClient.getLock("lock:number");
11
        try {
12
            // 加锁，失败会在这里阻塞
13
            redisLock.lock();
14
            // 加锁成功，代码执行到这里
15
            RBucket<Integer> bucket = redissonClient.getBucket("number");
16
            // 获取key为number的value值
17
            int number = bucket.get();
18
            // 自增1
19
            number++;
20
            // 在放回redis
21
            bucket.set(number);
22
        } finally {
23
            // 释放锁
24
            redisLock.unlock();
25
        }
26

27
    }
28
}

展开收起

为了确保分布式锁可用，我们要确保锁的实现同时满足以下四个条件：

- 互斥性。在任意时刻，只有一个客户端能持有锁。

- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

- 加锁和解锁必须具有原子性

ReentranLock

而这四个条件，Redisson实现的分布式锁都可以满足，同时Redisson实现的分布式锁，还是可重入的。

分布式锁改造获取SKU信息#

接下来，我们可以基于Redisson的分布式锁，改造getSkuInfo方法，主要基于两点：

增加缓存，将数据库中获取到的SKU信息放入缓存
当缓存中没有目标SKU信息时，加锁然后访问数据库，并将SKU信息放入缓存，最后释放锁

1
    public SkuInfoDTO getSkuInfoWithRedisson(Long skuId) {
2
        // 定义key sku:skuId:info
3
        String skuInfoKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKUKEY_SUFFIX;
4
        // 根据key获取redis中的SkuInfoDTO
5
        RBucket<SkuInfoDTO> bucket = redissonClient.getBucket(skuInfoKey);
6
        SkuInfoDTO skuInfoDTO = bucket.get();
7
        if (skuInfoDTO != null) {
8
            // 如果获取到，则直接返回
9
            return skuInfoDTO;
10
        }
11

12
        // 定义锁对应的key
13
        String lockKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKULOCK_SUFFIX;
14
        RLock redisLock = null;
15
        try {
16
            // 如果没有获取到，则获取锁
17
            redisLock = redissonClient.getLock(lockKey);
18
            //  加锁
19
            redisLock.lock();
20

21
            // 这里是做double check，因为有可能别的服务已经将该SKU数据放入到Redis中
22
            SkuInfoDTO retrySkuInfoDTO = bucket.get();
23
            if (retrySkuInfoDTO != null) {
24
                // 说明别的服务已经将SKU信息放入Redis中，我们只需要从Redis中读取数据即可
25
                return retrySkuInfoDTO;
26
            }
27
          /*
28
              1. 说明缓存中还是没有
29
              2. 而且，也没有其他服务将该SKU信息放入到Redis中，此时访问数据库
30
          */
31
            // 获取SKU基本信息
32
            SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
33
            // 根据skuId 查询图片列表集合
34
            List<SkuImage> skuImageList = skuImageMapper.getSkuImages(skuId);
35
            skuInfo.setSkuImageList(skuImageList);
36
            SkuInfoDTO skuInfoFromDB = skuInfoConverter.skuInfoPO2DTO(skuInfo);
37

38

39
            // 判断数据库中是否有该SKU
40
            if (skuInfoFromDB == null) {
41
                // 如果没有则在Redis中放入默认值，主要预防缓存穿透
42
                skuInfoFromDB = new SkuInfoDTO();
43
            }
44

45
            bucket.set(skuInfoFromDB);
46
            return skuInfoFromDB;
47

48
        } finally {
49
            if (redisLock != null) {
50
                // 释放锁
51
                redisLock.unlock();
52
            }
53
        }

展开收起

分布式锁+AOP#

我们在前面说过，商品详情页时访问量比较大的，所以我们需要给整个商品详情页的数据增加缓存(除了商品价格这种实时数据)。因此我们不仅仅需要对获取SKU基本信息的getSkuInfo方法做改造，还需要对其他获取商品详情页数据的方法做改造。

但是，无论对于哪个方法做改造，改造的逻辑几乎都是一样的，即我们需要给多个方法做增强，增加一段通用处理逻辑，此时你会想到什么呢？当然是AOP

既然要是用AOP，自然需要定义切面，但在定义切面之前，我们需要思考以下两个问题：

我们的切入点应该如何定义
我们应该使用什么样的通知类型

针对第一个问题，我们可以结合自定义注解，给需要增强的方法加自定义注解，所以我们的切入点使用@annotation注解找具有目标自定义注解的方法即可。

针对第二个问题，得根据我们的增强逻辑来决定，被增强的方法是访问数据库的，而我们的增强逻辑需要在访问数据库之前先访问缓存，如果缓存中没有，在被增强方法访问数据库之后，我们还需要将数据库中的查询结果，放入Redis，所以很显然，我们应该使用环绕通知。

![](/assets/firefly-docs/microservice/microservice-15-product-detail-optimize/aop cache.png)

所以我们可以定义自定义注解如下：

1
@Target({ElementType.METHOD})
2
@Retention(RetentionPolicy.RUNTIME)
3
public @interface RedisCache {
4

5
    // 给缓存数据增加前缀，以区分不同的缓存数据
6
    String prefix() default "cache:";
7

8
}

定义切面如下：

1
@Component
2
@Aspect
3
public class RedisCacheAspect {
4

5
    @Autowired
6
    private RedissonClient redissonClient;
7

8
    //  定义一个环绕通知！
9
    @Around("@annotation(com.cskaoyan.mall.common.cache.RedisCache)")
10
    public Object gmallCacheAspectMethod(ProceedingJoinPoint point) {
11
        //  定义一个对象
12
        Object obj = null;
13
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
14
        RedisCache redisCache = methodSignature.getMethod().getAnnotation(RedisCache.class);
15
        //   获取到注解上的前缀
16
        String prefix = redisCache.prefix();
17
        //  组成缓存的key！ 获取方法传递的参数
18
        String key = prefix + Arrays.asList(point.getArgs()).toString();
19
        RLock lock = null;
20
        try {
21
            //  可以通过这个key 获取缓存的数据
22
            obj = this.redissonClient.getBucket(key).get();
23
            if (obj != null) {
24
                // 获取到了直接返回
25
                return obj;
26
            }
27
        } catch (Exception e) {
28
            e.printStackTrace();
29
        }
30
        try {
31
            //  加锁
32
            lock = redissonClient.getLock(key + ":lock");
33
            lock.lock();
34
            Object redisData = this.redissonClient.getBucket(key).get();
35
            // double check
36
            if (redisData != null) {
37
                // 获取到了直接返回
38
                return redisData;
39
            }
40

41
            //  执行业务逻辑：直接从数据库获取数据
42
            obj = point.proceed(point.getArgs());
43

44
              // 将结果放入redis
45
            obj = putInRedis(obj, key, methodSignature);
46

47
            return obj;
48

49
        } finally {
50
            //  解锁
51
            if (lock != null) {
52
                lock.unlock();
53
            }
54
        }
55
    }
56

57
   /*
58
         将数据放入Redis缓存
59
     */
60
    private Object putInRedis(Object obj, String key, MethodSignature methodSignature) {
61
        try {
62
            if (obj == null) {
63
                //  防止缓存穿透
64
                //obj = new Object();
65
               Class returnType = methodSignature.getReturnType();
66
                if (returnType.isAssignableFrom(List.class)) {
67
                    // 返回值是Collection或List类型
68
                    obj = new ArrayList();
69
                } else if (Map.class.equals(returnType)) {
70
                    // 返回值是Map类型
71
                    obj = new HashMap();
72
                } else {
73
                    // 其他类型
74
                    Constructor declaredConstructor = returnType.getDeclaredConstructor();
75
                    declaredConstructor.setAccessible(true);
76
                    obj = declaredConstructor.newInstance();
77
                }
78
                //  将缓存的数据变为 Json 的 字符串,默认值的过期时间是1分钟
79
                this.redissonClient.getBucket(key).set(obj, RedisConst.SKUKEY_TEMPORARY_TIMEOUT, TimeUnit.SECONDS);
80
            } else {
81
                //  将缓存的数据变为 Json 的 字符串
82
                this.redissonClient.getBucket(key).set(obj, RedisConst.SKUKEY_TIMEOUT, TimeUnit.SECONDS);
83
            }
84
        } catch (Exception e) {
85
            e.printStackTrace();
86
        }
87

88
        return obj;
89
    }
90

91
}

展开收起

定义好切面后，我们可以在获取详情页数据的时候使用了

1
    @RedisCache(prefix = RedisConst.SKUKEY_PREFIX)
2
    @Override
3
    public SkuInfoDTO getSkuInfo(Long skuId) {
4
        ...
5
    }
6

7
    @RedisCache(prefix = "spuSaleAttrListCheckBySku:")
8
    @Override
9
    public List<SpuSaleAttributeInfoDTO> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {
10
     ...
11
    }
12

13
    @Override
14
    @RedisCache(prefix = "skuValueIdsMap:")
15
    public Map<String, Long> getSkuValueIdsMap(Long spuId) {
16
        ...
17
    }
18

19
    @Override
20
    @RedisCache(prefix = "categoryHierarchyByCategory3Id:")
21
    public CategoryHierarchyDTO getCategoryViewByCategoryId(Long category3Id) {
22
     ...
23
    }
24

25
    @Override
26
    @RedisCache(prefix = "SpuPosterList:")
27
    public List<SpuPosterDTO> findSpuPosterBySpuId(Long spuId) {
28
     ...
29
    }
30

31
    @RedisCache(prefix = "platformAttributeInfoList:")
32
    @Override
33
    public List<PlatformAttributeInfoDTO> getPlatformAttrInfoBySku(Long skuId) {
34
    ...
35
    }

展开收起

布隆过滤器BloomFilter#

使用场景#

缓存穿透问题，除了可以使用我们讲过的，在Redis中添加默认值并设置过期时间的方式之外，其实还有另外一种方式，就是使用布隆过滤器。

布隆过滤器有一个非常好的特征，就是能快速，可靠的帮助我们判断，某个值是否不存在于某个集合中。我们可以充分利用这一特征：

将所有在后台管理系统中添加的SKU商品的id放入到一个集合中(我们称之为所有SKU商品的skuId集合)
当处理获取SKU商品信息的请求时，我们可以取出请求中的skuId，然后利用布隆过滤器判断该skuId是否不在所有SKU商品的skuId集合，如果不在则直接返回
所以，当请求实际获取数据库中不存在的数据时，我们还是不会访问数据库，而是通过布隆过滤器拦截这样该请求

布隆过滤器及其构建过程#

那么什么是布隆过滤器呢？布隆过滤器由一个长度为n的二进制数组，和k个hash函数组成。

要构造布隆过滤器，首先得有一个长度为n的二进制数组，每个存储单元的初值为0.

紧接着，我们需要在二进制数组中，标识目标集合中的每一个元素(向布隆过滤器中添加元素)，这个过程就需要借助k个hash函数来完成了。对第m个hash函数

它会对标集合中的每个元素x做hash运算，将其映射到二进制数组中的位置i，并将第i个位置的元素值变为1
这个1表示第m个hash函数，在数组中的第i个位置，标记目标元素x存在于目标集合

一旦k个hash函数，将目标数据集合中的所有元素映射完毕，那么布隆过滤器就构建好了。

那么布隆过滤器是如何判断元素是否存在于集合中的呢？看起来很简单，就是对待判断的元素继续根据k个hash函数做hash映射，如果k个hash函数所映射到的数组元素值是否都为1。

看似很简单，但其实不然：

即使对于一个待判断的元素，即使k个hash函数映射到的数组元素的值都是1，也不能说明这个元素在目标集合中是存在的。原因很简单，hash函数还存在hash冲突。

但是反过来，对于一个待判断元素，如果至少有一个hash函数映射到的数组元素为0即映射结果为不存在，那么就一定能说明，该元素在目标集合中不存在。

所以关于关于布隆顾虑器，我们还有以下结论：

使用布隆过滤器判断元素是否存在，是有误判率的。误判率p，二进制位数组长度m，hash函数个数k, 数据规模n(元素数量) 是有关系的，可以通过公式计算，已知数据规模，误判率，可以计算二进制数组长度, 以及hash函数的个数。

对于有n个元素的集合，保证误判率<=p的情况下，二进制数组长度的可以由如下公式求得

在已知二进制数组长度m和数据元素规模n的情况下，可以求得hash函数的个数k为

布隆过滤器中的元素是不能被删除的。所谓删除就是指，把二进制数组中该元素经过k个hash函数映射的元素值设置为0。这显然是不合理的，还是因为hash冲突的问题，有可能多个元素经过hash函数映射到同一个位置。如果在二进制数组中，将这个元素的值设置为0，把其他有hash冲突的元素也删除了。

但是布隆过滤器也有自己的优点：

由于布隆过滤器只需要一个二进制数组，占用的空间是比较小的
布隆过滤器的查询和插入的效率是很高的
数据安全性高，因为不存储任何目标集合中的原始数据

使用布隆过滤器#

如果我们想要判断，一个skuId是否存在于数据库，我们只需要在构造布隆过滤器时，将目标集合变为数据库中所有的SKU商品的id集合即可。

Redisson本身对实现了基于Redis的布隆过滤器，可以非常方便的使用

1
       //  根据指定名称(key)获取布隆过滤器
2
     RBloomFilter rbloomFilter = redissonClient.getBloomFilter("xxx");
3
        // 初始化布隆过滤器，预计统计元素数量为100000，期望误判率为0.01
4
       rbloomFilter.tryInit(100000, 0.01);
5

6

7
       // 向布隆过滤器中添加目标元素
8
       rbloomFilter.add(目标元素);
9

10
       // 判断目标元素是否存在，返回false表示不存在
11
       boolen exists = rbloomFilter.contains(目标元素);

在我们的商品服务中，我们需要在服务启动的时候就执行对于布隆过滤器的初始化(即仅仅需要执行一个操作)，所以我们可以将布隆过滤器的初始化，可以使用CommandLineRunner接口

1
public interface CommandLineRunner {
2

3
  /**
4
     该方法会被SpringBoot在初始化完Spring容器之后自动调用
5
   * Callback used to run the bean.
6
   * @param args incoming main method arguments
7
   * @throws Exception on error
8
   */
9
  void run(String... args) throws Exception;
10

11
}

所以我们可以这样使用

1
/*
2
    这个BloomFilterRunner因为加了Component注解，所以会被放到Spring容器中，
3
    Spring容器初始化完毕后，该对象的run方法会被自动调用
4
*/
5
@Component
6
public class BloomFilterRunner implements CommandLineRunner {
7

8
    @Autowired
9
    RedissonClient redissonClient;
10

11
    @Override
12
    public void run(String... args) throws Exception {
13
        RBloomFilter<Long> rbloomFilter = redissonClient.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
14
        // 初始化布隆过滤器，预计统计元素数量为100000，期望误差率为0.01
15
        rbloomFilter.tryInit(100000, 0.01);
16
    }
17
}

展开收起

然后我们在上架SKU商品的时候，向布隆过滤器中添加元素

1
    @Override
2
    public void onSale(Long skuId) {
3

4
        /*
5
           ...
6
        */
7

8
        //向添加布隆过滤器添加元素
9
        RBloomFilter<Long> rbloomFilter = redissonClient.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
10
        rbloomFilter.add(skuId);
11

12
    }

在处理获取详情页商品信息的请求时，首先判断布隆过滤器中是否存在该元素，如果不存在，则直接返回默认值

1
@Override
2
    public ProductDetailDTO getItemBySkuId(Long skuId) {
3

4
        ProductDetailDTO productDetailDTO = new ProductDetailDTO();
5
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
6
        if (!bloomFilter.contains(skuId)) {
7
            // 如果不存在，则返回默认值
8
            return productDetailDTO;
9
        }
10

11
    /*
12
      ....
13
    */
14
        return productDetailDTO;
15
}

展开收起

MySQL 索引

Sun, 14 Jun 2026 00:00:00 GMT

索引的引入#

索引（Index）是数据库中一种特殊的数据结构，它用于提高数据库查询的效率和速度。在数据库中，索引类似于书籍中的目录，我们可以根据关键字快速定位到需要查看的内容所在的位置。

image-20240522023752302

在数据库中，常用的索引类型包括主键索引、唯一索引、普通索引等。不同的索引类型适用于不同的查询场景，开发人员需要根据实际需求选择合适的索引类型。

同时，在MySQL中我们如果使用不同的存储引擎，比如常见的MyISAM，InnoDB等，索引的存储方式也会有所不同

存储引擎 ·#

先来看看MySQL的架构

连接器：负责接收处理客户端的连接请求，建立连接，管理连接等工作
查询解析器：在这一步MySQL会将SQL语句解析为树，根据语法规则对语句进行验证，比如关键字是否正确，关键字顺序是否正确等等
查询优化器: 一条查询可以有很多种执行方式，最终返回相同的结果，优化器负责分析查询，评估各种可能的执行路径，并选择最有效的路径来执行该查询。这涉及到决策如何连接表、选择使用哪些索引、决定查询的执行顺序等。
执行器：执行器的功能是按照优化器提供的执行计划来执行查询。它负责实际上的数据读取、联接表、过滤行等操作。
存储引擎：数据库系统中负责数据存储和检索，在MySQL中有多种不同的存储引擎，每个存储引擎都提供了不同的存储机制、索引技术、以及加锁方式等等功能。

这里我们重点需要关注的是存储引擎，对于索引而言，不同的存储引擎其索引的实现有所差异，所以我们在提及索引的时候，都会先说明所使用的存储引擎。MySQL中提供了很多的存储引擎，常见的有InnoDB，MyISAM等，但是最常见和常用，以及MySQL默认的还是InnoDB存储引擎，所以接下来，我们主要基于InnoDB存储引擎来讲解索引。

MySQL数据的存储(InnoDB)#

实际上我们存储在MySQL中的数据，最终都是存储在磁盘中的。因此，当我们对MySQL进行查询操作的时候，会频繁读取磁盘文件内容，那么一次至少读取磁盘中的多少数据到内存呢？一次读取至少一页数据，16KB大小的内容。

image-20240522022832031

对于MySQL而言，看到的是一页一页的数据。每一页中存储的是什么数据呢？我们目前只关注表中数据，所以我们可以认为页中存储的是表中的数据。但是请注意一张表中的数据，仅一个页中就一定能存的下吗？当然不是，所以一张表中的数据，可能存储在多个不同的页中。

image-20240522022846453

所以总结一下：

页是MySQL(InnoDB)存储管理的基本单位
一页中可以存储多条数据
一张表中的数据可以存储在多个页中。
一张表对应的多个数据页会组成一个双向链表

关于页我们还需要说明的是，在MySQL中有多种不同类型的页，用来存储表中数据的页，我们称之为数据页。存储的问题搞清楚了，那么随之而来的另外一个问题是，一个数据页中存储了多条行数据，我们如何快速定位到其中的某一条目标数据呢？在MySQL的实现中，它主要是通过二分查找来实现的。但是，一张表中的数据可能存在于不同的数据页中，怎么在一张表对应的多页中快速查找到某一条记录呢？其实思路也不难：

首先定位到存储目标数据的数据页
在该页中进行二分查找(这也意味着，一页中的多行数据是有序的)

所以，快速查找到表中的一条记录的问题，就演变成了如何快速定位到目标数据页的问题了。那么如何快速定位到目标数据页呢？这就是索引要解决的问题了！

MySQL索引(InnoDB)#

接下来，我们就重点研究下InnoDB中的索引。

索引数据结构(InnoDB)#

假如有如下的一张表，我们以主键列id为条件，查询目标行数据。

1
CREATE TABLE `index_demo` (
2
  `id` int NOT NULL,
3
  `age` int DEFAULT NULL,
4
  `name` varchar(10) DEFAULT NULL,
5
  PRIMARY KEY (`id`)
6
);

假设该表中当前存储了很多数据，多到数据需要多个数据页来存储，并且在数据页中的记录以id主键值的大小排序，我们可以先自己来思考以下这个问题。如果执行如下查询：

1
select * from index_demo where id = 5;

我们如何快速查找到这条记录呢？很遗憾，目前我们只能遍历表的每一个页，在每一页中根据id主键值进行二分查找。但是很显然，因为要遍历数据页，那么查找效率不是很理想，能否实现对于数据页的二分查找，即利用二分查找的方式，快速确定目标id值所在的数据页呢？可以，但是会遇到两个问题。

第一个问题是，虽然每一页内的数据按照主键id值有序的，但是不同页之间记录的id主键值可能并没有固定的大小顺序。所以，我们可以在添加一个约束，让下一页的记录的id值都比上一页的记录的id值大，这样一来，页与页之间也变得有序了，我们就可以用类似的思路对页进行二分查找，如何对页进行二分查找呢？如图，如果我们记录每个数据页中，id的最小值，那么在进行二分查找的时候我们可以这样判断：

如果待查找的id值大于当前页A中的的最小id值
同时，待查找的id值小于下一页B的最小id值
这时就可以确定待查找的id值对应的数据在当前页A中

第二个问题是，因为在MySQL中分配给一张表的多个页可能物理上并不连续，它们以双向链表的形式串联起来，如图所示：

显然我们无法直接在一个双向链表上实现二分查找，但是如何实现二分查找的效果呢？这也难不倒我们，我们只需要将所有的数据页的最小值，集中到一个数据页中即可，所以我们需要完成如下步骤：

为每一页创建一条目录项记录，目录项记录中只需要记录每一页的最小id值，以及该页的页号
将每一页对应的目录项都存储在一个数据页中
保证存储在数据页中的目录项也按照id值排序

这样一来我们在查找的时候

首先访问目录页中的目录项，做二分查找
判断如果某个目录项的id值小于待查找的id值，且待查找的id值小于后一个目录项的id值，比如 1 < 5 < 51
那么待查找的id值就在该目录项所在的页中。

因为现在数据页中也会存放目录项记录了，所以为了好区分，我们称存储目录项的页为目录页，称存储行数据的页为普通数据页。(这种说法并非官方说法)

但是这样就可以了吗? 当然还是不行，因为一张表包含的普通数据页数量可能很多，多到什么程度呢？多到一个目录页都放不下普通数据页对应的目录项了，此时，我们的目录项就需要存储在多个目录页中，并且这些目录页之间继续用双向链表串联起来。这样一来存储目录项的问题解决了，但是还能对目录页中的目录项记录做二分查找吗？还是不行，原因有两个：

目录页内的目录项记录根据id有序，但是目录页之间无序
无法直接对链表做二分查找

所以为了实现对目录页中的目录项的二分查找，先来解决第一个问题保证：

首先已知目录页中的目录项是有序的(根据id值有序)
在此基础上在施加约束，即上一个目录页的目录项id值，小于下一目录页的所有目录项id值

其次，再来解决第二个问题，为每一个目录页创建对应的目录项记录，并保存在数据页中即可(即普通数据页的目录页的目录页)：

每一个目录页对应的目录项记录中只需要存储每一目录页的最小id值，以及该目录页的页号
每一个目录页对应的目录项都存储在一个数据页中
保证页中的目录项按照id值排序，如图所示

因为这个新的数据存储的是目录页对应的目录项，所以我们称这个数据页为目录页的目录页(非官方说法)

这样一来，我们在查询的时候，就可以按照如下流程来完成：

在目录页对应的目录页中快速定位到某个目录页的目录项，并找到该目录项对应的目录页
然后在目录页中继续二分查找，就可以找到目标数据对应的目录项，并找到目录项对应的普通数据页
再在普通数据页中做二分查找，就可以找到对应的目标行数据了

接下来，有同学可能还会有疑惑，那目录页的目录项也很多，多到一个数据页放不下呢？其实和之前一模一样的思路，依次类推即可，于是就形成了如下的结构：

这不就是一颗树的形状嘛，更准确的来说，其实它就是一颗B+树！这样的一颗B+树，就对应的一个索引，通过它可以快速定位到目标数据。

需要注意的是：

在这颗B+树索引中，树中节点都是数据页
用来存储真正的表中数据的数据页我们称它们为B+树中的叶子节点
用来存储目录项记录的节点，我们称之为非叶子节点，或者内节点
所有的叶子节点都在同一层，且组成了一个双向链表，我们称该层位第0层

总结一下，在数据库表中查找一条记录的过程，如果有索引的话，其实就转化成了在B+树从根节点，到叶子节点的一次访问过程。但是，因为每访问B+树中的一个节点都需要进行一次磁盘IO，所以B+树的高度就决定了从根到叶的一次访问过程中所进行的IO次数，从这一点上来说，使用B+树作为索引也是很合适的，相比于我们非常熟悉的平衡二叉树，B+树作为一颗平衡多叉树，大大降低了树的高度，从而减少IO次数，所以一般来说MySQL中B+树索引的高度不会超过4层！

聚簇索引(InnoDB)#

我们上面根据主键列的值所创建的那颗B+树，即主键列索引就是聚簇索引。对于数据库中我们定义的所有表，MySQL都会自动根据主键列创建一颗的B+树索引，即聚簇索引，聚簇索引具有两个非常重要的特征：

首先，索引即数据。即聚簇索引这颗B+树，即是一个索引，而且还包含了表中每一行的完整的数据，这里可以和我们前面讲的书和目录的例子做一个类比，一本书的目录并未包含书中任何一页的完整内容，它只是帮我们快速定位到某一页的真正内容。如果把书的目录当做索引，那么它就和我们的聚簇索引不同了，因为聚簇索引的叶子节点中(普通数据页)，就存储了表中的每一行完整数据！

其次，索引中的数据都以主键值排序，表现在：

普通数据页和目录页内存储的数据，按照主键值排序
如果分层来看，那么每一层的数据页，都按照id值有序

还有同学可能会有疑惑，如果对于一张表而言，没有定义主键那这张表是不是就没有聚簇索引了呢？并不是，如果一张表没有定义主键，那么MySQL或做如下工作：

会为当前表中添加了NOT NULL 和UNIQUE域约束的列创建聚簇索引
如果既没有定义主键，也没有定义了NOT NULL和UNIQUE的列，那么MySQL会自动生成一个名为row_id的隐藏列，MySQL保证该列的值在一张表中不会重复。
然后根据row_id这一列的值创建聚簇索引

聚簇索引非常重要，每张表都具有聚簇索引，且其叶子节点中存储着表中数据！

image-20240706020259468

二级索引(InnoDB)#

讲完了聚簇索引，当我们根据id值进行查询的时候，可以根据聚簇索引快速找到目标行。但是，如果我们的查询条件不是主键值，而是其他列的值，还可以用到聚簇索引来实现快速的查询吗？答案当然是否定的，因为聚簇索引只根据id值有序，从而构造出了id值有序的B+树。

有同学可能马上就要问了，只有根据主键值查询才能用到索引吗？当然不是，因为一张表可以具有多个索引，我们可以根据需要，创建除主键列以外的其他列的B+树索引，这样的索引我们称之为二级索引。比如，我们可以对age列创建索引，如图所示

这颗根据age列所创建的B+树索引(二级索引)，与聚簇索引相比，有如下区别:

首先，索引非数据。在这颗二级索引B+树的叶子节点(普通数据页)，并没有存储完整的表中行数据，而是仅仅存储了该行数据的索列的值(age值) + 该行数据的主键值

其次，二级索引中的数据都是根据索引列age的值来排序，具体表现在:

叶子结点，即普通数据页和目录项数据页内的条数据，按照age列的值有序
分层来看，每层数据页也按照age列有序

最后，对于我们创建的任何一张表而言，聚簇索引永远只会有一个，但是二级索引，我们可以根据需要创建多个！

接下来，我们看看如下的SQL，模拟根据age列创建的二级索引，执行查询的过程。

1
select * from index_demo where age = 14;

查询过程如下:

先找到根节点所在的页面即页16，经过二分查找确定，age值为14的记录对应的目录项记录所在的页为72(12 < 15 < 80)
然后再到页72中，确定age为14的数据所在的普通数据页为100(对应的目录项没画出来，但是可以推出来)
然后再到页100中，在页内通过二分查找，找到age值为14的行数据 (age为14的行数据可能有多条)

但是很遗憾，在二级索引中即使我们找到了age值为14某条记录，但里面仅仅只存储了age为14的这行所对应的主键值，但是我们用的是select * 的方式来查询的，怎么办呢？很简单，我们只需要根据已知的主键值，在去聚簇索引中查询一次就可以得到完整的行数据了。

在二级索引中根据条件查询到目标行数据的主键值之后，如果需要获取完整的行数据，就需要根据从二级索引中得到的主键值在去查询一次聚簇索引，这一过程我们称之为回表。一般来说，根据二级索引查询，但是又需要查询出完整的行数据，都需要进行回表操作。

联合索引#

前面讲过的索引，都是以单列的值作为排序规则创建的B+树索引，我们同时也可以以多个列的大小作为排序规则，同时为多个列建立索引，这种索引我们称之为联合索引。比如我们可以同时为age列和name列创建索引，其比较规则如下:

先根据第一列age的值比较大小
age列值相同，再根据name列的值比较大小

根据以上的比较规则，我们可以创建如图所示的联合索引：

image-20240520021340652

需要注意的是：

上面以age和name两列所创建的联合索引，因为也是非主键列索引，所以也属于二级索引
在联合索引B+树的叶节点中，存储的表中每行数据对应所有索引列值(age, name)以及对应的id主键列的值
在所有的目录页中的目录项主要包含所有索引列(age,name)的值和的目录项对应的页号
以上的联合索引是同时根据age和name两列创建的一颗B+树索引，但是如果我们要分别根据age列和name列创建B+树索引，那创建出的是两个不同的B+树索引

在以上联合索引中，我们可以模拟以下查询语句的查找过程:

1
select * from index_demo where age=15 and name='bd'

首先找到联合索引B+树的根节点，先比较age列的值，age列的值相同，在比较name列的值，确定满足条件的记录所对应的目录项记录所在的页号为50 ( 12 < 15 < 80)
找到目录项所在的目录页，在进行二分查找（ 12 < 15 < 50）,确定数据页页号为45
在页45中，先比较age的值，从而找到所有满足条件的记录，这里需要注意的是，在age值相同时，记录会按照name列的值排序，因此name相同的记录紧邻。
所以在满足age条件的记录集合中，在根据name条件进行判断，快速最终找到满足条件的记录集合
巧合的是，因为我们创建的表很简单，在这个联合索引叶节点中刚好包含了完整的行数据，所以不用在执行回表操作

MyISAM 索引#

前面我们介绍的都是InnoDB存储引擎中的索引方案，这也是我们实际开发中最常用的。但是鉴于面试中可能会提及，所以我们在给大家简单介绍下MyISAM存储引擎的索引方案。

我们知道在InnoDB存储引擎中的索引方案有一个特征，索引即数据，因为每张表都会自动创建聚簇索引。而MyISAM存储引擎的索引方案虽然也使用树形结构，但是却是将索引和数据分开存放的。

首先对于每一张表中所有的行数据，都会按照数据的插入顺序，一行一行的放入到一个文件中，这个文件称之为数据文件。在这个文件中，每一行数据都有一个唯一的行号，如图所示：

image-20240522022942439

MyISAM会将表的索引存储到另外一个索引文件中，和InnoDB类似MyISAM也会为自动根据每张表的主键，自动创建索引，只不过索引的叶子节点中存储的不是完整的用户记录，而是该记录在数据文件中所对应的行号 + 主键值。所以在该索引中查询的时候，需要先查询主键索引，然后做一次类似于InnoDB中的回表操作，才能查询到完整的行数据，这就意味着如果做一个类比的话，在MyISAM存储引擎中所创建的所有的索引，都相当于InnoDB中的二级索引

如果有需要的话，我们完全可以对其他列分别建立索引或者联合索引，原理和InnoDB中的B+树索引差不多，唯一的区别是叶子节点处，存储的是索引列的值 + 数据文件行号。

当然，在理解了以上MyISAM存储引擎特征之后，我们需要再声明一点，在MyISAM存储引擎中创建的索引的叶子节点中存储的并不一定是对应的数据文件中的行号，这还要看数据文件中存储行数据使用的是什么格式：

如果是定长格式，即每一行占用的存储空间大小相同，则索引叶节点存储行号
否则如果不是定长格式，即不同的行数据占用的存储空间大小不同，则索引叶子节点存储每行数据对应的地址偏移量

除了索引实现的区别之外，它们还有如下主要的区别:

InnoDB 支持事务处理，而MyISAM不支持事务，因此MyISAM更适合于只读数据或者在数据完整性要求不高的场合使用。
InnoDB支持行级锁，但是MyISAM只支持表级锁
InnoDB提供了崩溃恢复机制，但是MyISAM缺少崩溃恢复机制

索引的使用(InnoDB)#

在学习了InnoDB的索引原理之后，可以得到一个结论，如果在查询的时候，可以用到索引，可能会显著的提高查询效率。接下来，就有一个问题了，是不是索引创建的越多越好呢？当然不是

从空间上来说，我们每创建一个索引，就会生成一颗新的B+树，一颗B+树中可能包含很多节点，而每一个节点都对应一个默认16KB大小的数据页，所以一颗B+树会占用大量的存储空间。

从时间上来说

对表中的数据做任何增删改的操作，都需要在聚簇索引，以及对应的所有二级索引做出相应的修改，会一定程度影响增删改的效率
不论是B+树中的叶子节点，还是非叶子节点中的记录都是按照索引列值来排序的，而增删改操作往往会破会这个顺序，所以存储引擎为了维护这个顺序，需要额外做一些记录的移位，页面的分裂等操作，即需要付出一定的代价

所以，我们为一张表创建的索引越多，占用的存储空间就越大，增删改的效率就越低。为了能创建又少又好用的索引，接下来我们需要研究一下索引的应用场景。

为了更好举例说明，我们创建如下的一张表：

1
CREATE TABLE `user` (
2
  `id` int NOT NULL AUTO_INCREMENT,
3
  `name` varchar(10) DEFAULT NULL,
4
  `birthday` date DEFAULT NULL,
5
  `point` bigint DEFAULT NULL,
6
  `city` varchar(20) DEFAULT NULL,
7
  PRIMARY KEY (`id`),
8
  index `idx_name_birthday_city` (`name`,`birthday`,`city`) # 给name,birthday,city创建联合索引
9
);

在这张user表中有两个索引，一个聚簇索引一个联合索引，所以我们会有两颗B+树，其中联合索引的如图:

再次强调，大家一定要注意，在此联合索引的B+树中，不管是目录页还是普通数据页中，记录的排序规则：

先按照姓名排序(字符串字典序)
姓名相同在根据生日日期大小排序
姓名和出生日期都相同，再根据城市排序(字符串字典序)

查询中的使用#

接下来，我们给大家分析一下索引通常在查询中使用的一些典型场景。

全值匹配#

如果我们的搜索条件中的列和索引列一致，且指定每一列的精确值，这种查询就称为全值匹配，比如下面的查询：

1
select * from user where name='aq' and birthday='2002-10-10' and city='北京'
2

3
select * from user where name='aq'and city='北京'  and birthday='2002-10-10'

该SQL语句的查询条件中包含了idx_name_birthday_city索引中的所有索引列，我们可以模拟以上查询过程：

在联合索引的B+树上，从根节点出发先根据name条件定位到第一个满足name=‘aq’条件的第一条记录
因为idx_name_birthday_city首先根据name列的值排序，所以name值相同的记录紧邻，所以从满足name=‘aq’的第一条记录开始，依次向后遍历，直到找到所有name=‘aq’的记录
然后，因为对于name=‘aq’的所有记录，在联合索引中会根据birthday排序，birthday值相同的记录同样会紧邻，所以接下来可以快速在满足name=‘aq’的集合中，得到满足同时满足birthday=‘2010-01-10’的记录
满足name=‘aq’且birthday=‘2010-01-10’条件的记录，在联合索引中会根据city列的值排序，所以city值相同的记录也会紧邻，所以在其中，可以快速定位到所有city=‘北京’的记录

有同学可能会有疑问，对于全值匹配而言，条件的书写顺序，必须和索引列中定义的顺序相同吗？其实不用，因为MySQL优化器会分析这些搜索条件，并且按照可以使用的索引中列的顺序来决定先使用哪个搜索条件

细心的同学一定发现了，其实到这里我们的查询还没有结束，因为我们只是在idx_name_birthday_city中查询到了满足条件的记录，但是这些记录中并未包含point列的值，而我们使用的查询语法为select *，所以接下来，我们还需要回表，根据idx_name_birthday_city中查询到的主键id值，去聚簇索引中查询出所有满足条件的完整行数据。

匹配左边的列(最左前缀)#

其实在我们的搜索语句中也可以不用包含全部联合索引中的列，只包含联合索引中左边连续列就行，比方说下边的查询语句：

1
SELECT * FROM user WHERE name = 'aq';

或者包含多个左边的列也行：

1
SELECT * FROM user WHERE name = 'aq' AND birthday = '2002-10-10';

有同学可能马上就要问了，那为什么搜索条件中必须出现左边的列才可以使用到这个 B+ 树索引呢？比如下边的语句就用不到这个B+树索引么？

1
SELECT * FROM user WHERE birthday = '2002-10-10';

是的，的确用不到。因为B+树的数据页和目录页中的记录是先按照 name 列的值排序的，在name 列的值相同的情况下才使用 birthday列进行排序，也就是说 name 列的值不同的记录中 birthday 的值可能是无序的，这就意味着birthday列值相同的记录并不会紧邻，且无法使用二分查找

我们需要特别注意的：如果我们想使用联合索引中尽可能多的列，搜索条件中的各个列必须是联合索引中从最左边连续的列

比如以下查询条件，就能用到name列的索引

1
SELECT * FROM user WHERE name = 'zs' AND city = '武汉'

关于这个例子我们需要注意的是：

根据name列的查询条件，是可以用到idx_name_birthday_city索引的，因为无论数据页还是目录页中的记录都根据name列有序
但是，city列的查询条件无法使用联合索引中的city索引列，因为在只有在birthday相同的情况下，idx_name_birthday_city索引的city列才是有序的

匹配列前缀(针对字符串)#

其实，为某个列建立索引的意思就是在对应的B+ 树的记录中使用该列的值进行排序。比如说联合索引idx_name_birthday_city会先用name列的值排序，所以这个联合索引对应的B+树记录中的 name 列排列如下：

1
aq
2
aq
3
aqg
4
axl
5
bbb
6
ccc
7
zzz
8
...

name的值是字符串类型，所以其实name列是根据字符串比较规则排序，一般来说，我们认为字符串根据字典序排序，其排序特征为：

先按照字符串的第一个字符进行排序。
如果第一个字符相同再按照第二个字符进行排序。
如果第二个字符相同再按照第三个字符进行排序，依此类推。

也就是说这些字符串的前n个字符，也就是前缀都是排好序的，所以对于字符串类型的索引列来说，我们只匹配它的前缀也是可以快速定位记录的。比如说我们想查询名字以 ‘a’ 开头的名字，那就可以这么写查询语句：

1
 SELECT * FROM user WHERE name LIKE 'a%';

需要注意的是，如果只给出后缀或者中间的某个字符串，比如这样：

1
SELECT * FROM user WHERE name LIKE '%a%';
2

3
SELECT * FROM user WHERE name LIKE '%a';

MySQL 就无法快速定位记录位置了，因为字符串中间或后缀有 ‘a’ 的字符串并没有排好序，所以只能全表扫描了。

但是有时候我们有一些匹配某些字符串后缀的需求，比方说某个表有一个 url 列，该列中存储了许多url：

1
 www.baidu.com
2
 www.google.com
3
 www.github.com
4
 ...
5
 www.stackoverflow.com
6
 www.redis.cn
7
 www.redis.io

假设已经对该 url 列创建了索引，如果我们想查询以 com 为后缀的网址的话可以这样写查询条件，

1
WHERE url LIKE '%com'

但是这样的话无法使用该 url 列的索引。怎么办呢？其实我们可以把表中的数据全部逆序存储一下

1
com.baidu.www
2
com.google.www
3
com.github.www
4
 ...
5
com.stackoverflow.www
6
cn.redis.www
7
io.redis.www

1
WHERE url LIKE 'com%'

这样一来，就可以把后缀查询改写成前缀查询，使用到索引了。

范围匹配#

继续看idx_name_birthday_city索引，如果只看name一列的话，所有记录都是按照name索引列的值从小到大的顺序排好序的，这就极大的方便了我们，在name值的某个范围内查找目标记录，比如：

1
SELECT * FROM user WHERE name > 'aq' AND name < 'ww';

在idx_name_birthday_city B+树索引中，其查找过程大致如下:

找到 name 值为 aq 的最后一条记录A。
找到 name 值为 ww 的第一条记录B。
取出（A, B）范围的所有记录，并根据记录中的主键值回表

这里需要注意的是，由于所有记录都是由链表连起来的（页内的记录有序，数据页之间用双链表连接且有序），所以他们之间的记录都可以获取到

但是，如果对多个列同时进行范围查找的话，只有对索引最左边的那个列进行范围查找的时候才能用到 B+ 树索引中对应的索引列，比如下面的SQL语句

1
SELECT * FROM user WHERE name > 'a' AND name < 'ww' AND birthday > '2000-01-01';

以上的查询可以分成两个部分：

通过条件 name > ‘a’ AND name < ‘ww’ 来对 name 进行范围，查找的结果可能有多条 name值不同的记录
对这些 name 值不同的记录继续通过 birthday > ‘1980-01-01’ 条件继续过滤

这样一来，对于联合索引 idx_name_birthday_city来说，只能用到 name 列的索引部分，而用不到 birthday 索引列的部分，原因是：

只有 name 值相同的情况下才能用 birthday 列的值进行排序，
而这个查询中通过 name 进行范围查找的记录中可能并不是按照 birthday 列进行排序的
所以在搜索条件中继续以 birthday 列进行查找时是用不到这个B+树birthday索引列。

精确匹配 + 范围匹配#

对于同一个联合索引来说，虽然我们上面说，对多个列都进行范围查找时只能用到最左边那个索引列，但是如果左边的列是精确查找，则右边的列可以进行范围查找，比如如下的SQL语句

1
SELECT * FROM user WHERE name = 'aq' AND birthday > '2000-01-01' AND birthday
2
< '2000-12-31' AND city = '北京';

这个查询可以分成三个部分来看：

name = ‘aq’ ，对 name 列进行精确查找，当然可以使用联合索引了
birthday > ‘2000-01-01’ AND birthday< ‘2000-12-31’ 由于 name 列是精确查找，所以满足 name = ‘aq’ 条件的记录会再按照 birthday 的值进行排序。所以此时对 birthday 列进行范围查找是可以用到联合索引birthday索引列。
city = ‘北京’，通过 birthday 的范围查找的记录的 birthday 的值可能不同，所以这个条件无法再利用 B+ 树索引了，只能遍历上一步查询得到的记录。

同理，下边的查询也是可能用到 idx_name_birthday_city联合索引的：

1
SELECT * FROM user WHERE name = 'aq' AND birthday = '2002-10-10' AND city like '北%';

回表的代价#

下面我们以idx_name_birthday_city 这颗B+树索引为例，研究回表的代价，假设有如下SQL语句：

1
SELECT * FROM user WHERE name > 'a' AND name < 'ww'

该查询的执行大致可以分为两步：

从索引 idx_name_birthday_city 对应的 B+ 树中取出 name 值在 a～ ww之间的记录
因为使用select * 所以还需要根据上一步获得的每一条记录的主键值回表，查询出完整的行数据

对于InnoDB存储引擎来说，索引中的页数据都存放在磁盘的文件中，同时，B+树的页节点会使用双向链表连接起来，页与页之间可以不必紧邻。但是在实际实现中，InnoDB还是会尽可能的让一颗B+树的叶子节点物理紧邻。而叶子节点本身按照name列排序，这也就是说，在读取name值在(‘a’, ‘ww’)范围内的记录时，我们所读取的页面在磁盘上也是尽可能紧邻的，这意味着在扫描二级索引idx_name_birthday_city (‘a’, ‘ww’)时，执行的IO大部分都是顺序IO，相对来说IO代价会小一些。

但是，在(‘a’, ‘ww’)内的主键值，却是毫无规律可言的，因此执行回表操作时，但是由于主键值不连续，因此其页面所在的位置可能页毫无规律，因此会造成大量的随机IO。

一般情况下，顺序I/O比随机I/O的性能高很多，所以步骤1的相对较快，而步骤2相对较慢，所以这个使用索引 idx_name_birthday_city的查询有这么两个特点：

会使用到两个B+ 树索引，一个二级索引，一个聚簇索引。
访问二级索引使用顺序I/O ，访问聚簇索引使用随机I/O

需要回表的记录越多，使用二级索引的性能就越低，甚至当回表操作很多的时候，查询优化器宁愿让某些查询使用全表扫描也不使用二级索引。比方说 name 值在（a～ ww）之间的用户记录数量占全部记录数量90%以上，那么如果使用 idx_name_birthday_city 索引的话，有90%多的 id 值需要回表，还不如直接去扫描聚簇索引（也就是全表扫描)。

那什么时候采用全表扫描的方式，什么时候使用采用二级索引 + 回表的方式去执行查询呢？这是由查询优化器决定的，查询优化器会事先对表中的记录计算一些统计数据，然后再利用这些统计数据根据查询的条件来计算一下需要回表的记录数，需要回表的记录数越多，就越倾向于使用全表扫描，反之倾向于使用二级索引 + 回表的方式。当然优化器做的分析工作不仅仅是这么简单，但是大致如此。

一般情况下，限制查询获取较少的记录，会让优化器更倾向于选择使用二级索引 + 回表的方式进行查询，因为回表的记录越少，性能提升就越高，比如说上边的查询可以改写成这样：

1
SELECT * FROM user WHERE name > 'a' AND name < 'ww'  LIMIT 10;

添加了 LIMIT 10 的查询更容易让优化器采用二级索引 + 回表的方式进行查询。

覆盖索引#

为了彻底告别回表操作带来的性能损耗，我们建议：最好在查询列表里只包含索引列，比如如下SQL：

1
SELECT name, birthday, city FROM user WHERE name > 'a' AND name < 'ww'

因为我们只查询 name , birthday , city这三个索引列的值，而它们已经被包含在idx_name_birthday_city索引中，所以就不必到聚簇索引回表，就减少了回表操作带来的性能损耗。

我们把这种只需要用到二级索引的查询方式称为索引覆盖。当然，如果业务需要查询出索引以外的列，那还是以保证业务需求为重。但是我们很不鼓励用 * 号作为查询列表，最好把我们需要查询的列依次标明。

在排序中的使用#

我们在写查询语句的时候经常需要对查询出来的记录通过 ORDER BY 子句按照某种规则进行排序。一般情况下，我们只能把记录都加载到内存中，再用一些排序算法，比如快速排序、归并排序等等排序算法在内存中对这些记录进行排序，有的时候可能查询的结果集太大以至于不能在内存中进行排序的话，还可能暂时借助磁盘的空间来存放中间结果，排序操作完成后再把排好序的结果集返回到客户端。

在 MySQL中，把这种在内存中或者磁盘上进行排序的方式统称为文件排序（英文名： filesort ），跟文件这个词儿一沾边儿，就会使得这些排序操作非常慢了。

但是如果ORDER BY子句里使用到了我们的索引列，就有可能省去在内存或文件中排序的步骤，比如下边这个简单的查询语句：

1
SELECT * FROM user ORDER BY name, birthday, city LIMIT 10;

这个查询的结果集需要先按照 name 值排序，如果记录的 name 值相同，则需要按照 birthday 来排序，如果 birthday 的值相同，则需要按照 city排序。这不是和我们的 idx_name_birthday_city索引的的排序规则相同吗，所以直接从索引中提取数据，然后进行回表操作取出该索引中不包含的列就好了，所以大大提升了排序效率

需要说明的是，对于排序而言，之前讨论对于采用全表扫描还是二级索引 + 回表的方式进行查询的讨论在排序中仍然适用。由于上面的查询列表是 * ，所以如果使用二级索引进行排序的话，需要把排序完的二级索引记录全部进行回表操作，这样操作的成本还不如直接遍历聚簇索引然后再进行文件排序（ filesort ）低，所以优化器可能会倾向于使用全表扫描的方式执行查询。如果我们加了 LIMIT 子句

联合索引注意事项#

如果我们想在排序的时候使用到联合索引，我们就一定要注意ORDER BY 的子句后边的列的顺序也必须按照索引列的顺序给出，如果给出 ORDER BY city, birthday, name 的顺序，那也是用不了联合索引，这种颠倒顺序就不能使用索引的原因与B+树的排序顺序有关系，这就不赘述了。

同理， ORDER BY name 、 ORDER BY name, birthday 这种匹配索引左边的列的形式可以使用部分的 B+ 树索引。当查询条件中使用了对联合索引左边列的精确值匹配，也可以使用后边的列进行排序，比如这样：

1
SELECT * FROM user WHERE name = 'aq' ORDER BY birthday, city LIMIT 10;

这个查询能使用联合索引进行排序是因为name 列的值相同的记录是按照 birthday , city排序的。

无法使用索引的情况#

在以下的几种情况下，在排序时是无法使用到索引的

ASC DESC混用#

对于使用联合索引进行排序的场景，我们要求各个排序列的排序顺序是一致的，也就是要么各个列都是 ASC 规则排序，要么都是 DESC 规则排序。

为什么会有这样的规定呢？这个还得回头想想这个 idx_name_birthday_city 联合索引中记录的排序规则：

先按照记录的 name 列的值进行升序排列。
如果记录的 name 列的值相同，再按照 birthday 列的值进行升序排列。
如果记录的name和birthday 列的值相同，再按照 city列的值进行升序排列。

如果查询中的各个排序列的排序顺序是一致的，比方说下边两这种情况：

1
// 情况1
2
SELECT * FROM user ORDER BY name, birthday LIMIT 10
3
// 情况2
4
SELECT * FROM user ORDER BY name DESC, birthday DESC LIMIT 10

情况1直接从索引的最左边开始往右读10行记录就可以了，情况2直接从索引的最右边开始往左读10行记录就可以了。

但是如果我们查询的需求是先按照 name 列进行升序排列，再按照 birthday 列进行降序排列的话，比如如下查询语句：

1
SELECT * FROM user ORDER BY name, birthday DESC LIMIT 10

这样如果使用索引排序的话过程就是这样的：

先从索引的最左边确定 name 列最小的值，然后找到 name 列等于该值的所有记录，然后从 name 列等于该值的最右边的那条记录开始往左找10条记录。
如果 name 列等于最小的值的记录不足10条，再从左继续往右找 name 值第二小的记录，重复上边那个过程，直到找到10条记录为止。

这样不能高效使用索引，而要采取更复杂的算法去从索引中取数据，还不如直接文件排序来的快！

排序列包含非同一个索引的列#

有时候用来排序的多个列不是一个索引里的，这种情况也不能使用索引进行排序，比如如下SQL语句：

1
SELECT * FROM user ORDER BY name, point LIMIT 10

name 和 point 并不属于一个联合索引中的列，所以无法使用索引进行排序。

排序列使用了复杂的表达式#

要想使用索引进行排序操作，必须保证索引列是以单独列的形式出现，而不是修饰过的形式，比如如下SQL：

1
SELECT * FROM user ORDER BY UPPER(name) LIMIT 10;

这里的UPPER是MySQL中的函数，使用了 UPPER 函数修饰过的列就不是单独的列啦，这样就无法使用索引进行排序啦。

在分组中的使用#

有时候我们为了方便统计表中的一些信息，会把表中的记录按照某些列进行分组。比如下边这个分组查询：

1
 SELECT name, birthday, city, COUNT(*) FROM user GROUP BY name, birthday, city

这个查询语句相当于做了3次分组操作：

先把记录按照 name 值进行分组，所有 name 值相同的记录划分为一组。
将每个 name 值相同的分组里的记录再按照 birthday 的值进行分组，将 birthday 值相同的记录放到一个小分组里，所以看起来就像在一个大分组里又化分了好多小分组。
再将上一步中产生的小分组按照 city的值分成更小的分组，所以整体上看起来就像是先把记录分成一个大分组，然后把大分组分成若干个小分组，然后把若干个小分组再细分成更多的小小分组。

然后针对那些小小分组进行统计，比如在我们这个查询语句中就是统计每个小小分组包含的记录条数。如果没有索引的话，这个分组过程全部需要在内存里实现。

而有了索引的话，如果恰巧这个分组顺序又和我们的 B+树中的索引列的顺序是一致的，而我们的 B+ 树索引又是按照索引列排好序的，所以可以直接使用 B+ 树索引进行分组。和使用 B+ 树索引进行排序其实是一个道理，分组列的顺序也需要和索引列的顺序一致，也可以只使用索引列中左边的列进行分组。

索引的语法#

在MySQL中我们可以定义单列索引，也可以定义包含多列的索引(即联合索引)。

如果在创建表的时候定义索引，可以基于如下语法：

1
CREATE TABLE 表名 (
2
    ...
3
  [UNIQUE] INDEX 索引名称 (column1, column2, ...)
4
    ...
5
)
6
# 索引名称我们习惯上通常定位idx_索引列名1_索引列名2...
7
# 括号中的索引列可以是一列也可以是多列，如果是多列，列名之间以,分隔

如果在定义索引时添加了UNIQUE关键字，则该索引就变成了唯一索引，有如下效果：

如果索引列是单列的话，那么该单列的值在索引中不能重复（其实也就限定了在表中不能重复）
如果索引列是多列，即联合索引，那么各索引列的取值组合不能重复（其实也就限定了在表中这些列的取值组合不能重复）

我们也可以在创建表之后，通过修改表结构，给表添加索引

1
# 添加索引
2
ALTER TABLE 表名 ADD INDEX 索引名(列名1,列名2, ...);
3
# 添加唯一索引
4
ALTER TABLE 表名 ADD UNIQUE 索引名(列名1,列名2, ...);

我们也可以在创建索引后删除索引:

1
ALTER TABLE 表名 DROP INDEX 索引名;

如何挑选索引#

对于单列索引的查询和使用都比较简单，大家只要理解了B+树索引即可掌握，所以我们主要是针对联合索引的在MySQL使用进行了介绍，接下来我们重点研究，在实际开发时索引的使用。

只为特殊目的创建索引#

只为用于搜索、排序或分组的列创建索引，也就是说只为

出现在 WHERE 子句中的列
连接子句中的连接列 (连接的时候也可以使用到索引)
或者出现在 ORDER BY 或 GROUP BY 子句中的列创建索引。

而出现在查询列表中的列就没必要建立索引了：

1
SELECT birthday, city FROM user WHERE name = 'aq';

像查询列表中的 birthday 、 city这两个列就不需要建立索引，我们只需要为出现在 WHERE 子句中的 name 列创建索引就可以了。

考虑列的基数#

列的基数指的是某一列中不重复数据的个数，比方说某个列包含值 2, 5, 8, 2, 5, 8, 2, 5, 8 ，虽然有 9 条记录，但该列的基数却是 3 。也就是说，在记录行数一定的情况下，列的基数越大，该列中的值越分散，列的基数越小，该列中的值越集中。

这个列的基数指标非常重要，直接影响我们是否能有效的利用索引。假设某个列的基数为 1 ，也就是所有记录在该列中的值都一样，那为该列建立索引是没有用的，因为所有值都一样就无法排序，无法进行快速查找了. 而且如果某个建立了二级索引的列的重复值特别多，那么使用这个二级索引查出的记录还可能要做回表操作，这样性能损耗就更大了。

所以结论就是：最好为那些列的基数大的列建立索引，为基数太小列的建立索引效果可能不好。

索引列的类型尽量小#

我们在定义表结构的时候要显式的指定列的类型，以整数类型为例，有 TINYINT 、 MEDIUMINT 、 INT 、 BIGINT 这么几种，它们占用的存储空间依次递增，当然，这几种数据类型能表示的整数范围当然也是依次递增

如果我们想要对某个整数列建立索引的话，在表示的整数范围允许的情况下，尽量让索引列使用较小的类型，比如我们能使用 INT 就不要使用 BIGINT ，能使用 MEDIUMINT 就不要使用 INT。这是因为

数据类型越小，在查询时进行的比较操作越快（CPU层次）
数据类型越小，索引占用的存储空间就越少，在一个数据页内就可以放下更多的记录，从而减少磁盘 I/O 带来的性能损耗，也就意味着可以把更多的数据页缓存在内存中，从而加快读写效率。
这个建议对于表的主键来说更加适用，因为不仅是聚簇索引中会存储主键值，其他所有的二级索引的节点处都会存储一份记录的主键值，如果主键适用更小的数据类型，也就意味着节省更多的存储空间和更高效的 I/O 。

使用索引列前缀（针对字符串）#

我们知道一个字符串其实是由若干个字符组成，如果我们在 MySQL 中使用 utf8 字符集去存储字符串的话，编码一个字符需要占用 1~3 个字节。假设我们的字符串很长，那存储一个字符串就需要占用很大的存储空间。

在我们需要为这个字符串列建立索引时，那就意味着在对应的 B+ 树中有这么两个问题：

B+ 树索引中的记录需要把该列的完整字符串存储起来，而且字符串越长，在索引中占用的存储空间越大。
如果 B+ 树索引中索引列存储的字符串很长，那在做字符串比较时会占用更多的时间。

我们前边说过索引列的字符串前缀其实也是排好序的，所以索引的设计者提出了一个方案，只对字符串的前几个字符进行索引也就是说在二级索引的记录中只保留字符串前几个字符。这样在查找记录时虽然不能精确的定位到记录的位置，但是能定位到相应前缀所在的位置，然后根据前缀相同的记录的主键值回表查询完整的字符串值，再对比就好了。

这样，只在 B+ 树中存储字符串的前几个字符的编码，既节约空间，又减少了字符串的比较时间，还大概能解决排序的问题，何乐而不为，比方说我们在建表语句中只对 name 列的前5个字符进行索引可以这么写：

1
CREATE TABLE `user` (
2
  `id` int NOT NULL AUTO_INCREMENT,
3
  `name` varchar(10) DEFAULT NULL,
4
  `birthday` date DEFAULT NULL,
5
  `point` bigint DEFAULT NULL,
6
  `city` varchar(20) DEFAULT NULL,
7
  PRIMARY KEY (`id`),
8
  KEY `idx_name_birthday_city` (`name`(5),`birthday`,`city`)
9
);

name(5) 就表示在建立的 B+ 树索引中只保留记录的前5个字符的编码，这种只索引字符串值的前缀的策略是我们非常鼓励的，尤其是在字符串类型能存储的字符比较多的时候

但是，需要注意的是如果使用了索引列前缀，比方说前边只把 name 列的前5个字符放到了二级索引中，下边这个排序可能就有点儿问题了：

1
SELECT * FROM user ORDER BY name LIMIT 10;

因为二级索引中不包含完整的 name 列信息，所以无法对前5个字符相同，后边的字符不同的记录进行排序，也就是使用索引列前缀的方式无法支持使用索引排序，只能使用filesort文件排序。

索引列在表达式中单独出现#

假设表中有一个整数列 int_column，我们为这个列建立了索引。下边的两个 WHERE 子句虽然语义是一致的，但是在效率上却有差别：

1
 1. WHERE int_column * 3 < 60
2
 2. WHERE int_column < 60 / 3

第1个 WHERE 子句中 int_column列并不是以单独列的形式出现的，而是以 int_column* 3 这样的表达式的形式出现的，存储引擎会依次遍历所有的记录，计算这个表达式的值是不是小于 60 ，所以这种情况下是使用不到为 int_column列建立的 B+ 树索引的。
而第2个 WHERE 子句中 int_column列并是以单独列的形式出现的，这样的情况可以直接使用 B+ 树索引。

所以结论就是：如果索引列在比较表达式中不是以单独列的形式出现，而是以某个表达式，或者函数调用形式出现的话，是用不到索引的。

主键插入顺序#

我们知道，对于一个使用 InnoDB 存储引擎的表来说，在我们没有显式的创建索引时，表中的数据实际上都是存储在聚簇索引的叶子节点的。

而记录又是存储在普通数据页中的，普通数据页中的记录又是按照记录主键值从小到大的顺序进行排序，所以

如果我们插入的记录的主键值是依次增大的话，那我们每插满一个数据页就换到下一个数据页继续插，
而如果我们插入的主键值忽大忽小的话，这就比较麻烦了，假设某个数据页存储的记录已经满了，它存储的主键值在 1~100 之间：

image-20240522023002921

假设此时我们需要向数据页中插入主键值为7的一行数据，如图所示:

image-20240522023019293

可这个数据页已经满了啊，再插进来咋办呢？InnoDB需要把当前页面分裂成两个页面，把本页中的一些记录移动到新创建的这个页中。页面分裂和记录移位意味着什么？意味着：性能损耗！所以如果我们想尽量避免这样无谓的性能损耗，最好让插入的记录的主键值依次递增，这样就不会发生这样的性能损耗了。

所以我们建议：为了让主键依次递增我们可以使用 AUTO_INCREMENT，或者使用其他方式(雪花算法)生成依次递增的主键。

消除冗余和重复索引#

很多时候，我们会有意或者无意地创建同一个列的多个不同索引，比如如下的建表语句:

1
CREATE TABLE `user` (
2
  `id` int NOT NULL AUTO_INCREMENT,
3
  `name` varchar(10) DEFAULT NULL,
4
  `birthday` date DEFAULT NULL,
5
  `point` bigint DEFAULT NULL,
6
  `city` varchar(20) DEFAULT NULL,
7
  PRIMARY KEY (`id`),
8
  KEY `idx_name_birthday_city` (`name`(5),`birthday`,`city`),
9
  KEY 'idx_name'(`name`(5))
10
);

我们知道，通过 idx_name_birthday_city 索引就可以对 name 列进行快速搜索，再创建一个专门针对 name 列的索引就算是一个冗余索引，维护这个索引只会增加维护的成本，并不会对搜索有什么好处。

另一种情况，我们可能会对某个列重复建立索引，比如如下建表语句：

1
CREATE TABLE repeat_demo (
2
 id INT PRIMARY KEY,
3
 age INT,
4
 UNIQUE uidx_id (c1),
5
 INDEX idx_id (c1)
6
);

我们看到， id 既是主键、又给它定义为一个唯一索引，还给它定义了一个普通索引，可是主键本身就会生成聚簇索引，所以定义的唯一索引和普通索引是重复的，这种情况要避免。

总结#

这里我们最主要的是给大家介绍了InnoDB的B+树索引(聚簇索引，二级索引，联合索引)，在充分理解了B+树索引的基础上，我们有给大家讲解了索引在InnoDB查询，排序，分组中的使用，最后讲解了我们应该如何选择使用索引。

通过以上的讲解，大家应该能更加深刻的理解，索引尤其在加速查询过程中的作用。正因为如此，基于我们以上所讲的索引原理，一些常见的SQL优化规则我们就可以理解了，比如:

不建议查询时使用select *
所谓的最左前缀匹配原则
查询条件中，建议索引列单独出现(不出现在方法调用，以及运算表达式中)
排序中的多列顺序与联合索引列一致(如果有的话)
排序不建议ASC，DESC混用
建议保持主键列递增
在满足业务需要的前提下，尽量创建联合索引

…

除此之外，我们还应该知道，如果已经发现一个SQL语句执行较慢，如何在SQL语句层面优化？

首先，加快查询我们应该马上想到索引，先看看该SQL语句的查询条件所涉及的列是否创建索引，若没有则可以添加索引
但是，如果发现查询条件涉及到的列已经添加了索引，此时我们就需要判断，本次查询是否走了索引(这种情况大部分是没有走索引的)然后做相应调整，那么问题来了，我们怎么知道查询有没有走索引呢？可以通过MySQL提供的explain工具，其语法如下:

1
explain 查询语句

MySQL中的查询，都是经过查询优化器最终决定的查询计划执行的，而explain可以输查询语句执行时的执行计划，通过查看执行计划，就可以判断查询的执行过程，也可以看到查询过程中的索引使用情况，如图:

比如，针对某个查询，通过其possible_keys列的值，可以看到该查询可能使用到的索引，key列的值表示该查询实际使用的索引等等，这些信息，我们都可以从explain的执行计划输出中看到。

Elasticsearch-1

Sun, 14 Jun 2026 00:00:00 GMT

引例#

现在假设我们有如下的一张数据库表

现在假设我们有一个需求是从这张表中搜索“手机”或者“华为手机”的相关信息，我们会怎么做？

1
select * from product where name like "%手机%";
2
select * from product where name like "%华为手机%";

但是针对这张表，我们如果直接通过以上SQL语句来查询，会存在两个问题:

针对单表的全表扫描效率低
关系数据库中提供的查询功能弱

思考一下，我们的一个电商网站中，有上百万商品数据，如果我们采用like的方式，去实现商品搜索的功能，其效率是非常低下的，同时由于用户输入的商品关键字是比较随意的，使用like的方式往往也很难真正查询到用户想要的商品。

ES介绍及基本概念#

在很多场景下，比如电商网站的商品搜索，我们都需要使用全文检索的功能查询所需的内容，那么如何高效的实现全文检索的功能呢？解决之道就在于Elastic Search：

ElasticSearch是一个基于Lucene的分布式、高扩展、高实时的基于RESTful 风格API的搜索与数据分析引擎

1
RestFUL风格的API：
2
    1. 发送JSON数据，返回JSON响应
3
    2. 请求的类型就代表了对资源的操作类型
4
      GET: 查询
5
        POST: 修改
6
        DELETE：删除
7
        PUT：新增

为什么Elastic Search能够实现大规模数据场景下的高效全文检索呢？主要是因为在ES中，数据的存储和组织方式与关系数据库不同。

我们首先需要了解ES中的基本概念：

字段(Field): 一个字段表示一个属性，类比于数据库表中的属性，数据库中的一行数据通常是多个属性值组成
文档(document)：在ES中数据的存储和关系数据库不同，所有的数据都是以文档的JSON document的形式存在，document是ES中索引和搜索的最小的数据单位，类比于数据库中的一行数据，通常有多个字段值组成
映射(mapping): mapping定义了document中每个字段的类型、字段所使用的分词器等。相当于关系型数据库中的表结构。
索引（index): ElasticSearch存储数据的地方，可以理解成关系型数据库中的数据库概念，存放一类相同或者类似的document，比如一个员工索引，商品索引。
类型(Type)：逻辑上的数据分类，一种type就像一张表。如用户表、角色表等。在Elasticsearch6.X默认type为_doc，es 7.x中删除了type的概念

在了解了ES的基本概念之后，接下来，我们可以大致解释下，为何ES可以实现高效的全文检索功能，其中一个很重要的原因是ES使用了倒排索引(这里要注意的一点是，倒排索引和文档的存储本身没有关系，只是为了快速的全文检索，针对document的一个或者多个字段，所创建的索引)

那么什么是倒排索引呢？为了理解什么是倒排索引，我们先来理解正排索引。针对以下3条document文档数据所创建的正排索引如下：

凡是索引其本质都是在建立一种映射关系
无论是正排索引还是倒排索引，在创建索引时都是要对目标字段的值进行分词的。
正排索引，建立的是文档的唯一标识Id(内容所在位置) ——> 文档目标字段内容的映射

如果我们是基于正向索引来查找和“华为手机”相关的商品信息(根据商品的title字段的值来匹配)，首先对搜索的关键字也会做分词处理，比如分解为”华为”和”手机”两个关键词，然后遍历，每一个文档，和将关键词和文档中的分词内容进行匹配，此时，我们可以查找到我们所需要的华为手机的相关商品信息。

但是，使用正向索引我们仍然无法避免，遍历每一个商品对应的文档(“类似全表扫描”)，这种匹配方式，效率比较低下。接下来，我们换种方式，基于倒排索引，来实现搜索。

反向索引是以文段目标字段所有可能的分词结果为key，其value表达的是，包含改词的文档Id(即文档位置)
通过对比可知，反向索引表达的是文档字段内容 ——> 包含该内容的文档位置(文档Id)的映射

如果我们，基于倒排索引，来查找和关键字“华为手机”相关的商品，那么很显然，我们很容易就可以查询出想要的结果，并且还不需要，遍历每一个商品信息。同理，ES在搜索时就是基于倒排索引，所以它的搜索性能很好。

ES及可视化客户端安装#

ElasticSearch安装#

参考环境搭建文档

kibana安装#

参考环境搭建文档

Restful API操作ES#

ES虽然是基于Java语言开发的，但它的使用却不仅仅局限于Java语言，因为ES对外提供了Restful风格的API，我们可以通过这些Restful风格的API向ES发送请求，从而操作ES。

操作索引#

创建索引

1
PUT http://ip:端口/索引名称

查询索引

1
GET http://ip:端口/索引名称  # 查询单个索引信息
2
GET http://ip:端口/索引名称1,索引名称2...  # 查询多个索引信息
3
GET http://ip:端口/_all  # 查询所有索引信息

删除索引

1
DELETE http://ip:端口/索引名称

•关闭、打开索引

1
POST http://ip:端口/索引名称/_close
2
POST http://ip:端口/索引名称/_open
3

4

5
# 如果一个索引是关闭的状态，那么这个索引中的文档是不能被搜索的；但是如果一个索引是关闭的状态，索引本身的信息还是可以查询的

数据类型#

简单数据类型#

我们先来看一个简单的映射定义：

1
PUT teacher/_mapping
2
{
3
    "properties": {
4
      "id": {
5
        "type": "integer"
6
      },
7
      "name": {
8
        "type": "text"
9
      },
10
      "isMale": {
11
        "type": "boolean"
12
      }
13
    }
14
}

在定义映射的时候，类比于定义数据库中的表结构，我们需要指明每一个字段的名称，数据类型等等信息，所以我们先得了解映射中包含的数据类型。

字符串

1
text：会分词，不支持聚合
2
keyword：不会分词，将全部内容作为一个词条，支持聚合

数值：long, integer, short, byte, double, float, half_float, scaled_float
布尔：boolean
二进制：binary
范围类型

1
integer_range, float_range, long_range, double_range, date_range

日期

复杂数据类型#

•数组：[ ] 没有专门的数组类型，ES会自动处理数组类型数据

•对象：{ } Object: object(for single JSON objects 单个JSON对象)

操作映射#

添加映射

1
 #添加映射
2
 PUT student/_mapping
3
 {
4
   "properties":{
5
     "name":{
6
       "type":"text"
7
     },
8
     "age":{
9
       "type":"integer"
10
     }
11
   }
12
 }
13

14
#查询映射
15
 GET studnt/_mapping

展开收起

创建索引并添加映射

1
 #创建索引并添加映射
2
 PUT teacher
3
{
4
  "mappings": {
5
    "properties": {
6
      "name": {
7
        "type": "text"
8
      },
9
      "age": {
10
        "type": "integer"
11
      }
12
    }
13
  }
14
}
15

16
# 查询映射
17
GET teacher/_mapping

展开收起

添加字段

1
#添加字段
2
PUT teacher/_mapping
3
{
4
  "properties": {
5
      "name": {
6
        "type": "text"
7
      },
8
      "age": {
9
        "type": "integer"
10
      }
11
    }
12
}
13

14
# 查询映射
15
GET teacher/_mapping

展开收起

操作文档#

•添加文档，指定id

1
POST teacher/_doc/2
2
{
3
  "name":"张三",
4
  "age":18,
5
  "address":"北京"
6
}
7

8
GET /teacher/_doc/2

•添加文档，不指定id

1
#添加文档，不指定id，自动生成
2
POST teacher/_doc/
3
{
4
  "name":"张三",
5
  "age":18,
6
  "address":"北京"
7
}
8

9
#查询所有文档
10
GET /teacher/_search

修改文档（全量覆盖）

1
POST teacher/_doc/2
2
{
3
  "name":"张三",
4
  "age":18,
5
  "address":"北京"
6
}

修改文档(只修改部分)

1
POST teacher/_update/2
2
{
3
  "doc": {
4
    "name": "李四"
5
  }
6
}

删除文档

1
#删除指定id文档
2
DELETE teacher/_doc/1

分词器#

对于Elastic Search而言，在生成倒排索引时，需要对文档字段分词，在搜索时，还需要对搜索关键字进行分词，分词的工作是由分词器来完成的，但是很遗憾，ES中默认使用的分词器，对中文支持的并不好，会对中文逐字拆分。所以对于中文内容的分词，我们通常会采用，对中文支持比较好的IK分词器。

IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包，基于Maven构建，具有60万字/秒的高速处理能力，并且支持用户词典扩展定义。

IK分词器的安装#

参考环境搭建文档

IK分词器的使用#

IK分词器有两种分词模式：ik_max_word和ik_smart模式。

1、ik_max_word

会将文本做最细粒度的拆分，比如会将“好好学习, 天天向上”拆分为“好好学习，好好学、好好、好学、学习、天天向上、天天，向上。

1
#方式一ik_max_word
2
GET _analyze
3
{
4
  "analyzer": "ik_max_word",
5
  "text": "好好学习, 天天向上"
6
}

ik_max_word分词器执行如下：

1
{
2
  "tokens" : [
3
    {
4
      "token" : "好好学习",
5
      "start_offset" : 0,
6
      "end_offset" : 4,
7
      "type" : "CN_WORD",
8
      "position" : 0
9
    },
10
    {
11
      "token" : "好好学",
12
      "start_offset" : 0,
13
      "end_offset" : 3,
14
      "type" : "CN_WORD",
15
      "position" : 1
16
    },
17
    {
18
      "token" : "好好",
19
      "start_offset" : 0,
20
      "end_offset" : 2,
21
      "type" : "CN_WORD",
22
      "position" : 2
23
    },
24
    {
25
      "token" : "好学",
26
      "start_offset" : 1,
27
      "end_offset" : 3,
28
      "type" : "CN_WORD",
29
      "position" : 3
30
    },
31
    {
32
      "token" : "学习",
33
      "start_offset" : 2,
34
      "end_offset" : 4,
35
      "type" : "CN_WORD",
36
      "position" : 4
37
    },
38
    {
39
      "token" : "天天向上",
40
      "start_offset" : 6,
41
      "end_offset" : 10,
42
      "type" : "CN_WORD",
43
      "position" : 5
44
    },
45
    {
46
      "token" : "天天",
47
      "start_offset" : 6,
48
      "end_offset" : 8,
49
      "type" : "CN_WORD",
50
      "position" : 6
51
    },
52
    {
53
      "token" : "向上",
54
      "start_offset" : 8,
55
      "end_offset" : 10,
56
      "type" : "CN_WORD",
57
      "position" : 7
58
    }
59
  ]
60
}

展开收起

2、ik_smart 会做最粗粒度的拆分，比如会将“好好学习, 天天向上”拆分为好好学习、天天向上。

1
#方式二ik_smart
2
GET _analyze
3
{
4
  "analyzer": "ik_smart",
5
  "text": "好好学习, 天天向上"
6
}

ik_smart分词器执行如下：

1
{
2
  "tokens" : [
3
    {
4
      "token" : "好好学习",
5
      "start_offset" : 0,
6
      "end_offset" : 4,
7
      "type" : "CN_WORD",
8
      "position" : 0
9
    },
10
    {
11
      "token" : "天天向上",
12
      "start_offset" : 5,
13
      "end_offset" : 9,
14
      "type" : "CN_WORD",
15
      "position" : 1
16
    }
17
  ]
18
}

展开收起

指定分词器查询文档#

文档的查询可以分为两种查询方式:

•词条查询（term）：词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索

•全文查询（match）：全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

准备工作如下：

创建索引，添加映射，并指定分词器为ik分词器

1
PUT member
2
{
3
  "mappings": {
4
    "properties": {
5
      "name": {
6
        "type": "keyword"
7
      },
8
      "address": {
9
        "type": "text",
10
        "analyzer": "ik_max_word"
11
      }
12
    }
13
  }
14
}

添加文档

1
POST member/_doc/1
2
{
3
  "name":"zs",
4
  "age":18,
5
  "address":"武汉市洪山区"
6
}
7

8
POST member/_doc/2
9
{
10
  "name":"lisi",
11
  "age":18,
12
  "address":"武汉市"
13
}
14

15
POST /member/_doc/3
16
{
17
  "name":"ww",
18
  "age":18,
19
  "address":"武汉黄陂"
20
}

展开收起

查询映射

1
GET member/_search

4.查看分词效果

1
GET _analyze
2
{
3
  "analyzer": "ik_max_word",
4
  "text": "武汉市洪山区"
5
}

下面分别采用两种方式查询，分词都是用IK分词器：

词条查询：term

查询member中匹配到”武汉”两字的词条

1
GET member/_search
2
{
3
  "query": {
4
    "term": {
5
      "address": {
6
        "value": "武汉"
7
      }
8
    }
9
  }
10
}

全文查询：match

全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

1
GET member/_search
2
{
3
  "query": {
4
    "match": {
5
      "address":"武汉黄陂"
6
    }
7
  }
8
}

Java 操作ES#

我们仍然基于SpringBoot工程，首先引入依赖

1
    <parent>
2
        <groupId>org.springframework.boot</groupId>
3
        <artifactId>spring-boot-starter-parent</artifactId>
4
        <version>2.7.17</version>
5
    </parent>
6

7
        <!-- springboot-->
8
        <dependency>
9
            <groupId>org.springframework.boot</groupId>
10
            <artifactId>spring-boot-starter</artifactId>
11
        </dependency>
12

13
        <!-- springboot test-->
14
        <dependency>
15
            <groupId>org.springframework.boot</groupId>
16
            <artifactId>spring-boot-starter-test</artifactId>
17
        </dependency>
18

19

20

21
<!--引入es的坐标-->
22
        <dependency>
23
            <groupId>org.elasticsearch.client</groupId>
24
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
25
            <version>7.8.0</version>
26
        </dependency>
27
        <dependency>
28
            <groupId>org.elasticsearch.client</groupId>
29
            <artifactId>elasticsearch-rest-client</artifactId>
30
            <version>7.8.0</version>
31
        </dependency>
32
        <dependency>
33
            <groupId>org.elasticsearch</groupId>
34
            <artifactId>elasticsearch</artifactId>
35
            <version>7.8.0</version>
36
        </dependency>

展开收起

定义ES配置类

1
@Configuration
2
@ConfigurationProperties(prefix="elasticsearch")
3
public class ElasticSearchConfig {
4

5
    private String host;
6

7
    private int port;
8

9
    public String getHost() {
10
        return host;
11
    }
12

13
    public void setHost(String host) {
14
        this.host = host;
15
    }
16

17
    public int getPort() {
18
        return port;
19
    }
20

21
    public void setPort(int port) {
22
        this.port = port;
23
    }
24
    @Bean
25
    public RestHighLevelClient client(){
26
        return new RestHighLevelClient(RestClient.builder(
27
                new HttpHost(host,port,"http")
28
        ));
29
    }
30
}

展开收起

准备好测试类

1
@SpringBootTest(classes = ESApplication.class)
2
class ElasticsearchDay01ApplicationTests {
3
    @Autowired
4
    RestHighLevelClient client;
5

6
    @Test
7
    public void test() {
8
        System.out.println(client);
9
    }
10
}

创建索引#

1.添加索引

1
/**
2
    * 添加索引
3
    * @throws IOException
4
    */
5
   @Test
6
   public void addIndex() throws IOException {
7
      //1.使用client获取操作索引对象
8
       IndicesClient indices = client.indices();
9
       //2.具体操作获取返回值
10
       //2.1 设置索引名称
11
       CreateIndexRequest createIndexRequest=new CreateIndexRequest("member");
12

13
       CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
14
       //3.根据返回值判断结果
15
       System.out.println(createIndexResponse.isAcknowledged());
16
   }

展开收起

2.添加索引，并添加映射

1
 /**
2
     * 添加索引，并添加映射
3
     */
4
    @Test
5
    public void addIndexAndMapping() throws IOException {
6
       //1.使用client获取操作索引对象
7
        IndicesClient indices = client.indices();
8
        //2.具体操作获取返回值
9
        //2.具体操作，获取返回值
10
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("member");
11
        //2.1 设置mappings
12
        String mapping = "{\n" +
13
                "      \"properties\" : {\n" +
14
                "        \"address\" : {\n" +
15
                "          \"type\" : \"text\",\n" +
16
                "          \"analyzer\" : \"ik_max_word\"\n" +
17
                "        },\n" +
18
                "        \"age\" : {\n" +
19
                "          \"type\" : \"long\"\n" +
20
                "        },\n" +
21
                "        \"name\" : {\n" +
22
                "          \"type\" : \"keyword\"\n" +
23
                "        }\n" +
24
                "      }\n" +
25
                "    }";
26
        createIndexRequest.mapping(mapping,XContentType.JSON);
27

28
        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
29
        //3.根据返回值判断结果
30
        System.out.println(createIndexResponse.isAcknowledged());
31
    }

展开收起

查询、删除、判断索引#

查询索引

1
    /**
2
     * 查询索引
3
     */
4
    @Test
5
    public void queryIndex() throws IOException {
6
        IndicesClient indices = client.indices();
7
        GetIndexRequest getRequest=new GetIndexRequest("member");
8
        GetIndexResponse response = indices.get(getRequest, RequestOptions.DEFAULT);
9
        Map<String, MappingMetaData> mappings = response.getMappings();
10
        for (String key : mappings.keySet()) {
11
            System.out.println(key+":"+mappings.get(key).getSourceAsMap());
12
        }
13
    }

删除索引

1
 /**
2
     * 删除索引
3
     */
4
    @Test
5
    public void deleteIndex() throws IOException {
6
         IndicesClient indices = client.indices();
7
        DeleteIndexRequest deleteRequest=new DeleteIndexRequest("member");
8
        AcknowledgedResponse delete = indices.delete(deleteRequest, RequestOptions.DEFAULT);
9
        System.out.println(delete.isAcknowledged());
10

11
    }

索引是否存在

1
 /**
2
     * 索引是否存在
3
     */
4
    @Test
5
    public void existIndex() throws IOException {
6
        IndicesClient indices = client.indices();
7

8
        GetIndexRequest getIndexRequest=new GetIndexRequest("member");
9
        boolean exists = indices.exists(getIndexRequest, RequestOptions.DEFAULT);
10

11

12
        System.out.println(exists);
13

14
    }

添加文档#

1.添加文档,使用map作为数据

1
 @Test
2
    public void addDoc1() throws IOException {
3
        Map<String, Object> map=new HashMap<>();
4
        map.put("name","zs");
5
        map.put("age","18");
6
        map.put("address","武汉市洪山区");
7
        IndexRequest request=new IndexRequest("member").id("1").source(map);
8
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
9
        System.out.println(response.getId());
10
    }

2.添加文档,使用对象作为数据

1
@Test
2
public void addDoc2() throws IOException {
3
    Person person=new Person();
4
    person.setId("2");
5
    person.setName("lisi");
6
    person.setAge(18);
7
    person.setAddress("武汉");
8
    String data = JSON.toJSONString(person);
9
    IndexRequest request=new IndexRequest("member").id(person.getId()).source(data,XContentType.JSON);
10
    IndexResponse response = client.index(request, RequestOptions.DEFAULT);
11
    System.out.println(response.getId());
12
}

修改、查询、删除文档#

1.修改文档：添加文档时，如果id存在则修改(全量修改)，或者做增量修改

1
    /**
2
     * 修改文档：添加文档时，如果id存在则修改，id不存在则添加
3
     */
4

5
    @Test
6
    public void UpdateDoc() throws IOException {
7
        Person person=new Person();
8
        person.setId("2");
9
        person.setName("ww");
10
        person.setAge(20);
11
        person.setAddress("长城");
12

13
        String data = JSON.toJSONString(person);
14

15
        IndexRequest request=new IndexRequest("member").id(person.getId()).source(data,XContentType.JSON);
16
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
17
        System.out.println(response.getId());
18
    }

展开收起

1
    /*
2
       增量修改，只修改文档的一部分
3
    */
4
    @Test
5
    public void update() throws IOException {
6
        // 构造修改请求，修改member索引中，_id值为1的文档
7
        UpdateRequest updateRequest = new UpdateRequest("member", "100023501");
8

9
        // 准备修改的字段以及字段值
10
        HashMap<String, Object>  fieldMap = new HashMap<>();
11
        // 假设只修改age字段的值
12
        fieldMap.put("age", 100);
13

14
        updateRequest.doc(fieldMap);
15
        UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
16
        System.out.println(update.status());
17
    }

展开收起

3.根据id查询文档

1
    /**
2
     * 根据id查询文档
3
     */
4
    @Test
5
    public void getDoc() throws IOException {
6

7
        //设置查询的索引、文档
8
        GetRequest indexRequest=new GetRequest("member","1");
9

10
        GetResponse response = client.get(indexRequest, RequestOptions.DEFAULT);
11
        System.out.println(response.getSourceAsString());
12
    }

4.根据id删除文档

1
/**
2
     * 根据id删除文档
3
     */
4
    @Test
5
    public void delDoc() throws IOException {
6

7
        //设置要删除的索引、文档
8
        DeleteRequest deleteRequest=new DeleteRequest("member","1");
9

10
        DeleteResponse response = client.delete(deleteRequest, RequestOptions.DEFAULT);
11
        System.out.println(response.getId());
12
    }

Elasticsearch-2

Sun, 14 Jun 2026 00:00:00 GMT

Elastic Search 高级操作#

昨天我们学习了，对于Elastic Search基本的索引，映射，文档相关的增删改查操作。但是对于Elastic Search还有一些更为复杂的高级操作。

批量操作#

通过批量操作，我们可以一次向Elastic Search发送多条增删改操作。从而达到一定程度上节省带宽的目的

基本语法#

先来看通过脚本的方式执行批量操作：

1
# 准备工作定义索引，及其映射
2
PUT teacher
3
{
4
  "mappings": {
5
    "properties": {
6
    "id": {"type": "long"},
7
    "name": {"type": "text"},
8
    "age": {"type": "integer"}
9
   }
10
  }
11
}

批量操作脚本

1
#批量操作
2
#删除1号
3
#新增2号
4
#更新2号
5
POST _bulk
6
{"create": {"_index": "teacher", "_id": "2"}}
7
{"name": "南风", "age": 18}
8
{"update": {"_index": "teacher", "_id": 2}}
9
{"doc": {"name":"景天", "age": 19}}
10
{"delete": {"_index":"teacher", "_id": "1"}}

接着我们使用JAVA API执行批量操作

1
 /**
2
     *  Bulk 批量操作
3
     */
4
    @Test
5
    public void test2() throws IOException {
6

7
        //创建bulkrequest对象，整合所有操作
8
        BulkRequest bulkRequest =new BulkRequest();
9

10
           /*
11
        # 1. 删除1号记录
12
        # 2. 添加2号记录
13
        # 3. 修改2号记录 名称为 “景天”
14
         */
15
        //添加对应操作
16
        //1. 删除1号记录
17
        DeleteRequest deleteRequest=new DeleteRequest("teacher","1");
18
        bulkRequest.add(deleteRequest);
19

20
        //2. 添加2号记录
21
        Map<String, Object> map=new HashMap<>();
22
        map.put("name","南风");
23
        IndexRequest indexRequest=new IndexRequest("teacher").id("2").source(map);
24
        bulkRequest.add(indexRequest);
25
        //3. 修改3号记录 名称为 “景天”，年龄为19
26
        Map<String, Object> mapUpdate=new HashMap<>();
27
        mapUpdate.put("name","景天");
28
        UpdateRequest updateRequest=new UpdateRequest("teacher","2").doc(mapUpdate);
29

30
        bulkRequest.add(updateRequest);
31
        //执行批量操作
32
        BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
33
        System.out.println(response.status());
34

35
    }

展开收起

批量从数据库导入数据#

创建索引和映射

1
PUT product
2
{
3
  "mappings": {
4
    "properties": {
5
      "id":{"type": "long"},
6
      "image": {"type":  "keyword"},
7
      "status": {"type": "integer"},
8
      "sellPoint": {
9
        "type": "text",
10
        "analyzer": "ik_max_word"
11
      },
12
      "title": {
13
        "type": "text",
14
        "analyzer": "ik_max_word"
15
      },
16
      "num":{"type": "integer"},
17
      "tmName": {"type": "keyword"},
18
      "cid": {"type": "long"},
19
      "price": {"type": "double"},
20
      "limitNum": {"type": "integer"},
21
      "created": {"type": "date"},
22
      "updated": {"type": "date"}
23
    }
24
  }
25
}

展开收起

代码实现从数据库批量将数据导入Elastic Search

1
 /**
2
     * 从Mysql 批量导入 elasticSearch
3
     */
4
    @Test
5
    public void test3() throws IOException {
6
        //1.查询所有数据，mysql
7
        List<Item> products = productMapper.findAll();
8

9
        //2.bulk导入
10
        BulkRequest bulkRequest=new BulkRequest();
11

12
        //2.1 循环goodsList，创建IndexRequest添加数据
13
        for (Item item : items) {
14

15
            //将product对象转换为json字符串
16
            String data = JSON.toJSONString(item);
17
            IndexRequest indexRequest=new IndexRequest("product").source(data,XContentType.JSON);
18
            bulkRequest.add(indexRequest);
19

20
        }
21

22

23
        BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
24
        System.out.println(response.status());
25

26
    }

展开收起

高级查询#

match all 查询#

match all查询，相当于不加查询条件的查询索引中所有的文档

1
GET product/_search
2
{
3
  "query": {
4
    "match_all": {}
5
  },
6
  "from": 0,
7
  "size": 100
8
}

1
/**
2
     * 查询所有
3
     *  1. matchAll
4
     *  2. 将查询结果封装为Goods对象，装载到List中
5
     *  3. 分页。默认显示10条
6
     */
7
    @Test
8
    public void matchAll() throws IOException {
9

10
        //2. 构建查询请求对象，指定查询的索引名称
11
        SearchRequest searchRequest=new SearchRequest("product");
12

13
        //4. 创建查询条件构建器SearchSourceBuilder
14
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
15

16
        //6. 查询条件
17
        QueryBuilder queryBuilder= QueryBuilders.matchAllQuery();
18
        //5. 指定查询条件
19
        sourceBuilder.query(queryBuilder);
20

21
        //3. 添加查询条件构建器 SearchSourceBuilder
22
        searchRequest.source(sourceBuilder);
23
        // 8 . 添加分页信息  不设置 默认10条
24
//        sourceBuilder.from(0);
25
//        sourceBuilder.size(100);
26
        //1. 查询,获取查询结果
27
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
28

29
        //7. 获取命中对象 SearchHits
30
        SearchHits hits = searchResponse.getHits();
31

32
        //7.1 获取总记录数
33
      Long total= hits.getTotalHits().value;
34
        System.out.println("总数："+total);
35
        //7.2 获取Hits数据  数组
36
        SearchHit[] result = hits.getHits();
37
            //获取json字符串格式的数据
38
        List<Product> products = new ArrayList<>();
39
        for (SearchHit searchHit : result) {
40
            String sourceAsString = searchHit.getSourceAsString();
41
            //转为java对象
42
            Product product = JSON.parseObject(sourceAsString, Product.class);
43
            products.add(product);
44
        }
45

46
         System.out.println(items);
47

48
    }

展开收起

term 查询#

term查询和字段类型有关系，首先回顾一下ElasticSearch两个数据类型

ElasticSearch两个数据类型：

text：会分词，不支持聚合
keyword：不会分词，将全部内容作为一个词条，支持聚合

term查询：不会对查询条件进行分词。但是注意，term查询，查询text类型字段时，文档中类型为text类型的字段本身仍然会分词

1
GET product/_search
2
{
3
  "query": {
4
    "term": {
5
      "title": {
6
        "value": "手机充电器"
7
      }
8
    }
9
  }
10
}

Java API

1
@Test
2
    public void testTerm() throws IOException {
3

4
        //2. 构建查询请求对象，指定查询的索引名称
5
        SearchRequest searchRequest = new SearchRequest("product");
6

7
         //4. 创建查询条件构建器SearchSourceBuilder
8
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
9
        //6. 查询条件
10
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "手机充电器");
11

12
        //5. 指定查询条件
13
        searchSourceBuilder.query(termQueryBuilder);
14

15
        //3. 添加查询条件构建器 SearchSourceBuilder
16
        searchRequest.source(searchSourceBuilder);
17

18
        //1. 查询,获取查询结果
19
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
20
        //7. 获取命中对象 SearchHits
21
        SearchHits hits = search.getHits();
22

23
        //7.1 获取总记录数
24
        long value = hits.getTotalHits().value;
25

26
        ArrayList<Product> items = new ArrayList<>();
27

28
        SearchHit[] h = hits.getHits();
29
        for (int i = 0; i < value; i++) {
30
            Product product = JSON.parseObject(h[i].getSourceAsString(), Item.class);
31
            items.add(product);
32
        }
33

34
        System.out.println(items);
35

36
    }

展开收起

match查询#

match查询的特征：

•会对查询条件进行分词。

•然后将分词后的查询条件和目标字段分词后的词条进行等值匹配

•默认取并集（OR），即只要查询条件中的一个分词和目标字段值的一个分词(词条)匹配，即认为匹配查询条件

1
# match查询
2
GET product/_search
3
{
4
  "query": {
5
    "match": {
6
      "title": "手机充电器"
7
    }
8
  },
9
  "size": 500
10
}

match 的默认搜索（or 并集）例如：华为手机，会分词为 “华为”，“手机” 只要出现其中一个词条都会认为词条匹配

match的 and（交集）搜索，例如：例如：华为手机，会分词为 “华为”，“手机” 但要求“华为”，和“手机”同时出现在词条中，才算词条匹配

1
GET product/_search
2
{
3
  "query": {
4
    "match": {
5
      "title": {
6
        "query": "华为手机",
7
        "operator": "and"
8
      }
9
    }
10
  },
11
  "size": 500
12
}

Java API

1
    @Test
2
    public void testMatch() throws IOException {
3

4
        //2. 构建查询请求对象，指定查询的索引名称
5
        SearchRequest searchRequest = new SearchRequest("product");
6

7
         //4. 创建查询条件构建器SearchSourceBuilder
8
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
9
        //6. 查询条件
10
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "手机充电器");
11
        // 设置关键字查询的运算符
12
        //matchQueryBuilder.operator(Operator.AND);
13
        //5. 指定查询条件
14
        searchSourceBuilder.query(matchQueryBuilder);
15

16
        //3. 添加查询条件构建器 SearchSourceBuilder
17
        searchRequest.source(searchSourceBuilder);
18

19
        //1. 查询,获取查询结果
20
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
21
        //7. 获取命中对象 SearchHits
22
        SearchHits hits = search.getHits();
23

24
        //7.1 获取总记录数
25
        long value = hits.getTotalHits().value;
26

27
        ArrayList<Product> items = new ArrayList<>();
28

29
        SearchHit[] h = hits.getHits();
30
        for (int i = 0; i < value; i++) {
31
            Product product = JSON.parseObject(h[i].getSourceAsString(), Product.class);
32
            items.add(product);
33
        }
34
        System.out.println(items);
35

36
    }

展开收起

querystring#

queryString 多条件查询

会对查询条件进行分词。
然后将分词后的查询条件和词条进行等值匹配
默认取并集（OR）
可以指定多个查询字段

query_string：可以识别query中的连接符（or 、and）

1
# queryString
2

3
GET product/_search
4
{
5
  "query": {
6
    "query_string": {
7
      "fields": ["title","sellPoint"],
8
      "query": "耳机 AND 充电器"
9
    }
10
  }
11
}

java代码

1
QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("耳机充电器").field("title").field("sellPoint");

范围 & 排序查询#

1
GET product/_search
2
{
3
  "query": {
4
    "range": {
5
      "price": {
6
        "gte": 100,
7
        "lte": 1000
8
      }
9
    }
10
  },
11
  "sort": [
12
    {
13
      "price": {
14
        "order": "desc"
15
      }
16
    }
17
  ]
18
}

展开收起

1
 //范围查询 以price 价格为条件
2
RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
3

4
//指定下限
5
query.gte(100);
6
//指定上限
7
query.lte(1000);
8

9
sourceBuilder.query(query);
10

11
//排序  价格 降序排列
12
sourceBuilder.sort("price",SortOrder.DESC);

复合查询 bool#

boolQuery：对多个查询条件连接。其组成主要分为如下四个部分：

must（and）：条件必须成立
must_not（not）：条件必须不成立
should（or）：条件可以成立
filter：条件必须成立，性能比must高。不会计算近似度得分

1
# must
2
GET product/_search
3
{
4
  "query": {
5
    "bool": {
6
      "must": [
7
        {
8
           "term": {
9
             "title": {
10
               "value": "充电器"
11
             }
12
           }
13
        },
14
        {
15
          "match": {
16
            "sellPoint": "快充"
17
          }
18
        }
19
      ]
20
    }
21
  }
22
}

展开收起

1
# must_not
2
GET product/_search
3
{
4
  "query": {
5
    "bool": {
6
      "must_not": [
7
        {
8
           "match": {
9
             "title": "充电器"
10
           }
11
        }
12
      ]
13
    }
14
  }
15
}

展开收起

1
# should 中的多个条件是or关系
2
GET product/_search
3
{
4
  "query": {
5
    "bool": {
6
      "should": [
7
          {
8
           "term": {
9
             "title": {
10
               "value": "充电器"
11
             }
12
           }
13
        },
14
        {
15
          "term": {
16
             "sellPoint": {
17
               "value": "小菜鸡"
18
             }
19
           }
20
        }
21
      ]
22
    }
23
  }
24
}

展开收起

1
# filter
2
GET product/_search
3
{
4
  "query": {
5
    "bool": {
6
      "filter": [
7
          {
8
           "term": {
9
             "title": {
10
               "value": "充电器"
11
             }
12
           }
13
        },
14
        {
15
          "match": {
16
            "sellPoint": "快充"
17
          }
18
        }
19
      ]
20
    }
21
  }
22
}

展开收起

这里有几点需要注意：

一个复合查询中，可以同时包含must，must not，should，filter中的一个或多个部分
每一部分，都可以包含多个查询条件(should中的多个查询条件是or关系)
当存在must，或者filter的时候，should中的条件默认不生效
must和filter都可以表示同时满足多个条件的查询，但是不同的地方在于must会计算文档的近似度得分，filter不会(must_not也不会)

1
# boolquery 包含多个部分
2
GET product/_search
3
{
4
  "query": {
5
    "bool": {
6
      "must": [
7
        {
8
          "term": {
9
            "title": {
10
              "value": "充电器"
11
            }
12
          }
13
        }
14
      ],
15
      "filter":[
16
        {
17
        "term": {
18
          "title": "原装"
19
        }
20
       },
21
       {
22
         "range":{
23
          "price": {
24
            "gte": 40,
25
            "lte": 100
26
         }
27
         }
28
       }
29

30
      ]
31
    }
32
  }
33
}

展开收起

JAVA API:

布尔查询：boolQuery

查询商品为(title): 充电器
查询过滤条件：原装
查询价格在：40-100

1
        //1.构建boolQuery
2
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
3
        //2.构建各个查询条件
4
        //2.1 查询品牌名称为:华为
5
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "耳机");
6
        boolQuery.must(termQueryBuilder);
7
        //2.2. 查询标题包含：手机
8
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("title", "原装");
9
        boolQuery.filter(matchQuery);
10

11
        //2.3 查询价格在：40-100
12
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
13
        rangeQuery.gte(40);
14
        rangeQuery.lte(100);
15
        boolQuery.filter(rangeQuery);
16

17
        sourceBuilder.query(boolQuery);

展开收起

聚合查询#

聚合查询分为两种类型:

指标聚合：相当于MySQL的聚合函数。max、min、avg、sum等
桶聚合：相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。

1
# 聚合查询
2

3
# 指标聚合 聚合函数
4

5
GET product/_search
6
{
7
  "query": {
8
    "match": {
9
      "title": "耳机"
10
    }
11
  },
12
  "aggs": {
13
    "max_price": {
14
      "max": {
15
        "field": "price"
16
      }
17
    }
18
  }
19
}
20

21
# 桶聚合  分组
22
GET product/_search
23
{
24
  "query": {
25
    "match": {
26
      "title": "充电器"
27
    }
28
  },
29
  "aggs": {
30
    "price_bucket": {
31
      "terms": {
32
        "field": "price",
33
        "size": 100
34
      }
35
    }
36
  }
37
}

展开收起

JAVA API

1
/**
2
     * 聚合查询：桶聚合，分组查询
3
     * 1. 查询title包含充电器的数据
4
     * 2. 查询充电器的价格列表
5
     */
6
@Test
7
public void testAggQuery() throws IOException {
8

9
    SearchRequest searchRequest=new SearchRequest("product");
10

11
    SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
12
    MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "充电器");
13

14
    sourceBuilder.query(queryBuilder);
15
    // 查询价格列表  只展示前100条
16
    AggregationBuilder aggregation=AggregationBuilders.terms("price_bucket").field("price").size(100);
17
    sourceBuilder.aggregation(aggregation);
18

19

20
    searchRequest.source(sourceBuilder);
21

22
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
23

24
    //7 获取命中对象 SearchHits
25
    SearchHits hits = searchResponse.getHits();
26

27
    //7.1 获取总记录数
28
    Long total= hits.getTotalHits().value;
29
    System.out.println("总数："+total);
30

31
    // aggregations 对象
32
    Aggregations aggregations = searchResponse.getAggregations();
33
    //将aggregations 转化为map
34
    Map<String, Aggregation> aggregationMap = aggregations.asMap();
35

36

37
    //通过key获取price_bucket 对象 使用Aggregation的子类接收  buckets属性在Terms接口中体现
38

39
    // Aggregation price_bucket = aggregationMap.get("price_bucket");
40
    Terms price_bucket =(Terms) aggregationMap.get("price_bucket");
41

42
    //获取buckets 数组集合
43
    List<? extends Terms.Bucket> buckets = goods_brands.getBuckets();
44

45
    Map<String,Object>map=new HashMap<>();
46
    //遍历buckets   key 属性名，doc_count 统计聚合数
47
    for (Terms.Bucket bucket : buckets) {
48

49
        System.out.println(bucket.getKey());
50
        map.put(bucket.getKeyAsString(),bucket.getDocCount());
51
    }
52

53
    System.out.println(map);
54

55
}

展开收起

有时，为了获取更多的信息，针对桶聚合，我们还会做嵌套聚合，嵌套的子聚合可以针对父聚合的每个分桶中文档数据，在分桶中再做聚合。

接下来我们可以实现这样一个需求，针对指定价格区间中，统计实际售卖的商品有多少种不同的价格，并统计每种不同价格的商品名称

1
GET  product/_search
2
{
3

4
  "query": {
5
    "match_all": {}
6
  },
7

8
  "aggs": {
9
    "price_bucket": {
10
      "terms": {
11
        "field": "price"
12
        , "size": 20
13
      },
14
      "aggs": {
15
        "tm_bucket": {
16
          "terms": {
17
            "field": "tmName"
18
          }
19
        }
20
      }
21
    }
22
  }
23
}

展开收起

1
 @Test
2
    public void testSubAggregation() throws IOException {
3
        SearchRequest searchRequest=new SearchRequest("product");
4

5
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
6
        //1. 查询title包含手机的数据
7

8
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
9

10
        sourceBuilder.query(matchAllQueryBuilder);
11
        //2. 构造价格聚合
12
        AggregationBuilder priceAgg= AggregationBuilders
13
                                            .terms("price_bucket").field("price");
14

15
        // 构造品牌聚合(价格聚合的子聚合)
16
        TermsAggregationBuilder subAggregation = AggregationBuilders.terms("tm_bucket").field("tmName");
17
        // 给价格聚合设置子聚合
18
        priceAgg.subAggregation(subAggregation);
19

20
        // 设置结合参数
21
        sourceBuilder.aggregation(priceAgg);
22

23

24
        searchRequest.source(sourceBuilder);
25

26
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
27

28
        //7. 获取命中对象 SearchHits
29
        SearchHits hits = searchResponse.getHits();
30

31
        //7.1 获取总记录数
32
        Long total= hits.getTotalHits().value;
33
        System.out.println("总数："+total);
34

35
        // aggregations 对象
36
        Aggregations aggregations = searchResponse.getAggregations();
37

38
        //通过key获取price_bucket 对象 使用Aggregation的子类接收  buckets属性在Terms接口中体现
39
        Terms price_bucket = aggregations.get("price_bucket");
40

41
        //获取buckets 数组集合
42
        List<? extends Terms.Bucket> buckets = price_bucket.getBuckets();
43

44
        // 存放封装价格聚合信息的集合
45
        List<PriceAggregationInfo> priceTrademarkInfos = new ArrayList<>();
46

47
        //遍历buckets   key 属性名，doc_count 统计聚合数
48
        for (Terms.Bucket bucket : buckets) {
49
            // 一个价格桶(父聚合的桶)的信息，包括价格，以及该价格商品对应的品牌(子聚合的桶)
50
            PriceAggregationInfo priceAggregationInfo = new PriceAggregationInfo();
51
            // 针对每一个父聚合的桶(价格桶)，每一个桶的key是商品的价格
52
            Double price = Double.parseDouble(bucket.getKeyAsString());
53
            priceAggregationInfo.setPrice(price);
54

55
            // 获取价格桶中的，品牌聚合(子聚合)的结果
56
            Terms tmBuckets = bucket.getAggregations().get("tm_bucket");
57
            // 存放同一价格的品牌集合
58
            ArrayList<String> names = new ArrayList<>();
59
            for ( Terms.Bucket tmBucket: tmBuckets.getBuckets()) {
60
                String tmName  = tmBucket.getKeyAsString();
61
                names.add(tmName);
62
            }
63

64
            // 设置品牌集合
65
            priceAggregationInfo.setTrademarkNames(names);
66

67
            priceTrademarkInfos.add(priceAggregationInfo);
68
        }
69

70
        System.out.println(priceTrademarkInfos);
71
    }

展开收起

高亮查询#

高亮三要素：

高亮字段
前缀
后缀

默认前后缀：em

1
<em>手机</em>

1
GET product/_search
2
{
3
  "query": {
4
    "match": {
5
      "title": "充电器"
6
    }
7
  },
8
  "highlight": {
9
    "fields": {
10
      "title": {
11
        "pre_tags": "<font color='red'>",
12
        "post_tags": "</font>"
13
      }
14
    }
15
  }
16
}

展开收起

1
 @Test
2
    public void testHighLight() throws IOException {
3
        // 构建针对索引"product"的查询请求
4
        SearchRequest searchRequest = new SearchRequest("prouct");
5

6
        // 创建SearchSourceBuilder
7
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
8
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "充电器");
9
        searchSourceBuilder.query(matchQueryBuilder);
10

11
        // 构造高亮查询条件
12
        HighlightBuilder highlighter = new HighlightBuilder();
13
        highlighter.field("title").preTags("<font color='red'>").postTags("</font>");
14
        searchSourceBuilder.highlighter(highlighter);
15

16
        searchRequest.source(searchSourceBuilder);
17

18
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
19
        SearchHits hits = search.getHits();
20

21
        long value = hits.getTotalHits().value;
22

23
        ArrayList<Product> items = new ArrayList<>();
24

25
        SearchHit[] h = hits.getHits();
26
        for (int i = 0; i < value; i++) {
27
            Product item = JSON.parseObject(h[i].getSourceAsString(), Product.class);
28
            // 显示生成的高亮字符串
29
            Map<String, HighlightField> highlightFields = h[i].getHighlightFields();
30
            //System.out.println(highlightFields);
31
            HighlightField HighlightField = highlightFields.get("title");
32
            Text[] fragments = HighlightField.fragments();
33
            //替换
34
            item.setTitle(fragments[0].toString());
35
            items.add(item);
36
        }
37

38
        System.out.println(items);
39

40
    }

展开收起

集群相关知识#

我们启动的一个Elasticsearch进程，我们称之为为一个Elasticsearch节点(Node)，多个Elasticsearch节点，可以组成一个Elasticsearch集群，接下来，我们就来了解下Elasticsearch集群相关的知识

索引在集群中的分布#

shard-1652621281595

无论是单机还是集群模式，ES中的索引数据都是以分片的形式存在的，一个索引的一个分片中只存储该索引中的一部分数据，即一个索引中的文档数据，被存储在其所属的若干个分片中，每个分片只存储索引部分数据。

对于一个索引所包含的所有分片，又被分成了两种：

主分片：一个索引中的文档到底被被分成几部分来存储，主要看索引到底包含多少个主分片，有多少个主分片，索引数据数据就被分成几部分分别存储在主分片中。用户插入ES的文档数据都是首先存储到主分片的。
副本分片：而副本分片主要是作为主分片的数据副本而存在，每个主分片都可以有对应的副本分片。

所以，在ES集群中，一个索引的多个分片数据，就保存在不同的ES服务器实例或者说不同的ES Node上，一个单机版的ES服务器，也可以看做是只包含一个ES Node的ES集群，所以一个ES Node可以包含索引的多个分片数据。

这里还有三点细节需要注意：

ES 不允许将一个主分片和它对应的副本分片存储在同一个ES Node中。这主要是为了防止，一个ES Node 宕机导致，某分片数据全部丢失(主分片和该主分片对应的副本分片的数据全部丢失)。这是因为如果每个主分片至少有一个副本分片，那么即使该主分片所在的ES Node宕机也没关系，ES会自动将其副本分片变为主分片，保证数据的正常访问。
一个ES的索引由一个或多个主分片以及零个或多个副本分片构成，即ES不强制要求主分片一定有对应的副本分片
在创建索引的时候就可以定义，索引的主分片数量，以及每个主分片对应的副本分片的数量，但是对于一个索引而言，一旦索引创建完毕，其主分片数量就不能在变了，只能修改其副本分片的数量

文档数据在ES集群中的存储和搜索#

我们先来看看文档数据的存储：

当存储或一篇文档的时候，ES首先根据文档ID的散列值，选择一个主分片，并将该文档发送到该主分片保存。
然后，该文档被发送到主分片对应的所有的副本分片进行保存，这使得副本分片和主分片之间保持数据同步
数据同步使得副本分片可以服务与搜索请求，并在原有主分片无法访问时自动升级为主分片

文档的保存

在保存一篇文档的时候，我们讲解了如何决定一篇文档所在的分片的，这一过程我们称为文档路由。当ES散列文档ID时就会发生文档的路由，来决定文档应该索引到哪个分片中

再来看看在集群中搜索文档数据的过程，当在索引中搜索的时候，Elastic Search会在索引的所有分片中进行查找，这些分片可以是主分片，也可以是副本分片，原因是主分片和副本分片通常包含一样的文档。ES在索引的主分片和副本分片中进行搜索请求的负载均衡，使得副本分片对于搜索的性能和容错都有帮助。下面看看具体的搜索过程:

搜索请求首先被一个ES Node接收，并将请求转发到一组包含所有数据的索引分片
在选择转发请求的分片时，使用轮训算法选择可用分片(这里轮训的是某主分片和其对应的副本分片，并且对于索引中的每一个主分片与其对应的副本分片都会有这样的轮训选择过程)，并将搜索请求转发到所有选中的分片，
然后，ES将从这些接收到请求的分片收集搜索的结果，将其聚集到单一的回复，然后将回复返回给客户端

文档的搜索

脑裂问题#

在一个ES集群中，包含多个ES Node，这多个ES Node又可以扮演不同的角色，实现不同的功能，主要有以下几种角色：

Matster Node：负责创建，删除索引，以及给节点分配分片等集群管理工作
Data Node: 负责存储文档数据，以及对文档数据的CRUD操作
Coordinating Node: 负责接收客户端的请求，并将请求分发到各个相关节点，并最终收集各节点返回的结果，整合为一个统一的结果，返回给客户端, 其实每个ES Node都隐式的扮演者协调节点的角色。

在这其中，Data Node和Coordinating Node都可以有多个，但是Matster Node作为管理集群的”大脑”。正常情况下，当主节点无法工作时，会从备选主节点中选举一个出来变成新主节点，原主节点回归后变成备选主节点

但有时因为网络抖动等原因，主节点没能及时响应，集群误以为主节点挂了，选举了一个新主节点，此时一个es集群中有了两个主节点，其他节点不知道该听谁的调度，结果将是灾难性的！这种类似一个人得了精神分裂症，就被称之为“脑裂”现象。

之所以产生脑裂问题的原因是主节点因为各种原因，在收到请求后未能及时响应，导致主节点未能及时响应的原因，一般主要有以下几点:

网络抖动

内网一般不会出现es集群的脑裂问题，可以监控内网流量状态。外网的网络出现问题的可能性大些
节点负载

如果主节点同时承担数据节点的工作，可能会因为工作负载大而导致对应的 ES 实例停止响应。
内存回收

由于数据节点上es进程占用的内存较大，较大规模的内存回收操作也能造成es进程失去响应。

如何解决脑裂问题呢？

不要把主节点同时设为数据节点（node.master和node.data不要同时设为true），node.master=true意味着该节点有竞选Master Node的资格，node.date=true，意味着该节点扮演数据节点的角色
将节点响应超时（discovery.zen.ping_timeout）稍稍设置长一些（默认是3秒），避免误判。
设置需要超过半数的备选节点同意，才能发生主节点重选，类似需要参议院半数以上通过，才能弹劾现任总统。（discovery.zen.minimum_master_nodes = 半数以上的投票节点数）。

全文检索

Sun, 14 Jun 2026 00:00:00 GMT

功能介绍#

首页点击分类

在搜索框搜索关键字

搜索到的目标商品列表页

准备搜索数据#

当点击首页分类，或者在搜索框中搜索商品的时候，实际上都是在ES中完成搜索的，所以在搜索之前我们必须现将商品相关的数据，放入到ES的索引中，才能完成搜索。

创建索引和映射#

我们首先梳理下，在搜索结果展示的搜索列表页中，需要展示哪些数据：

所有搜索到的商品具有的品牌，以及品牌logo
所有搜索到的商品具有的平台属性，以及对应的平台属性值
SKU商品的名称
SKU商品的价格
SKU商品的默认图片

很显然，所有这些数据都需要包含在，搜索结果中，因此ES的索引中也必须要有这些数据。但是在定义索引，以及映射之前，我们要先解决一个小问题：

一个SKU商品有具有多个平台属性
每一个平台属性又可能包含了平台属性id，平台属性名称，平台属性取值

那么一个SKU商品的平台属性值如何在JSON文档中表示呢？如果写出一个JSON字符串的话，应该如下所示：

1
{
2
    ....
3
        "_source" : {
4
          "id" : 57,
5
          "title" : "荣耀（HONOR） 荣耀V30 pro 5G手机 麒麟990芯片 v40轻奢版【幻夜星河】 全网通(8+256G)",
6
           .....
7
          "attrs" : [
8
            {
9
              "attrId" : 23,
10
              "attrValue" : "8G",
11
              "attrName" : "运行内存"
12
            },
13
            {
14
              "attrId" : 24,
15
              "attrValue" : "256G",
16
              "attrName" : "机身内存"
17
            },
18
            {
19
              "attrId" : 111,
20
              "attrValue" : "4000-4499mAh",
21
              "attrName" : "电池容量"
22
            },
23
            {
24
              "attrId" : 112,
25
              "attrValue" : "6.3-6.59英寸",
26
              "attrName" : "屏幕尺寸"
27
            }
28
          ]
29
        }
30
      }
31
      ...
32
}

展开收起

所以，要在索引中存储SKU商品的平台属性，我们就需要用到对象类型了。我们学习一个简单的例子，创建如下索引

1
PUT user
2
{
3
  "mappings": {
4
    "properties": {
5
      "name": {
6
        "properties": {
7
          "first": {"type": "text"},
8
          "last":  {"type": "text"}
9
        }
10
      }
11
    }
12
  }
13
}

向索引中添加一条文档数据如下：

1
POST user/_doc/1
2
{
3
  "name": [
4
     {
5
      "first": "John",
6
      "last": "Smith"
7
     },
8
     {
9
      "first": "Alice",
10
      "last": "White"
11
     }
12
  ]
13
}

查询索引中的数据如下：

接下来，我们做一个简单的查询，查询下first name为Alice，last name为Smith的文档。

1
GET user/_search
2
{
3
  "query": {
4
    "bool": {
5
      "must": [
6
        { "match": { "name.first": "Alice" }},
7
        { "match": { "name.last":  "Smith" }}
8
      ]
9
    }
10
  }
11
}

查询结果如下：

看到这个结果，和我们的预期是不一样的，因为文档中并没有包含一个人的first name为Alice，last name为Smith。那么又为什么会有这样的结果呢？原因就在于，对于普通的对象数据，ES内部其实是这样来存储的：

1
{
2
   ...
3
   "_source" : {
4
      "name.first" : ["John", "Alice"],
5
      "name.last" : ["Smith", "White"]
6
    }
7
}

所以，再结合上面的查询条件，我们很容易就可以理解了，为什么命名没有一个人的first name叫Alice，last name叫White，但我们偏偏还是查询到了文档。

之所以会出现这种意料之外的情况，是因为使用对象类型可能会出现跨对象匹配，其实应该是，第一个人(对象)的last和“Smith”匹配，第二个人(对象)的first和“Alice匹配”，为了避免这种跨对象匹配的情况，我们需要使用nested类型，通过nested类型定义的对象，每个对象的数据是单独存储的，因此，在匹配查询条件时，是不会出现跨对象匹配的。

1
PUT user_nested
2
{
3
  "mappings": {
4
    "properties": {
5
      "name": {
6
        "type": "nested",
7
        "properties": {
8
          "first": {"type": "text"},
9
          "last":  {"type": "text"}
10
        }
11
      }
12
    }
13
  }
14
}

1
POST user_nested/_doc/1
2
{
3
  "name": [
4
     {
5
      "first": "John",
6
      "last": "Smith"
7
     },
8
     {
9
      "first": "Alice",
10
      "last": "White"
11
     }
12
  ]
13
}

再次使用相同的查询，结果就是空集合，查询结果是符合预期的。

但是一旦使用了nested这种数据类型，查询方式，也要发生变化，我们下来测试下，继续使用普通查询方式，查询nested数据。

1
GET user_nested/_search
2
{
3
  "query": {
4
    "bool": {
5
      "must": [
6
        { "match": { "name.first": "Alice" }},
7
        { "match": { "name.last":  "White" }}
8
      ]
9
    }
10
  }
11
}

发现结果还是不对，因为索引中有一个人的名字first是Alice，last是White，查询到的仍然是空集合。

所以我们一定要注意，针对nested类型数据的条件查询，我们的查询也要使用nested查询

1
GET user_nested/_search
2
{
3
  "query": {
4
    "nested": {
5
      "path": "name",
6
      "query": {
7
        "bool": {
8
          "must": [
9
            { "match": { "name.first": "Alice" }},
10
            { "match": { "name.last":  "White" }}
11
          ]
12
        }
13
      }
14
    }
15
  }
16
}

展开收起

关于nested查询，我们需要注意以下几点：

针对nested数据类型的字段查询，应该使用nested类型的查询
在nested查询中，path表示的是待查询的，数据类型为nested类型的字段名

所以很显然，在ES中，一条SKU商品对应的文档中，每个平台属性都应该使用nested类型来定义，同时针对平台属性的查询，也必须是nested查询。所以，定义映射的DSL如下：

1
PUT my_goods
2
{
3
    "mappings" : {
4
      "properties" : {
5
        "attrs" : {
6
          "type" : "nested",
7
          "properties" : {
8
            "attrId" : {
9
              "type" : "long"
10
            },
11
            "attrName" : {
12
              "type" : "keyword"
13
            },
14
            "attrValue" : {
15
              "type" : "keyword"
16
            }
17
          }
18
        },
19
        "defaultImg" : {
20
          "type" : "keyword"
21
        },
22
        "firstLevelCategoryId" : {
23
          "type" : "long"
24
        },
25
        "firstLevelCategoryName" : {
26
          "type" : "keyword"
27
        },
28
        "hotScore" : {
29
          "type" : "long"
30
        },
31
        "id" : {
32
          "type" : "long"
33
        },
34
        "price" : {
35
          "type" : "double"
36
        },
37
        "secondLevelCategoryId" : {
38
          "type" : "long"
39
        },
40
        "secondLevelCategoryName" : {
41
          "type" : "keyword"
42
        },
43
        "thirdLevelCategoryId" : {
44
          "type" : "long"
45
        },
46
        "thirdLevelCategoryName" : {
47
          "type" : "keyword"
48
        },
49
        "title" : {
50
          "type" : "text",
51
          "analyzer" : "ik_max_word"
52
        },
53
        "tmId" : {
54
          "type" : "long"
55
        },
56
        "tmLogoUrl" : {
57
          "type" : "keyword"
58
        },
59
        "tmName" : {
60
          "type" : "keyword"
61
        }
62
      }
63
    }
64
}

展开收起

添加测试商品数据#

1
POST my_goods/_doc/57
2
{
3
  "id" : 57,
4
  "title" : "荣耀（HONOR） 荣耀V30 pro 5G手机 麒麟990芯片 v40轻奢版【幻夜星河】 全网通(8+256G)",
5
  "price" : 3999.0,
6
  "tmId" : 3,
7
  "tmName" : "华为",
8
   "tmLogoUrl":"http://47.93.148.192:8080/group1/M00/01/71/rBHu8mEQpUuAVioLAAGXnmYhX7M923.jpg",
9
  "defaultImg": "http://57",
10
  "firstLevelCategoryId" : 2,
11
  "firstLevelCategoryName" : "手机",
12
  "secondLevelCategoryId" : 13,
13
  "secondLevelCategoryName": "手机通讯",
14
  "thirdLevelCategoryId" : 61,
15
  "thirdLevelCategoryName" : "手机",
16
  "attrs" : [
17
    {
18
      "attrId" : 23,
19
      "attrValue" : "8G",
20
      "attrName" : "运行内存"
21
    },
22
    {
23
      "attrId" : 24,
24
      "attrValue" : "256G",
25
      "attrName" : "机身内存"
26
    },
27
    {
28
      "attrId" : 111,
29
      "attrValue" : "4000-4499mAh",
30
      "attrName" : "电池容量"
31
    },
32
    {
33
      "attrId" : 112,
34
      "attrValue" : "6.3-6.59英寸",
35
      "attrName" : "屏幕尺寸"
36
    }
37
  ]
38
}
39

40
POST my_goods/_doc/58
41
{
42
  "id" : 58,
43
  "title" : "荣耀（HONOR）荣耀V30 pro 5G手机麒麟990芯片 v40轻奢版【冰岛幻境】全网通(8+128G)",
44
  "price" : 1999.0,
45
  "tmId" : 3,
46
  "tmName" : "华为",
47
  "tmLogoUrl":"http://47.93.148.192:8080/group1/M00/01/71/rBHu8mEQpUuAVioLAAGXnmYhX7M923.jpg",
48
   "defaultImg": "http://58",
49
  "firstLevelCategoryId" : 2,
50
  "firstLevelCategoryName" : "手机",
51
  "secondLevelCategoryId" : 13,
52
  "secondLevelCategoryName": "手机通讯",
53
  "thirdLevelCategoryId" : 61,
54
  "thirdLevelCategoryName" : "手机",
55
  "attrs" : [
56
    {
57
      "attrId" : 23,
58
      "attrValue" : "8G",
59
      "attrName" : "运行内存"
60
    },
61
    {
62
      "attrId" : 24,
63
      "attrValue" : "128G",
64
      "attrName" : "机身内存"
65
    },
66
    {
67
      "attrId" : 111,
68
      "attrValue" : "3000-3999mAh",
69
      "attrName" : "电池容量"
70
    },
71
    {
72
      "attrId" : 112,
73
      "attrValue" : "6.0-6.29英寸",
74
      "attrName" : "屏幕尺寸"
75
    }
76
  ]
77
}
78

79
POST my_goods/_doc/59
80
{
81
  "id" : 59,
82
  "title" : "小米 CC9 手机 骁龙710 屏幕指纹3200万美颜自拍 4800万广角三摄美颜拍照 蓝色星球",
83
  "price" : 799.0,
84
  "tmId" : 1,
85
  "tmName" : "小米",
86
   "tmLogoUrl":"http://47.93.148.192:8080/group1/M00/01/71/rBHu8mEQpUuAVioLAAGXnmYhX7M923.jpg",
87
  "defaultImg": "http://59",
88
  "firstLevelCategoryId" : 2,
89
  "firstLevelCategoryName" : "手机",
90
  "secondLevelCategoryId" : 13,
91
  "secondLevelCategoryName": "手机通讯",
92
  "thirdLevelCategoryId" : 61,
93
  "thirdLevelCategoryName" : "手机",
94
  "attrs" : [
95
    {
96
      "attrId" : 23,
97
      "attrValue" : "8G",
98
      "attrName" : "运行内存"
99
    },
100
    {
101
      "attrId" : 24,
102
      "attrValue" : "128G",
103
      "attrName" : "机身内存"
104
    },
105
    {
106
      "attrId" : 111,
107
      "attrValue" : "4000-4499mAh",
108
      "attrName" : "电池容量"
109
    },
110
    {
111
      "attrId" : 112,
112
      "attrValue" : "6.0-6.29英寸",
113
      "attrName" : "屏幕尺寸"
114
    }
115
  ]
116
}
117

118
POST my_goods/_doc/60
119
{
120
  "id" : 60,
121
  "title" : "小米 CC9 手机 骁龙710 屏幕指纹3200万美颜自拍 4800万广角三摄美颜拍照 蓝色星球",
122
  "price" : 899.0,
123
  "tmId" : 1,
124
  "tmName" : "小米",
125
  "tmLogoUrl":"http://47.93.148.192:8080/group1/M00/01/71/rBHu8mEQpUuAVioLAAGXnmYhX7M923.jpg",
126
   "defaultImg": "http://60",
127
  "firstLevelCategoryId" : 2,
128
  "firstLevelCategoryName" : "手机",
129
  "secondLevelCategoryId" : 13,
130
  "secondLevelCategoryName": "手机通讯",
131
  "thirdLevelCategoryId" : 61,
132
  "thirdLevelCategoryName" : "手机",
133
  "attrs" : [
134
    {
135
      "attrId" : 23,
136
      "attrValue" : "8G",
137
      "attrName" : "运行内存"
138
    },
139
    {
140
      "attrId" : 24,
141
      "attrValue" : "256G",
142
      "attrName" : "机身内存"
143
    },
144
    {
145
      "attrId" : 111,
146
      "attrValue" : "4000-4499mAh",
147
      "attrName" : "电池容量"
148
    },
149
    {
150
      "attrId" : 112,
151
      "attrValue" : "6.0-6.29英寸",
152
      "attrName" : "屏幕尺寸"
153
    }
154
  ]
155
}

展开收起

商品查询DSL#

接下来，我们需要思考下，用户进入我们的电商网站后，会根据什么条件查询？

商品名称关键字查询
分类
品牌
平台属性值

除此之外，我们可能还需要，做高亮查询，排序查询等

关键字查询#

之所以把关键字查询放到bool查询的must部分，是因为我们认为，用户更关心的可能是目标商品和查询关键字的近似度，近似度越高可能月符合用户的预期。

1
#例如小米手机
2
GET my_goods/_search
3
{
4
  "query": {
5
    "bool": {
6
      "must": [
7
        {
8
          "match": {
9
             "title": "小米手机"
10
          }
11
        }
12
      ]
13
    }
14
  }
15
}

展开收起

1
# 如果查询小米手机，业务上要求查询出的手机必须得是小米的
2
POST my_goods/_search
3
{
4
  "query": {
5
    "bool": {
6
      "must": [
7
        {
8
          "match": {
9
            "title": {
10
              "query": "小米手机",
11
              "operator": "and"
12
            }
13
          }
14
        }
15
      ]
16
    }
17
  }
18
}

展开收起

过滤查询#

对于品牌，平台属性，分类这些条件的查询，用户通常会希望商品和条件相同(所以就不关心，也不需要有近似度)，所以这些查询条件，我们往往可以放到bool查询的filter部分。

1
#过滤查询-根据分类id
2
#term 查询条件不分词
3
GET my_goods/_search
4
{
5
  "query": {
6
    "bool": {
7
      "filter": [
8
        {
9
          "term": {
10
            "thirdLevelCategoryId": "61"
11
          }
12
        }
13
      ]
14
    }
15
  }
16
}

展开收起

1
#过滤查询-根据品牌
2
GET my_goods/_search
3
{
4
  "query": {
5
    "bool": {
6
      "filter": [
7
        {
8
          "term": {
9
            "tmId": "1"
10
          }
11
        }
12
      ]
13
    }
14
  }
15
}

展开收起

1
#过滤查询-平台属性
2
#查询 平台属性： 运行内存(id为23)为8g的商品
3
GET my_goods/_search
4
{
5
  "query": {
6
    "bool": {
7
      "filter": [
8
        {
9
          "nested": {
10
            "path": "attrs",
11
            "query": {
12
              "bool": {
13
                "filter": [
14
                  {
15
                    "term": {
16
                      "attrs.attrValue": "8G"
17
                    }
18
                  },
19
                  {
20
                    "term": {
21
                      "attrs.attrId": 23
22
                    }
23
                  }
24
                ]
25
              }
26
            }
27
          }
28
        }
29
      ]
30
    }
31
  }
32
}

展开收起

我们如果想要同时查询多个平台属性值，怎么办呢？比如同时查询运行内存8G，屏幕尺寸为6.3-6.59英寸的手机

1
GET my_goods/_search
2
{
3
  "query": {
4
    "bool": {
5
      "filter": [
6
        {
7
          "nested": {
8
            "path": "attrs",
9
            "query": {
10
              "bool": {
11
                "must": [
12
                  {
13
                    "term": {
14
                      "attrs.attrValue": "8G"
15
                    }
16
                  },
17
                  {
18
                    "term": {
19
                      "attrs.attrId": 23
20
                    }
21
                  }
22
                ]
23
              }
24
            }
25
          }
26
        },
27
        {
28
          "nested": {
29
            "path": "attrs",
30
            "query": {
31
              "bool": {
32
                "must": [
33
                  {
34
                    "term": {
35
                      "attrs.attrValue": "6.3-6.59英寸"
36
                    }
37
                  },
38
                  {
39
                    "term": {
40
                      "attrs.attrId": 112
41
                    }
42
                  }
43
                ]
44
              }
45
            }
46
          }
47
        }
48
      ]
49
    }
50
  }
51

52
}

展开收起

分页查询#

1
#分页查询
2
# from 从结果集的第几条开始返回 计算 开始的索引=（当前页-1）*每条数据
3
# size 每页条数
4
#位置
5
POST my_goods/_search
6
{
7
  "query": {
8
    "match_all": {}
9
  },
10
  "from": 6,
11
  "size": 2
12
}

排序查询#

1
#排序查询-价格 ，热点
2
#sort
3
POST my_goods/_search
4
{
5
  "query": {
6
    "match_all": {}
7
  },
8
  "sort": [
9
    {
10
      "price": {
11
        "order": "asc"
12
      }
13
    }
14
  ]
15
}

展开收起

聚合查询#

1
#聚合查询--品牌id
2
#aggs
3
#field 聚合的字段
4
#size 显示聚合后的数据个数
5
#注意在聚合的内部只能有一个aggs属性
6
# 该聚合查询的目的是获取每一个品牌对应的品牌名称和品牌logo url
7
GET   my_goods/_search
8
{
9
  "query": {
10
    "match_all": {}
11
  },
12
  "aggs": {
13
    "tmIdAgg": {
14
      "terms": {
15
        "field": "tmId",
16
        "size": 10
17
      },
18
      "aggs": {
19
        "tmNameAgg": {
20
          "terms": {
21
            "field": "tmName",
22
            "size": 10
23
          }
24
        },
25
        "tmLogoUrlAgg":{
26
          "terms": {
27
            "field": "tmLogoUrl",
28
            "size": 10
29
          }
30
        }
31
      }
32
    }
33
  }
34
}

展开收起

1
#聚合查询--平台属性聚合
2
#特点--类型nested
3
# 对nested对象做nested聚合，主要获取每一个平台属性的属性名和属性值
4
POST my_goods/_search
5
{
6
  "query": {
7
    "match_all": {}
8
  },
9
  "aggs": {
10
    "attrAgg": {
11
      "nested": {
12
        "path": "attrs"
13
      },
14
      "aggs": {
15
        "attrIdAgg": {
16
          "terms": {
17
            "field": "attrs.attrId",
18
            "size": 10
19
          },
20
          "aggs": {
21
            "attrNameAgg": {
22
              "terms": {
23
                "field": "attrs.attrName",
24
                "size": 10
25
              }
26
            },
27
            "attrValueAgg":{
28
              "terms": {
29
                "field": "attrs.attrValue",
30
                "size": 10
31
              }
32
            }
33
          }
34
        }
35
      }
36
    }
37
  }
38
}

展开收起

高亮查询#

1
#高亮查询--title
2
#前提条件： 必须是关键字匹配查询才有高亮
3
POST my_goods/_search
4
{
5
  "query": {
6
    "match": {
7
      "title": "小米手机"
8
    }
9
  },
10
  "highlight": {
11
    "fields": {
12
      "title": {
13
        "pre_tags": "<span style=color:red>",
14
      "post_tags": "</span>"
15
      }
16
    },
17

18
  }
19

20
}

展开收起

指定查询结果中的字段#

1
# 指定在包含查询结果文档数据的_source属性中，只包含id，defaultImg，title，price这几个字段
2
POST my_goods/_search
3
{
4
  "query": {
5
    "match_all": {}
6
  },
7
  "_source": [
8
    "id",
9
    "defaultImg",
10
    "title",
11
    "price"
12
  ]
13
}

最终的查询DSL#

1
GET my_goods/_search
2
{
3
  "query": {
4
    "bool": {
5
      "must": [
6
        {
7
          "match": {
8
            "title": "荣耀手机"
9
          }
10
        }
11
      ],
12
      "filter": [
13
        {
14
          "term": {
15
            "thirdLevelCategoryId": "61"
16
          }
17
        },
18
        {
19
          "term": {
20
            "tmId": 3
21
          }
22
        },
23
    {
24
          "nested": {
25
            "path": "attrs",
26
            "query": {
27
              "bool": {
28
                "must": [
29
                  {
30
                    "term": {
31
                      "attrs.attrValue": "8G"
32
                    }
33
                  },
34
                  {
35
                    "term": {
36
                      "attrs.attrId": 23
37
                    }
38
                  }
39
                ]
40
              }
41
            }
42
          }
43
        },
44
        {
45
          "nested": {
46
            "path": "attrs",
47
            "query": {
48
              "bool": {
49
                "must": [
50
                  {
51
                    "term": {
52
                      "attrs.attrValue": "6.3-6.59英寸"
53
                    }
54
                  },
55
                  {
56
                    "term": {
57
                      "attrs.attrId": 112
58
                    }
59
                  }
60
                ]
61
              }
62
            }
63
          }
64
        }
65
      ]
66
    }
67
  },
68
  "from": 0,
69
  "size": 4,
70
  "sort": [
71
    {
72
      "hotScore": {
73
        "order": "asc"
74
      }
75
    }
76
  ],
77
  "aggs": {
78
    "tmIdAgg": {
79
      "terms": {
80
        "field": "tmId",
81
        "size": 10
82
      },
83
      "aggs": {
84
        "tmNameAgg": {
85
          "terms": {
86
            "field": "tmName",
87
            "size": 10
88
          }
89
        },
90
        "tmLogoUrlAgg": {
91
          "terms": {
92
            "field": "tmLogoUrl",
93
            "size": 10
94
          }
95
        }
96
      }
97
    },
98
    "attrAgg": {
99
      "nested": {
100
        "path": "attrs"
101
      },
102
      "aggs": {
103
        "attrIdAgg": {
104
          "terms": {
105
            "field": "attrs.attrId",
106
            "size": 10
107
          },
108
          "aggs": {
109
            "attrNameAgg": {
110
              "terms": {
111
                "field": "attrs.attrName",
112
                "size": 10
113
              }
114
            },
115
            "attrValueAgg": {
116
              "terms": {
117
                "field": "attrs.attrValue",
118
                "size": 10
119
              }
120
            }
121
          }
122
        }
123
      }
124
    }
125
  },
126
  "highlight": {
127
    "fields": {
128
      "title": {
129
         "pre_tags": "<span style=color:red>",
130
         "post_tags": "</span>"
131
      }
132
    }
133
  },
134
  "_source": [
135
    "id",
136
    "defaultImg",
137
    "title",
138
    "price"
139
  ]
140
}

展开收起

Spring Data Elasticsearch#

Spring Data Elasticsearch为文档的存储，查询，排序和统计提供了一个高度抽象的模板。使用Spring Data ElasticSearch来操作Elasticsearch，可以较大程度的减少我们的代码量，提高我们的开发效率。

要使用Elasticsearch我们需要引入如下依赖：

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
4
    <version>2.7.17</version>
5
</dependency>

还需要在配置文件中增加如下配置

1
spring:
2
  elasticsearch:
3
    rest:
4
      # es server的地址
5
      uris: 192.168.0.102:9200
6
      # 连接超时时间
7
      connection-timeout: 6s
8
      # 访问超时时间
9
      read-timeout: 10s

定义文档映射实体类#

类比于MyBatis-Plus可以定义实体类去映射数据库中的表中的数据，使用Spring Data Elasticsearch时，我们也可以通过定义一个实体类映射ES索引中的文档。

1
@Data
2
@Document(indexName = "goods" , shards = 1,replicas = 0)
3
public class Goods {
4
    // 商品Id skuId _id
5
    @Id
6
    private Long id;
7

8
    @Field(type = FieldType.Keyword, index = false)
9
    private String defaultImg;
10

11
    // es 中能分词的字段，这个字段数据类型必须是 text！keyword 不分词！
12
    @Field(type = FieldType.Text, analyzer = "ik_max_word")
13
    private String title;
14

15
    @Field(type = FieldType.Double)
16
    private Double price;
17

18
    @Field(type = FieldType.Long)
19
    private Long tmId;
20

21
    @Field(type = FieldType.Keyword)
22
    private String tmName;
23

24
    @Field(type = FieldType.Keyword)
25
    private String tmLogoUrl;
26

27
    @Field(type = FieldType.Long)
28
    private Long firstLevelCategoryId;
29

30
    @Field(type = FieldType.Keyword)
31
    private String firstLevelCategoryName;
32

33
    @Field(type = FieldType.Long)
34
    private Long secondLevelCategoryId;
35

36
    @Field(type = FieldType.Keyword)
37
    private String secondLevelCategoryName;
38

39
    @Field(type = FieldType.Long)
40
    private Long thirdLevelCategoryId;
41

42
    @Field(type = FieldType.Keyword)
43
    private String thirdLevelCategoryName;
44

45
    //  商品的热度！ 我们将商品被用户点查看的次数越多，则说明热度就越高！
46
    @Field(type = FieldType.Long)
47
    private Long hotScore = 0L;
48

49
    // 平台属性集合对象
50
    // Nested 支持嵌套查询
51
    @Field(type = FieldType.Nested)
52
    private List<SearchAttr> attrs;
53

54
}

展开收起

1
/*
2
   该类映射nested平台属性
3
*/
4
@Data
5
public class SearchAttr {
6
    // 平台属性Id
7
    @Field(type = FieldType.Long)
8
    private Long attrId;
9
    // 平台属性值名称
10
    @Field(type = FieldType.Keyword)
11
    private String attrValue;
12
    // 平台属性名
13
    @Field(type = FieldType.Keyword)
14
    private String attrName;
15
}

展开收起

在Goods类上，通过添加@Document注解，我们将Goods类映射的文档所属的索引：

@Document注解的index属性，用来定义实体类所映射的文档所属的目标索引名称
@Document的shards属性，表示目标索引的住分片数量
@Document的replicas属性，表示每个主分片所拥有的副本分片的数量

在Goods类的成员变量Id上通过添加@Id注解指定，Id成员变量映射到Goods索引中文档的id字段，同时也映射到文档的唯一表示_id字段。

在Goods类的其他成员变量上，通过添加@Field注解，定义成员变量和文档字段的映射关系：

默认同名成员变量，映射到文档中的同名字段(也可以由@Field注解的name属性显示指定)
通过@Field注解的type属性指定文档中同名字段的数据类型
通过@Field注解的analyzer属性，指定成员变量所映射的文档字段所使用的的分词器

Repository#

类比于Mybatis-Plus中定义BaseMaper子接口即可对单表做增删改查的操作，Spring Data Elastisearch中我们可以通过定义ElasticsearchRepository子接口，迅速实现对索引中的文档数据的增删改查，以及通过自定义方法，实现自定义查询。

1
public interface GoodsRepository extends ElasticsearchRepository<Goods,Long> {
2

3
}

ElasticsearchRepository接口需要接收两个泛型，第一个泛型即映射实体类，第二个泛型是在实体类中加了@Id注解的成员变量的数据类型，即映射到文档唯一标识_id字段的成员变量类型。

一旦我们定义好了ElasticsearchRepository的子接口，马上就可以实现对goods索引中文档的增删改查功能

1
    // 注入repository对象
2
    @Autowired
3
    private GoodsRepository goodsRepository;
4

5

6
    // 保存单个文档对象
7
    Goods good = ....
8
    goodsRepository.save(good);
9

10

11

12
    // 批量保存多个文档对象
13
    List<Goods> goods = ...
14
    goodsRepository.save(goods);
15

16
   // 根据id查询
17
   goodsRepository.findById(id);
18

19
   // 根据id删除
20
   goodsRepository.deleteById(id);

展开收起

同时，我们还需要注意一点，一旦我们定义好了ElasticsearchRepository接口，而且被SpringBoot启动类扫描到，那么在应用启动的时候，如果ElasticsearchRepository子接口所访问的索引在ES中不存在，Spring Data Elasticsearch会在ES中自动创建索引，并根据映射实体类定义索引的映射。

但是，大多数时候，我们可能需要对索引中的文档数据做自定义查询，此时仅仅使用ElasticsearchRepository接口中继承的方法无法满足我们的需求。此时我们就需要在自己的Repository接口中，通过自定义方法来实现各种自定义查询。

利用@Query注解自定义查询脚本

1
  /*
2
     1. 通过Query注解定义具体的查询字符串(也可以替换为其他查询)
3
     2. 字符串中的?0是固定格式，表示第0个参数的占位符，在实际查询时会被方法的第一个参数值title的值替换,         如果有多个参数，依次类推即可
4
     3. List<Goods>
5
    */
6
    @Query(
7
                "{ " +
8
                        "\"match\": {\n" +
9
                    "      \"title\": \"?0\"\n" +
10
                            "}" +
11
                        "}"
12
    )
13
    List<Goods> matchSearch(String title);

这里的@Query注解中，只需要包含我们查询脚本中”query”{} 里面的内容即可，比如上面的@Query注解所表示的查询等价于

1
GET goods/_search
2
{
3
  "query": {
4
    "match": {
5
      "title": 具体待查询的参数值
6
    }
7
  }
8
}

1
  @Autowired
2
    ProductRepository productRepository;
3

4
  @Test
5
    public void testMatchSearch() {
6
        // 在调用的时候传递查询的参数值
7
        List<Goods> list = goodsRepository.matchSearch("荣耀手机");
8
        System.out.println(list);
9
    }

利用@Query注解结合分页参数，实现分页查询

1
    /*
2
          1. 针对一个查询结果，返回对应的一页数据
3
          2. Pageable参数是当想要获取分页数据的时候，必须携带的参数，表示分页信息
4
             比如，查询第多少页数据，每页多少条数据等，该参数不会用来替换我们的@Query字符串中的参数
5
          3. 返回的结果是一个包含一页文档数据的Page对象
6
     */
7
    @Query(
8
            " {" +
9
                    "   \"match\": {\n" +
10
                    "      \"title\": \"?0\"\n" +
11
                    "    }" +
12
                    "}"
13
    )
14
    Page<Goods> testSearchPage(String title, Pageable pageable);

1
    // 注入repository对象
2
    @Autowired
3
    private GoodsRepository goodsRepository;
4
   /*
5
          测试分页查询
6
     */
7
    @Test
8
    public void testSearchPage() {
9
        // 创建表示分页信息的Pageable对象
10
        // 表示查询第几页数据，这里一定要注意，页数是从0开始算的
11
        int page = 0;
12
        // 每页假设10个文档
13
        int pageCount = 10;
14

15
        // 调用Sort方法得到Sort对象，一个Sort对象表示
16
        Sort sort = Sort.by(Sort.Direction.ASC, "price");
17
        // PageRequest 是 Pageable接口子类对象
18
         PageRequest pageInfo = PageRequest.of(page, pageCount,sort);
19

20
        // 这里的Page对象可以被看做是List
21
        Page<Goods> pageResult = goodsRepository.testSearchPage("小米手机", pageInfo);
22

23
        // 遍历集合，从每个SearchHit对象中取出文档对象,
24
        // 如果需要返回可以在遍历的时候将其，放入一个List中返回
25
        pageResult.forEach( goods -> {
26
            // 访问查询到的一条文档
27

28
            // ...
29
        });
30

31
        // 获取满足条件的总的文档数量
32
        long totalElements = pageResult.getTotalElements();
33

34
    }

展开收起

@Query注解 + @Highlight + 分页参数实现高亮，分页自定义查询

1
    @Query(
2
            "  {  \"match\": {\n" +
3
                    "      \"title\": \"?0\"\n" +
4
                    "    }" +
5
                    "}"
6
    )
7
    @Highlight(
8
            fields = {
9
                    @HighlightField(name = "title",
10
                            parameters = @HighlightParameters(
11
                                    preTags = "<font color='red'>", postTags = "</font>"))
12
            }
13
    )
14
    List<SearchHit<Goods>> testHighlight(String title, Pageable pageable);

1
@Test
2
    public void testHighlight() {
3
        // 分页参数
4
        PageRequest of = PageRequest.of(0, 10);
5

6
        // 调用Repository方法获取搜索结果
7
        List<SearchHit<Goods>> result = goodsRepository.testHighlight("小米手机", of);
8

9
        // 结果集
10
        List<Goods> itemDocuments = new ArrayList<>();
11

12
        result.forEach(hit -> {
13
            // 获取目标文档
14
            Goods content = hit.getContent();
15
            // 获取高亮字段title对应的高亮字符串
16
            List<String> title = hit.getHighlightField("title");
17
            // 在文档对象中，用高亮字符串替换掉原来的值
18
            content.setTitle(title.get(0));
19
            // 加入结果集
20
            itemDocuments.add(content);
21
        });
22

23
        System.out.println(itemDocuments.size());
24

25
    }

展开收起

虽然，testHighlight方法既实现了分页查询，又实现了高亮查询，但是有一个缺陷就是，该方法无法获取到满足查询条件的总的文档数量，它只会返回满足条件的一页文档数据。不知道满足条件的文档总数，前端就无法完成分页。

所以，很明显Repository好用，但是具有一定的局限性，如果面对比较复杂的查询，此时就只能使用Spring Data Elasticsearch提供的另外一个工具ElasticsearchRestTemplate了。

ElasticsearchRestTemplate#

构造自定义分页，高亮，nested以及聚合查询，并发起请求

1
    @Autowired
2
    ElasticsearchRestTemplate restTemplate;
3

4
    @Autowired
5
    GoodsConverter goodsConverter;
6

7
    @Test
8
    public void testRestTemplate() {
9
        // 该Builder包含所有搜索请求的参数
10
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
11

12

13
        // 获取bool查询Builder
14
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
15

16

17
        // 构造bool查询中match查询
18
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("title", "小米手机");
19
        // 将该查询加入bool查询must中
20
        boolQueryBuilder.must(matchQuery);
21

22
        TermQueryBuilder subQueryForAttrNested = QueryBuilders.termQuery("attrs.attrValue", "8G");
23
        // 构造nested查询
24
        NestedQueryBuilder attrsNestedQuery = QueryBuilders.nestedQuery("attrs", subQueryForAttrNested, ScoreMode.None);
25
        // 将nested查询作为一个过滤条件
26
        boolQueryBuilder.filter(attrsNestedQuery);
27

28

29
        // 将整个bool查询添加到NativeSearchQueryBuilder
30
        queryBuilder.withQuery(boolQueryBuilder);
31

32
        // 构造分页参数
33
        //PageRequest price = PageRequest.of(0, 10, Sort.by(Sort.Order.desc("price")));
34
        PageRequest price = PageRequest.of(0, 10);
35
        // 向NativeSearchQueryBuilder添加分页参数
36
        queryBuilder.withPageable(price);
37

38
        // 按照指定字段值排序
39
        FieldSortBuilder priceSortBuilder = SortBuilders.fieldSort("price").order(SortOrder.ASC);
40
        queryBuilder.withSort(priceSortBuilder);
41

42
        // 构造高亮参数
43
        HighlightBuilder highlightBuilder = new HighlightBuilder();
44
        highlightBuilder.field("title").preTags("<font color='red'>").postTags("</font>");
45
        // 向NativeSearchQueryBuilder添加高亮参数
46
        queryBuilder.withHighlightBuilder(highlightBuilder);
47

48
        // 设置品牌聚合(平台属性等的聚合也是相同的方式)
49
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("tmIdAgg").field("tmId")
50
                .subAggregation(AggregationBuilders.terms("tmNameAgg").field("tmName"))
51
                .subAggregation(AggregationBuilders.terms("tmLogoUrlAgg").field("tmLogUrl"));
52

53

54
        // 向NativeSearchQueryBuilder添加聚合参数
55
        queryBuilder.addAggregation(termsAggregationBuilder);
56

57
        // 设置文档中返回的字段
58
        FetchSourceFilter fetchSourceFilter = new FetchSourceFilter(new String[]{"id", "defaultImg", "title", "price"}, null);
59
        queryBuilder.withSourceFilter(fetchSourceFilter);
60

61
        // 使用ElasticsearchRestTemplate发起搜索请求
62
        NativeSearchQuery build = queryBuilder.build();
63
        SearchHits<Goods> search = restTemplate.search(build, Goods.class);
64

65
        //封装所有的查询数据
66
        SearchResponseDTO searchResponseDTO = new SearchResponseDTO();
67

68
        // 获取满足条件的总文档数量
69
        long totalHits = search.getTotalHits();
70
        // 设置查询到的总文档条数
71
        searchResponseDTO.setTotal(totalHits);
72

73

74
        // 获取包含所有命中文档的SearchHit对象
75
        List<SearchHit<Goods>> searchHits = search.getSearchHits();
76

77

78
        // 处理搜索到的结果集即SearchHit<Goods>集合, 并使用高亮字符串替换
79
        List<GoodsDTO> goodsList = searchHits.stream().map(hit -> {
80
            // 获取命中的文档
81
            Goods content = hit.getContent();
82

83
            //获取高亮字段
84
            List<String> title = hit.getHighlightField("title");
85

86
            // 用高亮字段替换
87
            content.setTitle(title.get(0));
88
            // 将Goods对象转化为GoodsDTO对象
89
            GoodsDTO goodsDTO = goodsConverter.goodsPO2DTO(content);
90
            return goodsDTO;
91
        }).collect(Collectors.toList());
92

93
        // 设置查询到的结果列表
94
        searchResponseDTO.setGoodsList(goodsList);
95

96
        // 从品牌聚合中获取品牌集合
97

98
        // 根据id获取品牌id terms聚合结果
99
       Terms terms = (Terms) searchResponse.getAggregations().aggregations().get("tmIdAgg");
100
        List<SearchResponseTmDTO> trademarkList = terms.getBuckets().stream().map(tmIdBucket -> {
101
            // 封装品牌数据
102
            SearchResponseTmDTO searchResponseTmDTO = new SearchResponseTmDTO();
103

104
            String tmIdStr = tmIdBucket.getKeyAsString();
105
            // 获取品牌id
106
            Long tmId = Long.parseLong(tmIdStr);
107
            // 设置品牌id
108
            searchResponseTmDTO.setTmId(tmId);
109

110
            // 获取品牌名称聚合(子聚合)
111
            Terms tmNameAgg = tmIdBucket.getAggregations().get("tmNameAgg");
112
            // 通过聚合桶的名称获取品牌名称
113
            String tmName = tmNameAgg.getBuckets().get(0).getKeyAsString();
114
            // 设置品牌名称
115
            searchResponseTmDTO.setTmName(tmName);
116

117

118
            // 获取品牌logo聚合(子聚合)
119
            Terms tmLogoUrlAgg = tmIdBucket.getAggregations().get("tmLogoUrlAgg");
120
            // 通过聚合桶的名称获取品牌名称
121
            String tmLogoUrl = tmLogoUrlAgg.getBuckets().get(0).getKeyAsString();
122
            // 设置品牌名称
123
            searchResponseTmDTO.setTmLogoUrl(tmLogoUrl);
124

125
            return searchResponseTmDTO;
126
        }).collect(Collectors.toList());
127

128
        // 设置聚合品牌数据
129
        searchResponseDTO.setTrademarkList(trademarkList);
130

131
        // .....
132

133
    }

展开收起

引入搜索服务#

商品上下架#

我们什么时候向ES中添加SKU商品数据呢？因为一个商品一旦上架，就应该是可以被搜索到的，所以当SKU商品上架的时候，我们需要向ES添加SKU商品数据。同理，当一个SKU商品下架的时候，该商品就不应该再被用户搜索到了，所以，当一个SKU商品下架的时候，我们应该从ES中删除该SKU商品的信息。

所以接下来在service-product中，我们需要修改上下架的SKU商品的代码

1
@RestController
2
@RequestMapping("api/list")
3
public class ListApiController {
4

5
    @Autowired
6
    private SearchService searchService;
7

8
    @Autowired
9
    private ElasticsearchRestTemplate restTemplate;
10

11

12
    /**
13
     * 上架商品
14
     * @param skuId
15
     * @return
16
     */
17
    @GetMapping("inner/upperGoods/{skuId}")
18
    public Result upperGoods(@PathVariable("skuId") Long skuId) {
19
    }
20

21
    /**
22
     * 下架商品
23
     * @param skuId
24
     * @return
25
     */
26
    @GetMapping("inner/lowerGoods/{skuId}")
27
    public Result lowerGoods(@PathVariable("skuId") Long skuId) {
28
    }
29
}

展开收起

1
public interface SearchService {
2

3
    /**
4
     * 上架商品列表
5
     * @param skuId
6
     */
7
    void upperGoods(Long skuId);
8

9
    /**
10
     * 下架商品列表
11
     * @param skuId
12
     */
13
    void lowerGoods(Long skuId);
14
}

1
@Service
2
public class SearchServiceImpl implements SearchService {
3

4
    @Autowired
5
    private ProductApiClient productFeignClient;
6

7

8
    @Autowired
9
    private GoodsRepository goodsRepository;
10

11
    @Autowired
12
    GoodsConverter goodsConverter;
13

14
    /**
15
     * 上架商品
16
     *
17
     * @param skuId
18
     */
19
    @Override
20
    public void upperGoods(Long skuId) {
21
        Goods goods = new Goods();
22
        //查询sku对应的平台属性
23
        List<PlatformAttributeInfoDTO> platformAttrInfoList = productFeignClient.getAttrList(skuId);
24
        if (null != platformAttrInfoList) {
25
            List<SearchAttr> searchAttrList = platformAttrInfoList.stream().map(baseAttrInfo -> {
26
                SearchAttr searchAttr = new SearchAttr();
27
                searchAttr.setAttrId(baseAttrInfo.getId());
28
                searchAttr.setAttrName(baseAttrInfo.getAttrName());
29
                //一个sku的一个平台属性，只对应一个属性值
30
                List<PlatformAttributeValueDTO> attrValueList = baseAttrInfo.getAttrValueList();
31
                searchAttr.setAttrValue(attrValueList.get(0).getValueName());
32
                return searchAttr;
33
            }).collect(Collectors.toList());
34

35
            goods.setAttrs(searchAttrList);
36
        }
37

38
        //查询sku信息
39
        SkuInfoDTO skuInfoDTO = productFeignClient.getSkuInfo(skuId);
40
        // 查询品牌
41
        TrademarkDTO baseTrademark = productFeignClient.getTrademark(skuInfoDTO.getTmId());
42
        if (baseTrademark != null) {
43
            goods.setTmId(skuInfoDTO.getTmId());
44
            goods.setTmName(baseTrademark.getTmName());
45
            goods.setTmLogoUrl(baseTrademark.getLogoUrl());
46

47
        }
48

49
        // 查询分类
50
        CategoryHierarchyDTO categoryView = productFeignClient.getCategoryView(skuInfoDTO.getThirdLevelCategoryId());
51
        if (categoryView != null) {
52
            goods.setFirstLevelCategoryId(categoryView.getFirstLevelCategoryId());
53
            goods.setFirstLevelCategoryName(categoryView.getFirstLevelCategoryName());
54
            goods.setSecondLevelCategoryId(categoryView.getSecondLevelCategoryId());
55
            goods.setSecondLevelCategoryId(categoryView.getSecondLevelCategoryName());
56
            goods.setThirdLevelCategoryId(categoryView.getThirdLevelCategoryId());
57
            goods.setThirdLevelCategoryName(categoryView.getThirdLevelCategoryName());
58
        }
59
        goods.setDefaultImg(skuInfoDTO.getSkuDefaultImg());
60
        goods.setPrice(skuInfoDTO.getPrice().doubleValue());
61
        goods.setId(skuInfoDTO.getId());
62
        goods.setTitle(skuInfoDTO.getSkuName());
63

64
        goodsRepository.save(goods);
65
    }
66

67
    /**
68
     * 下架商品
69
     *
70
     * @param skuId
71
     */
72
    @Override
73
    public void lowerGoods(Long skuId) {
74
           // 删除文档
75
        this.goodsRepository.deleteById(skuId);
76

77
        // 删除热度
78
        redissonClient.getScoredSortedSet("hotScore").remove("skuId:" + skuId);
79
    }
80
}

展开收起

这里需要注意一点的是，我们并没有在商品服务中定义FeignClient来调用商品服务，而是在后面学习消息中间件之后，利用发送消息的方式，通知搜索服务，实现SKU商品在ES中的上下架。

更新商品热度#

在ES中，我们希望在用户搜索到SKU商品后，我们可以按照SKU商品的热度排序，将最热门的商品排在前面。那么如何定义商品的热度呢？我们以商品的浏览量来定义商品的热度。因此每当一个SKU商品的详情数据被获取一次，我们就给它的热度加1。

1
    @GetMapping("api/list/inner/incrHotScore/{skuId}")
2
    public Result incrHotScore(@PathVariable("skuId") Long skuId) {
3
    }

1
/*
2
     该类用来ES根据条件查询到的每一个SKU商品信息
3
 */
4
@Data
5
public class GoodsDTO {
6

7
    // 商品Id skuId
8
    private Long id;
9

10
    // ...
11

12
    //  商品的热度！ 我们将商品被用户点查看的次数越多，则说明热度就越高！
13
    private Long hotScore = 0L;
14
}

1
public interface SearchService {
2

3
    // ...
4

5
    /**
6
     * 更新热点
7
     * @param skuId
8
     */
9
    void incrHotScore(Long skuId);
10
}

1
@Service
2
public class SearchServiceImpl implements SearchService {
3

4
    @Autowired
5
    private ProductApiClient productFeignClient;
6

7

8
    @Autowired
9
    private GoodsRepository goodsRepository;
10

11
    @Autowired
12
    GoodsConverter goodsConverter;
13

14
    //...
15

16
    @Autowired
17
    private RedissonClient redissonClient;
18

19
    @Override
20
    public void incrHotScore(Long skuId) {
21
        // 定义key
22
        String hotKey = "hotScore";
23
        // 保存数据
24
        Double hotScore = redissonClient.getScoredSortedSet(hotKey).addScore("skuId:" + skuId, 1);
25
        if (hotScore.longValue() % 10 == 0) {
26
            // 更新es
27
            Optional<Goods> optional = goodsRepository.findById(skuId);
28
            Goods goods = optional.get();
29
            goods.setHotScore(Math.round(hotScore));
30
            goodsRepository.save(goods);
31
        }
32
    }
33
}

展开收起

我们需要在每次获取商品详情数据的时候，增加该商品的热度(该SKU商品对应的文档的hotScore)，所以在商品服务中我们需要定义如下FeignClient用来调用搜索服务。

1
@FeignClient("service-search")
2
public interface SearchApiClient {
3

4
    /**
5
     * 更新商品incrHotScore
6
     * @param skuId
7
     * @return
8
     */
9
    @GetMapping("/api/list/inner/incrHotScore/{skuId}")
10
    Result incrHotScore(@PathVariable("skuId") Long skuId);
11
}

在商品服务中，需要修改获取商品详情页的代码，在增加SKU商品的热度

1
@Service
2
public class ItemServiceImpl implements ProductDetailService {
3

4
    @Autowired
5
    SpuService spuService;
6

7
    @Autowired
8
    SkuService skuService;
9

10
    @Autowired
11
    CategoryService categoryService;
12
    @Autowired
13
    private ThreadPoolExecutor threadPoolExecutor;
14

15
    @Autowired
16
    SearchApiClient searchApiClient;
17

18
    @Autowired
19
    RedissonClient redissonClient;
20

21
    @Override
22
    public ProductDetailDTO getItemBySkuId(Long skuId) {
23
       // ..., 增加热度
24
        searchApiClient.incrHotScore(skuId);
25
        return productDetailDTO;
26
    }
27
}

展开收起

条件查询#

在搜索服务中，实现搜索接口

1
    @GetMapping("/list")
2
    public Result list(SearchParam searchParam) throws IOException {
3

4
    }

1
public interface SearchService {
2

3
    /**
4
     * 搜索列表
5
     * @param searchParam
6
     * @return
7
     * @throws IOException
8
     */
9
    SearchResponseDTO search(SearchParam searchParam) throws IOException;
10
}

1
// 封装查询条件
2
@Data
3
public class SearchParam {
4
/*
5
前端携带的请求参数：?thirdLevelCategoryId=61&trademark=2:华为&props=23:4G:运行内存&order=1:desc
6
1. 三级类目：thirdLevelCategoryId=61
7
2. 品牌参数(可能有多个)：trademark=2:华为 2是品牌id，华为是品牌名称
8
3. 规格参数(平台属性，可能有多个):  props=23:4G:运行内存，23是属性id，4G是平台属性值，运行内存是属性名
9
4. 排序参数：order=1:desc，1表示按照热度排序，2表示按照价格排序
10
*/
11
    private Long firstLevelCategoryId;
12
    private Long secondLevelCategoryId;
13
    private Long thirdLevelCategoryId;
14
    // trademark=2:华为
15
    private String trademark;//品牌
16

17
    private String keyword;//检索的关键字
18

19
    // 排序规则
20
    // 1:hotScore 2:price
21
    private String order = ""; // 1：综合排序/热度  2：价格
22

23
    // props=23:4G:运行内存
24
    //平台属性Id 平台属性值名称 平台属性名
25
    private String[] props;//页面提交的数组
26

27
    private Integer pageNo = 1;//分页信息
28
    private Integer pageSize = 3; // 每页默认显示的条数
29
}

展开收起

1
    @Override
2
    public SearchResponseDTO search(SearchParam searchParam) throws IOException {
3
        // 构建dsl语句
4
        NativeSearchQueryBuilder nativeSearchQueryBuilder = buildQueryDsl(searchParam);
5
        NativeSearchQuery searchQuery = nativeSearchQueryBuilder.build();
6
        SearchHits<Goods> searchResults = restTemplate.search(searchQuery, Goods.class);
7

8
        //解析查询结果
9
        SearchResponseDTO responseDTO = parseSearchResult(searchResults);
10

11

12
        //设置满足条件的总记录数
13
        responseDTO.setTotal(searchResults.getTotalHits());
14
        // 响应中设置一页的文档数量
15
        responseDTO.setPageSize(searchParam.getPageSize());
16
        // 响应中设置当前页数
17
        responseDTO.setPageNo(searchParam.getPageNo());
18
        // 计算总页数
19
        long totalPages = (responseDTO.getTotal() + searchParam.getPageSize() - 1) / searchParam.getPageSize();
20
        if (totalPages == 0) {
21
            // 前端的页数是从1开始的
22
            totalPages = 1;
23
        }
24
        responseDTO.setTotalPages(totalPages);
25
        return responseDTO;
26
    }

展开收起

1
 // 制作dsl 语句
2
    private NativeSearchQueryBuilder buildQueryDsl(SearchParam searchParam) {
3
        // 构建查询器
4
        NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
5

6
        // 构建boolQueryBuilder
7
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
8
        // 构造关键字查询参数
9
        buildKeyQuery(searchParam, boolQueryBuilder);
10
        // 构建品牌查询 trademark=2:华为
11
        buildTrademarkQuery(searchParam, boolQueryBuilder);
12

13
        // 构造类目查询
14
        buildCategoryQuery(searchParam, boolQueryBuilder);
15

16
        // 构建平台属性查询 23:4G:运行内存(可能有多个查询，这个例子只是一个平台属性或者叫规格参数)
17
        BuildSpecificQuery(searchParam, boolQueryBuilder);
18
        // 设置整个复合查询
19
        nativeSearchQueryBuilder.withQuery(boolQueryBuilder);
20
        // 构建分页(es中的页数从0开始)
21
        PageRequest pageRequest = PageRequest.of(searchParam.getPageNo() - 1, searchParam.getPageSize());
22
        nativeSearchQueryBuilder.withPageable(pageRequest);
23

24
        // 构造排序参数 order=1:desc  1为按热度排序，2为按照价格排序
25
        buildSort(searchParam, nativeSearchQueryBuilder);
26

27
        // 构建高亮
28
        HighlightBuilder highlightBuilder = new HighlightBuilder();
29
        highlightBuilder.field("title").postTags("</span>").preTags("<span style=color:red>");
30
        nativeSearchQueryBuilder.withHighlightBuilder(highlightBuilder);
31

32
        //  构造品牌聚合
33
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("tmIdAgg").field("tmId")
34
                .subAggregation(AggregationBuilders.terms("tmNameAgg").field("tmName"))
35
                .subAggregation(AggregationBuilders.terms("tmLogoUrlAgg").field("tmLogoUrl"));
36
        // 设置品牌聚合
37
        nativeSearchQueryBuilder.addAggregation(termsAggregationBuilder);
38

39
        //  构造平台属性聚合
40
        NestedAggregationBuilder nestedAggregationBuilder = AggregationBuilders.nested("attrAgg", "attrs")
41
                .subAggregation(AggregationBuilders.terms("attrIdAgg").field("attrs.attrId")
42
                        .subAggregation(AggregationBuilders.terms("attrNameAgg").field("attrs.attrName"))
43
                        .subAggregation(AggregationBuilders.terms("attrValueAgg").field("attrs.attrValue")));
44
        //  设置平台属性聚合
45
        nativeSearchQueryBuilder.addAggregation(nestedAggregationBuilder);
46

47

48
        // 设置结果集过滤
49
        String[] fields = {"id","title","price","defaultImg"};
50
        FetchSourceFilter fetchSourceFilter = new FetchSourceFilter(fields,null);
51
        nativeSearchQueryBuilder.withSourceFilter(fetchSourceFilter);
52

53
        return nativeSearchQueryBuilder;
54
    }

展开收起

单点登录

Sun, 14 Jun 2026 00:00:00 GMT

功能介绍#

问题的引出#

在微服务架构中，我们的整个应用被分解为登录的用户才能访问这些接口，比如查询用户的订单，查看用户的购物车，或者用户个人资料等等接口。但是还有另外一些服务的另外一些接口的访问，是不需要登录的，比如获取电商网站首页的商品类目，查看商品详情等等接口。

我们先来简单回顾下，单体架构中的登录，以及登录身份认证过程

在微服务架构中，我们按照相同的方式，再来分析下登录，以及登录身份认证过程：

假设用户在没有登录的情况下，发起查看购物车的请求：

当请求转发给订服务的时候，订单服务，订单服务发现用户的请求中没有包含JsessionId的Cookie，认为用户没登录，于是给前端返回需要登录的响应码，前端自动跳转到登录页面。
在登录界面，用户提交用户名和密码，向登录服务发起请求，登录服务验证用户发送的用户名和密码无误后，创建session，并返回包含JsessionId的Cookie
登录成功后，用户再次发起查看订单的请求，此时虽然携带了包含JsessionId的Cookie，但是这个JsessionId对应却并不是订单服务中的某一个Session的id，即在订单服务中找不到与此JssionId对应的Session，于是订单服务还是认为用户未登录。

经过以上分析，我们发现，在微服务架构中，适用于单体应用的登录以及登录验证逻辑，在微服务架构中不适用了。所以，在微服务架构中，我们就需要解决单点登录问题——Single Sign On，简称为 SSO，是比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。

解决思路#

要解决单点登录问题，思路不止一种，在我们的项目中，我们采用共享会话的方案来解决。

这个思路的核心要点，当用户登录成功之后，将用户的会话信息，存储在一个共享的地方(比如Redis)，而不是某个服务的内存中，这样一来就可以通过访问共享会话来判断用户的登录状态。

对于用户服务而言:

一旦判断用户登录成功，就将用户信息存储到Redis，这就相当于将用户登录之后的会话，存储到Redis中。
同时，随机生成Token，作为Redis中，会话信息的key，通过该Token获取Redis中对应的共享会话信息
该Token还需要返回给前端。

对于前端而言，只要用户登陆成功，就会接收到Redis中，登录会话对应的Token，前端就会在请求Cookie中携带该Token，发起请求的时候，会在请求中携带该Cookie。

对于服务而言：

因为所有的请求都是经过网关的，所以登录身份认证的工作，没有必要在每个服务中完成，而是统一在网关中完成即可
所以网关会拦截那些需要做登录身份认证的请求，并根据请求中携带是否携带Cookie，以及通过Cookie中的Token是否能在Redis中获取登录会话，来判断用户是否登录过。

登录实现#

在项目中引入用户服务

![](/assets/firefly-docs/microservice/microservice-20-sso/introduce user-3.png)

在登录页面输入用户名和密码后，点击登录提交登录请求，在用户服务中，需要实现如下Controller方法

1
@RestController
2
public class LoginController {
3

4
    @Autowired
5
    private UserService userService;
6

7
    @Autowired
8
    private RedissonClient redissonClient;
9

10
    /**
11
     * 登录
12
     */
13
    @PostMapping("/user/login")
14
    public Result login(@RequestBody UserInfoParam userInfo, HttpServletRequest request) {
15
        // 生成uuid字符串，作为Redis存储登录会话的key
16
        String token = UUID.randomUUID().toString().replaceAll("-", "");
17
        // 从当前请求中，获取请求发起的IP地址
18
        String ipAddress = IpUtil.getIpAddress(request);
19
        UserLoginDTO loginInfo = userService.login(userInfo, ipAddress, token);
20
        if (loginInfo != null) {
21
            // 登录匹配成功
22
            return Result.ok(loginInfo);
23
        }
24

25
        return Result.build(null, UserCodeEnum.USER_LOGIN_CHECK_FAIL);
26
    }
27

28
}

展开收起

还有实现登录的业务接口

1
public interface UserService {
2

3
    /**
4
     * 登录方法
5
     */
6
    UserLoginDTO login(UserInfoParam userInfo, String ip, String token);
7

8
}

1
    @Override
2
    public UserLoginDTO login(UserInfoParam userInfo, String ip, String token) {
3
        // select * from userInfo where userName = ? and passwd = ?
4
        // 注意密码是MD5密文存储
5
        String passwd = userInfo.getPasswd(); //123
6
        String newPasswd = DigestUtils.md5DigestAsHex(passwd.getBytes());
7

8
        LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
9
        queryWrapper.eq(UserInfo::getLoginName, userInfo.getLoginName());
10
        queryWrapper.eq(UserInfo::getPasswd, newPasswd);
11
        UserInfo info = userInfoMapper.selectOne(queryWrapper);
12
        if (info == null) {
13
            // 未查询到，匹配登录失败
14
            return null;
15
        }
16
        // 登录匹配成功，则向redis保存用户登录信息
17
        UserLoginInfoDTO userLoginInfo = new UserLoginInfoDTO();
18
        // 登录用户id
19
        userLoginInfo.setUserId(info.getId().toString());
20
        // 登录用户id
21
        userLoginInfo.setIp(ip);
22
        // 获取存储登录会话的桶
23
        RBucket<UserLoginInfoDTO> bucket = redissonClient.getBucket(UserConstants.USER_LOGIN_KEY_PREFIX  + token);
24
        // 向桶中存储用户id和ip地址，相当于保存登录会话
25
        bucket.set(userLoginInfo, UserConstants.USERKEY_TIMEOUT, TimeUnit.SECONDS);
26
        // 返回用户昵称和登录会话token
27
        return new UserLoginDTO(info.getNickName(), token);
28
    }

展开收起

登录验证逻辑实现#

首先，gateway工程中需要引入user-api依赖

1
        <dependency>
2
            <groupId>com.cskaoyan.mall</groupId>
3
            <artifactId>user-api</artifactId>
4
            <version>1.0-SNAPSHOT</version>
5
        </dependency>

1
/**
2
 * 全局过滤器
3
 * 对所有的请求进行拦截(在这个商城中，不是所有的请求都需要登录，只有部分业务的接口才需要登录）
4
 * 如果已经登录，那么放行
5
 * 如果没有登录，那么拦截
6
 *
7
 */
8
@Component
9
public class AuthFilter implements GlobalFilter {
10

11
    @Value("${authUrls.url}")
12
    String authUrl;                 //  /*/auth/**
13

14

15
    // 创建一个路径匹配工具
16
    AntPathMatcher antPathMatcher = new AntPathMatcher();
17

18

19
    @Autowired
20
    RedissonClient redissonClient;
21

22

23
    @Override
24
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
25

26
        // 1. 获取当前请求的路径
27
        ServerHttpRequest request = exchange.getRequest();
28
        ServerHttpResponse response = exchange.getResponse();
29

30
        // 获取path
31
        String path = request.getURI().getPath();
32

33
        // 如果path是内部的接口 /api/*/inner/** , 要拦截
34
        // TODO
35

36
        // 2. 根据请求的路径判断是否需要登录
37
        boolean isNeedLogin = judgeLogin(path);
38

39

40
        // 3. 判断当前用户是否已经登录
41
        String userId = hasLogin(request);
42

43
        // 如果ip被盗用了，那么拦截
44
        if ("-1".equals(userId)) {
45
            return out(response, ResultCodeEnum.ILLEGAL_REQUEST);
46
        }
47

48
        // 4. 如果当前路径需要登录且用户未登录，拦截
49
        if (isNeedLogin && StringUtils.isEmpty(userId)) {
50
            return out(response, ResultCodeEnum.LOGIN_AUTH);
51
        }
52

53
        // 5. 对于其他的情况,放行
54
            // 当前路径不需要登录
55
            // 当前路径需要登录且用户已经登录
56
        ServerHttpRequest.Builder builder = request.mutate();       // 复制一个新的请求头
57
        if (!StringUtils.isEmpty(userId)) {
58
            // 把用户id放到请求头中去，方便后续服务直接从请求头中获取用户id
59
            // 因为在此已经获取过一次用户id了，如果不做任何操作，直接放行，
60
            // 那么后续各个服务收到请求之后，还是需要根据请求中的token查询Redis
61
            builder.header("userId", userId);
62
        }
63

64
        // 为了方便购物车的业务逻辑，可以也统一的把临时用户id放入请求头
65
        String userTempId = this.getUserTempId(request);
66

67
        // 把临时用户id放入请求头
68
        if (!StringUtils.isEmpty(userTempId)) {
69
            builder.header("userTempId", userTempId);
70
        }
71

72
        ServerHttpRequest newRequest = builder.build();
73
        // 把newRequest放入exchange对象
74
        ServerWebExchange newExChange = exchange.mutate().request(newRequest).build();
75

76
        return chain.filter(newExChange);
77

78
    }
79

80
    // 用户临时用户id
81
    private String getUserTempId(ServerHttpRequest request) {
82

83
        String userTempId = request.getHeaders().getFirst("userTempId");
84
        if (StringUtils.isEmpty(userTempId)) {
85
            // 从请求的cookie中获取token
86
            HttpCookie httpCookie = request.getCookies().getFirst("userTempId");
87
            if (httpCookie != null) {
88
                userTempId = httpCookie.getValue();
89
            }
90
        }
91

92
        return userTempId;
93

94
    }
95

96
    /**
97
     * 获取用户信息
98
     * @param request
99
     * @return
100
     * null: 说明用户未登录
101
     * “-1”: 说明 ip被盗用了
102
     * userId：说明用户已登录
103
     */
104
    private String hasLogin(ServerHttpRequest request) {
105

106

107
        // 1. 获取令牌
108

109
        // 从请求头中获取 token
110
        String token = request.getHeaders().getFirst("token");
111
        if (StringUtils.isEmpty(token)) {
112
            // 从请求的cookie中获取token
113
            HttpCookie httpCookie = request.getCookies().getFirst("token");
114
            if (httpCookie != null) {
115
                token = httpCookie.getValue();
116
            }
117
        }
118

119
        // 2. 如果没有令牌，那么返回null,表示用户未登录
120
        if (StringUtils.isEmpty(token)) {
121
            return null;
122
        }
123
        // 3. 如果有令牌，返回通过令牌查询Redis, 获取用户信息
124
        String key = UserConstants.USER_LOGIN_KEY_PREFIX + token;
125
        RBucket<UserLoginInfoDTO> bucket = redissonClient.getBucket(key);
126

127
        UserLoginInfoDTO userLoginInfoDTO = bucket.get();
128
        // 4. 如果用户信息获取失败，那么说明这个令牌无效，返回null,表示用户未登录
129
        if (userLoginInfoDTO == null) {
130
            return null;
131
        }
132

133
        // 5. 因为在登录的时候，记录了用户的ip
134
        // 那么在此处进行拦截，验证用户是否已经登录，也可以获取当前客户端的ip
135
        // 如果redis中的ip和当前请求的ip是一致的，说明是来自同一台主机的请求（登录主机和现在发请求的是同一台主机）
136
        // 如果不一致，说明登录的主机和当前发请求的主机，不同同一台主机（有可能是token被盗用了）
137
        String ip = userLoginInfoDTO.getIp();
138
        String currentIp = IpUtil.getGatwayIpAddress(request);
139

140
        if (!ip.equals(currentIp)) {
141
            return "-1";
142
        }
143
        // 6. 如果这个令牌查到了用户信息，那么说明用户已经登录，那么返回用户id
144
        String userId = userLoginInfoDTO.getUserId();
145

146
        return userId;
147

148
    }
149

150
    /**
151
     * 判断当前路径的请求是否需要登录
152
     * @param path
153
     * @return
154
     *
155
     * /index
156
     * /order/auth/getOrder
157
     */
158
    private boolean judgeLogin(String path) {
159

160
        boolean ret = antPathMatcher.match(authUrl, path);
161

162
        return ret;
163
    }
164

165
    // 接口鉴权失败返回数据
166
    private Mono<Void> out(ServerHttpResponse response, ResultCodeEnum resultCodeEnum) {
167
        // 返回用户没有权限登录
168
        Result<Object> result = Result.build(null, resultCodeEnum);
169
        // 将result对象转化为json字符串，并将字符串转化为字节数据
170
        byte[] bits = JSONObject.toJSONString(result).getBytes(StandardCharsets.UTF_8);
171
        // 封装一个字节数据为一个DataBuffer，消息体数据
172
        DataBuffer wrap = response.bufferFactory().wrap(bits);
173
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
174
        // 输出到页面
175
        return response.writeWith(Mono.just(wrap));
176
    }
177

178

179
    public static void main(String[] args) {
180

181
        /**
182
         * SpringMVC用来做路径匹配的工具
183
         */
184
        AntPathMatcher antPathMatcher = new AntPathMatcher();
185

186
        String path = "/order/auth/getOrder";
187
        boolean ret = antPathMatcher.match("/*/auth/**", path);
188

189
        System.out.println(ret);
190

191

192
    }
193
}

展开收起

退出登录#

退出登录的思路就很简单了，我们只需要在Redis中删除，用户对应的登录会话即可，这样一来，下次访问需要登录的接口时，就会因为获取不到用户在Redis中获取到登录会话，而被要求重新登录了

1
@RestController
2
@RequestMapping("/user")
3
public class LoginController {
4

5
    @Autowired
6
    private UserService userService;
7

8
    @Autowired
9
    private RedissonClient redissonClient;
10

11
    /**
12
     * 退出登录
13
     * @param request
14
     * @return
15
     */
16
    @GetMapping("logout")
17
    public Result logout(HttpServletRequest request){
18
        RBucket<String> token = redissonClient.getBucket(UserConstants.USER_LOGIN_KEY_PREFIX + request.getHeader("token"));
19
        token.delete();
20
        return Result.ok();
21
    }
22
}

展开收起

购物车

Sun, 14 Jun 2026 00:00:00 GMT

表结构分析#

购物车不入MySQL数据库，所以没有表

存入Redis，考虑使用Hash数据结构存储用户的购物车。

Terminal window

1
key：用户id
2
       field：商品id
3
       value：CartInfoDTO

image-20230322150810580

业务功能#

添加购物车#

通过上图可知，在添加购物车的业务中，需要完成的接口如下

图中第一步。

功能描述：就是把商品添加到购物车，不用考虑是临时用户还是已经登录的用户

1
·
2

3
    // 获取用户id
4
    String userId = AuthContext.getUserId(request);
5
    if (StringUtils.isBlank(userId)) {
6
      userId = AuthContext.getUserTempId(request);
7
    }
8

9
    // 添加商品到购物车
10
    cartService.addToCart(skuId,userId,skuNum);
11

12
    return Result.ok();
13
}

添加商品到购物车

1
public void addToCart(Long skuId, String userId, Integer skuNum) {
2
    // 这里可以使用我们定义好的前后缀常量构造购物车的key：RedisConst.USER_KEY_PREFIX + userId + RedisConst.USER_CART_KEY_SUFFIX(user:userId:cart)
3

4
    // 获取用户购物车
5

6
    // 查看用户购物车中是否包含该商品
7

8
    // 如果包含，更新数量（根据skuId，获取购物车中的CartInfoDTO, 修改数量）
9

10
    // 如果不包含，添加商品到购物车(根据skuId调用商品服务(skuName, skuPrice, defaultImg) + skuNum ——> CartInfoDTO)
11

12
}

展示购物车列表#

查看用户的购物车列表

1
@GetMapping("/cart")
2
public Result cartList(HttpServletRequest request) {
3
    // 获取用户Id
4
    String userId = AuthContext.getUserId(request);
5
    // 获取临时用户Id
6
    String userTempId = AuthContext.getUserTempId(request);
7

8
    // 调用购物车服务，获取用户的购物车列表
9
    // 如果userId不为空且userTempId也不为空，那么意味着要合并购物车，并删除用户临时用户的购物车
10
    List<CartInfoDTO> cartInfoList = cartService.getCartList(userId, userTempId);
11

12
    return Result.ok(cartInfoList);
13
}

合并购物车思路：注意在获取用户购物车数据时，使用和添加购物车时的key相同

1
public List<CartInfoDTO> getCartList(String userId, String userTempId) {
2

3
    // 1. 如果userId为空，那么表示用户未登录，直接返回用户userTempId的临时购物车列表
4

5
    // 2. 如果userId不为空，那么表示用户已经登录
6

7
    // 3. 查询出已经登录的购物车、查询出未登录的购物车
8

9
    // 4. 如果未登录的购物车为空，那么直接返回已经登录的购物车
10

11
    // 5. 如果未登录的购物车不为空，那么需要合并 未登录和已登录的购物车，得到合并之后的购物车
12
       // 合并需要注意 同一个商品的数量和状态(合并之后的数据，放到用户登录之后的购物车)
13

14
    // 6. 把合并之后的购物车的商品进行排序，按照添加购物车的时间排序
15

16
    // 7. 更新用户userId的购物车
17

18
    // 8. 删除用户临时Id userTempId的购物车
19

20
    // 9. 返回合并之后的购物车
21
}

展开收起

选中状态变更#

image-20230314175053879

请求：PUT /cart/check/5/0
参数 5: 表示商品的skuId
参数 0: 表示商品在购物车中的状态，1表示选中，0表示未选中，默认为1

1
@PutMapping("cart/check/{skuId}/{isChecked}")
2
public Result checkCart(@PathVariable Long skuId, @PathVariable Integer isChecked,
3
HttpServletRequest request)
4
{
5

6
    // TODO
7
    // 修改指定用户购物车中指定商品的 isChecked状态
8

9
  return Result.ok();
10
}

删除购物车#

删除对应的商品#

image-20230314180244957

请求： DELETE /cart/38

1
@DeleteMapping("/cart/{skuId}")
2
public Result deleteCart(@PathVariable("skuId") Long skuId, HttpServletRequest request) {
3
    //注意在获取用户购物车数据时，使用和添加购物车时的key相同
4
  // TODO
5
    // 删除指定用户购物车中指定的商品
6

7
    return Result.ok();
8

9
}

删除已选中的商品#

image-20230314215333009

请求： DELETE /cart/checked

1
@DeleteMapping("/cart/checked")
2
public Result deleteChecked(HttpServletRequest request) {
3

4
    // 注意在获取用户购物车数据时，使用和添加购物车时的key相同
5
        // 根据userId先获取购物车数据
6

7

8

9
        // TODO
10
        // 遍历购物车中的购物车商品数据，删除用户购物车中所有已经被选中的商品
11
        return Result.ok();
12
}

RocketMQ

Sun, 14 Jun 2026 00:00:00 GMT

简介#

消息中间件是什么？#

中间件：顾名思义介于两者之间的一个技术

img

消息中间件：消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。

RocketMQ是什么？#

RocketMQ是阿里巴巴开源的一个消息中间件，是一个队列（FIFO）模型的消息中间件，具有高性能、高可靠、高实时、分布式特点。目前已贡献给apache

参考阅读链接：RocketMQ的前世今生

功能#

异步化#

将一些可以进行异步化的操作通过发送消息来进行异步化，提高效率

具体场景：用户为了使用某个应用，进行注册，系统需要发送注册邮件并验证短信。对这两个操作的处理方式有两种：串行及并行。

串行方式：新注册信息生成后，先发送注册邮件，再发送验证短信

img

在这种方式下，需要最终发送验证短信后再返回给客户端。
并行处理：新注册信息写入后，发短信和发邮件并行处理

img

在这种方式下，发短信和发邮件需处理完成后再返回给客户端。

假设以上三个子系统处理的时间均为50ms，且不考虑网络延迟，则总的处理时间：

串行：50 + 50 + 50 = 150ms 并行：50 + 50 = 100ms
使用消息队列

img

并在写入消息队列后立即返回成功给客户端，则总的响应时间依赖于写入消息队列的时间，而写入消息队列的时间本身是可以很快的，基本可以忽略不计，因此总的处理时间相比串行提高了2倍，相比并行提高了一倍；

什么样的操作可以异步化呢？

这一步操作的执行结果不会影响到主业务的执行结果，即主业务的处理结果不依赖于这个可以异步化的操作的执行结果

限流削峰#

在高并发场景下把请求存入消息队列，利用排队思想降低系统瞬间峰值

具体场景：购物网站开展秒杀活动，一般由于瞬时访问量过大，服务器接收过大，会导致流量暴增，相关系统无法处理请求甚至崩溃。而加入消息队列后，系统可以从消息队列中取数据，相当于消息队列做了一次缓冲。

img

优点：

请求先入消息队列，而不是由业务处理系统直接处理，做了一次缓冲,极大地减少了业务处理系统的压力；
事实上，秒杀时，后入队列的用户无法秒杀到商品，这些请求可以直接被抛弃，返回活动已结束或商品已售完信息；

对比#

消息中间件不仅仅只有RocketMQ，市面上还有很多其他的消息中间件，这里列举几个常见的和RocketMQ作为一个对比

ActiveMQ：ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，是使用Java语言编写的。

1
JMS: 全称是Java Message Service,即消息服务应用程序接口，是一个Java面向消息中间件平台的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信

RabbitMQ：AMQP协议的领导实现，支持多种场景。淘宝的MySQL集群内部有使用它进行通讯，OpenStack开源云平台的通信组件，最先在金融行业得到运用，使用Erlang语言编写的。

1
AMQP: 即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计

Kafka: Kafka是最初由Linkedin公司开发，是一个分布式、支持分区的（partition）、多副本的（replica），基于zookeeper协调的分布式消息系统，它的最大的特性就是可以实时的处理大量数据以满足各种需求场景：比如基于hadoop的批处理系统、低延迟的实时系统、storm/Spark流式处理引擎，web/nginx日志、访问日志，消息服务等等，用scala语言编写，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。

img

1
1. activeMQ: 实现了JMS接口，比较老，性能不是很好。现在基本没有公司在使用了
2

3
2. RabbitMQ: 消息延迟低，作为消息队列，功能比较多，而且有管理后台，国内有一些小公司在使用（缺点就是 消息的堆积能力不够），因为消息延迟低，所以在金融领域使用广泛。
4

5
3. Kafka：消息堆积能力强，支持集群。但是作为消息中间件，功能不够多，但是消息堆积能力很强。通常在大数据领域广泛应用。
6

7

8
4. RocketMQ：消息堆积能力强，支持集群， 功能比较多，而且有管理后台， 缺点就是使用Java语言编写的，效率不是特别高。

模型（RocketMQ）#

概念模型#

Producer：消息生产者，负责消息的产生，由业务系统负责产生
Consumer：消息消费者，负责消息消费，由后台业务系统负责异步消费
Topic：消息的逻辑管理单位（消息的一个属性，并且每个消息都一定有这个属性）

这三者是RocketMq中最最基本的概念。Producer是消息的生产者。Consumer是消息的消费者。消息通过Topic进行传递。Topic存放的是消息的逻辑地址。

image-20210714110247255

具体来说是Producer将消息发往具体的Topic。Consumer订阅Topic，主动拉取或被动接受消息，如果Consumer消费消息失败则默认会重试16次

Broker: 消息的中转角色，负责存储消息，转发消息，一般也称为server，可以理解为一个存放消息的服务，里面可以有多个Topic
MessageQueue: 消息的物理管理单位，一个Topic下有多个Queue，默认一个Topic创建时会创建四个MessageQueue
ConsumerGroup: 具有同样消费逻辑消费同样消息的Consumer，可以归并为一个group
ProducerGroup: 具有同样属性的一些Producer可以归并为同一个Group

同样属性是指：发送同样Topic类型的消息
Nameserver 注册中心

作用：
- 每个Broker启动的时候会向namesrv注册
- Producer发送消息的时候根据Topic获取路由到Broker里面Broker的信息
- Consumer根据Topic到Namesrv 获取topic的路由到Broker的信息

部署模型#

image-20210714110416958

注册中心Nameserver启动

消息中转服务Broker启动

启动的时候会去创建Topic并创建对应的MessageQueue
启动的时候会去注册中心注册，把自己的地址以及负责的Topic告诉注册中心

Broker和Nameserver之间通过心跳机制来检测对方是否存活

1
连接: 单个broker和所有nameserver保持长连接
2
心跳:
3
  心跳间隔：每隔30秒（此时间无法更改）向所有nameserver发送心跳，心跳包含了自身的topic配置信息。
4
  心跳超时：nameserver每隔10秒钟（此时间无法更改），扫描所有还存活的broker连接，若某个连接2分钟内（当前时间与最后更新时间差值超过2分钟，此时间无法更改）没有发送心跳数据，则断开连接。

消息生产者Produer启动

启动时：
- 单个生产者者和一台nameserver保持长连接，定时查询topic配置信息
- 单个生产者和该生产者关联的所有broker保持长连接。
运行时：
- 默认情况下，生产者每隔30秒从nameserver获取所有topic的最新队列情况
- 发送消息时，根据从nameserver获取的路由信息，根据发送消息的Topic和目标Broker建立连接
- 默认情况下，生产者每隔30秒向所有broker发送心跳，该时间由DefaultMQProducer的heartbeatBrokerInterval参数决定，可手动配置。broker每隔10秒钟（此时间无法更改），扫描所有还存活的连接，若某个连接2分钟内（当前时间与最后更新时间差值超过2分钟，此时间无法更改）没有发送心跳数据，则关闭连接
消息消费者Consumer启动

启动时：
- 单个消费者和一台nameserver保持长连接，定时查询topic配置信息
- 单个消费者和该消费者关联的所有broker保持长连接。
运行时:
- 默认情况下，消费者每隔30秒从nameserver获取所有topic的最新队列情况
- 默认情况下，消费者每隔30秒向所有broker发送心跳，该时间由DefaultMQPushConsumer的heartbeatBrokerInterval参数决定，可手动配置。broker每隔10秒钟（此时间无法更改），扫描所有还存活的连接，若某个连接2分钟内（当前时间与最后更新时间差值超过2分钟，此时间无法更改）没有发送心跳数据，则关闭连接

注意事项#

同步刷盘与异步刷盘：

RocketMQ的消息是存储到磁盘上的，这样既能保证断电后恢复，又可以让存储的消息量超出内存的限制。

RocketMQ为了提高性能，会尽可能地保证磁盘的顺序写。消息在通过Producer写入RocketMQ的时候，有两种写磁盘方式：
- 异步刷盘：在返回写成功状态时，消息可能只是被写入了内存中，写操作的返回快，
  
  吞吐量大；当内存里的消息量积累到一定程度时，统一触发写磁盘操作，快速写入
- 同步刷盘：在返回写成功状态时，消息已经被写入磁盘。具体流程是，消息写入内存后，立刻通知刷盘线程刷盘，然后等待刷盘完成，刷盘线程执行完成后唤醒等待的线程，返回消息写成功的状态。
同步刷盘还是异步刷盘，是通过Broker配置文件里的flushDiskType参数设置的，这个参数被设置成SYNC_FLUSH、ASYNC_FLUSH中的一个
同步复制与异步复制

如果一个broker组有Master和Slave，消息需要从Master复制到Slave上，有同步和异步两种复制方式。

同步复制是等Master和Slave均写成功后才反馈给客户端写成功状态；异步复制方式是只要Master写成功即可反馈给客户端写成功状态

同步复制和异步复制是通过Broker配置文件里的brokerRole参数进行设置的，这个参数可以被设置成ASYNC_MASTER、SYNC_MASTER、SLAVE三个值中的一个。

安装使用#

安装#

参加环境搭建文档

配置文件#

1
# 所属集群名称，如果节点较多可以配置多个
2
brokerClusterName = DefaultCluster
3
#broker名称，master和slave使用相同的名称，表明他们的主从关系
4
brokerName = broker-a
5
#0表示Master，大于0表示不同的slave
6
brokerId = 0
7
#表示几点做消息删除动作，默认是凌晨4点
8
deleteWhen = 04
9
#在磁盘上保留消息的时长，单位是小时
10
fileReservedTime = 48
11
#有三个值：SYNC_MASTER，ASYNC_MASTER，SLAVE；同步和异步表示Master和Slave之间同步数据的机制；
12
brokerRole = ASYNC_MASTER
13
#刷盘策略，取值为：ASYNC_FLUSH，SYNC_FLUSH表示同步刷盘和异步刷盘；SYNC_FLUSH消息写入磁盘后才返回成功状态，ASYNC_FLUSH不需要；
14
flushDiskType = ASYNC_FLUSH
15
# 设置broker节点所在服务器的ip地址
16
brokerIP1 = 192.168.233.129
17
# 磁盘使用达到95%之后,生产者再写入消息会报错 CODE: 14 DESC: service not available now, maybe disk full
18
diskMaxUsedSpaceRatio=95

展开收起

整合#

导包#

1
        <dependency>
2
            <groupId>org.apache.rocketmq</groupId>
3
            <artifactId>rocketmq-client</artifactId>
4
            <version>4.9.4</version>
5
        </dependency>

普通消息#

消息生产者

1
public static void main(String[] args){
2
    // 新增消息生产者
3
    DefaultMQProucer producer = new DefaultMQProucer("producer_group");
4
    // 配置注册中心
5
    producer.setNamesrvAddr("localhost:9876");
6
    // 启动
7
    producer.start();
8
    // 新建消息对象
9
    Message message = new Message("topicA","message".context.getBytes(Charset.forName("utf-8")));
10
    // 发送消息
11
    producer.send(message);
12
}

消息消费者

1
public static void main(String[] args) throws MQClientException {
2
        DefaultMQPushConsumer mqConsumer = new DefaultMQPushConsumer("consumer_group");
3
        mqConsumer.setNamesrvAddr("localhost:9876");
4
        mqConsumer.subscribe("topicA", "*");
5
        // 设置消息监听器
6
        mqConsumer.registerMessageListener(new MessageListenerConcurrently() {
7
            @Override
8
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
9
                MessageExt message = msgs.get(0);
10
              //获取消息内容
11
                byte[] body = message.getBody();
12

13
        });
14

15
        mqConsumer.start();

展开收起

延迟消息#

消息生产者

1
    public static void main(String[] args) throws MQClientException, UnsupportedEncodingException, RemotingException, InterruptedException, MQBrokerException {
2
    // 1. 创建Producer对象
3
        DefaultMQProducer produce = new DefaultMQProducer("delay_producer_group");
4
        producer.setNamesrvAddr("127.0.0.1:9876");
5
        producer.start();
6

7
        // 准备消息
8
        Message message = new Message();
9
        message.setTopic("test_delay");
10
        message.setBody("hello,delay".getBytes("utf-8"));
11
        // 非常简单  延迟级别
12
        //  1s   5s  10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 32m 1h 2h
13
        //  1    2    3  4   5  6  7  8  9 10  11 12 13 14 15  16   17 18
14
        message.setDelayTimeLevel(2);
15
        // 发送
16
        SendResult send = producer.send(message);
17
        System.out.println(send);
18
    }

展开收起

消息消费者(和普通的消息消费者没有区别)

当然，我们也可以修改延迟消息的延迟级别所对应的具体时间，只需要在broker配置文件里增加如下配置即可

1
messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 32m 1h 2h 15s

订单

Sun, 14 Jun 2026 00:00:00 GMT

数据库#

image-20230315110922296

1
# 订单表
2
CREATE TABLE `order_info` (
3
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
4
  `parent_order_id` bigint(20) DEFAULT NULL COMMENT '父订单编号',
5
  `order_status` varchar(20) DEFAULT NULL COMMENT '订单状态',
6
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id',
7
  `payment_way` varchar(20) DEFAULT NULL COMMENT '付款方式',
8
  `consignee` varchar(100) DEFAULT NULL COMMENT '收货人',
9
  `consignee_tel` varchar(20) DEFAULT NULL COMMENT '收件人电话',
10
  `delivery_address` varchar(1000) DEFAULT NULL COMMENT '送货地址',
11
  `total_amount` decimal(10,2) DEFAULT NULL COMMENT '总金额',
12
  `original_total_amount` decimal(16,2) DEFAULT NULL COMMENT '原价金额',
13
  `order_comment` varchar(200) DEFAULT NULL COMMENT '订单备注',
14
  `out_trade_no` varchar(50) DEFAULT NULL COMMENT '订单交易编号（第三方支付用)',
15
  `trade_body` varchar(200) DEFAULT NULL COMMENT '订单描述(第三方支付用)',
16
  `order_type` varchar(50) DEFAULT NULL COMMENT '订单类型: 秒杀订单|普通订单',
17

18
  `tracking_no` varchar(1000) DEFAULT NULL COMMENT '物流单编号',
19
  `refundable_time` datetime DEFAULT NULL COMMENT '可退款日期（签收后30天）',
20
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
21
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
22
  `expire_time` datetime DEFAULT NULL COMMENT '失效时间',
23
  `is_deleted` tinyint(3) NOT NULL DEFAULT '0',
24
  PRIMARY KEY (`id`)
25
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8 COMMENT='订单表';
26

27

28
# 订单明细表
29
CREATE TABLE `order_detail` (
30
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
31
  `order_id` bigint(20) DEFAULT NULL COMMENT '订单编号',
32
  `sku_id` bigint(20) DEFAULT NULL COMMENT 'sku_id',
33
  `sku_name` varchar(200) DEFAULT NULL COMMENT 'sku名称（冗余)',
34
  `img_url` varchar(200) DEFAULT NULL COMMENT '图片名称（冗余)',
35
  `order_price` decimal(10,2) DEFAULT NULL COMMENT '购买价格(下单时sku价格）',
36
  `sku_num` varchar(200) DEFAULT NULL COMMENT '购买个数',
37
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
38
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
39
  `is_deleted` tinyint(3) NOT NULL DEFAULT '0',
40
  PRIMARY KEY (`id`)
41
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='订单明细表';

展开收起

接口功能#

去结算#

接口说明：这个接口主要是从购物车点击“结算” 然后跳转去结算页面。结算页面需要显示以下两个信息
请求路径 /order/auth/trade

返回值：Result
用户的收货地址信息
1
@GetMapping("/api/user/inner/findUserAddressListByUserId/{userId}")
2
public List<UserAddressDTO> findUserAddressListByUserId(@PathVariable("userId") String userId);
用户购物车中所有的选中商品信息
1
// 下单的时候 查询购物车中所有被选中的商品
2
@GetMapping("/api/cart/inner/getCartCheckedList/{userId}")
3
public List<CartInfoDTO> getCartCheckedList(@PathVariable(value = "userId") String userId);

提交订单#

接口说明：这个接口是在上一步获取了结算页的信息之后，用户点击提交订单，然后去生成订单，需要做的事情：

下单之前校验

校验库存是否足够 wareApiClient.hasStock(skuId,num);

校验商品价格是否产生变动

如果发生变动，那么需要更新购物车中的商品价格为最新价格，并且返回给用户”商品价格发生变动”

保存订单以及订单详情

删除购物车中所有被选中的商品

发送订单超时自动取消的消息

关于仓储系统（Warehouse Management System）, 在一般企业的电商开发中，都是独立的系统。对于我们做电商业务的同学而言，只需要调用它提供的接口即可。
详情见仓储管理系统开发文档。

1
@PostMapping("/order/auth/submitOrder")
2
    public Result submitOrder(@RequestBody OrderInfoParam orderInfo,HttpServletRequest request) {
3
        // 获取到用户Id
4
        String userId = AuthContext.getUserId(request);
5

6
        // 1. 校验库存是否足够
7
    // wareApiClient.hasStock(skuId,num);
8

9
        // 2. 校验商品价格是否产生变动
10

11
        // 3. 保存订单以及订单详情
12

13
        // 4. 删除购物车中已经下单的商品
14

15
        // 5. 发送订单超时自动取消的消息
16

17
        // 6. 返回
18
        return Result.ok(orderId);
19
}

展开收起

几个细节：

保存订单以及订单详情：事务

删除购物车：

不要把用户的购物车都删除，只删除这次订单中的商品

需要调用购物车服务

发送订单超时取消的消息

需要引入common-mq模块

使用BaseProducer发送消息

消息的Topic是什么？消息延迟多久？

在哪个服务消费消息？消费消息的逻辑是什么？

修改订单状态为 “已取消”

下单成功后前端自动跳转到支付页面，此时因为在支付的页面，要显示订单信息，所以此时前端会发送请求到支付服务，获取当前的订单信息，所以支付服务需要实现如下接口

1
    @GetMapping("pay/auth")
2
    public Result<OrderInfoDTO> payIndex(Long orderId){
3
        // 调用订单服务获取订单信息
4
        OrderInfoDTO orderInfoDTO = orderApiClient.getOrderInfoDTO(orderId);
5
        return Result.ok(orderInfoDTO);
6
    }

所以，很显然我们需要在订单服务中，实现Controller方法来接收处理这个来自支付服务的服务调用请求

image-20230316175430364

查看我的订单#

1
@GetMapping("/order/auth/{page}/{limit}")
2
public Result<IPage<OrderInfoDTO>> index(@PathVariable Long page, @PathVariable Long limit, HttpServletRequest request) {
3
    // 获取到用户Id
4
    String userId = AuthContext.getUserId(request);
5

6
    Page<OrderInfoDTO> pageParam = new Page<>(page, limit);
7

8
    // 获取用户订单的分页列表
9
    // 注意：
10
    // 1. 建议使用MybatisPlus的分页查询功能
11
    // 2. 思考一下哪些订单状态不用在用户页面展示出来？
12
    // 3. 查询结果需要设置OrderInfoDTO中的orderStatusName(如'未支付'| '已支付' | '已发货')
13
    IPage<OrderInfoDTO> pageModel = orderService.getPage(pageParam, userId);
14

15
    return Result.ok(pageModel);
16
}

展开收起

设计模式

Sun, 14 Jun 2026 00:00:00 GMT

设计模式简介#

什么是设计模式#

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。设计模式代表了最佳的实践，通常被有经验的软件开发人员所使用。

设计模式是一套编码的经验的总结。

大白话来说，设计模式是前人总结的一套经验。按照前人总结的经验去设计架构，编写代码，有很多好处。

比如：后期可维护性强、耦合度低、代码复用性高、代码通俗易懂。

为什么学习设计模式#

可以面对面试中的关于设计模式的问题，比如单例模式的几种实现方式；比如懒汉式和饿汉式你如何理解
有助于阅读源码框架，后续进阶提升所必须要掌握的技能
借助于设计模式可以编写出非常高效的代码，可复用性以及稳健性都会比较强。比如在建筑领域，如果你只是希望盖一个茅草屋，那么无需任何模式；但是如果你希望建造出一个摩天大楼，那么必须要有一个模式

设计模式的发展历史#

设计模式是由谁来发明的呢？其实最早提出设计模式概念的人并不是来自于软件领域，而是来自于建筑方向。由克里斯托佛·亚历山大在其著作《建筑模式语言》中首次提出的。比如包含对窗户应该在多高、一座建筑应该有多少层以及一片街区应该有多大面积的植被等信息的描述。

后来埃里希·伽玛、约翰·弗利赛德斯、拉尔夫·约翰逊和理查德·赫尔姆这四位作者接受了模式的概念。 1994 年，他们出版了《设计模式：可复用面向对象软件的基础》一书，将设计模式的概念应用到程序开发领域中。该书提供了 23 个模式来解决面向对象程序设计中的各种问题，很快便成为了畅销书。由于书名太长，人们将其简称为 “四人组（Gang of Four， GoF）的书”，并且很快进一步简化为 “GoF 的书”。

设计模式的分类#

GoF（4人组）设计模式共有23种，根据用途的不同，设计模式可以分为：创建型、结构型、行为型三种。

创建型模式

这类模式提供创建对象的机制，能够提升已有代码的灵活性和可复用性。常见的有单例、工厂、建造者(生成器)模式

结构型模式

这类模式介绍如何将对象和类组装成较大的结构，并同时保持结构的灵活和高效。常用的有代理、桥接、装饰者、适配器模式。
行为型模式

这类模式负责对象间的高效沟通和职责委派。常见的有观察者、模板、策略、责任链、迭代器、状态模式。

设计模式原则#

设计模式需要有设计的原则作为指导纲领，设计模式是在设计原则的指引下设计出来的。因为我们需要对设计原则有一个清晰的认识。

设计原则按照字母手写简写可以概括为SOLID原则。

单一职责原则（Single Responsibility Principle）

开放封闭原则（Open Close Principle）

里氏替换原则（Liskov Substitution Principle）

迪米特法则（Least Knowledge Principle）

接口分离原则（Interface Segregation Principle）

依赖倒置原则（Dependency Inversion Principle）

单一职责原则#

尽量使得每个类只负责整个软件的功能模块中的一个。当程序不断壮大之后，类也会变得非常的庞杂，查找某部分代码也会变得非常的吃力；如果此时需要做任何一处的修改，那么整个类的代码都会受到影响。

如下图所示，是一个雇员类。假设我们需要对雇员表进行修改。但是出于两方面原因，我们需要对这个类进行修改：1.和当前类主要功能相关的，比如管理雇员的信息等；2.打印雇员的信息，打印的信息随着时间的不同，对于格式要求也不太相同。

image-20230227145935832

出于上述两方面原因，我们需要对雇员类进行修改，但是修改该类的原因却不是一个，而是有多个原因。那么此时，雇员类的设计就不符合单一职责原则。我们可以尝试按照如下方式来进行修改：

image-20230227150423502

将打印相关的代码全部移动到一个新的类中，该类需要依赖于Employee类。

开放封闭原则#

开闭原则规定软件设计中的对象、类、模块以及函数等对于扩展是开放的，但是对于修改是封闭的。如果一个功能模块已经开发、测试完毕，那么对其代码直接进行修改便是由很大风险的。如果有新的业务功能，那么应当做的事情是对于现有代码进一步扩展，而不是修改现有代码。比如可以创建一个子类来重写这部分业务逻辑以到达目的等。也就是说，我们应该选择使用抽象来定义结构，用具体实现来扩展细节。

上述讨论的前提是代码中没有缺陷等问题，如果代码中存在缺陷、bug等，那么直接对其进行修复即可。

比如，我们在学习数据库时，使用Java语言连接数据库，这种方式我们称之为JDBC。使用Java语言连接数据库，可以连接Mysql数据库，也可以连接Oracle数据库。如果我们之前使用Mysql数据库，如何扩展到对于Oracle数据库的支持呢？相信大家应该都不会陌生的。

设计一个Connection接口，不同的数据库厂商针对该接口，设计自己的Connection实现类。

image-20230227155416973

里氏替换原则#

它由芭芭拉·利斯科夫（Barbara Liskov）在1987年在一次会议上名为“数据的抽象与层次”的演说中首先提出。主要内容如下：

如果S是T的子类型，对于S类型的任意对象，如果将他们看作是T类型的对象，则它的行为也理应和预期的行为一致。

这意味着子类必须保持与父类行为的兼容。在重写一个方法时，你要对基类行为进行扩展，而不是将其完全替换。在使用父类的程序中，替换为使用子类，那么程序的运行结果应该是一致的，不会发生任何异常。下面的一个案例便是违反了里氏替换原则。

image-20230227164630136

上述案例如何改进呢？子类的行为应当和父类保持一致，但是子类可以在父类的基础上做进一步的扩展。修改为如下：

image-20230227164857336

迪米特法则#

又叫作最少知道原则，指的是一个类/模块对于其他的类/模块有越少的了解越好。简单来说就是不应该有依赖关系的类之间，不要存在依赖关系；有依赖关系的类之间，尽量只依赖于接口。

迪米特法则还有一个更简单的定义：只与直接的朋友通信。什么是直接的朋友呢？我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。不要和”陌生人”说话。比如明星和经纪人之间的关系，明星处理各种事项，比如粉丝见面会、商业合作、剧邀约等事项，如果全部都亲力亲为，显然没有那么多的精力；可以将这些事项全部委托给经纪人代为办理。

如下图所示，全部的事情都由自己亲力亲为。此时一个类中有过多的依赖。

image-20230227172132757

可以按照如下方式来进行修改，在本案例中，经纪人是明星的朋友，其他均是陌生人，尽量不要和陌生人之间产生依赖。

image-20230227174049484

还比如，老师让班长点名，统计当天到的学生的人数。如果老师除了依赖班长，还依赖学生，那么就不满足迪米特法则，不应该有依赖关系的类之间尽量不要有依赖关系；相反，老师只需要依赖班长即可。

错误代码：

1
public class Teacher {
2
    public void command(){
3
        //耦合了student类
4
        List<Student> students = new ArrayList<Student>();
5
        for(int i=0; i<20; i++){
6
            students.add(new Student());
7
        }
8

9
        //耦合了studentleader类
10
        StudentLeader leader = new StudentLeader();
11
        System.out.println("清点人数完毕，总共有:"+leader.counts(students)+"人");
12

13
    }
14
}
15

16
public class Student {
17

18
}
19

20
//班干部负责清点人数
21
public class StudentLeader {
22
    public int counts(List<Student> lists){
23
        return lists.size();
24
    }
25
}
26
public class Client{
27
    public static void main(String[] args){
28
        System.out.println("周末收假，学校领导命令老师去点名.....");
29
        Teacher teacher = new Teacher();
30
        teacher.command();
31
    }
32
}

展开收起

正确代码

1
public class LODTeacher {
2
    //仅仅耦合了LODStudentLeader类
3
    public void command(LODStudentLeader leader){
4
        System.out.println("清点人数完毕，总共有:"+leader.counts()+"人");
5
    }
6
}
7

8
public class LODStudentLeader {
9
    //仅仅耦合了student类
10
    private List<Student> students;
11

12
    public LODStudentLeader(List<Student> students){
13
        this.students = students;
14
    }
15
    public int counts(){
16
        return students.size();
17
    }
18
}
19

20
public class TaskTest {
21
    public static void main(String[] args) {
22
        System.out.println("周末收假，学校领导命令老师去点名.....");
23
        List<Student> students = new ArrayList<Student>();
24
        for(int i = 0; i < 20; i++ ){
25
              students.add(new Student());
26
        }
27
        LODTeacher teacher = new LODTeacher();
28
        teacher.command(new LODStudentLeader(students));
29
    }
30
}

展开收起

接口隔离原则#

一个类对另外一个类的依赖应当建立在最小的接口上。这句话的含义其实是要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

假设目前我们正在开发一套程序，该程序可以很方便地和目前市面上的云服务器进行整合。虽然最初版本是以阿里云服务器来进行开发对接，但是希望后期可以延展到所有的云服务器之上。所以，我们开发设计了一套接口包含了各个阶段的功能。

image-20230228094107478

通过上图，我们可以发现，后续整合腾讯云服务器时，我们发现，有几个功能暂未实现。遵循接口隔离原则，我们此时设计的接口就不符合最小接口的要求。我们应当将上述复杂、庞大的接口拆分为一组颗粒度更小的接口。

image-20230228094804270

依赖倒置原则#

指的是设计代码架构时，高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。其所表达的含义是指在软件设计过程中，细节具有多变性，而抽象则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构稳定的多。

假设，我们正在组装一台电脑，CPU模块，我们可以选择Intel或者AMD;内存模块，我们可以选择Kingston或者ADATA;硬盘模块，我们可以选择SEAGATE或者SanDisk.我们可以按照如下方式来进行组织：

image-20230228101419968

上图的设计架构，初看没觉得有何不妥。但是如果我们需要更换不同的品牌型号，那么此时，我们的Computer类需要进行大幅的修改。

遵循依赖倒置原则，高层模块代码应该依赖于抽象。

image-20230228101702714

常用设计模式#

创建型模式#

创建型模式提供了创建对象的机制，能够提升已有代码的灵活性和可复用性。

单例模式（Singleton）#

单例是一种创建型设计模式，让你保证一个类只有一个实例对象，并提供了一个访问该实例对象的全局节点。

image-20230228105104449

对应的UML类图如下

image-20230228111143834

饿汉模式#

在类加载的过程中初始化了私有的静态实例对象，保证了该实例对象的线程安全性。因为该实例对象先于使用前提供，所以称之为饿汉模式。

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 饿汉式
5
 **/
6
public class Singleton1 {
7

8
    //创建私有静态实例对象
9
    private static final Singleton1 instance = new Singleton1();
10

11
    //私有化构造函数
12
    private Singleton1(){}
13

14
    public static Singleton1 getInstance(){
15
        return instance;
16
    }
17
}

展开收起

饿汉式特点：不支持延时加载（懒加载），获取对象速度比较快；但是如果对象比较大，或者一直没有去使用，那么比较浪费内存空间。

懒汉模式(线程不安全)#

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 懒汉式-线程不安全
5
 **/
6
public class Singleton2 {
7

8
    private static Singleton2 instance;
9

10
    //私有化构造函数
11
    private Singleton2(){}
12

13
    //判断当前对象是否已经被创建
14
    public static Singleton2 getInstance(){
15
        if(instance == null){
16
            instance = new Singleton2();
17
        }
18
        return instance;
19
    }
20
}

展开收起

编写测试用例，我们使用1000个线程来创建Singleton2对象，发现对象的地址不同。产生上述问题的主要原因在于我们执行的代码其实都不是原子性，在多线程操作的过程中，会进行线程切换。比如线程A执行到 if(instance == null){，继续执行代码便会创建instance实例对象，但是此时进行了线程切换；切换到了线程B，线程B创建了instance对象；随后再次线程切换给线程A，因为线程A已经执行过判断，所以便会直接执行instance = new Singleton2();，便又会创建一个对象。

image-20230228114741374

懒汉模式(线程安全)#

如何保证线程安全呢？使用synchronized关键字即可。

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 懒汉式-线程安全
5
 * @Version V1.0
6
 **/
7
public class Singleton3 {
8

9
    private static Singleton3 instance;
10

11
    //私有化构造函数
12
    private Singleton3(){}
13

14
    //引入synchronized，保证多线程模式下实例对象的唯一性
15
    public static synchronized Singleton3 getInstance(){
16
        if(instance == null){
17
            instance = new Singleton3();
18
        }
19
        return instance;
20
    }
21
}

展开收起

使用synchronized锁住对象创建的方法，防止该方法被多个线程同时调用。

但是这种方式最合适吗？

因为我们对getInstance()添加了锁，降低了该方法的并发量；实际上，我们只需要针对最开始抢先创建实例对象的线程加锁即可，后续的线程在执行时，因为if(instance == null)条件已经不满足，所以直接执行返回实例对象即可，此时不需要加锁。

双重检查(Double Check)#

针对上述存在的问题，我们做了进一步修改。这种方式最明显的特征是synchronized关键字不是修饰整个方法，而是仅修饰创建对象的代码块，可以提高并发；此外，存在两个if条件判断语句。这也是双重检查的由来。为什么需要双重检查呢？线程A可能首先先执行到了外层的if条件判断，执行通过之后并没有进一步执行，而是进行了线程的切换，切换成了线程B；线程B也执行了外层的if条件判断，并且顺利地获取到了锁，执行完了内部的if条件判断，创建了实例对象；如果此时线程再次切换给线程A，线程A因为刚刚已经执行完外层的if条件判断，此时顺利的获取到了锁，如果没有内部的if条件判断，则会再次创建一个实例对象。这也是为何一定要双重检查的原因。

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
* 懒汉式-双重检查
5
**/
6
public class Singleton4 {
7

8
   private static Singleton4 instance;
9

10
   //私有化构造函数
11
   private Singleton4(){}
12

13
   public static Singleton4 getInstance(){
14
       if(instance == null){
15
           synchronized (Singleton4.class){
16
               if(instance == null){
17
                   instance = new Singleton4();
18
               }
19
           }
20
       }
21
       return instance;
22
   }
23
}

展开收起

静态内部类#

利用静态内部类来解决延迟加载、线程安全的问题；并且可以使得代码更加简洁。由JVM来保障线程安全性。

1
public class Singleton5 {
2

3
    private static Singleton5 instance;
4

5

6
    //私有化构造函数
7
    private Singleton5(){}
8

9
    //静态内部类
10
    private static class SingletonHolder{
11
        private static Singleton5 instance = new Singleton5();
12
    }
13

14
    public static Singleton5 getInstance(){
15

16
        return SingletonHolder.instance;
17
    }
18
}

展开收起

枚举#

1
public enum Singleton6 {
2

3
    INSTANCE;
4

5
    public static Singleton6 getInstance(){
6
        return INSTANCE;
7
    }
8
}

总结#

饿汉式：在类加载时期，便已经将instance实例对象创建了；所以这种方式是线程安全的方式，但是不支持懒加载。
懒汉式：该种方式支持懒加载，但是要么不是线程安全，要么虽然是线程安全，但是需要频繁释放锁、抢夺锁，并发量较低。
双重检查：既可以实现懒加载，又可以实现高并发的需求。这种方式比较完美，但是代码有一些复杂。
静态内部类：使用该种方式也可以解决懒加载以及高并发的问题，代码实现起来比双重检查也是比较简洁。
枚举：最简单、最完美的实现方式。

单例设计模式的意义是什么呢？

节省资源。节省内存资源、网络资源等…

工厂模式（Factory）#

工厂顾名思义就是生产产品的地方。我们通常会定义工厂（类、接口），通过该工厂类（或其工厂实例）提供的方法能够获得返回值，该返回值就是通过工厂生产的实例。

也就是说，工厂中一定会提供一个返回实例的方法。其中核心的好处是封装（隐藏）生产的具体细节

工厂类或接口的命名方式，通常为XXXFactory

简单工厂模式#

之所以叫简单工厂是因为真的非常简单，只要一个工厂（函数）就可以了，，那么只需要传入不同的参数，就可以返回不同的产品（实例），这种模式就叫简单工厂模式。

比如，我们要生产Tesla汽车，Tesla下又有不同的产品，比如Model3、ModelY、ModelS等，我们其实可以通过给简单工厂传入不同的参数，来生产不同的产品

首先定义不同的产品

1
public abstract class Tesla {
2
    String name;
3
    public Tesla(String name) {
4
        this.name = name;
5
    }
6
    public void run(){
7
        System.out.println(name + "在路上跑");
8
    }
9
}
10
public class Model3 extends Tesla{
11
    public Model3() {
12
        super("model 3");
13
    }
14
}
15
public class ModelS extends Tesla{
16
    public ModelS() {
17
        super("model S");
18
    }
19
}
20
public class ModelY extends Tesla{
21
    public ModelY() {
22
        super("model Y");
23
    }
24
}

展开收起

我们在上面定义了抽象类Tesla，通过不同的子类定义不同的车型

接下来，我们首先先不使用工厂

1
Scanner scanner = new Scanner(System.in);
2
String keyword = scanner.nextLine();
3
Tesla tesla = null;
4
switch (keyword) {
5
    case "model3":
6
        tesla = new Model3();
7
        break;
8
    case "modely":
9
        tesla = new ModelY();
10
        break;
11
    case "models":
12
        tesla = new ModelS();
13
        break;
14
    default:
15
        tesla = new Tesla("未知车辆") {
16
            @Override
17
            public void run() {
18
                System.out.println(name + "路上请注意，道路千万条，安全第一条");
19
            }
20
        };
21
        break;
22
}
23
tesla.run();

展开收起

然后我们再使用工厂

将获得tesla对象的过程放入到工厂的生产方法中，故定义一个这样的工厂

1
public class SimpleTeslaFactory {
2

3
    public static Tesla create(String keyword) {
4
        Tesla tesla = null;
5
        switch (keyword) {
6
            case "model3":
7
                tesla = new Model3();
8
                break;
9
            case "modely":
10
                tesla = new ModelY();
11
                break;
12
            case "models":
13
                tesla = new ModelS();
14
                break;
15
            default:
16
                tesla = new Tesla("未知车辆") {
17
                    @Override
18
                    public void run() {
19
                        System.out.println(name + "路上请注意，道路千万条，安全第一条");
20
                    }
21
                };
22
                break;
23
        }
24
        return tesla;
25
    }
26
}

展开收起

其中的create方法可以定义为静态

我们通过工厂提供的create方法可以直接获得tesla对象

1
Scanner scanner = new Scanner(System.in);
2
String keyword = scanner.nextLine();
3
Tesla tesla = SimpleTeslaFactory.create(keyword);
4
tesla.run();

工厂方法模式#

image-20230228173257502

工厂方法模式，是一种创建型设计模式，其在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。它的主要意图是定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

我们模拟客户下单一辆特斯拉电动车，特斯拉生产车间需要交付一辆该型号汽车来讲述该设计模式。首先不借助于任何设计模式，我们先完成该功能。

1
import java.util.Scanner;
2

3
/**
4
 * @ClassName OrderCar
5
 * @Description: TODO
6
 * @Author stone
7
 * @Date 2023/2/28 20:05
8
 * @Version V1.0
9
 **/
10
public class OrderCar {
11

12
    public static void main(String[] args) {
13
        Scanner scanner = new Scanner(System.in);
14
        String keyword = scanner.nextLine();
15
        Tesla tesla = SimpleTeslaFactory.create(keyword);
16
        tesla.run();
17
    }
18
}

展开收起

上述的案例，我们便实现了根据订购的车型不同，生产不同的车辆。但是面临最大的问题便是在于扩展车型时非常的麻烦。当我们需要重构代码时，代码中涉及到的地方千丝万缕、错综复杂会使得开发人员望而却步。接下来，我们尝试使用工厂方法来重构上述代码。

对应的类关系如下

image-20230228202626089

1
public interface TeslaFactory {
2

3
    public Tesla getTesla();
4
}

1
public class ModelYFactory implements TeslaFactory{
2
    @Override
3
    public Tesla getTesla() {
4
        return new ModelY();
5
    }
6
}
7
public class Model3Factory implements TeslaFactory{
8
    @Override
9
    public Tesla getTesla() {
10
        return new Model3();
11
    }
12
}
13
//其他工厂类似，就不全部列举了

1
public class OrderTesla {
2

3
    private static Map<String, TeslaFactory> factoryMap = new HashMap<>();
4

5
    static {
6
        factoryMap.put("modelx", new ModelXFactory());
7
        factoryMap.put("modely", new ModelYFactory());
8
        factoryMap.put("models", new ModelSFactory());
9
        factoryMap.put("model3", new Model3Factory());
10
    }
11

12
    public static void main(String[] args) {
13
        Scanner scanner = new Scanner(System.in);
14
        String keywords = scanner.nextLine();
15
        TeslaFactory teslaFactory = factoryMap.get(keywords.toLowerCase());
16
        Tesla tesla = teslaFactory.getTesla();
17
        tesla.run();
18
    }
19
}

展开收起

通过OrderTesla类的代码和OrderCar代码进行比较，我们发现代码明显变得更加简洁了。

抽象工厂模式#

image-20230228211613272

是所有工厂模式中抽象程度最高的一种模式。抽象工厂模式可以向客户端提供一个接口，使得客户端可以在不必指定具体类型的情况下，能够创建多个一系列或者相关联的对象。

工厂方法和抽象工厂，首先都是要将工厂抽象为接口或抽象类。工厂方法主要是生产的是单个产品，抽象工厂主要是生产是一系列的产品。

工厂方法：单品

抽象工厂：产品矩阵

我们以下面这个案例来进行讲述。随着智能家居的兴起，许多家庭在选择家居电器时，会倾向于选择同一厂家的产品。比如目前市面上有Haier以及Mi的家居产品。不同的厂家产品线都非常丰富，涵盖TV、Freezer等。设计一套代码程序，根据用户选择的厂家，提供对应的配套产品。

对应的类关系如下：

image-20230228220735462

1
public abstract class AbstractFurnitureFactory {
2

3
    public abstract TV createTV();
4
    public abstract Freezer createFreezer();
5
}

1
public class MiFurnitureFactory extends AbstractFurnitureFactory{
2
    @Override
3
    public TV createTV() {
4
        return new MiTV();
5
    }
6

7
    @Override
8
    public Freezer createFreezer() {
9
        return new MiFreezer();
10
    }
11
}

1
public class HaierFurnitureFactory extends AbstractFurnitureFactory{
2
    @Override
3
    public TV createTV() {
4
        return new HaierTV();
5
    }
6

7
    @Override
8
    public Freezer createFreezer() {
9
        return new HaierFreezer();
10
    }
11
}

1
public class OrderFurniture {
2
    public static void main(String[] args) {
3
        MiFurnitureFactory miFactory = new MiFurnitureFactory();
4
        TV tv = miFactory.createTV();
5
        Freezer freezer = miFactory.createFreezer();
6
        System.out.println("tv instanceof MiTV = " + (tv instanceof MiTV));
7
        System.out.println("freezer instanceof MiFreezer = " + (freezer instanceof MiFreezer));
8
    }
9
}

建造者模式#

image-20230301094814544

建造者模式也叫作生成器模式，就是分步骤创建复杂对象，该模式允许使用相同的创建代码生成不同类型和形式的对象。

在开发中，有时候我们需要创建出一个很复杂的对象，这个对象的创建有一个固定的步骤，并且每个步骤中会涉及到多个组件对象，这个时候就可以考虑使用建造者模式。使用建造者模式将原本复杂的对象创建过程按照规律将其分解成多个小步骤，这样在构建对象时可以灵活的选择或修改步骤。建造者模式将对象的创建和表示过程进行分离，这样我们可以使用同样的过程，只需修改这个过程中的小步骤，便能够构建出不同的对象。而对于调用方来说，我们只需要传入需要构建的类型，便能够得到需要的对象，并不需要关系创建的过程，从而实现解耦。

比如我们要制造手机，手机里包含屏幕、颜色、电池、摄像头、系统等组成，那么我们定义一个Phone如下

1
@Data
2
public class Phone {
3
    private String battery;
4
    private String screen;
5
    private String os;
6
    private String camera;
7
    private String color;
8
    // 通过@Data提供了getter/setter方法，以及我们打印的时候用的toString方法
9
}

然后我们要提供一个PhoneBuilder类

通过Builder类提供的build方法能够获得Phone实例

同时提供一些方法，通过这些方法能够设置build方法获得的该phone实例的属性值

要保证这些方法操作的是同一个phone实例，要在Builder中提供phone成员变量

基于以上，我们定义的PhoneBuilder如下

1
public class PhoneBuilder {
2
    private Phone phone = new Phone();
3

4
    public PhoneBuilder color(String color) {
5
        this.phone.setColor(color);
6
        return this;
7
    }
8

9
    public PhoneBuilder battery(String battery) {
10
        this.phone.setBattery(battery);
11
        return this;
12
    }
13

14
    public PhoneBuilder screen(String screen) {
15
        this.phone.setScreen(screen);
16
        return this;
17
    }
18

19
    public PhoneBuilder os(String os) {
20
        this.phone.setOs(os);
21
        return this;
22
    }
23

24
    public PhoneBuilder camera(String camera) {
25
        this.phone.setCamera(camera);
26
        return this;
27
    }
28

29
    public Phone build() {
30
        return this.phone;
31
    }
32
}

展开收起

使用如下

1
public class UseBuilder {
2
    public static void main(String[] args) {
3
        PhoneBuilder builder = new PhoneBuilder();
4
        Phone phone = builder.battery("4000毫安大容量")
5
                .camera("徕卡顶级镜头")
6
                .color("尊贵黑")
7
                .screen("2K高清分辨率")
8
                .os("Android")
9
                .build();
10
        System.out.println("phone = " + phone);
11
    }
12
}

上述代码是建造者模式最经典的使用方式。

建造者模式的优点如下：

可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
不同的构建器，相同的装配，也可以做出不同的对象，实现了更好的复用。
建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

采用链式调用，一步一步把一个完整的对象构建出来。使用该模式是一次性将一个完整的对象构建出来，更加的紧凑，同时也避免了对象在其他处调用了set方法导致属性赋值错误。

建造者设计模式和工厂设计模式都是为了创建具体的实例：工厂模式更关注通过什么工厂生产什么实例，建造者模式主要是通过组装零配件而产生一个新产品

结构型模式#

代理#

image-20230302171931943

代理是一种结构型设计模式，可以允许我们生成对象的替代品。代理控制着对于原对象的访问，同时也允许在原对象的方法之前前后做一些处理，便可以实现在原方法执行前后都会执行某段代码逻辑的功能。这个也是面向切面编程的指导思想。

代理模式在我们日常生活中用处还是相当广泛的，比如海外购网站就是一个代理。海外购网站负责代理用户到国外的电商网站去下单购买商品，也可以在商品送达到海外购网站时，再执行进一步加固操作，再次转送给用户。

代理模式在软件开发过程中的应用场景也非常常见。在客户端以及客户端访问的目标类对象中间，额外再引入一个第三方代理类对象。如果直接访问目标类对象，就是执行对应的方法；如果客户端访问的是代理类对象，那么不仅可以访问对应的方法，还会再方法的执行前后执行对应的前置、后置通知。

image-20230302113049838

静态代理#

1
public interface UserService {
2

3
    void insert();
4
}

1
public class UserServiceImpl implements UserService {
2
    @Override
3
    public void insert() {
4
        System.out.println("目标类执行了insert方法");
5
    }
6
}

1
public class UserServiceProxy implements UserService {
2

3
    UserService target;
4

5
    public UserServiceProxy(UserService target) {
6
        //注入委托类对象
7
        this.target = target;
8
    }
9

10
    @Override
11
    public void insert() {
12
        System.out.println("代理之前打印一个日志");
13
        target.insert();
14
        System.out.println("代理之后打印一个日志");
15
    }
16
}

展开收起

1
@Test
2
    public void test1(){
3
        UserServiceProxy proxy = new UserServiceProxy(new UserServiceImpl());
4
        proxy.insert();
5
    }

代理模式最大的优点在于可以不更改目标类代码的前提下，扩展目标类代码的功能。

静态代理最大的缺点在于代码较为冗余，每代理一个类，便要手动编写一个代理类；代理对象和目标类对象均实现了接口，如果接口发生了修改，不仅目标类需要更改，代理类也需要同步发生修改，维护成本变高了很多。

因此，我们希望可以在程序运行过程中，动态地生成一个代理类对象，这样处理任务更加的方便。这也便是我们接下来介绍的动态代理。

JDK动态代理#

静态代理，顾名思义，便是在编译时，就已经实际存在了该class文件；而动态代理，在编译时期，实际上并不存在该class文件，而是程序在运行阶段动态生成了字节码。JDK动态代理，即JDK给我们提供的动态生成代理类的方式，无需引入第三方jar包，但是使用JDK动态代理有一个先决条件，那就是目标类对象必须实现了某个接口；如果目标类对象没有实现任何接口，则JDK动态代理无法使用。

如果使用JDK提供的动态代理，那么需要借助于如下几个类

java.lang.reflect.Proxy

API	参数	返回值
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)	loader表示目标类使用的类加载器；interfaces表示目标类所实现的接口类型；h表示处理器，用来规定代理的内部细节	返回一个实现指定接口的代理类实例对象；代理类对象和目标类对象实现相同的接口类型

java.lang.reflect.InvocationHandler

API	参数	返回值
public Object invoke(Object proxy, Method method, Object[] args)	proxy表示JDK帮助开发者生成的代理类对象，这个参数一般不用理会；method表示的是目标类中的方法；args表示执行目标类方法时传递的参数；三个参数合在一起表示的含义表示代理类如何来代理、增强目标类里面的方法	代理类执行完对应的方法时它的返回值

1
public class ProxyFactory {
2

3
    Object target;
4

5
    public ProxyFactory(Object target) {
6
        this.target = target;
7
    }
8

9
    public Object newProxyInstance(){
10
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
11
                target.getClass().getInterfaces(),
12
                new InvocationHandler() {
13

14
                    //代理类如何代理
15
                    @Override
16
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
17
                        System.out.println("代理之前签订合约");
18
                        Object invoke = method.invoke(target, args);
19
                        System.out.println("代理完毕转账确认");
20
                        return invoke;
21
                    }
22
                });
23
    }
24
}

展开收起

1
@Test
2
    public void test2(){
3
        UserService userService = new UserServiceImpl();
4
        //对哪个目标类进行代理，我们对UserServiceImpl进行代理
5
        //生成代理类对象
6
        UserService userServiceProxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
7
                target.getClass().getInterfaces(),
8
                new InvocationHandler() {
9

10
                    //代理类如何代理
11
                    @Override
12
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
13
                        System.out.println("代理之前签订合约");
14
                        Object invoke = method.invoke(userService, args);
15
                        System.out.println("代理完毕转账确认");
16
                        return invoke;
17
                    }
18
                });;
19
        //代理类对象执行insert方法，什么逻辑呢？主要是invoke里面的代码逻辑
20
        userServiceProxy.insert();
21
    }

展开收起

利用线上监测工具以及反编译工具，可以看到生成的代理类对象源码

1
public final class $Proxy0
2
extends Proxy
3
implements UserService {
4
    private static Method m1;
5
    private static Method m3;
6
    private static Method m2;
7
    private static Method m0;
8

9
    public $Proxy0(InvocationHandler invocationHandler) {
10
        super(invocationHandler);
11
    }
12

13
    static {
14
        try {
15
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
16
            m3 = Class.forName("com.cskaoyan.pattern.proxy.UserService").getMethod("insert", new Class[0]);
17
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
18
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
19
            return;
20
        }
21
        catch (NoSuchMethodException noSuchMethodException) {
22
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
23
        }
24
        catch (ClassNotFoundException classNotFoundException) {
25
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
26
        }
27
    }
28

29
    public final boolean equals(Object object) {
30
        try {
31
            return (Boolean)this.h.invoke(this, m1, new Object[]{object});
32
        }
33
        catch (Error | RuntimeException throwable) {
34
            throw throwable;
35
        }
36
        catch (Throwable throwable) {
37
            throw new UndeclaredThrowableException(throwable);
38
        }
39
    }
40

41
    public final String toString() {
42
        try {
43
            return (String)this.h.invoke(this, m2, null);
44
        }
45
        catch (Error | RuntimeException throwable) {
46
            throw throwable;
47
        }
48
        catch (Throwable throwable) {
49
            throw new UndeclaredThrowableException(throwable);
50
        }
51
    }
52

53
    public final int hashCode() {
54
        try {
55
            return (Integer)this.h.invoke(this, m0, null);
56
        }
57
        catch (Error | RuntimeException throwable) {
58
            throw throwable;
59
        }
60
        catch (Throwable throwable) {
61
            throw new UndeclaredThrowableException(throwable);
62
        }
63
    }
64
  //主要关注insert方法
65
    public final void insert() {
66
        try {
67
            this.h.invoke(this, m3, null);
68
            return;
69
        }
70
        catch (Error | RuntimeException throwable) {
71
            throw throwable;
72
        }
73
        catch (Throwable throwable) {
74
            throw new UndeclaredThrowableException(throwable);
75
        }
76
    }
77
}

展开收起

Cglib动态代理#

Cglib(Code Generation Library)是一个开源项目，是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。我们可以借助于Cglib来帮助我们动态地生成代理类对象。Cglib可以弥补JDK动态代理的不足，JDK要求目标类必须实现了某个接口，才可以执行代理功能；而Cglib对此无任何要求，主要原因在于Cglib扩展的代理类会继承自目标类。所以这也要求我们的目标类不能是final修饰。

使用Cglib涉及到的相关类如下

net.sf.cglib.proxy.Enhancer

API	参数	返回值/说明
enhancer.setSuperclass(superClass)	父类的字节码对象，也就是我们的目标类	无返回值;Cglib产生的代理类会继承目标类，所以此处设置的父类也就是目标类
enhancer.setCallBack(callback)	设置一个回调函数，代理类对象如何代理目标对象需要在回调函数中制定策略	CallBack是一个接口，MethodInterceptor是一个子接口。我们选用该类来设置回调策略
enhancer.create()	-	生成代理类对象

net.sf.cglib.proxy.MethodInterceptor

API	参数	返回值/说明
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)	第一个参数obj为代理类对象；第二个参数为目标类对应中对应的方法；第三个参数为目标类对象中对应的方法执行时传递的参数；第四个参数是代理类对象中的对应方法	返回值一般便将代理类对象对应方法的执行结果返回

使用Cglib需要导包

1
<dependency>
2
    <groupId>cglib</groupId>
3
    <artifactId>cglib</artifactId>
4
    <version>3.3.0</version>
5
</dependency>

创建一个目标类，在这里为了体现Cglib的效果，目标类没有实现任何接口

1
public class UserServiceImpl {
2

3
    public String getName(){
4
        System.out.println("目标方法执行");
5
        return "zhangsan";
6
    }
7
}

编写测试代码

1
public class ProxyTest {
2

3
    public static void main(String[] args) {
4
        UserServiceImpl userService = new UserServiceImpl();
5

6
        UserServiceImpl userServiceProxy = Enhancer.create(UserServiceImpl.class,new InvocationHandler() {
7

8
            //代理类如何代理
9
            @Override
10
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
11
                System.out.println("目标方法执行之前");
12
                Object invoke = method.invoke(userService, args);
13
                System.out.println("目标方法执行之后");
14
                return invoke;
15
            }
16
        });
17
        String name = userServiceProxy.getName();
18
        System.out.println(name);
19
    }
20
}

展开收起

Terminal window

1
# 解决cglib动态代理和jdk17的兼容性问题
2
--add-opens java.base/sun.net.util=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED

image-20240605164303310

行为型模式#

责任链#

image-20230303092747708

责任链是一种行为设计模式，允许请求沿着链进行发送。收到请求后，每个处理者均可对请求进行处理或者将其传递给链上的下一个处理者。

对应的类关系如下

image-20230303103450856

我们先举一个简单的例子，提供三个处理器，并处理好其先后关系，然后分别依次处理，那么我们要做的事情拆解如下

定义三个不同的处理器

这三个处理器做的是类似的事情，那么可以抽象一个接口或抽象类，接下来就是关于抽象类中的方法

要处理先后关系，可以提供一个方法来处理处理器的顺序关系

要做处理器的核心方法完成业务的处理，每个处理器的处理方法的业务不同

将一些共性的部分放置在一个基类中，其中提供的成员变量next能够维护顺序关系，通过调用其提供的setNext方法完成顺序关系的维护，handle方法能够提供不同的

1
public abstract class AbstractHandler {
2
    AbstractHandler next;
3
    public void setNext(AbstractHandler next){
4
        System.out.println("已经设置" + this.getClass().getSimpleName() + "的下一级为" + next.getClass().getSimpleName());
5
        this.next = next;
6
    }
7
    public abstract void handle();
8
}

三个处理器

1
public class Level1Handler extends AbstractHandler{
2
    @Override
3
    public void handle() {
4
        System.out.println("一级处理器正在处理");
5
        if (next != null) {
6
            next.handle();
7
        }
8
    }
9
}

1
public class Level2Handler extends AbstractHandler{
2
    @Override
3
    public void handle() {
4
        System.out.println("二级处理器正在处理");
5
        if (next != null) {
6
            next.handle();
7
        }
8
    }
9
}

1
public class Level3Handler extends AbstractHandler{
2
    @Override
3
    public void handle() {
4
        System.out.println("三级处理器正在处理");
5
        if (next != null) {
6
            next.handle();
7
        }
8
    }
9
}

最终的测试

1
public class ChainExecution {
2

3
    public static void main(String[] args) {
4
        Level1Handler level1Handler = new Level1Handler();
5
        Level2Handler level2Handler = new Level2Handler();
6
        Level3Handler level3Handler = new Level3Handler();
7

8
        level2Handler.setNext(level3Handler);
9
        level1Handler.setNext(level2Handler);
10

11
        level1Handler.handle();
12
    }
13
}

责任链模式降低了系统之间的耦合性，提升了系统的可扩展性。在很多中间件、框架的内部大量地使用了该种设计模式，比如Filter的执行过程等。

支付

Sun, 14 Jun 2026 00:00:00 GMT

支付业务流程#

业务场景如下，用户确认订单之后，跳转到支付界面，点击支付宝扫码支付的图标，就可以进行扫码支付了

1. 用户点击扫码支付

请求url：http://localhost/pay/alipay/submit/{orderId}

image-20230324102648455

2. 跳转到支付宝付款页面

image-20230324152933063

3. 用户扫码付款

image-20230324165118538

4. 浏览器跳转到支付成功页面

image-20230324163337306

支付宝支付#

支付宝简介#

支付宝是国内的第三方支付平台，致力于提供简单、安全、快速的支付解决方案。自2014年第二季度开始成为当前全球最大的移动支付)厂商。

支付详细流程#

1
1. 用户点击扫码支付图标，然后由浏览器发起支付请求，发给Gateway服务
2

3
2. Gateway收到请求之后把请求路由分发给 service-pay 服务
4

5
3. 支付服务接受请求，收到参数OrderId，然后调用订单服务的接口，查询这个订单是否是未支付的状态
6

7
4. 支付服务保存一条支付记录到数据库，并且记录状态为《未支付》
8

9
5. 支付服务向支付宝发起请求，获取支付页
10

11
6. 把支付页交给浏览器渲染，用户在浏览器中看到如下效果
12

13
7. 用户扫码或者是 用户输入账号密码确认支付
14

15
8. 同步回调：用户支付完成之后，浏览器发起请求，跳转到支付成功页面
16

17
9. 异步回调：用户支付完成之后，支付宝服务器发起请求，把支付结果通知给我们的服务，我们的服务收到请求之后，需要做修改订单状态，修改支付状态，扣减库存等操作

展开收起

image-20230324165332289

接入支付流程#

image-20230324164020243

找到对应的开发者平台（支付宝开放平台、微信开发平台、百度开放平台、讯飞开放平台、顺丰开放平台）
首先申请相关的账号
- 在那里申请呢？支付宝开放平台/微信开放平台+微信商户平台
- 申请什么账号呢？申请商户账号→ 商户id，在对应的平台上创建应用 → 应用id
- 申请账号需要什么资料呢？
  
  需要提交公司的营业执照，法人代表等身份信息，保证公司的合法性
绑定商户账号和应用ID，并配置接口访问的秘钥以及下载配置商户
确定需要接入支付的类别
- 刷脸支付
- 扫码支付
- APP支付
- 手机网站支付
- 电脑网站支付
查看你要接入的支付类别相对应的接口文档
编写代码

沙箱使用说明#

由于我们目前在开发的时候，没有商户账号，也没有营业执照等，所以暂时没有条件在支付宝上申请到对应的账号与AppId，不过支付宝为了协助我们开发者进行开发联调测试，推出了一个沙箱环境。

沙箱环境是协助开发者进行接口开发及主要功能联调的模拟环境，目前仅支持网页/移动应用和小程序两种应用类型。在沙箱完成接口调试后，直接修改必要的配置就可以接入正式环境。

沙箱环境地址

通过沙箱环境，我们需要获取的参数：

APPID

支付宝网关地址

应用公钥

应用私钥

支付宝公钥

当然，我们也可以使用沙箱平台在线调试我们的代码。

支付宝接口说明#

我们是网站应用，所以接入电脑网站支付。

在本项目中，使用到的接口有：

支付功能测试#

内网穿透#

为什么需要内网穿透？

我们当前的支付服务，网关服务等也是运行在网络上，为什么支付宝访问不到我们的支付服务或者是网关呢？

image-20230327115055579
如何解决`问题？

image-20230327120739464
内网穿透工具
- Natapp 下载地址
- 在配置页面我们可以看到authtoken，根据authToken启动natapp客户端，进入natapp所在的目录，打开命令行输入如下命令：
```
1
natapp -authtoken=你的authtoken
```

测试#

创建springboot工程，版本为2.7.17

1
<dependencies>
2
        <dependency>
3
            <groupId>org.springframework.boot</groupId>
4
            <artifactId>spring-boot-starter-web</artifactId>
5
        </dependency>
6
        <!--导入支付宝支付sdk-->
7
        <dependency>
8
            <groupId>com.alipay.sdk</groupId>
9
            <artifactId>alipay-sdk-java</artifactId>
10
            <version>4.35.71.ALL</version>
11
        </dependency>
12
    </dependencies>

定义启动类

1
@SpringBootApplication
2
public class PayApplication {
3

4
    public static void main(String[] args) {
5
        SpringApplication.run(PayApplication.class, args);
6
    }
7
}

定义配置类

1
@Configuration
2
public class MyAlipayConfig {
3

4
    @Bean
5
    public AlipayConfig getPublicConfig() {
6
        String privateKey = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCwH5CIl0zwjtnxXSVAom43F1QQFOz30V3y/ZswtHKQzC12e1dYkxLqeq7HOVYhBK225MU1WHZWM0he8V4ISGY7nCz0zE179OS8EcNR152MMkYlp6ZjspC6TtkdY/3WDbo/lgC6GN9T1bqiQnpAYL+61DAF4v70iOXVo6vWy/2IBlmG0Nfyn67RswFgmurNa/m/3MhbH3Ncd6hUUB8GnGgjtvXXTHJPniYNZzDUCBdA1YF5wQhG5D9zEpPitM10kPVBd0eJD+uThKQ1ZyKE7Wnb1l8VXIyFEOFkGqylAtCtjhz37F/YMOSn+QLGEZsc77TYwNABneHt1nuFKle8AMhfAgMBAAECggEAEoIOpzv3GuR4JLQcIRGwsVtjOxln2ZcH32wlLdYYn/zE3kmR4T37Y+amjUsKMQgT1T9vNe7o6KAU/90ve4FYNPVxh/wcPGV80AKx2tzksoHp+zUF+D4glWOJz1vdpevlYZ86zlOkzGOObFS+EhvYqiJ4NXYoQrxMIspDWZwwNWYAsqbUl2DITYo+JkBZP6U1oeQCs09KFsoIs73tsLc7UE5JLZL/fjmigo8wJvfGrAXAQwlg0ie8oAzpjlS2hK5YhaRezw9OqgcRb/KgnPOWApAepJ86RYOQsvhiuuP9SLctYSnCOWWxP5f+zLU1Hf1l4RAlctdy255QWaC6lbDHAQKBgQDi3Xl3Ccnv8zQVkIpiNSChjiYtjDELcdqbrdCSbLdUxRvjxg6t1NPVRTI9LzjCSIRWny01pYv6Ujt2+nAW28bGiPcMPg2J+Q5G70H33g85uJ6yy4aPTyfDi0XuUwn0Xaetm/qWFR4Mrvgy2a1eKMWXMN8OpD+Ebk/CKbLsr0kv3wKBgQDGveCk0GY+NOYx791nea9mWlFdY54Zx3HWf/cTnwcDGwr51jTYBgeoiWX0WCC2s4i6awCEedkTz0QdRRze/NLC9gYRwagHFA9rUwENYFih4HPiFcz13DjN6I0pjLam1VQf37ZWJyRwXXf4J2trMBDYFz8l84IPnxQWn2m7LQF3gQKBgQCWYVzMrW5wYfQaf09bvf+9V26zLoSsI3JXU6Y4CVyVEntkRrsgOz2X12Bv8kdbcZpXmPfs4amh6rSEL4nxfQmMPOoV8WQkGzV9i8dcuJO7HUgFGKg/gqbHFiDq05x7oUEu8X/v0Fu06J6ZhnVHPxuLFtgk6nc4H686800pWx/WXQKBgQCY3Bx3x86MFBXl3M8XMnHlMJyaTu+gdlWpnN0GG2/CRL+Jb+dPLDwhtiRT7qCixa3pbDmGq016vhVuyeSt4hmdWKtMZv39C8HcU4hgqHUjdMbM4uW1SL/sJ+zDQ3aNFVHR/jh5RTvyrQGEPZWSaPLbse2hHA0yRLGnwM8K50/UgQKBgHgd0L619bDKRsBKRag4fquNn+oU1kgWX8jjpGcLcDP/Eqpc7eE7AFSkMMuRS9aL8f59gyC4uv1DyuYpx3pgiPKER82uEkeLRrLGxJ31EtmOtc9XshOEw6v1x0MqkELVwCuJmf/DiW8MYEZDN07rkrx7doxKFBV+FrZQ5oJPnoCW";
7
        String alipayPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqnyvBrR4QWg0vY30uYToeDyZ7mq71nYVgkUKsBqaCzKoGbrGt75kWw7r+07ZHI8CqiYeQGd9krQ7TkFZ/DYF4p0k86wn21kqAILAVBW5mDkZF8xznDXX754NIcRXyDeUBuwGQ+FtH3GWtQVHAoTkv9XTW3RWonC/9z7DumDG3CajKZGUq64PnX0xttfEAIkGnGd7jgT8TQCVC6CH31XQMvOSDmkpCMNKYQn/XNpwaoV+SlXpJ8vV7a/9iThGBhXXRceilzOhK1bAB6MBFaMu67KWOV075cP3AwCHJmJyPVxzK54h/zn9wx0gEFGMAsuWaMTS6QI6VJCODKLwOdkpKQIDAQAB";
8
        AlipayConfig alipayConfig = new AlipayConfig();
9
        alipayConfig.setServerUrl("https://openapi.alipaydev.com/gateway.do");
10
        alipayConfig.setAppId("2021000117621153");
11
        alipayConfig.setPrivateKey(privateKey);
12
        alipayConfig.setFormat("json");
13
        alipayConfig.setAlipayPublicKey(alipayPublicKey);
14
        alipayConfig.setCharset("UTF8");
15
        alipayConfig.setSignType("RSA2");
16
        return alipayConfig;
17
    }
18
}

展开收起

定义Controller

1
@RestController
2
public class payController {
3

4
    @Autowired
5
    MyAlipayConfig myalipayConfig;
6

7

8
     @GetMapping("/test/page/pay")
9
    public String testPagePay() throws AlipayApiException {
10

11
        // 创建AlipayAlipayClient
12
        AlipayClient alipayClient = new DefaultAlipayClient(alipayConfig);
13
        // 创建Request对象
14
        AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
15
        // 创建Model对象封装请求参数
16
        AlipayTradePagePayModel model = new AlipayTradePagePayModel();
17
        model.setOutTradeNo("cskaoyan005");
18
        model.setTotalAmount("88.88");
19
        model.setSubject("Iphone6 16G");
20
        model.setProductCode("FAST_INSTANT_TRADE_PAY");
21

22
        request.setNotifyUrl("https://732sw00878.zicp.fun/callback/notify");
23
        // 给Model对象
24
        request.setBizModel(model);
25
        // 发起请求，获取结果
26
        AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
27

28
        if (response.isSuccess()) {
29
            System.out.println("调用成功");
30
        } else {
31
            System.out.println("调用失败");
32
        }
33
        // 输出响应体(支付表单页面)
34
        return response.getBody();
35
    }
36

37

38
    @GetMapping("/test/pay/query")
39
    public String testPayQuery() throws AlipayApiException {
40
        // 创建AlipayAlipayClient
41
        AlipayClient alipayClient = new DefaultAlipayClient(alipayConfig);
42
        // 创建Request对象
43
        AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();
44
        // 创建Model对象封装具体的请求参数
45
        AlipayTradeQueryModel model = new AlipayTradeQueryModel();
46
        model.setOutTradeNo("cskaoyan005");
47
        // 给Request设置具体的请求
48
        request.setBizModel(model);
49
        // 发起请求并获取响应
50
        AlipayTradeQueryResponse response = alipayClient.execute(request);
51

52
        if (response.isSuccess()) {
53
            System.out.println("调用成功");
54
        } else {
55
            System.out.println("调用失败");
56
        }
57

58

59
        // 返回响应中查询到的订单支付状态
60
        return response.getTradeStatus();
61
    }
62

63
    @GetMapping("return/notify")
64
    public String returnCallback(@RequestParam Map<String, String> paramsMap) {
65
        System.out.println(paramsMap);
66
        return "return notify success";
67
    }
68

69
    @GetMapping("/test/pay/close")
70
    public String testClosed() throws AlipayApiException {
71
        // 创建AlipayAlipayClient
72
        AlipayClient alipayClient = new DefaultAlipayClient(alipayConfig);
73
        // 创建Request对象
74
        AlipayTradeCloseRequest request = new AlipayTradeCloseRequest();
75
        // 创建Model对象封装具体的请求参数
76
        AlipayTradeCloseModel model = new AlipayTradeCloseModel();
77
        model.setOutTradeNo("cskaoyan005");
78
        // 给Request设置具体的请求
79
        request.setBizModel(model);
80
        // 发起请求并获取响应
81
        AlipayTradeCloseResponse response = alipayClient.execute(request);
82

83
        if (response.isSuccess()) {
84
            System.out.println("调用成功");
85
        } else {
86
            System.out.println("调用失败");
87
        }
88
        // 输出响应体
89
        return response.getBody();
90
    }
91

92
    @Autowired
93
    RedissonClient redissonClient;
94

95
    @PostMapping("/callback/notify")
96
    public String notifyCallback(@RequestParam Map<String, String> paramsMap) throws AlipayApiException {
97
  @Autowired
98
    RedissonClient redissonClient;
99

100
    @PostMapping("/callback/notify")
101
    public String notifyCallback(@RequestParam Map<String, String> paramsMap) throws AlipayApiException {
102

103
        // 1. 调用SDK验证签名
104
        boolean signVerified = AlipaySignature.rsaCheckV1(paramsMap, alipayConfig.getAlipayPublicKey(), alipayConfig.getCharset(), alipayConfig.getSignType());
105

106
        // 2. 验签成功后，按照支付结果异步通知中的描述，对支付结果中的业务内容进行二次校验
107
        if (signVerified) {
108

109
            String outTradeNo = paramsMap.get("out_trade_no");  // 外部订单号
110
            String totalAmount = paramsMap.get("total_amount"); // 交易总金额
111
            String appId = paramsMap.get("app_id");   // appId
112
            String tradeStatus = paramsMap.get("trade_status");  // 交易状态
113

114
            // 3. 二次参数校验，校验金额，校验appid
115
            // 根据订单id去数据库获取订单信息，以及其中的订单金额
116
            BigDecimal dbTotalAmount = new BigDecimal("88.88");
117
            int result = new BigDecimal(totalAmount).compareTo(dbTotalAmount);
118
            if (!appId.equals(alipayConfig.getAppId()) || result != 0) {
119
                return "failure";
120
            }
121
            // 4. 交易状态校验
122
            if (tradeStatus != null && (tradeStatus.equals("TRADE_SUCCESS") || tradeStatus.equals("TRADE_FINISHED"))) {
123

124
                // 5. 幂等性校验
125
                String notifyId = paramsMap.get("notify_id");
126
                String key = "pay:callback:notifyid" + notifyId;
127
                RBucket<String> bucket = redissonClient.getBucket(key);
128
                boolean ret = bucket.trySet(notifyId, 25, TimeUnit.HOURS);
129
                if (!ret) {
130
                    System.out.println("failure");
131
                    return "failure";
132
                }
133

134
                // 执行业务逻辑
135
                System.out.println("success");
136
                return "success";
137
            } else {
138
                System.out.println("failure");
139
                return "failure";
140
            }
141
        } else {
142
            System.out.println("failure");
143
            return "failure";
144
        }
145
    }
146

147
}

展开收起

表结构设计#

1
CREATE TABLE `payment_info` (
2
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
3
  `out_trade_no` varchar(50) DEFAULT NULL COMMENT '对外业务编号，创建订单的时候生成，从订单中获取',
4
  `order_id` varchar(50) DEFAULT NULL COMMENT '订单编号',
5
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id',
6
  `payment_type` varchar(20) DEFAULT NULL COMMENT '支付类型（微信 支付宝）',
7
  `trade_no` varchar(50) DEFAULT NULL COMMENT '交易编号，回调时生成',
8
  `total_amount` decimal(10,2) DEFAULT NULL COMMENT '支付金额',
9
  `subject` varchar(200) DEFAULT NULL COMMENT '交易内容，利用商品名称拼接。',
10
  `payment_status` varchar(20) DEFAULT NULL COMMENT '支付状态',
11
  `callback_time` datetime DEFAULT NULL COMMENT '回调时间',
12
  `callback_content` text COMMENT '回调信息',
13
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
14
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
15
  `is_deleted` tinyint(3) NOT NULL DEFAULT '0',
16
  PRIMARY KEY (`id`)
17
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8 COMMENT='支付信息表';

展开收起

接口#

去支付#

1
@RequestMapping("/pay/alipay/submit/{orderId}")
2
@ResponseBody
3
public String submitOrder(@PathVariable Long orderId){
4

5
    String form = alipayService.createAliPay(orderId);
6
    // 在上面这个支付的方法中，需要做的事情有如下几个
7

8
    // 1. 校验支付对应的订单状态是否为未支付，如果是已支付或已关闭，则直接返回
9

10
    // 2. 保存支付记录到支付表
11

12
    // 3. 调用支付宝SDK，生成支付表单（支付表单实际上就是一个支付页面，是一个html的字符串）
13

14
    // 4. 返回支付表单
15
    return form;
16
}

展开收起

支付工厂#

在第三步调用支付宝SDK的时候，我们可以用一个接口来定义对于支付服务提供商的访问行为如下：

1
public interface PayHelper {
2

3
    /*
4
         预下单方法，获取交易二维码字符串，或者交易表单字符串
5
     */
6
    String prePay(OrderInfoDTO orderInfo);
7

8

9
    /*
10
         根据订单号查询订单交易状态
11
     */
12
    String queryTradeStatus(String outTradeNo);
13

14

15
    /*
16
         根据订单编号关闭订单交易
17
     */
18
    void closeTrade(String outTradeNo);
19

20
}

展开收起

这样做的好处在于：

我们只需要访问PayHelper接口中定义的方法即可访问支付服务提供商的功能，代码书写简洁
因为调用的是接口方法，所以我们可以有不同的接口实现类，从而可以实现，在几乎不修改代码的情况下，访问不同支付服务提供商的支付功能

比如，如果我们使用支付宝支付时，我们就可以实现针对支付宝的实现类如下，同理如果我们如果还要访问微信支付，我们还可以定义微信支付的实现类。

1
@Component
2
public class AlipayHelper implements PayHelper {
3

4
    @Autowired
5
    CsmallAlipayConfig csmallAlipayConfig;
6

7
    @Autowired
8
    AlipayClient alipayClient;
9

10

11
    /**
12
     * 向支付宝发起请求，生成支付页面（表单）
13
     */
14
    @Override
15
    public String prePay(OrderInfoDTO orderInfo) {
16
        // 构建请求对象
17
        AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
18

19
        // 设置同步回调（不需要公网可访问）
20
        request.setReturnUrl(csmallAlipayConfig.getReturnPaymentUrl());
21

22
        // 设置异步回调（公网可访问）
23
        request.setNotifyUrl(csmallAlipayConfig.getNotifyPaymentUrl());
24

25
        // 构建参数
26
        AlipayTradePagePayModel model = new AlipayTradePagePayModel();
27
        model.setOutTradeNo(orderInfo.getOutTradeNo());
28
        model.setTotalAmount(orderInfo.getTotalAmount().toString());
29
        model.setSubject(orderInfo.getTradeBody());
30
        model.setProductCode("FAST_INSTANT_TRADE_PAY");
31
        // ...此处省略了一些代码(这些代码在4.1.2中解释)
32
        request.setBizModel(model);
33

34
        // 向支付宝发起请求
35
        AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
36

37
        return response.getBody();
38
    }
39

40
    /**
41
     * 根据外部订单号 查询支付宝支付状态
42
     */
43
     @Override
44
    public String queryTradeStatus(String outTradeNo) {
45
        String tradeStatus = "ACQ.SYSTEM_ERROR";
46
        try {
47
            AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();
48
            AlipayTradeQueryModel model = new AlipayTradeQueryModel();
49

50
            model.setOutTradeNo(outTradeNo);
51
            request.setBizModel(model);
52

53
            AlipayTradeQueryResponse response = alipayClient.execute(request);
54

55
            if ("ACQ.TRADE_NOT_EXIST".equals(response.getSubCode())) {
56
                return "ACQ.TRADE_NOT_EXIST";
57
            }
58

59
            if (response.isSuccess()) {
60
                tradeStatus = response.getTradeStatus();
61
            }
62
        } catch (AlipayApiException e) {
63
            e.printStackTrace();
64
        }
65
        return tradeStatus;
66
    }
67

68
    /**
69
     * 关闭支付宝支付记录
70
     */
71
    public void closeTrade(String outTradeNo) {
72

73
        AlipayTradeCloseModel model = new AlipayTradeCloseModel();
74
        model.setOutTradeNo(outTradeNo);
75

76
        AlipayTradeCloseRequest request = new AlipayTradeCloseRequest();
77
        request.setBizModel(model);
78

79
        try {
80
            alipayClient.execute(request);
81
        } catch (AlipayApiException e) {
82
            e.printStackTrace();
83
        }
84
    }
85
}

展开收起

如果在我们的项目中要接入不同的支付方式，很显然就需要用不同的PayHelper接口实现类对象，如何方便的获取这些PayHelper对象呢？我们可以使用前面学习过的简单工厂来实现：

1
public interface PayHelperFactory {
2
    // 获取PayHelper对象
3
    PayHelper getPayHelper(PaymentType paymentType);
4
}

1
@Getter
2
public enum PaymentType {
3

4
    ALIPAY("支付宝"),
5
    WEIXIN("微信" );
6

7
    private String comment ;
8

9

10
    PaymentType(String comment ){
11
        this.comment=comment;
12
    }
13
}

1
@Component
2
public class SimplePayHelperFactory implements PayHelperFactory{
3

4
    @Autowired
5
    AlipayHelper alipayHelper;
6
    @Override
7
    public PayHelper getPayHelper(PaymentType paymentType) {
8
        if (PaymentType.ALIPAY.equals(paymentType)) {
9
            return alipayHelper;
10
        }
11
        return null;
12
    }
13
}

超时时间#

这里有一点需要注意，在上面的第3步生成表单的时候，考虑到订单超市取消功能的实现，我们需要设置支付表单的过期时间，用当前时间 - 订单创建时间：

如果当前时间 - 订单创建时间 > 订单超时时间，则直接返回，不生成表单
否则，指定绝对时间 = 当前时间 + 剩余的订单超时时间(订单超时时间 - (当前时间 - 订单创建时间))

1
        // 获取当前时间
2
        long now = new Date().getTime();
3
        // 距离下单已经过去的时间
4
        long orderTimeSpan = now - createTime.getTime();
5
        long timeOutSpan = 30;
6
        if (orderTimeSpan >= timeOutSpan * 60 * 1000) {
7
            // 超过了订单的超时时间
8
            return "对不起，已经超过支付时间，请重新下单";
9
        }
10
        String timeoutStr;
11
        // 四舍五入求超时时间
12
        // 求以毫秒为单位的超时时间
13
        long timeoutRemain = timeOutSpan * 60 * 1000 - orderTimeSpan;
14
        // 生成过期时间对应的日期格式字符串
15
        timeoutStr = DateFormatUtils.format(new Date(now + timeoutRemain), "yyyy-MM-dd HH:mm:ss");
16

17
        // 设置相对超时时间
18
        model.setTimeExpire(timeoutStr);

展开收起

支付完成#

需要说明的是，同步回调和异步回调都会携带参数，在当前项目中，我们使用同步回调来跳转到支付成功页面；使用异步回调来修改订单状态等。这也是支付宝推荐的使用方式，新版本的支付接口已经取消了同步回调的支付结果的传递。

image-20230326184921170

同步回调#

同步回调的作用是跳转到支付成功页面。

pay-service#PayApiController

1
/**
2
 * 支付成功：同步回调
3
 */
4
@RequestMapping("/pay/alipay/alipay/callback/return")
5
public String callBack() {
6
    log.info("支付成功，同步回调！ ");
7
    // 同步回调给用户展示信息
8
    return "redirect:" + "http://localhost:8000/pay/success";
9
}

异步回调#

异步回调是指在请求参数中传入 notify_url 参数，在用户支付成功后，支付宝服务器会按照这个异步地址使用 post 方式给 notify_url 来发送交易信息，参数示例。需要注意的是：notify_url 地址由商户自己定义保证可以正常使用外网 post 方式访问，否则是无法正常接收到异步通知的。

pay-service#PayApiController

1
/**
2
 * 支付成功：异步回调
3
 */
4
@PostMapping("/pay/alipay/callback/notify")
5
@ResponseBody
6
@SneakyThrows
7
public String callbackNotify(@RequestParam Map<String, String> paramsMap){
8
    log.info("支付成功，异步回调，paramMap:{}", JSON.toJSONString(paramsMap));
9

10
    // 验证参数
11
      // 验签
12
      // 校验金额
13
      // 校验appid
14
      // 校验交易状态
15
      // 幂等性校验
16

17
     // 1. 调用SDK验证签名
18
        boolean signVerified = AlipaySignature.rsaCheckV1(paramsMap, alipayConfig.getAlipayPublicKey(), CsmallAlipayConfig.charset, CsmallAlipayConfig.sign_type);
19

20
        // 2. 验签成功后，按照支付结果异步通知中的描述，对支付结果中的业务内容进行二次校验
21
        if (signVerified){
22

23
            String outTradeNo = paramsMap.get("out_trade_no");  // 外部订单号
24
            String totalAmount = paramsMap.get("total_amount"); // 交易总金额
25
            String appId = paramsMap.get("app_id");   // appId
26
            String tradeStatus = paramsMap.get("trade_status");  // 交易状态
27

28
            PaymentInfoDTO paymentInfo = payService.queryPaymentInfoByOutTradeNoAndPaymentType(outTradeNo, PaymentType.ALIPAY.name());
29

30
            // 3. 二次参数校验，校验金额，校验appid
31
            if (paymentInfo == null) return "failure";
32
            BigDecimal dbTotalAmount = paymentInfo.getTotalAmount();
33
            double m = Double.valueOf(totalAmount) - dbTotalAmount.doubleValue();
34
            if (!appId.equals(alipayConfig.getAppId()) || m != 0) {
35
                return "failure";
36
            }
37
            // 4. 交易状态校验
38
            if (tradeStatus != null && (tradeStatus.equals("TRADE_SUCCESS") || tradeStatus.equals("TRADE_FINISHED"))) {
39

40
                // 5. 幂等性校验
41
                String notifyId = paramsMap.get("notify_id");
42
                String key = RedisConst.PAY_CALL_BACK_VERFY_PREFIX + notifyId;
43
                RBucket<String> bucket = redissonClient.getBucket(key);
44
                // setnx
45
                boolean ret = bucket.trySet(notifyId,RedisConst.PAY_CALL_BACK_EXPIRE_TIME, TimeUnit.SECONDS);
46
                if (!ret) {
47
                    // 幂等标记存在，说明处理成功，重复的通知，返回success
48
                    return "success";
49
                }
50

51
                // 6. 修改支付表状态为支付成功 //修改失败的话，需要删除幂等标记
52
            } else {
53
                // 通知失败，返回failure
54
                return "failure"
55
            }
56
        }
57

58

59
    // 回调成功，返回success
60
    return "success";
61
}

展开收起

支付后处理

Sun, 14 Jun 2026 00:00:00 GMT

支付处理成功#

![6. 支付后处理](/assets/firefly-docs/microservice/microservice-26-payment-postprocess/6. 支付后处理-16834705483461.png)

step1#

支付服务：支付宝异步回调

1
@PostMapping("/api/payment/alipay/callback/notify")
2
@ResponseBody
3
@SneakyThrows
4
public String callbackNotify(@RequestParam Map<String, String> paramsMap){
5
    log.info("支付成功，异步回调，paramMap:{}", JSON.toJSONString(paramsMap));
6

7
    // 1. 验证签名
8
    boolean signVerified = AlipaySignature.rsaCheckV1(paramsMap, alipayConfig.getAlipayPublicKey(), CsmallAlipayConfig.charset, CsmallAlipayConfig.sign_type);
9

10
    // 2. 校验参数
11
    // 校验APPID
12
    // 校验金额
13
    // 校验支付宝交易状态
14
    // 添加幂等标记（setnx）
15

16
    // 3. 修改支付表状态（已支付）
17

18
    // 4. 远程调用订单服务（修改订单状态）
19
}

展开收起

step2#

订单服务：修改订单状态

1
@PostMapping("/api/order/inner/success/{orderId}")
2
public Result successPay(@PathVariable Long orderId){
3

4
    // 1. 修改订单状态（已支付）
5

6
    // 2. 调用仓储服务 接口 (见仓储管理系统参考手册)
7
}

step3#

由仓储服务完成。

step4#

订单服务：拆单接口step5

1
@PostMapping("/api/order/inner/orderSplit/{orderId}")
2
public List<WareOrderTaskDTO> orderSplit(@PathVariable(value = "orderId") String orderId, @RequestBody List<WareSkuDTO> wareSkuDTOList){
3

4
    // 1. 获取原订单信息
5

6
    // 2. 创建新的子订单，使用原订单给子订单赋值（注意：设置parent_order_id为原订单Id）
7

8
    // 3. 设置子订单订单明细
9

10
    // 4. 保存子订单到数据库（状态：已支付）
11

12
    // 5. 修改原订单状态（状态：已拆分）
13

14
    // 6. 把子订单List转化为库存工作单List并返回
15
    return wareOrderTaskDTOS;
16
}

展开收起

step5#

订单服务：修改订单状态接口

1
@PostMapping("/api/order/inner/successLockStock/{orderId}/{taskStatus}")
2
public Result successLockStock(@PathVariable(value = "orderId") String orderId, @PathVariable(value = "taskStatus") String taskStatus){
3

4
    // 根据库存工作单状态 获取订单状态
5

6
    // 如果扣减成功，修改订单状态为待发货
7
    // 如果扣减失败，修改订单状态为库存扣减异常
8

9
    return Result.ok();
10
}

订单超时取消#

之前在订单模块，创建订单之后，发送了一个延迟消息，本项目中，在订单模块处理这个延迟消息。

![7. 订单超时取消逻辑](/assets/firefly-docs/microservice/microservice-26-payment-postprocess/7. 订单超时取消逻辑.png)

伪代码实现

1
// 处理超时订单
2
public void execExpiredOrder(Long orderId) {
3

4
    OrderInfo orderInfo = orderInfoMapper.selectById(orderId);
5
    // 0. 如果订单不存在，那么直接返回
6
    // 1. 如果订单已支付，也直接返回
7
    // 2. 如果订单状态 是未支付
8
    if (orderStatus.equals(OrderStatus.UNPAID.name()) {
9

10
        // 3. 查询支付记录
11
        PaymentInfoDTO paymentInfoDTO = payApiClient.getPaymentInfoDTO(orderId);
12
        if(paymentInfoDTO != null) {
13

14
            // 3. 查询支付宝 是否存在支付记录（如果获取成功，Result的data字段放的是支付状态字符串，比如TRADE_SUCCESS）
15
            Result ret = payApiClient.getAlipayInfo(outTradeNo);
16
            // 4.
17
            if (如果有支付记录 即ret的状态码为200) {
18
                // 5. 判断是否交易成功
19

20
                if (“TRADE_SUCCESS”.equals(result.getData().toString())) {
21
                    // 如果交易成功，直接返回
22
                    return;
23
                }
24

25
                if (ret data字段的值不等于 "ACQ.TRADE_NOT_EXIST") {
26
                  // 关闭支付宝 支付记录
27
                   closeAlipay();
28
                }
29

30

31
            }
32
            // 关闭支付记录，调用支付服务，将支付记录的支付状态改为CLOSED
33
            closePay();
34
        }
35
        // 关闭订单 将订单状态改为CLOSED
36
        closeOrder();
37
    }
38

39
}

展开收起

秒杀

Sun, 14 Jun 2026 00:00:00 GMT

秒杀背景介绍#

所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一种销售方式。通俗一点讲就是网络商家为促销等目的组织的网上限时抢购活动。由于商品价格低廉，往往一上架就被抢购一空，有时只用一秒钟。

秒杀商品通常有三种限制：库存限制、时间限制、购买量限制。

库存限制：商家只拿出限量的商品来秒杀。比如某商品实际库存是200件，但只拿出50件来参与秒杀。我们可以将其称为“秒杀库存”。商家赔本赚吆喝，图的是人气与流量
时间限制：通常秒杀都是有特定的时间段，只能在设定时间段进行秒杀活动
购买量限制：同一个商品只允许用户最多购买几件。比如某手机限购1件。张某第一次买个1件，那么在该次秒杀活动中就不能再次抢购

数据库设计#

1
CREATE TABLE `seckill_goods` (
2
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
3
  `spu_id` bigint(20) DEFAULT NULL COMMENT 'spu_id',
4
  `sku_id` bigint(20) DEFAULT NULL COMMENT 'sku_id',
5
  `sku_name` varchar(100) DEFAULT NULL COMMENT '标题',
6
  `sku_default_img` varchar(150) DEFAULT NULL COMMENT '商品图片',
7
  `price` decimal(10,2) DEFAULT NULL COMMENT '原价格',
8
  `cost_price` decimal(10,2) DEFAULT NULL COMMENT '秒杀价格',
9
  `check_time` datetime DEFAULT NULL COMMENT '审核日期',
10
  `status` varchar(20) DEFAULT NULL COMMENT '审核状态',
11
  `start_time` datetime DEFAULT NULL COMMENT '开始时间',
12
  `end_time` datetime DEFAULT NULL COMMENT '结束时间',
13
  `num` int(11) DEFAULT NULL COMMENT '已售秒杀商品数',
14
  `stock_count` int(11) DEFAULT NULL COMMENT '剩余库存数',
15
  `sku_desc` varchar(2000) DEFAULT NULL COMMENT '描述',
16
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
17
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
18
  `is_deleted` tinyint(3) NOT NULL DEFAULT '0',
19
  PRIMARY KEY (`id`)
20
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8;

展开收起

功能分析#

当前项目秒杀业务流程：

后台运营人员通过管理系统录入秒杀商品，主要包括商品标题、原价、秒杀价、图片、库存等；提交秒杀活动申请
后台管理人员通过管理系统审核，审核通过表示可以参与秒杀；审核不通过表示不能秒杀
秒杀频道首页列出当天的秒杀商品，用户点击秒杀图片跳转到秒杀商品详情页
商品详细页显示秒杀商品信息，点击立即抢购进入秒杀订单确认页面
点击立即下单，参与抢购，抢购成功，用户生产订单，扣减秒杀库存；抢购失败，扣减秒杀库存失败，用户生成订单失败
当用户秒杀下单30分钟内未支付，取消订单，调用微信支付或支付宝的关闭订单接口。

说明：

当前项目中的秒杀活动，我们默认为每天早上8:00开始，晚上8:00结束

取消订单的业务因为之前做过了，在秒杀业务中我们不做，主要是考虑前面抢购下单的部分

秒杀列表页#

image-20230328101327281

业务分析：查询秒杀表中”当前正在秒杀”的商品

1
# 如何确认当前正在参与秒杀呢？
2
# 1. 审核通过：status = CHECKED_PASS
3
# 2. 今天开始：DATE_FORMAT(start_time,'%Y-%m-%d') = new Date()
4
# 3. 库存大于0：stock_count>0

秒杀商品详情页#

image-20230327175517363

业务分析：根据商品Id查询秒杀商品详情。

立即抢购#

会出现下单之前的结算页面

image-20230327180015193

image-20230327180027532

提交订单#

提交订单之后，可能会有如下结果

功能实现思路#

库存状态标志位#

当秒杀商品售罄时，如果能有一个标志位来标识，我们就无需在访问数据库了，而是直接返回秒杀失败的结果。通过引入库存状态标志位，我们可以在秒杀商品售罄时，迅速返回失败的响应。

1
@Slf4j
2
public class LocalCacheHelper {
3

4

5
    /**
6
     * 缓存，key为skuId，value为库存状态0表示售罄，1表示未售罄
7
     */
8
    private final static Map<String, Object> cacheMap = new ConcurrentHashMap<String, Object>();
9

10
    /**
11
     * 加入缓存
12
     *
13
     * @param key
14
     * @param cacheObject
15
     */
16
    public static void put(String key, Object cacheObject) {
17
        cacheMap.put(key, cacheObject);
18
        log.info("当前本地缓存 cacheMap:{}", JSON.toJSONString(cacheMap));
19
    }
20

21
    /**
22
     * 获取缓存
23
     * @param key
24
     * @return
25
     */
26
    public static Object get(String key) {
27
        return cacheMap.get(key);
28
    }
29

30
    /**
31
     * 清除缓存
32
     *
33
     * @param key
34
     * @return
35
     */
36
    public static void remove(String key) {
37
        cacheMap.remove(key);
38
    }
39

40

41
    public static void removeAll() {
42
        cacheMap.clear();
43
    }
44
}

展开收起

库存状态的初始化#

由于我们每一天都可能有秒杀活动，所以库存状态的初始化，可以选择在每天的凌晨这种访问量不高的时段内，通过定时任务，查询出当天要参与秒杀活动的商品，将其库存状态初始化为1，即未售罄的状态。

1
// 从数据库中获取
2
List<SeckillGoods> seckillGoodsList = ...
3

4
// 遍历并初始化库存标志位
5
for(SeckillGoods seckillGoods : seckillGoodsList) {
6
    // 1表示有库存状态
7
    LocalCacheHelper.put(seckillGoods.getSkuId().toString(), "1");
8
}

如何实现定时任务呢？通过Spring Scheduling实现

接口功能实现#

定时任务#

定时任务如何实现#

在程序中常常有定时任务的需求，例如每隔一周生成一次报表、每个月月末清空用户积分等等。Spring也提供了相应的支持，我们可以非常方便的按时执行任务。

官方参考文档地址

如何实现呢？

开启定时任务功能 @EnableScheduling
添加任务 @Scheduled(cron="")

1
@Component
2
@EnableScheduling
3
public class ScheduledTask {
4

5
  @Scheduled(cron = "0 0/1 * * * ?")   // 每分钟执行一次
6
    public void importIntoRedisTask(){
7

8
        // TODO something...
9

10
    }
11
}

cron表达式#

1
 ┌───────────── second (0-59)
2
 │ ┌───────────── minute (0 - 59)
3
 │ │ ┌───────────── hour (0 - 23)
4
 │ │ │ ┌───────────── day of the month (1 - 31)
5
 │ │ │ │ ┌───────────── month (1 - 12) (or JAN-DEC)
6
 │ │ │ │ │ ┌───────────── day of the week (0 - 7)
7
 │ │ │ │ │ │          (0 or 7 is Sunday, or MON-SUN)
8
 │ │ │ │ │ │
9
 * * * * * *

Terminal window

1
# 占位符解释
2

3
# *： 表示每秒钟都触发
4
* * * * * ? : 表示每秒触发一次
5

6
# ,： 表示在指定的秒触发
7
15,45 * * * * ? : 表示每分钟的15秒，45秒都触发一次
8

9

10
# -：表示在指定的范围内每秒都触发
11
20-30 * * * * * ： 表示在每分钟的20秒-30秒内，每秒触发一次
12

13
# /: 表示步进，也就是增量。
14
15/20 * * * * * : 表示从每分钟的15秒开始，每20秒触发一次，即 15s，35s，55s各触发一次

注意事项：

cron表达式可以是七位，最后一位是年，可以省略

天和星期会冲突，当表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

Terminal window

1
# 常用的cron表达式
2
0/2 * * * * ?   表示每2秒 执行任务
3

4
0 0/2 * * * ?    表示每2分钟 执行任务
5

6
0 0 2 1 * ?   表示在每月的1日的凌晨2点调整任务
7

8
0 0 12 * * ?   每天中午12点触发
9

10
0 0 10,14,16 * * ?   每天上午10点，下午2点，4点
11

12
0 0 12 ? * WED    表示每个星期三中午12点

在线cron生成器

https://cron.ciding.cc/

本地库存状态位初始化#

1
@Component
2
@EnableScheduling
3
public class ScheduledTask {
4

5
  @Scheduled(cron = "0 0 1 * * ?")   // 每天凌晨一点执行
6
    public void importIntoRedisTask(){
7

8
        // 1. 从数据库查询今天的秒杀商品数据
9
        // where status = CHECKED_PASS AND stock_count > 0 AND DATE_FORMAT(start_time,'%Y-%m-%d') = ?
10

11

12
        // 2. 初始化库存状态位
13
        for(...) {
14

15
        // eg: 50-1 表示skuId为50的商品还有库存
16
        // eg: 49-0 表示skuId为49的商品没有库存
17
        LocalCacheHelper.put(skuId,"1");
18

19
        }
20
    }
21
}

展开收起

秒杀商品列表#

image-20240503174751864

1
@GetMapping("/seckill")
2
public Result findAll() {
3

4
    // 调用promoService的方法，根据如下条件查询
5
    // 1. 审核通过：status = CHECKED_PASS
6
    // 2. 今天开始：DATE_FORMAT(start_time,'%Y-%m-%d') = new Date()
7
    // 3. 库存大于0：stock_count>0
8

9
    return Result.ok(promoService.findAll());
10
}

秒杀商品详情#

image-20240503174812802

1
@GetMapping("seckill/{skuId}")
2
public Result getSeckillGoods(@PathVariable("skuId") Long skuId) {
3

4
    // 获取秒杀商品数据详情
5
    return Result.ok(promoService.getSeckillGoodsDTO(skuId));
6

7
}

秒杀商品结算#

当点击立即抢购之后，我们就会跳转到结算页面，先来看一看前端代码

1
 async trade () {
2
      // 获取下单码
3
      const res = await getSeckillSkuIdStr(this.goodsData.skuId)
4

5
      // 跳转结算页
6
      this.$router.push({
7
        name: 'seckillTrade',
8
        query: {
9
          skuId: this.goodsData.skuId,
10
          skuIdStr: res.data
11
        }
12
      })
13
    }

获取下单码#

下单码的目的主要是秒杀下单的时候校验用户请求，防止非法请求参与秒杀下单

1
@GetMapping("seckill/auth/getSeckillSkuIdStr/{skuId}")
2
public Result getSeckillSkuIdStr(@PathVariable("skuId") Long skuId, HttpServletRequest request) {
3

4
    // 获取用户id
5
    String userId = AuthContext.getUserId(request);
6

7
    // 获取秒杀商品信息
8
    SeckillGoodsDTO seckillGoods = promoService.getSeckillGoodsDTO(skuId);
9
    if (null != seckillGoods) {
10
        Date curTime = new Date();
11

12
        // 判断当前时间是否在秒杀商品开始时间和结束时间之内
13
        if (DateUtil.dateCompare(seckillGoods.getStartTime(), curTime) && DateUtil.dateCompare(curTime, seckillGoods.getEndTime())) {
14
            // 生成下单码
15
            // 可以用其他方式生成
16
            String skuIdStr = MD5.encrypt(userId);
17
            return Result.ok(skuIdStr);
18
        }
19
    }
20
    return Result.fail().message("获取下单码失败");
21
}

展开收起

获取秒杀结算数据#

1
@GetMapping("/seckill/auth/trade/{skuId}")
2
public Result<OrderTradeDTO> trade(@PathVariable("skuId") Long skuId,String skuIdStr, HttpServletRequest request) {
3

4
    //1. 校验下单码（抢购码规则可以自定义）
5
    String userId = AuthContext.getUserId(request);
6
    if (!skuIdStr.equals(MD5.encrypt(userId + skuId))) return Result.build(null, SeckillCodeEnum.SECKILL_ILLEGAL);
7

8
    // 2. 校验状态位
9
    String skuStatus = (String) LocalCacheHelper.get(skuId.toString());
10
    if (skuStatus == null) return Result.build(null,  SeckillCodeEnum.SECKILL_ILLEGAL);   // 请求非法
11
    if (skuStatus.equals("0")) return Result.build(null, SeckillCodeEnum.SECKILL_FINISH); // 库存售罄
12

13

14
    // 3. 获取结算信息
15
    OrderTradeDTO tradeData =  ...
16
    return Result.ok(tradeData);
17

18
}

展开收起

成功获取秒杀下单结算数据后，跳转到秒杀下单结算页面

image-20230329001116671

秒杀下单#

在结算页面中，点击提交订单就开始真正的秒杀下单，对于秒杀服务而言，主要的工作分三步完成：

校验库存标志位，校验是否重复下单
扣减秒杀商品库存
调用订单服务，生成秒杀订单

1
/**
2
  * 提交秒杀订单
3
    * POST http://localhost/seckill/auth/submitOrder
4
*/
5
@PostMapping("/seckill/auth/submitOrder")
6
public Result submitOrder(@RequestBody OrderInfoParam orderInfo, HttpServletRequest request) {
7

8
    Long skuId = orderInfo.getOrderDetailList().get(0).getSkuId();
9
    // 1. 获取用户id
10
    String userId = AuthContext.getUserId(request);
11

12
    // 2. 校验本地库存状态位
13
    Object stockFlag = LocalCacheHelper.get(skuId.toString());
14
    if (!"1".equals(stockFlag)) {
15
        return Result.build(null, SeckillCodeEnum.SECKILL_FINISH);
16
    }
17

18
    // 3. 校验是否重复下单
19
    RSet<Long> set = redissonClient.getSet(RedisConst.PROMO_USER_ORDERED_FLAG + userId);
20
    boolean ret = set.tryAdd(skuId);
21
    if (!ret) {
22
        return Result.build(null, SeckillCodeEnum.SECKILL_DUPLICATE_TRADE);
23
    }
24

25
    orderInfo.setUserId(Long.valueOf(userId));
26

27
    // 4. 提交秒杀订单
28
    boolean submitOrderRet = promoService.submitOrder(orderInfo);
29
    if (!submitOrderRet) {
30
        return Result.build(null, SeckillCodeEnum.SECKILL_FINISH);
31
    }
32

33
    // 返回下单成功
34
    return Result.build(null, SeckillCodeEnum.SECKILL_ORDER_SUCCESS);
35

36
}

展开收起

1
    /*
2
         提交秒杀订单
3
     */
4
    boolean submitOrder(OrderInfoParam orderInfo);

1
public boolean submitOrder(OrderInfoParam orderInfo) {
2

3
    Long skuId = orderInfo.getOrderDetailList().get(0).getSkuId();
4

5
    // 1. 扣减库存
6
    int affectedRows = seckillGoodsMapper.decreaseStock(skuId, 1);
7
    if (affectedRows < 1) {
8
        // 没有库存了
9
        // 更新本地库存状态位
10
        LocalCacheHelper.put(skuId.toString(), "0");
11
        return false;
12
    }
13

14
    // 2. 调用订单接口，生成订单
15
    Long orderId = orderApiClient.submitOrder(orderInfo);
16
    if (orderId != null) {
17
        return true;
18
    }
19

20
    return false;
21
}

展开收起

分布式事务

Sun, 14 Jun 2026 00:00:00 GMT

问题的引入#

再来回顾一下我们的秒杀下单接口

image-20240606015255568

从秒杀下单业务逻辑来讲，秒杀下单要么成功，要么失败，不存在中间状态。这就要求:

扣减库存和秒杀商品的订单以信息的保存要么全部成功，要么全部失败
所以，扣减库存和秒杀商品的订单以及订单邮寄信息的保存的实现，应该实现为一个事物

但是，回顾一下我们秒杀下单的实现代码，我们能够实现，让秒杀服务对数据库的访问(扣减秒杀商品库存)，以及订单服务对数据库的访问(保存秒杀订单信息)，成为一个数据库事物吗？当然不行

image-20240606015233450

那么如何让秒杀服务对数据库的访问，以及订单服务对数据库的访问成为一个事务呢？需要使用分布式事务

分布式系统理论#

CAP理论#

在讲解分布式事务之前，我们必须首先了解分布式系统中的一个基本理论，CAP理论。这个定理里描述了一个分布式的系统中，以下三个特性最多只能同时满足其中两个

C(consistentcy)：一致性。代表数据在任何时刻、任何分布式节点中所看到的都是符合预期的
A(Availibality): 可用性。代表系统不间断地提供服务的能力
P(Partition Tolerance): 分区容忍性。代表分布式环境中部分节点因网络原因而彼此失联后，即与其他节点形成“网络分区”时，系统仍能正常地提供服务的能力。

接下来，我们以两台数据库服务器所组成的数据库服务器集群来说明，这三种特性对分布式系统来说将意味着什么。

image-20240606015223264

在这个简单的系统中，用户通过数据库客户端访问数据库服务器，针对用户的写操作，数据库服务器1和数据库服务器2之间可以相互同步数据。我们希望不管用户访问数据库服务器1还是数据库服务器2，它们之间都可以正确的同步数据的修改，从而使两个数据库服务器中的数据一致。但是，在实际运行时，可能会发生以下的问题：

如果用户对数据库服务器1对数据的修改，没有被及时同步给数据库服务器2，那么就会导致，用户通过不同的客户端访问数据库，看到的数据不相同，此即为一致性问题
如果由于要把对一个数据库服务器中的数据修改同步给另外一个数据库服务器，必须暂时停止用户对数据库服务器的访问，直到数据同步完成在重新恢复，将可能导致用户在下一次访问数据库时，因数据库服务器之间正在同步数据，而无法访问数据库，此即为可用性问题
如果由于数据库服务器之间的网络问题，导致数据库服务器之间无法相互同步数据，此时我们是否继续允许数据库服务器继续正常运行，并且能被访问。此即为分区容忍性问题。

接下来，我们讨论一下在一个分布式系统中，C，A，P这三个指标之间的关系：

如果放弃分区容忍性（CA without P）：意味着我们将假设节点之间通信永远是可靠的。永远可靠的通信在分布式系统中必定不成立的。所以分区容忍性在分布式系统中不可能排除。
如果放弃可用性（CP without A）：意味着我们将假设一旦网络发生分区，节点之间的信息同步时间可以无限制地延长，直到网络故障恢复。这就意味着在这个过程中，系统不能被外界正常的访问。
如果放弃一致性（AP without C）：意味着我们将假设一旦发生分区，节点之间所提供的数据可能不一致，用户访问到的数据也可能有不一致的情况。

所以，CAP理论的结论是：一个分布式的系统中CAP三个特性最多只能同时满足其中两个

image-20240606015205819

BASE理论#

有了CAP理论之后，2008年由eBay的工程师提出了BASE理论，可以把它看作是CAP理论的延伸：

基本可用（Basically Available）：基本可用指的是系统保证核心功能的可用性。
软状态（Soft State）：系统的状态不需要实时保持一致，即系统中的数据可以存在一段时间的不一致
最终一致性（Eventually Consistent）：虽然系统在某一时间点可能不保证数据的严格一致性，但承诺在未来某个时间点，所有的数据最终会变得一致

分布式事务#

在微服务架构中，分布式事务是指不同的服务对不同数据库的访问成为一个事务。根据对数据一致性的要求不同，分布式事务又分为了两类：

刚性事务：像本地事务一样，追求事务的ACID特性，即追求数据的强一致性。比如2PC等
柔性事务：不在追求事务的ACID特性，转而追求数据的最终一致性。比如，TCC事务，消息型事务等

刚性事务#

为了解决分布式事务的一致性问题，X/Open组织提出了一套名为X/Open XA（XA 是 eXtended Architecture 的缩写）的处理事务规范，被称为2PC，又叫做二阶段提交协议它将整个事务处理的过程定义为两个阶段：

准备阶段：又叫作投票阶段，在这一阶段，事务管理器询问事务的所有参与者，发送要执行的SQL语句，并询问是否准备好提交(此时，SQL语句在数据库的本地事务中执行，但不提交)，参与者如果已经准备好提交则回复 Prepared，否则回复 Non-Prepared
提交阶段：又叫作执行阶段，事务管理器如果在上一阶段收到所有事务参与者回复的 Prepared 消息，则向所有参与者发送 Commit 指令，所有参与者立即执行提交操作;否则，任意一个参与者回复了 Non-Prepared 消息，或任意一个参与者超时未回复，协调者向所有参与者发送 Rollback 指令，参与者立即执行回滚操作

两段式提交原理简单，并不难实现，但有几个非常显著的缺点：

资源锁定问题：从事务的第一阶段开始，参与事务的资源就会被当前事务锁定，直到事务执行完毕。
单点问题：一旦协调者(事务管理器)宕机的话，所有参与者都会受到影响。如果协调者一直没有恢复，没有正常发送 Commit 或者 Rollback 的指令，那所有参与者都必须一直等待。
性能问题：整个事务的执行，要等待整个两个阶段的工作都完成，整个事务才会执行结束，这是一个同步阻塞的过程，所以事务的执行效率不会很高
一致性问题：数据不一致的风险仍然存在

柔性事务#

柔性事务与刚性事务不同，不追求数据的强一致性，而只追求数据的最终一致性。常见的柔性事务有TCC，以及消息型事务等。

TCC事务#

TCC 是另一种常见的分布式事务机制，它是“Try-Confirm-Cancel”三个单词的缩写。TCC事务分为以下三个步骤：

Try：尝试执行，完成所有业务可执行性的检查，并且预留好全部需用到的业务资源。
Confirm：确认执行，不进行任何业务检查，直接使用 Try 阶段准备的资源来完成业务处理
Cancel：取消执行，释放 Try 阶段预留的业务资源

TCC事务和2PC的形式有些类似，也是将整个事务的执行分成了两个阶段，其中

Try阶段类比于2PC的准备阶段
Confirm/Cancel类比于2PC的提交阶段，confirm类比于commit指令，cancel类比于rollback指令

在使用TCC事务之前我们还得先完成代码的改造，让订单服务和秒杀服务分别实现，针对Try，Confirm和Cancel三个阶段的三个方法：

image-20240606015335152

对于秒杀服务而言，try方法扣减可售卖库存，增加冻结库存，confirm方法扣减冻结库存，增加锁定库存，try方法和confirm方法合起来，完成整个库存扣减功能，而cancel方法的功能则是”抵消”第一步try方法对数据库的修改，扣减冻结库存，并加回可售卖库存。
对于订单服务也是类似，在try方法中完成保存订单信息，但订单状态保存为“预下单”，在confirm方法中将订单状态改为初始化状态。cancel方法则用来”抵消”第一步try方法对数据库的修改，删除try方法中插入的订单

整个执行过程分为如下两个阶段：

第一阶段，通过事务管理器调用秒杀服务和订单服务的try方法，事务管理器会负责收集两个服务try方法执行的结果，当收集到两服务的try方法的执行结果，自动进入第二阶段
第二个阶段，事务管理器会判断两服务的try方法执行成功与否的结果，如果两服务的try方法都执行成功，则事务管理器自动调用两服务的confirm方法完成整个事务。否则，如果两服务中至少有一个服务的try方法执行不成功，则调用两服务的cancel方法，实现事务的回滚，“抵消”两服务中的try方法对数据库的修改

虽然都是两阶段，但是TCC事务和2PC还是有明显的区别：

TCC事务的实现不依赖于数据库事务，TCC是业务层面的两阶段，而2PC是数据库内部事务提交的两阶段
和2PC相比，使用TCC几乎不会出现资源锁定的问题，因为在数据库层面，try，confirm，cancel是三个完全独立的事务
因为TCC不依赖于数据库，所以其实现更加灵活

但是TCC事务也有它明显的缺点，其实现具有很强的代码侵入性，要是用TCC事务，首先就得改造代码，实现try，confirm，cancel，这也意味这TCC事务通常与业务逻辑强耦合，不便于代码维护

消息型事务#

消息型事务不止一种实现方式，但是其中最简单的就是基于RocketMQ的事务消息实现的分布式事务。

要理解基于RocketMQ实现的分布式事务，就必须首先理解RocketMQ的事务消息，其特征如下：

MQ发送方和MQ订阅方分别指消息生产者和消息消费者，它们在不同的服务中运行
对于消息生产者而言，一旦它发送消息成功，紧接着就会执行一个本地事务，该事物的结果直接决定消息是否能被消息消费者消费到
对于消费者而言，只有当消息生产者执行的本地事务成功，消费者才能消费到消息，否则永远也消费不到消息。
同时，如果本地事务执行的结果没有被成功发送给RocketMQ，RocketMQ还会主动向消息生产者查询本地事务的执行结果，从而决定消费者是否能消费到消息

所以，消息发送者所执行的本地事务的结果决定了消费者是否能消费到消息，这样的消息我们称之为事务消息。对于事务消息的发送和普通消息的发送有较大的差别，但是事务消息的消费和普通消息没有区别，所以我们重点看下事务消息的发送代码：

1
 public static void main(String[] args) throws MQClientException {
2

3
        // 1. 创建专门用于发送事务消息的producer
4
        TransactionMQProducer transactionProducer
5
                = new TransactionMQProducer("test_transaction_producer56");
6

7

8
        //2. 设置nameserver地址
9
        transactionProducer.setNamesrvAddr("192.168.153.149:9876");
10

11
        //3. 设置TransactionLisener
12
        transactionProducer.setTransactionListener(new TransactionListener() {
13
            /*
14
                  在该方法中执行本地事务
15
                  参数:
16
                   msg: 发送的事务消息
17
                   arg: 发送事务消息所需的参数(不需要就传递null)
18
                  返回值: 表示本地事务的执行结果
19
             */
20
            @Override
21
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
22
                // ... 本地事务
23
                return null;
24
            }
25

26
            /*
27
                 本地事务执行结果的查询
28
                 参数:
29
                   msg: 之前发送的事务消息
30
                 返回值:
31
                   查询到的本地事务的执行结果
32
             */
33
            @Override
34
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
35
                // ... 查询本地事务的执行结果
36
                return null;
37
            }
38
        });
39

40
        // 4. 启动producer对象
41
        transactionProducer.start();
42

43
        // 5. 准备待发送的消息
44
        Message message = ...;
45

46
        // 6. 发送事务消息，第二个参数就是传递给本地事务的参数
47
        TransactionSendResult transactionSendResult = transactionProducer.sendMessageInTransaction(message, null);
48
        System.out.println(transactionSendResult);
49

50
    }

展开收起

基于RocketMQ的事务消息，我们就可以实现秒杀服务和订单服务的分布式事务了，该事物的执行会有三种情况：

秒杀服务(我们称为上游服务)本地事务执行失败，订单服务(我们称为下游服务)消费不到消息，相当于什么也没做
上游服务本地事务执行成功，下游服务消费到消息且本地事务也执行成功，相当于都成功
上游服务本地事务执行成功，下游服务消费到消息但是本地事务执行失败，此时会出现数据的不一致

针对第3种情况，我们也无需担心，因为：

RocketMQ会有16次重试的机会，在重试过程中，只要下游服务消费消息成功，那么又会变成第2种情况。
即使16次重试都失败，也没有关系，RocketMQ会把这种消息存储到一种特殊的死信队列中。然后我们可以通过人工干预的方式，获取死信队列中的消息，在解决订单服务的问题后，将死信队列中的消息重新发送到RocketMQ让下游服务重新消费。

分布式事务的实现#

在下单时，除了检查是否重复下单，我们只需要检查重复下单，然后给订单服务发送事务消息，至于库存扣减，需要再TransactionManager中实现。

1
 public void submitOrderInTransaction(OrderInfoParam orderInfo) {
2

3
        // 一次只对一个秒杀商品下单
4
        Long skuId = orderInfo.getOrderDetailList().get(0).getSkuId();
5

6
        RSet<Long> set = redissonClient.getSet(RedisConst.PROMO_USER_ORDERED_FLAG + orderInfo.getUserId());
7
        // 向用户抢购的商品id集合中，添加当前sku商品id
8
        boolean ret = set.tryAdd(skuId);
9
        if (!ret) {
10
            // 如果用户已经下过单，那么直接返回
11
            throw new BusinessException(SeckillCodeEnum.SECKILL_DUPLICATE_TRADE);
12
        }
13

14
        Map<String, Number> paramMap = new HashMap<>();
15
        paramMap.put("skuId", orderInfo.getOrderDetailList().get(0).getSkuId());
16
        paramMap.put("count", orderInfo.getOrderDetailList().get(0).getSkuNum());
17
        MqResultEnum mqResultEnum = producer.sendTransactionMessage(MqTopicConst.PROMO_ORDER_TOPIC, orderInfo, paramMap);
18
        if (mqResultEnum.SEND_FAIL.equals(mqResultEnum)) {
19
            // 消息未发送成功，或者本地事务执行失败, 需要让用户可以重新下单
20
            redissonClient.getSet(RedisConst.PROMO_USER_ORDERED_FLAG + orderInfo.getUserId()).remove(skuId);
21
            throw new BusinessException(SeckillCodeEnum.SECKILL_ORDER_TRY_AGAIN);
22
        }
23

24
        if (mqResultEnum.LOCAL_TRANSACTION_FAIL.equals(mqResultEnum)) {
25
            // 消息发送成功，本地事务执行失败
26
            throw new BusinessException(SeckillCodeEnum.SECKILL_FINISH);
27
        }
28
        //  本地事务执行成功
29
    }

展开收起

在TransactionListener的实现如下：

1
 transactionMQProducer.setTransactionListener(new TransactionListener() {
2
      @Override
3
      public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
4
          Map<String, Number> paramsMap = (Map<String, Number>) arg;
5

6
          Number skuId = paramsMap.get("skuId");
7
          Number count = paramsMap.get("count");
8
                // 扣减库存
9
          RBucket<String> bucket = redissonClient
10
              .getBucket(RedisConst.PROMO_TRANSACTION_PREFIX + msg.getTransactionId());
11
       try {
12
                    Integer stock = seckillGoodsMapper.decreaseStock(skuId, 1);
13

14
                    if (stock <= 0) {
15
                        // 库存售罄
16
                        if (stock == 0) {
17
                            // 设置库存售罄标志位
18
                            LocalCacheHelper.put(skuId.toString(), "0");
19
                        }
20

21
                        //保存本地事务结果
22
                        bucket.set("fail");
23
                        return LocalTransactionState.ROLLBACK_MESSAGE;
24
                    }
25

26
                    bucket.set("success");
27
                    return LocalTransactionState.COMMIT_MESSAGE;
28
                } catch (Exception e) {
29
                    e.printStackTrace();
30
                    bucket.set("exception");
31
                    return LocalTransactionState.ROLLBACK_MESSAGE;
32
                }
33

34
            }
35

36
            @Override
37
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
38

39
                // 获取本地事务结果
40
               RBucket<String> bucket = redissonClient
41
                    .getBucket(RedisConst.PROMO_TRANSACTION_PREFIX + msg.getTransactionId());
42
                if (bucket == null) {
43
                    return LocalTransactionState.UNKNOW;
44
                }
45
                if ("success".equals(bucket.get())) {
46
                    return LocalTransactionState.COMMIT_MESSAGE;
47
                }
48
                return LocalTransactionState.ROLLBACK_MESSAGE;
49
            }
50
        });

展开收起

至于订单服务，只需要定义一个消费者来消费秒杀服务发送的事务消息即可：

1
@Slf4j
2
@Component
3
public class PromoOrderConsumer {
4

5
    @Value("${rocketmq.namesrv.addr}")
6
    String namesrvAddr;
7

8
    @Value("${rocketmq.consumer.group}")
9
    String consumerGroup;
10

11
    DefaultMQPushConsumer mqComsumer;
12

13
    @Autowired
14
    OrderService orderService;
15

16

17

18
    @PostConstruct
19
    public void init() throws MQClientException {
20
        // 初始化
21
        mqComsumer = new DefaultMQPushConsumer(consumerGroup + "-promorder");
22

23
        // 设置注册中心
24
        mqComsumer.setNamesrvAddr(namesrvAddr);
25

26
        // 订阅主题
27
        mqComsumer.subscribe(MqTopicConst.PROMO_ORDER_TOPIC, "*");
28

29
        // 设置消息监听器
30
        mqComsumer.setMessageListener(new MessageListenerConcurrently() {
31
            @Override
32
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
33
                MessageExt messageExt = list.get(0);
34
                OrderInfoParam orderInfoParam = JSON.parseObject(new String(messageExt.getBody()), OrderInfoParam.class);
35
                log.info("收到秒杀下单消息，topic:{}, messageId:{}", messageExt.getTopic(), messageExt.getMsgId());
36
                try {
37
                    // 保存秒杀订单
38
                    Long orderId = orderService.saveSeckillOrder(orderInfoParam);
39
                    log.info("秒杀下单 消息消费成功！orderId:{}" , orderId);
40
                } catch (Exception e) {
41
                    e.printStackTrace();
42
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
43
                }
44

45
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
46

47
            }
48
        });
49
        // 启动
50
        mqComsumer.start();
51
        log.info("订单超时取消 消息消费者启动成功! ");
52
    }
53
}

展开收起

秒杀下单的结果#

在使用了基于RocketMQ事务消息实现的分布式事务之后，当秒杀下单接口返回时，有可能订单服务正在接收消息，或者正在执行秒杀下单功能，此时秒杀下单还没有真正完成。所以在秒杀下单之后，我们会跳转到一个排队等待页面。

当订单服务真正下单成功的时候，就会向Redis中放入对应的标志位

1
 @Transactional
2
    @Override
3
    public Long saveSeckillOrder(OrderInfoParam orderInfoParam) {
4

5
        //... 保存订单
6

7
        // 向redis中添加标记
8
        Long skuId = orderInfoParam.getOrderDetailList().get(0).getSkuId();
9
        String userId = orderInfoParam.getUserId().toString();
10
        RMap<String, Long> map = redissonClient.getMap(RedisConst.PROMO_SECKILL_ORDERS);
11
        // 放入下单成功的标志位
12
        map.put(userId + ":" + skuId, orderInfo.getId());
13

14
        return orderInfo.getId();
15
    }

展开收起

同时，前端在排队等待页面中会有一个定时任务，向秒杀服务发送查询秒杀下单结果的请求，直到获取到本次秒杀下单的结果，然后会显示如下页面：

所以，在秒杀服务中我们还需要实现一个接口为前端返回秒杀下单的结果

1
    @GetMapping(value = "/seckill/auth/checkOrder/{skuId}")
2
    public Result checkOrder(@PathVariable("skuId") Long skuId, HttpServletRequest request) {
3
        //当前登录用户
4
        String userId = AuthContext.getUserId(request);
5
        boolean orderSuccess = promoService.checkOrder(skuId, userId);
6
        if (orderSuccess) {
7
            return Result.build(null, SeckillCodeEnum.SECKILL_ORDER_SUCCESS);
8
        }
9

10
        return Result.build(null, SeckillCodeEnum.SECKILL_RUN);
11
    }

1
@Override
2
    public boolean checkOrder(Long skuId, String userId) {
3

4
        //2. 判断Redis中是否已经存在用户的订单
5
        return redissonClient.getMap(RedisConst.PROMO_SECKILL_ORDERS).containsKey(userId + ":" + skuId);
6

7
    }

缓存预热-优化#

很显然秒杀商品数据的访问量是比较大的。如果不考虑缓存，那么每次都需要直接访问数据库，势必会给数据库带来比较大的压力，所以在此考虑使用缓存预热的方案提高对秒杀数据的访问效率。

缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据放入缓存。

因为缓存预热是在每次秒杀活动开始之前进行的，而我们的秒杀活动是有固定时间的，因此我们可以使用定时任务来实现缓存预热

1
@Component
2
@EnableScheduling
3
public class ScheduledTask {
4

5
  @Scheduled(cron = "0 0 1 * * ?")   // 每天凌晨一点执行
6
    public void importIntoRedisTask(){
7

8
        // 1. 从数据库查询今天的秒杀商品数据
9
        // where status = CHECKED_PASS AND stock_count > 0 AND DATE_FORMAT(start_time,'%Y-%m-%d') = ?
10

11
        // 2. 初始化
12
        for(...) {
13
        // 2.1 将秒杀商品数据放入Redis(hash)，其中每个filed对应skuId，value对应SseckillGoods对象
14
        // 2.2 在redis中初始化秒杀商品库存(hash)，其中每个filed对应skuId，value对应库存数量
15
        // 2.3 初始化库存状态位
16
        }
17

18

19
    }
20
}

展开收起

库存的扣减-优化#

在Redis中，为了使库存的扣减成为一个原子操作，所以我们提供一个工具类，在该工具类中使用lua脚本来实现库存的扣减

1
@Component
2
@Slf4j
3
public class RedisStockOper {
4

5
    @Autowired
6
    RedissonClient redissonClient;
7

8
    private final static String STOCK_LUA_NAME = "Redis扣减库存脚本";
9
    /*
10
        -- 调用Redis的get指令，查询活动库存，其中KEYS[1]为传入的参数1，即库存key
11
        local c_s = redis.call('get', KEYS[1])
12
        -- 判断活动库存是否充足，其中ARGV[1]为传入当前抢购数量
13
        if not c_s or tonumber(c_s) < tonumber(ARGV[1]) then
14
           return -1
15
        end
16
        -- 如果活动库存充足，则进行扣减操作。其中ARGV[1]为传入当前抢购数量
17
        redis.call('decrby',KEYS[1], ARGV[1])
18
    * */
19
    private final static String STOCK_LUA = "local c_s = redis.call('hget', KEYS[1], ARGV[1]) \n" +
20
            "if not c_s or tonumber(c_s) < tonumber(ARGV[2]) then \n" +
21
            "return -1 end \n" +
22
            "return redis.call('hincrby',KEYS[1], ARGV[1], -tonumber(ARGV[2]))";
23

24
    private String sha1;
25

26
    @PostConstruct
27
    public void loadScript(){
28
        // 缓存脚本
29
        sha1 = redissonClient.getScript().scriptLoad(STOCK_LUA);
30
        log.info("load script {}", sha1);
31
    }
32

33
    public Long decrRedisStock(Long skuId, Integer count) {
34
        // 执行脚本，扣减商品skuId对应的库存，扣减的值为count
35
        return redissonClient.getScript(StringCodec.INSTANCE).evalSha(RScript.Mode.READ_WRITE,
36
                sha1,
37
                RScript.ReturnType.INTEGER,
38
                List.of(RedisConst.PROMO_SECKILL_GOODS_STOCK), // 脚本不涉及键，传递空列表
39
                skuId.toString(), count.toString());
40
    }
41

42
}

展开收起

因此在TransactionManager中，扣减库存的代码也会有所变化：

1
 transactionMQProducer.setTransactionListener(new TransactionListener() {
2
      @Override
3
     public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
4
                Map<String, Number> paramsMap = (Map<String, Number>) arg;
5

6
                Number skuId = paramsMap.get("skuId");
7
                Number count = paramsMap.get("count");
8

9
         RBucket<String> bucket = redissonClient
10
             .getBucket(RedisConst.PROMO_TRANSACTION_PREFIX + msg.getTransactionId());
11

12
                try {
13
                    // 从Redis中扣减库存
14
                    Long remainStock = redisStockOper.decrRedisStock(skuId, count.intValue());
15

16
                    if (remainStock >= 0) {
17

18
                        if (remainStock == 0) {
19
                            LocalCacheHelper.put(skuId.toString(), PromoGoodsStock.STOCK_NOT_ENOUGH.getNum());
20
                        }
21

22
                        // 往Redis中添加标记，存入success
23
                        bucket.set("success");
24

25
                        // 库存扣减成功
26
                        // 返回本地事务执行成功
27
                        return LocalTransactionState.COMMIT_MESSAGE;
28
                    }else {
29

30
                        // 库存扣减失败
31
                        // 说明没库存了，设置本地内存中的库存状态位标记 为 “0”
32
                        // LocalCacheHelper.put(skuId.toString(), PromoGoodsStock.STOCK_NOT_ENOUGH.getNum());
33

34
                        // 往Redis中添加标记，存入success
35
                        bucket.set("fail");
36

37

38
                        // 返回本地事务执行失败
39
                        return LocalTransactionState.ROLLBACK_MESSAGE;
40
                    }
41
                } catch (Exception e) {
42
                    e.printStackTrace();
43
                    bucket.set("exception");
44
                    return LocalTransactionState.ROLLBACK_MESSAGE;
45
                }
46
            }
47
    }

展开收起

定时任务-清除缓存#

秒杀过程中我们写入了大量redis缓存，我们可以在秒杀结束或每天固定时间清楚缓存，释放缓存空间

当前项目中的秒杀活动，我们默认为每天早上8:00开始，晚上8:00结束，所以我们可以在每天晚上十点清空Redis缓存

需要清空哪些缓存呢？

清空商品缓存库存

清空缓存预热商品列表

清空用户下单商品集合标识

清空用户下单成功缓存

清空本地秒杀商品库存标志位

最后，还需要修改秒杀表对应的商品状态为已结束状态，修改数据库中的秒杀商品库存为秒杀结束之后的库存

1
 @Override
2
    public void clearRedisCache() {
3

4
        // 更新数据库中的库存
5
        updateStock();
6

7
        //修改数据库当天审核通过的的秒杀商品状态为秒杀结束
8
        updateStatus();
9

10
        // 删除redis中缓存预热的相关数据
11
        redissonClient.getKeys().deleteByPattern("promo:*");
12

13
        // 清空本地缓存
14
        LocalCacheHelper.removeAll();
15

16
    }

展开收起

面试技术要点

Sun, 14 Jun 2026 00:00:00 GMT

..面试技术要点#

多线程#

线程池#

在使用线程池(ThreadPoolExecutor)的时候，都是通过其execute方法执行异步任务的，当提交异步任务的时候，有可能会让异步任务直接在线程中执行，也有可能将异步任务放入任务队列中排队等待。

1
 public void execute(Runnable command) {
2
        if (command == null)
3
            throw new NullPointerException();
4
        /*
5
         * Proceed in 3 steps:
6
         *
7
         * 1. If fewer than corePoolSize threads are running, try to
8
         * start a new thread with the given command as its first
9
         * task.  The call to addWorker atomically checks runState and
10
         * workerCount, and so prevents false alarms that would add
11
         * threads when it shouldn't, by returning false.
12
         *
13
         * 2. If a task can be successfully queued, then we still need
14
         * to double-check whether we should have added a thread
15
         * (because existing ones died since last checking) or that
16
         * the pool shut down since entry into this method. So we
17
         * recheck state and if necessary roll back the enqueuing if
18
         * stopped, or start a new thread if there are none.
19
         *
20
         * 3. If we cannot queue task, then we try to add a new
21
         * thread.  If it fails, we know we are shut down or saturated
22
         * and so reject the task.
23
         */
24
        int c = ctl.get();
25
        if (workerCountOf(c) < corePoolSize) {
26
            // 当前线程数小于核心线程数
27
            if (addWorker(command, true))
28
                return;
29
            c = ctl.get();
30
        }
31
        if (isRunning(c) && workQueue.offer(command)) {
32
            // 如果当前线程池在正常运行，且添加异步任务到队列成功
33
            int recheck = ctl.get();
34
            if (! isRunning(recheck) && remove(command))
35
                reject(command);
36
            else if (workerCountOf(recheck) == 0)
37
                addWorker(null, false);
38
        }
39
        else if (!addWorker(command, false)) // 否则尝试给线程池添加非核心线程
40
            reject(command);
41
    }
42

43

44
# 把一个任务交给线程池来执行，有以下四种情况：
45
    1.如果当前线程池中的线程数 < 这个线程池设定的核心线程数；那么创建一个新的核心线程来执行这个异步任务
46
    2. 如果当前线程池中的线程数 >= 这个线程池设定的核心线程数；那么就把这个新的任务添加到任务队列中
47
    3. 如果添加到任务队列失败了, 那么对于线程池来说，会创建一个新的非核心线程来执行这个异步任务
48
    4. 如果创建非核心线程也失败了（比如说线程池中的线程数量已经达到最大线程数）,此时会调用线程池的拒绝策略拒绝这个异步任务

展开收起

线程池的中的线程是如何实现复用的呢？

其实很简单，JAVA语言中虽然任何一个线程只能被启动一次，但是当异步任务的线程执行完了异步任务之后，它会去异步任务队列中获取新的异步任务来执行，此时就会有两种情况：

获取到了队列中的异步任务，就继续执行这个异步任务
异步任务队列中，没有异步任务，此时因为使用异步任务队列实际为阻塞队列，因此当队列为空时，获取任务的线程会阻塞等待，直到因为有新的任务加入队列而获取任务成功

ThreadPoolExecutor3 个最重要的参数：

corePoolSize ：核心线程数，线程数定义了最小可以同时运行的线程数量。
maximumPoolSize ：线程池中允许存在的工作线程的最大数量
workQueue：当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数:

keepAliveTime：线程池中的线程数量大于corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过 keepAliveTime才会被回收销毁；
unit ：keepAliveTime 参数的时间单位。
threadFactory：为线程池提供创建新线程的线程工厂
handler ：线程池任务队列超过 maxinumPoolSize 之后的拒绝策略

线程池中的线程数量#

对于一个线程池中的线程数，到底设置为多少合适呢？

首先，理论上有一些经验经验公式，设N为核数的话：

如果是CPU密集型应用线程数设置为N+1，如果是IO密集型应用线程数设置为2N+1。
还有如下公式，可以来计算线程池中线程的数量，Ncpu表示核数，Ucpu表示cpu的利用率

线程数=Ncpu∗Ucpu∗(1+等待时间/计算时间)线程数 = Ncpu * Ucpu * (1 + 等待时间 / 计算时间)线程数=Ncpu∗Ucpu∗(1+等待时间/计算时间)

但是，公式通常不建议直接套公式，还是需要通过实际测试的结果来确定。我们可以在一开始的时候根据公式计算出一个大致的值，然后再根据实际的业务要求，不断的进行压力测试，不断调整，最终得到一个相对合适的值

异步任务的编排#

有三个线程T1,T2,T3,如何保证顺序执行？

join方法：等待该线程终止

谁等待? 调用join方法的线程阻塞

等待谁? 线程对象.join()，等待join方法所对应的那个线程执行完毕

在多线程中有多种方法让线程按特定顺序执行，我们可以用线程类的join()方法在一个线程中等待另一个线程，另外一个线程完成，该线程继续执行。实际上先启动三个线程中哪一个都行，因为在每个线程的run方法中用join方法限定了三个线程的执行顺序。

1
public class JoinTest2 {
2

3
    // 1.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行
4

5

6
    public static void main(String[] args) {
7

8
        final Thread t1 = new Thread(new Runnable() {
9

10
            @Override
11
            public void run() {
12
                System.out.println("t1");
13
            }
14
        });
15
        final Thread t2 = new Thread(new Runnable() {
16

17
            @Override
18
            public void run() {
19
                try {
20
                    //引用t1线程，等待t1线程执行完
21
                    t1.join();
22

23
                } catch (InterruptedException e) {
24
                    e.printStackTrace();
25
                }
26
                System.out.println("t2");
27
            }
28
        });
29
        Thread t3 = new Thread(new Runnable() {
30

31
            @Override
32
            public void run() {
33
                try {
34
                    //引用t2线程，等待t2线程执行完
35
                    t2.join();
36
                } catch (InterruptedException e) {
37
                    e.printStackTrace();
38
                }
39
                System.out.println("t3");
40
            }
41
        });
42
        t3.start();
43
        t2.start();
44
        t1.start();
45
    }
46
}

展开收起

通过上述例子可以看到，自己实现还是有点麻烦的，我们自己得根据线程间的依赖关系，给每个Thread对象传递它所依赖的Thread对象，而且还得自己调用join方法。

但是，如果我们使用CompletableFuture那就简单多了，只需要使用其thenRun，或者thenAccept或者thenApply或其对应的xxxAsync方法即可实现异步任务的顺序编排了。

同时，我们还需要知道，对于CompletebleFuture而言，其xxxAsync方法如果没有指定线程池的话，都是在其默认的ForkJoin线程池的线程中执行的。

CAS#

即 compare and swap（比较与交换），是一种有名的无锁算法。基于CAS算法，可以实现无锁编程，即不使用锁的情况下实现多线程同步的原子操作，所以也叫非阻塞同步（Non-blocking Synchronization）

CAS 算法涉及到三个操作数 :

需要读写的内存值 V
进行比较的值 A
拟写入的新值 B

当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V 的值，否则不会执行任何操作（其中比较和替换是一个原子操作），所以为了保证使用CAS操作一定更新成功，CAS通常还会和循环(自旋)结合在一起。

java.util.concurrent.atomic 包下的类大多是使用 CAS 操作来实现的，比如AtomicInteger。

悲观锁和乐观锁#

乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种锁各有优缺点，不能不以场景而定说一种人好于另外一种人。

悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。我们之前学习过的比如synchronized，以及Lock锁等都属于悲观锁。

乐观锁：总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和 CAS 算法实现。

两种锁的使用场景：

乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行循环重试
而在写操作比较多的情况下，就比较适合使用悲观锁了。

乐观锁的缺点：

乐观锁只能保证一个共享变量的原子操作。如果多一个或几个变量，乐观锁将变得力不从心，但互斥锁能轻易解决, 不管对象数量多少及对象颗粒度大小。
长时间自旋(循环重试)可能导致开销大。假如CAS长时间不成功而一直自旋，会给CPU带来很大的开销。
ABA 问题。 CAS的核心思想是通过比对内存值与预期值是否一样而判断内存值是否被改过，但这个判断逻辑不严谨，假如内存值原来是A，后来被一条线程改为B，最后又被改成了A，则CAS认此内存值并没有发生改变，但实际上是有被其他线程改过的，这种情况对依赖过程值的情景的运算结果影响很大。解决的思路是引入版本号，每次变量更新都把版本号加 1。

分布式锁#

在商品详情页的缓存优化中，我们给大家介绍过，常见的分布式锁的实现方式有基于MySQL，Redis以及Zookeeper实现的分布式锁。因为我们在项目中使用的是基于Redisson实现的分布式锁。所以我们重点来看看它的实现原理。

Redisson实现的分布式锁，在Redis中使用hash数据结构表示锁(lockObj表示锁对应的key)：

当加锁时，如果lockObj这个key对应hash数据结构中存在一个field-value，且field值表示的不是当前线程则说明，该锁已被其他线程加锁，加锁失败
否则，如果加锁时lockObj这个key对应的hash结构的值不存在，或者field-value存在但是当前加锁线程和field表示的线程相同(同一个加锁线程)，则加锁成功
当释放锁时，会将hash数据结构的值删除掉。

同时，我们还要注意，当我们调用lock()无参方法加锁时，如果加锁成功，会给锁设置默认的过期时间30s。那是不是意味着我们通过lock()方法加的锁只有30s的有效时间呢？并不是。

这是因为，在Redisson中每当调用lock()方法加锁，就会同时启动一个定时任务（watch dog)，该定时任务每隔10s钟，会重新设置锁的过期时间为30s, 直到锁被释放。

定时任务#

在我们的任何一个JAVA进程中，我们都可以通过使用Spring定时调度的功能从而实现定时任务。但是一旦我们在服务的实现代码中通过Spring定时调度的功能实现定时任务，那就意味着该服务的每个服务实例只要运行起来，也都会执行这个定时任务。

但是有时候完全没有必要，比如说秒杀服务的缓存预热功能，如果有多个秒杀服务实例，我们只需要让其中一个服务实例执行一次缓存预热任务即可，那么如何实现这个功能呢？可以通过使用分布式任务调度的方式来实现，比如我们以xxl-job为例来说明：

对于xxl-job这个分布式调度框架而言有两个核心概念：

调度中心: 调度中心负责任务的注册、调度及管理等功能(独立运行)
执行器: 执行器是任务执行的工作节点。它负责接收调度中心的执行命令，并运行相应的任务逻辑(Java进程)

xxl-job会由调度中心根据定时任务的触发条件，在满足条件时触发(调用)执行器中定义的对应的定时任务，具体过程如下：

在JAVA进程中定义执行器，以及多个任务处理器(JobHandler)，每个任务处理器就可以当做是被调度的任务
同时，我们可以在调度中心，定义调度任务，指定其触发条件，指定要调度的执行器以及执行器中要触发执行的任务处理器
在JAVA进程启动的时候，如果定义了执行器，则会向调度中心注册进程所在的主机IP以及监听端口，这样一来调度中心就知道了执行器的地址
紧接着，我们只需要在调度中心启动调度任务，调度任务就会根据触发条件自动调用指定执行器中定义的指定任务处理器，从而完成定时调度
如果多个进程中定义了同一个执行器，即有执行器的集群，则在调度的时候，每一次执行，调度中心都会选择某个执行器实例中的任务处理器执行，即存在负载均衡

集合#

List,Set, Map接口#

Java 容器分为 Collection 和 Map 两大类，Collection集合的子接口有Set、 List、Queue三种子接口。我们比较常用的是Set、List，而Map接口不是 collection的子接口。

Collection集合主要有List和Set两大接口

List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。
Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、 LinkedHashSet 以及 TreeSet。

ArrayList和LinkedList#

相同点：

都是List子实现, 描述的数据结构都是线性表, 都有序, 允许存储重复元素, 允许存储null
都线程不安全的集合类实现

不同点：

但是ArrayList底层是个数组(默认长度10, 扩容机制1.5倍), LinkedList底层是个双向链表
并且LinkedList不仅仅是List的子实现还是Deque接口的子实现, 也就是说LinkedList除了作为线性表以外还可以作为队列/双端队列/栈

HashMap#

JDK1.7 的HashMap的实现主要如下图所示：

![](/assets/firefly-docs/microservice/microservice-29-interview/hashmap jdk1.7.png)

JDK 1.8中的hashMap其实现主要如下：

JDK1.7对于Hash冲突的解决方法主要是通过链地址法，JDK1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）且数组长度>=64时，将链表转化为红黑树，以减少搜索时间。

在HashMap中通过如下方式判断Key是否相同，所以就可以解释我们在使用HashMap的时候，如果key的类型为自定义类型，为什么Key对应的类必须实现hashCode和equals方法了

1
p.hash == hash &&  ((k = p.key) == key || (key != null && key.equals(k)))

并发安全的集合#

常见的并发安全的集合主要分成两类：

诸如Vector，Stack，HashTable, 以及SynchronizedMap, SynchronizedList 这样的集合，我们统称为同步集合，因为它们都是通过阻塞式的方式(要加锁)来保证多线程的数据并发安全
诸如ConcurrentHashMap，ConcurrentLindQueue，CopyOnWriteArrayList等集合类，我们统称为并发集合，因为它们主要是通过非阻塞的方式来保证多线程的数据并发安全(主要采用CAS等方式实现)

并发集合中的CopyOnWriteArrayList采用了Copy-On-Write的思想。通俗的理解就是当我们向一个List中添加或修改元素的时候，不直接向当前集合底层的数组中写入数据，而是先将当前List底层数组中的数据Copy一份得到一个新的数组，然后在新的数组中添加或修改元素，然后在讲当前List底层使用的数组替换为这个新的数组

CopyOnWriteArrayList中的修改数据的方法都是加了锁的，但是读方法却是没有加锁的。因为每次修改都需要复制已有数据，因此CopyOnWriteArrayList适用于读多写少的并发场景

MySQL#

SQL语句执行顺序#

(5) SELECT column_name, … (1) FROM table_name, … (2) [WHERE …] (3) [GROUP BY …] (4) [HAVING …] (6) [ORDER BY …]; (7)[Limit …]

索引相关#

针对InnoDB存储引擎，什么是聚簇索引，什么是非聚簇索引，它们有何区别？

InnoDB中根据主键列创建的索引就是聚簇索引，根据非主键列创建的索引就叫非聚簇索引或者二级索引。它们的区别如下：

聚簇索引，索引即数据，而对于非聚簇索引而言，索引非数据
聚簇索引根据主键值有序，非聚簇索引根据非主键的其他索引列有序
在非聚簇索引上所做的查询，有可能需要回表

这里需要注意的是，并不是，如果一张表没有定义主键，那么MySQL或做如下工作创建聚簇索引：

会为当前表中添加了NOT NULL 和UNIQUE域约束的列创建聚簇索引
如果既没有定义主键，也没有定义了NOT NULL和UNIQUE的列，那么MySQL会自动生成一个名为row_id的隐藏列，MySQL保证该列的值在一张表中不会重复。
然后根据row_id这一列的值创建聚簇索引

什么是回表？为什么要尽量规避回表操作？

回表指的是当我们在二级索引中根据查询条件查询到数据后，从查询结果中取出每条数据对应的主键值，然后再去聚簇索引中根据主键值查询完整行数据的过程，我们称之为回表。

之所以要尽量规避回表操作，首先是因为针对查询结果中的每条记录要在聚簇索引中多做一次查询，其次，也是更重要的是，因为对于非聚簇索引中查询的数据，可能并非根据主键值有序，因此回表可能会包含大量的随机IO可能会涉及频繁的磁头移动，大大降低IO效率

InnoDB存储引擎和MyISAM存储引擎有什么区别？

InnoDB存储引擎的聚簇索引索引即数据，MyISAM的索引和数据是分开存放的
InnoDB 支持事务处理，而MyISAM不支持事务，因此MyISAM更适合于只读数据或者在数据完整性要求不高的场合使用。
InnoDB支持行级锁，但是MyISAM只支持表级锁
InnoDB提供了崩溃恢复机制，但是MyISAM缺少崩溃恢复机制

设计索引时的原则有哪些？

只为用于搜索、排序或分组的列创建索引，也就是说只为，出现在 WHERE 子句中的列，连接子句中的连接列 (连接的时候也可以使用到索引)，或者出现在 ORDER BY 或 GROUP BY 子句中的列创建索引。
在上面的基础上，我们还可以根据查询频率来确定，给查询频率高的列创建索引
选择基数大的列作为索引
尽可能使用联合索引，避免回表
避免冗余索引
避免索引列的长度过长(字符串类型)

事务#

什么是事务？事务的ACID特性？事务的隔离级别？事务的传播行为？

数据库事务(transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行，要么全部不执行，是一个不可分割的工作单位。

数据库事务具有ACID特性：

原子性(Atomicity)：事务作为一个整体被执行，包含在其中的数据库操作要么全部执行，要么全部不执行
一致性(Consistency)：事务应该保证数据从一个一致性状态转化到下一个一致性状态
隔离性(Isolation): 多个事务并发执行时，一个事务不应该影响其他事务的执行。
持久性(Durability)：一个事务一旦提交，其对数据库的修改就应该永久保存在数据库中

针对事务的隔离性，还有不同的隔离级别：

读未提交（Read Uncommitted）：最低的隔离级别，在这种事务隔离级别下，允许一个事务读取另一个事务尚未提交的数据。这可能导致脏读、不可重复读和幻读的问题。
读已提交（Read Committed）：也可以翻译成提交读，在一个事务修改数据过程中，如果事务还没提交，其他事务不能读该数据。这可以避免脏读问题，但仍可能出现不可重复读和幻读的问题。
可重复读（Repeatable Read）：在一个事务中，多次读取同一数据时，得到的结果保持一致。即使其他事务对数据进行了修改并提交，当前事务读取的数据也不会发生变化。可重复读可以避免脏读和不可重复读问题，但仍可能出现幻读的问题。
串行化（Serializable）：最高的隔离级别，确保事务之间完全隔离，一个事务执行时，其他事务无法对其进行并发操作。串行化可以避免脏读、不可重复读和幻读的问题，但会降低并发性能。

事务的传播行为(与MySQL无关，纯粹是Spring定义的)：

Propagation_required:如果当前没有事务就创建一个事务，如果存在事务，则加入该事务。
Propatation_supports:支持当前事务，如果当前存在事务，则加入该事务，如果不存在该事务，则以非事务执行
Propagation_requires_new:无论当前存不存在事务，创建一个新事务
Propagation_mandatory:如果当前存在事务，则加入该事务；如果不存在事务，则抛出异常
Propagation_not_supported:以非事务方式运行，如果当前存在事务，则把当前事务挂起
Propagation_never：以非事务方式运行，如果当前存在事务，则抛出异常
Propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

优化#

随着系统越来越复杂，数据库中的表会变的越来越多，表中的数据也会越来越多，此时Mysql数据库可能出现性能瓶颈，具体表现在某些SQL语句的执行时间长，或者等待时间长。因此我们就需要对数据库系统做优化了。

导致MySQL出现性能瓶的原因有很多，比如：

查询语句写的不好，各种连接，各种子查询用不上索引或者没有建立索引
建立的索引失效，建立了索引,在真正执行时,没有用上建立的索引
表设计不合理，导致太多连接查询
表中的数据量太大
服务器调优及配置参数，如果设置的不合理，比如并发连接数过少等
…

所以，我们的优化手段可以从以下角度入手：

索引优化: 添加适当索引(index）(重点)
SQL优化: 写出高质量的sql，避免索引失效 (重点)
设计优化: 表的设计合理化(符合3NF，有时候要进行反三范式操作)
配置优化: 对mysql配置优化 [比如，配置最大并发数my.ini, 调整缓存大小 ]
架构优化：分库分表、读写分离、(分布式数据库)
硬件优化: 服务器的硬件优化

作为我们来说，在面试的时候可以重点多说一些的其实主要是，索引优化和SQL优化。

关于索引优化，我们说一说设计索引的原则即可，关于SQL优化常见的优化手段如下：

不建议查询时使用select *
针对联合索引，查询条件尽量满足最左前缀匹配原则
查询条件中，建议索引列单独出现(不出现在方法调用，以及运算表达式中)
like模糊匹配时，不要写 like ‘%a’
排序中的多列顺序与联合索引列一致(如果有的话)
排序不建议ASC，DESC混用
建议保持主键列递增
在满足业务需要的前提下，尽量创建联合索引

有些时候，即使创建了索引，查询条件中也是用到了索引列(索引列单独出现)，因为查询优化器的存在可能有些情况下，查询优化器也不会选择根据索引查询，比如如果在二级索引中查询出许多需要回表的数据，因为会存在大量的随机IO，此时查询优化器宁愿走全表扫描，所以，在查询时到底有没有走索引，我们还可以通过explain来分析查询语句的执行过程！然后具体问题具体分析。

我们如何能够方便的发现一些执行比较慢的SQL语句呢？通过开启MySQL的慢查询日志即可。MySQL的慢查询日志是默认关闭的，但是一旦开启，那么查询时间超过指定阈值(默认10秒)的查询，会出现在慢查询日志中。

11.897911Z

1
# User@Host: myuser[myuser] @ localhost [127.0.0.1]
2
# Query_time: 11.293654  Lock_time: 0.000094 Rows_sent: 45  Rows_examined: 17888
3
# Rows_affected: 0  Bytes_sent: 894
4
SET timestamp=1683565331;
5
SELECT * FROM my_table WHERE column_date > '2024-05-01';

时间戳 (# Time): 记录查询发生的具体时间。
用户和主机 (# User@Host): 执行查询的用户和来源主机。
查询时间 (# Query_time): 查询执行所需的总时间（秒）。
锁定时间 (# Lock_time): 查询在等待锁的时间。
发送的行数 (# Rows_sent): 查询结果返回的行数。
检查的行数 (# Rows_examined): 查询在执行过程中检查的行数。
影响的行数 (# Rows_affected): 查询导致更改的数据行数。
发送的字节数 (# Bytes_sent): 发送给客户端的字节数。
时间戳设置 (SET timestamp): 查询执行时的UNIX时间戳。
查询语句: 实际的SQL查询。

Redis#

单工作线程#

redis 为什么这么快？

完全基于内存，绝大部分请求是纯粹的内存操作，非常快速
使用了一些简单高效的数据结构，如hash表，跳表
高效的IO，使用了异步非阻塞的事件驱动模型
使用单工作线程，避免的不必要的上下文切换，以及加锁释放锁的操作

Rehash(渐进式Hash)#

在Redis中，随着元素数量的增多，可能会导致用来存储键值对的hash表的扩容，这通常会导致hash表(数组)的容量变为之前的2倍。一旦扩容之后，元素在扩容之后的新的hash表中的位置可能也会变化，这个元素位置的变化过程就是通过Rehash实现的。

在Rehash的过程中，因为hash表中的元素可能会比较多，因此想要一次性在扩容之后的hash表中将所有元素放置到正确的位置是一件比较耗时的事情，而且在移动过程中为了保证数据访问的正确性，可能还需要阻止对hash表中元素的访问。所以Redis并未这样做，还是选择了分多次来完成这个元素移动过程。

在Redis中有两张hash表，我们称其为hash表1，hash表2。并且会维护一个rehashIndex(初值为-1)，记录当前Rehash到的数组下标位置。一开始，当我们开始插入数据时，只使用哈希表1，而哈希表2没有分配空间

随着插入的数据越来越多，需要对hash表扩容，于是就会为哈希表2分配了hash表1两倍的存储空间，并开始Rehash过程：

在Rehash过程中，不会将hash表1中的数据全部放到hash表2中去，而是在后续有增删改查操作的时候，会从hash表(数组)中的第一个元素开始，每个操作完成对hash数组下标为rehashIndex + 1位置的所有元素的移动，并且移动完成后rehashIndex的值增1。重复这个过程，直到将hash表1中的所有元素移动完。

最后，将hash表2变为新的hash表1，将原来的hash表1变成hash表1并将其值置为null(rehashIndex的值也置为-1)，直到下一次rehash发生，重复以上过程。

持久化#

Redis的两种持久化方式：RDB和AOF我们在讲解Redis的时候就已经讲过，这里不在赘述。但是有一个结论，大家一定要有印象，就是当RDB和AOF同时开启的时候，在恢复数据时Redis优先采用AOF日志来恢复数据，因为，AOF更新频率更高，数据更加完整,所以如果AOF和RDB同时存在的时候,Redis会优先使用从AOF文件来还原数据库状态。

其实，从Redis4.0开始实现了一种新的持久化方式即所谓的混合持久化。混合持久化旨在结合 AOF 和 RDB 的优点，以提供更快的数据恢复速度和更高效的数据写入性能。

混合持久化工作原理：

持久化前的操作：
- 在没有触发重写操作之前，Redis 将继续按照正常的 AOF 机制记录每个写命令到 AOF 文件中。此时，数据的持久化完全依赖于 AOF 日志。(重写)
触发 AOF 重写时的操作：
- 当触发 AOF 文件的重写时（比如达到文件大小的阈值或根据配置的定时任务），Redis 不仅仅重写 AOF 文件，而是首先创建一个 RDB 快照，然后再将这个 RDB 文件包含在新的 AOF 文件中。
- 在 RDB 快照之后，Redis 会继续记录之后发生的所有写命令。这样，新的 AOF 文件实际上是一个 RDB 文件，后面跟着从 RDB 快照点之后开始的所有写命令。
重启时的恢复：
- 当 Redis 重启时，它会使用这个混合的 AOF 文件进行数据恢复。首先加载 RDB 文件中的数据快照，然后应用其后的 AOF 命令，这样可以确保数据的完整性和一致性。

优点：

快速恢复：使用 RDB 快照可以快速加载大量数据，而后续的 AOF 命令则确保了数据的最新状态。
效率：在 AOF 重写过程中生成 RDB 快照，减少了重写过程中的 IO 操作，同时也缩短了重写的时间。

缓存双写一致性#

双写一致性主要指在一个数据同时存在于缓存（如Redis）和持久化存储（如数据库）的情况下，任何一方的数据更新都必须确保另一方数据的同步更新，以保持双方数据的一致状态。

如果以Redis作为缓存使用，读取数据没有什么争议，主要问题时如何在更新数据是，如何保证MySQL和Redis中数据的一致性？其解决方案主要有下面几种。

设置过期时间#

对于实时性要求不高的数据，可以采用设置过期时间的方式，对存入缓存的数据设置过期时间，所有的写操作以数据库为准，对缓存操作只是尽最大努力即可。也就是说如果数据库写成功，缓存更新失败，那么只要到达过期时间，则后面的读请求自然会从数据库中读取新值然后回填缓存

应用程序直接更新#

如果我们的应用程序使用通过更新MySQL和Redis的方式来使其数据同步，有如下策略：

先更新缓存，再更新数据库
先更新数据库，再更新缓存
先删除缓存，再更新数据库
先更新数据库，再删除缓存

先来看第一种情况，先更新缓存，在更新数据库。这种方式通常是不行的。因为缓存更新成功了，数据库没更新（更新失败），导致缓存存的是最新值，数据库存的是旧值。如果缓存失效了，就会拿到数据库中的旧值。

再来看第二种情况，先更新数据库，在更新缓存。这种方式也是大家普遍反对的。若同时有请求A和请求B进行更新操作，会出现如下情况：

线程A更新了数据库更新的旧数据
线程B更新了数据库最后更新新数据
线程B更新了缓存
线程A更新了缓存

再来看第三种情况, 先删除缓存，在更新数据库. 该方案同样会存在多线程的线程安全问题。若同时有一个请求A进行更新操作，另一个请求B进行查询操作，会出现如下情况：

请求A进行写操作，删除缓存
请求B查询发现缓存不存在
请求B去数据库查询得到旧值
请求B将旧值写入缓存
请求A将新值写入数据库

image-20240612010951121

针对第三种情况，还有一种改进策略：延迟双删策略，其伪代码如下：

1
public void write(String key,Object data){
2
        // 第一次删除缓存
3
    redis.delKey(key);
4
        // 更新数据库
5
      db.updateData(data);
6
        // 休眠一段时间
7
      Thread.sleep(1000);
8
        // 第二次删除缓存
9
      redis.delKey(key);
10
}

第二次删除的意义在于，防止更新数据库的过程中，有一个读请求读取数据库的旧数据并将其放入到Redis中的情况。那么这里的休眠时间是如何确定的呢？我们通常会在读数据业务逻辑的耗时基础上，加几百ms即可。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。大大降低数据不一致的概率。

再来看第四种情况，先更新数据库，再删除缓存。这种情况即所谓的 Cache Aside Pattern，知名社交网站facebook也在论文《Scaling Memcache at Facebook》中提出，他们用的也是先更新数据库，再删缓存的策略。这种情况下，不会出现数据并发安全问题吗？当然不是，一个请求A做查询操作，一个请求B做更新操作，那么会有如下情形产生：

缓存刚好失效
请求A查询数据库，得一个旧值
请求B将新值写入数据库
请求B删除缓存
请求A将查到的旧值写入缓存

然而，发生这种情况的概率又有多少呢？

发生上述情况有一个先天性条件，就是步骤3的写数据库操作比步骤2的读数据库操作耗时更短，才更有可能使得步骤4先于步骤5。

可是，大家想想，数据库的读操作的速度远快于写操作的因此步骤3耗时比步骤2更短，这一情形出现的概率比较低。

1
为什么写操作比读操作要更慢呢？
2

3
    1. 写操作涉及了数据的移动，而读不会
4
    2. 写操作对比数据库而言，需要加锁，而读不需要
5
    3. 写操作对于MySQL而言需要记录日志，比如binLog日志，而读操作不需要

在删除缓存的时候，我们还可以采用异步更新的方式。

在大厂中这种方式用的是比较多的。

加分布式锁#

还可以通过加分布式读写锁的方式，在一个线程更新数据时，其他线程排队等待，但是因为加读写锁，可以让读-读请求并发执行。

主从架构#

可以通过配置实现，在Redis中为一个Redis-Server(master节点)配置一个或多个slave节点，此时有了主从架构。

写数据的请求，只能由Master节点处理写数据请求
Master节点会将写入的数据复制到其对应的一个或多个Slave节点
Slave节点可以接收读数据的请求

哨兵模式#

为了让主从架构的Redis服务器具有更高的可用性，因此在Redis中引入了哨兵模式。Redis 哨兵模式（Sentinel）是 Redis 的高可用性解决方案之一。其主要目的是监控 Redis 主从服务器的运行状态，并在主服务器出现故障时自动进行故障转移，选则一个Slave节点作为新的Master节点，从而使得主从架构的Redis-Server继续正常运行。

哨兵模式主要包括以下几个组成部分：

主节点（Master）：负责处理所有客户端请求的 Redis 服务器节点。
从节点（Slaves）：复制主节点的数据，并在主节点故障时可以提升为新的主节点。
哨兵（Sentinels）：一组独立运行的进程，用于监控主节点和从节点的健康状态，并在主节点故障时执行自动故障转移。

哨兵的工作过程可以分为以下几个步骤：

监控：每个哨兵节点定期向所有的主节点和从节点发送心跳包（PING），以检查它们的健康状态。
通知：哨兵在发现节点异常时，会通知系统管理员和其他哨兵节点，报告发现的问题。
自动故障转移：当哨兵通过足够数量的哨兵节点确认主节点无法访问时，它将开始故障转移过程。
配置更新：在故障转移过程中，哨兵会选举出一个从节点来成为新的主节点，并通知其余的从节点更新配置，将新的主节点作为自己的主节点

集群模式#

redis集群是一个由多个主从节点群组成的分布式服务器群，它具有复制、高可用和分片特性。

redis集群支持分片，每个Master节点都只存储了一部分Redis中的数据。Redis 集群将所有的数据划分为 16384 个哈希槽（hash slot）, 每个键根据其键名被分配到某一个槽中。
当客户端尝试访问一个键时，它会使用相同的哈希函数计算出键应该在哪个槽，并直接连接到负责该槽的节点
Redis集群不需要sentinel哨兵∙也能完成节点移除和故障转移的功能，每个节点包括主节点和从节点都会向其他节点发送心跳数据包，用以维护集群中所有节点的状态信息和健康状况。当超过半数的人认为某Master节点失效，那么就会选择该Master节点的一个Slave节点成为新的Master节点

这种集群模式没有中心节点，可水平扩展，据官方文档称可以线性扩展到上万个节点(官方推荐不超过1000个节点)。redis集群的性能和高可用性均优于之前版本的哨兵模式，且集群配置非常简单

1
# 补充说明: hash槽的分配问题 →  一致性hash的问题

Spring#

IOC和AOP#

概念及其理解，参考课件

AOP的实现#

AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

AspectJ是编译时的增强，AOP框架会在编译阶段生成AOP代理类，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。
Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

Spring事务失效的情况#

几种事务常见的失效场景如下：

数据库不支持事务。比如使用MySQL时存储引擎为MyISAM
事务没有被Spring管理

1
public class XxxImpl implements XxxService{
2
  @Transactional
3
  public void update(参数){
4
    //update
5
  }
6
}
7

8
XxxService service = new XxxImpl();
9
service.update();

方法不是 public 的。@Transactional注解只能作用于public 的方法上，否则事多不会生效
自身调用问题。在同一个类中的一个事务方法内部调用另一个事务方法，内部方法的事务设置不会生效。

1
@Service
2
public class OrderServiceImpl implements OrderService {
3

4
  public void update(Order order) {
5
    // 原始对象
6
    this.updateOrder(order);
7
  }
8
}
9

10

11
  @Transactional
12
  public void updateOrder(0rder order) {
13
    // update order
14
  }
15
}

展开收起

异常没有被抛出

1
@Service
2
public class OrderServiceImpl implements OrderService {
3
  @Transactional
4
  public void update(Order order) {
5
    try{
6
      // update order
7
    }catch{
8

9
    }
10
  }
11
}

事务传播行为中设置了不支持事务

1
@Service
2
public class OrderServiceImpl implements OrderService {
3
  @Transactional
4
  public void update(Order order) {
5
    updateOrder(order);
6
  }
7

8
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
9
  public void updateOrder(Order order) {
10
    //update order
11
  }
12
}

异常类型不匹配。因为 Spring 默认回滚的是 RuntimeException 异常，和程序抛出的 Exception 异常不匹配，所以事务也是不生效的。

1
@Service
2
public class OrderServiceImpl implements OrderService {
3
  @Transactional(rollbackFor=Exception.class)
4
  public void update(Order order) {
5
    try{
6
      // update order
7
    }catch{
8
      throw new Exception("更新失败");
9
    }
10
  }
11
}

Mybatis#

获取数据库的自增主键#

使用 useGeneratedKeys 和 keyProperty。这通常用于数据库支持自动增长的主键字段，如 MySQL、PostgreSQL、SQL Server 等。

1
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
2
  INSERT INTO users (name, email) VALUES (#{name}, #{email})
3
</insert>

使用 selectKey，如果数据库使用的是如序列等特定的方式生成主键，或者需要在插入前获取主键值，你可以使用 “ 元素来实现。这在 Oracle 等数据库中特别有用，因为它们使用序列生成主键。

1
<insert id="insertUser">
2
  <selectKey keyProperty="id" resultType="int" order="AFTER">
3
    查询主键值的sql语句
4
  </selectKey>
5
  INSERT INTO users (id, name, email) VALUES (#{id}, #{name}, #{email})
6
</insert>

#{}和${}的区别#

处理方式不同：#{} 是预处理语句（PreparedStatement）的参数占位符。MyBatis 会使用预处理语句来传递参数，这种方式可以有效防止 SQL 注入攻击。${} 是简单的字符串替换。在 SQL 语句被执行之前，${} 中的内容会被直接替换成变量值。
安全性不同: 使用${}更容易受到SQL注入攻击
类型处理不同：如果是字符串类型的参数，则#{}会自动为替换后的值加”, 而${}则不会
如果需要动态指定排序，分组，表名，以及select部分的列名，那么只能使用${}，因为#{}只针对where查询条件的参数进行替换

一对多，一对一映射#

在xml中定义映射关系，使用association代表映射一个实体类， property映射的属性名，javaType该属性的实体类类型，fetchType是否延迟加载，column用于执行select方法所传递的参数,select需要执行的mapper方法的全限定名称

在xml中定义一对多的映射关系，使用collection标签标识映射一个集合，ofType代表集合中实体类的类型，其他属性和上面对一的情况一致

RocketMQ#

消息类型#

说一下消息队列消息的类型有哪些？

普通消息：普通消息也叫做无序消息，简单来说就是没有顺序的消息。因为不需要保证消息的顺序，所以消息可以大规模的并发的发生和消费，吞吐量很高，适合大部分场景
批量消息：Apache RocketMQ可以将一些消息聚成一批以后进行发送，可以增加吞吐率，并减少API和网络调用次数。
有序消息：有序消息就是按照一定的先后顺序的消息类型。

有序消息还可以进一步分为：全局有序消息（1个MessageQueue）、局部有序消息（多个MessageQueue）
延时消息：简单来说就是当producer将消息发送到broker之后，会延时一定时间后才投递给consumer进行消费。
事务消息：本地事务和事务消息的投递保持一致性

如何实现顺序消息#

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。

在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。

所以如果要实现先发送的消息一定先被消费的效果，即顺序消息的效果，必须满足如下条件：

消息被发送时保持顺序(使用一个Producer发送消息，且发送方法不在多线程中调用)
消息被存储时保持和发送的顺序⼀致(顺序消息总是存储在同一个MessgeQueue中)
消息被消费时保持和存储的顺序⼀致(使用顺序消费的消息监听器消费)

1
/*
2
*  要保证消息的有序性，即需要把有先后顺序的消息，发送到同一个MessageQueue中去，如何实现呢？
3
*  a. 在发送消息的时候，就需要给send方法，传递一个MessageQueueSelector，选择消息发送的具体是Topic中的那个MessageQueue
4
*  b. MessageQueueSelector中有一个方法select方法，该方法中有一个参数List<MessageQueue> mqs，该参数代表某个Topic对应的所有的MessageQueue
5
*  c. 在select方法中，实现消息的路由，即决定消息发送到哪个MessageQueue中，实例中就是一种方式，利用orderId对MessageQueue数量取余，这样一来
6
      同一个id的消息，就会被发送到同一个MessageQueue中去了
7
*/
8
SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
9
    @Override
10
    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
11
        Long id = (Long) arg;  //根据订单id选择发送queue
12
        long index = id % mqs.size();
13
        return mqs.get((int) index);
14
    }
15
}, orderList.get(i).getOrderId());//订单id

展开收起

1
/*
2
*  这里我们只需要保证，同一个MessageQueue中的消息，是前一个消息消费完了，才消费后一个消息，此时我们只需要设置MessageListenerOrderly
3
*  这种类型的监听器，在监听器内实现消费逻辑即可
4
*/
5
consumer.registerMessageListener(new MessageListenerOrderly() {
6
    @Override
7
    public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
8
    // 消费逻辑
9
    return ConsumeOrderlyStatus.SUCCESS;
10
    }
11
});

MQ消费者如果消费不成功#

MQ如何消费不成功，RocketMQ会把该消息丢入重试队列当中去
MQ重试队列默认有重试机制，会反复去投递直到投递成功或者是在16次（默认的，可更改）之后假如还没有消费失败的话会把该消息投递到MQ死信队列里面
我们可以通过后台管理系统从死信队列里面把没消费成功的消息取出来，然后等问题解决之后，将消息发送给RocketMQ让消费者正常消费

项目#

购物车与数据库#

我们项目中的购物车数据数据是存放在Redis中的，但是实际开发的时候，也有可能还会在数据库中存储用户的购物车数据，因此会存在缓存双写一致性问题。我们利用上面关于缓存双写一致性的分析去回答即可。

Elasticsearch与数据库#

使用ES来搜索的前提是ES中得有数据，ES中的数据肯定是来自于数据库中的，数据的同步方式：

使用普通消息实现个别商品的异步上下架(增量同步)
使用批量消息，在搜索服务中实现批量商品的上下架
使用定时任务，批量同步（全量同步）
或者，使用canal实现数据库和ES数据的同步

秒杀服务缓存预热#

关于秒杀服务的缓存预热，我们使用的是Spring的定时调度功能，但是这里有一个问题就是，如果启动了多个秒杀服务实例，那么在多个秒杀服务实例中，都会运行这个定时任务去完成定时任务的功能，但是我们知道缓存预热的功能只需要执行一次即可，所以我们有两种解决方案:

还是使用Spring定时调度功能，在Redis中增加一个标志位用来表示缓存预热功能是否已经完成，同时每次执行缓存预热之前使用Double Check方式加分布式锁
使用分布式定时调度，比如xxl-job

秒杀商品库存同步#

因为存在缓存预热，我们在秒杀活动开始之前就已经将商品信息，库存等存储到Redis中了，所以秒杀活动开始之后我们的库存扣减都是在Redis中完成的，在秒杀活动结束后，在利用Redis中的库存更新数据库中的库存、

这里面试官有可能会问，那如果秒杀过程中Redis宕机了，不是库存数据全都没有了吗？关于这个问题，我们可以基于以下两点来回答：

我们的秒杀下单是基于分布式事务实现的，因此可以认为，秒杀库存扣减成功，那么就会生成对应的订单
所以，Redis挂了也没关系，因为我们可以通过通过订单数据，重新计算出秒杀商品的库存
可能会存在个别极端情况是，库存扣减了，还没返回给秒杀服务扣减结果，结果Redis挂了，此时本地事务的执行会抛出异常，RocketMQ也会认为本地事务执行的结果为UNKONW，最终事务消息不会被订单服务消费，不会生成订单
但是，注意到在用户点击提交订单之后，我们给用户展示的是排队中，并未告之用户秒杀成功的结果这个结果对于用户来说应该也是可以接受的。

仓储管理系统参考手册

Sun, 14 Jun 2026 00:00:00 GMT

业务简介#

image-20230323180404324

库存管理系统（Warehouse Management System）主要是和订单、物流等服务交互，逻辑也一般十分复杂，也需要有专门的后台管理系统来管理各个仓库中的商品库存，在企业中一般是单独开发，常常对于我们开发商城其他业务的人来说，是一个类似于黑盒的存在。在我们CSMALL商城中，也不需要关心它的实现细节，只需要调用接口即可。

WMS主要逻辑如下：

用户点击提交订单，订单服务需要调用库存服务接口，查看订单中的商品是否有库存

注意：在本商城中，提交订单的时候，不扣减库存，等用户付款完成才锁定库存，等待发货之后，用户收货了才会最终扣减库存
在用户订单支付完成之后，需要调用库存管理系统的接口扣减库存（锁定库存）
在库存管理系统扣减库存的过程中，需要判断这笔订单中的商品是否都存在在同一个仓库中(内部逻辑)
- 如果在同一个仓库中，那么直接扣减对应商品的库存即可
- 如果不在同一个仓库中，那么就意味着这笔订单需要从不同的仓库发货，物流信息等也会不一样，那么就需要对订单进行拆分，通常我们业内叫做拆单。如何拆单呢？本商场的逻辑是按照仓库ID进行拆单，在这里需要调用订单服务的接口，把一个订单按照仓库ID拆分成多个订单

库存管理系统搭建#

直接把整个工程作为模块引入IDEA即可，只需要更改一下父工程的pom.xml文件。

image-20230323230732724

image-20230323230617126

数据库简介#

image-20230323232041217

仓库信息表：主要是存储各个仓储信息，比如北京大兴仓、武汉江夏仓、深圳龙岗仓。表示这个仓库位置在哪里。

库存表：表示各个商品库存多少，关联仓库ID，进而表示这个商品在哪个仓库

stock：库存数
stock_locked：当前已经被锁定的库存数

库存工作单：关联订单，记录订单扣减库存的信息

库存工作单明细：关联库存工作单，记录订单扣减库存的商品详情。

接口说明#

查询库存#

1
// 参数说明：
2
// skuId: 商品Id
3
// num: 商品数量
4
@GetMapping("/api/ware/inner/hasStock/{skuId}/{num}")
5
public Result hasStock(@PathVariable Long skuId, @PathVariable Integer num){
6
    Boolean ret = wareService.hasStock(skuId,num);
7
    if (ret) return Result.ok();
8
    return Result.fail();
9
}

扣减库存#

1
// 参数说明：
2
// orderId: 订单Id
3
@PostMapping("//inner/decreaseStock/{orderId}")
4
public Result decreaseStock(@PathVariable(value = "orderId") Long orderId){
5
    wareService.decreaseStock(orderId);
6
    return Result.ok();
7
}

拆单接口#

拆单是由库存服务调用订单服务，有订单服务拆单，所以需要由订单服务来提供，接口示例：

1
// 参数说明
2
// orderId: 订单Id
3
// List<WareSkuDTO>:仓库和商品ids映射，可以理解为在这次订单中，这些商品分别属于哪个仓库
4

5
// 返回值说明：
6
// List<WareOrderTaskDTO>, 表示订单被拆分之后的那些子订单对应的库存工作单列表，每一个子订单对应一个库存工作单
7

8
@PostMapping("/api/order/inner/orderSplit/{orderId}")
9
List<WareOrderTaskDTO> orderSplit(@PathVariable(value = "orderId") String orderId, @RequestBody List<WareSkuDTO> wareSkuDTOList){
10

11
    return null;
12

13
}

1
public class WareSkuDTO {
2

3
    // 仓库id
4
    String wareId;
5

6
    // 商品id列表
7
    List<String> skuIds;
8

9
}

LeetCode 1. 两数之和

Thu, 11 Jun 2026 00:00:00 GMT

LeetCode 1. 两数之和#

标签#

平台：LeetCode
难度：简单
数据结构：数组、哈希表
算法：枚举
解题模式：无

一、题目概述#

给定一个整数数组 nums 和目标值 target，需要在数组中找到两个不同位置的数，使它们的和等于 target，并返回这两个数的下标。当前实现如果没有找到结果，会返回空数组。

二、解题思路#

当前代码使用 HashMap 记录已经遍历过的数字和它的下标。遍历到 nums[i] 时，先计算当前数字需要的配对值 target - nums[i]，再去哈希表中查找这个配对值是否已经出现。

因为哈希表中只保存当前位置之前的元素，所以不会重复使用同一个下标。找到配对值后立即返回两个下标；如果遍历结束仍未找到，就返回空数组。

三、执行过程#

创建 hashMap，用于保存“数字 → 下标”。
从左到右遍历数组。
对当前数字 nums[i] 计算 need = target - nums[i]。
如果 need 已经在 hashMap 中，返回 need 的下标和当前下标。
否则把当前数字和下标放入 hashMap。
遍历结束仍没有结果时，返回 new int[0]。

例如 nums = [2, 7, 11, 15]，target = 9：遍历到 7 时，need = 2，哈希表中已经保存了 2 → 0，因此返回 [0, 1]。

四、代码实现#

1
public class LeetCode0001TwoSum {
2

3
    public static int[] twoSum(int[] nums, int target) {
4
        Map<Integer, Integer> hashMap = new HashMap<>();
5

6
        for (int i = 0; i < nums.length; i++) {
7
            int need = target - nums[i];
8

9
            if (hashMap.containsKey(need)) {
10
                return new int[]{hashMap.get(need), i};
11
            }
12

13
            hashMap.put(nums[i], i);
14
        }
15

16
        return new int[0];
17
    }
18
}

展开收起

五、关键代码说明#

hashMap：保存已经遍历过的数字及其下标。
need：当前数字需要匹配的另一个数字。
containsKey(need)：判断之前是否出现过配对数字。
hashMap.put(nums[i], i) 放在查找之后，可以避免同一个元素被重复使用。
return new int[0] 是当前仓库实现定义的无解返回方式。

六、复杂度分析#

时间复杂度：O(n)，数组只遍历一次，哈希表查询平均为 O(1)。
空间复杂度：O(n)，最坏情况下哈希表会保存数组中的多数元素。

七、注意事项#

当前实现没有对 nums == null 做保护，传入 null 会触发空指针异常。
无解时返回空数组，这是当前实现行为，和部分平台“必有一解”的前提不同。
先查找再放入哈希表，才能避免同一个下标被使用两次。

八、面试知识点：HashMap#

1. 为什么两数之和会想到 HashMap？#

两数之和的核心问题是：遍历到 nums[i] 时，如何快速判断前面是否出现过 target - nums[i]。

如果使用两层循环，外层固定一个数，内层继续找另一个数，时间复杂度是 O(n^2)。当前实现使用 HashMap 保存已经遍历过的数字，把“查找某个值是否出现过”优化为平均 O(1)，整体时间复杂度就降为 O(n)。

这是一种典型的“用空间换时间”：额外使用一个哈希表，换来更快的查找速度。

2. 本题里的 HashMap 存什么？#

当前代码中：

key：已经遍历过的数组元素值；
value：这个元素在数组中的下标。

也就是：

1
Map<Integer, Integer> hashMap = new HashMap<>();

例如 nums = [2, 7, 11, 15]，target = 9：

遍历到 2 时，哈希表为空，先存入 2 -> 0；
遍历到 7 时，需要查找 9 - 7 = 2；
哈希表中已经存在 key 为 2 的记录，于是返回 [0, 1]。

3. 为什么先查找再插入？#

当前代码先执行：

1
if (hashMap.containsKey(need)) {
2
    return new int[]{hashMap.get(need), i};
3
}

再执行：

1
hashMap.put(nums[i], i);

这样可以避免同一个元素被使用两次。

例如 nums = [3]，target = 6。如果先把 3 放入哈希表，再查找 need = 3，就可能错误地把同一个下标当作两个数使用。先查找历史元素，再插入当前元素，可以保证找到的配对值一定来自当前下标之前的位置。

4. HashMap 的底层结构是什么？#

Java 8 之后，HashMap 的核心结构可以理解为：

1
数组 + 链表 + 红黑树

数组中的每个位置通常称为一个桶。插入一个 key-value 时，HashMap 会先根据 key 的哈希值计算它应该落在哪个桶里。

如果桶为空，直接放入节点；如果桶中已经有节点，说明发生了哈希冲突，会继续在这个桶对应的链表或红黑树中查找、插入或更新。

简化理解：

1
table[index]
2
    ├── Node
3
    ├── Node -> Node -> Node
4
    └── TreeNode 红黑树结构

5. 什么是哈希冲突？HashMap 如何解决？#

哈希冲突指的是：不同的 key 经过哈希计算后，落到了同一个数组桶中。

例如两个不同的 key 计算出的桶下标都是 5，它们就会争用同一个位置。

HashMap 主要使用链地址法解决冲突：同一个桶里的多个节点用链表连接起来。Java 8 之后，如果同一个桶里的节点过多，并且数组容量足够大，链表会转换成红黑树，以降低极端情况下的查找成本。

所以 HashMap 处理冲突的演进可以概括为：

1
少量冲突：数组桶 + 链表
2
严重冲突：数组桶 + 红黑树

6. 为什么 HashMap 的数组长度通常是 2 的幂？#

HashMap 需要根据 hash 值计算数组下标。数组长度是 2 的幂时，可以用位运算：

1
(n - 1) & hash

来代替取模运算：

1
hash % n

位运算通常更高效。

更重要的是，当 n 是 2 的幂时，n - 1 的二进制低位全是 1，可以更均匀地保留 hash 的低位信息，帮助元素分布到不同桶中。

扩容时也更方便。因为容量翻倍后，元素的新位置只会有两种情况：

1
仍在原下标
2
移动到 原下标 + oldCapacity

这使得扩容迁移不需要重新做完整取模计算。

7. 默认容量、负载因子和扩容阈值#

HashMap 的几个高频默认值：

默认初始容量：16
默认负载因子：0.75
扩容阈值：capacity * loadFactor

例如默认情况下：

1
capacity = 16
2
loadFactor = 0.75
3
threshold = 16 * 0.75 = 12

当元素数量超过 12 时，会触发扩容，通常扩容为原来的 2 倍。

负载因子表示哈希表允许被填满到什么程度。负载因子越高，空间利用率越高，但冲突可能更多，查找成本可能上升；负载因子越低，冲突更少，但会占用更多空间。默认的 0.75 是时间和空间之间的折中。

8. 链表什么时候转红黑树？#

Java 8 之后，HashMap 中单个桶的链表在满足条件时会转成红黑树：

桶内节点数达到 8；
并且数组容量至少为 64。

如果链表长度达到 8，但数组容量还小于 64，HashMap 会优先扩容，而不是立即树化。因为容量太小时，冲突可能只是数组太小导致的，扩容后节点可能会分散到不同桶中。

当红黑树中的节点数量减少到一定程度时，可能会退回链表。常见阈值是 6。这样可以避免节点数量在 8 附近反复变化时频繁树化和退化。

9. hashCode 和 equals 有什么关系？#

HashMap 查找 key 时，不是只看 hashCode，也不是只看 equals，而是两者都会用到。

基本规则：

如果两个对象通过 equals 判断相等，那么它们的 hashCode 必须相同；
如果两个对象的 hashCode 相同，它们不一定 equals 相等；
如果重写了 equals，通常必须同时重写 hashCode。

原因是 HashMap 会先用 hashCode 定位桶，再在桶内用 equals 判断是否是真正相同的 key。

本题使用的是 Integer 作为 key，Integer 已经正确实现了 hashCode 和 equals，所以不需要自己处理这些细节。

10. HashMap 的时间复杂度#

在哈希分布比较均匀的情况下：

put 平均时间复杂度：O(1)；
get 平均时间复杂度：O(1)；
containsKey 平均时间复杂度：O(1)。

如果大量 key 发生哈希冲突，并且都落到同一个桶里，链表结构下最坏可能退化到 O(n)。

Java 8 之后引入红黑树，冲突严重且满足树化条件时，桶内查找可以从链表的 O(n) 降到红黑树的 O(log n)。

所以本题复杂度分析里说时间复杂度是 O(n)，前提是 HashMap 的查找和插入按平均 O(1) 计算。

11. HashMap 是线程安全的吗？#

HashMap 不是线程安全的。

如果多个线程同时访问同一个 HashMap，并且至少有一个线程在做结构性修改，比如新增或删除 key，就需要额外同步。

面试中常见延伸对比：

Hashtable：线程安全，但方法级别同步，粒度较粗，性能较低；
Collections.synchronizedMap：把普通 Map 包装成同步 Map；
ConcurrentHashMap：并发场景更常用，设计上更适合高并发读写。

本题是单线程算法题，不涉及并发修改，所以直接使用 HashMap 即可。

12. 回到本题，面试时怎么回答？#

可以这样组织回答：

这道题的关键是快速判断补数是否已经出现过。我用 HashMap<Integer, Integer> 保存已经遍历过的数字和下标，其中 key 是数字，value 是下标。遍历当前数字 nums[i] 时，先计算 need = target - nums[i]，再用 containsKey 判断 need 是否在哈希表中。如果存在，就返回历史下标和当前下标；如果不存在，再把当前数字放入哈希表。这样可以避免同一个元素被重复使用。
相比双重循环的 O(n^2)，HashMap 的查找和插入平均是 O(1)，所以整体时间复杂度是 O(n)，空间复杂度是 O(n)。从 Java 实现看，HashMap 底层是数组、链表和红黑树，通过 hash 定位桶，通过链表或红黑树解决冲突。默认容量是 16，负载因子是 0.75，链表在节点数达到 8 且数组容量至少 64 时会转成红黑树。

LeetCode 2. 两数相加

Thu, 11 Jun 2026 00:00:00 GMT

LeetCode 2. 两数相加#

标签#

平台：LeetCode
难度：中等
数据结构：链表
算法：模拟、迭代
解题模式：虚拟头节点、链表合并

一、题目概述#

两个非负整数用两个链表表示，链表中的每个节点保存一位数字，并且数字按逆序存放。需要返回这两个数相加后的结果链表，结果同样按逆序存放。

二、解题思路#

当前实现按位模拟加法。使用两个指针 p 和 q 分别遍历两个链表，再用 carry 保存进位。每一轮取两个链表当前节点的值，如果某个链表已经结束，就按 0 处理。

为了简化结果链表的构建，代码使用 dummyHead 作为虚拟头节点，curr 始终指向结果链表的尾部。循环结束后如果还存在进位，需要额外追加一个节点。

三、执行过程#

创建虚拟头节点 dummyHead 和尾指针 curr。
使用 p、q 分别指向 l1、l2。
当任一链表未遍历完时，取当前位数字，不存在则取 0。
计算 sum = x + y + carry。
新节点值为 sum % 10，新进位为 sum / 10。
移动结果链表尾指针和输入链表指针。
循环结束后，如果 carry > 0，追加进位节点。
返回 dummyHead.next。

例如 2 -> 4 -> 3 和 5 -> 6 -> 4 分别表示 342 和 465，逐位相加后返回 7 -> 0 -> 8。

四、代码实现#

1
public class LeetCode0002AddTwoNumbers {
2

3
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
4
        ListNode dummyHead = new ListNode(0);
5
        ListNode curr = dummyHead;
6

7
        ListNode p = l1;
8
        ListNode q = l2;
9
        int carry = 0;
10

11
        while (p != null || q != null) {
12
            int x = (p != null) ? p.val : 0;
13
            int y = (q != null) ? q.val : 0;
14

15
            int sum = x + y + carry;
16
            carry = sum / 10;
17

18
            curr.next = new ListNode(sum % 10);
19
            curr = curr.next;
20

21
            if (p != null) {
22
                p = p.next;
23
            }
24
            if (q != null) {
25
                q = q.next;
26
            }
27
        }
28

29
        if (carry > 0) {
30
            curr.next = new ListNode(carry);
31
        }
32

33
        return dummyHead.next;
34
    }
35
}

展开收起

五、关键代码说明#

dummyHead：虚拟头节点，用来统一处理结果链表的头节点创建。
curr：结果链表的尾指针，每生成一个新节点后向后移动。
p、q：分别遍历两个输入链表。
carry：保存上一位产生的进位。
x、y：当前位的两个数字，链表结束时按 0 处理。
循环条件是 p != null || q != null，可以处理两个链表长度不同的情况。

六、复杂度分析#

时间复杂度：O(max(m, n))，其中 m 和 n 分别是两个链表长度。
空间复杂度：O(max(m, n))，需要创建结果链表；除返回链表外，只使用常量额外变量。

七、注意事项#

最后一位相加后仍可能产生进位，需要在循环结束后单独处理。
两个链表长度不一致时，短链表缺失的位置要按 0 参与计算。
当前实现假设输入链表节点中的值是合法的一位数字。

八、面试知识点：链表与虚拟头节点#

1. 为什么这题用链表模拟加法？#

题目本身把数字按逆序存放在链表中，每个节点只保存一位数字，所以最自然的做法就是从链表头开始逐位相加。

因为链表头正好对应数字的最低位，当前实现不需要先反转链表，也不需要从尾部回退。只要同时遍历两个链表，并维护一个进位 carry，就能模拟小学竖式加法。

2. 为什么不能先把链表转成整数？#

面试中经常会追问这个点。不能简单把链表转成 int 或 long，原因是题目没有保证数字长度一定能放进基本整数类型。

例如链表可能有几十位甚至上百位，转换成整数会溢出。链表逐位相加不依赖数字整体大小，只和链表长度有关，因此更稳妥。

3. 链表和数组有什么区别？#

数组支持按下标随机访问，访问 nums[i] 是 O(1)；链表不支持高效随机访问，如果要访问第 i 个节点，需要从头走过去，时间复杂度是 O(i)。

链表的优势是插入和删除节点时不需要搬移大量元素，只要修改引用关系即可。本题中结果链表是一边计算一边追加节点，使用链表很自然。

4. 什么是虚拟头节点？#

虚拟头节点也叫 dummy node。它不保存真正结果，只是放在结果链表最前面，方便统一处理链表头节点。

没有虚拟头节点时，创建第一个结果节点需要特殊判断：

1
如果结果链表为空，当前节点就是头节点；
2
否则，把当前节点接到尾部。

有了 dummyHead 后，每次都只需要执行：

1
curr.next = new ListNode(sum % 10);
2
curr = curr.next;

最后返回 dummyHead.next 即可。

5. curr 指针的作用是什么？#

curr 始终指向结果链表的尾节点。每计算出一位，就把新节点挂到 curr.next，然后让 curr 后移。

这个写法的关键是：dummyHead 保持不动，用于最后返回结果；curr 负责移动，用于构建链表。如果直接移动 dummyHead，最后就找不到结果链表的头了。

6. carry 进位为什么必须保留？#

链表每个节点只保存一位数字，因此当前位相加可能产生进位。

当前实现中：

1
int sum = x + y + carry;
2
carry = sum / 10;
3
curr.next = new ListNode(sum % 10);

sum % 10 是当前位要保存的数字；
sum / 10 是传给下一位的进位。

循环结束后还要检查 carry > 0。例如 5 + 5 = 10，两个链表都遍历完后，仍然要追加一个值为 1 的节点。

7. 两个链表长度不同怎么办？#

当前实现用：

1
int x = (p != null) ? p.val : 0;
2
int y = (q != null) ? q.val : 0;

当某个链表已经遍历结束时，把它当前位当作 0。这样可以统一处理长度相同和长度不同的情况，不需要把短链表补零。

循环条件使用：

1
while (p != null || q != null)

只要还有一个链表没走完，就继续计算。

8. 迭代和递归怎么选？#

这题可以递归写，但当前实现选择迭代更直接。

迭代写法的优点是：

不会产生额外递归调用栈；
对长链表更稳定；
指针移动过程更容易和竖式加法对应。

递归写法通常代码更短，但需要把进位传给下一层，并且链表很长时可能有栈溢出风险。

9. 链表题常见面试追问#

为什么链表题常用虚拟头节点？
什么时候返回 dummyHead.next？
为什么尾指针移动不能丢掉头节点？
如何处理空链表？
如何处理两个链表长度不同？
如何处理最后一个进位？
能不能原地修改其中一个链表来节省空间？

本题当前实现创建了新链表，没有修改输入链表。这种写法更清晰，也避免影响调用方继续使用原链表。

10. 回到本题，面试时怎么回答？#

可以这样组织回答：

这道题本质是链表上的竖式加法。因为链表是逆序存储的，头节点就是最低位，所以我可以从两个链表头开始同时遍历。每一位计算 x + y + carry，当前节点保存 sum % 10，进位保存为 sum / 10。如果某个链表提前结束，就把它当前位当作 0。
构建结果链表时我使用虚拟头节点 dummyHead，这样可以避免单独处理第一个节点。curr 指针负责不断追加结果节点，最后返回 dummyHead.next。如果循环结束后还有进位，需要再追加一个节点。整体时间复杂度是 O(max(m, n))，空间复杂度是 O(max(m, n))。

LeetCode 3. 无重复字符的最长子串

Thu, 11 Jun 2026 00:00:00 GMT

LeetCode 3. 无重复字符的最长子串#

标签#

平台：LeetCode
难度：中等
数据结构：字符串、集合、哈希表
算法：滑动窗口、双指针
解题模式：可变窗口、同向双指针

一、题目概述#

给定一个字符串，求其中不包含重复字符的最长连续子串长度。当前仓库的主方法使用集合维护滑动窗口；源码中还保留了一个基于哈希表记录最近下标的内部类实现。

二、解题思路#

主方法使用可变滑动窗口。右指针 right 逐个扩展窗口，window 集合保存当前窗口中的字符。如果当前字符已经存在于窗口中，说明窗口出现重复，需要不断移动左指针 left，并从集合中移除左侧字符，直到窗口中不再包含当前字符。

每次把当前字符加入窗口后，用 right - left + 1 更新最大长度。

三、执行过程#

创建 HashSet<Character> 作为当前窗口。
初始化 left = 0 和 maxLength = 0。
right 从左到右遍历字符串。
如果 currentChar 已在窗口中，持续移除 s.charAt(left) 并右移 left。
将 currentChar 加入窗口。
用当前窗口长度更新最大值。
遍历结束后返回 maxLength。

例如 s = "abcabcbb"：窗口依次扩展到 "abc" 时最大长度为 3；再次遇到 a 后左边界右移，继续维护无重复窗口。

四、代码实现#

1
public class LeetCode0003LengthOfLongestSubstring {
2

3
    public int lengthOfLongestSubstring(String s) {
4
        HashSet<Character> window = new HashSet<>();
5
        int maxLength = 0;
6
        int left = 0;
7

8
        for (int right = 0; right < s.length(); right++) {
9
            char currentChar = s.charAt(right);
10

11
            while (window.contains(currentChar)) {
12
                window.remove(s.charAt(left));
13
                left++;
14
            }
15

16
            window.add(currentChar);
17
            maxLength = Math.max(maxLength, right - left + 1);
18
        }
19

20
        return maxLength;
21
    }
22
}

展开收起

源码中还保留了一个内部类 LongestSubstringWithoutRepeatingCharacters，它使用 Map<Character, Integer> 记录字符最近一次出现位置，并通过 Math.max(left, lastIndex + 1) 防止左边界回退。

五、关键代码说明#

window：保存当前滑动窗口内的字符，判断是否重复。
left：窗口左边界，只会向右移动。
right：窗口右边界，负责逐个扫描字符串。
while (window.contains(currentChar))：当窗口出现重复字符时收缩窗口。
maxLength：记录扫描过程中出现过的最大无重复窗口长度。

六、复杂度分析#

时间复杂度：O(n)，每个字符最多被右指针加入一次、被左指针移除一次。
空间复杂度：O(k)，其中 k 是窗口内不同字符数量，最坏情况下为 O(n)。

七、注意事项#

当前主方法没有处理 s == null，测试中也明确传入 null 会抛出 NullPointerException。
收缩窗口时必须使用 while，因为左侧可能需要连续移除多个字符。
内部类的哈希表版本虽然能处理 null 和空字符串，但当前测试调用的是外层主方法。

八、面试知识点：滑动窗口与 HashSet#

1. 为什么这题适合滑动窗口？#

题目要求的是“连续子串”，而不是子序列。连续区间问题经常可以考虑滑动窗口。

本题窗口要维护的性质是：窗口内不能有重复字符。右指针负责扩大窗口，左指针负责在出现重复时收缩窗口。整个过程始终维护一个无重复字符的连续区间。

2. 什么是可变滑动窗口？#

滑动窗口一般分为固定窗口和可变窗口。

固定窗口：窗口长度固定，例如每次看长度为 k 的子数组；
可变窗口：窗口长度会根据条件变化，例如本题遇到重复字符时收缩窗口。

本题属于可变窗口，因为窗口大小不是固定的，而是由“是否包含重复字符”这个条件决定。

3. HashSet 在本题中存什么？#

当前实现使用：

1
HashSet<Character> window = new HashSet<>();

window 保存当前窗口中的所有字符，用于快速判断 currentChar 是否已经出现。

如果 window.contains(currentChar) 为 true，说明当前窗口加入这个字符后会重复，需要移动左边界并删除左侧字符，直到窗口中不再包含 currentChar。

4. 为什么出现重复时要用 while？#

出现重复字符时，左边界可能需要连续移动多次。

例如 s = "abba"：

窗口先扩展到 "ab"；
再遇到第二个 b，需要移除 a，窗口仍然包含 b；
还要继续移除第一个 b，才能加入当前 b。

所以这里必须使用 while，不能只用 if。

5. 为什么左右指针都只向右移动？#

滑动窗口的效率来自这一点：每个字符最多被右指针加入一次，最多被左指针移除一次。

虽然代码里有嵌套的 while，但整体不是 O(n^2)。因为左指针不会回退，所有移除操作加起来最多也是 n 次，所以总时间复杂度是 O(n)。

6. HashSet 和 HashMap 有什么关系？#

面试中常会从 HashSet 追问到 HashMap。

可以这样理解：HashSet 只关心元素是否存在，不关心映射值；HashMap 保存 key-value 映射。Java 中 HashSet 的底层通常借助 HashMap 实现，把元素作为 key，value 使用一个固定占位对象。

所以本题如果只需要判断字符是否在窗口中，使用 HashSet 就够了；如果还想快速跳过重复字符上一次出现的位置，可以使用 HashMap<Character, Integer>。

7. HashSet 版本和 HashMap 版本有什么区别？#

当前主方法是 HashSet 版本，重复时通过 while 一个个移除左侧字符。

源码内部类中还有一个 HashMap 版本，记录每个字符最近一次出现位置。遇到重复字符时，可以直接把 left 移动到上次出现位置的后一位：

1
left = Math.max(left, lastIndexMap.get(currentChar) + 1);

这个 Math.max 很关键，用来防止 left 回退。例如 abba 中最后一个 a 的上次位置在窗口外，不能把左边界重新移回去。

8. char 能表示所有字符吗？#

Java 的 char 是 UTF-16 代码单元，不一定能完整表示所有 Unicode 字符。某些特殊字符可能需要两个 char 组成。

LeetCode 这类题通常默认输入是常规字符集，因此用 charAt 和 Character 足够。如果面试官追问 Unicode 完整处理，可以说明需要按 code point 遍历，而不是简单按 char 遍历。

9. 滑动窗口题的通用思路是什么？#

可以按这个模板思考：

明确窗口表示什么；
明确窗口需要满足什么条件；
右指针扩展窗口；
条件不满足时，左指针收缩窗口；
在合适时机更新答案。

本题中，窗口表示当前无重复字符子串；条件是窗口内不含重复字符；答案是窗口长度最大值。

10. 回到本题，面试时怎么回答？#

可以这样组织回答：

这道题要求最长的无重复连续子串，所以我使用滑动窗口。窗口用 HashSet 保存当前区间内的字符，右指针不断向右扩展。如果当前字符已经在集合中，就说明窗口出现重复，需要移动左指针，并从集合中移除左侧字符，直到窗口内不再包含当前字符。然后加入当前字符并更新最大长度。
虽然代码里有 while 收缩窗口，但每个字符最多被加入一次、移除一次，所以总时间复杂度是 O(n)。空间复杂度取决于窗口内不同字符数量，最坏是 O(n)。如果想进一步优化左指针移动，可以用 HashMap 记录字符最近出现位置。

LeetCode 4. 寻找两个正序数组的中位数

Thu, 11 Jun 2026 00:00:00 GMT

LeetCode 4. 寻找两个正序数组的中位数#

标签#

平台：LeetCode
难度：困难
数据结构：数组
算法：二分查找、双指针、模拟
解题模式：左右指针、哨兵节点

一、题目概述#

给定两个正序数组，求它们合并后的中位数。当前源码提供了两种实现：findMedianSortedArrays 使用二分切割，满足更优复杂度；mergeSortedArrays 先合并数组，再计算中位数，便于理解。

二、解题思路#

二分切割法始终在较短数组上二分。目标是找到一条切割线，使两个数组切割后左半部分元素数量等于中位数左侧需要的数量，并且左半部分所有元素都小于等于右半部分所有元素。

为避免切割线位于数组边界时越界，代码使用 Integer.MIN_VALUE 和 Integer.MAX_VALUE 作为边界哨兵。找到合法切割后，如果总长度为奇数，中位数是左半部分最大值；如果总长度为偶数，中位数是左半最大值和右半最小值的平均值。

三、执行过程#

校验两个数组不能为 null，且不能同时为空。
如果 nums1 比 nums2 长，交换参数，保证在短数组上二分。
计算左半部分需要的元素数量 leftPartSize。
在短数组切割位置 [0, shortLength] 上二分。
根据短数组切割位置推导长数组切割位置。
取四个边界值：短左最大、短右最小、长左最大、长右最小。
如果满足合法切割条件，直接计算中位数。
否则根据边界大小调整二分区间。

合并数组法则使用两个指针按顺序合并两个正序数组，再根据总长度奇偶返回中位数。

四、代码实现#

1
public class LeetCode0004MedianOfTwoSortedArrays {
2

3
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
4
        if (nums1 == null || nums2 == null) {
5
            throw new IllegalArgumentException("输入数组不能为 null");
6
        }
7
        if (nums1.length == 0 && nums2.length == 0) {
8
            throw new IllegalArgumentException("两个数组不能同时为空");
9
        }
10

11
        if (nums1.length > nums2.length) {
12
            return findMedianSortedArrays(nums2, nums1);
13
        }
14

15
        int[] shortArray = nums1;
16
        int[] longArray = nums2;
17
        int shortLength = shortArray.length;
18
        int longLength = longArray.length;
19
        int totalLength = shortLength + longLength;
20
        int leftPartSize = (totalLength + 1) / 2;
21

22
        int left = 0;
23
        int right = shortLength;
24

25
        while (left <= right) {
26
            int shortCut = left + (right - left) / 2;
27
            int longCut = leftPartSize - shortCut;
28

29
            int shortLeftMax =
30
                    shortCut == 0 ? Integer.MIN_VALUE : shortArray[shortCut - 1];
31
            int shortRightMin =
32
                    shortCut == shortLength ? Integer.MAX_VALUE : shortArray[shortCut];
33
            int longLeftMax =
34
                    longCut == 0 ? Integer.MIN_VALUE : longArray[longCut - 1];
35
            int longRightMin =
36
                    longCut == longLength ? Integer.MAX_VALUE : longArray[longCut];
37

38
            if (shortLeftMax <= longRightMin && longLeftMax <= shortRightMin) {
39
                int leftMax = Math.max(shortLeftMax, longLeftMax);
40
                if ((totalLength & 1) == 1) {
41
                    return leftMax;
42
                }
43

44
                int rightMin = Math.min(shortRightMin, longRightMin);
45
                return ((double) leftMax + (double) rightMin) / 2.0;
46
            }
47

48
            if (shortLeftMax > longRightMin) {
49
                right = shortCut - 1;
50
            } else {
51
                left = shortCut + 1;
52
            }
53
        }
54

55
        throw new IllegalArgumentException("输入数组必须是正序数组");
56
    }
57

58
    public double mergeSortedArrays(int[] nums1, int[] nums2) {
59
        if (nums1 == null || nums2 == null) {
60
            throw new IllegalArgumentException("输入数组不能为 null");
61
        }
62
        if (nums1.length == 0 && nums2.length == 0) {
63
            throw new IllegalArgumentException("两个数组不能同时为空");
64
        }
65

66
        int totalLength = nums1.length + nums2.length;
67
        int[] merged = new int[totalLength];
68

69
        int index1 = 0;
70
        int index2 = 0;
71
        int mergedIndex = 0;
72

73
        while (index1 < nums1.length && index2 < nums2.length) {
74
            if (nums1[index1] <= nums2[index2]) {
75
                merged[mergedIndex] = nums1[index1];
76
                index1++;
77
            } else {
78
                merged[mergedIndex] = nums2[index2];
79
                index2++;
80
            }
81
            mergedIndex++;
82
        }
83

84
        while (index1 < nums1.length) {
85
            merged[mergedIndex] = nums1[index1];
86
            index1++;
87
            mergedIndex++;
88
        }
89

90
        while (index2 < nums2.length) {
91
            merged[mergedIndex] = nums2[index2];
92
            index2++;
93
            mergedIndex++;
94
        }
95

96
        int mid = totalLength / 2;
97
        if ((totalLength & 1) == 1) {
98
            return merged[mid];
99
        }
100

101
        return ((double) merged[mid - 1] + (double) merged[mid]) / 2.0;
102
    }
103
}

展开收起

五、关键代码说明#

leftPartSize：切割后左半部分应该包含的元素数量。
shortCut、longCut：两个数组的切割位置。
Integer.MIN_VALUE、Integer.MAX_VALUE：用于处理切割线在数组边界时的哨兵值。
合法切割条件是 shortLeftMax <= longRightMin && longLeftMax <= shortRightMin。
偶数长度时先转成 double 再相加，避免 int 溢出。

六、复杂度分析#

二分切割法时间复杂度：O(log(min(m, n)))，只在较短数组上二分。
二分切割法空间复杂度：O(1)，只使用常量变量。
合并数组法时间复杂度：O(m + n)，需要合并两个数组。
合并数组法空间复杂度：O(m + n)，需要额外的合并数组。

七、注意事项#

当前实现要求输入数组不能为 null，也不能同时为空。
二分切割法依赖两个输入数组已经按正序排列。
切割线在数组头尾时必须使用哨兵值，否则容易数组越界。
计算偶数长度中位数时要避免两个极值相加导致整数溢出。

八、面试知识点：二分切割与中位数#

1. 为什么这题不能只会合并数组？#

合并数组法很直观：把两个有序数组合并成一个有序数组，然后取中位数。当前源码也保留了 mergeSortedArrays，方便理解中位数定义。

但 LeetCode 原题通常要求时间复杂度达到 O(log(m + n))。完整合并需要 O(m + n) 时间和 O(m + n) 空间，不满足更优要求。因此面试重点通常是二分切割法。

2. 中位数的本质是什么？#

中位数可以理解为：把所有元素分成左右两部分，并且满足：

1
左半部分元素数量 == 右半部分元素数量，或左半部分多一个
2
左半部分最大值 <= 右半部分最小值

如果总长度是奇数，中位数是左半部分最大值；如果总长度是偶数，中位数是左半部分最大值和右半部分最小值的平均值。

3. 什么是二分切割？#

二分切割不是直接二分答案，而是二分“短数组的切割位置”。

假设短数组切 shortCut 个元素到左边，那么长数组左边需要放：

1
longCut = leftPartSize - shortCut;

这样可以保证左右两边的元素数量满足中位数要求。接下来只要判断切割线附近的四个边界值是否有序即可。

4. 为什么一定要在短数组上二分？#

在短数组上二分有两个好处：

时间复杂度是 O(log(min(m, n)))；
更容易保证另一个数组的切割位置合法。

当前实现一开始判断：

1
if (nums1.length > nums2.length) {
2
    return findMedianSortedArrays(nums2, nums1);
3
}

这一步就是为了始终在较短数组上做二分。

5. 四个边界值分别表示什么？#

二分切割时，需要关注：

shortLeftMax：短数组切割线左边最大值；
shortRightMin：短数组切割线右边最小值；
longLeftMax：长数组切割线左边最大值；
longRightMin：长数组切割线右边最小值。

合法切割条件是：

1
shortLeftMax <= longRightMin && longLeftMax <= shortRightMin

满足这个条件，说明左半部分所有元素都小于等于右半部分所有元素。

6. 为什么需要哨兵值？#

切割线可能在数组最左边或最右边。

例如短数组为空，或者切割位置为 0，左边没有元素；如果切割位置等于数组长度，右边没有元素。为了避免数组越界，当前实现使用：

1
Integer.MIN_VALUE
2
Integer.MAX_VALUE

作为边界哨兵。

它们的含义是：

左边没有元素时，左侧最大值当作负无穷；
右边没有元素时，右侧最小值当作正无穷。

7. 二分区间怎么移动？#

如果：

1
shortLeftMax > longRightMin

说明短数组左边选多了，shortCut 太靠右，需要左移。

否则说明短数组左边选少了，shortCut 太靠左，需要右移。

这就是当前代码中：

1
if (shortLeftMax > longRightMin) {
2
    right = shortCut - 1;
3
} else {
4
    left = shortCut + 1;
5
}

8. 为什么求平均值前要转 double？#

偶数长度时，中位数是两个数的平均值。

如果直接写：

1
(leftMax + rightMin) / 2.0

leftMax + rightMin 会先按 int 相加，极端情况下可能已经溢出。

当前实现写成：

1
((double) leftMax + (double) rightMin) / 2.0

先转成 double 再相加，可以避免 int 溢出。

9. 这题常见面试追问#

为什么不是二分两个数组，而是只二分短数组？
leftPartSize = (totalLength + 1) / 2 为什么要加 1？
数组为空时怎么处理？
总长度奇偶如何分别处理？
哨兵值会不会影响答案？
输入数组不是有序数组怎么办？
合并数组法和二分切割法复杂度分别是多少？

其中 leftPartSize 加 1 是为了在总长度为奇数时，让左半部分多一个元素，便于直接返回左半部分最大值。

10. 回到本题，面试时怎么回答？#

可以这样组织回答：

这道题如果直接合并两个有序数组，时间复杂度是 O(m + n)，但更优做法是二分切割。中位数的本质是把合并后的有序序列分成左右两部分，并保证左边最大值小于等于右边最小值。我始终在较短数组上二分切割位置，再根据左半部分总元素数量推导长数组的切割位置。
每次只需要比较切割线附近的四个值：短左最大、短右最小、长左最大、长右最小。如果满足 shortLeftMax <= longRightMin && longLeftMax <= shortRightMin，就找到了合法切割。奇数长度返回左半最大值，偶数长度返回左半最大值和右半最小值的平均值。时间复杂度是 O(log(min(m, n)))，空间复杂度是 O(1)。