本文总结 Java 8 中最常用、最核心的三项特性：Lambda 表达式、Stream API 与 Optional。内容以“已学过、快速回顾与查阅”为目标，侧重概念理解与典型用法。

目录导航

• 1. Lambda 表达式
• 2. Stream API
• 3. Optional

1.Lambda表达式

1.简介

Lambda 表达式是 Java 8 引入的一种匿名函数语法，用于简化只有一个抽象方法的接口（函数式接口）的实现方式。它本质上是一段可以被传递和执行的代码，使 Java 在一定程度上具备了函数式编程的特征。

在 Java 8 之前，若要实现接口通常需要使用匿名内部类，代码冗长且可读性较差。Lambda 表达式通过更简洁的语法，使“做什么”比“怎么写”更加直观。

2.作用

Lambda 表达式的主要作用包括：

1. 简化代码结构
   使用 Lambda 可以显著减少匿名内部类的样板代码，使核心逻辑更加突出。

2. 提高可读性
   在集合操作、事件回调等场景中，Lambda 能让代码更加贴近自然语言描述。

3. 支持函数式编程风格
   Lambda 是 Stream API、Optional 等特性的基础，使 Java 能以声明式方式处理数据。

3.使用

Stream 的典型使用流程为：

1. 获取 Stream
2. 中间操作（可选，可多次）
3. 终止操作

示例：

1
2
3
4
5
6

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

int sum = list.stream()
        .filter(x -> x % 2 == 0)
        .map(x -> x * x)
        .reduce(0, Integer::sum);

常见中间操作：

• filter
• map
• sorted
• distinct

常见终止操作：

• forEach
• collect
• reduce
• count

需要注意：

• Stream 只能被消费一次
• Stream 操作是惰性执行的，只有遇到终止操作才会真正执行

4.示例

将传统集合遍历方式改写为 Stream 写法：

1
2
3
4
5
6
7
8

List<String> names = Arrays.asList("Tom", "Jerry", "Alice", "Bob");
List<String> result = new ArrayList<>();

for (String name : names) {
    if (name.length() > 3) {
        result.add(name.toUpperCase());
    }
}

使用 Stream 改写后：

1
2
3
4

List<String> result = names.stream()
        .filter(name -> name.length() > 3)
        .map(String::toUpperCase)
        .collect(Collectors.toList());

Stream 写法将“过滤—转换—收集”的数据处理流程清晰地表达出来，避免了显式的循环和临时变量。

返回顶部

2.Stream API

1.简介

Stream API 是 Java 8 提供的一套用于操作集合数据的全新抽象。Stream 并不是数据结构，而是一种对数据源（如集合、数组）的高层次操作视图。

Stream 强调“做什么”，而非“如何遍历”，通过链式调用的方式完成对数据的处理。

2.作用

Stream API 的主要作用包括：

1. 简化集合操作
   过滤、映射、排序、聚合等操作可以用一行链式代码完成。

2. 提高代码表达力
   使用 Stream 可以清晰表达数据处理流程，减少中间变量。

3. 支持并行处理
   通过 parallelStream()，可以较低成本地利用多核 CPU 提升性能。

3.使用

Stream 的典型使用流程为：

1. 获取 Stream
2. 中间操作（可选，可多次）
3. 终止操作

示例：

1
2
3
4
5
6

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

int sum = list.stream()
        .filter(x -> x % 2 == 0)
        .map(x -> x * x)
        .reduce(0, Integer::sum);

常见中间操作：

• filter
• map
• sorted
• distinct

常见终止操作：

• forEach
• collect
• reduce
• count

需要注意：

• Stream 只能被消费一次
• Stream 操作是惰性执行的，只有遇到终止操作才会真正执行

返回顶部

3.Optional

1.简介

Optional 是 Java 8 引入的一个容器类，用于显式表示“可能为空”的值。它的出现旨在减少空指针异常（NullPointerException），并引导开发者以更加安全的方式处理空值。

Optional 本身并不是为了解决所有 null 问题，而是作为一种 API 设计层面的约束和提示。

2.作用

Optional 的主要作用包括：

1. 减少空指针异常
   通过强制检查或处理空值，降低运行时错误风险。

2. 提高代码可读性
   方法返回 Optional，可以明确告诉调用者：返回值可能不存在。

3. 鼓励函数式写法
   Optional 与 Lambda 配合使用，可避免大量的 if-null 判断。

3.使用

创建 Optional 的常见方式：

1
2
3

Optional<String> op1 = Optional.of("Java");
Optional<String> op2 = Optional.ofNullable(null);
Optional<String> op3 = Optional.empty();

常用方法示例：

1. 判断是否有值

1

op1.isPresent();

2. 获取值（不推荐直接使用）

1

op1.get();

3. 提供默认值

1

String s = op2.orElse("default");

4. 使用 Lambda 处理

1

op1.ifPresent(v -> System.out.println(v));

4.示例

将传统的空值判断代码改写为 Optional 写法：

1
2
3
4

String value = getValue();
if (value != null) {
    System.out.println(value.length());
}

使用 Optional 改写后：

1
2
3

Optional.ofNullable(getValue())
        .map(String::length)
        .ifPresent(System.out::println);

Optional 通过链式调用，将空值判断与业务逻辑合并，使代码更加紧凑且不易出错。

返回顶部

总目录

1. 链表的中间节点
2. 反转链表
3. 回文链表
4. 重排链表
5. 移除链表元素
6. 两两交换链表中的节点
7. 合并两个有序链表

链表的中间节点-快慢指针

题号：876
给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

输入：head = [1,2,3,4,5]

输出：[3,4,5]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode p = head;
        ListNode q = head;
        while(q != null && q.next != null){
            p = p.next;
            q = q.next.next;
        }
        return p;
    }
}

• 当快指针遍历完时，慢指针刚好在整个链表中间。

反转链表

题号：206

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]

输出：[5,4,3,2,1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode q = head;
        while(q != null){
            ListNode nxt = q.next;
            q.next = pre;
            pre = q;
            q = nxt;
        }
        return pre;
    }
}

回文链表

-前置 ：链表的中间节点、反转链表
题号：234

给你一个单链表的头节点 head，请判断该链表是否为回文链表。

1. 用快慢指针找到链表中点（偶数长度时取后半段起点，即第二个中间节点）；
2. 反转后半段链表；
3. 用两个指针分别从头节点和反转后的后半段头节点同步遍历比较；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
    public boolean isPalindrome(ListNode head) {
        // 快慢指针
        ListNode fast =head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        // 反转
        ListNode pre = null;
        ListNode cur = slow;
        while (cur != null) {
            ListNode nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }

        while (pre != null){
            if(pre.val != head.val){
                return false;
            }
            head = head.next;
            pre = pre.next;
        }
        return true;
    }
}

类似例题

题号：9 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0 || x > 0 && x % 10 == 0){
            return false;
        }
        int rev = 0;
        while(rev < x / 10){
            rev = rev * 10 + x % 10;
            x /= 10;
        }
        return rev == x || rev == x / 10;
    }
}

重排链表

题号：143

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Solution {
    public void reorderList(ListNode head) {
        ListNode mid = middle(head);
        ListNode head2 = reverse(mid);
        while(head2.next != null){
            ListNode nxt = head.next;
            ListNode nxt2 = head2.next;
            head.next = head2;
            head2.next = nxt;
            head = nxt;
            head2 = nxt2;
        }
    }

    private ListNode reverse(ListNode head){
        ListNode pre = null, cur = head;
        while(cur != null){
            ListNode nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    private ListNode middle(ListNode head){
        ListNode slow = head, fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

移除链表元素

题号：203

输入：head = [1,2,6,3,4,5,6], val = 6

输出：[1,2,3,4,5]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode cur = dummy;
        while(cur.next != null ){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }
            else{
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

两两交换链表中的节点

题号：24

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

输入：head = [1,2,3,4]

输出：[2,1,4,3]

• 方法一：迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0, head);
        ListNode node0 = dummy;
        ListNode node1 = head;
        while (node1 != null && node1.next != null) {
            ListNode node2 = node1.next;
            ListNode node3 = node2.next;

            node0.next = node2; // 0 -> 2
            node2.next = node1; // 2 -> 1
            node1.next = node3; // 1 -> 3

            node0 = node1;
            node1 = node3;
        }
        return dummy.next;
    }
}

• 方法二：递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode node1 = head;
        ListNode node2 = head.next;
        ListNode node3 = node2.next;

        node1.next = swapPairs(node3);
        node2.next = node1;

        return node2;
    }
}

合并两个有序链表

题号：21

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：l1 = [1,2,4], l2 = [1,3,4]

输出：[1,1,2,3,4,4]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode();
        ListNode cur = dummy;
        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                cur.next = list1;
                list1 = list1.next;
            } else {
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        cur.next = list1 != null ? list1 : list2;
        return dummy.next;
    }
}

数据库操作

创建

名称若为关键词需用单引号

1

CREATE DATABASE [IF NOT_EXISTS] XX

查看/删除

1
2
3

SHOW DATABASES 查看数据库
SHOW CREATE DATABASE XXX 数据库创建语句
DROP DATABASE [IF EXITS] XX 删除数据库

备份恢复

必须在DOS执行
备份

1

mysqldump -u * -p * -B 数据库

生成 xx.sql文件
恢复

1
2

Source xx.sq了、

表操作

创建表

1
2
3
4

CREATE TABLE table_name
{
    field datatype
}

character 字符集 (不指定默认用数据库字符集)
collate 校队规则
ENGINE

修改表

ALTER TABLE table_name

• ADD 添加列
• MODIFY 修改列
• DROP 删除列
• Rename table name to new_name 修改表名
• ALTER table name character set 字符集 修改字符集
• NOT NULL DEFAULT 默认不为空
• DESC 查看字段

数据类型

数值类型

1. 整型

    tinyint[1字节] (-127~127) unsigned(0~255)
    smallint[2]
    mediumint[3]
    int[4]
    bigint[8]
   

2. 小数类型

    float[4]
    double[8]
    decimal[M,D] (M为小数位数总数，D为小数点后的位数)(M默认10，D默认0)max(65,30)
   

文本类型

1. char(0~255)
2. varchar(065535[2^16-1]) 注：utf-8编码最大21844(65535 - 3)/3 13个字节用于记录大小
3. text(0~2^16-1)
4. longtext(2^32-1)

细节

• 1.char(4)和varchar(4)中的4表示字符
• 2.char(4)是定长，varchar(4)是变长

二进制数据

1. blob(0~2^16-1)
2. longblob(2^32-1)

日期

1. date [日期 年月日]
2. time [时间 时分秒]
3. datetime [YYYY-MM-DD HH:mm:ss]
4. timestamp 时间戳 自动更新：NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP

增删改查

INSERT

1
2

INSERT INTO table_name(columns)
    VALUES (具体数值)

注意：

1. 日期和字符数据需包含在单引号中
2. 可以插入空值
3. insert into table () values (),(),()可以添加多条记录
4. 给表中所有字段添加数据可以不写字段名称

UPDATE

1
2
3

UPDATE name
    SET COLUNMS
    (WHERE ...)

DETELE

1
2

DELETE name FROM
    WHERE ...

注意：

1. delete不能单独删除一列的数据
2. delete只删除记录。不删除表本身

SELECT

1
2

SELECT [DISTINCT] * | {COLUMN}
  FROM table_name

注意：

1. DISTINCT 是否去重
2. 使用表达式对查询的列进行运算：

1
2

SELECT *|{COLUMN1|EXPRESSION}
  FROM table_name

3. AS 语句

1

SELECT column_name as 别名 from table

4. WHERE 子句：条件筛选

🔹 逻辑运算符（组合条件）

✅ 注意：AND 优先级高于 OR，建议用括号 () 明确逻辑分组，例如：

1	WHERE (status = 'active' OR level > 5) AND NOT is_deleted

🔹 比较运算符（判断单值/集合）

📌 提示：

• NULL 表示“缺失/未知”，任何与 NULL 的比较（如 =, !=）结果均为 UNKNOWN。
• 字符串模糊匹配注意大小写敏感性（依赖数据库设置，如 MySQL 默认不区分，PostgreSQL 区分）。

5. ORDER BY 排序查询结果

• 升序 ASC
• 降序 DESC

合计函数 COUNT

返回行的总数
SELECT COUNT *|COLUMN FROM table_name

合计函数 SUM

返回满足WHERE条件的行的和

1

SELECT SUM (COLUMN) FROM table_name

合计函数 AVG

返回平均值

1

SELECT AVG (COLUMN) FROM table_name

合计函数 MAX/MIN

1

SELECT MAX/MIN (COLUMN) FROM table_name

GROUP BY 分组查询 + HAVING 限制显示结果

字符串函数

🔤 一、基础操作

🔗 二、拼接与拆分

🔍 三、查找与定位

🛠️ 四、替换与格式化

五、高级处理（MySQL 8.0+）

数学函数

以下是 MySQL 中常用的数学类函数（Mathematical Functions），适用于 MySQL 5.7 / 8.0+，按功能分类整理，附典型用法与注意事项。

一、基本运算与取整

二、幂、指数与对数

三、三角函数（角度单位：弧度）

⚠️ 注意：三角函数入参为弧度，若需角度计算，先用 RADIANS() 转换。

四、随机数

✅ 生成 [a, b] 区间随机整数：

1 2 3

FLOOR(a + RAND() * (b - a + 1)) -- 例如生成 [1, 100]： SELECT FLOOR(1 + RAND() * 100);

五、进制与位运算（部分）

实用示例

1. 计算用户年龄（假设 birth_date 为 DATE 类型）

   1 2 3 4

   SELECT name, FLOOR(DATEDIFF(CURDATE(), birth_date) / 365.25) AS age FROM users;

2. 评分归一化到 [0, 100]

   1 2 3 4 5 6 7 8 9

   SELECT score, ROUND(100 * (score - min_score) / (max_score - min_score), 1) AS normalized_score FROM ( SELECT score, (SELECT MIN(score) FROM exams) AS min_score, (SELECT MAX(score) FROM exams) AS max_score FROM exams ) t;

3. 生成带随机延迟的模拟数据

   1 2	SELECT NOW() + INTERVAL FLOOR(RAND() * 3600) SECOND AS random_time;

以下是 MySQL 中常用的日期与时间函数（Date and Time Functions），适用于 MySQL 5.7 / 8.0+，按功能分类整理，附详细说明、典型示例与实用技巧。

一、获取当前日期/时间

NOW() 返回语句开始执行时的时间；SYSDATE() 返回函数执行时的时间（在 SLEEP() 或触发器中差异明显）。

二、日期时间构造与提取

推荐用 WEEK(date, 1)：周一为每周首日，第1周需 >=4 天（ISO 标准兼容）。

三、日期时间格式化与解析

常用格式符（DATE_FORMAT / STR_TO_DATE）

示例：中文日期格式

1 2	SELECT DATE_FORMAT(NOW(), '%Y年%m月%d日 %W %H:%i'); -- 输出：2025年12月07日 Sunday 15:30

四、日期时间运算（加减间隔）

核心函数：DATE_ADD() / DATE_SUB() / INTERVAL

支持的 unit 类型（常用）

示例：获取本月第一天/最后一天

1 2 3 4 5 6 7 8 9

-- 本月第一天 SELECT DATE_FORMAT(CURDATE(), '%Y-%m-01'); -- 或 SELECT CURDATE() - INTERVAL DAYOFMONTH(CURDATE())-1 DAY; -- 本月最后一天（MySQL 8.0+ 推荐） SELECT LAST_DAY(CURDATE()); -- 兼容旧版： SELECT DATE_ADD(DATE_FORMAT(CURDATE(), '%Y-%m-01'), INTERVAL 1 MONTH) - INTERVAL 1 DAY;

五、日期差值计算

TIMESTAMPDIFF 的 unit：YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND
示例：计算年龄（精确到月）

1 2 3 4 5

SELECT name, TIMESTAMPDIFF(YEAR, birth_date, CURDATE()) AS age_years, TIMESTAMPDIFF(MONTH, birth_date, CURDATE()) % 12 AS extra_months FROM users;

六、其他实用函数

数学类函数

一、基础算术与取整

ROUND 的“银行家舍入”说明：
ROUND(1.5) = 2，ROUND(2.5) = 2，ROUND(3.5) = 4 —— 避免统计偏差。

二、幂、指数与对数

输入为负或零时，对数函数返回 NULL 并警告。

三、三角函数（弧度制）

角度计算模板：

1 2	-- 计算 30 度的正弦值 SELECT SIN(RADIANS(30)); -- → 0.5

四、随机数

常用随机数生成公式

1
2
3
4
5
6
7
8

-- [a, b] 区间随机整数（含端点）
SELECT FLOOR(a + RAND() * (b - a + 1));

-- 示例：生成 [1, 100] 随机整数
SELECT FLOOR(1 + RAND() * 100);

-- 生成 6 位随机数字验证码
SELECT LPAD(FLOOR(RAND() * 1000000), 6, '0');

五、进制与位运算辅助（部分）

注意：BIN(), HEX() 等返回的是字符串，不是数值。

六、聚合中的数学应用（补充）

虽属聚合函数，但常与数学结合：

1
2
3
4
5
6
7
8

SELECT
  AVG(score) AS avg_score,
  STDDEV_POP(score) AS population_std,  -- 总体标准差
  STDDEV_SAMP(score) AS sample_std,      -- 样本标准差（更常用）
  VARIANCE(score) AS variance,
  -- 百分位（MySQL 8.0+）
  PERCENT_RANK() OVER (ORDER BY score) AS pct_rank
FROM scores;

STDDEV_POP vs STDDEV_SAMP：

• 总体标准差：分母为 N
• 样本标准差：分母为 N-1（无偏估计）

附：常见错误与注意事项

加密函数

1. USER() 查询用户
2. DATABASE() 当前数据库名称
3. MD5(str)
4. PASSWORD(str)
5. SELECT * FROM mysql.user \G

流程控制函数

1. IF
2. IFNULL
3. SELECT CASE XX THEN XX

查询增强

• LIKE % 表示0到多个字符 、 - 表示单个字符

分页查询

1

SELECT XXX LIMIT START, LOWS

从start + 1 开始，取rows行

公式：

1

LIMIT 每页显示数 * 第几页 - 1，每页显示数

多表查询

直接查询两张表

从第一张表N取一行与第二张表M每一行进行组合，一共返回 N * M 行

解决方法

WHERE 过滤

注：查询条件不能少于 表数 - 1，否则会出现笛卡尔积

若表 A 有 1万 行，表 B 有 1万 行，笛卡尔积就是 1亿行

自连接

1. 把一张表当两张表用
2. 需要给表起别名

子查询

单行子查询

子查询返回 0 行或 1 行（即至多一行结果）。

1
2
3
4

-- 查询工资高于平均工资的员工
SELECT name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);  -- ← 单行子查询（AVG 返回一个值）

多行子查询

• 必须配合多行操作符使用

常用操作符：

• IN：等于列表中任意一个值
• NOT IN：不等于列表中所有值
• ANY / SOME：与子查询结果中的任意一个比较为真即满足
• ALL：与子查询结果中的所有值比较都为真才满足

1
2
3
4
5
6
7

-- 查询工资高于“任一”经理工资的员工
SELECT name, salary
FROM employees
WHERE salary > ANY (
    SELECT salary FROM employees WHERE job_title = '经理'
);
-- 等价于：salary > (子查询中最小的经理工资)

多列子查询

返回多个列数据的子查询语句。

1
2
3
4
5
6
7
8

-- 高薪岗位定义：salary > 10000 的 (dept_id, job_title) 组合
SELECT name, dept_id, job_title
FROM employees
WHERE (dept_id, job_title) IN (
    SELECT dept_id, job_title
    FROM employees
    WHERE salary > 10000
);

数据库会把 (col1, col2) 视为一个逻辑元组（tuple） 进行匹配。

表复制

只复制表结构

1

CREATE TABLE new_table LIKE old_table;

复制全部数据

1
2

CREATE TABLE new_table AS
SELECT * FROM old_table;

合并查询

“合并查询”在 SQL 中通常指将多个查询结果集纵向拼接为一个结果集，核心语法是 UNION、UNION ALL、INTERSECT、EXCEPT（或 MINUS）。下面以标准 SQL 为主，结合主流数据库（MySQL / PostgreSQL / Oracle / SQL Server）差异，系统讲解：

✅ 一、核心操作符对比

🔔 MySQL 不支持 INTERSECT 和 EXCEPT，需用 INNER JOIN / NOT EXISTS 模拟（后文给出方案）。

二、UNION 与 UNION ALL

基本规则

1. 列数必须相同；
2. 对应列数据类型需兼容（如 INT + VARCHAR 可能隐式转换）；
3. 结果集列名取自第一个查询；
4. 每个 SELECT 可独立使用 WHERE、GROUP BY、HAVING，但不能单独用 ORDER BY（除非加括号+LIMIT）。

示例：合并销售数据（按季度分表）

1
2
3
4
5
6
7
8
9
10
11
12

-- 合并 Q1、Q2 销售记录，去重（如避免重复录入）
SELECT product, amount, 'Q1' AS quarter
FROM sales_q1
WHERE amount > 1000

UNION  -- ← 自动去重 + 排序

SELECT product, amount, 'Q2'
FROM sales_q2
WHERE amount > 1000

ORDER BY amount DESC;  -- 全局排序

UNION ALL 高性能场景

1
2
3
4
5
6

-- 日志按天分表，合并最近3天（无需去重）
SELECT * FROM log_20251206
UNION ALL
SELECT * FROM log_20251207
UNION ALL
SELECT * FROM log_20251208;

• ⚡ 比 UNION 快 5~10 倍（省去排序+去重开销）；
• 适合：分区表合并、ETL 临时表整合、大数据分析。

✅ 三、交集 INNER JOIN 或 IN

1
2
3
4
5
6
7
8

-- 方案1：INNER JOIN（推荐，性能好）
SELECT v.user_id
FROM vip_users v
INNER JOIN active_users a ON v.user_id = a.user_id;

-- 方案2：IN + 子查询
SELECT user_id FROM vip_users
WHERE user_id IN (SELECT user_id FROM active_users);

四、差集 NOT EXISTS

1
2
3
4
5

SELECT r.user_id
FROM registered_users r
WHERE NOT EXISTS (
    SELECT 1 FROM orders o WHERE o.user_id = r.user_id
);

避免用 NOT IN（若 orders.user_id 含 NULL，结果为空！）

✅ 五、高级技巧与注意事项

1️ 为每个来源打标签

1
2
3
4

SELECT name, email, 'internal' AS source FROM employees
UNION ALL
SELECT name, email, 'external' FROM partners
ORDER BY source, name;

2️ 处理列类型不一致

1
2
3
4
5
6
7
8
9

-- 错误：INT vs VARCHAR
SELECT id FROM table1
UNION
SELECT name FROM table2;  --  可能报错或隐式转换失败

-- 正确：显式转换
SELECT CAST(id AS CHAR) FROM table1
UNION
SELECT name FROM table2;

3️ 子查询中使用 UNION

1
2
3
4
5
6
7

SELECT *
FROM (
    SELECT id, name FROM students
    UNION ALL
    SELECT id, name FROM teachers
) AS all_people
WHERE name LIKE '张%';

4️ ORDER BY 限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

--  错误：不能在中间 SELECT 加 ORDER BY
SELECT * FROM t1 ORDER BY id
UNION ALL
SELECT * FROM t2;

--  正确1：全局排序
(SELECT * FROM t1)
UNION ALL
(SELECT * FROM t2)
ORDER BY id;

--  正确2：各子查询排序+LIMIT（需括号）
(SELECT * FROM t1 ORDER BY id LIMIT 5)
UNION ALL
(SELECT * FROM t2 ORDER BY id DESC LIMIT 5);

六、性能优化建议

约束

主键

1. 主键列的值不能重复 PRIMARY KEY
2. 值不能为NULL
3. 可以复合，但必须唯一
4. DESC 会显示主键

UNIQUE

被添加的值不能重复

外键

1

FOREIGN KEY (外键) REFERENCES table (属性)

1. 外键类型与主键要一致
2. 外键指向主键或UNIQUE
3. 外键字段的值，必须出现在主键中，或为空
4. 建立主外键关系后，数据不能随意删除

check

MySQL5.7不支持，只做语法校验

自增长

AUTO_INSERT

• 自增长默认从1开始，但可修改
• 通常搭配主键或UNIQUE

索引

MySQL 索引底层结构：B+ 树

MySQL 默认（InnoDB 引擎）使用 B+ 树（B+ Tree） 实现索引，不是哈希，也不是普通二叉树。

B+ 树特点（InnoDB）：

示意图简化版：

1
2
3
4
5

              [20, 50]               ← 根节点（内存中常驻）
             /    |    \
    [5,10,15]  [25,30,40]  [55,60,70]   ← 非叶子节点
     / | | \     / | | \      / | | \
[1..5]...[15..20] ... [70..∞]           ← 叶子节点（存数据或主键），双向链表连接

知识点：

• 一次查询 = 树的高度次磁盘 IO（例如 3 层 → 3 次 IO）；
• 全表扫描 = 扫所有叶子节点（数据页）；
• 范围查询（如 WHERE id BETWEEN 10 AND 30）只需在叶子节点链表上顺序遍历，效率高。

MySQL 索引类型（按存储 & 逻辑分）

1️ 按存储结构分（InnoDB 引擎）

举例（表：users(id PK, name, age)）

• 聚簇索引：按 id 组织数据页 → 查 WHERE id=100 → 1 次 IO 直接得数据。
• 二级索引 idx_name (name)：
  • 叶子节点存 (name, id)；
  • 查 WHERE name='Alice' → 先在 idx_name 找到 'Alice', id=500 → 再用 id=500 回表查聚簇索引 → 2 次 IO（即“回表”）。

优化技巧：覆盖索引（Covering Index）
如果查询的列全部包含在索引中，就无需回表！

1 2 3 4 5

-- 创建联合索引 (name, age) CREATE INDEX idx_name_age ON users(name, age); -- 查询只涉及 name 和 age → 直接从索引取数据，不回表！ SELECT name, age FROM users WHERE name = 'Alice';

2️ 按逻辑功能分（常用）

联合索引 & 最左前缀原则（面试高频！）

这是高效使用索引的关键！

规则：

对联合索引 (a, b, c)：

• WHERE a = 1 → 用索引
• WHERE a = 1 AND b = 2 → 用索引
• WHERE a = 1 AND b = 2 AND c = 3 → 用索引
• WHERE a = 1 AND c = 3 → 只用到 a（b 跳过，c 无效）
• ❌ WHERE b = 2 → 索引失效
• ❌ WHERE c = 3 → 索引失效
• WHERE a = 1 AND b > 2 AND c = 3 → 用到 a, b（c 无法用，因 b 是范围查询）

原理：B+ 树先按 a 排序，a 相同再按 b，再按 c。
就像字典：先按首字母（a），再按第二字母（b）…… 要查“apple”，必须从 ‘a’ 开始；若直接查“pple”，无法定位。

正确建联合索引顺序：

1
2
3
4
5
6
7
8

-- 查询常为：WHERE status = 'active' AND create_time > '2024-01-01' ORDER BY user_id
--  好顺序：(status, create_time, user_id)
-- 理由：
--   status = 常量 → 精准定位
--   create_time > 范围 → 可继续用索引范围扫描
--   user_id → 用于 ORDER BY，避免 filesort

CREATE INDEX idx_status_time_user ON orders(status, create_time, user_id);

如何判断索引是否生效？——EXPLAIN

这是调试索引的必备工具！

1

EXPLAIN SELECT * FROM users WHERE name = 'Alice';

重点关注字段：

示例：

1
2

EXPLAIN SELECT name, age FROM users WHERE name = 'Alice';
-- 若 key = idx_name_age, Extra = "Using index" → 完美覆盖索引！

索引失效的常见场景（避坑指南！）

索引设计最佳实践（总结清单）

1. 主键首选自增 INT/BIGINT
   → 避免 UUID 乱序插入导致页分裂（如需分布式 ID，用雪花算法 + 前移时间位）。

2. 高频 WHERE / JOIN / ORDER BY 字段建索引
   → 先用 slow query log 或 EXPLAIN 找慢查询。

3. 优先考虑联合索引
   → 避免单列索引过多；按“等值在前，范围在后，排序最后”排序列。

4. 善用覆盖索引
   → SELECT 的列尽量包含在索引中，减少回表。

5. 定期检查无效索引

   1 2	-- MySQL 5.7+：查看未使用的索引（需开启 performance_schema） SELECT * FROM sys.schema_unused_indexes;

   删除不用的索引，提升写性能。

6. 大表加索引用 ALGORITHM=INPLACE（Online DDL）

   1 2 3

   ALTER TABLE users ADD INDEX idx_name (name), ALGORITHM=INPLACE, LOCK=NONE; -- MySQL 5.6+ 支持，不锁表！

7. 监控索引效率

   1	SHOW INDEX FROM users; -- 查看索引 Cardinality（区分度），越高越好

事务

用于保证数据的一致性，要么全部成功，要么全部失败。

概念

场景：用户 A 给用户 B 转账 100 元

1
2
3
4
5

-- 步骤1：A 扣款
UPDATE accounts SET balance = balance - 100 WHERE user = 'A';

-- 步骤2：B 收款
UPDATE accounts SET balance = balance + 100 WHERE user = 'B';

问题：
如果步骤1成功，但步骤2因断电/崩溃失败 → A 少了 100，B 没收到 → 数据不一致！

✅ 事务的使命：把多个操作打包成一个“原子单元”，要么全成功，要么全失败回滚，绝不留半截状态！

1
2
3
4
5
6
7

START TRANSACTION;  -- 开启事务

UPDATE accounts SET balance = balance - 100 WHERE user = 'A';
UPDATE accounts SET balance = balance + 100 WHERE user = 'B';

COMMIT;  -- 全部成功 → 永久生效
-- 或 ROLLBACK; -- 任一失败 → 撤销所有修改

设置保存点

1
2

SAVEPOINT A
ROLLBACK A (不具体指向默认回退到初始点)

事务的四大特性：ACID

关键理解：

• ACID 不是 MySQL “发明”的，而是事务的设计目标；
• InnoDB 引擎通过 WAL（Write-Ahead Logging） + Undo/Redo Log 实现 ACID；
• MyISAM 不支持事务！务必用 InnoDB。

事务隔离级别（解决并发问题）

多个事务同时操作数据，可能引发 3 类经典问题：

MySQL 的 4 种隔离级别（InnoDB 默认：REPEATABLE READ）

🔍 重点：InnoDB 的 RR 级别如何防止幻读？

• 快照读（普通 SELECT）：通过 MVCC 读事务开始时的一致性视图，天然无幻读；
• 当前读（SELECT … FOR UPDATE / LOCK IN SHARE MODE / UPDATE / DELETE）：通过 Next-Key Lock（锁住记录 + 前后间隙）防止新记录插入。

1
2
3
4

-- 当前读示例：防止别人在 (100, 200) 之间插新订单
SELECT * FROM orders 
WHERE amount > 100 AND amount < 200 
FOR UPDATE;  -- 加 Next-Key Lock

事务控制语句（实战语法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

-- 1. 开启事务（显式）
START TRANSACTION;
-- 或
BEGIN;

-- 2. 执行 SQL（DML：INSERT/UPDATE/DELETE）
UPDATE accounts SET balance = balance - 100 WHERE user = 'A';
INSERT INTO transfers (from_user, to_user, amount) VALUES ('A', 'B', 100);

-- 3. 提交 or 回滚
COMMIT;      -- 永久生效
-- ROLLBACK; -- 撤销所有修改（到 START TRANSACTION 之前）

-- 4. 设置保存点（部分回滚）
SAVEPOINT sp1;
UPDATE ...;
ROLLBACK TO sp1;  -- 只回滚到 sp1，之前的操作仍保留

注意：

• DDL（如 CREATE TABLE）、LOCK TABLES 会隐式提交当前事务；
• 客户端自动提交模式：

  1 2	SELECT @@autocommit; -- 1=开启（每条 SQL 自动 COMMIT），0=关闭 SET autocommit = 0; -- 关闭自动提交，需手动 COMMIT

InnoDB 事务实现原理（深入理解）

核心组件：

事务执行流程（简化）：

1. START TRANSACTION → 生成 Read View；
2. 执行 UPDATE →
   • 修改 Buffer Pool 中的数据页；
   • 写 Undo Log（旧值）；
   • 写 Redo Log Buffer（新值）；
3. COMMIT →
   • Redo Log Buffer 刷盘（fsync）→ 事务持久化；
   • 释放锁；
4. 后台线程异步刷脏页到磁盘。

崩溃恢复：重启时，InnoDB 用 Redo Log 重做已提交事务，用 Undo Log 回滚未提交事务。

事务使用最佳实践 & 常见误区

推荐做法：

常见错误：

如何监控事务？

1
2
3
4
5
6
7
8
9

-- 1. 查看当前运行的事务（重点关注 trx_state, trx_started）
SELECT * FROM information_schema.INNODB_TRX;

-- 2. 查看锁等待
SELECT * FROM sys.innodb_lock_waits;

-- 3. 查看长事务（运行超过 60 秒）
SELECT * FROM information_schema.INNODB_TRX 
WHERE TIME_TO_SEC(TIMEDIFF(NOW(), trx_started)) > 60;

存储引擎

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

SHOW ENGINES

mysql> SHOW ENGINES;
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
| Engine             | Support | Comment                                                        | Transactions | XA   | Savepoints |
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
| InnoDB             | DEFAULT | Supports transactions, row-level locking, and foreign keys     | YES          | YES  | YES        |
| MRG_MYISAM         | YES     | Collection of identical MyISAM tables                          | NO           | NO   | NO         |
| MEMORY             | YES     | Hash based, stored in memory, useful for temporary tables     | NO           | NO   | NO         |
| BLACKHOLE          | YES     | /dev/null storage engine (anything you write to it disappears)| NO           | NO   | NO         |
| MyISAM             | YES     | Non-transactional engine with good read performance            | NO           | NO   | NO         |
| CSV                | YES     | CSV storage engine                                             | NO           | NO   | NO         |
| ARCHIVE            | YES     | Compression-focused storage engine for archival data           | NO           | NO   | NO         |
| PERFORMANCE_SCHEMA | YES     | Performance Schema                                             | NO           | NO   | NO         |
| FEDERATED          | NO      | Federated MySQL storage engine (not available in 8.0+)        | NULL         | NULL | NULL       |
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+

• Support：DEFAULT = 默认引擎；YES = 支持但非默认；NO = 编译支持但禁用；DISABLED = 不支持
• Transactions：是否支持事务（YES = 事务安全型；NO = 非事务安全型）
• XA：是否支持分布式事务（XA 协议）
• Savepoints：是否支持保存点（SAVEPOINT / ROLLBACK TO）

事务安全型

InnoDB（MySQL 5.5+ 默认引擎）

非事务安全型

如何查看/设置表的存储引擎？

1. 查看某张表的引擎：

1
2
3
4

SHOW CREATE TABLE users;  -- 看 CREATE 语句末尾的 ENGINE=...
-- 或
SELECT ENGINE FROM information_schema.TABLES 
WHERE TABLE_SCHEMA = 'your_db' AND TABLE_NAME = 'users';

2. 建表时指定引擎：

1
2
3
4

CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    amount DECIMAL(10,2)
) ENGINE = InnoDB;  -- 显式指定（推荐）

3. 修改已有表的引擎（谨慎！大数据量会锁表）：

1
2

ALTER TABLE old_myisam_table ENGINE = InnoDB;
-- ⚠️ 大表建议用 pt-online-schema-change 工具在线转换

选择存储引擎决策树

1
2
3
4
5
6
7
8
9
10
11
12

graph TD
    A[需要事务/外键/崩溃恢复？] 
    -->|是| B[选 InnoDB]
    A -->|否| C{主要是读？写很少？}
    C -->|是| D{需要极快 COUNT* 或全文检索（旧版）？}
    D -->|是| E[考虑 MyISAM]
    D -->|否| F{数据临时/内存足够？}
    F -->|是| G[MEMORY]
    F -->|否| H{只追加不更新？需高压缩？}
    H -->|是| I[ARCHIVE]
    H -->|否| J[仍推荐 InnoDB]
    C -->|否（高并发写）| B

终极建议：
除非有非常明确的特殊需求（如 MEMORY 做缓存），否则一律用 InnoDB！
它是 MySQL 社区和官方持续优化的重点，功能、稳定性、性能综合最佳。

附：InnoDB vs MyISAM 关键对比表

前言

在学习Spring Boot时了解到这是一个整合Web/持久层(持久层框架（如MyBatis/Hibernate）属于数据访问层组件，与Web框架是协作关系而非包含关系。)的全栈框架，但对于各种框架的含义仍缺乏了解，故在此系统梳理一下。

框架

定义

Java Web框架是封装好的专为构建Web应用的代码骨架，为开发者提供标准化的开发基础。在框架中预先写好了许多基础或底层功能，让开发者可以在开发时避免在这些琐碎的方面浪费时间，专心于业务逻辑和核心代码构建。

核心功能

1.提升开发效率。 框架可以通过调用接口等方式自动化处理如数据库操作、HTTP请求解析等重复性任务。

2.生态整合。 一些框架会集成数据库、缓存、消息队列等第三方组件，不需要开发者进行二次引入(SpringBoot自带Tomcat)。

3.提高维护性。 模块化设计降低代码耦合度，便于后期扩展。

分类

架构风格分类

1. 传统 MVC 框架

• 代表框架： Spring MVC, Struts2 (已过时)
• 特点： 基于 Servlet 规范，采用同步阻塞 I/O 模型。严格遵循 Model-View-Controller 分层设计，强调职责分离。通常配合 JSP、Thymeleaf 等模板引擎进行服务端渲染 (SSR)。
• 适用于： 传统的企业级单体应用、后台管理系统、SEO 友好的门户网站。

2. 微框架 (Micro-frameworks)

• 代表框架： Javalin, Spark Java, Blade
• 特点： 极简设计 (核心库往往 <1MB)，不强制特定的项目结构。去除了复杂的依赖注入和繁重的配置，专注于提供轻量级的 HTTP 路由和 API 处理。
• 适用于： 轻量级微服务、简单的 RESTful API、原型快速开发、教学演示。

3. 云原生框架 (Cloud-Native)

• 代表框架： Quarkus, Micronaut, Helidon
• 特点： “为云而生”。通过编译时依赖注入 (Compile-time DI) 和 AOT (Ahead-of-Time) 预编译技术，显著减少内存占用和启动时间。完美适配 Kubernetes 环境，且对 GraalVM 原生镜像有极佳支持。
• 适用于： Serverless (无服务器架构)、高密度部署的容器化微服务、对启动速度和内存有严格要求的场景 (如 AWS Lambda)。

4. 响应式框架 (Reactive)

• 代表框架： Spring WebFlux, Vert.x
• 特点： 基于 Netty 等非阻塞服务器，采用异步非阻塞 I/O 模型和事件驱动架构。能够以少量的线程处理极高的并发请求，背压 (Backpressure) 机制保证系统稳定性。
• 适用于： 高并发系统 (如网关、社交 IM)、I/O 密集型应用、实时数据流处理。

按部署形态分类

1. 嵌入式服务器框架

• 代表： Spring Boot
• 形态： 内嵌 Tomcat/Jetty/Undertow(4里取消支持Undertow了，不知道未来会不会支持，先插个眼) 容器。
• 特点： 打包为可执行的 Fat JAR，java -jar 即可运行，不再依赖外部 Web 容器。
• 性能： 启动时间通常在 1-5 秒，开发体验极佳。

2. GraalVM 原生框架

• 代表： Quarkus Native, Micronaut Native
• 形态： 经 GraalVM 编译为本地机器码 (Binary)。
• 特点： 启动速度极快 (<50ms)，内存占用极低 (<30MB)，但构建 (Build) 时间较长，且反射机制受限。
• 性能： “冷启动”几乎消失，非常适合 Serverless。

3. 传统 WAR 部署框架

• 代表： JSF + WebLogic/JBoss
• 形态： 打包为 WAR 文件，需部署到独立的外部应用服务器中。
• 特点： 配置繁琐，依赖服务器环境，且应用服务器本身启动沉重。
• 现状： 主要存在于遗留系统 (Legacy Systems) 中，新项目已很少采用。

引入

之前跟着教程做了web后端的项目，打算找个时间上线运营培养经验，不过因为域名的问题一直拖着没做。

但在学习网络安全时，老师提了一句：“为什么不用MD5加密，因为它已经被破解了”，一句话让我的困意瞬间消失。因为我的加密就是用MD5。

MD5为什么不能用

MD5的加密逻辑

将输入数据扩展为 512 位的整数倍，用四个 32 位的十六进制整数作为初始链接变量进行四轮循环运算，每轮循环包含 16 次操作，共 64 步。每轮循环结束后，将当前链接变量 A、B、C、D 分别加上临时变量 a、b、c、d。最终，将四个链接变量级联，得到 128 位的 MD5 哈希值。

缺点

1.计算太快

对于选择的电脑的性能，MD5的计算量太少，攻击者可以轻松通过计算进行解密。

2.被证明过不安全

王小云研究团队发现了MD5国际密码算法存在漏洞，被证实MD5并不安全。

选择SpringSecurity的原因

优势

1.导入便捷

SpringSecurity 对于 SpringBoot 项目来说几乎是“标配安全框架”，只需要在pom.xml文件中加入配置就可以进行使用。

2.自带BCrypt，加密安全

BCrypt是慢哈希函数，适合存储密码，带 salt，不可逆，抗暴力破解。

3.内置认证 + 授权体系

Security会自己处理：登录验证、过滤器链、会话安全、跨域、csrf、路由权限控制等问题，开发者不需要操心这些方面的问题。

配置和导入

1.依赖

1
2
3
4

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. 配置类

补充：之前没注意Spring2和Spring3的区别

Spring Boot 2.x 配置方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin();
    }
}

作者：刘大华
链接：https://juejin.cn/post/7570191839593332799

来源：稀土掘金

SpringBoot 3 去掉了 WebSecurityConfigurerAdapter，用 Bean 配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/login", "/register").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(login -> login
                .loginPage("/login")
                .permitAll()
            );
        return http.build();
    }
}

如何兼容之前的用户

之前在数据库中存储的密码是MD5加密的，如果直接更新加密方法，会导致之前的用户无法登录。所以需要增加一段逻辑。

用户注册->直接使用SpringSecurity加密。

用户登录->如果使用MD5加密：用MD5验证->更新加密逻辑，将新的数据存入数据库。

为什么要学沙箱

第一次接触这个概念是因为Python的期末大作业，老师让我们写一个python学习的平台。

我想到模仿FreeCodecamp，写一个可以通过程序二次运行python代码的平台。

之前也没有相关的经验，我便将自己的想法发给ai，让它告诉我需要用到什么，也就接触到了沙箱–用于防止别人在执行代码时对程序(或电脑)造成破坏。

概念

沙箱（Sandboxing）是一种用于隔离环境的技术。

用途

沙箱技术通常用于以下几类场景：

• 在线代码运行平台：如 LeetCode、FreeCodeCamp、自建 OJ 系统
• 浏览器隔离：Chrome 的每个 tab 页就是一个沙箱进程
• 移动端应用权限管理：iOS、Android 对 App 的文件访问就是沙箱设计
• 恶意软件分析：将样本放在沙箱中运行，观察行为
• 插件系统：比如浏览器扩展、VSCode 插件，都不能直接访问用户系统
• 安全研究和渗透测试有专门做沙箱业务的公司

这些场景的共同点就是：“运行不可信代码”，而沙箱的职责就是“让它尽量跑得动，但伤不到我”。

分类

根据隔离程度不同，可以粗略分成三类：

1. 语言级沙箱（最轻量）

依赖语言本身的机制进行限制。

• Python 的 ast、受控 namespace
• JavaScript 的 vm2
• Lua 沙箱化 runtime

优点：实现简单，启动快
缺点：很容易被绕过，安全性弱

2. 系统级沙箱（中等级别）

依赖操作系统提供的隔离机制：

• Linux cgroups（限制资源）
• namespace（隔离进程、文件系统、网络）
• seccomp（限制系统调用）
• Docker / LXC（容器）

优点：安全性高、性能好
缺点：实现较复杂，需要系统层面的支持

3. 虚拟化级沙箱（最高隔离）

原来我用过这么久沙箱…

• KVM
• QEMU
• Firecracker（AWS Lambda 用的）
• VirtualBox

优点：隔离性能好
缺点：启动慢、消耗资源大，不适合大量高频的代码执行

实现模板

Java

java.lang.SecurityManager是Java的一个可插拔的安全策略执行器，用于在运行时对敏感操作（如文件读写、网络访问、反射调用、类加载等）进行权限检查。

当某段代码执行特权操作时，JVM 会调用 SecurityManager.checkXXX() 方法（如 checkRead, checkConnect, checkPermission 等），若未授权，则抛出 SecurityException。

虽然“安全管理员多年来一直不是保护客户端 Java 代码的主要手段，也很少用于保护服务器端代码，并且维护成本很高。”（官方回复），导致这个类在JDK17后被淘汰了，但作为新手去学习依旧足够了。

Python

目前还在写(前文提到的)，先插个眼

TODO

一些开源的沙盒项目

https://github.com/sandboxie-plus/Sandboxie Sandboxie 允许您创建几乎无限的沙箱并单独或同时运行它们，以将程序与主机隔离并相互隔离，同时还允许您在单个盒子中同时运行任意数量的程序。

https://github.com/alibaba/jvm-sandbox
JVM-SANDBOX（沙箱）实现了一种在不重启、不侵入目标JVM应用的AOP解决方案。

起因

在我的项目中，用户注册后会获得默认头像。虽然后续可以自行更改，但未免太过单调。于是我便想起注册GitHub时，会根据用户的名称自动生成一个头像，还不用担心版权问题。于是我在项目中引入了头像生成工具，测试成功后分享给大家。

Dicebear

简介

Dicebear 是一个开源的头像生成服务，支持 SVG、PNG 等多种格式。
它的特色是：风格丰富、可定制项多、无需复杂后端即可直接使用。无论是像素风、卡通风，还是圆形首字母，都能一键生成。

更重要的是，Dicebear 是 MIT License，使用范围宽松，不存在版权风险。

导入

1. 直接请求 API（最简单）

1

https://api.dicebear.com/7.x/{style}/svg?seed={text}

例如：

https://api.dicebear.com/7.x/bottts/svg?seed=darkyellowcat

返回的就是一个 SVG 头像。

2. NPM 包

1

npm install @dicebear/core @dicebear/bottts

示例：

1
2
3
4
5
6
7
8

import { createAvatar } from '@dicebear/core';
import { bottts } from '@dicebear/bottts';

const avatar = createAvatar(bottts, {
  seed: 'darkyellowcat'
});

const svg = avatar.toString();

功能

支持十几种风格（像素、商务、卡通、漫画…）

支持通过 seed 保证「同名用户头像固定」

提供性别随机化、配色方案、表情样式等配置

可直接返回 SVG 或 PNG

CDN 快速访问，不占用自己服务器

ui-avatars

简介

ui-avatars是一个简单、轻量的姓名首字母头像生成工具。（GMail的用户头像就是单字母）

它不支持复杂的风格，但胜在简单、稳定、无需依赖库，访问速度快。

导入

只需直接请求 API：

1

https://ui-avatars.com/api/?name={Name}&background=random

例如：

1

https://ui-avatars.com/api/?name=Dark+Bird&background=random

返回的是 PNG 图片。

功能

不需要 seed，直接根据名称生成

配置参数简单易懂

轻量、稳定、无额外依赖

不会出现风格过于跳脱的问题

对比

ui-avatars相较而言功能较少，仅通过名称生成首字母头像，风格和种类较少。

但风格单一换来的是，它几乎不需要学习成本，且更加轻量级，适合喜欢简约风或轻量化配置的用户。

当然，你也可以在配置中同时引入两种工具，根据情况选用。

GitHub仓库：https://github.com/redis/redis

可以试试deepwiki读取GitHub仓库：https://deepwiki.com/redis/redis

在线测试：https://redis.io/try/sandbox/

官网：https://redis.io/

NoSQL

Redis是一种NoSQL类型的数据库

• 1-Maven介绍
  • 1.1 Maven两大功能
    • 1.1.1 项目构建
    • 1.1.2依赖管理
• 2-Maven仓库
  • 2.1 本地仓库
  • 2.2 远程仓库
    • 2.2.1 中央仓库
    • 2.2.2 私服仓库
    • 2.3 替换仓库至阿里云
• 3-核心文件pom.xml
  • 3.1 示例文件
  • 3.2 Maven坐标
• 4-三大生命周期
  • 4.1 clean清理项目
  • 4.2 defalut项目构建
  • 4.3 site生成文档
• 5-依赖管理
  • 5.1流程
  • 5.2依赖传递
    • 5.2.1 直接依赖和间接依赖
    • 5.2.2 影响
    • 5.2.3 依赖冲突
• 6-插件
  • 6.1 功能
  • 6.2 绑定方式
• 补充：

1-Maven介绍

1.1 Maven两大功能

1.1.1 项目构建

Maven构建项目特点：

Maven可以将传统的项目构建标准化，每个阶段用一个命令完成。

1、Clean 生命周期：

clean：删除目标目录中的编译输出文件。这通常是在构建之前执行的，以确保项目从一个干净的状态开始。

2、Default 生命周期（也称为 Build 生命周期）：

validate：验证项目的正确性，例如检查项目的版本是否正确。

compile：编译项目的源代码。

test：运行项目的单元测试。

package：将编译后的代码打包成可分发的格式，例如 JAR 或 WAR。

verify：对项目进行额外的检查以确保质量。

install：将项目的构建结果安装到本地 Maven 仓库中，以供其他项目使用。

deploy：将项目的构建结果复制到远程仓库，以供其他开发人员或团队使用。

3、Site 生命周期：

site：生成项目文档和站点信息。

deploy-site：将生成的站点信息发布到远程服务器，以便共享项目文档。

与其他项目构建工具对比

1.Ant:Ant没有依赖管理功能.

2.Gradle：在Maven Apache的基础上引入了基于Groovy的特定领域语言。

1.1.2依赖管理

传统

手动拷贝jar包

1.容易版本冲突；
2.难以寻找；
3.添加麻烦。

Maven

在pom.xml文件中添加jar包坐标，Maven会自动从仓库中下载
1.一步构建；

2.方便管理；

3.支持跨平台。

2-Maven仓库

2.1 本地仓库

本地仓库，在第一次执行 maven 命令的时候才被创建。

运行 Maven 的时候，Maven 所需要的任何构件都是直接从本地仓库获取的。如果本地仓库没有，它会首先尝试从远程仓库下载构件至本地仓库，然后再使用本地仓库的构件。

默认情况下，不管 Linux 还是 Windows，每个用户在自己的用户目录下都有一个路径名为 .m2/repository/ 的仓库目录。

2.2 远程仓库

2.2.1 中央仓库

中央仓库是由 Maven 社区提供的仓库，其中包含了大量常用的库。
https://repo.maven.apache.org/maven2/

2.2.2 私服仓库

局域网架设私有仓库服务器，常用于企业开发。

2.3 替换仓库至阿里云

中央仓库的服务器在国外，国内进行访问下载速度较慢，可以替换为阿里云的镜像仓库。

修改 maven 根目录下的 conf 文件夹中的 settings.xml 文件，在 mirrors 节点上，添加内容如下：

1
2
3
4
5
6

<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>*</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>

如果想使用其它代理仓库，可在 节点中加入对应的仓库使用地址。以使用 spring 代理仓为例：

1
2
3
4
5
6
7
8
9
10

<repository>
  <id>spring</id>
  <url>https://maven.aliyun.com/repository/spring</url>
  <releases>
    <enabled>true</enabled>
  </releases>
  <snapshots>
    <enabled>true</enabled>
  </snapshots>
</repository>

3-核心文件pom.xml

3.1 示例文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!--    Maven模型版本-->
    <modelVersion>4.0.0</modelVersion>
<!--组织标识-->
    <groupId>com.darkyellowcat</groupId>
<!--项目标识-->
    <artifactId>untitled</artifactId>
<!--    版本号-->
    <version>1.0-SNAPSHOT</version>
<!-- 项目依赖-->
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
<!--项目依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
<!--             配置项-->
            <configuration>
                <url>http://localhost:8080/manager/text</url>
                <server>TomcatServer</server>
                <path>/untitled</path>
            </configuration>
        </dependency>
    </dependencies>

</project>

3.2 Maven坐标

Maven通过groupId，artifactId，version三个字段来获取坐标，进而获得jar包。

4-三大生命周期

官网
https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

4.1 clean清理项目

清理项目的临时文件和目录

1.pre-clean 清理前

2.clean

3.post-clean 清理后

命令

1

mvn clean

4.2 defalut项目构建

核心生命周期，负责项目构建和部署的所有核心步骤。

1

mvn validate/compile/test ...

4.3 site生成文档

1

mvn site

pre-site 生成前准备

site 生成项目站点文档

post-site 收尾

site-deploy 部署站点到服务器

5-依赖管理

5.1流程

pom.xml中添加地址 -> 在本地仓库中查找 -> 去远程仓库查找（如果有） -> 去中央仓库下载

5.2依赖传递

5.2.1 直接依赖和间接依赖

如果B使用A，C使用B，那么B是C的直接依赖，C是A的间接依赖。Maven 会自动将间接依赖引入，这种自动处理依赖关系的特性称为传递性依赖(Transitive Dependencies)。

5.2.2 影响

//本图来自菜鸟教程

5.2.3 依赖冲突

如果直接依赖和间接依赖同时包含一个包的不同版本，默认以直接依赖为准。
去除依赖：

1
2
3
4
5
6
7
8

<exclusions>
  <groupId>
    xxx
  </groupId>
  <artifactId>
    xxx
  </artifactId>
</exclusions>

6-插件

6.1 功能

插件用于用于执行特定任务(编译、测试、打包等)，具体实现生命周期对应的功能。

6.2 绑定方式

Maven会为生命周期阶段预绑定插件，同时也支持在pom.xml中自定义绑定

补充：

推荐菜鸟教程，虽然直接点进去看起来有点乱，但知识点很全，也适合做笔记。
https://www.runoob.com/maven

前言

网上关于“MySQL密码正确却无法登录”的解决方案很多，比如跳过权限验证、重置 root 密码、检查插件认证方式等。但在我遇到的问题中，这些方法都不适用——因为根本不是密码错了，而是连错了实例。
这里记录一下我的“乌龙”经历，希望能帮到踩了同样坑的朋友。

正文

情况描述

我在本地安装并配置好 MySQL 后，成功设置了 root 密码，并正常使用了一段时间。
但第二天再次尝试登录时，执行：

1

mysql -u root -p

却出现

1

ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

于是按照网上的教程重置了密码，登录就成功了，我便没有深究。

然而，当我为了修改数据库默认编码（utf8mb4）而编辑 my.ini 文件并重启 MySQL 后，发现之前创建的数据库和表全都不见了！

病因分析

经过反复排查，终于发现问题根源：

我之前退出 MySQL 客户端时，直接关闭了命令行窗口，没有输入 exit 或 \q 正常退出。
第二天执行 mysql -u root -p 时，系统自动启动了一个新的、干净的 MySQL 实例（或连接到了另一个实例），而这个实例的 root 用户密码是空的（或默认值），和我之前配置的实例不是同一个！

更具体地说：

我本地可能同时存在两个 MySQL 服务

解决办法

1. 确认当前连接的是哪个 MySQL 实例

登录后执行：

1

SHOW VARIABLES LIKE 'datadir';

查看数据目录。对比你之前配置的 my.ini 中的 datadir 路径是否一致。

2. 检查 MySQL 服务状态

在 Windows 上：

1
2
3

sc query mysql
# 或
net start

看是否有多个 MySQL 服务在运行（如 MySQL80、MySQL 等）。

在 Linux/macOS 上：

1

ps aux | grep mysqld

3. 确保只启动一个 MySQL 服务

停止所有 MySQL 进程(把不是你需要的服务删除了)，然后手动启动你配置过的那个实例：

Windows（以管理员身份）

1
2

net stop MySQL80
mysqld --defaults-file="C:\path\to\my.ini"

4. 使用明确的连接方式

如果你有多个实例，建议通过指定端口或 socket 连接：

1

mysql -u root -p -P 3306 --protocol=tcp

5. 避免“直接关窗口”

虽然直接关闭命令行通常不会导致数据丢失，
但介于我糟心的体验，还是建议养成输入 exit 退出的习惯。

bb

如果所有方法试过之后都不好用，重装可以解决你的一切烦恼(记得备份数据)。