Aiyezi

mysql基础

Wed, 25 Feb 2026 00:00:00 GMT

什么是 MySQL

MySQL 是一个高性能，开源的关系型数据库管理系统 (RDBMS)。使用 SQL (Structured Query Language) 进行数据查询，数据以表的形式（行和列）进行存储。

数据会以文件的形式存储到磁盘中，根据不同的存储引擎会有不同的存储策略，现在大多数是使用 InnoDB 引擎。

但是如果每次数据操作都直接读写磁盘，效率会非常低，因此 InnoDB 会在内存中开辟一块称作缓冲池的空间，每次读写操作都会通过缓冲池进行，大大的提高了效率。

核心概念

在 MySQL 的存储逻辑中，有几个核心的概念：

数据库 (Database)：存储和管理数据的容器
表 (Table): 实际存放数据的结构，由行和列组成
行 (Row): 表示具体的一条数据
列 (Column) / 字段 (Field): 表示数据的属性
主键 (Primary Key): 一条数据的唯一(不能重复)标识，不能为空
外键 (Foreign Key): 用于在表与表之间建立联系的标识，通常是另一张表的主键或唯一键。当前表中通过外键记录关联表的主键值，从而建立联系

一些基础 SQL 语法

DDL (Data Definition Language - 数据定义语言)

用于对数据库对象(比如数据库、表、视图、索引、存储) 进行增删改操作 (操作隐性提交，不能回滚)

-- 1. 查看数据库
SHOW DATABASES;

-- 2. 创建一个名为 demo 的数据库
CREATE DATABASE demo;

-- 3. 切换到 demo 这个数据库 (后续能操作这个数据库)
USE demo;

-- 4. 显示当前数据库中的表
SHOW TABLES;

-- 5. 创建一张表
-- id 大整型(BIGINT) 设定为主键(PRIMARY KEY) 值自增(AUTO_INCREMENT)
-- name password 可变字符串(VARCHAR) 不能为空(NOT NULL)
-- create_time 时间戳(TIMESTAMP) 默认为数据创建时的时间(DEFAULT CURRENT_TIME)
CREATE TABLE users (
 id BIGINT PRIMARY KEY AUTO_INCREMENT,
 name VARCHAR(50) NOT NULL,
 password VARCHAR(50) NOT NULL,
 create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

-- 6. 查看表结构
DESCRIBE users; -- 也可以简写为 DESC users;

-- 7. 删除表
DROP TABLE users;

-- 8. 删除数据库
DROP DATABASE demo;

-- 9. 修改表结构
-- 10. 例如将 users 表中 password 改为 user_password 并且类型改为 varchar(32)
ALTER TABLE users CHANGE COLUMN password user_password VARCHAR(32) NOT NULL;

DML (Data Manipulation Language - 数据操作语言)

用于对表中的数据进行增、删、改操作

-- 1. 插入数据 (INSERT)
-- id 字段自增，可以不用填写 (实际上密码一般都是加密存储的)
-- create_time 字段有默认值，也可以不用填写
-- 注意：列名列表和 VALUES 中的值必须一一对应
INSERT INTO users (name, password) VALUES ('admin', '12345678');
-- 也可以直接插入
-- 但是必须提供所有字段，对于自增和有默认值的可以用 DEFAULT 让系统自动生成
INSERT INTO users VALUES (DEFAULT, 'user_001', '87654321', DEFAULT);

-- 2. 修改数据 (UPDATE)
-- 将用户名为 'admin' 的用户密码改为 '11223344'
-- 如果不加 WHERE 限定会改掉所有用户的密码
UPDATE users SET password = '11223344' WHERE name = 'admin';

-- 3. 删除数据 (DELETE)
-- 删除名字为 'user_001' 的用户
-- 如果不加 WHERE 限定会删掉所有用户(DELETE FROM users -- 清空表，但保留表结构)
DELETE FROM users WHERE name = 'user_001';

PS. 一定要注意 WHERE 的使用，一不小心就把整张表所有数据改掉了

DQL (Data Query Language - 数据查询语言)

用于查询数据库中的数据

-- 1. 查询所有行
SELECT * FROM users;

-- 2. 查询指定列 (又称投影查询)
SELECT name, password FROM users;

-- 3. 带条件查询 (WHERE)
SELECT * FROM users WHERE create_time > '2026-02-23';

-- 4. 排序(ORDER BY 默认升序)
SELECT * FROM users ORDER BY create_time;
-- 降序 (DESC)
SELECT * FROM users ORDER BY create_time DESC;

-- 5. 限制返回行数 (LIMIT)
-- 只返回两行
SELECT * FROM users LIMIT 2;

-- 结合排序和限制，查询最早注册的用户
SELECT * FROM users ORDER BY create_time LIMIT 1;

-- 6. 模糊查询 (LIKE)
-- '%'代表匹配多个任意字符 '_'代表匹配一个任意字符
SELECT * FROM users WHERE name LIKE '%d%';
SELECT * FROM users WHERE name LIKE '__e%';

-- 7. 去重 (DISTINCT)
-- 查看有叫哪些名字的 (把重复的名字去掉了)
SELECT DISTINCT name FROM users;

一些进阶 SQL 语法

分页查询

在数据量很多的时候，进行大量查询时通常会进行分页操作

-- 基于 LIMIT 加上偏移量 OFFSET 进行分页操作
-- 没有加上 OFFSET 的时候其实就是相当于 OFFSET = 0
SELECT * FROM users LIMIT 5;
SELECT * FROM users LIMIT 5 OFFSET 0;

-- 正常我们看分页数据都是有两个指标：页长(pageSize)和页码(pageNum)
-- 页长就是每页有多少个数据，页码就是当前第几页
-- 本质上 LIMIT N 和 OFFSET M 的组合就是获取 范围为第M+1~M+N的所有数据
-- 页长和页码同偏移量之间的转换则就是: offset = pageSize * (pageNum - 1)
-- 例如当页长为10，查询第5页
SELECT * FROM users LIMIT 10 OFFSET 40;

聚合查询

SQL 提供了一些用于统计和计算的聚合函数，例如:

-- 用于统计数量的 COUNT()，其结果返回一个一行一列的二维表
-- 列名为填写的 COUNT(*) , 对应的数据为统计的数量
-- * 替换成表中其他字段效果也等同，都是统计这个表的行数
SELECT COUNT(*) FROM users;

-- 用于计算数值和的 SUM() 计算的字段必须为数值类型
-- 返回形式和COUNT()相似
-- 假设users 存在数值字段 age
-- 计算用户年龄总和 (好像没啥实际意义)
SELECT SUM(age) FROM users;

-- 用于计算最大值的 MAX()
-- 计算的字段不局限于数值，字符类型也可以，其大小以字典序决定
-- 返回形式同上
-- 计算用户的最大年龄
SELECT MAX(age) FROM users;

-- 用于计算最小值的 MIN()
-- 形式同 MAX()
SELECT MIN(age) FROM users;

-- 用于分组的 GROUP BY
-- 假设 users 存在角色字段 role
-- 这里的 num 是给结果列名 COUNT(*) 改名为 num 上述也能进行这种操作
-- 这里是将 users 按 role 分组后分别统计数量，结果返回一个多行一列的结果
-- 每行对应每个角色分组的统计数量
SELECT COUNT(*) num FROM users GROUP BY role;

多表查询

SELECT 查询可以从多张表同时查询数据，实际业务上也是多表查询居多

-- 1. 直接多表查询
-- 直接查询多个表
-- 返回一个 users 和 roles 表的"乘积表" (集合论中的笛卡尔积)
SELECT * FROM users, roles;

-- 直接查询多个表的指定字段的
-- 就是上面那个乘积里选出几列
-- 指定字段用了【表名.字段名】的形式表示具体指哪个表中的字段
-- 这里用了在数据对象后面取别名的方法，在复杂查询中能简化许多
SELECT
 u.id uid, u.name uname, r.id rid, r.name rname
FROM
 users u, roles r;

-- 2. 内连接多表查询
-- 假设 roles 表存储 (id, user_id, role_name)
-- 现在要查询出用户信息和对应的角色的表
-- 使用 INNER JOIN 进行连接，结果会返回上述"乘积"中，符合 u.id = r.user_id的
SELECT
 u.id, u.name, u.password ,r.role_name
FROM
 users u INNER JOIN roles r
ON
 u.id = r.user_id;

-- 3. 外连接多表查询
-- 外连接有左外连接(LEFT JOIN),右外连接(RIGHT JOIN)查询 (外 OUTER 通常会被省略)
-- 对于左外连接，就是以左表为主表，将右表存在关联的数据连接上，其他用 NULL 补全
SELECT
 u.id, u.name, u.password ,r.role_name
FROM
 users u LEFT JOIN roles r
ON
 u.id = r.user_id;
-- 对于右外连接，则是以右表为主表，将左表存在关联的数据连接上，其他用 NULL 补全
SELECT
 u.id, u.name, u.password, r.role_name
FROM
 users u RIGHT JOIN rules r
ON
 u.id = r.user_id;
-- 以及全外连接 (FULL JOIN)，但是在 Mysql 里没有这个语法
-- 实际上相当于将 左右连接 UNION 起来
SELECT
 u.id, u.name, u.password, r.role_name
FROM
 users u Left JOIN rules r
ON
 u.id = r.user_id
UNION
SELECT
 u.id, u.name, u.password, r.role_name
FROM
 users u RIGHT JOIN rules r
ON
 u.id = r.user_id;

Maven 以及 pom

Mon, 23 Feb 2026 00:00:00 GMT

Maven 是一个项目管理和构建的自动化工具，主要服务于 JAVA 项目。其特性在于

标准化项目管理 (统一的项目目录结构)
依赖管理 (自动管理第三方库及其版本、传递性依赖)
构建生命周期 (标准的构建流程-编译、测试、打包、部署)
插件机制 (通过插件扩展功能)

`pom.xml` 详解

POM (Project Object Model) 是 Maven 的核心配置，定义了项目的基本信息、依赖、构建配置等。

基础结构

<?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">

    <!-- POM 版本，通常固定为 4.0.0 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 项目坐标：唯一标识一个项目 -->
    <groupId>com.example</groupId>           <!-- 组织/公司标识 -->
    <artifactId>my-app</artifactId>          <!-- 项目名称 -->
    <version>1.0.0-SNAPSHOT</version>        <!-- 项目版本 -->
    <packaging>jar</packaging>               <!-- 打包方式：jar/war/pom等 -->

</project>

坐标详解

元素	说明	示例
groupId	组织标识，通常为域名倒写	com.example, cc.ieaf
artifactId	项目唯一标识	my-app, springsecurity-demo
version	项目版本号	1.0.0, 2.0.0-beta
packaging	打包方式 (可选)	jar, war, pom, maven-plugin
classifier	分类器 (可选)	sources, javadoc

版本号规范

Maven 版本号规范允许使用数字、点、连字符、下划线、字母的组合。

<version>2.5.6.RELEASE</version>   <!-- Spring 传统格式 -->
<version>2.5.6</version>     <!-- 纯数字格式 -->
<version>2.5.6-Final</version>    <!-- 带标识符 -->
<version>2.5.6.20201231.123456</version> <!-- 时间戳版本 -->

版本号排序规则（从小到大）：

2.5.6-SNAPSHOT (开发版)
2.5.6-alpha (内测版)
2.5.6-beta (公测版)
2.5.6-milestone (里程碑版)
2.5.6.RELEASE 或 2.5.6 (正式版)
2.5.6.RELEASE.1 (补丁版)

依赖管理

<dependencies>
    <!-- 一个依赖项 -->
    <dependency>
        <!-- 组织标识 -->
        <groupId>org.springframework.boot</groupId>
        <!-- 项目唯一标识 -->
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 项目版本号 -->
        <version>2.7.0</version>
        <!-- 依赖范围 -->
        <scope>compile</scope>
        <!-- 是否可选 -->
        <optional>false</optional>
        <!-- 排除传递性依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

依赖范围 (scope)

范围	说明
compile	默认值，所有阶段都有效
provided	编译时有效，运行时由 JDK 或容器提供
runtime	编译时不需要，运行时需要
test	测试时需要
system	类似 provided 需要显式指定路径
import	仅用于 dependencyManagement, 导入依赖

是否可选 (optional)

这个选项表示这个依赖是否应该被传递继承

optional=true: 表示当前项目需要这个依赖，但是不强制要求引用我这个项目的使用者也被传递需要这个依赖
optional=false: （默认值）表示当前项目需要这个依赖，同时引用我这个项目的使用者也会自动获得这个依赖举个例子：我写一个项目的时候用到了 lombok, 但是它仅在我编译代码的时候需要，如果别人要使用我写的包不一定就需要它，这种时候就可以使用 optional=true

属性配置

<properties>
    <!-- 项目编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

    <!-- Java 版本 -->
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>

    <!-- 自定义属性：统一版本管理 -->
    <spring.version>5.3.20</spring.version>
    <junit.version>5.8.2</junit.version>
</properties>

<!-- 使用属性 -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

配置属性中，一些是内置属性，直接配置使用。一些是自定义配置，需要自己在用到的地方通过 ${spring.version} 这样的形式进行引用。

常见的内置属性

属性名	说明	示例值
`project.build.sourceEncoding`	源码编码	UTF-8
`project.reporting.outputEncoding`	报告编码	UTF-8
`maven.compiler.source`	Java 源码版本	1.8,11,17,21
`maven.compiler.target`	Java 目标版本	1.8,11,17,21<br>
`maven.test.skip`	是否跳过测试	true/false
`maven.javadoc.skip`	是否跳过javadoc	true/false

构建配置

<build>
    <!-- 最终打包的文件名-->
    <!-- 不写的话，默认就是这个命名 -->
    <finalName>${project.artifactId}-${project.version}</finalName>

    <!-- 资源配置文文件 -->
    <!-- 不写的话，资源文件路径默认是下面这个 -->
    <!-- filtering 默认是 false -->
    <!-- 但是包含的文件默认是所有，下面限定了.yaml和.xml后缀的 -->
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.yaml</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>

    <!-- 插件配置 -->
    <plugins>
        <plugin>
            <!-- 和上述依赖类似 -->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.10.1</version>
            <!-- 插件的具体配置，要根据插件决定 -->
            <configuration>
                <source>11</source>
                <target>11</target>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!-- 和依赖类似，可以排除传递包 -->
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

filtering=true 的作用: 允许在构建时替换资源文件中的占位符，例如

# src/main/resources/application.yaml
app:
  name: ${project.name}
  version: ${project.version}
  env: ${env}
  url: ${db.url}

用来替换这些占位符的可以来自 pom.xml:

<properties>
 <!-- 可以是内置属性 -->
 <project.version>1.0.0</project.version>

 <!-- 也可以是自定义属性 -->
    <env>dev</env>
</properties>

<build>
    <ressources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </ressources>
</build>

也可以用命令行，通过 -D参数 传递

mvn package -ddb.url=jdbc:mysql://localhost:3306/test

还可以是来自系统变量例如系统变量里有 $OPENAI_API=sk...，在资源文件里也能使用
```
# src/main/resources/application.yaml
openai_api: ${OPENAI_API}
```

仓库配置

<!-- 定义项目特有的仓库 -->
<repositories>
    <repository>
        <id>aliyun</id>
        <name>阿里云仓库</name>
        <url>https://maven.aliyun.com/repository/public</url>
  <!-- 允许使用正式发行版本 -->
        <releases>
            <enabled>true</enabled>
        </releases>
  <!-- 禁止使用开发快照版本 -->
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

<!-- 插件仓库 -->
<pluginRepositories>
    <pluginRepository>
        <id>aliyun-plugin</id>
        <url>https://maven.aliyun.com/repository/public</url>
    </pluginRepository>
</pluginRepositories>

用于自定义项目的依赖仓库和插件仓库，一般不使用，通常是在 Maven 的 settings.xml 文件里配置。

多模块项目

大多数时候一些大型项目会分成多个模块构建，减小项目的耦合性，增大开发效率和灵活性。其实就是把项目里的文件分散到几个独立的模块里去：

spring-boot-multi-module/
├── pom.xml (父)
├── common/
│   ├── pom.xml
│   └── src/main/java/com/example/common/...
├── service/
│   ├── pom.xml
│   └── src/main/java/com/example/service/...
└── web/
    ├── pom.xml
    └── src/main/java/com/example/web/Application.java

父POM (聚合模块)

<!-- 父模块定义 -->
<groupId>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0.0</version>
<packaging>pom</packaging>

<!-- 定义子模块 -->
<module>common</module>
<module>core</module>
<module>web</module>

<!-- 子模块公用配置 -->
<properties>
    <java.version>11</java.version>
</properties>

子 POM

<parent>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <relativePath>../pom.xml</relativePath>
</parent>

<artifactId>common</artifactId>
<packaging>jar</packaging>

Maven 是基于坐标识别项目，所以显式地声明父模块的 groupId、artifactId、version 是必须的。
子模块通过 <parent> 声明继承了父模块的 groupId、artifactId、version 等。
relativePath 只是一个辅助提示，如果没找到 Maven 会转而去依赖仓库中去寻找

多模块依赖管理

<!-- 通常用在父POM中 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>
    </dependencies>
</dependencyManagement>

在 dependencyManagement 中的是声明的依赖版本，可以让子模块引用时无需声明版本，而在子模块里的 dependencies 一般则是直接引入的依赖。

常用插件

插件	用途	常用命令
`maven-compiler-plugin`	编译Java代码	compile, testCompile
`maven-surefire-plugin`	运行单元测试	test
`maven-jar-plugin`	打包成JAR	package
`maven-war-plugin`	打包成WAR	package
`maven-source-plugin`	生成源码包	source:jar
`maven-javadoc-plugin`	生成JavaDoc	javadoc:javadoc
`spring-boot-maven-plugin`	SpringBoot打包	spring-boot:run

Maven 的生命周期

Maven 有三个内置的生命周期：

default （核心生命周期）

validate -> compile -> test -> package -> verify -> install -> deploy

阶段	说明
validate	验证项目是否正确
compile	编译源代码
test	运行单元测试
package	打包成 jar/war
verify	检查包是否有效
install	安装到本地仓库
deploy	部署到远程仓库

clean (清理)

pre-clean -> clean -> post-clean

阶段	说明
pre-clean	执行清理前需要完成的工作（例如清除之前的日志）
clean	删除上一次构建生成的所有文件（核心阶段，默认删除 `target` 目录）
post-clean	执行清理之后的工作（例如清理完成后的通知）

site (生成站点)

Ps. 现在前后端分离基本不会用这个吧

pre-site -> site -> post-site -> site-deploy

常用命令

# 清理
mvn clean

# 编译
mvn compile

# 运行测试
mvn test

# 打包
mvn package

# 安装到本地仓库
mvn install

# 部署到远程仓库
mvn deploy

# 跳过测试
mvn package -DskipTests

# 指定settings文件
mvn clean install -s /path/to/settings.xml

# 查看依赖树
mvn dependency:tree

# 查看项目信息
mvn help:effective-pom

Hello World

Fri, 13 Feb 2026 00:00:00 GMT