大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

DDD记账软件实战二

经过一开始的战略设计和战术设计以后，我们有了一个初步的服务划分

• 用户服务：管理用户相关的信息
• 记账服务：管理账本和收支相关的信息

并且，我们已经知道了我们要创建一个什么样的目录结构，每个服务的目录如下：

• starter: 接口层，包括HTTP接口、队列的消费者、DTO、启动类
• api: 接口层，提供RPC接口，包括外部RPC接口需要使用的DTO、枚举等
• application：应用服务层，放应用服务，负责编排领域服务、聚合根等。
• domain：领域服务层，放领域相关的一切信息，领域服务负责编排聚合根，聚合根负责完成自身的业务逻辑。
• infrastructure: 基础设施层，放配置、仓储、工厂、对外部的请求、发送MQ消息等。
• common: 放一些公共信息。

我们这个整体架构图如下：

除了我们一开始划分好的两个服务以外，还有一些支撑服务，属于不管干啥都需要用到的。

创建用户服务

首先，我们要创建一个spring项目。可以直接使用start.spring.io来创建。

我们选择的是

• java
• maven
• 3.5.4版本
• java21
• Jar

接下来输入一些基础信息就可以了。

点击下面的generate就可以把项目代码下载下来了。

下载下来以后，我们需要调整maven文件和目录结构。

最外层的maven文件内容如下，我们主要引入了下面的一些依赖

• spring cloud
• nacos: 配置管理和服务注册发现
• mysql
• mybatis plus
• jwt
• lombok

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.5.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zt.bookkeeping.user</groupId>
	<artifactId>user</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>pom</packaging>
	<name>user</name>
	<description>记账软件用户服务</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>21</java.version>
		<spring-cloud.version>2025.0.0</spring-cloud.version>
		<spring-cloud-alibaba.version>2023.0.3.2</spring-cloud-alibaba.version>
		<project.version>0.0.1-SNAPSHOT</project.version>
	</properties>

	<modules>
		<module>user-domain</module>
		<module>user-application</module>
		<module>user-infrastructure</module>
		<module>user-starter</module>
		<module>user-common</module>
	</modules>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>

			<!-- 添加Spring Cloud Alibaba依赖管理 -->
			<dependency>
				<groupId>com.alibaba.cloud</groupId>
				<artifactId>spring-cloud-alibaba-dependencies</artifactId>
				<version>${spring-cloud-alibaba.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>

			<!-- 内部模块依赖管理 -->
			<dependency>
				<groupId>com.zt.bookkeeping.user</groupId>
				<artifactId>user-domain</artifactId>
				<version>${project.version}</version>
			</dependency>
			<dependency>
				<groupId>com.zt.bookkeeping.user</groupId>
				<artifactId>user-application</artifactId>
				<version>${project.version}</version>
			</dependency>
			<dependency>
				<groupId>com.zt.bookkeeping.user</groupId>
				<artifactId>user-infrastructure</artifactId>
				<version>${project.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

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

		<!-- 添加Nacos服务发现依赖 -->
		<dependency>
			<groupId>com.alibaba.cloud</groupId>
			<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
		</dependency>

		<!-- 添加Nacos配置管理依赖 -->
		<dependency>
			<groupId>com.alibaba.cloud</groupId>
			<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
		</dependency>

		<!-- 添加bootstrap配置支持 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-bootstrap</artifactId>
		</dependency>

		<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
			<version>3.5.6</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.30</version>
		</dependency>

		<!-- 引入jwt-->
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-api</artifactId>
			<version>0.11.2</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-impl</artifactId>
			<version>0.11.2</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-jackson</artifactId>
			<version>0.11.2</version>
			<scope>runtime</scope>
		</dependency>
	</dependencies>

</project>

调整了目录结构，整体目录如下图

我们首先复制一份代码放到目录下面并改名为user-starter。然后修改maven文件如下：

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
42
43
44
45
46
47
48
49
50
51

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.zt.bookkeeping.user</groupId>
		<artifactId>user</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>user-starter</artifactId>
	<packaging>jar</packaging>
	<name>user-starter</name>
	<description>用户服务启动模块</description>

	<dependencies>
		<!-- 依赖应用层 -->
		<dependency>
			<groupId>com.zt.bookkeeping.user</groupId>
			<artifactId>user-application</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

接下来用同样的方法复制出应用服务层。改名user-application.修改maven文件如下：

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.zt.bookkeeping.user</groupId>
		<artifactId>user</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>user-application</artifactId>
	<packaging>jar</packaging>
	<name>user-application</name>
	<description>用户服务应用层</description>

	<dependencies>
		<!-- 依赖领域层 -->
		<dependency>
			<groupId>com.zt.bookkeeping.user</groupId>
			<artifactId>user-domain</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>jakarta.validation</groupId>
			<artifactId>jakarta.validation-api</artifactId>
		</dependency>
	</dependencies>

</project>

在复制出领域层，改名user-domain。maven文件如下：

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.zt.bookkeeping.user</groupId>
		<artifactId>user</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>user-domain</artifactId>
	<packaging>jar</packaging>
	<name>user-domain</name>
	<description>用户服务领域层</description>

	<dependencies>
		<!-- 依赖common -->
		<dependency>
			<groupId>com.zt.bookkeeping.user</groupId>
			<artifactId>user-common</artifactId>
			<version>0.0.1-SNAPSHOT</version>
			<scope>compile</scope>
		</dependency>
		<!-- 领域层只需要基础的Java依赖，不需要Spring Web -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
	</dependencies>

</project>

继续复制出基础设施层，改名user-infrastructure。maven文件如下：

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.zt.bookkeeping.user</groupId>
		<artifactId>user</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>user-infrastructure</artifactId>
	<packaging>jar</packaging>
	<name>user-infrastructure</name>
	<description>用户服务基础设施层</description>

	<dependencies>
		<!-- 依赖领域层 -->
		<dependency>
			<groupId>com.zt.bookkeeping.user</groupId>
			<artifactId>user-domain</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
			<version>3.5.6</version>
		</dependency>

		<!-- 引入jwt-->
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-api</artifactId>
			<version>0.11.2</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-impl</artifactId>
			<version>0.11.2</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-jackson</artifactId>
			<version>0.11.2</version>
			<scope>runtime</scope>
		</dependency>
	</dependencies>

</project>

最后，复制出common层，即可。maven文件如下：

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.zt.bookkeeping.user</groupId>
		<artifactId>user</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>user-common</artifactId>
	<packaging>jar</packaging>
	<name>user-common</name>
	<description>用户服务公共层</description>

	<dependencies>
	</dependencies>

</project>

设置启动类

我们将启动类放到user-starter下面。内容如下：

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

package com.zt.bookkeeping.user;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class UserApplication {

	private static final Logger logger = LoggerFactory.getLogger(UserApplication.class);

	public static void main(String[] args) {
		SpringApplication.run(UserApplication.class, args);
		logger.info("用户服务启动成功");
	}

}

目录如下图：

接下来启动服务，启动成功，打印出用户服务启动成功。我们就成功创建了DDD结构的用户微服务了。

总结

本次我们梳理了整体的系统架构图，为接下来的工作做了准备，并且带大家从0-1创建了用户微服务。并且改造成了DDD项目的目录结构。

至于剩下的记账微服务。用同样的方式创建即可。遇到问题可以随时在评论区留言～

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

MySQL零基础教程

本教程为零基础教程，零基础小白也可以直接学习，有基础的可以跳到后面的原理篇学习。
基础概念和SQL已经更新完成。

接下来是应用篇，应用篇的内容大致如下图所示。

高阶应用实战

除了常用的增删改查以外，MySQL还有很多的功能。比如CTE、窗口函数这种。再比如一些特性比如视图，触发器等。

这次我们就来看一下对于这些如何使用。

有些功能用好了可以完成很多实际业务需求的。

CTE(common table expressions)

在MySQL中，CTE（Common Table Expressions，公共表表达式）是一种临时的结果集，可以在查询中被引用。CTE通常用于简化复杂的查询，使查询更易于理解和维护。CTE在MySQL 8.0及更高版本中得到了支持。

CTE的主要特点

临时结果集：

• CTE是一个临时的结果集，可以在查询中被引用。它类似于子查询，但更易于阅读和维护。
  简化复杂查询：
• CTE可以将复杂的查询分解为多个简单的部分，使查询更易于理解和维护。
  可重用性：
• CTE可以被多次引用，减少了代码重复，提高了开发效率。
  递归查询：
• CTE支持递归查询，可以用于处理层次结构或递归数据。

使用CTE实现获取每个课程中分数最高的学生信息。

通过WITH语句来声明一个临时表。表名cteSource，表的内容就是最的sid，通过SELECT MAX(sid) FROM enrolled查询出来的结果。字段名叫maxId。

然后在查询语句里面就可以连接cteSource表，然后通过sid = cteSource.maxId 来获取到sid最大的用户信息。

1
2
3
4
5

WITH cteSource (maxId) AS (
    SELECT MAX(sid) FROM enrolled
)
SELECT name FROM student, cteSource
WHERE student.sid = cteSource.maxId

还有一些其他的用法，比如:

1
2
3
4
5
6
7

WITH cte1 (col1) AS (
SELECT 1
),
cte2 (col2) AS (
SELECT 2
)
SELECT * FROM cte1, cte2;

CTE（公共表表达式）使用场景

1. 递归查询（如树形结构）

CTE最常见的场景之一是递归查询，比如组织架构、分类目录、菜单结构等树状数据。例如，查询某个员工的所有下属员工。

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

WITH RECURSIVE subordinates AS (
  SELECT id, name, manager_id
  FROM employees
  WHERE manager_id IS NULL -- 顶层经理

  UNION ALL

  SELECT e.id, e.name, e.manager_id
  FROM employees e
  INNER JOIN subordinates s ON e.manager_id = s.id
)
SELECT * FROM subordinates;

2. 简化复杂查询逻辑，提高可读性

当查询逻辑复杂时，可以将中间结果用CTE分段处理，让SQL更易读。例如，先筛选出某类用户，再基于这些用户做进一步统计。

1
2
3
4
5
6

WITH active_users AS (
  SELECT user_id
  FROM user_logins
  WHERE login_date > CURRENT_DATE - INTERVAL '30 days'
)
SELECT COUNT(*) FROM orders WHERE user_id IN (SELECT user_id FROM active_users);

3. 多次引用中间结果，避免重复计算

如果某个子查询需要被多次引用，CTE可以定义一次，后续多次调用，避免重复书写和计算，提高效率。

1
2
3
4
5
6
7

WITH sales_summary AS (
  SELECT product_id, SUM(amount) AS total_sales
  FROM sales
  GROUP BY product_id
)
SELECT * FROM sales_summary WHERE total_sales > 1000;
-- 也可以在后续多个查询中引用 sales_summary

4. 分步处理数据，逐步细化结果

例如，先计算每个部门的总销售额，再筛选出销售额最高的部门。

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

WITH dept_sales AS (
  SELECT department_id, SUM(sales) AS total_sales
  FROM employees
  GROUP BY department_id
),
top_dept AS (
  SELECT department_id
  FROM dept_sales
  ORDER BY total_sales DESC
  LIMIT 1
)
SELECT * FROM employees WHERE department_id IN (SELECT department_id FROM top_dept);

5. 数据去重和排名

CTE可以配合窗口函数实现数据去重、分组排名等需求。

1
2
3
4
5
6

WITH ranked_orders AS (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY order_date DESC) AS rn
  FROM orders
)
SELECT * FROM ranked_orders WHERE rn = 1;

实战案例

比如我之前的业务。有一个公司表，一个公司合同表，一个公司合同申请表。在后台的公司合同列表里面，要展示最新的申请记录和申请状态。

如果没有CTE的话，我们就需要使用子查询来实现。这对于一个列表来说，性能是很低的。

表结构假设:

• company：公司表，字段如 company_id, company_name 等。
• company_contract：公司合同表，字段如 contract_id, company_id, contract_no 等。
• company_contract_application：公司合同申请表，字段如 application_id, contract_id, apply_time, status 等。

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

SELECT
    c.company_id,
    c.company_name,
    cc.contract_id,
    cc.contract_no,
    cca.application_id,
    cca.apply_time,
    cca.status
FROM company c
JOIN company_contract cc ON c.company_id = cc.company_id
LEFT JOIN company_contract_application cca
    ON cc.contract_id = cca.contract_id
    AND cca.apply_time = (
        SELECT MAX(apply_time)
        FROM company_contract_application
        WHERE contract_id = cc.contract_id
    );

而有了CTE以后，我们可以通过CTE来实现，这样可以提升性能。

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

WITH latest_applications AS (
    SELECT
        application_id,
        contract_id,
        apply_time,
        status,
        ROW_NUMBER() OVER (PARTITION BY contract_id ORDER BY apply_time DESC) AS rn
    FROM company_contract_application
)
SELECT
    c.company_id,
    c.company_name,
    cc.contract_id,
    cc.contract_no,
    la.application_id,
    la.apply_time,
    la.status
FROM company c
JOIN company_contract cc ON c.company_id = cc.company_id
LEFT JOIN latest_applications la ON cc.contract_id = la.contract_id AND la.rn = 1;

窗口函数

窗口函数（Window Function）是SQL标准中的一种功能强大的工具，它允许在查询中对一组行进行计算，而不会像聚合函数那样消除行的个数。窗口函数在MySQL 8.0及更高版本中得到了支持，它们可以用于计算移动平均值、累积和、排名等复杂的分析任务。

窗口函数的主要特点

行级计算：

• 窗口函数在每一行上执行计算，同时可以访问同一组中的其他行。
• 这与聚合函数不同，聚合函数会将多行数据合并为一行。
  分区和排序：
• 窗口函数可以使用PARTITION BY子句将数据分成多个分区，每个分区独立计算。
• 可以使用ORDER BY子句在每个分区内对数据进行排序。
  灵活的范围定义：
• 窗口函数可以定义计算的范围，如当前行的前几行或后几行。
• 使用ROWS或RANGE子句可以指定计算的范围。
  多种功能：
• 窗口函数提供了多种功能，如ROW_NUMBER()、RANK()、DENSE_RANK()、NTILE()、SUM()、AVG()、LEAD()、LAG()等。

ROW_NUMBER和RANK都需要和OVER一起使用。

• ROW_NUMBER(): 显示当前行号
• RANK() : 显示排序后的排名，如果没有排序，都是1
• OVER()
  • PARTITION BY 进行分组
  • GROUP BY 进行分组
  • ORDER BY 排序

实战：获取每个课程中分数最高的学生信息

下面的SQL，在postgresql中执行成功，mysql8执行报错。

首先查询所有课程信息，并按照课程分组，按照分数排序。

1
2
3

SELECT *,
RANK() OVER (PARTITION BY cid ORDER BY grade ASC)
AS rank FROM enrolled

接着搜索上表中分数为1，也就是分数最高的学生。也就是每个课分数最高的学生信息。

1
2
3
4
5
6

SELECT * FROM (
    SELECT *,
    RANK() OVER (PARTITION BY cid
    ORDER BY grade ASC)
    AS rank FROM enrolled) AS ranking
WHERE ranking.rank = 1

视图

在MySQL中，视图（View）是一种虚拟表，其内容由SQL查询定义。视图并不存储实际的数据，而是根据定义的查询动态生成数据。视图可以简化复杂的SQL操作，提供数据的逻辑抽象，并且可以限制对某些数据的访问，从而增强数据的安全性。

MySQL中的视图是虚拟视图，说白了就是一条SQL语句，当查询视图的时候执行SQL语句而已。

除此之外，还有一个东西叫做物化视图，MySQL并没有实现这个东西，物化视图就是一张真的表，而不是一个SQL语句，因此查询效率更好。

视图的主要特点

虚拟表：

• 视图是一个虚拟表，其内容由SQL查询定义。视图本身并不存储数据，而是根据定义的查询动态生成数据。

简化复杂查询：

• 视图可以简化复杂的SQL操作，将复杂的查询逻辑封装起来，使用户可以像查询普通表一样查询视图。

数据抽象：

• 视图提供数据的逻辑抽象，隐藏了底层表的复杂性，使用户可以更直观地访问数据。

安全性：

• 视图可以限制对某些数据的访问，增强数据的安全性。通过视图，用户只能访问视图定义的特定数据，而不能访问底层表的全部数据。

更新限制：

• 视图可以是可更新的，也可以是不可更新的。可更新视图允许用户通过视图插入、更新或删除数据，但需要满足一定的条件。不可更新视图则不允许用户通过视图修改数据。

创建一个视图。下面的语句，创建一个视图，视图名称是sales_employees，内容就是后面的Select语句的结果。当原始表employees变化以后，视图的内容也会跟着变化。

1
2
3
4

CREATE VIEW sales_employees AS
SELECT name, salary
FROM employees
WHERE department = 'Sales';

实战：交易聚合

我之前有一个业务，存在两个表，一个是买单表，代表买方要买一个产品出的价格。一个是卖单表，代表卖方要卖一个产品出的价格。

现在有一个需求是：在C端的一个页面上，要求混合展示买单信息和卖单信息，按照价格从低到高排序

数据库假设：

• buy: 买单表
• sell: 卖单表
• order: 交易视图

1
2
3
4

CREATE VIEW order AS
SELECT *
FROM buy, sell
order by price asc;

触发器

在MySQL中，触发器（Trigger）是一种特殊的存储过程，它在特定的数据库操作（如INSERT、UPDATE、DELETE）发生时自动执行。触发器可以用于实现复杂的业务逻辑，确保数据的完整性和一致性，以及自动维护数据的同步。

触发器的主要特点

自动执行：

• 触发器在特定的数据库操作发生时自动执行，无需显式调用。这使得触发器可以用于实现自动化的数据处理和维护。

数据完整性：

• 触发器可以用于确保数据的完整性和一致性。例如，可以在插入或更新数据时自动检查数据的有效性，或者在删除数据时自动清理相关数据。

业务逻辑：

• 触发器可以用于实现复杂的业务逻辑。例如，可以在插入或更新数据时自动计算某些字段的值，或者在删除数据时自动更新相关表的数据。

数据同步：

• 触发器可以用于自动维护数据的同步。例如，可以在插入或更新数据时自动更新相关表的数据，或者在删除数据时自动清理相关表的数据。

触发器的类型

• BEFORE INSERT：
  • 在插入数据之前执行触发器逻辑。
• AFTER INSERT：
  • 在插入数据之后执行触发器逻辑。
• BEFORE UPDATE：
  • 在更新数据之前执行触发器逻辑。
• AFTER UPDATE：
  • 在更新数据之后执行触发器逻辑。
• BEFORE DELETE：
  • 在删除数据之前执行触发器逻辑。
• AFTER DELETE：
  • 在删除数据之后执行触发器逻辑。

触发器的限制

性能影响：

• 触发器的执行会增加数据库操作的开销，可能会影响性能。因此，应谨慎使用触发器，避免在高频操作的表上定义过多的触发器。
  复杂性：
• 触发器的逻辑可以非常复杂，但过多的复杂逻辑可能导致触发器难以维护和调试。因此，应尽量保持触发器的逻辑简单明了。
  调试困难：
• 触发器的调试相对困难，因为它们在特定的操作发生时自动执行，难以直接观察和调试。因此，建议在开发和测试阶段充分测试触发器的逻辑。

因此，实际开发中基本不使用触发器。

存储过程

在MySQL中，存储过程（Stored Procedure）是一种预编译的SQL语句集合，它存储在数据库中，可以通过调用其名称并传递参数来执行。存储过程可以包含复杂的逻辑和多个SQL语句，用于完成特定的任务。它们类似于其他编程语言中的函数或方法。

可以把存储过程想成一个函数。只不过是在MySQL中的函数，这个函数可以实现各种功能。可以实现一些复杂的SQL处理，这样可以简化调用。

存储过程的主要特点

预编译：

• 存储过程在创建时被预编译并存储在数据库中，这使得它们的执行速度比单独的SQL语句更快。
  代码重用：
• 存储过程可以被多次调用，减少了代码重复，提高了开发效率。
  减少网络流量：
• 存储过程在服务器端执行，减少了客户端和服务器之间的网络流量，因为只需要发送存储过程的名称和参数，而不是大量的SQL语句。
  安全性：
• 存储过程可以限制用户对底层数据的直接访问，只允许通过存储过程进行数据操作，从而增强数据的安全性。
  事务管理：
• 存储过程可以包含事务控制语句，如COMMIT和ROLLBACK，确保数据操作的完整性和一致性。

存储过程的限制

性能影响：

• 存储过程的执行会增加数据库操作的开销，可能会影响性能。因此，应谨慎使用存储过程，避免在高频操作的表上定义过多的存储过程。
  复杂性：
• 存储过程的逻辑可以非常复杂，但过多的复杂逻辑可能导致存储过程难以维护和调试。因此，应尽量保持存储过程的逻辑简单明了。
  调试困难：
• 存储过程的调试相对困难，因为它们在服务器端执行，难以直接观察和调试。因此，建议在开发和测试阶段充分测试存储过程的逻辑。

实战案例

存储过程的实际应用场景有限。

我们之前有一个场景，是需要批量处理数据，有几十行SQL语句。因此将这些SQL封装到了一个存储过程中，这样只需要执行这个存储过程就可以了。

这里给出一个简单的实战案例：

创建一个存储过程get_employee_details，用于根据员工ID获取员工的详细信息：

DELIMITER用来设置结束符，比如正常的句子结束符是句号。代码结束符是分号；

IN代表输入参数，也就是这个函数有一个输入参数emp_id，是int类型。
还有out代表输出参数，用于返回结果。
INOUT代表既可以输入参数也可以是输出参数。

1
2
3
4
5
6
7
8
9
10

DELIMITER //

CREATE PROCEDURE get_employee_details(IN emp_id INT)
BEGIN
    SELECT name, department, salary
    FROM employees
    WHERE id = emp_id;
END //

DELIMITER ;

上面这个存储过程的函数体，就是一段select查询语句。

存储函数

在MySQL中，存储函数（Stored Function）是一种预编译的SQL语句集合，类似于存储过程，但它返回一个值。存储函数可以被SQL语句直接调用，就像调用普通的函数一样。存储函数通常用于封装复杂的逻辑，并在查询中重用这些逻辑。

存储函数同样是一个函数，和上面的存储过程差不多。

存储过程和存储函数的区别

存储函数的主要特点

实战案例

创建一个存储函数get_employee_salary，用于根据员工ID获取员工的薪资：

可以看到和上面存储过程的区别，声明了一个返回值，类型是DECIMAL,最后通过return返回了，并且声明了一个变量。参数也没有IN、OUT这种了。

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

DELIMITER //

CREATE FUNCTION get_employee_salary(emp_id INT)
RETURNS DECIMAL(10, 2)
BEGIN
    DECLARE emp_salary DECIMAL(10, 2);
    SELECT salary INTO emp_salary
    FROM employees
    WHERE id = emp_id;
    RETURN emp_salary;
END //

DELIMITER ;

总结

本次讲解了MySQL的高级功能和实战应用的一些场景。

只有知道了场景才能活学活用。这里面最常用的其实还是CTE和窗口函数。

可以多多练习，希望遇到这些场景的时候，大家能想起来使用这些功能。

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

DDD战术设计代码结构

之前讲过了如何进行领域建模，也就是将真实世界映射到业务领域中。

接下来，看一下如何将业务领域落地到代码实现里面。

只有战略设计和战术设计结合到一起，才能做好DDD，不能只注重领域建模而忽视了代码实现，也不能只注重代码实现而忽视了领域建模。

层次结构

贫血三层架构

一般情况下，我们使用的是贫血三层架构。也就是

• controller：负责接收参数，参数校验，调用service处理业务逻辑。
• service：处理业务逻辑
• Model：和数据库交互，可能是Mybatics。

DDD四层架构

而对于DDD来说，使用的则是经典四层架构。

• 用户接口层：作为程序的入口，controller就属于这一层。
• 应用服务层：负责领域编排，不负责具体的业务逻辑处理。通过调用领域服务层来完成业务逻辑处理。
• 领域服务层：负责具体的业务逻辑处理。可以将service的业务逻辑下沉到这一层，而业务逻辑编排则放到应用服务层。
• 基础设施层：提供一些基础设施，包括数据库持久化，缓存，RPC调用等等。Model就属于这一层。

如果是重构项目的话，可以将三层架构拆解成四层架构，映射关系如下：

用户接口层

用户接口层的命名可以是starter或者是interface等等。

用户接口层的职责就是整个程序的入口，对外部提供接口，包括HTTP接口和RPC接口。

这一层的结构很简单：

• controller: 就是传统的controller
• dto: dto里面包括了请求参数和返回参数
• converter：负责将请求参数转换成应用服务的入参，将应用服务的出参转换成返回参数
• consumer：消费者，负责消费MQ的消息

我们还可以将这一层进一步划分为两个目录，一个是HTTP接口的starter目录，一个是RPC接口的api目录。

因为一般来说rpc会对外部提供一个包。因此可以将这两个分开。

而且对于RPC接口的包来说，consumer这个目录是没有用的，因此，只需要三个目录就可以了。

对于HTTP接口来说，因此请求和返回都是JSON格式的对象，因此，可以省略dto和converter这两个步骤。

应用服务层

应用服务的职责边界很清晰，就是调用领域服务、聚合等完成业务操作。这一层只做服务编排，而不处理具体的业务逻辑。

1. 代码结构

因此，应用服务层的代码结构也很简单，可以放到目录application里面。

• service: 应用服务，应用服务不需要和领域服务一对一的关系，也不需要和controller一对一的关系。根据业务来创建即可。
• dto: 这个里面存放应用服务层的入参和出参。可以根据CQRS规则来设置，创建、修改、删除的入参是Command。查询的入参是Query。
• event：应用服务层的事件发布。

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
35
36

@Service
@Slf4j
public class MobileRegisterApplicationService {

    @Resource
    private UserAggService userAggService;

    @Resource
    private ApplicationEventPublisher eventPublisher;

    @Resource
    private SnowFlakeGenerator snowFlakeGenerator;

    public Long register(MobileRegisterRequest command) {
        // 1. 校验验证码是否正确
        checkVerifyCode(command.getMobile(), command.getCode());

        // 2. 调用用户领域服务 判断能否注册用户
        userAggService.canRegister(command.getMobile());

        // 3. 验证码正确 用户可以注册 生成用户聚合
        UserAgg userAgg = UserAgg.init(command.getMobile(), snowFlakeGenerator.nextId("user"));

        // 4. 调用用户领域服务 注册用户
        userAggService.save(userAgg);

        // 5. 发送注册成功领域事件
        eventPublisher.publishEvent(new UserRegisteredEvent(userAgg.getId(), userAgg.getUsername(), null, LocalDateTime.now()));
        return userAgg.getId();
    }

    private void checkVerifyCode(String mobile, String verifyCode) {
        // 调用RPC接口来校验验证码

    }
}

领域服务层

领域服务层是DDD的核心，所有的业务逻辑都以充血模型的形式放到聚合根、实体、值对象里面。

领域服务层的入参和出参都应该是领域模型。

1. 代码结构

领域服务层的代码结构相对复杂。领域服务层的代码目录首先按照聚合来区分。其次，每个聚合下面有自己的领域模型和领域服务。可以放到目录domain里面。

• 聚合
  • service: 存储领域服务，领域服务的职责是编排聚合。调用聚合来完成业务逻辑。
  • entity：这个目录存储所有的聚合根、实体和值对象。
  • event：存放领域事件
  • repository：存放仓储的接口，仓储的具体实现放在基础设施层。
  • factory：存放工厂的接口，工厂的具体实现放在基础设施层。
  • enums：存放一些领域层使用的枚举
  • gateway：存放一些RPC请求的接口，具体实现放在基础设施层。

2. 代码示例

可以看到领域服务里面调用了Repository来重建聚合，然后判断聚合是否存在来完成校验。

1
2
3
4
5
6
7
8
9

public void canRegister(String mobile) {
    // 根据要注册的手机号获取用户信息
    UserAgg userAgg = userRepository.getUserByMobile(mobile);
    // 校验用户是否存在
    if (userAgg != null) {
        log.warn("用户已存在");
        throw new DomainException(ResultCode.USER_ALREADY_EXISTS);
    }
}

再来看一下判断能否登陆的方法。这里调用的是聚合的方法来校验用户状态，而不是通过领域服务来校验。这就是编排聚合。

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

public void canLogin(UserAgg userAgg) throws UserLoginException {
    // 0. 校验用户存在
    if (userAgg == null) {
        log.warn("用户不存在");
        throw new UserLoginException(ResultCode.USER_NOT_FOUND);
    }

    // 2. 校验用户状态
    if (!userAgg.validateStatus()) {
        log.warn("用户状态错误:{}", userAgg.getUserStatus());
        throw new UserLoginException(ResultCode.USER_STATUS_ERROR);
    }
}

基础设施层

基础设施层为所有层提供基础的技术支持，包括但不限于数据库、缓存、队列、RPC请求、HTTP请求等等。

基础设施层有两个重要的概念

• Repository：仓储，为领域模型提供持久化的功能，入参是领域模型，将领域模型转换成数据模型，在进行持久化。至于是缓存还是数据库，是MySQL还是PostgreSQL，上层并不关心。同时，也负责从持久化中恢复领域模型。
• Factory：工厂，和工厂模式的工厂不同，这里的工厂是负责创建领域模型的。有些领域模型的创建较为复杂，可以封装到工厂里面。

1. 基础设施层的目录

基础设施层的代码结构可以按照职能区分。其中Repository和聚合是一对一的关系，一个聚合有一个Repository负责持久化和恢复。可以放到目录infrastructure里面。

• config: 放置项目的配置文件。
• repository: 放仓储的具体实现类，一个仓储对应一个聚合，负责持久化聚合里面的多个表数据。
• factory: 工厂的具体实现类，负责创建领域模型。
• gateway：放对外部的请求，包括HTTP请求和RPC请求。
• util：放一些工具类
• listener: 放一些领域事件的监听者，有一些领域事件是放到队列中其他服务监听，也有一些领域事件是自己服务监听的。
• producer: 生产者，负责向队列中发送消息

2. 代码示例

以用户聚合对应的用户仓储来看，需要创建用户的时候传入用户聚合。然后转换成数据模型，当插入数据库以后会更新用户聚合的ID。

1
2
3
4
5
6
7

@Override
public void insert(UserAgg userAgg) {
    UserPO userPO = this.toPO(userAgg);
    userMapper.insert(userPO);
    // 回填id
    userAgg.setId(userPO.getId());
}

当需要查询数据的时候，传入查询条件，返回用户聚合。

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

@Override
public UserAgg getUserByMobile(String mobile) {
    // 1. 查询用户信息
    LambdaQueryWrapper<UserPO> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserPO::getMobile, mobile);
    UserPO userPO = userMapper.selectOne(queryWrapper);
    if (userPO == null) {
        return null;
    }

    // 2. 转化成聚合返回
    return this.toEntity(userPO);
}

四层架构之间的依赖关系

四层架构的目录结构已经出来了

• starter: 放置启动类和HTTP请求以及队列的消费者。
• api: 放置RPC接口以及外部需要使用的一些DTO。
• application：应用服务层的代码
• domain: 领域服务层的代码
• infrastructure: 基础设施层的代码
• common: 可以放置一些公共的代码，比如工具类、exception、枚举等。

总的目录结构如下，外层的user代表服务名称，这个是用户服务，也就是用户领域。

用户接口层

• 依赖应用服务层：调用应用服务实现功能。

1
2
3
4

<dependency>
    <groupId>com.zt.bookkeeping.user</groupId>
    <artifactId>user-domain</artifactId>
</dependency>

应用服务层

• 依赖领域服务层：应用服务的职责就是编排领域服务和领域模型。

1
2
3
4
5

<!-- 依赖领域层 -->
<dependency>
    <groupId>com.zt.bookkeeping.user</groupId>
    <artifactId>user-domain</artifactId>
</dependency>

领域服务层

• 什么也不依赖，领域服务层作为最底层的服务，什么也不依赖，如果需要使用基础设施的话，接口定义在领域层，实现放在基础设施层。

基础设施层

• 依赖领域服务层：因为接口要放在领域服务层，实现放在基础设施层

1
2
3
4
5

<!-- 依赖领域层 -->
<dependency>
    <groupId>com.zt.bookkeeping.user</groupId>
    <artifactId>user-domain</artifactId>
</dependency>

整体依赖关系如下：

如何确定代码放在哪一层？

写代码的时候如何确定这个代码该放到哪一层呢？

如果这个代码是负责和外部交互的，那么就放到基础设施层。

如果这个代码包含业务逻辑，那么就放到领域层，将业务逻辑拆分到聚合、实体、值对象中，如果逻辑复杂，就通过领域服务进行编排。

应用层代码只编排领域服务和领域模型。

接口层代码只暴露接口给外部。

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

用 @TypeHandler 做自动转换进阶：MyBatis + 自定义 TypeHandler

之前讲过通过枚举+值对象的方式来构建用户状态和用户类型。

但是每次查询的时候我们都需要手动的将数据库中的1，2，3来映射成值对象。

我们可以使用TypeHandler来实现自动转换，就不需要每次都手动执行了。

场景目标

已经使用了 UserStatus 值对象 + UserStatusEnum 枚举来表达用户状态（如 ACTIVE、FROZEN、DELETED），现在希望：

• 数据库存储 Integer 类型（如：1、2、3）
• MyBatis 能自动将 Integer → UserStatus
• 不再每次手动 UserStatus.of(statusInt) 转换

最佳方案：MyBatis 自定义 @TypeHandler

✅ 1. 项目结构

1
2
3
4
5
6
7
8
9
10
11

domain.model.user
└── UserStatus.java（值对象）
└── UserStatusEnum.java（枚举）

infrastructure.mybatis.typehandler
└── UserStatusTypeHandler.java（自定义 TypeHandler）

infrastructure.repository.mybatis
└── UserMapper.java
└── UserPO.java
└── UserMapper.xml

✅ 2. 代码实现

✅ 值对象：UserStatus（简化版）

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

public class UserStatus {
    private final UserStatusEnum status;

    public static final UserStatus ACTIVE = new UserStatus(UserStatusEnum.ACTIVE);
    public static final UserStatus FROZEN = new UserStatus(UserStatusEnum.FROZEN);
    public static final UserStatus DELETED = new UserStatus(UserStatusEnum.DELETED);

    private UserStatus(UserStatusEnum status) {
        this.status = status;
    }

    public static UserStatus of(int code) {
        return new UserStatus(UserStatusEnum.fromCode(code));
    }

    public int getCode() {
        return status.getCode();
    }

    public UserStatusEnum getStatusEnum() {
        return status;
    }

    @Override
    public boolean equals(Object o) {
        return (o instanceof UserStatus that) && this.status == that.status;
    }

    @Override
    public int hashCode() {
        return status.hashCode();
    }
}

✅ 枚举类：UserStatusEnum

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

public enum UserStatusEnum {
    ACTIVE(1, "启用"),
    FROZEN(2, "冻结"),
    DELETED(3, "注销");

    private final int code;
    private final String label;

    UserStatusEnum(int code, String label) {
        this.code = code;
        this.label = label;
    }

    public int getCode() { return code; }

    public static UserStatusEnum fromCode(int code) {
        for (UserStatusEnum e : values()) {
            if (e.code == code) return e;
        }
        throw new IllegalArgumentException("未知状态码: " + code);
    }
}

✅ 自定义 TypeHandler：UserStatusTypeHandler

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

@MappedJdbcTypes(JdbcType.INTEGER)
@MappedTypes(UserStatus.class)
public class UserStatusTypeHandler extends BaseTypeHandler<UserStatus> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, UserStatus parameter, JdbcType jdbcType) throws SQLException {
        ps.setInt(i, parameter.getCode());
    }

    @Override
    public UserStatus getNullableResult(ResultSet rs, String columnName) throws SQLException {
        int code = rs.getInt(columnName);
        return UserStatus.of(code);
    }

    @Override
    public UserStatus getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        int code = rs.getInt(columnIndex);
        return UserStatus.of(code);
    }

    @Override
    public UserStatus getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        int code = cs.getInt(columnIndex);
        return UserStatus.of(code);
    }
}

✅ 3. PO 层配置 TypeHandler

1
2
3
4
5
6
7
8
9
10
11

public class UserPO {
    private Long id;
    private String username;
    private String passwordHash;

    @TableField(typeHandler = UserStatusTypeHandler.class)
    private UserStatus status;

    // getter/setter
}

如果你用 XML 而不是注解，也可以在 XML 中配置：

1

<result column="status" property="status" typeHandler="com.example.infrastructure.mybatis.typehandler.UserStatusTypeHandler"/>

✅ 4. 注册 TypeHandler（推荐方式）
Spring Boot + MyBatis：
确保你在配置类里添加扫描：

1
2
3
4
5
6
7
8
9
10
11

@MapperScan("com.example.infrastructure.repository.mybatis")
@Configuration
public class MyBatisConfig {
    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> {
            configuration.getTypeHandlerRegistry().register(UserStatusTypeHandler.class);
        };
    }
}

或者：使用 Spring Boot 自动注册（只要包结构正确 + 被 Spring 管理）

✅ 5. 使用效果

现在，MyBatis 自动完成：

• SELECT 时：从 int 字段转成 UserStatus 值对象
• INSERT/UPDATE 时：从 UserStatus 转为 int

你无需手动 .of() 转换，仓储代码更简洁：

1
2
3
4
5
6
7
8

UserPO userPO = mapper.selectByUsername("jack");
User user = new User(
    userPO.getId(),
    userPO.getUsername(),
    userPO.getPasswordHash(),
    userPO.getStatus() // ✅ 直接是 UserStatus
);

总结

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

用户状态（UserStatus） 和 用户类型（UserType） 应该如何在领域模型中表达？

这是一个很有代表性的建模问题：用户状态（UserStatus） 和 用户类型（UserType） 应该如何在领域模型中表达？

✅ 最佳实践结论（DDD 建模角度）：

✅ 建议建模为单独的值对象（Value Object），而不是直接使用 Integer 类型。

接下来分析一下为什么

✅ 原因分析：为什么不用普通的 Integer？

✅ 为什么用值对象更合适？

在 DDD 中，值对象（Value Object）是具有领域语义但无身份标识的对象，适合表达用户的“状态”、“类型”、“级别”等固定枚举值的场景。

它能提供：

✅ 明确的领域语言（如：UserStatus.ACTIVE、UserType.ADMIN）
✅ 不变性（状态是不可变的值对象）
✅ 合法性控制（通过私有构造 + 工厂控制范围）
✅ 方便扩展（可以加业务方法，如 canLogin()）

将用户状态设置为值对象以后，我们能明确的表达状态的含义，是正常、冻结还是封禁等等。且避免了非法值。并且如果要变更的话，是变更整个值对象。

在领域建模中，你可以一下子明白这个实体中这个值的含义。

在DDD中，不要使用传统的数据建模思想，而是要使用领域建模思想。

传统的数据建模思想的话，用户状态存储在数据库中通常都是1,2,3,4这样的Int值。

所以实体中一般也直接使用Int类型的值作为存储。

而领域建模思想则强调将真实世界中的业务映射成领域模型。数据库仅仅是领域模型持久化的一个地方而已。

✅ 示例：建模用户状态为值对象

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
42
43
44
45
46

package com.example.accountbook.domain.model.user;

import java.util.Objects;

public class UserStatus {

    private final int code;

    public static final UserStatus ACTIVE = new UserStatus(1);
    public static final UserStatus FROZEN = new UserStatus(2);
    public static final UserStatus DELETED = new UserStatus(3);

    private UserStatus(int code) {
        this.code = code;
    }

    public static UserStatus of(int code) {
        return switch (code) {
            case 1 -> ACTIVE;
            case 2 -> FROZEN;
            case 3 -> DELETED;
            default -> throw new IllegalArgumentException("非法用户状态: " + code);
        };
    }

    public boolean isActive() {
        return this == ACTIVE;
    }

    public int getCode() {
        return code;
    }

    // equals / hashCode for value object identity

    @Override
    public boolean equals(Object o) {
        return (o instanceof UserStatus that) && this.code == that.code;
    }

    @Override
    public int hashCode() {
        return Objects.hash(code);
    }
}

聚合中使用值对象

1
2
3
4
5
6
7
8
9
10

public class User {
    private Long id;
    private String username;
    private String passwordHash;

    private UserStatus status;  // ✅ 状态是值对象
    private UserType type;      // ✅ 类型是值对象

}

用 enum 枚举 + 值对象混合的高级方案

一般来说，用户状态和用户类型，我们都会创建一个枚举类。因此我们可以使用枚举+值对象的方式来重新构建一下用户状态。

我们现在深入 DDD 实践：用 Enum 枚举 + 值对象（Value Object）混合建模方式 表达如用户状态 / 用户类型，并展示如何在 MyBatis 中映射为字段、在 Repository 中自动转换为领域值对象。

✅ 为什么用「Enum + 值对象」组合建模？

🌟 组合起来，既有类型安全、又有语义表达、也便于持久化。

✅ 枚举类：UserStatusEnum

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

public enum UserStatusEnum {
    ACTIVE(1, "启用"),
    FROZEN(2, "冻结"),
    DELETED(3, "注销");

    private final int code;
    private final String label;

    UserStatusEnum(int code, String label) {
        this.code = code;
        this.label = label;
    }

    public int getCode() {
        return code;
    }

    public static UserStatusEnum fromCode(int code) {
        for (UserStatusEnum status : values()) {
            if (status.code == code) return status;
        }
        throw new IllegalArgumentException("未知状态: " + code);
    }
}

✅ 值对象：UserStatus

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
42
43

public class UserStatus {

    private final UserStatusEnum status;

    private UserStatus(UserStatusEnum status) {
        this.status = status;
    }

    public static UserStatus of(UserStatusEnum status) {
        return new UserStatus(status);
    }

    public static UserStatus of(int code) {
        return new UserStatus(UserStatusEnum.fromCode(code));
    }

    public boolean isActive() {
        return this.status == UserStatusEnum.ACTIVE;
    }

    public int getCode() {
        return this.status.getCode();
    }

    public String getLabel() {
        return this.status.name();
    }

    public UserStatusEnum getStatusEnum() {
        return this.status;
    }

    @Override
    public boolean equals(Object o) {
        return (o instanceof UserStatus that) && this.status == that.status;
    }

    @Override
    public int hashCode() {
        return status.hashCode();
    }
}

✅ MyBatis 持久化对象（PO）：UserPO

1
2
3
4
5
6
7
8

public class UserPO {
    private Long id;
    private String username;
    private String passwordHash;
    private Integer status; // 状态值字段
    // ... 省略 getter/setter
}

✅ Mapper XML 映射

1
2
3
4
5
6
7

<mapper namespace="com.example.repository.mybatis.UserMapper">
    <select id="selectByUsername" resultType="com.example.repository.mybatis.UserPO">
        SELECT id, username, password_hash, status
        FROM users
        WHERE username = #{username}
    </select>
</mapper>

✅ 5. 仓储实现：UserRepositoryImpl → 转换 PO → 聚合

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

@Repository
public class UserRepositoryImpl implements UserRepository {

    private final UserMapper mapper;

    public UserRepositoryImpl(UserMapper mapper) {
        this.mapper = mapper;
    }

    @Override
    public Optional<User> findByUsername(String username) {
        UserPO userPO = mapper.selectByUsername(username);
        return Optional.ofNullable(userPO).map(this::toEntity);
    }

    private User toEntity(UserPO doObj) {
        return new User(
            doObj.getId(),
            doObj.getUsername(),
            doObj.getPasswordHash(),
            UserStatus.of(doObj.getStatus()) // ← 关键转换点
        );
    }
}

✅ 领域聚合实体：User

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

public class User {
    private Long id;
    private String username;
    private String passwordHash;
    private UserStatus status; // 值对象

    public User(Long id, String username, String passwordHash, UserStatus status) {
        this.id = id;
        this.username = username;
        this.passwordHash = passwordHash;
        this.status = status;
    }

    public boolean canLogin() {
        return status.isActive();
    }

    public int getStatusCode() {
        return status.getCode();
    }

    public String getStatusLabel() {
        return status.getLabel();
    }

    // 省略其他 getter...
}

✅ 保存数据时：实体 → PO

1
2
3
4
5
6

UserPO userPO = new UserPO();
userPO.setId(user.getId());
userPO.setUsername(user.getUsername());
userPO.setPasswordHash(user.getPasswordHash());
userPO.setStatus(user.getStatus().getCode()); // ← 值对象 → DB 字段

✅ 总结对比

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

DDD领域驱动设计记账软件实战教程–划分领域和聚合

本文章为实战教程，主要内容包括：

• 从零使用DDD构建一个记账软件

你是否有以下疑问？

• 你是一个DDD软件开发人员，但是只是按照现有的项目去写，如果自己搭建一个新项目就无从下手了？
• 你是一个传统软件开发人员，想使用DDD重构软件，却不知道如何入手？
• 你看过很多DDD的文章，了解DDD概念，却没有一个从头到尾的完整教程，无法把碎片化的知识串起来？

本文章带你从头构建一个完整的DDD项目。由点到面的串联起来所有的知识。达成一个完整的知识图谱。

事件风暴

首先需要进行事件风暴。整理出来所有的命令、业务流和事件。

• 命令：可以简单理解为一些行为。这些命令可以映射成代码模型中的一个个方法。
• 业务流：可以按照场景进行分析业务流，比如对于记账软件来说：记账场景、查账场景就是两个不同的场景，可能有不同的业务流。业务流可以映射成代码模型中的接口。
• 事件：可以简单理解成上面的命令产生的一些事件。会有一些监听者异步监听这些事件并实现一些逻辑。

我们来分析一些记账场景会有哪些业务流。

首先用户需要注册登陆。因此我们可以识别出注册业务流和登陆业务流。继而识别出注册命令和登陆命令。

对于登陆业务流中来说，除了登陆命令，还可以有查询用户、校验用户信息、生成token等命令。这些命令共同完成了一次登陆业务流。

此外，还会产生对应的事件。比如用户已注册事件、已登陆事件等。

对于已注册事件，我们可以发送注册成功的消息提醒。还可以参与注册活动等。

对于已登陆事件，我们可以写入登陆成功日志，发送登陆成功消息提醒等。

登陆成功以后，首先需要创建一个账本。接下来可以更新账本信息。更新预算。设置角色信息。然后就可以添加收支记录在账本上了。

DDD领域其实是现实世界的映射。这里我们要思考现实世界的记账是怎么样的。
现实世界需要一个账本、需要记录收支信息、账本的最上方可能会写上本月的预算。记录收支信息的时候会写上分类、角色、金额等信息。

在这里我仅仅分析了记账场景的业务流。其实还有查账场景的业务流。此外还有一些其他的通用业务流。比如监控，数据统计等。

大家可以自己分析一下将结果发到评论区。我会一一回复的。

纸上得来终觉浅，绝知此事要躬行

领域建模

当我们分析完所有的命令、事件以后。我们就可以根据上面分析出来的这些进行领域建模了。通过这些我们可以分析出领域对象。

比如，登陆注册行为是围绕用户领域对象来完成的行为。写入登陆日志、登陆日志事件是围绕用户日志领域对象的行为。

此外，我们还可以从上面的分析中找到账本、预算、角色和收支记录这几个领域对象。

如下图：

领域对象也分三种类型

• 聚合根：聚合的入口，操作聚合下所有的实体和值对象都需要通过聚合根来操作
• 实体：具有唯一ID的实体，使用充血模型实现，也就是要包含属性和方法。所有对于实体的操作都应该放到这个实体中。可以映射为数据库的一个表。
• 值对象：值对象分为简单值对象和复杂值对象。值对象和实体最大的区别在于可变性，值对象不能单独存在，只能作为实体的一部分存在。同样的，值对象不支持变更，如果需要变更则是整个值对象删除再创建一个新的。
  • 简单值对象：基本类型的属性可以视为简单值对象。
  • 复杂值对象：引用其他类（自定义的类）作为属性的值，可以视为复杂值对象。

接下来我们就可以分析出上面的领域对象哪些是实体，哪些是值对象了。

实体：

• 用户实体：用户实体包括用户信息和用户的一些操作。这里可以将最新的一个登陆日志作为值对象放到用户实体中。而不是将所有的登陆日志都作为值对象放到用户实体中，因为那样的话太庞大了。
• 用户登陆日志实体：存储登陆日志的信息，虽然从用户的角度来看，登陆日志不能单独存在。但是如果从数据分析的角度看，登陆日志则可以单独存在了。因此可以作为一个实体存在。
• 账本实体：账本作为一个现实世界记账必须的物品，自然也要作为一个实体存在，有账本ID保证唯一性。并且可以修改账本的部分信息。
• 收支记录实体：每一个收支记录都是账本上的一条信息，都是可以独立修改的个体。比如修改某一个记录的金额等。所以收支记录也作为一个实体存在。

值对象：

• 预算值对象：预算信息是依赖于账本的一个信息，修改预算就是修改预算这个整体。因此预算作为账本的一个值对象存在。
• 角色值对象：多个人记账，每个人记账的时候的角色都是不一样的，修改角色也是修改角色这个整体，角色离开账本以后就没有存在的意义了，因此角色也作为值对象存在。

聚合建模

经过上面的步骤，我们已经找到了我们需要的实体和值对象。接下来我们可以根据他们之间的关系，来划分成一个个聚合了。

如果把实体理解成一个个的人，那么聚合就相当于部落、家族等等。相近的一些人聚集在一起，就变成了一个聚合。

变成聚合以后，当对外沟通的时候，需要一个话事人，也就是聚合根。

首先我们要有用户聚合，用户聚合来管理用户信息。用户实体就是用户聚合的聚合根。

其次，用户登陆日志也作为一个单独的聚合存在。可以思考一下。

✅ 1. 领域含义：登录日志是用户行为的“历史轨迹”，而非用户本身的组成部分

• 用户（User）是一个业务主语，它的职责是认证、权限、信息管理
• 登录日志是用户行为产生的事实事件，它与用户的生命周期边界无关

✅ 2. 技术设计上：日志数据量大、写入频繁、读取模式完全不同

这说明 LoginLog 应该用独立表、独立聚合、独立读写模型管理。

✅ 3. 聚合的职责原则（Evans 原则）

一个聚合应尽可能小，保持一致性边界清晰，仅包含保护不变式所必须的部分。

登录日志并不影响用户不变式（用户名、密码唯一性、身份验证），因此它不应该进聚合。

所以，我们把登陆日志放到一个单独的聚合中。登陆日志就是聚合根。

接下来，账本实体、预算和角色值对象一起构成了账本聚合。账本作为聚合根存在。

剩下的收支记录作为一个聚合。

有了4个聚合。我们还需要划分领域。将相近的聚合放到一个领域中。

领域可以简单理解为粗粒度的聚合。聚合中是实体和值对象。而领域中则是聚合。

我们将4个聚合划分成两个领域，分别是用户领域和记账领域。

总结

至此，我们完成了整个领域建模的工作，下一步就是将领域建模转换成代码建模了。

下一遍文章会将我们这次的领域建模转换成代码建模，并用spring框架来实现整个代码。

大家可以先自己将领域建模转换成代码建模，并将结果发到评论区一起讨论～

文末福利

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。
部分电子书如图所示。

大家好，我是大头，职高毕业，现在大厂资深开发，前上市公司架构师，管理过10人团队！
我将持续分享成体系的知识以及我自身的转码经验、面试经验、架构技术分享、AI技术分享等！
愿景是带领更多人完成破局、打破信息差！我自身知道走到现在是如何艰难，因此让以后的人少走弯路！
无论你是统本CS专业出身、专科出身、还是我和一样职高毕业等。都可以跟着我学习，一起成长！一起涨工资挣钱！
关注我一起挣大钱！文末有惊喜哦！

关注我发送“MySQL知识图谱”领取完整的MySQL学习路线。
发送“电子书”即可领取价值上千的电子书资源。
发送“大厂内推”即可获取京东、美团等大厂内推信息，祝你获得高薪职位。
发送“AI”即可领取AI学习资料。

MySQL零基础教程

本教程为零基础教程，零基础小白也可以直接学习，有基础的可以跳到后面的原理篇学习。
基础概念和SQL已经更新完成。

接下来是应用篇，应用篇的内容大致如下图所示。

高阶应用实战

除了常用的增删改查以外，MySQL还有很多的功能。比如CTE、窗口函数这种。再比如一些特性比如视图，触发器等。

这次我们就来看一下对于这些如何使用。

有些功能用好了可以完成很多实际业务需求的。

CTE(common table expressions)

在MySQL中，CTE（Common Table Expressions，公共表表达式）是一种临时的结果集，可以在查询中被引用。CTE通常用于简化复杂的查询，使查询更易于理解和维护。CTE在MySQL 8.0及更高版本中得到了支持。

CTE的主要特点

临时结果集：

• CTE是一个临时的结果集，可以在查询中被引用。它类似于子查询，但更易于阅读和维护。
  简化复杂查询：
• CTE可以将复杂的查询分解为多个简单的部分，使查询更易于理解和维护。
  可重用性：
• CTE可以被多次引用，减少了代码重复，提高了开发效率。
  递归查询：
• CTE支持递归查询，可以用于处理层次结构或递归数据。

使用CTE实现获取每个课程中分数最高的学生信息。

通过WITH语句来声明一个临时表。表名cteSource，表的内容就是最的sid，通过SELECT MAX(sid) FROM enrolled查询出来的结果。字段名叫maxId。

然后在查询语句里面就可以连接cteSource表，然后通过sid = cteSource.maxId 来获取到sid最大的用户信息。

1
2
3
4
5

WITH cteSource (maxId) AS (
    SELECT MAX(sid) FROM enrolled
)
SELECT name FROM student, cteSource
WHERE student.sid = cteSource.maxId

还有一些其他的用法，比如:

1
2
3
4
5
6
7

WITH cte1 (col1) AS (
SELECT 1
),
cte2 (col2) AS (
SELECT 2
)
SELECT * FROM cte1, cte2;

CTE（公共表表达式）使用场景

1. 递归查询（如树形结构）

CTE最常见的场景之一是递归查询，比如组织架构、分类目录、菜单结构等树状数据。例如，查询某个员工的所有下属员工。

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

WITH RECURSIVE subordinates AS (
  SELECT id, name, manager_id
  FROM employees
  WHERE manager_id IS NULL -- 顶层经理

  UNION ALL

  SELECT e.id, e.name, e.manager_id
  FROM employees e
  INNER JOIN subordinates s ON e.manager_id = s.id
)
SELECT * FROM subordinates;

2. 简化复杂查询逻辑，提高可读性

当查询逻辑复杂时，可以将中间结果用CTE分段处理，让SQL更易读。例如，先筛选出某类用户，再基于这些用户做进一步统计。

1
2
3
4
5
6

WITH active_users AS (
  SELECT user_id
  FROM user_logins
  WHERE login_date > CURRENT_DATE - INTERVAL '30 days'
)
SELECT COUNT(*) FROM orders WHERE user_id IN (SELECT user_id FROM active_users);

3. 多次引用中间结果，避免重复计算

如果某个子查询需要被多次引用，CTE可以定义一次，后续多次调用，避免重复书写和计算，提高效率。

1
2
3
4
5
6
7

WITH sales_summary AS (
  SELECT product_id, SUM(amount) AS total_sales
  FROM sales
  GROUP BY product_id
)
SELECT * FROM sales_summary WHERE total_sales > 1000;
-- 也可以在后续多个查询中引用 sales_summary

4. 分步处理数据，逐步细化结果

例如，先计算每个部门的总销售额，再筛选出销售额最高的部门。

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

WITH dept_sales AS (
  SELECT department_id, SUM(sales) AS total_sales
  FROM employees
  GROUP BY department_id
),
top_dept AS (
  SELECT department_id
  FROM dept_sales
  ORDER BY total_sales DESC
  LIMIT 1
)
SELECT * FROM employees WHERE department_id IN (SELECT department_id FROM top_dept);

5. 数据去重和排名

CTE可以配合窗口函数实现数据去重、分组排名等需求。

1
2
3
4
5
6

WITH ranked_orders AS (
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY order_date DESC) AS rn
  FROM orders
)
SELECT * FROM ranked_orders WHERE rn = 1;

实战案例

比如我之前的业务。有一个公司表，一个公司合同表，一个公司合同申请表。在后台的公司合同列表里面，要展示最新的申请记录和申请状态。

如果没有CTE的话，我们就需要使用子查询来实现。这对于一个列表来说，性能是很低的。

表结构假设:

• company：公司表，字段如 company_id, company_name 等。
• company_contract：公司合同表，字段如 contract_id, company_id, contract_no 等。
• company_contract_application：公司合同申请表，字段如 application_id, contract_id, apply_time, status 等。

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

SELECT
    c.company_id,
    c.company_name,
    cc.contract_id,
    cc.contract_no,
    cca.application_id,
    cca.apply_time,
    cca.status
FROM company c
JOIN company_contract cc ON c.company_id = cc.company_id
LEFT JOIN company_contract_application cca
    ON cc.contract_id = cca.contract_id
    AND cca.apply_time = (
        SELECT MAX(apply_time)
        FROM company_contract_application
        WHERE contract_id = cc.contract_id
    );

而有了CTE以后，我们可以通过CTE来实现，这样可以提升性能。

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

WITH latest_applications AS (
    SELECT
        application_id,
        contract_id,
        apply_time,
        status,
        ROW_NUMBER() OVER (PARTITION BY contract_id ORDER BY apply_time DESC) AS rn
    FROM company_contract_application
)
SELECT
    c.company_id,
    c.company_name,
    cc.contract_id,
    cc.contract_no,
    la.application_id,
    la.apply_time,
    la.status
FROM company c
JOIN company_contract cc ON c.company_id = cc.company_id
LEFT JOIN latest_applications la ON cc.contract_id = la.contract_id AND la.rn = 1;

窗口函数

窗口函数（Window Function）是SQL标准中的一种功能强大的工具，它允许在查询中对一组行进行计算，而不会像聚合函数那样消除行的个数。窗口函数在MySQL 8.0及更高版本中得到了支持，它们可以用于计算移动平均值、累积和、排名等复杂的分析任务。

窗口函数的主要特点

行级计算：

• 窗口函数在每一行上执行计算，同时可以访问同一组中的其他行。
• 这与聚合函数不同，聚合函数会将多行数据合并为一行。
  分区和排序：
• 窗口函数可以使用PARTITION BY子句将数据分成多个分区，每个分区独立计算。
• 可以使用ORDER BY子句在每个分区内对数据进行排序。
  灵活的范围定义：
• 窗口函数可以定义计算的范围，如当前行的前几行或后几行。
• 使用ROWS或RANGE子句可以指定计算的范围。
  多种功能：
• 窗口函数提供了多种功能，如ROW_NUMBER()、RANK()、DENSE_RANK()、NTILE()、SUM()、AVG()、LEAD()、LAG()等。

ROW_NUMBER和RANK都需要和OVER一起使用。

• ROW_NUMBER(): 显示当前行号
• RANK() : 显示排序后的排名，如果没有排序，都是1
• OVER()
  • PARTITION BY 进行分组
  • GROUP BY 进行分组
  • ORDER BY 排序

实战：获取每个课程中分数最高的学生信息

下面的SQL，在postgresql中执行成功，mysql8执行报错。

首先查询所有课程信息，并按照课程分组，按照分数排序。

1
2
3

SELECT *,
RANK() OVER (PARTITION BY cid ORDER BY grade ASC)
AS rank FROM enrolled

接着搜索上表中分数为1，也就是分数最高的学生。也就是每个课分数最高的学生信息。

1
2
3
4
5
6