后端MySQL 与 Redis 前端速成

第四章 MySQL 和 Redis 到底用什么“编程”?

它不是 JavaScript,也不是 Java。

MySQL 与 Redis 前端速成4 / 11

后端
第四章 MySQL 和 Redis 到底用什么“编程”?文章封面

当前1. SQL 本身就是一种语言

先回答你最容易混淆的问题:

MySQL 和 Redis 到底用什么“编程”?

1. SQL 本身就是一种语言

MySQL 使用的是:

SQL,结构化查询语言。

它不是 JavaScript,也不是 Java。

例如:

-- 从订单表中查询订单编号为指定值的订单
SELECT *
FROM orders
WHERE order_no = 'ORDER20260730001';

这段代码可以直接在这些工具里执行:

  • MySQL 命令行
  • Navicat
  • DataGrip
  • MySQL Workbench
  • 后端程序

2. Redis 不使用 SQL

Redis 使用的是自己的命令,例如:

# 保存用户 1001 的昵称
SET user:1001:name "刘凤伟"

# 读取用户 1001 的昵称
GET user:1001:name

所以要记住:

MySQL 写 SQL,Redis 写 Redis 命令。


3. JavaScript、Java、Python 负责“调用”它们

实际项目中,通常是后端程序连接 MySQL 和 Redis。

常见组合:

后端语言MySQL 工具Redis 工具
Node.jsmysql2、Sequelize、Prismaredis、ioredis
JavaJDBC、MyBatis、JPASpring Data Redis
PythonPyMySQL、SQLAlchemyredis-py
Godatabase/sql、GORMgo-redis

你是前端开发,最适合先掌握:

Node.js + Express + mysql2 + Redis。


4. 前端不能直接连接 MySQL

正常项目结构是:

Vue / React 前端
        ↓
通过 Axios 或 Fetch 请求接口
        ↓
Node.js / Java 后端
        ↓
MySQL 和 Redis

不能这样做:

Vue 前端 → 直接连接 MySQL

原因包括:

  • 数据库账号和密码会暴露;
  • 用户可以绕过业务规则;
  • 容易被恶意修改数据库;
  • 浏览器通常也不直接支持数据库连接协议。

5. Node.js 怎么执行 SQL?

以 mysql2 为例:

// 引入 mysql2 的 Promise 版本,用来连接 MySQL
const mysql = require('mysql2/promise');

// 创建 MySQL 数据库连接池
const pool = mysql.createPool({
  host: 'localhost', // MySQL 服务器地址
  user: 'root', // MySQL 用户名
  password: '123456', // MySQL 密码
  database: 'wanfu', // 要连接的数据库名称
});

// 定义查询用户订单的方法
async function getUserOrders(userId) {
  // 执行 SQL,并通过问号占位符安全传入用户 ID
  const [rows] = await pool.execute(
    `
      -- 查询订单编号、状态和金额
      SELECT order_no, status, amount
      FROM orders
      WHERE user_id = ?
      ORDER BY created_at DESC
    `,
    [userId], // 将 userId 替换到 SQL 的问号位置
  );

  // 返回数据库查询结果
  return rows;
}

这里的职责是:

JavaScript:控制程序流程
SQL:告诉 MySQL 查什么数据

6. Node.js 怎么操作 Redis?

以官方 redis 库为例:

// 引入 Redis 客户端创建方法
const { createClient } = require('redis');

// 创建 Redis 客户端
const redisClient = createClient({
  url: 'redis://localhost:6379', // Redis 服务器连接地址
});

// 连接 Redis
await redisClient.connect();

// 保存用户昵称,并设置 300 秒后过期
await redisClient.set(
  'user:1001:name', // Redis 的 Key
  '刘凤伟', // Redis 的 Value
  {
    EX: 300, // 设置数据 300 秒后自动过期
  },
);

// 根据 Key 读取用户昵称
const name = await redisClient.get('user:1001:name');

// 打印读取到的用户名
console.log(name);

7. 数据库本身是用什么语言写的?

这是另外一个问题。

  • MySQL 核心主要由 C、C++ 实现;
  • Redis 核心主要由 C 实现;
  • 但我们开发业务时,不需要自己编写数据库底层;
  • 我们只需要通过 SQL、Redis 命令和客户端库操作它们。

一句话总结:

MySQL 本身主要由 C/C++ 实现,但业务开发使用 SQL 操作;Redis 本身主要由 C 实现,但业务开发使用 SET、GET、HSET 等 Redis 命令操作。Node.js、Java 等语言负责连接数据库并执行这些命令。


第四章:MySQL 查询实战

今天你是一名“订单侦探”。

万福鉴酒系统里有几万条订单,产品经理跑来问你:

刘凤伟这个月买了多少瓶酒? 哪种订单状态最多? 哪些用户订单超过五单? 为什么列表第一页正常,第五千页却特别慢?

这一章就是教你回答这些问题。

你的万福鉴酒项目有订单状态机,生猪健康系统有药品和疾病检索,TripStar AI 有任务和行程记录,这些都是 SQL 高频使用场景。


一、先认识我们的订单表

假设有一张订单表:

-- 创建订单表
CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT, -- 订单主键,自增 ID
  order_no VARCHAR(64) NOT NULL UNIQUE, -- 订单编号,不能重复
  user_id BIGINT NOT NULL, -- 下单用户 ID
  status TINYINT NOT NULL, -- 订单状态
  amount DECIMAL(10, 2) NOT NULL, -- 订单金额
  created_at DATETIME NOT NULL -- 订单创建时间
);

假设状态含义是:

10:待接单
20:进行中
30:已完成
40:已退款

二、WHERE:先把无关的人赶出去

WHERE 用来筛选符合条件的数据。

查询用户 1001 的订单

-- 查询用户 1001 的所有订单
SELECT id, order_no, status, amount
FROM orders
WHERE user_id = 1001;

查询用户 1001 的进行中订单

-- 查询用户 1001 并且状态为进行中的订单
SELECT id, order_no, status, amount
FROM orders
WHERE user_id = 1001
  AND status = 20;

这里的 AND 表示:

两个条件必须同时满足。


查询进行中或已完成的订单

-- 查询状态为进行中或者已完成的订单
SELECT id, order_no, status, amount
FROM orders
WHERE status = 20
   OR status = 30;

更推荐使用 IN:

-- 查询状态属于进行中或已完成的订单
SELECT id, order_no, status, amount
FROM orders
WHERE status IN (20, 30);

记忆:

AND:并且
OR:或者
IN:属于其中任意一个

三、BETWEEN:查询某个范围

查询金额在 100 元到 500 元之间的订单:

-- 查询金额在 100 元到 500 元之间的订单,包含 100 和 500
SELECT id, order_no, amount
FROM orders
WHERE amount BETWEEN 100 AND 500;

BETWEEN 通常包含左右边界。

它相当于:

-- 查询金额大于等于 100,并且小于等于 500 的订单
SELECT id, order_no, amount
FROM orders
WHERE amount >= 100
  AND amount <= 500;

四、日期查询千万不要乱写

查询 2026 年 7 月 30 日创建的订单。

不太推荐:

-- 对 created_at 字段调用 DATE 函数,可能影响普通索引使用
SELECT id, order_no, created_at
FROM orders
WHERE DATE(created_at) = '2026-07-30';

更推荐:

-- 查询 2026 年 7 月 30 日零点之后创建的订单
SELECT id, order_no, created_at
FROM orders
WHERE created_at >= '2026-07-30 00:00:00'
  AND created_at < '2026-07-31 00:00:00';

这里为什么不用:

小于等于 23:59:59

因为数据库时间可能还包含毫秒或微秒。

所以日期范围常用:

大于等于今天零点,小于明天零点。


五、LIKE:模糊搜索

例如前端有一个订单号搜索框。

查询以 ORDER2026 开头的订单

-- 查询订单编号以 ORDER2026 开头的订单
SELECT id, order_no
FROM orders
WHERE order_no LIKE 'ORDER2026%';

这里 % 表示任意多个字符。


查询中间包含 730 的订单

-- 查询订单编号中任意位置包含 730 的订单
SELECT id, order_no
FROM orders
WHERE order_no LIKE '%730%';

但要记住:

前面带 % 的模糊查询,通常难以高效利用普通 B+ 树索引。


六、ORDER BY:给结果排队

按创建时间倒序

-- 查询订单,并按照创建时间从新到旧排序
SELECT id, order_no, created_at
FROM orders
ORDER BY created_at DESC;

DESC:

从大到小、从新到旧。

ASC:

从小到大、从旧到新。


先按状态,再按时间排序

-- 先按照订单状态升序,再按照创建时间倒序
SELECT id, order_no, status, created_at
FROM orders
ORDER BY status ASC, created_at DESC;

可以想象成:

先把相同状态的人分到一个队伍
再让每个队伍里最新订单站前面

七、LIMIT:只取一部分数据

查询最新的十条订单

-- 按照订单创建时间倒序排列,只返回前十条
SELECT id, order_no, created_at
FROM orders
ORDER BY created_at DESC
LIMIT 10;

查询第二页

假设一页十条:

-- 跳过前十条订单,再返回十条,相当于查询第二页
SELECT id, order_no, created_at
FROM orders
ORDER BY created_at DESC
LIMIT 10 OFFSET 10;

计算公式:

OFFSET = (pageIndex - 1) × pageSize

例如第 3 页,每页 10 条:

OFFSET = (3 - 1) × 10 = 20

SQL:

-- 跳过前二十条数据,再查询十条,相当于第三页
SELECT id, order_no, created_at
FROM orders
ORDER BY created_at DESC
LIMIT 10 OFFSET 20;

八、为什么深分页很慢?

第 10001 页:

-- 跳过前十万条订单,再返回十条,可能产生深分页性能问题
SELECT id, order_no, created_at
FROM orders
ORDER BY id DESC
LIMIT 10 OFFSET 100000;

MySQL 并不是瞬间传送到第十万条。

它可能需要:

先找到前 100010 条
丢掉前 100000 条
只留下最后 10 条

因此会浪费大量扫描。


使用 lastId 优化

假设上一页最后一条订单 ID 是 88888:

-- 查询 ID 小于上一页最后一个 ID 的订单
SELECT id, order_no, created_at
FROM orders
WHERE id < 88888
ORDER BY id DESC
LIMIT 10;

前端请求可以传:

// 请求下一页订单数据
axios.get('/api/orders', {
  params: {
    lastId: 88888, // 上一页最后一条订单的 ID
    pageSize: 10, // 本次需要查询的订单数量
  },
});

这种方式叫:

游标分页。

面试回答:

普通后台列表可以使用 pageIndex 和 pageSize,但大数据量的深分页会扫描并丢弃大量记录。信息流场景可以基于上一页最后一个 ID 进行游标分页。


九、聚合函数:让数据库帮你做数学题

常见聚合函数:

函数用途
COUNT统计数量
SUM求和
AVG求平均值
MAX求最大值
MIN求最小值

1. 统计订单数量

-- 统计订单表中一共有多少条订单
SELECT COUNT(*) AS order_count
FROM orders;

AS order_count 表示给结果起别名。

结果类似:

order_count:5000

2. 统计用户 1001 的订单数量

-- 统计用户 1001 一共有多少条订单
SELECT COUNT(*) AS order_count
FROM orders
WHERE user_id = 1001;

3. 统计用户的总消费金额

-- 计算用户 1001 所有订单金额的总和
SELECT SUM(amount) AS total_amount
FROM orders
WHERE user_id = 1001;

4. 统计平均订单金额

-- 计算所有订单的平均金额
SELECT AVG(amount) AS average_amount
FROM orders;

5. 查询最高和最低订单金额

-- 查询订单中的最高金额和最低金额
SELECT
  MAX(amount) AS maximum_amount, -- 计算最高订单金额
  MIN(amount) AS minimum_amount -- 计算最低订单金额
FROM orders;

十、COUNT 三兄弟的区别

COUNT(*)

统计符合条件的行数:

-- 统计订单表中符合条件的所有记录数量
SELECT COUNT(*)
FROM orders;

COUNT(id)

统计 id 不为 NULL 的数量:

-- 统计 id 字段不为 NULL 的记录数量
SELECT COUNT(id)
FROM orders;

由于主键 id 不会为 NULL,通常结果和 COUNT(*) 相同。

COUNT(refund_reason)

-- 只统计退款原因字段不为 NULL 的订单数量
SELECT COUNT(refund_reason)
FROM orders;

它不会统计 refund_reason 为 NULL 的记录。

面试记忆:

COUNT(*) 统计行数,COUNT(字段) 只统计该字段不为 NULL 的行数。


十一、GROUP BY:把订单分组统计

产品经理问:

每种状态分别有多少条订单?

这时不能只用 COUNT,因为需要按照状态分组。

-- 按照订单状态分组,并统计每种状态的订单数量
SELECT
  status, -- 返回订单状态
  COUNT(*) AS order_count -- 统计当前状态对应的订单数量
FROM orders
GROUP BY status;

结果可能是:

状态 10:20 条
状态 20:15 条
状态 30:100 条
状态 40:8 条

你可以把 GROUP BY 想象成体育老师分队:

待接单去第一队
进行中去第二队
已完成去第三队
已退款去第四队

然后分别数每一队有多少人。


十二、按照用户分组统计消费

-- 按照用户 ID 分组,统计每个用户的订单数量和消费总额
SELECT
  user_id, -- 返回用户 ID
  COUNT(*) AS order_count, -- 统计当前用户的订单数量
  SUM(amount) AS total_amount -- 计算当前用户的消费总额
FROM orders
GROUP BY user_id;

结果:

用户 1001:5 单,共 1200 元
用户 1002:8 单,共 3000 元
用户 1003:2 单,共 500 元

十三、WHERE 和 HAVING 到底有什么区别?

这是面试高频。

WHERE:分组前过滤

例如只统计已完成订单:

-- 先筛选出已完成订单,再按照用户分组
SELECT
  user_id, -- 返回用户 ID
  COUNT(*) AS completed_count -- 统计用户已完成订单数量
FROM orders
WHERE status = 30
GROUP BY user_id;

执行思路:

先把不是已完成的订单赶走
再按照用户分组

HAVING:分组后过滤

例如只查询订单数量超过 5 单的用户:

-- 按照用户分组后,只保留订单数量超过五单的用户
SELECT
  user_id, -- 返回用户 ID
  COUNT(*) AS order_count -- 统计每个用户的订单数量
FROM orders
GROUP BY user_id
HAVING COUNT(*) > 5;

执行思路:

先按照用户分组
再统计每组订单数量
最后留下数量超过 5 的组

一句话背诵:

WHERE 过滤原始数据,HAVING 过滤分组后的结果。


十四、WHERE 和 HAVING 一起使用

需求:

统计已完成订单中,总消费超过 1000 元的用户。

-- 查询已完成订单中,累计消费金额超过 1000 元的用户
SELECT
  user_id, -- 返回用户 ID
  SUM(amount) AS total_amount -- 计算用户已完成订单的总金额
FROM orders
WHERE status = 30 -- 分组前只保留已完成订单
GROUP BY user_id -- 按照用户进行分组
HAVING SUM(amount) > 1000; -- 分组后筛选总金额超过 1000 元的用户

故事顺序:

第一步:只留下已完成订单
第二步:按用户分组
第三步:计算每个用户总金额
第四步:留下超过 1000 元的用户

十五、JOIN:把两张表拼起来

假设用户表:

-- 创建用户表
CREATE TABLE users (
  id BIGINT PRIMARY KEY AUTO_INCREMENT, -- 用户主键 ID
  username VARCHAR(50) NOT NULL -- 用户名
);

订单表中只保存了:

user_id = 1001

但是页面想展示:

用户:刘凤伟
订单:ORDER001
金额:999 元

这时需要连接用户表和订单表。


INNER JOIN

-- 查询能够匹配到用户信息的订单
SELECT
  o.order_no, -- 返回订单编号
  o.amount, -- 返回订单金额
  u.username -- 返回用户名
FROM orders AS o
INNER JOIN users AS u
  ON o.user_id = u.id;

o 和 u 是表的别名:

o:orders
u:users

INNER JOIN 只返回:

两张表都能匹配上的数据。


LEFT JOIN

-- 查询全部订单,即使某些订单匹配不到用户信息也保留
SELECT
  o.order_no, -- 返回订单编号
  o.amount, -- 返回订单金额
  u.username -- 返回用户名,匹配不到时为 NULL
FROM orders AS o
LEFT JOIN users AS u
  ON o.user_id = u.id;

LEFT JOIN 会保留左边订单表的全部数据。

记忆:

INNER JOIN:双方对得上才进来
LEFT JOIN:左边的人全部进来

十六、一个非常真实的列表查询

万福鉴酒后台需要:

  • 查询指定用户;
  • 查询进行中和已完成订单;
  • 显示用户名;
  • 按创建时间倒序;
  • 每页二十条。
-- 查询指定用户的进行中和已完成订单列表
SELECT
  o.id, -- 返回订单主键 ID
  o.order_no, -- 返回订单编号
  o.status, -- 返回订单状态
  o.amount, -- 返回订单金额
  o.created_at, -- 返回订单创建时间
  u.username -- 返回下单用户名
FROM orders AS o
LEFT JOIN users AS u
  ON o.user_id = u.id -- 根据用户 ID 关联用户表
WHERE o.user_id = 1001 -- 只查询用户 1001 的订单
  AND o.status IN (20, 30) -- 只查询进行中和已完成状态
ORDER BY o.created_at DESC -- 按照创建时间从新到旧排序
LIMIT 20; -- 只返回前二十条记录

这已经是一条很像真实项目的 SQL。


十七、SQL 的实际执行顺序

SQL 虽然是这样写:

-- 查询每个用户已完成订单的总金额
SELECT
  user_id, -- 返回用户 ID
  SUM(amount) AS total_amount -- 计算总金额
FROM orders
WHERE status = 30 -- 筛选已完成订单
GROUP BY user_id -- 按用户分组
HAVING SUM(amount) > 1000 -- 筛选总金额大于 1000 的分组
ORDER BY total_amount DESC -- 按总金额从高到低排序
LIMIT 10; -- 只返回前十名

但大致逻辑执行顺序是:

1. FROM:先确定从哪张表查询
2. JOIN:连接其他表
3. WHERE:过滤原始数据
4. GROUP BY:进行分组
5. HAVING:过滤分组结果
6. SELECT:选择返回字段
7. ORDER BY:排序
8. LIMIT:限制返回数量

记忆小故事:

先找表,再连接;先过滤,再分组;分完再过滤,最后选字段、排序、截取。


十八、为什么不能在 WHERE 中直接使用聚合结果?

错误思路:

-- 错误示例:WHERE 阶段还没有完成分组统计
SELECT
  user_id, -- 返回用户 ID
  COUNT(*) AS order_count -- 统计订单数量
FROM orders
WHERE COUNT(*) > 5 -- 这里不能直接使用聚合结果
GROUP BY user_id;

因为 WHERE 执行时,还没有进行 GROUP BY 和 COUNT。

正确写法:

-- 正确示例:使用 HAVING 筛选分组后的统计结果
SELECT
  user_id, -- 返回用户 ID
  COUNT(*) AS order_count -- 统计用户订单数量
FROM orders
GROUP BY user_id -- 先按照用户进行分组
HAVING COUNT(*) > 5; -- 再筛选订单数量超过五单的用户

十九、DISTINCT:删除重复结果

例如查询所有下过单的用户 ID:

-- 查询订单表中不重复的用户 ID
SELECT DISTINCT user_id
FROM orders;

假设原数据是:

1001
1001
1002
1002
1003

结果变成:

1001
1002
1003

但不要无脑使用 DISTINCT。

因为数据库需要做去重处理,数据量大时也会有成本。


二十、结合生猪健康系统

产品经理问:

每种药品分类分别有多少种药品?

-- 按照药品分类统计每个分类中的药品数量
SELECT
  category_id, -- 返回药品分类 ID
  COUNT(*) AS medicine_count -- 统计该分类下的药品数量
FROM medicines
GROUP BY category_id;

查询药品数量超过十种的分类:

-- 查询药品数量超过十种的分类
SELECT
  category_id, -- 返回药品分类 ID
  COUNT(*) AS medicine_count -- 统计分类下的药品数量
FROM medicines
GROUP BY category_id -- 按照药品分类进行分组
HAVING COUNT(*) > 10; -- 只保留药品数量超过十种的分类

二十一、结合 TripStar AI

查询用户最近完成的旅行计划:

-- 查询用户 1001 最近完成的十个旅行计划
SELECT
  id, -- 返回旅行计划 ID
  destination, -- 返回目的地
  status, -- 返回任务状态
  created_at -- 返回创建时间
FROM trip_tasks
WHERE user_id = 1001 -- 只查询用户 1001 的任务
  AND status = 'completed' -- 只查询已完成任务
ORDER BY created_at DESC -- 按照创建时间从新到旧排序
LIMIT 10; -- 只返回最新十条

统计每天生成了多少个旅行计划:

-- 按照日期统计每天创建的旅行计划数量
SELECT
  DATE(created_at) AS create_date, -- 提取任务创建日期
  COUNT(*) AS task_count -- 统计当天创建的任务数量
FROM trip_tasks
GROUP BY DATE(created_at) -- 按照创建日期分组
ORDER BY create_date DESC; -- 按照日期从新到旧排序

注意:

在统计报表中对日期使用函数很常见;但在高频 WHERE 查询中,要注意函数可能影响索引使用。


本章必须背的五个问题

1. WHERE 和 HAVING 有什么区别?

WHERE 在分组前过滤原始数据,不能直接筛选聚合结果;HAVING 在 GROUP BY 分组后过滤统计结果,常与 COUNT、SUM 等聚合函数配合使用。

2. INNER JOIN 和 LEFT JOIN 有什么区别?

INNER JOIN 只返回左右两张表能够匹配的记录;LEFT JOIN 会保留左表全部记录,右表匹配不到时对应字段为 NULL。

3. COUNT(*) 和 COUNT(字段) 有什么区别?

COUNT(*) 统计符合条件的记录行数,COUNT(字段) 只统计该字段不为 NULL 的记录数量。

4. 深分页为什么慢?

OFFSET 很大时,MySQL 可能需要扫描并丢弃大量前置数据。可以使用合适索引以及基于 lastId 的游标分页优化。

5. SQL 的逻辑执行顺序是什么?

大致是 FROM、JOIN、WHERE、GROUP BY、HAVING、SELECT、ORDER BY、LIMIT。


本章一句话知识链

WHERE 负责找人
ORDER BY 负责排队
LIMIT 负责截取
COUNT 和 SUM 负责算账
GROUP BY 负责分组
HAVING 负责淘汰分组
JOIN 负责把多张表拼起来

下一章进入 MySQL 慢 SQL 优化与 EXPLAIN 实战:一条接口为什么从 100 毫秒变成 5 秒,怎样像排查前端性能问题一样一步步找出数据库凶手。