zy123/md_files
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Commit on 2025/05/16 周五 14:50:05.84

Browse Source
This commit is contained in:
zhangsan 2025-05-16 14:50:05 +08:00
parent fb3525c12d
commit e594fd9248
4 changed files with 221 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
科研/ZY网络重构分析.md
View File

@ -187,27 +187,34 @@ $$
### 矩阵符号说明 ### 矩阵符号说明
- 原始（真实）邻接矩阵： - 原始（真实）邻接矩阵 $A$ ,假设 $A$ 的秩为 $r$： $\lambda_{r+1}=\cdots=\lambda_n=0$
$$ $$
A = \sum_{m=1}^n \lambda_m\,x_m x_m^T, A = \sum_{m=1}^n \lambda_m\,x_m x_m^T=\begin{align*}
\quad \lambda_1\ge\lambda_2\ge\cdots\ge\lambda_n\; \sum_{m=1}^r \lambda_m x_m x_m^T + \sum_{m=r+1}^n \lambda_m x_m x_m^T = \sum_{m=1}^r \lambda_m x_m x_m^T
\end{align*},
$$ $$
- 滤波估计得到的矩阵及谱分解： - 滤波估计得到的矩阵及谱分解：
$$ $$
\widetilde A = \sum_{m=1}^r \widetilde\lambda_m\,\widetilde x_m\widetilde x_m^T, \widetilde A = \sum_{m=1}^r \widetilde\lambda_m\,\widetilde x_m\widetilde x_m^T,
\quad \widetilde\lambda_1\ge\cdots\ge\widetilde\lambda_n\; \quad \widetilde\lambda_1\ge\cdots\ge\widetilde\lambda_n\;
$$ $$
- 只取前 $r$ 项重构 ： - 只取前 $\kappa$ 项重构 ：
$$ $$
A_r \;=\;\sum_{m=1}^r \widetilde\lambda_m\,\widetilde x_m\widetilde x_m^T, A_\kappa \;=\;\sum_{m=1}^\kappa \widetilde\lambda_m\,\widetilde x_m\widetilde x_m^T,
$$ $$
- 对 $A_r$ 进行K-means聚类，得到 $A_{final}$ - 对 $A_\kappa$ 进行K-means聚类，得到 $A_{final}$
目标是让 $A_{final}$ = $A$ 目标是让 $A_{final}$ = $A$
### **0/1矩阵** ### **0/1矩阵**
其中 $\widetilde{\lambda}_i$ 和 $\widetilde{x}_i$ 分别为通过预测得到矩阵 $\widetilde A$ 的第 $i$ 个特征值和对应特征向量。 然而预测值和真实值之间存在误差，直接进行矩阵重构会使得重构误差较大。 对于这个问题，文献提出一种 0/1 矩阵近似恢复算法。 其中 $\widetilde{\lambda}_i$ 和 $\widetilde{x}_i$ 分别为通过预测得到矩阵 $\widetilde A$ 的第 $i$ 个特征值和对应特征向量。 然而预测值和真实值之间存在误差，直接进行矩阵重构会使得重构误差较大。 对于这个问题，文献提出一种 0/1 矩阵近似恢复算法。
@ -324,3 +331,10 @@ $$
假设都是破松分布 假设都是破松分布
![image-20250515175402459](https://pic.bitday.top/i/2025/05/15/t01cvj-0.png)
估计带权邻接矩阵（存在量化误差），比较分布式算法的误差。

41
科研/草稿.md
View File

@ -1,32 +1,11 @@
以下是修改后的内容，所有公式部分都已用 `$`（行内公式）或 `$$`（行间公式）包裹： $$
\begin{align*}
\sum_{m=1}^r \lambda_m x_m x_m^T + \sum_{m=r+1}^n \lambda_m x_m x_m^T = \sum_{m=1}^r \lambda_m x_m x_m^T
\end{align*}
$$
--- $$
\begin{align*}
### **1. 核心区别** \lambda_{r+1}=\cdots=\lambda_n=0
| **性质** | **特征分解/谱分解** | **奇异值分解（SVD）** | \end{align*}
| ------------ | -------------------------------- | ------------------------------------------ | $$
| **适用矩阵** | 仅限**方阵**（$n \times n$） | **任意矩阵**（$m \times n$，包括矩形矩阵） |
| **分解形式** | $A = P \Lambda P^{-1}$ | $A = U \Sigma V^*$ |
| **矩阵类型** | 可对角化矩阵（如对称、正规矩阵） | 所有矩阵（包括不可对角化的方阵和非方阵） |
| **输出性质** | 特征值（$\lambda_i$）可能是复数 | 奇异值（$\sigma_i$）始终为非负实数 |
| **正交性** | 仅当 $A$ 正规时 $P$ 是酉矩阵 | $U$ 和 $V$ 始终是酉矩阵（正交） |
---
### 修改说明：
1. **行内公式**（用 `$...$` 包裹）：
- 矩阵维度：$n \times n$、$m \times n$
- 分解形式：$A = P \Lambda P^{-1}$、$A = U \Sigma V^*$
- 数学符号：$\lambda_i$、$\sigma_i$、$A$、$P$、$U$、$V$ 等
2. **特殊符号**：
- 使用 `^*` 表示共轭转置 $V^*$
- 使用 `\times` 表示乘号 $\times$
- 使用 `\Lambda` 和 `\Sigma` 表示对角矩阵
3. **表格结构**：
- 保持原有 Markdown 表格格式
- 对齐表头和内容
- 保留中文说明部分
这样修改后，公式可以兼容 LaTeX 渲染，同时保持内容的清晰性和可读性。

141
自学/Docker指南.md
View File

@ -110,13 +110,13 @@ docker image prune
![image-20210731161950495](https://pic.bitday.top/i/2025/03/19/u66wrs-2.png) ![image-20210731161950495](https://pic.bitday.top/i/2025/03/19/u66wrs-2.png)
1. docker run 创建并运行一个新容器 1.docker run 创建并运行一个新容器
​ -d:以后台模式运行容器，不会占用当前终端。 ​ -d:以后台模式运行容器，不会占用当前终端。
​ --name <容器名> :为容器指定一个自定义名称，便于后续管理。 ​ --name <容器名> :为容器指定一个自定义名称，便于后续管理。
​ -p <宿主机端口>:<容器端口> : 将容器内部的端口映射到宿主机，使外部可以访问容器提供的服务。 ​ -p <宿主机端口>:<容器端口> : 将容器内部的端口映射到宿主机，**使外部可以访问容器提供的服务，如果不写的话，只有容器内部网络能访问它**比如mysql，如果写''-p 3307:3306',那么可以用navicat连接localhost:3307访问这个数据库。
​ --restart <策略> :设置容器的重启策略，如 `no`（默认不重启）、`on-failure`（失败时重启）、`always`（总是重启）或 `unless-stopped`。 ​ --restart <策略> :设置容器的重启策略，如 `no`（默认不重启）、`on-failure`（失败时重启）、`always`（总是重启）或 `unless-stopped`。
@ -126,7 +126,7 @@ docker image prune
docker run --name test-container -d test:latest docker run --name test-container -d test:latest
``` ```
2. docker exec 在正在运行的 test-container 内执行命令 2.docker exec 在正在运行的 test-container 内执行命令
​ -it : 给当前进入的容器创建一个标准输入、输出终端 ​ -it : 给当前进入的容器创建一个标准输入、输出终端
@ -134,43 +134,43 @@ docker run --name test-container -d test:latest
docker exec -it test-container sh docker exec -it test-container sh
``` ```
3. docker logs ，查看 test-container 的日志输出： 3.docker logs ，查看 test-container 的日志输出：
```text ```text
docker logs --since 1h test-container #查看最近1h docker logs --since 1h test-container #查看最近1h
``` ```
4. docker stop 停止正在运行的 test-container： 4.docker stop 停止正在运行的 test-container：
```text ```text
docker stop test-container docker stop test-container
``` ```
5. docker start 启动一个已停止的 test-container： 5.docker start 启动一个已停止的 test-container：
```text ```text
docker start test-container docker start test-container
``` ```
6. docker cp 复制文件（或目录）到容器内部，先cd到文件所在目录 6.docker cp 复制文件（或目录）到容器内部，先cd到文件所在目录
```text ```text
docker cp localfile.txt test-container:/target_dir/ docker cp localfile.txt test-container:/target_dir/
``` ```
7. docker stats ，查看docker中运行的所有容器的运行状态（CPU 内存占用） 7.docker stats ，查看docker中运行的所有容器的运行状态（CPU 内存占用）
```text ```text
docker stats docker stats
``` ```
8. docker container ls，查看运行容器的创建时间、端口映射等 8.docker container ls，查看运行容器的创建时间、端口映射等
```text ```text
docker container ls docker container ls
``` ```
9. docker ps 查看 Docker 容器的状态,默认情况下，它只显示正在运行的容器 9.docker ps 查看 Docker 容器的状态,默认情况下，它只显示正在运行的容器
```text ```text
docker ps -a #查看所有容器，包括已经停止或启动失败的容器 docker ps -a #查看所有容器，包括已经停止或启动失败的容器
@ -257,7 +257,7 @@ Mountpoint是宿主机上的路径，也就是 Docker 存储该数据卷数据
#### docker网络 #### docker网络
Docker 网络的主要作用是实现容器之间的**通信和隔离**，同时也能控制容器与外部主机或网络的连接。通过创建自定义网络，你可以让属于同一网络的容器通过名称互相访问，而不必暴露所有服务到外部网络，这既提升了安全性又简化了容器间的交互。 Docker 网络的主要作用是实现容器之间的**通信和隔离**，同时也能控制容器与外部主机或网络的连接。通过创建自定义网络，你可以**让属于同一网络的容器通过名称互相访问**，而不必暴露所有服务到外部网络，这既提升了安全性又简化了容器间的交互。
**举例说明** **举例说明**
@ -289,8 +289,6 @@ docker run -d --name mysql \
3.启动 Web 应用容器，加入同一个 `app-net` 网络 3.启动 Web 应用容器，加入同一个 `app-net` 网络
```text ```text
@ -309,7 +307,7 @@ ping db
举个例子，如果你的 Java 应用运行在容器 B 中，而数据库容器 A 已经通过 `--network-alias db` 起了别名，那么在 Java 应用中，你只需要写： 举个例子，如果你的 Java 应用运行在容器 B 中，而数据库容器 A 已经通过 `--network-alias db` 起了别名，那么在 Java 应用中，你只需要写：
```text ```java
String dbUrl = "jdbc:mysql://db:3306/your_database"; String dbUrl = "jdbc:mysql://db:3306/your_database";
``` ```
@ -317,9 +315,8 @@ String dbUrl = "jdbc:mysql://db:3306/your_database";
否则： 否则：
```text ```java
String dbUrl = "jdbc:mysql://<宿主机IP或localhost>:3306/your_database"; String dbUrl = "jdbc:mysql://<宿主机IP或localhost>:3306/your_database";
``` ```
因为会通过**宿主机IP映射到容器内**的IP 因为会通过**宿主机IP映射到容器内**的IP
@ -742,7 +739,7 @@ docker run --name zbparse-container --security-opt seccomp=unconfined zbparse
### docker-compose安装： ### docker-compose安装：
**方式1：**从 Docker 20.10 开始，Docker 官方就将 Docker Compose 作为插件集成在 Docker Engine 中，所以在安装 Docker Engine 时，它也会一并安装 Docker Compose 插件。无需额外安装 **方式1：**从 Docker 20.10 开始，Docker 官方就将 Docker Compose 作为插件集成在 Docker Engine 中，所以在安装 Docker Engine 时，它也会一并安装 Docker Compose 插件。**无需额外安装**
验证安装 验证安装
@ -857,7 +854,7 @@ build: ./web_app #两种写法是等效的
**** ****
### 4.docker-compose常用命令 ### docker-compose常用命令
**构建镜像：**这个命令根据 docker-compose.yml 中各服务的配置构建镜像。如果你修改了 Dockerfile 或者项目代码需要打包进镜像时，就需要运行该命令来构建新的镜像。 **构建镜像：**这个命令根据 docker-compose.yml 中各服务的配置构建镜像。如果你修改了 Dockerfile 或者项目代码需要打包进镜像时，就需要运行该命令来构建新的镜像。
@ -953,6 +950,10 @@ docker-compose restart flask_app #指定某个服务
### docker-compose容器名
**1：默认**
当使用docker-compose build 构建镜像时，镜像的标签格式通常是 `项目名_服务名` 当使用docker-compose build 构建镜像时，镜像的标签格式通常是 `项目名_服务名`
docker-compose up生成的容器名默认是 `项目名_服务名_索引号` docker-compose up生成的容器名默认是 `项目名_服务名_索引号`
@ -961,15 +962,15 @@ docker-compose up生成的容器名默认是 `项目名_服务名_索引号`
**服务名**是指你在docker-compose中设置的服务名称（services:下的名称）。 **服务名**是指你在docker-compose中设置的服务名称（services:下的名称）。
**项目名**默认是**当前目录名**，如果你使用了 `-p` 选项指定项目名，则使用指定的项目名 **项目名**默认是**当前目录名**，如果你使用了 `-p` 选项指定项目名，则使用指定的项目名,如
如
```shell ```shell
docker-compose -p my_custom_project up -d docker-compose -p my_custom_project up -d
``` ```
在docker-compose.yml中指定容器名
**2.在docker-compose.yml中指定容器名**
```text ```text
version: '3' version: '3'
@ -994,9 +995,17 @@ services:
### 关于Docker-compose的重要说明 ### 关于Docker-compose的重要说明
**一个Docker-compose文件定义的各个服务默认使用同一个网络**。不同的Docker-compose文件可能使用相同的镜像，如mysql8.0，此时docker会自动进行镜像复用，而不会重复下载。 1.**服务名和网络别名**可用于**同一网络**内容器之间的通信（如Java→MySQL、前端→后端，因为同一个网络会自动注册一个DNS名） 尽管容器名也可以作为通信的名字、但是极不推荐！！！
一个**基础镜像可以构造多个容器**，互不影响， 2.服务名可用于docker compose系列命令
3.容器名主要用于docker命令：`docker ps`、`docker logs`、`docker exec` 等命令时指定目标容器。
**4.一个Docker-compose文件定义的各个服务默认使用同一个网络**。
5.不同的Docker-compose文件可以使用相同的镜像，如mysql8.0，此时docker会自动进行镜像复用，而不会重复下载。
```text ```text
db: db:
@ -1010,18 +1019,6 @@ db:
- db_data_project1:/var/lib/mysql - db_data_project1:/var/lib/mysql
``` ```
```text
db:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: 123456
MYSQL_DATABASE: db_project2
ports:
- "3307:3306" # 使用不同的主机端口以避免冲突
volumes:
- db_data_project2:/var/lib/mysql
```
| **问题类型** | **可能的冲突** | **解决方案** | | **问题类型** | **可能的冲突** | **解决方案** |
@ -1029,16 +1026,29 @@ db:
| **端口冲突** | 容器监听相同的宿主机端口（如 `3306:3306`） | 在不同 `docker-compose.yml` 中映射不同端口（如 `3307:3306`） | | **端口冲突** | 容器监听相同的宿主机端口（如 `3306:3306`） | 在不同 `docker-compose.yml` 中映射不同端口（如 `3307:3306`） |
| **数据卷冲突** | 多个 MySQL 实例共享相同的 `/var/lib/mysql` | 使用不同的 `volume` 名称，或只运行一个 MySQL 实例 | | **数据卷冲突** | 多个 MySQL 实例共享相同的 `/var/lib/mysql` | 使用不同的 `volume` 名称，或只运行一个 MySQL 实例 |
| **网络冲突** | 默认网络可能导致 DNS 解析失败 | 在 `docker-compose.yml` 里创建独立的 `network` | | **网络冲突** | 默认网络可能导致 DNS 解析失败 | 在 `docker-compose.yml` 里创建独立的 `network` |
| **镜像冲突** | 镜像不会冲突，但多个实例可能导致资源竞争 | 镜像可共享，但实例应该使用独立配置 |
**最佳实践**
1. 如果只需要一个 MySQL 服务，建议让多个 Compose 连接到同一个 MySQL 容器，而不是启动多个 MySQL 容器。
2. **所有服务都在一个docker-compose中，包括mysql** **最佳实践1**
3. 如果必须运行多个 MySQL 实例：
- 为不同的 MySQL 实例分配不同的宿主机端口（如 `3306`、`3307`）。 1. 部署单一 MySQL 服务，不用为每个应用都起一个数据库容器；
- 使用不同的数据卷，避免数据损坏。 2. 将需要访问该 MySQL 的服务挂到一个专用网络，且**各自用不同数据库用户和库名**；
- 确保不同的实例在不同的 Docker 网络中运行，防止冲突。 3. 若要更严格隔离（应用之间不可相互访问），可以为每个应用拆分出独立网络，只在网络交集里放 MySQL（MYSQL可以加入不同的网络）；
4. 数据卷 `mysql-data` 仍然只对应一个实例，数据完全由该实例管控。
**最佳实践2**
JAVA应用和MYSQL一起定义在自己的Compose中（天生处于同一个网络，且应用之间隔离）
1.**独立数据卷**：给每个实例用不同的 named volume（如 `mysql-data-app1`、`mysql-data-app2`），保证数据互不干扰；
2.**不同端口映射**：在各自的 Compose 里把宿主机端口映射到 `3306`，如 `3306:3306`、`3307:3306`；
**最佳实践1：** **最佳实践1：**
@ -1054,11 +1064,13 @@ docker network create my_shared_network
2.创建 MySQL 的 `docker-compose-mysql.yml` 2.创建 MySQL 的 `docker-compose-mysql.yml`
```text ```yml
version: '3' version: '3'
services: services:
mysql: mysql:
image: mysql:8 image: mysql:8
volumes:
- mysql-data:/var/lib/mysql
restart: always restart: always
environment: environment:
MYSQL_ROOT_PASSWORD: root MYSQL_ROOT_PASSWORD: root
@ -1075,7 +1087,7 @@ networks:
3.在 `docker-compose-app.yml` 里连接这个 MySQL 3.在 `docker-compose-app.yml` 里连接这个 MySQL
```text ```yml
version: '3' version: '3'
services: services:
web_app: web_app:
@ -1092,47 +1104,10 @@ services:
networks: networks:
my_shared_network: my_shared_network:
external: true external: true
``` ```
| **方式** | **能否被其他容器访问？** | **生效范围** | **优缺点** |
| ------------------------- | ------------------------ | ----------------------------------------------------- | ------------------------------------------ |
| **`network-alias`（db）** | ✅ **推荐** | 仅限同一个 `network`(不同compose文件共享网络时也生效) | **最稳定，不受 `container_name` 变更影响** |
| **`服务名`（mysql）** | ✅ **默认推荐** | 仅限 **同一个**`docker-compose.yml` | **简单，自动解析，不需要额外配置** |
服务名和网络别名可用于同一网络内容器之间的通信
容器名主要用于管理和运维：`docker ps`、`docker logs`、`docker exec` 等命令时指定目标容器。
4.启动 MySQL 容器
```text
docker-compose -f docker-compose-mysql.yml up -d
```
5.启动 Web 应用
```text
docker-compose -f docker-compose-app.yml up -d
```
**问题：但你需要确保其他服务不会产生不必要的相互访问，因为相当于都在my_shared_network中。**
**最佳实践**
- **如果所有服务都在同一个 `docker-compose.yml`，直接用 `服务名`（如 `mysql`），因为 Docker Compose 会自动解析。**
- **如果是多个 `docker-compose.yml` 共享网络，建议用 `network-alias`**，这样即使 `container_name` 改变，服务依然可以正确解析。
### 实践：部署微服务集群 ### 实践：部署微服务集群
**需求**：将之前学习的cloud-demo微服务集群利用DockerCompose部署 **需求**：将之前学习的cloud-demo微服务集群利用DockerCompose部署

154
自学/苍穹外卖.md
View File

@ -94,6 +94,8 @@ postman: 接口测工具，模拟用户发起的各类HTTP请求，获取对应
#### 前端环境搭建 #### 前端环境搭建
**Windows下**
1.构建和打包前端项目 1.构建和打包前端项目
```bash ```bash
@ -128,15 +130,26 @@ server {
4.启动或重启 Nginx 4.启动或重启 Nginx
启动：双击nginx.exe
重启：nginx -s reload
5.查看是否正在运行
```bash ```bash
sudo nginx -t # 检查配置是否正确 tasklist /FI "IMAGENAME eq nginx.exe"
sudo systemctl restart nginx # 重启 Nginx 服务
``` ```
5.访问前端项目 6.访问前端项目
在浏览器中输入你配置的域名或服务器 IP 地址 在浏览器中输入你配置的域名或服务器 IP 地址
终止运行nginx：
```bash
nginx.exe -s stop
```
#### 后端环境搭建 #### 后端环境搭建
@ -292,17 +305,6 @@ server{
windows下更新nginx配置：先cd到nginx安装目录
```bash
nginx -t
nginx -s reload
```
#### APIFox #### APIFox
使用APIFox管理、测试接口、导出接口文档... 使用APIFox管理、测试接口、导出接口文档...
@ -463,9 +465,9 @@ public class EmployeeController {
## 后端代码部署 ## 后端部署
### 项目已经开发完毕 ### 项目开发完毕
这种情况下JAVA代码无需改动，直接本地打包maven->package成Jar包复制到服务器上部署： 这种情况下JAVA代码无需改动，直接本地打包maven->package成Jar包复制到服务器上部署：
@ -485,15 +487,15 @@ public class EmployeeController {
</dependency> </dependency>
``` ```
打包方式： **打包方式：**
1.直接对父工程执行mvn clean install 1.*直接对父工程执行mvn clean install
2.分别对子模块common和pojo执行install，再对server执行package 2.分别对子模块common和pojo执行install，再对server执行package
因为Maven 在构建 `sky-server` 时，去你本地仓库或远程仓库寻找它依赖的两个 SNAPSHOT 包。 因为Maven 在构建 `sky-server` 时，去你本地仓库或远程仓库寻找它依赖的两个 SNAPSHOT 包。
dockerfile： **JAVA项目dockerfile：**
```dockerfile ```dockerfile
# 使用 JDK 17 运行时镜像 # 使用 JDK 17 运行时镜像
@ -510,13 +512,105 @@ WORKDIR /app
COPY sky-server-1.0-SNAPSHOT.jar ./app.jar COPY sky-server-1.0-SNAPSHOT.jar ./app.jar
# 暴露端口（与 application.properties 中的 server.port 保持一致） # 暴露端口（与 application.properties 中的 server.port 保持一致）
EXPOSE 8080 EXPOSE 8085
# 以 exec 形式启动 # 以 exec 形式启动
ENTRYPOINT ["java", "-jar", "app.jar"] ENTRYPOINT ["java", "-jar", "app.jar"]
``` ```
`ENTRYPOINT ["java", "-jar", "app.jar"]` 能够启动 `ENTRYPOINT ["java", "-jar", "app.jar"]` 能够启动是因为Spring Boot 的 Maven 插件在打包时已经将你的启动类标记进去了：
Spring Boot 的启动器会：
1. 读取 `MANIFEST.MF` 里的 `Start-Class: com.sky.SkyApplication`
2. 将 `com.sky.SkyApplication` 作为入口调用其 `main` 方法
由于该项目还需依赖Mysql和Redis运行，因此需在**docker-compose.yml**中统一创建容器环境。（:ro代表只读）
```yml
version: "3.8"
services:
mysql:
image: mysql:8.0
container_name: sky-mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: 123456
MYSQL_DATABASE: sky_take_out
TZ: Asia/Shanghai
volumes:
- ./data/mysql:/var/lib/mysql
- ./init/sky.sql:/docker-entrypoint-initdb.d/sky.sql:ro
- ./mysql-conf/my.cnf:/etc/mysql/conf.d/my.cnf:ro
ports:
- "3307:3306"
redis:
image: redis:7.0-alpine
container_name: sky-redis
restart: always
command: redis-server --requirepass 123456
volumes:
- ./data/redis:/data
ports:
- "6379:6379"
app:
# 构建并打标签 sky-server:latest
build:
context: .
dockerfile: Dockerfile
image: sky-server:latest
container_name: sky-server
depends_on:
- mysql
- redis
# 挂载敏感配置到 /app/config
volumes:
- ./config:/app/config:ro
environment:
TZ: Asia/Shanghai
# 激活 dev 配置文件：application-dev.yml
SPRING_PROFILES_ACTIVE: dev
ports:
- "8085:8085"
restart: always
volumes:
mysql:
redis:
```
**其中启动数据库要准备两份文件：**
初始化脚本sky.sql，用来创建数据库和表
my.cnf：让初始化脚本创建的表中的中文数据正常显示
```cnf
[client]
default-character-set = utf8mb4
[mysql]
default-character-set = utf8mb4
[mysqld]
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect='SET NAMES utf8mb4'
```
**另外：**
`application-dev.yml` 是给 **Spring Boot** 读取的，Spring Boot 会在启动时自动加载它，填充到JAVA项目中。
Docker Compose 里的 `environment:` 无法读取`application-dev.yml`，要不就写死、要不就写在.env文件中。
**最后项目结构：**
![image-20250515092129486](https://pic.bitday.top/i/2025/05/15/f8ix5c-0.png)
@ -524,6 +618,24 @@ ENTRYPOINT ["java", "-jar", "app.jar"]
## 前端部署
直接部署开发完毕的前端代码，准备：
1.静态资源html文件夹
2.nginx.conf
![image-20250515111352735](https://pic.bitday.top/i/2025/05/15/iexngr-0.png)
注意把nginx.conf中的server改为Docker 容器（或服务）在**同一网络中**的主机名，如
```nginx
upstream webservers {
server sky-server:8085 weight=90;
}
```
## 实战开发 ## 实战开发