Dukeの快乐老家

从零搭建：CD2+Symedia+FastEmby实现302观影体验

Wed, 04 Feb 2026 00:00:00 GMT

:::warning
全文由人工撰写并通过AI寻找语病订正，如果无法接受可退出。
:::

1. 概览与先决条件

本文将在一台云服务器上，手把手带你从零开始搭建基于 115 网盘或 123 网盘的影视库。我们将结合 Symedia 进行自动化管理，并提供 Emby 服务端与 Infuse 直连两种观影路径。

在正式开始之前，我们需要理清整体的架构逻辑。

前情提要： 115 网盘对开放 API 接口有着极其严格的速率限制。这就导致了一个非常现实的问题：无论是使用刮削软件、Emby 还是 Infuse，如果选择直接挂载 115 网盘进行读取，扫库速度会慢到令人发指。添加新影片后，刮削入库的过程繁琐且漫长。更糟的是，Infuse 在直接挂载 115 网盘时，请求限制往往导致扫库卡顿，甚至无法起播。

与此同时，Infuse 虽然好用，但也有局限性：

在线元数据模式：无法获取 TMDB 里不存在的那类 影片信息。
离线元数据模式：识别率感人。

因此，引入 Emby 作为后端来统一管理元数据，是提高观影体验的必要手段。

:::note
主要方案流程：

存储：115网盘 / 123网盘
挂载：通过 CloudDrive (CD2) 挂载为本地目录
管理：Symedia 读取网盘目录树，生成指向本地路径的 STRM 文件，并自动下载影片元数据
媒体库：Emby 直接扫描 STRM 文件极速入库
播放（302） ：
- 客户端连接 FastEmby 反代端口
- STRM 链接被拦截并改写
- 115 视频由 FastEmby 获取直链
- 123 等其他盘由 OpenList 302 挂载模式获取直链
客户端：Infuse/Emby直连网盘地址流畅观看

:::

然而，原生的 Emby 在起播 STRM 文件之前，有一个顽固的机制：它总是会尝试读取文件头部，使用 ffprobe -i 获取视频的编码、音轨等详细信息。这带来了三个严重的副作用：

起播龟速：客户端点击播放后需要转圈很久。
流量爆炸：服务端为了读取文件头，会消耗大量下行流量，对于按流量计费的服务器不友好。
性能崩溃：在处理结构不良的 MKV 或 ISO 原盘文件时，可能消耗上 GB 的流量并耗尽低配服务器的内存与磁盘 IO，直接导致假死。

在 Symedia 的官方 Wiki 中有关于此问题的详细描述：Symedia Wiki-神医插件。简单来说：这款 Emby 插件可以有效解决问题 1（起播慢），但对问题 2 和 3 的改善有限。

因此，针对服务端配置较低、或者对起播速度有极致要求的场景，这里也提供一套去除了 Emby 的备选方案。代价是牺牲了媒体库的自由划分能力，且无法展示特殊影片的海报墙。但经实测，该方案针对 Remux 动漫和电影，起播速度可压缩至 2-5 秒。

:::note
备选方案流程（极速起播）：

存储：115网盘 / 123网盘
挂载：CloudDrive (CD2) 挂载
管理：Symedia 生成指向 OpenList 的 STRM 文件（而非本地路径），并下载元数据
播放（302） ：
- Infuse 直接挂载包含 STRM 的文件夹（通过 WebDAV）
- 所有视频请求由 OpenList 302 模式获取直链
终端：客户端直连网盘观看

:::

如果既想观看特殊影片，又希望普通影片在低配服务器上秒播，可以混合使用这两种方案。即：普通影片走备选方案（Infuse 直连），特殊影片走主要方案（Emby 管理）。

让我们开始吧！

本文所需的前置条件：

:::important

一台 NAS 或云服务器（必需）
115 网盘或 123 网盘账号（必需，需付费）
Symedia 激活码（必需，179 元）
Infuse PRO（备选方案必需，需付费）
CloudDrive 会员（若挂载多个网盘则必需）
Emby 激活码（可选，也可寻找某种版本）

:::

2. 服务端准备工作

2.1 虚空终端（网络环境配置）

Symedia 在刮削元数据、通过 Bot 推送通知以及我们拉取 Docker 镜像时，需要一个相对科学的网络环境。

如果你使用的是家用 NAS，解决方式较多：

旁路网关：在局域网内运行基于虚空终端的软件，开启“允许局域网连接”，获取内网代理地址（如 192.168.1.x:7890）
透明代理：在主路由或软路由层面解决
本机运行：直接在服务端运行虚空终端核心

下面重点介绍方法 3，它同时适用于云服务器和 NAS 环境。

操作步骤：

下载核心：用电脑下载适用于你服务器架构（通常是 linux-amd64）的虚空终端核心并解压。
上传文件：将核心文件上传到服务器的工作目录，假设重命名为 mihomo-linux-amd64。

安装与配置：执行以下命令，创建目录并赋予权限。

sudo mv mihomo-linux-amd64 /usr/local/bin/mihomo
sudo chmod +x /usr/local/bin/mihomo
sudo mkdir -p /etc/mihomo
sudo vi /etc/mihomo/config.yaml

编辑配置文件：先填入下面的基础配置，然后从你自己的订阅配置文件中复制 proxies、proxy-groups 和 rules 部分填入下方。

# 基础端口设置
port: 7890
socks-port: 7891
mixed-port: 7893
allow-lan: true
mode: Rule
log-level: info
ipv6: true
external-controller: '0.0.0.0:9990'
secret: "您的后台密码"
external-ui: /etc/mihomo/ui

# --- 关键：TUN 模式配置 ---
# 在拉取 Docker 镜像时非常有用，日常运行可关闭
tun:
  enable: false
  stack: system # 或者 gvisor
  dns-hijack:
    - any:53
  auto-route: true
  auto-detect-interface: true

# --- 关键：DNS 配置 (配合 TUN 必须开启 fake-ip 或 redir-host) ---
dns:
  enable: true
  listen: 0.0.0.0:53
  enhanced-mode: fake-ip
  nameserver:
    - 8.8.8.8
    - 1.1.1.1

# --- 请在下方粘贴您的 proxies, proxy-groups, rules ---

配置 UI 面板：下载 Metacubexd 或其他 UI 的 release 压缩包，解压后将文件夹内的所有文件放入 /etc/mihomo/ui。
注意：运行时如果提示缺少 MMDB 文件，请自行下载 Country.mmdb 放入 /etc/mihomo 目录。

设置开机自启：
创建服务文件：

sudo nano /etc/systemd/system/mihomo.service

填入内容：

[Unit]
Description=Mihomo Daemon
After=network.target

[Service]
Type=simple
User=root
# TUN 模式必须用 root 权限运行
ExecStart=/usr/local/bin/mihomo -d /etc/mihomo
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务：

sudo systemctl daemon-reload
sudo systemctl enable mihomo --now
sudo systemctl status mihomo

验证：访问 http://服务器IP:9990/ui，填入服务器 IP 和密码即可进入控制面板。

2.2 Docker 环境

在安装 Docker 和拉取镜像之前，建议先在虚空终端的网页面板中，开启 “配置” -> “开启 TUN 转发”。下载完成后记得关闭此开关，以免影响其他服务。

安装 Docker ：

curl -fsSL https://get.docker.com | bash

3. 安装 CD2 与 OpenList

CloudDrive2 (CD2)

此处不使用 Docker 版本的 CD2，前往 CloudDrive2 官网下载 Linux x86_64 版本。

请详细阅读 CD2 官方教程。将下载的 tgz 包解压到你的工作目录，例如 /root。解压后，最终的可执行文件路径应类似：/root/clouddrive-2-linux-x86_64-x.x.x/clouddrive。

设置开机自启服务：

sudo nano /etc/systemd/system/clouddrive.service

[Unit]
Description=CloudDrive Daemon
After=network.target

[Service]
Type=simple
User=root
# 请根据实际解压路径修改 WorkingDirectory 和 ExecStart
WorkingDirectory=/root/clouddrive-2-linux-x86_64-你的版本号
ExecStart=/root/clouddrive-2-linux-x86_64-你的版本号/clouddrive
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动 CD2：

sudo systemctl daemon-reload
sudo systemctl enable clouddrive --now
sudo systemctl status clouddrive

安装完成后，可通过 http://服务器IP:19798 访问 CD2 管理页面。

OpenList

OpenList 是一个轻量级的目录列表程序，支持 302 重定向，是本方案中处理非 115 网盘（如 123 盘）直链的工具。

使用官方一键脚本安装（脚本可能随时间更新，建议到官网一键安装寻找最新脚本）：

curl -fsSL https://res.oplist.org/script/v4.sh > install-openlist-v4.sh && sudo bash install-openlist-v4.sh

脚本运行过程中选择“安装OpenList”即可。安装完成后，通过 http://服务器IP:5244 访问。初始用户名和密码会显示在终端输出中，请务必记录。如果遗忘，可再次运行脚本重置密码。

4. 创建 Symedia、Emby、FastEmby 容器

这一步涉及到路径映射，逻辑需要非常清晰。

我们将通过 CD2 把网盘挂载到宿主机的本地路径。

对于群晖/飞牛等 NAS，通常挂载到 /volume1/CloudNAS。
对于普通 Linux 服务器，推荐挂载到 /mnt/CloudNAS。

关键： 本文不使用 Docker 化的 CD2，因此挂载路径完全由我们控制。为了统一后续配置，我们假设宿主机的挂载点为 /mnt/CloudNAS/CloudDrive。

:::note
关于 Symedia 官方 Wiki 的说明： Wiki 中的逻辑是针对“全容器化”场景，即网盘在宿主机的路径和在 CD2 容器内的路径存在映射关系。由于我们直接在宿主机运行 CD2，请勿参考 Wiki 中“标准挂载”部分的映射逻辑。
:::

请直接复制以下命令创建容器，确保路径一致。

Symedia

Symedia 负责刮削、整理和生成 STRM。

docker run -d \
    --name symedia \
    -e TZ=Asia/Shanghai \
    -e LICENSE_KEY=你的Symedia激活码 \
    -e COVER_MAKER=true \
    -e HTTP_PROXY=http://127.0.0.1:7890 \
    -v /var/run/docker.sock:/var/run/docker.sock:ro \
    -v ./config:/app/config \
    -v ./playwright:/symedia/.cache/ms-playwright \
    -v ./fonts:/app/static/fonts \
    -v /mnt/CloudNAS:/CloudNAS:rslave \
    -v /mnt/media_strm:/media \
    -p 8095:8095 \
    --restart always \
    --network host \
    shenxianmq/symedia:latest

HTTP_PROXY：指向你搭建的虚空终端。如果 Symedia 使用 host 网络模式，填 127.0.0.1:7890 即可；否则需填服务器内网 IP。
/mnt/CloudNAS：这是 CD2 挂载网盘的根目录的上级目录。
/mnt/media_strm：这是 Symedia 生成的 STRM 文件存放的本地路径。

访问端口：8095

Emby

媒体服务器核心。

docker run -d \
  --name emby_server \
  --restart always \
  --network host \
  -e PUID=0 \
  -e PGID=0 \
  -e TZ=Asia/Shanghai \
  -v /mnt/emby_data:/config \
  -v /mnt/CloudNAS:/CloudNAS:rslave \
  -v /mnt/media_strm:/media \
  linuxserver/emby:latest

/mnt/emby_data：Emby 的配置数据目录，可以改变。
/mnt/media_strm:/media：将 Symedia 生成的 STRM 映射给 Emby 读取。

访问端口：8096

FastEmby

用于接管 115 视频流量并实现重定向。

docker run -d \
  --name FastEmby \
  --network host \
  --restart unless-stopped \
  -e LICENSE_KEY=你的Symedia激活码 \
  -v /mnt/fastEmby/config:/app/config \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  shenxianmq/fastemby:latest

访问端口：9026

:::danger
所有容器部署完毕后，请务必回到虚空终端面板，将 TUN 模式 开关关闭，避免影响服务器正常的网络流量转发。
:::

5. 在 CD2 和 OpenList 挂载网盘

CloudDrive2 挂载

访问 CD2 后台，登录你的 115 和 123 网盘账号。

115 网盘挂载名设为：/115open
123 网盘挂载名设为：/123云盘

进入“挂载”，点击添加挂载点。按照下图填写，将网盘挂载到我们预设的 /mnt/CloudNAS/CloudDrive。

挂载完成后，进入“我的文件”，找到网盘内的影视库文件夹，点击“详情”，将缓存时间修改为 0 秒。如果后期遇到添加了影片，但是Symedia却找不到文件、无法链接的情况，可以点击黄色时钟按钮清空缓存。

目录结构建议： 为了配合 Symedia 的自动整理，建议按照如下树状结构组织你的网盘影视库：

115影视库
├── 电影
│   └── 上海堡垒 (2019)
│       ├── 上海堡垒 (2019) {tmdb-xxxxx} - 4K DV.mkv
│       └── (元数据)
├── 动漫
│   └── 笨女孩 (2017)
│       ├── (元数据)
│       └── Season 1
│           ├── (集元数据)
│           └── 笨女孩 (2017) S01E01 - 标题.mkv
├── 演唱会
└── 电视剧

OpenList 挂载

OpenList 主要用于解决 123 盘等非 115 网盘的直链分发。

全局设置：进入设置 -> 全局，关闭“签名所有”。
添加驱动：
- 进入存储 -> 添加。
- 驱动选择：123开放平台
- 挂载路径：/123云盘
- WebDAV 策略：302 重定向
- 其他参数（客户端 ID、密钥等）：请参考 OpenList 官方文档 - 123开放平台驱动获取并填写

6. 配置 Symedia

6.1 插件配置：EmbyServer

进入 Symedia 插件中心，找到 EmbyServer。
按照下图填写 Emby 地址和 API Key。API Key 可以在 Emby 后台 -> API 页面生成。填写完毕记得保存。

6.2 添加网盘账号

115 设置：设置 -> 115设置 -> 添加配置 -> 随便填写名称 -> 保存。
- Cookie 获取：去插件中心安装“115扫码cookie”插件，扫码获取 Cookie 后，可以一键填入刚才创建的配置中。
123 设置：设置 -> 123设置 -> 直接填写账号密码保存。

6.3 STRM 链接同步

115 网盘同步任务： 打开“链接同步”界面，创建任务。

媒体目录：选择 CD2 挂载的 115 影视库目录。
链接目录：选择 /media/影视库115（Symedia 容器内的路径）。

在“实时监控”选项卡中，选择 Webhook 模式。

123 网盘同步任务： 创建新任务，设置逻辑同上，但请注意下图红框标记的字段。

6.4 连接 CD2 并开启 Webhook

Symedia 插件 -> clouddrive2助手。

服务器地址：填写 CD2 的访问地址（如果你的CD2是容器化的，IP填写服务器的内网IP，如果你按照本文来部署的，无需改动）。
API Token：在 CD2 界面创建一个拥有**所有权限**的 Token 填入。

保存配置后，Symedia 就能接收到 CD2 的文件变动通知。

6.5 运行同步与归档

启动同步：在链接同步界面，启动 115 和 123 的任务。可以在日志中查看进度。
如果卡住，可以在“CD2-系统任务-下载任务”查看情况，通常是由于下载到了体积较大的元数据或者多音轨。这是正常现象，如果嫌慢，可以编辑任务-高级配置-元数据后缀-去掉mka,mp3,flac等体积可能较大的文件。
配置自动归档：
- 创建规则：Symedia -> 归档刮削 -> 规则。推荐使用“自动二级分类”，文件名保持默认。
- 创建任务：Symedia -> 归档刮削 -> 任务列表。源目录指向网盘内的“影视库待归档”文件夹，目标目录指向正式的“影视库”文件夹。

设置完成后，只需将下载或转存的影片丢入“待归档”文件夹，Symedia 就会全自动刮削、重命名并移动到影视库，整个过程行云流水。

7. 配置 Emby 媒体库 + FastEmby

Emby 媒体库设置：
进入 Emby 设置 -> 媒体库。
将/media内的文件夹按你的喜好添加为媒体库，去掉一切可能导致读取视频信息、生成缩略图有关的选项。之后开始扫库，体验速度带来的快感，所有人保持衣物干燥。
FastEmby 设置：
打开 FastEmby 后台，参照下图配置：
- 115 授权：打开 Symedia 设置 -> 115设置，复制 Cookie。然后去 FastEmby -> 115助手，粘贴并测试。

最终效果：
客户端连接 http://服务器IP:8098（FastEmby 的反代端口），即可实现 302 播放。Emby 负责展示精美的海报墙，FastEmby 负责在后台偷梁换柱。

至此，新片转存后，Emby将会快速完成入库。emby由于会在播放前尝试解析视频信息，导致起播速度缓慢，可通过购买神医助手插件解决，详见本文开头部分。注意，这无法解决服务器流量消耗和配置不足、解析视频时卡死的问题。

8. 低配服务器的备用方案（极速起播）

如果服务器配置实在太低或者流量费用太高，可以将普通影片的播放任务完全交给 Infuse，抛弃 Emby，或者只把Emby用于特殊影片的观看。

原理变更： 在备用方案中，Symedia 生成的 STRM 文件不再包含指向本地文件的路径，而是直接指向 OpenList 的网盘视频文件地址。Infuse 挂载 OpenList STRM文件夹后，请求视频时，OpenList 直接返回网盘直链（302 跳转），Infuse 随之直连网盘。

改造步骤：

清理旧数据：
删除 /mnt/media_strm 内的所有旧 STRM 文件（因为它们是给 Emby 用的本地路径）。
先预览要删除的文件：
```
find /mnt/media_strm -type f -name "*.strm"
```
确认无误后，执行删除：
```
find /mnt/media_strm -type f -name "*.strm" -delete
```
修改同步任务：
回到 Symedia -> 链接同步，修改 115 和 123 的任务配置。
重点关注红框部分，将链接前缀指向 OpenList 路径。

重新执行同步任务。这次速度会飞快，因为元数据之前已经下载过了。
配置 OpenList：
- 添加本机存储：
  进入 OpenList -> 存储 -> 添加。
  驱动：本机存储。
  挂载路径：/media_strm。
  根文件夹路径：/mnt/media_strm（即 Symedia 生成 STRM 的位置）。
  保存。
- 添加 115 存储：
  驱动：115开放平台。
  挂载路径：/115open。
  WebDAV 策略：302 重定向。
  令牌获取方式到OpenList官方文档去查
Infuse 客户端设置：
- 添加 WebDAV 共享。
- 地址：服务器 IP，端口 5244。
- 用户名/密码：OpenList 的账号密码（默认是admin）。
- 路径：/dav/media_strm。
- 关闭“预获取详情”和“预缓存海报”，但可以开启“智能文件夹”。

等待 Infuse 扫描完成，点击播放。此时，Infuse 获取到的是经过 OpenList 302 重定向后的直链，起播速度通常在 5 秒以内，拖拽进度条丝般顺滑。

借助Nginx实现 NAS 服务内外网无缝访问

Wed, 09 Apr 2025 00:00:00 GMT

告别手动切换！实现 NAS 服务内外网无缝访问

自从组建了我的丐版 NAS 后，生活便利了不少。我在上面部署了 Komga 漫画库、Emby 媒体服务器、用于同步的 WebDAV 服务，以及 qBittorrent 下载器等。借助内网穿透，这些服务都能通过专属域名从公网访问。理论上，无论我身在何处，即使校园网宵禁，也能愉快地使用 NAS 上的资源。

下面是我的网络拓扑示意图：

然而，一个恼人的问题始终困扰着我：
每当我在宿舍内网和外部网络环境之间切换时（比如从宿舍的 Wi-Fi 切换到手机热点或校园网），都必须手动更改各种客户端软件或网页书签中的 URL 地址。这意味着我不得不在 192.168.5.123 (内网 IP) 和 mynas.com (我的公网域名，此处为示例) 之间反复横跳，才能重新连接服务。这涉及到手机上的文件管理器、相册同步工具、Emby 客户端等等。

更令人抓狂的是，有些应用天生就不适合这种频繁切换。例如，Mihon 的 Komga 插件，一旦添加了某个源（漫画库），除非执行繁琐的手动迁移（而且只能一本一本地操作），否则根本无法更改其目标服务器地址。难道我为了能在内外网都能看漫画，需要在插件里把同一个漫画库添加两遍（一个内网 IP 版，一个公网域名版）吗？即便如此，版本冲突、阅读进度同步等新问题又会接踵而至。还有各类软件内置的 WebDAV 同步功能，通常只允许设置一个服务器地址，来回修改配置几乎不可能。

这种不便极大地影响了我享受珍藏资料的热情。毕竟，谁愿意在想看电影、追漫画或读小说之前，先折腾一通服务器地址，然后焦急地等待加载圈转完呢？我们存储资源是为了欣赏，开启 WebDAV 是为了便捷同步，如果这些基本操作都变得费时费力，那 NAS 的乐趣何在？本文就将分享我如何解决这个问题，实现内外网访问的无缝切换。

我的网络环境

在开始之前，先明确一下我的网络状况：

NAS 主机: 运行在家庭内网，固定 IP 地址为 192.168.5.123。
内网访问: NAS 上运行的各项服务（如 Emby, Komga 等）分别监听不同的端口，例如 5001, 5002, 5003 等。在内网中，可以直接通过 http://192.168.5.123:端口号 的方式访问这些服务。
外网访问: NAS 上运行了内网穿透客户端，将内网服务暴露到公网。可以通过 https://mynas.com:外网端口号 的方式访问，其中 mynas.com 是我的域名，外网端口号 是由穿透服务商分配的公网端口（例如 1234）。

核心问题: 内外网访问时，不仅 主机名 (192.168.5.123 vs mynas.com) 不同，端口号 (内网服务端口 vs 外网穿透端口) 和 协议/加密方式 (HTTP vs HTTPS) 也可能完全不同！

探索解决方案

为了解决这个地址统一性的问题，我进行了一些尝试，查阅了论坛资料，并与 AI 进行了探讨，初步筛选出以下几个看似可行的方案：

异地组网工具 (如 Tailscale, ZeroTier, WireGuard 自建等)
- 优点: 可以在外部网络环境下，通过虚拟局域网 IP 直接访问 NAS，似乎绕过了公网穿透。
- 缺点: 这些工具通常会分配新的虚拟内网 IP (例如 10.x.x.x 或 172.x.x.x)，而不是我原来的 192.168.5.123。这并没有解决需要统一访问地址的核心问题。此外，在国内网络环境下，某些服务的连接速度可能不尽人意。
利用 DNS 服务商的解析记录
- 优点: 某些 DNS 服务商允许设置特殊的解析规则，可以将域名在特定条件下解析到内网 IP。理论上，在家时访问 mynas.com 就能指向 192.168.5.123。
- 缺点: 这只能解决内网访问的问题。一旦离开内网，域名解析到的仍然是内网 IP，自然无法连接。更重要的是，它无法解决内外网端口不一致以及内网访问时 HTTPS 证书无效的问题。
在路由器上设置 DNS 劫持/重定向
- 优点: 这似乎是最接近目标的方案。通过在路由器上设置规则，强制将 mynas.com 在局域网内解析到 NAS 的内网 IP 192.168.5.123。这样，无论在内网还是外网，访问 mynas.com 时：
  - 在内网：DNS 查询被路由器拦截，返回 192.168.5.123。
  - 在外网：DNS 查询正常进行，返回公网 IP（穿透服务器的 IP）。
- 缺点: 这个方案本身也存在两个问题：
  - 端口不一致: 内网服务端口（如 5001）和外网访问端口（如 1234）仍然不同。客户端依然需要根据网络环境切换端口。
  - SSL 证书问题: 当在内网通过 https://mynas.com:1234 访问时，虽然 DNS 解析到了 192.168.5.123，但浏览器/客户端请求的是 mynas.com 的证书。如果直接访问 NAS 上的原始服务端口（如 5001），该服务很可能没有配置或配置了错误的 SSL 证书，导致连接失败或出现安全警告。

综合来看，方案 3 (路由器 DNS 劫持) 是最有潜力的，其核心思路正确——让域名在不同网络环境下指向不同的 IP。剩下的端口和 SSL 证书问题，可以通过在 NAS 上部署一个 Nginx 反向代理 来完美解决。

实现过程

最终的实现步骤分为两大部分：路由器 DNS 配置和 NAS 上的 Nginx 反向代理配置。

1. 配置路由器 DNS 劫持

登录路由器管理界面，不同品牌路由器界面不同，找到 DNS 相关设置，通常被称为“静态主机名”、“DHCP/DNS”、“局域网 DNS”或类似名称。添加一条规则，将你的公网域名 mynas.com 解析到 NAS 内网 IP 192.168.5.123。

设置完成后，当设备连接到这个路由器下的局域网时，任何对 mynas.com 的 DNS 查询都会被路由器直接响应为 192.168.5.123。这样，访问 https://mynas.com:1234 在内网实际上就是在访问 https://192.168.5.123:1234。

(在 OpenWrt 路由器中设置 DNS 主机名)

2. 在 NAS 上配置 Nginx 反向代理

接下来解决端口和 SSL 证书问题。我们需要在 NAS 上安装 Nginx，并配置它来监听外网访问的端口（例如 1234），处理 mynas.com 的 HTTPS 请求，然后将请求转发给 NAS 上实际运行服务的内网端口（例如 5001）。

前提: 确保你已经拥有 mynas.com 域名的 SSL 证书文件（通常是 .pem 或 .crt 文件）和私钥文件（通常是 .key 文件），并将它们上传到 NAS 的某个目录下。

步骤 1: 安装 Nginx (假设 NAS 运行的是 Debian/Ubuntu 或类似的 Linux 系统)

# 更新软件包列表
sudo apt update

# 安装 Nginx
sudo apt install nginx -y

# 检查 Nginx 服务状态 (应显示 active/running)
sudo systemctl status nginx
# 按 q 退出状态查看

# 设置 Nginx 开机自启 (通常安装后会自动设置，此命令确保启用)
sudo systemctl enable nginx

步骤 2: 存放 SSL 证书和私钥

建议将证书文件放在 Nginx 的标准配置目录下。

# 创建 SSL 证书存放目录 (如果不存在)
sudo mkdir -p /etc/nginx/ssl/

# 复制证书和私钥到指定位置
# 注意：请将 /path/to/your/certificate.pem 替换为你的证书文件实际路径
sudo cp /path/to/your/certificate.pem /etc/nginx/ssl/mynas.com.pem
# 注意：请将 /path/to/your/private.key 替换为你的私钥文件实际路径
sudo cp /path/to/your/private.key /etc/nginx/ssl/mynas.com.key

# 设置严格的权限，保护私钥（非常重要）
sudo chown root:root /etc/nginx/ssl/mynas.com.key
sudo chmod 600 /etc/nginx/ssl/mynas.com.key

# 证书文件权限可以相对宽松些
sudo chmod 644 /etc/nginx/ssl/mynas.com.pem

提醒：如果你的证书文件后缀是 .crt 而不是 .pem ，请在后续 Nginx 配置中也使用 .crt 。

步骤 3: 备份默认 Nginx 配置 (可选但推荐)

sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup
sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/default.backup

步骤 4: 创建 Nginx 配置文件

推荐在 /etc/nginx/sites-available/ 目录下为你的 NAS 服务创建一个新的配置文件。

sudo nano /etc/nginx/sites-available/nas_proxy

步骤 5: 编写 Nginx 代理配置

在打开的编辑器中，粘贴并修改以下配置。这个示例配置会让 Nginx 监听 1234 端口上的 HTTPS 请求，并将流量转发到本机 (127.0.0.1) 的 5001 端口 (假设这是 Emby 或 Komga 的内网端口)。

server {
    listen 1234 ssl http2;        # 监听的外网端口 (需要与你外网访问时使用的端口一致)，启用 SSL 和 HTTP/2
    listen [::]:1234 ssl http2;   # 同时监听 IPv6 地址

    server_name mynas.com;         # 你的域名

    # SSL 证书配置
    ssl_certificate /etc/nginx/ssl/mynas.com.pem;      # 指向你的证书文件
    ssl_certificate_key /etc/nginx/ssl/mynas.com.key;    # 指向你的私钥文件

    # SSL 安全性设置 (推荐使用较新的协议)
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers off; # 通常设为 off 或 on 均可，现代浏览器协商能力强

    # 访问日志和错误日志 (自定义文件名，方便区分)
    access_log /var/log/nginx/mynas.com_1234.access.log;
    error_log /var/log/nginx/mynas.com_1234.error.log;

    location / {
        # 核心：反向代理配置
        # 将请求转发给实际的服务端口 (这里是 5001)
        # 如果 Nginx 和目标服务在同一台机器，使用 127.0.0.1 是最高效的
        proxy_pass http://127.0.0.1:5001;

        # 设置必要的 HTTP 头信息，以便后端服务能正确处理请求
        proxy_set_header Host $host; # 传递原始 Host 头
        proxy_set_header X-Real-IP $remote_addr; # 传递客户端真实 IP
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # 记录代理链 IP
        proxy_set_header X-Forwarded-Proto $scheme; # 告知后端是 http 还是 https

        # 支持 WebSocket (对 Emby, qBittorrent WebUI 等可能需要)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    # 如果你需要代理其他服务到不同的外网端口，可以复制上面的 server {} 块，

}

步骤 6: 启用新的配置文件并禁用默认配置

sudo ln -s /etc/nginx/sites-available/nas_proxy /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

步骤 7: 测试 Nginx 配置并重启服务

# 测试配置文件语法是否有错误
sudo nginx -t

# 如果测试通过 (显示 syntax is ok 和 test is successful)，则重启 Nginx 服务
sudo systemctl restart nginx

步骤 8: 配置 NAS 防火墙

确保 NAS 的防火墙允许外部（在这里指局域网内部和潜在的公网）访问 Nginx 监听的端口（在我们的例子中是 1234 TCP 端口）。

如果你使用 ufw:

# 允许访问 1234 端口
sudo ufw allow 1234/tcp
# 重新加载防火墙规则
sudo ufw reload
# 查看防火墙状态确认规则已添加
sudo ufw status

如果你使用 firewalld:

# 永久添加允许 1234 端口的规则
sudo firewall-cmd --permanent --add-port=1234/tcp
# 重新加载防火墙规则使之生效
sudo firewall-cmd --reload
# 列出所有规则确认
sudo firewall-cmd --list-all

步骤 9: 验证效果

现在，无论你的设备连接的是家庭内网 Wi-Fi 还是外部网络（如手机流量、校园网），尝试通过 https://mynas.com:1234 访问服务。

在内网: 路由器 DNS 会将 mynas.com 解析到 192.168.5.123。你的请求 https://mynas.com:1234 实际上发送给了 192.168.5.123 上的 Nginx。Nginx 使用正确的 SSL 证书响应，并将请求代理到内部的 http://127.0.0.1:5001。
在外网: DNS 将 mynas.com 解析到你的公网 IP（或穿透服务器的 IP）。请求 https://mynas.com:1234 通过内网穿透隧道到直接达 NAS 上内部的 http://127.0.0.1:5001。

你应该能够在这两种网络环境下都成功访问服务，并且浏览器不会再报 SSL 证书错误。

最终效果

经过以上配置，我终于实现了 NAS 服务在内外网访问上的无缝切换！现在，所有的客户端软件（Emby, Komga 插件, 文件同步工具等）只需要设置唯一的地址：https://mynas.com:外网端口号 (例如 https://mynas.com:1234)。

身处内网时：请求会被路由器智能地导向 NAS 的内网 IP，数据直接在局域网内高速传输，即使外部网络中断（例如校园网断网）也完全不受影响。
身处外网时：请求则通过公网和内网穿透通道，同样能够无缝访问到 NAS 上的资源。

更重要的是，由于无论是内网（通过 Nginx 代理）还是外网访问，客户端收到的都是与 mynas.com 域名匹配的有效 SSL 证书，因此浏览器或 App 不会再弹出“不安全”、“证书无效”或“服务器发送了无效响应”之类的恼人警告了。

现在，我可以随时随地、无需任何手动干预，畅快地欣赏 NAS 上的漫画、电影，或者让相册、笔记等自动同步了。这才是 NAS 该有的便捷体验！

(Emby 客户端现在只需一个地址就能稳定连接)

数据库课程笔记

Wed, 09 Apr 2025 00:00:00 GMT

课程信息

教材: 《数据库系统概论》, 《Database System Concepts》（7th Edition）
作业: 线上提交
实验: 内网地址上传

绪论

概念

数据库 (Database) : 合理存放、有关联、有结构的数据集合
数据库管理系统 (DBMS) :
是计算机的系统软件; 位于用户（应用程序）和操作系统之间；
3个重要组成部分包括：数据定义功能 , 数据组织/存储/管理 (存储引擎) , 数据存取功能 (查询引擎) , 数据库运行管理功能 (事务) , 数据库建立和维护功能 , 数据库的传输功能
数据库系统 (DBS) : 组成:
硬件, 软件 (操作系统, 数据库管理系统, 应用开发工具, 高级语言及其编译系统), 数据库 (工作数据, 数据字典), 用户 (数据库管理员, 系统分析员, 应用程序员, 终端用户)

数据库应用系统 (DBAS) : 数据库系统及其应用程序的组成; 也常被称为应用软件
数据库系统的特点:
- 数据整体结构化: 与文件系统的根本区别，含数据本身和数据之间的整体结构化
- 数据的共享性高: 冗余度低，减少数据不一致性
- 数据的独立性高
- 数据由DBMS统一管理和控制

数据模型

数据模型应满足: 能够真实模拟现实世界, 容易被人理解, 容易在计算机上实现
模型分类:
- 概念模型: E－R模型，UML模型; 面向用户，主要用于数据库设计
- 逻辑模型: 层次模型，网状数据模型，关系数据模型，面向对象模型; 面向DBMS实现
- 物理模型: 描述数据在系统内部的表示和存取，面向计算机系统
模型的要素: 数据**结构 , 数据操作 , 数据的约束条件**
E－R模型:
- 现实世界概念: 实体，实体特性（属性），实体集，实体标识符
- 信息世界概念: 实体型，属性，实体，联系
- 计算机世界概念: 记录型，字段，记录，码
实体标识符: 能够唯一标识一个实体的最小的数据集合
实体（集）间的联系:
- 二元联系:
  1. 一对一 (1:1) : 实体集A中每个实体，B中至多一个实体与之联系，反之亦然
  2. 一对多 (1:n) : 实体集A中每个实体与B中任意个实体联系，B中每个实体至多和A中一个实体联系，有方向
  3. 多对多 (m:n) : 实体集A、B中每个实体都和另一个实体集中任意个实体联系

多元联系: 参与联系的实体集个数~3时，称为多元联系; 如学生、教师、课程实体集之间的“教学“联系是三元联系
自反联系: 同一实体集内两部分实体之间的联系，特殊的二元联系; 例如学生实体集的班长和同学
E－R图:

常用结构数据模型

层次模型:
- 节点之间联系基本方式是1 : n; 满足条件：只有一个根节点，根外节点只有一个双亲节点；通过冗余数据、虚拟记录等手段也能表示多对多关系
- 优点: 查询效率高，结构简单，层次分明，便于实现
- 缺点: 不适合表示非层次复杂联系，层次顺序严格增删限制多，查询复杂

网状模型:
- 取消了层次模型限制，允许一个以上节点无双亲，一个节点允许有一个以上双亲; 记录型之间的联系通过“系"(Set)实现；箭头指向 1 : n 联系的 n 方；多对多联系可用两个一对多联系实现

关系模型:
- 关系 (Relation) 的性质: 属性不可分解，域应是原子数据集合；没有相同行列，行列顺序无关
- 关系模式 (Relation Schema) : 关系中信息内容结构的描述

它包括关系名、属性名、每个属性列的取值集合、数据完整性约束条件以及各属性
间固有的数据依赖关系等。因此,关系模式可表示为:
$R(U,D, DOM,I,\Sigma)$

其中:

R是关系名;

U是组成关系R的全部属性的集合;

D是U中属性取值的值域;

DOM 是属性列到域的映射,即$DOM: U \rightarrow D$,且每个属性$A_i$所有可能的取值集合构成
$D_i(i=1,2,...,n)$,并允许$D_i=D_j,i \neq j$;

数据库原理与应用(MySQL版)

I是一组完整性约束条件;

$\Sigma$是属性集间的一组数据依赖。

通常,在不涉及完整性约束及数据依赖的情况下,为了简化,可用R(U)表示关系模式。
例如,学生关系模式可表示为:

S(学号,姓名,性别,年龄,学院)

在层次和网状模型中,联系是用指针来实现的,而在关系模型中,联系是通过关系模式中的关键字来体现的。

面向对象模型

数据库系统结构

三级模式结构:
外部模式 (External Schema) / 视图层,
概念模式 (Conceptual Schema) / 模式层,
内部模式 (Internal Schema) / 存储层

数据独立性: 应用程序和数据结构之间相互独立,不受影响; 在三层模式体系结构中，指某一层次模式改变不影响上一层模式的能力
- 逻辑独立性: 模式变化, 外模式/应用程序无须改变; 外模式/模式映像保证逻辑独立性
- 物理独立性: 內模式改变，概念模式无需改变; 模式/内模式映像保证物理独立性
外模式／模式映像？模式／内模式映像？ [需要人工补充]
用户通过DBMS访问数据库的过程:

DBMS 的工作过程:
1. 接受应用程序的数据请求
2. DBMS 分析用户操作请求
3. DBMS 向操作系统发操作请求
4. 操作系统处理数据, 结果送系统缓冲区, 发读完标志
5. DBMS 接信号, 缓冲区数据经模式映射变用户逻辑记录送用户区, 给用户成功/失败信息

关系数据库

关系模型

域 (Domain) : 一组相同数据类型的值的集合
笛卡尔积:$D_1 \times D_2 \times \cdots \times D_n = {(d_1, d_2, \dots, d_n)| d_i \in D_i, i=1,2,\dots,n}$
关系 (Relation) : 一组域的笛卡尔积的子集
码 (Key) :
- 候选码 (Candidate Key) : 关系中唯一标识元组的属性或**最小属性集**
- 主码 (Primary Key) : 选择一个候选码为主码
- 主属性 (Prime Attribute) : 包含在任何一个候选码中的属性; 剩下的都是非主属性
- 外码 (Foreign Key) : 基本关系 R 的属性F (非R的码)，关系S的主码Ks，若F与Ks对应, 则F是R的外码, R为参照关系, S 为被参照关系
  例如:
  - 学生表：学生（学生学号, 姓名, 性别, 出生年份, 专业编号, 身份证号码）
  - 专业表：专业（专业编号, 专业名称, 专业负责人）
  学生表主码"学生学号", 专业表主码"专业编号", 学生表"专业编号"参照专业表专业取值, "专业编号"是学生表外码； "专业编号"作为专业表主码和学生表外码, 实现两表关联；表的联系通过公共属性实现，公共属性是一个表的主码和另一表的外码

‍

关系的性质

关系的性质

列是同质的：每列数据类型相同，来自同一个域。
不同的列可以有相同的域。
行列顺序无所谓。
任意两行的候选码不能相同。
每个分量必须是不可分的。

关系操作

关系操作分为：检索、更新。

更新操作分为：插入、删除、修改。

关系数据库管理系统一般向用户提供4种数据操纵：数据检索，插入，删除，修改。

操纵的对象是关系。基本操纵方式有5种：属性指定，元组选择，关系合并，元组插入，元组删除。

关系完整性约束

实体完整性规则：主属性不能取空值。
参照完整性规则：外码必须是被参照关系中主码的有效值，或者是一个空值。
用户定义完整性规则。

关系代数

基本关系运算

基本关系运算：五种基本关系运算（选择，投影，并，差，笛卡尔积）

传统的集合运算

并运算 (UNION)
差运算 (DIFFERENCE)
交运算 (INTERSECTION)
广义笛卡尔积运算 (CARTESIAN PRODUCT) ：R中的每一个元组与S的每一个元组串接。
- 新关系的度：R的度 + S的度
- 基数：R的基数 × S的基数
- 新关系的同名属性：使用 "关系名.属性名" 区分。

注意区分：逻辑运算 V（或） 和关系运算 U（并）

专门的关系运算

选择 (Selection)

选择是指在给定的关系中选择出满足条件的元组组成一个新的关系。

关系R关于公式F的选择运算用$\sigma_F(R)$表示,形式
化定义如下:
$\sigma_F(R) = {t | t \in R \land F(t) = 'true'}$
其中,$\sigma_F(R)$表示从R中挑选满足公式F的元组所构成的关系。

这个式子的左侧看起来是这样的：
$\sigma_{出生年份>=1990 \land 出生年份<=1999}$(学生)
投影 (Projection)

对一个关系内属性的指定称为投影运算，它也是单目运算。这个操作是对一个关系进行垂直分割，消去某些列，并按要求的顺序重新排列，再删除重复元组。

关系R关于属性集A的投影运算用$\prod_A(R)$表示,形式化定义如下:

$\prod_A(R) = {t[A] | t \in R }$

【例】查询所有学生的姓名和籍贯。

分析：该操作要进行的操作对象为学生表，所关心的属性只有姓名和籍贯。

表示为：

$\prod_{姓名,籍贯}$(学生)或者$\prod_{2,4}$(学生),属性名可用列号来表示。
连接 (Join)

连接运算是把两个关系连接成一个新关系，它是一个双目运算。

假设有两个关系R和S,R和S的连接是指在R与S的笛卡尔积中,选取R中的属性组A的值与S中的属性组B的值进行比较后,找出满足比较关系θ的元组,组成一个新的关系。连接操作可以记作:

$R \underset{A\theta B}{\bowtie} S = {t_r t_s | t_r \in R \land t_s \in S \land t_r[A]\theta t_s[B]}$

其中,A和B分别为R和S上度数相等且可比的属性组。θ是比较运算符,因此,也称连接为θ连接。

关系可以自身连接。
自然连接 (Natural Join)

它要求两个关系中进行比较的分量必须是相同的属性组，并且在结果中把重复的属性列去掉。如果关系R和S具有相同的属性组B，则自然连接可记为：

$R \bowtie S = {t_r t_s | t_r \in R \land t_s \in S \land t_r[B] = t_s[B] }$

具体计算过程如下：
1. 计算 R × S (笛卡尔积)。
2. 设R和S的公共属性是B，找出 R×S 中满足R中属性B的值与S中的属性B的值相等的那些元组。
3. 去掉S中B列（或者去掉R中B列）。
除运算 (Division)

适用的场合：查询条件是一个集合包含另一个集合，即适合于含有短语 “对所有的…” 的查询，如 “查询被所有的学生都选修的课程的信息”。

除运算的条件：假设给定关系 R(X, Y) 和 S(Y, Z)。 R和S中的Y可以有不同的属性名，但必须出自相同的域集。

除运算的结果:R与S的除运算得到一个新的关系P(X)，P是R中满足下列条件的元组在X属性列上的投影:元组在X上分量值x的像集Yₓ,包含S在Y上投影的集合。
记作:

$R÷S = {t_x[X]\ |\ t_r \in R \land \prod_y(S) \subseteq Y_x }$

其中,Yₓ为x在R中的像集,像集Yₓ={t[Y]|t∈ R,t[X]=x}。

查询优化

10种公式：[需要人工补充]

优化策略：

在关系代数表达式中尽可能早执行选择操作。
合并笛卡尔积和其后的选择操作，使之成为一个连接运算。
合并连续的选择和投影操作，以免分开运算造成多次扫描文件，从而节省了操作时间。
找出表达式里的公共子表达式。如果一个表达式中多次出现某个子表达式，那么应该将该子表达式预先计算出结果保存起来，以避免重复计算。
适当地对关系文件做预处理。根据实际需要对文件进行分类排序或建立临时索引等。

优化算法：一个关系代数表达式，可以得到一棵语法树，叶子是关系，非叶子节点是关系代数操作。利用前面的等价变换规则和优化策略来对关系代数表达式进行优化。

关系系统

定义：一个系统可定义为关系系统，当且仅当它支持：

关系数据结构。
支持选择、投影和（自然）连接运算，并且对这些运算不必要求定义任何物理存取路径。

分类：表式系统（不算关系系统），最小关系系统，完备关系系统，全关系系统。

SQL

特点

高度非过程化
功能完备并一体化
统一的语法结构
- 自含式
- 嵌入式
语言简洁，易学易用

体系结构

SQL支持关系数据库体系结构，即外模式、模式和内模式。

SQL功能

表结构的定义
```
CREATE TABLE <表名>
(
 <列名> <数据类型> [列级完整性约束条件],
 [, <列名> <数据类型> [列级完整性约束条件] ... ],
 [, <表级完整性约束条件>]
)[表属性，例如： ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci]

--指定存储引擎为 InnoDB，支持事务、行级锁和外键约束，适合处理高并发的事务场景--
--设置字符集为 utf8mb4，支持 UTF-8 编码并允许存储 4 字节字符（如 emoji 表情）；--
--指定排序规则为不区分大小写的 Unicode 排序，用于排序和比较字符数据--
```
在语法描述中，中括号 [] 用于表示可选的语法元素。

常见约束条件：NOT NULL、UNIQUE、DEFAULT

AUTO_INCREMENT 必须与被索引的列一起使用（通常是主键或唯一键），但它本身并不强制要求该列必须是主键。选择将其用于主键通常是出于设计和管理的便利性

employee_id INT PRIMARY KEY AUTO_INCREMENT,

每次插入新记录时 employee_id 值自动加 1

‍

CHECK ：约束条件，例如确保薪资为非负数，防止负薪资的插入。

salary DECIMAL(10, 2) CHECK (salary >= 0)

查看表结构/查看建表语句：
```
DESCRIBE <表名>
SHOW CREATE TABLE <表名>
```
主要数据类型：

1. 数值类型

数值类型用于存储数值数据，根据数值的大小和精度，数值类型可分为整数类型和浮点类型。

1.1 整数类型

数据类型	字节数	范围（有符号）	范围（无符号）
TINYINT	1	-128 到 127	0 到 255
SMALLINT	2	-32,768 到 32,767	0 到 65,535
MEDIUMINT	3	-8,388,608 到 8,388,607	0 到 16,777,215
INT	4	-2,147,483,648 到 2,147,483,647	0 到 4,294,967,295
BIGINT	8	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0 到 18,446,744,073,709,551,615

TINYINT：适合存储较小的整数，例如布尔值或状态码。
INT 和 BIGINT：适合较大数值的存储，如计数、金额等。

1.2 浮点类型与定点类型

数据类型	字节数	描述
FLOAT	4	单精度浮点数
DOUBLE	8	双精度浮点数
DECIMAL(m, d)	可变	定点数，精确存储

FLOAT 和 DOUBLE：适合对精度要求不高的科学计算和分析。
DECIMAL：适合精度要求高的场景，如货币计算。

2. 字符串类型

字符串类型用于存储文本数据，根据字符长度和内容，MySQL 提供了多种字符串类型。

数据类型	字节数	描述
CHAR(n)	n 字节	固定长度字符串，适合短文本
VARCHAR(n)	1 + 实际字符长度	可变长度字符串，适合长文本
TEXT	实际字符长度	大文本数据，最大 64KB
BLOB	实际字符长度	二进制大对象，最大 64KB

CHAR：适合固定长度的短字符串，如性别、国家代码。
VARCHAR：适合变长字符串，如用户名、电子邮件地址。
TEXT 和 BLOB：适合较大文本或二进制数据，如文章内容或图像数据。

3. 日期和时间类型

日期和时间类型用于存储日期和时间信息，MySQL 提供了灵活的时间数据类型。

数据类型	字节数	范围	描述
DATE	3	1000-01-01 到 9999-12-31	存储日期（年-月-日）
TIME	3	-838:59:59 到 838:59:59	存储时间（时:分:秒）
DATETIME	8	1000-01-01 00:00:00 到 9999-12-31 23:59:59	存储日期和时间
TIMESTAMP	4	1970-01-01 00:00:00 到 2038-01-19 03:14:07 UTC	存储日期和时间，适合时间戳
YEAR	1	1901 到 2155	存储年

DATE 和 DATETIME：适合存储日期和完整的日期时间信息。
TIMESTAMP：适合记录 Unix 时间戳。
TIME：适合记录时间数据，如工时或时长。

4. JSON 类型

MySQL 5.7 及以上版本支持 JSON 数据类型，允许存储 JSON 格式的数据。JSON 类型字段可用于存储灵活的结构化数据，但要注意 JSON 类型的字段索引和查询性能较差，不宜用于复杂查询。

CREATE TABLE example_table (
    data JSON
);

使用场景：适合存储结构变化频繁的数据，如动态配置或用户偏好。

5. ENUM 和 SET 类型

ENUM

ENUM 数据类型用于定义一组允许的值，例如状态或类型。创建 ENUM 列时指定所有可能值：

CREATE TABLE example_table (
    status ENUM('active', 'inactive', 'pending')
);

SET

SET 数据类型用于定义多个可能值的组合，适合多选项字段。

CREATE TABLE example_table (
    tags SET('sports', 'news', 'entertainment')
);

6. 选择数据类型的注意事项

空间效率：尽量选择占用空间少的数据类型，能用 TINYINT 就不选 INT。
性能考虑：使用合适的数据类型有助于提高查询和索引性能。
存储精度：财务数据用 DECIMAL 存储，避免浮点数精度误差。
拓展性：VARCHAR 灵活适合变长字符，避免固定长度导致浪费空间

来源：小哈教程-mySQL数据类型

主关键字定义 (Primary Key Definition)

关系数据库中，唯一标识每一行数据的属性或属性组合。
每个表只能有一个主键。

声明方式：
1. 单属性主键： 属性名数据类型 PRIMARY KEY
2. 通用方式： PRIMARY KEY (属性1, 属性2, ...) (可用于单属性或多属性主键)
方法一:
```
CREATE  TABLE  学生
(学号    CHAR(8)     PRIMARY KEY,
姓名    CHAR(8),
性别    CHAR(2),
出生年份  SMALLINT,
籍贯    CHAR(8),
学院    CHAR(15));
```
方法二:
```
CREATE  TABLE  学生
(学号    CHAR(8),
姓名    CHAR(8),
性别    CHAR(2),
出生年份  SMALLINT,
籍贯    CHAR(8),
学院    CHAR(15),
PRIMARY  KEY(学号));
```
外键定义 (Foreign Key Definition)
1. 如果外部关键字只有一个属性，可以在它的属性名和类型后面直接用 "REFERENCES" 说明它参照了某个表的某些属性（必须是主关键字）。
```
REFERENCES <表名>(<属性>)
```
2. 在 CREATE TABLE 语句的属性列表后面增加一个或几个外部关键字说明，其格式为：
```
FOREIGN KEY(<属性 1>) REFERENCES <表名>(<属性2>)
```
```
CREATE TABLE 学习
(学号 CHAR(8),
课程号 CHAR(8),
成绩 SMALLINT,
PRIMARY KEY (学号,课程号),
FOREIGN KEY (学号) REFERENCES 学生(学号)
FOREIGN KEY (课程) REFERENCES 课程(课程号)
```

基本表修改和删除

调整列位置：

使用 AFTER 或 FIRST 关键字调整列的位置。

AFTER column_name: 将列移动到指定列之后。
FIRST: 将列移动到第一列。

-- 将 email 列移动到 name 列之后
ALTER TABLE t_employee
MODIFY email VARCHAR(255) AFTER name;

-- 将 email 列移动到第一列
ALTER TABLE t_employee
MODIFY email VARCHAR(255) FIRST;

修改：

ALTER TABLE <表名>
[ ADD [COLUMN] <新列名> <数据类型> [DEFAULT 默认值] [完整性约束] ]
| [ DROP [COLUMN] <列名> ]
| [ ALTER COLUMN <列名> <数据类型> ]
| [ ADD CONSTRAINT <约束名> <约束类型> (<列名>)]
| [ DROP CONSTRAINT <约束名> ]

常用操作:

增加列 (ADD COLUMN):

语法: ALTER TABLE <表名> ADD [COLUMN] <新列名> <数据类型> [DEFAULT 默认值] [完整性约束]
```
ALTER TABLE 学生 ADD COLUMN 年龄 SMALLINT;
```
删除列 (DROP COLUMN):

语法: ALTER TABLE <表名> DROP [COLUMN] <列名>
```
ALTER TABLE 学生 DROP COLUMN 年龄;
```
修改列 (ALTER COLUMN / MODIFY COLUMN / CHANGE COLUMN):

标准 SQL使用 ALTER COLUMN

语法: ALTER TABLE <表名> ALTER COLUMN <列名> <数据类型>

修改 课程名 列类型为 VARCHAR(20):
```
ALTER TABLE 课程 ALTER COLUMN 课程名 VARCHAR(20);
```
MySQL: 推荐使用 MODIFY COLUMN 或 MODIFY， CHANGE COLUMN 还可以同时修改列名。

修改类型: ALTER TABLE <表名> MODIFY [COLUMN] <列名> <新数据类型> [其他属性]

修改名和类型 : ALTER TABLE <表名> CHANGE [COLUMN] <旧列名> <新列名> <新数据类型> [其他属性]
```
ALTER TABLE t_employee MODIFY email TINYINT;
ALTER TABLE t_employee CHANGE email employee_email TINYINT;
```
增加约束 (ADD CONSTRAINT): 向表添加约束，如主键、外键、唯一约束等。

语法: ALTER TABLE <表名> ADD CONSTRAINT <约束名> <约束类型> (<列名>)

学生表添加主键约束 PK_学生，列为 学号:
```
ALTER TABLE 学生 ADD CONSTRAINT PK_学生 PRIMARY KEY (学号);
```
删除约束 (DROP CONSTRAINT):

语法: ALTER TABLE <表名> DROP CONSTRAINT <约束名>

示例: 学生表删除主键约束 PK_学生:
```
ALTER TABLE 学生 DROP CONSTRAINT PK_学生;
```

提示:

列长度修改: 增加列长度通常没问题，但缩短长度可能导致数据丢失或失败，确保新长度能容纳现有数据。
NULL 约束修改为 NOT NULL: 若将列从允许 NULL 改为 NOT NULL，必须先处理列中的 NULL 值，否则修改会失败。

‍

删除 (Delete) ：DROP TABLE [IF EXISTS] <表名> [RESTRICT | CASCADE];

RESTRICT：如果有视图或约束条件涉及要删除的表时，禁止DBMS执行该命令。
CASCADE：将该表与其涉及的对象一起删除。
IF EXISTS：表示如果表存在则删除，否则不会报错。建议使用此选项以避免因表不存在而导致的错误。

注意：

锁表问题
ALTER TABLE 操作会锁定表结构，因此在高并发环境中应小心操作。

列的删除与重命名
删除列或重命名操作可能会导致依赖该列的视图或存储过程失效。

操作影响
某些复杂的 ALTER TABLE 操作可能需要 MySQL 创建临时表，从而耗费更多资源。

索引建立与删除

建立索引 (Create Index) ：

CREATE [UNIQUE] [CLUSTER] INDEX <索引名>
ON <表名>(<列名> [<次序>][, <列名> [<次序>] ...]);

UNIQUE 表明此索引的每个索引值只对应唯一的数据记录。CLUSTER 表示要建立的索引是聚簇索引。聚簇索引是指索引项的顺序与表中记录的物理顺序一致的索引组织。
【例3-10】为学生、课程和学习表建立索引。
CREATE UNIQUE INDEX STU_IDX_SNO ON 学生(学号);
CREATE UNIQUE INDEX COU_IDX_CNO ON 课程(课程号);
CREATE UNIQUE INDEX SC_IDX_SNO_CNO ON 学习(学号 ASC,课程号 DESC);
其中,ASC表示按照升序排列,DESC表示按照降序排列。

删除索引 (Drop Index) ：

DROP INDEX <索引名>;

数据查询

语法格式：

SQL 92 标准中SELECT语句的语法格式:

SELECT [ALL | DISTINCT] <属性列表>
FROM <表名或视图名>[,<表名或视图名>]...
[WHERE <条件表达式>]
[GROUP BY <列名>]
[HAVING <条件表达式>]
[ORDER BY <列名> [ASC | DESC] ];

单表查询

最简单的SQL查询只涉及一个关系（基本表），可归纳为：

选择表中的若干列（关系代数中的投影运算）。
选择表中的若干元组（关系代数中的选择运算）。
对查询进行分组。
使用集函数。（WHERE 作用于元组，HAVING 作用于分组）
对查询结果排序。

连接查询

等值与非等值连接查询 (Equi-join and Non-equi-join Query)

用来连接两个表的条件称为连接条件或连接谓词，其一般格式为：

[<表名1>.]<列名1><比较运算符>[<表名2>.]<列名2>

其中,比较运算符主要有：=,>,<,>=,<=、!=。

此外,连接谓词还可以使用下面的形式。

[<表名1>.]<列名1> BETWEEN [<表名2>.]<列名2> AND [<表名2>.]<列名3>

当连接运算符为=时,称为等值连接,使用其他运算符时称为非等值连接。

连接示例 (Join Example)：

SELECT 学生.*, 学习.*
FROM 学生, 学习
WHERE 学生.学号 = 学习.学号;

自然连接示例 (Natural Join Example)：

SELECT 学生.学号, 姓名, 性别, 出生年份, 学院, 课程号, 成绩
FROM 学生, 学习
WHERE 学生.学号 = 学习.学号;

或者，使用 NATURAL JOIN 关键字：

SELECT *
FROM 学生
NATURAL JOIN 学习;

自身连接 (Self Join)： 同一关系与自身进行连接

外连接 (Outer Join)： 保留单边或双边未匹配元组的连接

复合条件连接 (Complex Condition Join)： 使用AND、OR或多个JOIN子句的复杂连接

集合运算连接查询

使用集合运算（并、交、除）来组合关系。SQL为此提供了相应的运算符：UNION、INTERSECT、EXCEPT。

嵌套查询

带有IN的子查询

判断属性列值是否在子查询结果（集合）中。

带有比较运算符的子查询

子查询结果为单值时，可直接使用比较运算符。

示例： 查询选修了 '数据库原理' 课程的学生的学号和姓名。

SELECT 学号, 姓名
FROM 学生
WHERE 学号 IN (
    SELECT 学号
    FROM 学习
    WHERE 课程号 = (
        SELECT 课程号
        FROM 课程
        WHERE 课程名 = '数据库原理'
    )
);

带有ANY/ALL的子查询

当子查询可能返回多行结果时，不能直接用比较运算符。此时用 ANY 或 ALL 谓词搭配比较运算符。

ANY：子查询结果中，只要有 任意一个值 满足比较关系，条件就成立。

ALL：子查询结果中，所有值 都必须满足比较关系，条件才成立。

示例： 查询比计算机学院任意一个学生年龄小的学生姓名。

SELECT 姓名
FROM 学生
WHERE year(now()) - 出生年份 < ANY (
    SELECT year(now()) - 出生年份
    FROM 学生
    WHERE 学院 = '计算机'
)
ORDER BY year(now()) - 出生年份 DESC;

等价于使用 MAX 聚合函数：

SELECT 姓名
FROM 学生
WHERE year(now()) - 出生年份 < (
    SELECT MAX(year(now()) - 出生年份)
    FROM 学生
    WHERE 学院 = '计算机'
)
ORDER BY year(now()) - 出生年份 DESC;

|ANY、ALL 谓词与集合函数及 IN 的等价转换关系：|||||||

谓词 = <> 或 != < <= > >=

ANY IN -- < MAX <=MAX > MIN >=MIN

ALL -- NOT IN < MIN <=MIN > MAX >=MAX

谓词	=	<> 或 !=	<	<=	>	>=
ANY	IN	--	< MAX	<=MAX	> MIN	>=MIN
ALL	--	NOT IN	< MIN	<=MIN	> MAX	>=MAX

带有EXISTS的子查询

子查询不返回数据，只产生逻辑真值 true 或 false。

示例： 查询选修了 '180102' 号课程的学生的学号和姓名。
```
SELECT 学号, 姓名
FROM 学生
WHERE EXISTS (
    SELECT *
    FROM 学习
    WHERE 学生.学号 = 学习.学号 AND 学习.课程号 = '180102'
);
```
执行过程： 依次取 学生 表中元组，用其 学号 检查 学习 表。若 学习 表中存在匹配 学号 且 课程号 为 '180102' 的记录，则 EXISTS 返回 true，该学生记录的 学号 和 姓名 被选中。
NOT EXISTS 则相反。

带 EXISTS/NOT EXISTS 的子查询不一定能被其他形式替代，但所有带 IN、比较运算符、ANY/ALL 的子查询都能用 EXISTS 等价替换。

使用 EXISTS 实现除法

关系代数中的除法运算（查询选修了所有某类课程的学生）。

核心思想： 找到 不存在 这样的课程：目标学生（如 '091501'）选修了，而当前被检查的学生没有选修。
示例： 查询选修了学号为 '091501' 的学生所选修的全部课程的学生学号。
```
SELECT DISTINCT 学号
FROM 选课表 AS S1
WHERE NOT EXISTS (
    SELECT 课程号
    FROM 选课表 AS S2
    WHERE S2.学号 = '091501'
      AND NOT EXISTS (
          SELECT 课程号
          FROM 选课表 AS S3
          WHERE S3.学号 = S1.学号
            AND S3.课程号 = S2.课程号
      )
);
```
精简解释： 对于每个学生 S1.学号，检查是否 不存在 课程 S2.课程号，满足条件：课程 S2.课程号 是学生 '091501' 选修的，并且学生 S1.学号 没有选修课程 S2.课程号。如果不存在这样的课程，则说明学生 S1.学号 选修了 '091501' 学生选修的所有课程。

其他实现除法的方法：
使用 GROUP BY 和 HAVING
统计每个学生选修的目标课程数，与目标学生选修的总课程数比较。
SELECT 学号
FROM 选课表
WHERE 课程号 IN (SELECT 课程号 FROM 选课表 WHERE 学号 = '091501')
GROUP BY 学号
HAVING COUNT(DISTINCT 课程号) = (SELECT COUNT(DISTINCT 课程号) FROM 选课表 WHERE 学号 = '091501');

对于相关的嵌套查询（如使用 EXISTS 且子查询引用了外层查询的列），其执行过程通常是：外层查询取出一个元组，将该元组的相关值传入内层子查询，内层子查询执行并返回结果（或真/假），外层查询根据内层结果判断当前元组是否满足条件，然后外层查询处理下一个元组。对于不相关的嵌套查询（子查询可以独立执行），通常是先执行内层子查询，得到结果集，然后外层查询使用这个结果集进行判断。

数据更新

插入数据 (INSERT)

插入单个元组 (行)
- 基本语法:
```
INSERT INTO <表名> [(<列名1>, <列名2>, ...)] VALUES (<值1>, <值2>, ...);
```
- 如果省略列名列表，VALUES 子句必须为所有列提供值，且顺序与表定义一致。
- 如果指定列名列表，VALUES 子句只需为指定的列提供值，顺序需对应，未指定的列将取默认值或 NULL。
- 示例：
```
-- 插入完整信息
INSERT INTO t_employee (name, position, salary) VALUES ('犬小哈', '项目经理', 7000.00);
-- 插入部分列信息 (salary 会是 NULL 或默认值)
INSERT INTO t_employee (name, position) VALUES ('李四', 'DBA 数据库工程师');
```
 注意：命令行工具可能对中文支持不佳，建议使用图形客户端（如 Navicat）测试含中文的插入。
 
 MySQL 插入单行数据

插入多行数据

一条 INSERT 语句插入多个元组。

示例：

INSERT INTO t_employee (name, position, salary) VALUES
    ('犬二哈', 'Java实习生', 3000.00),
    ('犬大哈', 'Java高级工程师', 6000.00),
    ('张三', '运维工程师', 5000.00);

!MySQL 查看数据

插入子查询结果

将查询结果插入表中。

语法:

INSERT INTO <表名> [(<列名1>, <列名2>, ...)] <子查询>;

示例： 从 t_employee_archive 表复制薪资高于 4000 的记录到 t_employee 表。

INSERT INTO t_employee (name, position, salary)
SELECT name, position, salary FROM t_employee_archive WHERE salary > 4000;

插入或替换 (REPLACE INTO)
- 如果插入的行导致主键或唯一键冲突，则先删除旧行，再插入新行。
- 示例：
```
REPLACE INTO t_employee (employee_id, name, position, salary) VALUES (1, '王五', '前端工程师', 6000.00);
```

插入或更新 (ON DUPLICATE KEY UPDATE)

如果插入的行导致主键或唯一键冲突，则执行 UPDATE 子句指定的操作。

示例： 尝试插入 ID 为 1 的记录，若已存在，则更新其职位和薪资。

INSERT INTO t_employee (employee_id, name, position, salary) VALUES (1, '诸葛亮', '安卓工程师', 7000.00)
ON DUPLICATE KEY UPDATE position = 'Java架构师', salary = 60000.00;

注意事项:

依赖主键或唯一键来检测冲突。

UPDATE 子句可使用 VALUES(column_name) 引用 INSERT 语句中尝试插入的值。

-- 冲突时，用本次尝试插入的值更新记录
INSERT INTO t_employee (employee_id, name, position, salary) VALUES (1, '诸葛亮', '安卓工程师', 7000.00)
ON DUPLICATE KEY UPDATE name = VALUES(name), position = VALUES(position), salary = VALUES(salary);

删除数据 (DELETE)

语法: DELETE FROM <表名> [WHERE <条件>];

删除满足条件的元组: 使用 WHERE 子句。

示例： 删除学号为 '092010' 的学生记录。
```
DELETE FROM 学生 WHERE 学号 = '092010';
```

示例（带子查询）： 删除计算机学院所有学生的选课记录。

DELETE FROM 学习
WHERE '计算机' = (SELECT 学院 FROM 学生 WHERE 学生.学号 = 学习.学号);
-- 也可用 EXISTS 实现
DELETE FROM 学习
WHERE EXISTS (SELECT 1 FROM 学生 WHERE 学生.学号 = 学习.学号 AND 学院 = '计算机');

删除所有元组: 省略 WHERE 子句（慎用！）。
```
DELETE FROM <表名>;
```

修改数据 (UPDATE)

语法: UPDATE <表名> SET <列名>=<表达式> [, <列名>=<表达式>]... [WHERE <条件>];

修改满足条件的元组: 使用 WHERE 子句。

示例： 将学号 '091611' 的学生籍贯改为 '江苏'。

UPDATE 学生 SET 籍贯 = '江苏' WHERE 学号 = '091611';

示例： 将课程号 '180101' 的成绩加 1 分。

UPDATE 学习 SET 成绩 = 成绩 + 1 WHERE 课程号 = '180101';

示例（带子查询）： 将计算机学院学生的成绩清零。

UPDATE 学习 SET 成绩 = 0
WHERE '计算机' = (SELECT 学院 FROM 学生 WHERE 学生.学号 = 学习.学号);
-- 也可用 EXISTS 实现
UPDATE 学习 SET 成绩 = 0
WHERE EXISTS (SELECT 1 FROM 学生 WHERE 学生.学号 = 学习.学号 AND 学院 = '计算机');

修改所有元组: 省略 WHERE 子句。
使用子查询/连接更新:
- 示例： 将员工薪资更新为其部门平均薪资（假设有 t_department 表）。
```
UPDATE t_employee AS e
JOIN t_department AS d ON e.department_id = d.department_id
SET e.salary = d.avg_salary;
```
使用 ORDER BY 和 LIMIT 更新特定行:
- 示例： 将薪资最低的 3 名员工薪资更新为 4500。
```
UPDATE t_employee
SET salary = 4500
ORDER BY salary ASC
LIMIT 3;
```

视图 (Views)

建立视图 (CREATE VIEW)

视图是虚表，基于基本表或其他视图，其定义存储在数据字典中，不存储实际数据。
语法：
```
CREATE VIEW <视图名> [(<列名1> [,<列名2>]...)]
AS <子查询>
[WITH CHECK OPTION];
```
- 列名列表： 可省略，默认为子查询的 SELECT 列。以下情况必须指定：
 1. 某列是聚合函数或表达式。
 2. 多表连接时存在同名列。
 3. 需要为列指定新名称。
- WITH CHECK OPTION ：对视图进行 INSERT 或 UPDATE 操作时，确保结果行满足视图定义中的 WHERE 条件。

示例：

创建计算机学院学生视图:

CREATE VIEW CS_VIEW AS
SELECT * FROM 学生 WHERE 学院 = '计算机';

创建指定列名的视图:

CREATE VIEW CS_VIEW (学号, 姓名, 性别, 籍贯, 出生年份, 学院) AS
SELECT 学号, 姓名, 性别, 籍贯, 出生年份, 学院 FROM 学生 WHERE 学院 = '计算机';

基于多表创建视图 (选修数据库原理的计算机学院学生):

CREATE VIEW DB_S1 AS
SELECT 学生.学号, 姓名, 性别, 籍贯, 学院, 成绩
FROM 学生, 学习, 课程
WHERE 课程名 = '数据库原理'
  AND 学生.学号 = 学习.学号
  AND 课程.课程号 = 学习.课程号
  AND 学院 = '计算机';

基于视图创建视图 (成绩>=90):

CREATE VIEW DB_S2 AS
SELECT * FROM DB_S1 WHERE 成绩 >= 90;

创建带表达式的视图 (计算年龄):

CREATE VIEW BT_S (学号, 姓名, 年龄) AS
SELECT 学号, 姓名, year(now()) - 出生年份 AS 年龄 FROM 学生;

删除视图 (DROP VIEW)

语法： DROP VIEW <视图名>;
删除视图会使基于该视图导出的其他视图失效。

查询视图

查询视图的操作与查询基本表类似。
视图消解 (View Resolution): 视图消解是指数据库管理系统（DBMS）在执行对视图的查询时，会先将视图定义（即创建视图时的 AS 子查询）与用户的查询语句进行合并或重写，最终转换成对底层基本表的查询操作的过程。DBMS 并不实际存储视图的数据，而是存储其定义，查询时通过消解机制访问基础数据。

示例： 查询计算机学院视图中年龄小于20岁的学生。

SELECT * FROM CS_VIEW WHERE year(now()) - 出生年份 < 20;

消解后的查询：

SELECT * FROM 学生 WHERE 学院 = '计算机' AND year(now()) - 出生年份 < 20;

更新视图

只有部分简单视图（通常称为可更新视图，如行列子集视图）允许更新 (INSERT, UPDATE, DELETE)。
不可更新视图的常见限制：
1. 视图的列来自表达式或常数（通常不允许 INSERT/UPDATE，可能允许 DELETE）。
2. 视图的列来自聚合函数。
3. 视图定义中包含 GROUP BY 子句。
4. 视图定义中包含 DISTINCT 关键字。
5. 视图定义中包含嵌套查询，且嵌套查询的 FROM 子句涉及导出该视图的基本表。
6. 视图基于两个或以上基本表导出（某些数据库可能有限支持）。
7. 视图基于不可更新的视图定义。

示例（不可更新视图）： 查询成绩高于平均分的选课记录视图。

CREATE VIEW GOOD_SC_VIEW AS
SELECT 学号, 课程号, 成绩
FROM 学习
WHERE 成绩 > (SELECT AVG(成绩) FROM 学习);
-- 此视图通常不可更新，因为它包含子查询引用了自身的基础表

数据控制 (Data Control)

授权 (GRANT)

授予用户对数据库对象的操作权限。
语法：
```
GRANT <权限> [,<权限>]...
[ON <对象类型> <对象名>]
TO <用户> [,<用户>]...
[WITH GRANT OPTION];
```
- <权限>: 如 SELECT, INSERT, UPDATE, DELETE, ALL PRIVILEGES 等。
- <对象类型>: 如 TABLE, VIEW 等。
- <对象名>: 表名、视图名等。
- <用户>: 用户名或 PUBLIC (所有用户)。
- WITH GRANT OPTION: 允许被授权用户将获得的权限再授予其他用户。
常用权限: (详见教材或文档，如表 3-39)
示例：
- 授予 User1 对 学生 表的查询权限：
```
GRANT SELECT ON TABLE 学生 TO User1;
```
- 授予 User2, User3 对 学生 表和 课程 表的所有权限：
```
GRANT ALL PRIVILEGES ON TABLE 学生, 课程 TO User2, User3;
```
- 授予所有用户对 学习 表的查询权限：
```
GRANT SELECT ON TABLE 学习 TO PUBLIC;
```
- 授予 User4 对 学习 表的查询权限和修改 成绩 列的权限：
```
GRANT UPDATE (成绩), SELECT ON TABLE 学习 TO User4;
```
- 授予 User5 对 学生 表的 INSERT 权限，并允许其传播此权限：
```
GRANT INSERT ON TABLE 学生 TO User5 WITH GRANT OPTION;
```

收回权限 (REVOKE)

收回已授予用户的权限。

语法：

REVOKE <权限> [,<权限>]...
[ON <对象类型> <对象名>]
FROM <用户> [,<用户>]...;

示例：
- 收回 User4 修改 学习 表 成绩 的权限：
```
REVOKE UPDATE (成绩) ON TABLE 学习 FROM User4;
```
- 收回 User5 对 学生 表的 INSERT 权限（级联收回）：
```
REVOKE INSERT ON TABLE 学生 FROM User5;
```
  - 如果 User5 曾将此 INSERT 权限授予 User6，则 User6 从 User5 处获得的该权限也会被收回。

关系规范化理论（待续）

函数依赖 (Functional Dependency): Y 依赖于 X，或 X 函数确定 Y，记为 X -> Y。
SQL 连接类型补充:
- INNER JOIN / JOIN: 只保留两个表中能匹配上的行（交集）。
- LEFT JOIN (或 LEFT OUTER JOIN): 保留左表所有行，右表只保留匹配行，无匹配则为 NULL。
- RIGHT JOIN (或 RIGHT OUTER JOIN): 保留右表所有行，左表只保留匹配行，无匹配则为 NULL。
- FULL OUTER JOIN: 保留左右两表所有行，无匹配则对应表列为 NULL (MySQL 不直接支持，需用 LEFT JOIN UNION RIGHT JOIN 模拟)。
范式 (Normal Forms):
- 1NF (第一范式): 关系中的所有属性都是原子的，不可再分。
- 2NF (第二范式): 满足 1NF，且每一个非主属性都 完全函数依赖 于候选码（不能只依赖于候选码的一部分）。
- 3NF (第三范式): 满足 2NF，且消除非主属性对候选码的 传递函数依赖。
- BCNF (Boyce-Codd 范式): 满足 3NF，且所有函数依赖中，决定因素（->左侧）都必须包含候选码。
- 多值依赖和 4NF (第四范式): ?[需要人工补充]
相关理论:
- 数据依赖的公理系统 (Armstrong 公理)
- 函数依赖集的闭包 (F+)
- 函数依赖的推理规则
- 属性集闭包 (X+)
- F 逻辑蕴含 G 的充要条件
- 码的理论 (候选码、主码、超码)
- 函数依赖集的等价和最小函数依赖集 (Minimal Cover)

‍

Gemini 2.5 音视频识别实测，震撼

Sun, 30 Mar 2025 00:00:00 GMT

谷歌Gemini音视频实测！以后再也不需要字幕组了？

Gemini 2.5 Pro 是啥

谷歌在前几天（25年3月25号）发布了 Gemini 2.5 Pro 模型，综合排名世界第一，号称有百万上下文，后期将会开放 200 万上下文。最大输出长度约为 6 万 token。
刚发布时我就快速体验了一下代码和散文写作能力，毫无疑问就我个人体验而言，Gemini 2.5 Pro 是目前效果最强的。尤其是文章写作，剧情连贯，措辞合理，不像 DeepSeek R1、Claude 3.7 Thinking 等思考模型，会自我意识过剩导致文章中意象和辞藻堆砌。
不过本文的重点不在此。今天我看到了网络上有人用 2.5Pro 处理一段多语言视频的效果展示，于是便想要测试一下 Gemini 对音视频的理解能力如何、能处理多长的音视频。谷歌在 AI Studio 网站给所有人提供免费使用，我立刻开始了测试。结果令我震撼，尤其是测试 4：动漫加字幕！

测试内容

测试主要关注这几个方面：音频内容识别、音视频时间轴、视频内容理解、音视频上下文连贯性理解、音效音乐等元素识别。
太长不看，结论：除了中文歌和刁钻题材（专有词地狱的动画、发音人类都很难听懂的视频）之外，Gemini 无敌了，可以完美给视频加字幕！
我准备了下面几个任务，依次来看看结果吧。以下素材在喂给 AI 之前均已经裁掉字幕，提供给 AI 信息的只有字幕要求以及来源作品名称，也就是说角色名字和额外剧情信息均为 Gemini 依靠知识库脑补的！

《你想活出怎样的人生》插曲视频片段——要求输出画面内容、剧情、中文字幕、日文字幕、音效描述
《你的名字》英文版片头曲视频——要求输出画面内容、英文字幕、中文字幕、音效描述
初音未来《Miku》短视频——要求输出画面内容、中日歌词
大的来了，《New Game》第一集全部音频👍——要求输出中日字幕、音效、根据声线与上下文推断说话人名字、OP/ED 中日歌词
中日英歌曲各一首，吐字较为清晰，《Hello World 》- Kizuna AI，《真昼の空の月》- アビドス高等学校対策委員会，《漂亮面对》- 洛天依; 阿良良木健——要求输出双语滚动歌词、每句话的歌唱感情

测试结果

所有结果我都人工检查过通篇，有错误会指出。如果没指出则代表通篇都正确。
所有的时间轴均精确到 0.01 秒，可以和视频完美对应，下文不再提及时间轴。

1《你想活出怎样的人生》

结论：完美完成任务。无任何错误。

画面内容识别↑

↑知识库丰富度、剧情上下文识别。可以正确认识角色，可以识别安慰剧情。

↑音效和音乐识别

↑嘈杂环境中的语音识别

2 《你的名字》英文版片头

英语歌词部分出现个位数识别错误，为同音词或短语连读出错，基本没有影响汉语意思。其他方面完美完成任务，甚至可以根据电影剧情补充信息，例如“口嚼酒”、“东京街道”等。

↑画面识别，音效识别

↑根据电影剧情补充画面描述信息，例如组纽、系守、口嚼酒

3 《Miku》短视频

视频镜头快速切换的时候，字幕中漏掉了一两个分镜。歌词与音乐节奏识别完美。

4 《New Game》第一集👍

本测试只提供了音频和作品名称给 AI。 极个别台词没分清说话人是谁，不过这个要求对于只听音频来说有点难了。
角色尖叫的时候，有概率识别不出在叫什么（有时候成功，有时候只显示尖叫）。
其他地方完美。

↑语音识别与角色名推断，即使是初次登场也可以自动推断发言角色名。

↑片假名专有名词自动补充英文、或者直接使用剧中原文（我没要求它）

↑日语、英语混合 OPED 识别，非常准确。甚至能在角色发言的时候，同时识别台词和歌词（图 3）

↑最逆天的，角色默念的所有短信全都标注了【message】，有的短信甚至没有上下文可供推测，我怀疑它能识别角色内心独白时候的回音效果。

5 中日英三首歌

时间轴全对。日文错了两个单词，英文全对，中文错了接近一半。这里直接放结果图。
日文，只有开头错了两个词。

英文，全对。

中文，错一半，不标注了。

能处理多长的视频

我没有测试极限长度。但是可以根据 token 使用量大致推算，我在上传视频时，为了方便 AI 处理，将视频码率压缩到了 2Mbps，一分钟视频大约占用 4-6 万 token。24 分钟音频占用 5 万 token。

处理一集动漫长度的视频大约需要 2 万 token。由此可见，输入长度并非瓶颈，真正的瓶颈在于输出长度。如果以动漫视频的 token 消耗量计算，一次性最长可以处理 60-80 分钟的音频。如果是网课视频，处理时长可能会更短。

不过总的来说，目前来看还是非常够用的，毕竟在现阶段，我们不太可能上传整部电影。Gemini 这一举措无疑为 AI 应用开辟了更广阔的道路！

结论

看来 AI 的进化超出了我的想象。我还停留在用一堆工作流+人工辅助打轴的认知呢，现在看，AI 来为日常番、外语网课加字幕，已经可以做到无敌了。甚至可以为视力障碍者直接描述剧情和画面。一切都发生得太快了。

Go+Gin+Gorm 入门项目笔记

Tue, 25 Mar 2025 00:00:00 GMT

Go Gin Gorm

精炼笔记：Go + Gin + Gorm 项目

这个教程内容涵盖了Go + Gin + Gorm + MySQL + Redis 的技术栈。下面是我学习后的精华笔记，按模块叙述了每个重要的知识点和代码实现。

1. 项目结构设计

1.1 项目目录结构

首先，在main.go开始运行时，config包负责读取程序的配置文件，并按照配置连接数据库，将数据库实例保存到global包的变量中方便调用。

之后，调用router包进行路由初始化设置，初始化函数返回一个r *gin.Engine。main.go将在goroutine中使用r来非阻塞式地启动服务，监听配置文件中指定的端口。

当接收到请求的时候，http包的上下文数据会按照路由规则交给不同的controllers和中间件处理。utils中定义了程序常用的工具、方法，models中定义了文章、用户等数据的结构、数据库的表结构。

服务运行时，main将会被channel阻塞。当程序接收到的系统的停止信号时，将会开始进行优雅关闭，停止接受连接并释放资源。

1.2 资源和API设计

这套教程的目标是开发一个能够实现汇率查询、文章获取、点赞、用户注册、登录功能的，使用mySQL和Redis数据库的go后端项目。因此应该基于这个最终目标来设计各种API。

RESTful API：一种设计风格

RESTful API：基于资源设计路径，使用 HTTP 方法定义操作。REST（Representational State Transfer，表述性状态转移）本身不是一种技术，而是一组设计约束。遵循这些约束设计的 API 就被称为 RESTful API。

在同一个路径上，可以通过不同的HTTP方法和参数来区分不同的功能，例如：
- GET /api/articles 获取所有文章
- POST /api/articles 创建新文章
- GET /api/articles/:id 获取单篇文章
- POST /api/articles/:id/like 为文章点赞
请求路径设计如下：
- /api/v1/articles：文章相关资源
- /api/v1/auth/login：登录接口
- /api/v1/auth/register：注册接口

1.3 使用HTTP状态码向客户端反馈

200 OK：请求成功
201 Created：成功创建资源
400 Bad Request：请求无效，通常由参数错误引起
401 Unauthorized：未授权的请求
404 Not Found：请求的资源不存在
500 Internal Server Error：服务器错误

2. Gin框架

2.1 简单配置和初始化

Gin框架是Go语言中高效的Web框架，用于处理HTTP请求和响应。这是一个最小的gin服务，监听8080端口/ping路径的GET请求，并返回json。

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "pong"})
    })
    r.Run(":8080")
}

gin.Default() 创建带有日志和恢复中间件的默认引擎。
c.JSON() 用于返回JSON格式的响应。

2.2 路由与分组

r := gin.Default()

// 路由分组
auth := r.Group("/api/auth")
{
    auth.POST("/login", controllers.Login)
    auth.POST("/register", controllers.Register)

}

api := r.Group("/api")
api.GET("/exchangeRates", controllers.GetExchangeRates)
api.Use(middlewares.AuthMiddleWare())
{
    //此处的api都将受到用户认证中间件的保护，登录用户才能使用
    api.POST("/exchangeRates", controllers.CreateExchangeRate)
    api.POST("/articles", controllers.CreateArticle)
    api.GET("/articles", controllers.GetArticles)
    api.GET("/articles/:id", controllers.GetArticlesByID)
    api.POST("/articles/:id/like", controllers.LikeArticle)
    api.GET("/articles/:id/like", controllers.GetArticleLikes)
}
)

使用Group可以对相似的路由进行分组，有助于管理和维护。
会路由指向不同路径的请求，并将请求上下文交给handler函数处理

2.3 中间件

func AuthMiddleWare() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        token := ctx.GetHeader("Authorization")
        //获取请求头中的token
        if token == "" {
        //无token，结束处理
            ctx.JSON(http.StatusUnauthorized, gin.H{"error": "Token is missing"})
            ctx.Abort()
            return
        }

        username, err := utils.ParseJWT(token)

        if err != nil {
            ctx.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
            ctx.Abort()
            return
        }
        ctx.Set("username", username)
        //解析成功，获得用户名，进行下一步操作
        ctx.Next()
    }
}

自定义中间件，用于记录请求时间、验证用户身份或执行其他操作。

2.4 请求绑定

type Login struct {
    Username string `json:"username" binding:"required"`
    Password string `json:"password" binding:"required"`
}

func LoginHandler(c *gin.Context) {
    var login Login
    if err := c.ShouldBindJSON(&login); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    c.JSON(200, gin.H{"message": "Login successful"})
}

ShouldBindJSON() 绑定JSON数据到结构体，并进行验证。

3. Gorm ORM

3.1 配置与数据库连接

Gorm是Go中常用的ORM库，用于简化与数据库的交互。

func initDB() {

    db, err := gorm.Open(mysql.Open(AppConfig.Database.Dsn), &gorm.Config{})

    if err != nil {
        log.Fatalf("failed to connect database: %v", err)
    }

    sqlDB, err := db.DB()
    //设置连接的限制
    sqlDB.SetMaxIdleConns(AppConfig.Database.MaxIdleConns)
    sqlDB.SetMaxOpenConns(AppConfig.Database.MaxOpenConns)
    sqlDB.SetConnMaxLifetime(time.Hour)

    if err != nil {
        log.Fatalf("failed to config database: %v", err)
    }
    // 添加这段代码，在应用启动时迁移所有模型
    if err := db.AutoMigrate(&models.User{}, &models.ExchangeRate{}); err != nil {
        log.Fatalf("failed to auto migrate: %v", err)
    }
    //存入global方便使用
    global.Db = db
}

mysql.Open(dsn)：连接数据库
gorm.Config{}：提供数据库连接的配置。

3.2 模型定义

package models

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Username string `gorm:"unique"`
    Password string
}

gorm:"primaryKey"：定义主键字段。
gorm:"uniqueIndex"：确保字段唯一。

gorm.models是自带的，包含了：

type Model struct { // size=88 (0x58)
    ID        uint `gorm:"primarykey"`
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt DeletedAt `gorm:"index"`
}

3.3 数据库操作

// 创建用户
db.Create(&User{Username: "john", Password: "12345"})

// 查询用户
var user User
db.Where("username = ?", "john").First(&user)

// 更新用户
db.Model(&user).Update("Password", "newpassword")

// 删除用户
db.Delete(&user)

3.4 自动迁移

AutoMigrate方法可以自动同步数据库表结构。

db.AutoMigrate(&models.User{})

3.5 数据库连接池配置

sqlDB, err := db.DB()
if err != nil {
    log.Fatal(err)
}
sqlDB.SetMaxIdleConns(10) // 设置最大空闲连接数
sqlDB.SetMaxOpenConns(100) // 设置最大连接数
sqlDB.SetConnMaxLifetime(time.Hour) // 设置最大连接生命周期

4. 配置与初始化

4.1 配置文件（YAML）

为了方便修改程序的配置，避免把数据库地址、密码等信息写死在代码中，可以使用yaml来存储配置信息。

# config/config.yml
app:
  name: CurrencyExchangeApp
  port: ":3000"

database:
  host: "localhost"
  port: "3306"
  user: "root"
  password: "password"
  name: "currency_exchange_db"

4.2 配置加载

func InitConfig() {
    viper.SetConfigName("config")
    viper.SetConfigType("yml")
    viper.AddConfigPath("./config")

    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("读配置文件失败: %v", err)
    }

    AppConfig = &Config{}

    if err := viper.Unmarshal(AppConfig); err != nil {
        log.Fatalf("解析配置文件失败: %v", err)
    }

    initDB()
    initRedis()
}

使用viper加载YAML配置文件。

4.3 配置结构体

type Config struct {
    App struct {
        Name string
        Port string
    }
    Database struct {
        Dsn          string
        MaxIdleConns int
        MaxOpenConns int
    }
}

viper.Unmarshal将配置映射到结构体。

5. 身份验证与JWT

5.1 JWT生成与验证

JWT（JSON Web Token）用于实现用户身份验证。

func GenerateJWT(username string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "username": username,
        "exp":      time.Now().Add(time.Hour * 24).Unix(),
    })
    //使用密钥签名
    SignedToken, err := token.SignedString([]byte("secret"))
    return "Bearer " + SignedToken, err
}

jwt.NewWithClaims()：根据指定的签名方法和声明生成JWT。

对应的，可以使用相反的流程来解析JWT：

func ParseJWT(tokenString string) (string, error) {
    // 移除 "Bearer " 前缀
    if len(tokenString) > 7 && tokenString[:7] == "Bearer " {
        tokenString = tokenString[7:]
    }

    // 解析 JWT token
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        // 检查 signing 方法
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("unexpected signing method") // signing 方法错误
        }
        return []byte("secret"), nil // 秘钥
    })

    if err != nil {
        return "", err // 解析失败
    }

    // 验证 token 并提取 claims
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        username, ok := claims["username"].(string)
        if !ok {
            return "", errors.New("Username not found in token") // username 不存在
        }
        return username, nil // 成功返回 username
    }

    return "", errors.New("Invalid token") // 无效 token
}

6. 用户注册与登录

6.1 用户注册

auth_controller.go：

func Register(ctx *gin.Context) {
    var user models.User
    //请求json绑定到结构体
    if err := ctx.ShouldBindJSON(&user); err != nil {
        ctx.JSON(http.StatusBadRequest, gin.H{
            "error": err.Error(),
        })
        return
    }
    //两次调用utils中的函数
    hashedPwd, err := utils.HashPassword(user.Password)

    if err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
    }
    user.Password = hashedPwd

    token, err := utils.GenerateJWT(user.Username)

    if err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }
    //尝试在数据库中创建用户
    if err := global.Db.Create(&user).Error; err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }
    //没有出错，返回新用户的token
    ctx.JSON(http.StatusOK, gin.H{
        "token": token,
    })
}

用户密码加密存储，生成JWT并返回。

6.2 用户登录

func Login(ctx *gin.Context) {
    // 定义输入结构体
    var input struct {
        Username string `json:"username"`
        Password string `json:"password"`
    }

    // 绑定JSON数据到结构体
    if err := ctx.ShouldBindJSON(&input); err != nil {
        ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    var user models.User

    // 根据用户名查询用户
    if err := global.Db.Where("username = ?", input.Username).First(&user).Error; err != nil {
        ctx.JSON(http.StatusUnauthorized, gin.H{"error": "invalid username or password"})
        return
    }

    // 验证密码
    if !utils.CheckPassword(input.Password, user.Password) {
        ctx.JSON(http.StatusUnauthorized, gin.H{"error": "invalid username or password"})
        return
    }

    // 生成JWT token
    token, err := utils.GenerateJWT(user.Username)
    if err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    // 返回token
    ctx.JSON(http.StatusOK, gin.H{"token": token})
}

7. 点赞缓存

7.1 Redis缓存（文章点赞）

初始化Redis：

func initRedis() {
    redisClient := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        DB:       0,
        Password: "",
    })

    _, err := redisClient.Ping().Result()
    if err != nil {
        log.Fatalf("Failed to connect redis: %v", err)
    }

    global.RedisDB = redisClient
}

使用Go-Redis库与Redis服务器交互。

7.2 文章点赞

func LikeArticle(ctx *gin.Context) {
    articleID := ctx.Param("id")
    //组装出键
    likeKey := "article:" + articleID + ":likes"
    if err := global.RedisDB.Incr(likeKey).Err(); err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }

    ctx.JSON(http.StatusOK, gin.H{
        "message": "点赞成功",
    })
}

使用Incr命令递增文章的点赞数。

7.3 获取点赞

func GetArticleLikes(ctx *gin.Context) {
    articleID := ctx.Param("id")
    fmt.Print(articleID)
    likeKey := "article:" + articleID + ":likes"

    likes, err := global.RedisDB.Get(likeKey).Result()
    if err == redis.Nil {
        likes = "0"//没有数据则创建一个0值
    } else if err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
    }

    ctx.JSON(http.StatusOK, gin.H{
        "likes": likes,
    })
}

8. 文章与缓存

8.1 创建文章并更新缓存

在创建文章的同时，删除Articles缓存，避免用户获取到旧的文章列表。

func CreateArticle(ctx *gin.Context) {
    // 绑定JSON请求体到文章结构
    var article models.Article
    if err := ctx.ShouldBindJSON(&article); err != nil {
        ctx.JSON(http.StatusBadRequest, gin.H{
            "error": err.Error(),
        })
        return
    }

    // 自动迁移表结构
    if err := global.Db.AutoMigrate(&article); err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }

    // 创建文章记录
    if err := global.Db.Create(&article).Error; err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }

    // 删除缓存以保证数据一致性
    if err := global.RedisDB.Del(cacheKey).Err(); err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }

    // 返回创建的文章
    ctx.JSON(http.StatusCreated, article)

}

8.2 获取全部文章

优先从缓存中获取，如果获取不到再从数据库查询，并写入缓存。

func GetArticles(ctx *gin.Context) {
    // 尝试从Redis获取缓存数据
    cachedData, err := global.RedisDB.Get(cacheKey).Result()

    if err == redis.Nil {
        // 缓存不存在，从数据库查询
        var articles []models.Article

        if err := global.Db.Find(&articles).Error; err != nil {
            ctx.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }

        // 序列化文章数据
        articleJSON, err := json.Marshal(articles)
        if err != nil {
            ctx.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }

        // 设置Redis缓存，有效期10分钟
        if err := global.RedisDB.Set(cacheKey, articleJSON, 10*time.Minute).Err(); err != nil {
            ctx.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }
        ctx.JSON(http.StatusOK, articles)
    } else if err != nil {
        // Redis操作出错
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return

    } else {
        // 使用缓存的数据
        var articles []models.Article
        if err := json.Unmarshal([]byte(cachedData), &articles); err != nil {
            ctx.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }
        ctx.JSON(http.StatusOK, articles)
    }

}

总结

此项目结合了Gin框架和Gorm ORM，使用JWT进行用户身份验证，通过Redis缓存实现点赞功能，且配置通过Viper加载。项目结构简洁而清晰，代码通过分层结构便于维护，包含了基本的CRUD操作和API设计。

‍

借助本地部署的AI工具制作视觉小说

Mon, 09 Sep 2024 00:00:00 GMT

:::warning AI发展如此之快。本文撰写于2024年9月，所用工具和方法可能已经过时。 本文是应选修课程要求所写，因此内容较为肤浅，且未经过严格的校对和润色。 :::

一次有趣的实践

在校内选修了一门以“生成式AI”为主题课程，课程上讲授的一些内容与我的一个埋藏已久的点子不谋而合——从零开始开发一部视觉小说。鉴于此前已经有基于前端技术开发简单视觉小说应用的经验，再加上现在有了各领域都有了强大AI的帮助，因此我决定好好地尝试一次，从部署AI工具，到运行程序的搭建，完全从零开始用AI来实现每一步。

‍

技术路线

项目结构

首先需要明确的是，要制作基本完整的视觉小说作品，至少需要完成以下几个部分：引擎，角色设定，剧情脚本，场景图，角色表情动作差分图，片头视频（Opening），片尾视频（Ending）。接下来对这些必备元素稍做分析。

引擎是游戏的载体，是负责向用户展示故事情节与视觉小说基本功能（存取进度等）的程序。为了方便成品可以轻松运行、随处可用，同时简化开发难度，这里采用单页web应用做为游戏载体，借助Vue及前端技术栈开发。整个开发过程将会借助cursor、GitHub copilot等编程助手来实现。为了更完善的用户体验，也将同步推出基于Electron的Windows、MacOS桌面端应用（毕竟技术栈都一样）。

市场上的部分引擎

角色设定及剧情脚本是支撑游戏内容的重要部分，这部分将由本地LLM来完成创作。通过撰写完善的提示词与大致的剧情纲要，大语言模型有能力生成详尽的人物外观、性格、经历设定，并根据这些信息来帮助生成更符合角色特征的对白。最后依然借助本地大语言模型将对白数据结构化，导入到游戏文件中。

场景图和角色差分图，前者的制作较为简单，只需要向本地绘画模型描述（在comfy web UI中输入）大致内容即可。但是角色差分图的制作将会较为复杂，因为在整个游戏流程中，同一个角色的外貌特征应该有着极高的稳定性，但是却又需要根据不同的情节调整表情、姿态，这是主要难点。

表情的局部差分

角色稳定性方面主要有两种途径来解决，一是通过详尽的外貌提示词和较高的提示词权重来限制AI的创作，二是先使用一张基准图片搭配不同的提示词（img2img功能）来创建一组相似的该角色的图片，之后将图片组训练为Lora模型，在后续的生成中使用Lora来控制人物形象。
表情可以使用蒙版工具（局部重绘）来修改，将底图与盖住脸部的蒙版同时导入，即可实现仅仅修改脸部表情。
姿态可以使用ControlNet来控制，借助ControlNet和pose模型，我们可以将一张真人姿态照片应用到生成出的角色身上。

此外，得益于国外HuggingFace与国内LibLib等开源社区，许多Checkpoint、Lora和comfy UI工作流可以直接使用，使得角色风格更丰富更容易控制。在提示词超市（亦称为标签超市、魔导书）中，也可以随心选择需要的提示词组合，更方便的控制和微调图像生成结果。

本地与云端大模型

本项目尽可能使用在本地部署的AI工具，仅在当本地端没有可以满足质量和效率要求的工具，或是工具所需显存过大的情况下才借助云端产品。主要环节实现途径如下表。

实现途径	任务
本地绘画模型	绘制背景图、绘制角色立绘、绘制表情与动作差分图
本地LLM	撰写人设、完善故事细节、输出结构化对白数据
Suno.ai	生成Opening、Ending音乐、生成剧情BGM
人力	将素材组织为Opening、Ending视频、搭建服务端

Suno音乐与歌曲生成

提示词工程

在视觉小说的制作过程中，提示词的设计至关重要，因为它直接影响AI生成内容的质量与一致性。在为不同的素材撰写提示词时，需要根据目标内容的特点，确保提示词具备足够的清晰度、细节性以及创意空间。

角色设定的提示词需要涵盖角色的外貌特征、性格、背景故事等多维度信息，确保AI生成的人物不仅外形符合预期，性格与行为逻辑也能融入剧情。提示词可以包含年龄、发型、服装风格等具体描述，同时通过性格词汇设定角色的情感表达与互动方式。

场景图的提示词则更注重对氛围、色彩和空间布局的描述。场景不仅仅是视觉背景，还承载了故事的情感基调。因此，在撰写提示词时，可以明确指出时间、季节、光线效果等因素，帮助AI生成符合故事氛围的环境。

角色表情与动作差分图的提示词撰写需要特别注重情感和动态的表达。要确保不同的情绪（如愤怒、喜悦、悲伤）的细微差别能够通过提示词传达出来。这里需要通过明确的情感词汇和动作描写，如“微笑”、“皱眉”、“抬手”等，帮助AI准确抓住角色的情感和动作变化。

实际搭建

comfy UI

本体部署

Comfy UI 的本体托管在 GitHub 上，我们可以通过 git 来拉取最新版。首先，可以借助scoop等包管理器或官网MSI安装工具在系统中安装 Git 和 Python环境（3.8+），然后在终端中运行以下命令来克隆 Comfy UI 仓库并进入项目目录：

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

接着，通过以下命令安装所需依赖并启动 Comfy UI：

pip install -r requirements.txt
python main.py

启动完成后，Comfy UI 将可以通过本地的 Web UI 进行访问，在 http://localhost:8188 上。通过网页界面，我们就可以直接进行节点编辑、工作流制作和图像生成了。

插件管理器

Comfy UI 的许多功能和节点都依赖插件实现，但手动安装插件耗时较长，尤其是在加载新的工作流时需要安装大量节点。为了解决这个问题，可以借助 manager 插件来简化安装与管理节点的流程。该插件允许一键安装缺失插件，自动更新已安装的插件，极大地提升了效率。使用时只需在插件管理器中选择相应的插件或节点库，系统会自动进行安装与升级。

要安装，直接终端里输入以下命令（工作目录均为Comfy UI 根目录）

cd custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

借助 Blender 的 Shade 中的节点样式 UI

虽然 Comfy UI 自带的 Web UI 功能强大，但在操作上略显局限，特别是在与本地文件系统的交互上不够便利。哔哩哔哩开源作者“一瓶辣椒酱”开发的 铁锅炖 插件可以用 Blender 的节点样式 UI 替代 Comfy Web UI ，从而提升用户体验。

Blender 等专业 3D 软件的材质和效果器编辑方式与 Comfy UI 的节点编辑方式十分相似。通过下载“铁锅炖”，并将插件安装至 Blender 目录下，我们可以使用 Blender 的直观 UI 来编辑 Comfy UI 中的节点，使操作更加便捷且直观。

下载“铁锅炖” -> 首页安装插件至 Blender  -> 启动blender并切换的Comfy Node界面 ->连接Comfy UI Server

Checkpoint 模型与 Lora

Comfy UI 支持加载 HuggingFace 和哩布哩布等平台上开源的 Checkpoint 模型和 Lora 模型。我们可以通过社区网站提供的模型预览和介绍选择需要的模型文件，下载后将其放入 Comfy UI 中的 models 目录下的对应文件夹。然后，在 Comfy UI 的节点中加载这些模型，即可在工作流中使用不同的模型来生成不同风格的图像。具体路径如下：

/models/Checkpoints/   # Checkpoint 模型目录
/models/Lora/          # Lora 模型目录

加载模型后，通过 UI 中的模型节点进行选择与应用，便可以将不同模型的风格应用到项目中。

工作流

在 HuggingFace 和哩布哩布等开源社区中，不仅可以下载模型，还可以找到许多功能强大的工作流模板。通过直接导入这些工作流，我们可以快速实现复杂的功能，而不需要从零开始搭建。例如，可以在社区中下载一个多节点的工作流，并通过 Comfy UI 导入，以完成图像生成、角色设定等任务。导入工作流时，Comfy UI Manager会检查所需的节点和插件是否完整，缺失的内容会提示你使用插件管理器一键安装。

平台浏览和下载

本地一键导入、补齐缺失节点

LLM

在本地部署大语言模型（LLM）是生成式AI开发中的一项重要步骤，我们可以在不依赖云端服务的情况下，直接在本地设备上运行强大的语言模型。在这里以Meta公司最新发布的 Llama 3.1 模型为例，在本地进行部署和运行。

硬件要求

首先需要确保电脑满足以下硬件要求：

显卡：NVIDIA RTX 3060 或更高
显存：至少 8 GB
内存：至少 16 GB
硬盘：至少 20 GB 可用空间

安装 Ollama 客户端

为了在本地部署 Llama 3.1 模型，我们需要安装 Ollama 客户端。该客户端不仅能让我们下载并运行 Llama 模型，还可以管理与模型相关的数据和文件。

首先，前往 Ollama 官方网站下载客户端并安装。默认安装目录为 C:\Users\你的用户名\.ollama。在这个目录下可以找到下载的模型文件和相关数据。

部署 Llama 3.1 模型

Ollama 客户端为我们提供了简单的命令行方式来安装和运行大语言模型。在终端中，使用以下命令来安装 Llama 3.1-8B 模型：

ollama run llama3.1:8b

这个命令会在第一次运行时自动下载所需的模型文件，并将它们存储在默认目录中。Llama 3.1-8B 模型需要至少 8GB 的显存来运行，适合个人开发者或中小型项目。

如果你的计算资源较为有限，Llama 3.1-8B 通常已经足够满足大部分任务需求。如果你需要更高性能或处理更复杂的任务，Ollama 还提供了更大模型（如 70B 和 405B）的下载和运行，但这些模型的硬件要求显著（真的很显著，高达450GB显存需求）增加。

运行与交互

安装完成后，通过 Ollama 的终端可以直接与 Llama 3.1 模型进行交互。只需在终端中输入提示词，模型便会实时生成文本并进行反馈。对于那些更习惯使用类似 ChatGPT 图形界面的人，可以通过安装 GPT4ALL 软件来获得一个用户友好的本地 LLM 启动器。

然而，对于我们来说，使用终端与模型交互已经足够简单有效。

使用在线服务

非常简单，直接使用就好了，在此不再赘述。

Suno：进入官网，任选社交媒体账户登入即可获得免费额度。在create页面中输入需求即可创作。仅适合非大陆及港澳台地区。
cursor：进入官网，下载安装客户端并从VS code迁移配置即可开始使用。引导教程涵盖补全、重写、整个项目作为上下文生成。
GitHub Copilot：对于教育工作者和学生（大善人GitHub已收录本校），通过教育邮箱完成教育认证即可获得免费不限次的copilot使用权。在VS、VS code、Jetbrain系列IDE里面只需要安装copilot插件然后登陆一下账户即可。

谁用谁知道，反正就是爽

‍

如何用自己的域名做https内网穿透

Thu, 05 Sep 2024 00:00:00 GMT

用自己的域名做https内网穿透

为什么要做穿透

前段时间用黑裙nas折腾好了一些私有云服务，在内网提供emby、Komga、云同步、音乐库等服务。不过很快就遇到了一些问题，校内个别地方连通性不太好，管理给内网的设备之间做了隔离，因此无法在这些地方使用服务。此外，一旦离开内网环境，出门玩耍、实习的时候也没法愉快享受影音乐趣，很是不爽。

看了多个大厂的穿透服务，性价比不能说很低，只能说没有。遂去海鲜市场和各小厂找解决方案。转了一圈发现Sakura FRP的性价比挺不错，操作起来也简单，支持导出frpc客户端配置。本次就以Sakura穿透服务为例聊一聊如何用自己的域名搭配内网穿透服务，并开启https安全连接。

刚刚做好了FC社的宣传图，要怎么做才能让学长访问到呢？

开启隧道遇到的问题

Sakura对于备案要求比较严格，未备案域名无法使用国内节点对外暴露80/443端口。使用自定义端口的TCP隧道时，节点于客户端之间必须开启https。

这就产生的一个问题，Sakura一些节点的证书未被浏览器信任，直接通过节点域名+端口访问服务时，首先是浏览器会报不安全，非常烦人；其次是一些服务的客户端APP只认安全连接，没办法用。为了解决这些问题，我决定用自己的域名和zeroSLL证书来访问服务。

申请免费SSL证书

如果我们有自己的公网IP，那么则可以直接将域名解析到自己的IP或者套一层Cloudflare代理，随后通过Certbot直接自动向Let’s Encrypt之类的机构申请即可。但是我们现在的状况是：正因为没有公网IP，所以需要做内网穿透+域名访问，因此需要通过其他方法来获取证书。

随着各大平台提供SSL证书有效期不断缩短，现在能获取到的免费证书基本都是只有90天有效期，需要手动续期，这里以Zero SSL为例。

首先来到官网，直接在最显眼的输入框里输入我们要申请的域名，例如sakura.yourdomain.com，之后一路下一步。

随后，Zero SSL会要求你验证你是域名的所有者，这里采用DNS验证比较简单。首先来到DNS提供商的后台，这里依然使用Cloudflare。

按照提示创建一条CNAME记录
将网页提供的Name去掉主域名和顶级域名（即yourdomain.com这部分），保留子域名填入Cloudflare的名称一栏
Point整个填入目标一栏
小云朵代理一般不需要开启，保存即可

:::tip
对于其他DNS提供商，也是类似的操作。例如你购买了阿里云的域名，则可以直接在阿里云控制台设置DNS解析。
:::

完成操作后在浏览器中点击下一步等待自动验证即可，完成后就可以下载包含证书及私钥的压缩包了，之后将在frpc客户端中使用它。

:::warning
续期过程中，用户可以选择继续使用原来的密钥对，或者生成新的密钥对。如果生成新的密钥对，证书中的公钥信息会改变！
:::

开通隧道

来到SakuraFRP后台，根据下图格式创建一个隧道，现在我们没有开放80/443端口的需求（要备案的/(ㄒoㄒ)/~~），所以可以不选带有“建站”标签的节点。

图中的本地IP，如果你在同一台机器上运行服务端和穿透客户端，则选择127.0.0.1，否则填写服务端所在设备的内网IP（例如你决定在路由器或另一台内网设备上跑穿透）。本地端口为你的服务端所使用的端口。

域名解析到节点

接下来需要将域名解析到Sakura提供的穿透节点，节点的域名可以把鼠标放上去查看。

知道了节点域名之后就可以在DNS页面创建一条CNAME记录，指向Sakura穿透节点即可，名称可以随意。

配置客户端并启动

在frpc客户端，我们需要添加证书和key。这里使用的是Sakura FRP启动器，它实际上是个frpc套壳，操作原理都是相同的。通过查阅SakuraFRP的wiki，可以得知群晖上的Sakura启动器工作目录的位置在/var/packages/natfrp/var。

:::tip
对于其他平台也是同理，只需要在平台对应的配置目录做操作即可。在这里要吐槽一下Sakura的wiki的导航和分类做的真的不太好，要查什么东西需要翻半天才能找到......
:::

核心服务的所有文件都是相对于 工作目录 创建的。下面是工作目录的默认值：

Windows：%PROGRAMDATA%\SakuraFrpService

macOS：~/Library/Containers/com.natfrp.launcher/Data/Library/Application Support/natfrp-service

Linux / FreeBSD 下遵循 FreeDesktop 规范：

优先使用 $XDG_CONFIG_HOME/.config/natfrp-service

如果 $XDG_CONFIG_HOME 未设置，则使用 ~/.config/natfrp-service

Android 启动器：/data/data/com.natfrp.launcher/service/

OpenWrt LuCI 插件：/etc/natfrp

群晖 DSM 套件包：/var/packages/natfrp/var

Docker 镜像：/run/

‍

我们来到工作目录中，进入FrpcWokingDirectory，将域名证书与私钥文件放在这里即可。我们在电脑上将之前在ZeroSSL下载好的zip文件打开，里面的crt文件和key文件使用文本编辑器打开后复制即可。

cd /var/packages/natfrp/var/FrpcWorkingDirectory
sudo vi xxx.yourdomain.com.crt
#输入你的群晖管理员密码后，粘贴crt证书中的内容
#按下Esc，输入 :wq ,按下回车即可保存
sudo vi xxx.yourdomain.com.key
#同上

完成后，即可在启动器中开启隧道。访问群晖IP+4101端口进入后台，在隧道页通过拖拽的方式启用隧道即可弹出提示：“隧道已启动，您可通过https://节点域名:为你分配的端口访问”。此时就可以使用https://xxx.yourdomain.com:为你分配的端口/来随处访问你的服务啦。

:::tip
对于其他设备，则可以通过双击图标等更简单的方式来进入启动器页面，或者通过查阅Sakura的wiki、frpc文档、chatGPT来完成启动的步骤。在使用Sakura官方启动器之前，会要求通过token来进行登录，按照提示输入用户信息页面的访问密钥即可。
:::

c++数据结构常用操作

Sat, 29 Jun 2024 00:00:00 GMT

:::note 参考文档见于文末 ::: 在学习数据结构的过程中遇到了一些常用的STL操作和算法知识点，下面是整理后的结果。

数组

数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变特点。

基本操作

/* 初始化数组 */
// 存储在栈上
int arr[5];
int nums[5] = { 1, 3, 2, 5, 4 };
// 存储在堆上（需要手动释放空间）
int* arr1 = new int[5];
int* nums1 = new int[5] { 1, 3, 2, 5, 4 };

增删改

/* 索引 index 处插入 num */
void insert(int *nums, int size, int num, int index) {
    // 把索引 index 以及之后的所有元素向后移动一位
    for (int i = size - 1; i > index; i--) {
        nums[i] = nums[i - 1];
    }
    // 将 num 赋给 index 处的元素
    nums[index] = num;
}

/* 删除 index 处 */
for (int i = index; i < size - 1; i++) {
    nums[i] = nums[i + 1];
}

扩容

创建->复制->释放

链表

链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、环形链表、双向链表。

数组与链表的效率

	数组	链表
存储方式	连续内存空间	分散内存空间
容量扩展	长度不可变	可灵活扩展
内存效率	元素占用内存少、但可能浪费空间	元素占用内存多
访问元素	𝑂(1)	𝑂(𝑛)
添加元素	𝑂(𝑛)	𝑂(1)
删除元素	𝑂(𝑛)	𝑂(1)

增删改

/* 节点 n0 之后插入节点 P */
void insert(ListNode *n0, ListNode *P) {
    ListNode *n1 = n0->next;
    P->next = n1;
    n0->next = P;
}

/* 删除 n0 之后的首个节点 */
void remove(ListNode *n0) {
    if (n0->next == nullptr)
        return;
    // n0 -> P -> n1
    ListNode *P = n0->next;
    ListNode *n1 = P->next;
    n0->next = n1;
    // 释放内存
    delete P;
}

Vector列表

列表（list）是一个抽象概念，它表示元素的有序集合，支持元素访问、修改、添加、删除和遍历等操作。列表可以基于链表或数组实现。

常用操作

//初始化
vector<int> nums1;
vector<int> nums = { 1, 3, 2, 5, 4 };

//末尾插入删除
nums.push_back(元素)；
nums.pop_back()；//动态数组为空时pop会出错

//中间插入删除
nums.insert(nums.begin() + 3, 6);  // 在索引 3 处插入 6
nums.erase(nums.begin() + 3);      // 删除索引 3 处

// 将列表 nums1 拼接到 nums 之后
nums.insert(nums.end(), nums1.begin(), nums1.end());

//长度
nums.size();

//排序
sort(nums.begin(), nums.end());

//清空释放内存
vector<类型>().swap(名字);

一个列表类示例


class MyList {
  private:
    int *arr;             // 数组（存储列表元素）
    int arrCapacity = 10; // 列表容量
    int arrSize = 0;      // 列表长度（当前元素数量）
    int extendRatio = 2;   // 每次列表扩容的倍数

  public:
    /* 构造方法 */
    MyList() {
        arr = new int[arrCapacity];
    }

    /* 析构方法 */
    ~MyList() {
        delete[] arr;
    }

    /* 获取列表长度（当前元素数量）*/
    int size() {
        return arrSize;
    }

    /* 获取列表容量 */
    int capacity() {
        return arrCapacity;
    }

    /* 访问元素 */
    int get(int index) {
        // 索引如果越界，则抛出异常，下同
        if (index < 0 || index >= size())
            throw out_of_range("索引越界");
        return arr[index];
    }

    /* 更新元素 */
    void set(int index, int num) {
        if (index < 0 || index >= size())
            throw out_of_range("索引越界");
        arr[index] = num;
    }

    /* 在尾部添加元素 */
    void add(int num) {
        // 元素数量超出容量时，触发扩容机制
        if (size() == capacity())
            extendCapacity();
        arr[size()] = num;
        // 更新元素数量
        arrSize++;
    }

    /* 在中间插入元素 */
    void insert(int index, int num) {
        if (index < 0 || index >= size())
            throw out_of_range("索引越界");
        // 元素数量超出容量时，触发扩容机制
        if (size() == capacity())
            extendCapacity();
        // 将索引 index 以及之后的元素都向后移动一位
        for (int j = size() - 1; j >= index; j--) {
            arr[j + 1] = arr[j];
        }
        arr[index] = num;
        // 更新元素数量
        arrSize++;
    }

    /* 删除元素 */
    int remove(int index) {
        if (index < 0 || index >= size())
            throw out_of_range("索引越界");
        int num = arr[index];
        // 将索引 index 之后的元素都向前移动一位
        for (int j = index; j < size() - 1; j++) {
            arr[j] = arr[j + 1];
        }
        // 更新元素数量
        arrSize--;
        // 返回被删除的元素
        return num;
    }

    /* 列表扩容 */
    void extendCapacity() {
        // 新建一个长度为原数组 extendRatio 倍的新数组
        int newCapacity = capacity() * extendRatio;
        int *tmp = arr;
        arr = new int[newCapacity];
        // 将原数组中的所有元素复制到新数组
        for (int i = 0; i < size(); i++) {
            arr[i] = tmp[i];
        }
        // 释放内存
        delete[] tmp;
        arrCapacity = newCapacity;
    }

    /* 将列表转换为 Vector 用于打印 */
    vector<int> toVector() {
        // 仅转换有效长度范围内的列表元素
        vector<int> vec(size());
        for (int i = 0; i < size(); i++) {
            vec[i] = arr[i];
        }
        return vec;
    }
};

栈

常用操作

/* 初始化栈 */
stack<int> stack;

/* 入栈 */
stack.push(1);

/* 访问栈顶 */
int top = stack.top();

/* 元素出栈 */
stack.pop(); // 无返回值

/* 长度 */
stack.size();

/* 是否为空 */
stack.empty();

手动实现

:::note
较为冗长，点击此处阅读
:::

队列、双向队列

常用操作

队列

/* 初始化 */
queue<int> queue;

/* 入队 */
queue.push(1);

/* 访问队首 */
queue.front();

/* 出队 */
queue.pop();

queue.size();
queue.empty();

双向队列

:::tip
兼具栈与队列的逻辑，因此它可以实现这两者的所有应用场景，同时提供更高的自由度。
:::

deque<int> deque;

/* 入队 */
deque.push_back(2);   // 添加至队尾
deque.push_front(3);  // 添加至队首

/* 访问 */
deque.front(); // 队首元素
deque.back();   // 队尾元素

/* 出队 */
deque.pop_front();  // 队首元素出队
deque.pop_back();   // 队尾元素出队

/* 获取双向队列的长度 */
int size = deque.size();

/* 判断双向队列是否为空 */
bool empty = deque.empty();

实现

队列可以基于链表或者数组实现。基于链表时可以将列表的头尾节点分别视为队首和队尾，只在队尾插入只在队首删除；使用数组实现时只需要记录队首的索引、长度，通过公式计算队尾索引。

当队伍移动到数组末尾时可以使用环形数组的存储方式，对队尾索引取模可得队尾实际位置。但是实现的队列仍然具有局限性：其长度不可变。

哈希表

负载因子（load factor）是哈希表的一个重要概念，其定义为哈希表的元素数量除以桶数量，用于衡量哈希冲突的严重程度，也常作为哈希表扩容的触发条件。

哈希表的结构改良方法主要包括 “链式地址”和“开放寻址” 。

链式地址（separate chaining）将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中。当链表很长时，查询效率 𝑂(𝑛) 很差。此时可以将链表转换为“AVL 树”或“红黑树”，从而将查询操作的时间复杂度优化至 𝑂(log⁡𝑛) 。

开放寻址（open addressing）不引入额外的数据结构，而是通过“多次探测”来处理哈希冲突，探测方式主要包括线性探测、平方探测和多次哈希等。我们不能在开放寻址哈希表中直接删除元素。

线性探测采用固定步长的线性搜索来进行探测。过哈希函数计算桶索引，若发现桶内已有元素，则从冲突位置向后线性遍历（步长通常为 1 ），直至找到空桶，将元素插入其中线性探测容易产生 “聚集现象” 。具体来说，数组中连续被占用的位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促使该位置的聚堆生长，形成恶性循环，最终导致增删查改操作效率劣化。

平方探测与线性探测类似，都是开放寻址的常见策略之一。当发生冲突时，平方探测不是简单地跳过一个固定的步数，而是跳过“探测次数的平方”的步数，即 1,4,9,… 步。

多次哈希方法使用多个哈希函数 𝑓1(𝑥)、𝑓2(𝑥)、𝑓3(𝑥)、… 进行探测。与线性探测相比，多次哈希方法不易产生聚集，但多个哈希函数会带来额外的计算量。

常用操作

/* 初始化 */
unordered_map<int, string> map;

// 添加键值对 (key, value)
map[12836] = "小哈";

// 查询value
string name = map[15937];

// 删除键值对 (key, value)
map.erase(10583);

/* 遍历哈希表 */
// 遍历键值对 key->value
for (auto kv: map) {
    cout << kv.first << " -> " << kv.second << endl;
}
// 使用迭代器遍历 key->value
for (auto iter = map.begin(); iter != map.end(); iter++) {
    cout << iter->first << "->" << iter->second << endl;
}

树

术语

节点所在的层（level）：从顶至底递增，根节点所在层为 1 。
节点的度（degree）：节点的子节点的数量。
二叉树的高度（height）：从根节点到最远叶节点所经过的边的数量。
节点的深度（depth）：从根节点到该节点所经过的边的数量。
节点的高度（height）：从距离该节点最远的叶节点到该节点所经过的边的数量。

二叉树常用操作

插入与删除节点

TreeNode* P = new TreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1->left = P;
P->left = n2;
// 删除节点 P
n1->left = n2;

层序遍历（BFS）

可以借助队列来实现

/* 层序遍历 */
vector<int> levelOrder(TreeNode *root) {
    // 初始化队列，加入根节点
    queue<TreeNode *> queue;
    queue.push(root);
    // 初始化一个列表，用于保存遍历序列
    vector<int> vec;
    while (!queue.empty()) {
        TreeNode *node = queue.front();
        queue.pop();              // 队列出队
        vec.push_back(node->val); // 保存节点值
        if (node->left != nullptr)
            queue.push(node->left); // 左子节点入队
        if (node->right != nullptr)
            queue.push(node->right); // 右子节点入队
    }
    return vec;
}

前中后序遍历（DFS）

深搜借助递归来实现。二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：二叉搜索树的中序遍历序列是升序的。

/* 前序遍历 */
void preOrder(TreeNode *root) {
    if (root == nullptr)
        return;
    // 访问优先级：根节点 -> 左子树 -> 右子树
    vec.push_back(root->val);
    preOrder(root->left);
    preOrder(root->right);
}

/* 中序遍历 */
void inOrder(TreeNode *root) {
    if (root == nullptr)
        return;
    // 访问优先级：左子树 -> 根节点 -> 右子树
    inOrder(root->left);
    vec.push_back(root->val);
    inOrder(root->right);
}

/* 后序遍历 */
void postOrder(TreeNode *root) {
    if (root == nullptr)
        return;
    // 访问优先级：左子树 -> 右子树 -> 根节点
    postOrder(root->left);
    postOrder(root->right);
    vec.push_back(root->val);
}

实现

完全二叉树可以用数组来实现，但是不适合存储数据量过大的树，增删节点需要通过数组插入与删除操作实现，效率较低。

/* 二叉搜索树查找 */
TreeNode *search(int num) {
    TreeNode *cur = root;
    while (cur != nullptr) {
        // 目标节点在 cur 的右子树中
        if (cur->val < num)
            cur = cur->right;
        // 目标节点在 cur 的左子树中
        else if (cur->val > num)
            cur = cur->left;
        else
            break;
    }
    // 返回目标节点
    return cur;
}

AVL树、B树、红黑树

AVL树（Adelson-Velsky and Landis树）是一种自平衡的二叉搜索树。它通过在每个节点上维护平衡因子（即左子树和右子树的高度差）来确保树的平衡，从而保证基本操作的时间复杂度为O(log n)。每次插入或删除操作后，AVL树会通过旋转操作来重新平衡树。

与二叉搜索树不同，B树的节点可以有多个子节点。适用于大规模数据存储，因为它可以高效地进行范围查询和顺序遍历，并且由于其节点可以存储多个键值对，它减少了需要访问磁盘的次数，从而提高了性能。

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树。它通过在每个节点上附加一个颜色属性（红色或黑色）来保持平衡，确保树的高度大致为O(log n)

实现细节可以参考CS61B的七海版教学：七海讲数据结构，质量很好也很有趣。

堆

需要指出的是，许多编程语言提供的是优先队列（priority queue），这是一种抽象的数据结构，定义为具有优先级排序的队列。

实际上，堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列。从使用角度来看，我们可以将“优先队列”和“堆”看作等价的数据结构。

常用操作

/* 初始化堆 */
// 初始化小顶堆
priority_queue<int, vector<int>, greater<int>> minHeap;
// 初始化大顶堆
priority_queue<int, vector<int>, less<int>> maxHeap;

/* 元素入堆 */
maxHeap.push(1);

/* 获取堆顶元素 */
maxHeap.top(); 

/* 堆顶元素出堆 */
// 出堆元素会形成一个从大到小的序列
maxHeap.pop(); //c++中无返回值，python有

maxHeap.size();
maxHeap.empty();

/* 输入列表并建堆 */
vector<int> input{1, 3, 2, 5, 4};
priority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());

实现

完全二叉树非常适合用数组来表示。由于堆正是一种完全二叉树，因此可以采用数组来存储堆。

节点指针通过索引映射公式来实现。给定索引 𝑖 ，其左子节点的索引为 2𝑖+1 ，右子节点的索引为 2𝑖+2 ，父节点的索引为 (𝑖−1)/2（向下整除）。当索引越界时，表示空节点或节点不存在。

添加元素之后，由于值可能大于堆中其他元素，堆的成立条件可能已被破坏，因此需要修复从插入节点到根节点的路径上的各个节点，这个操作被称为堆化（heapify）。从入堆节点开始，从底至顶执行堆化。出堆时根节点开始，从顶至底执行堆化

参考资料

‍

最方便的 CLion 一键分别运行多个cpp方法

Sat, 22 Jun 2024 00:00:00 GMT

:::note
文章标题所提到的是指中文互联网易于得到的搜索结果中，本方法是运行起来最为快捷的、准备起来最为简易并且一劳永逸的。不包含社区可能存在的更优解决方案。 这个方案主要适用于学习C++过程中，方便在同一个项目下运行不同的、带main函数的cpp文件。
:::

痛点所在

众所周知，CLion在创建项目后会自动给我们一个main.cpp，如果我们想在项目目录中同时存放多个cpp文件，会发现其他cpp的main函数是无法运行的。

目前网上已有的各种博客和解决方案无非是：

在右上角的运行区域手动添加当前cpp文件的运行配置
在Cmake配置文件中手动引入当前cpp文件，之后重载Cmake项目，从右上角运行区域选择需要运行的cpp
在Cmake配置文件中写脚本或者直接全局引入*.cpp，在设置中勾选自动重载Cmake项目，最后从右上角运行区域选择需要运行的cpp
安装插件来一键在Cmake配置文件中引入，从右上角运行区域选择需要运行的cpp
安装插件来直接编译cpp，但是运行起来不方便

但是这些方案，我认为全都不够方便，都需要多次鼠标甚至是编辑文件操作，完全是浪费了效率，也不优雅。急需寻找一套不借助任何插件！

解决思路

借助脚本文件，将当前cpp文件传递给编译脚本，编译完成后在终端中执行exe成品

具体实现

:::warning
在CLion设置中进行任何编辑之后，应该立即点击应用按钮，否则极可能出错。必要的时候可以关闭设置页面重开。
:::

‍

创建编译运行脚本

在不包含空格和中文的目录中创建run_current.bat，其中内容按照如下格式填写

@echo off
setlocal

rem Get the filename without extension
set filename=%1
set target_name=%~n1

rem Navigate to the project directory
cd /d %~dp0

rem Compile the CPP file
你的编译器路径\mingw64\bin\g++ -o 你希望编译文件输出的位置\OUTPUT\%target_name% %filename%

if %errorlevel% equ 0 (
    rem Run the executable if the build was successful
    你希望编译文件输出的位置\OUTPUT\%target_name%
) else (
    echo Build failed
)

endlocal

其中，你的编译器路径如果你不知道，可以打开CLion>设置>构建执行部署>工具链>MinGW（默认）>工具集>下拉菜单

这里面会显示你的编译器路径，注意不要有空格，如果有需要在bat里面加引号："你的编译器路径\mingw64\bin\g++"

脚本的含义是接受cpp文件作为参数，然后在控制台编译并运行它。

你应该提前创建好这个路径中的所有文件夹，不允许中文和空格：你希望编译文件输出的位置\OUTPUT\

一切完成后保存，复制bat文件的路径，我这里以D:\WORK\run_current.bat为例。在你实践的时候记得替换成自己的目录。

向脚本传参

来到CLion>设置>工具>外部工具>加号，创建一个外部程序入口。

名称随便写，程序填写cmd.exe。实参填写/c "D:\WORK\run_current.bat" "$FileDir$\$FileName$"，注意替换这里面的bat文件位置。工作目录填写 $ProjectFileDir$ 。

这里的意思是以当前项目目录为工作目录调用我们的编译运行脚本，同时把cpp文件路径+文件名.cpp作为参数传递到脚本中执行。

添加快捷键

来到CLion>设置>按键映射>外部工具>外部工具>外部工具>双击选择添加键盘快捷键，这里推荐Alt+Shift+Z，方便按还没有热键冲突。

消除“不属于任何项目目标”警告

由于CLion默认Cmake配置原因，除了main.cpp之外的cpp默认都不能开启代码洞察（如果你创建CPP文件的时候没勾选加入项目目标的话）。

首先来到CLion>设置>构建执行部署>Cmake勾选自动重载Cmake项目：

随后来到默认创建的CMakeLists.txt中，将set(CMAKE_CXX_STANDARD XX)这一行以下的内容删除，替换为：

file(GLOB SOURCES "*.cpp")

add_executable(项目名 ${SOURCES})

cmd控制台显示中文乱码

对于某些设备，用c++输出中文的时候，控制台都是乱码。造成此现象的原因是GBK于UTF8编码的转换问题。来到CLion>设置>编辑器>文件编码将全局改为GBK即可。

对于已有的UTF8编码的cpp文件，可以打开它后双击shift，选择操作，输入文件编码，选择文件编码（文件|文件属性）。在弹出菜单中选择GBK，最后单击转换即可。

‍

爽一把

在项目里面任意位置新建一个cpp，随便写点代码，按一下Alt+Shift+Z。终端瞬间就会开始编译执行你当前的cpp文件啦！如丝般顺滑~

、

ACGN爽记-4-清晰视界:全平台视频超分插帧

Mon, 20 May 2024 00:00:00 GMT

概要

使用MPV.net-DW和Reex播放器，与Anime4K算法搭配，在全平台实现视频超分。效果如下图。

这次我们先不聊服务端，而是从播放器入手提升我们观看的幸福度。从感知上来说，无论我们的影片下载、收集、整理等步骤做得多好，如果没有一个好的播放器来呈现它们，我们实际的观看体验并不会好很多。很多朋友在折腾的过程中容易错把手段当做目的，实际上折腾的目标应该是为观看的幸福服务，而不是致力于提高NAS的参数、PT的流量等等。

现在大多数番剧资源都是720P分辨率，新番也往往只有1080P高码，对于4K屏幕或追求画质的人来说实在有些不够，旧番全屏之后更是糊上加糊。因此为了能够以4K分辨率爽看古今动画，接下来介绍一种思路。

播放器安装

从系统自带播放器，到优酷、迅雷看看、暴风影音、VLC、potplayer，我在冲浪的路上遇到了许多播放器，每次相遇都有一种“我怎么没早点发现？”的感慨。现在这种感慨又来了。

MPV作为开源项目，拥有众多分支，我们选用的是大佬做好的整合版MPV.net-DW。相比其他播放器，优势在于界面简洁美观、能正确渲染特效字幕、支持AI插帧、AI超分、支持HDR、支持杜比视界（据我所知PotPlayer直到最近才添加对杜比视界的官方支持）等等。接下来我们就看一看如何使用吧。

首先从github的diana7127/mpv.net-DW页面下载大佬打包的安装器，不过由于来自东方的神秘力量，我准备了能直接下载的链接。下载链接

安装完成后来到安装地址，打开播放器，右键画面进行设置。

在mpv设置中，基础->vo选项，如果你是比较新的N卡可以改成next。

.NET专属->start-size选项，建议改成session，否则切换视频到时候窗口大小跳来跳去。

之后我们找到一个视频文件，右键->打开方式->选择其他应用->在电脑上选择应用->选中刚才播放器文件->点击“始终”就可以用新播放器双击打开视频了。

开启超分和插帧

对于不同类型的视频，有不同的优化方法，我大致分为2D、3D、实拍三种来介绍。以下是插帧、超分功能的开启位置，具体选择什么可以自己尝试一下，图中是我推荐的选项。

对于2D动漫来说，推荐开启A4K HQ，不开启插帧。

对于3D视频，推荐同时开启二者，如果原视频本身就比较清晰，应该选择A4K Fast来避免卡顿。

对于实拍视频，只建议开启插帧，A4K会丢失细节。

通过右键设置的效果，在关闭窗口后不会保存，因此建议设置一下快捷键来方便一键开启这些效果。例如“按C开超”，“按V开插”。

手机平板超分

MPV官方播放器因为和高版本Android的兼容性问题，很难读到Anime4K配置文件。我们使用界面更美观，更方便的Reex播放器。播放器下载地址，Anime4K文件下载地址。

将Anime4K解压到手机里，例如 内部存储/shaders。然后安装Reex，打开设置->着色器->加号，选择刚才shader文件夹里的所有文件。

这里建议选择DTD x2，速度和效果比较均衡，当然其他的效果可以自己尝试。前，后对比如图。

结尾

超分拯救了低码率老番，就像近视患者带上眼镜一样，极大地提高了我们观看的幸福程度。不过这种粗暴加效果的方式可能会破坏压制组精心调教的画面效果，具体怎么选择就见仁见智咯，我个人是倾向于更高的分辨率，因为这是最直观最容易感受到的部分。本人才疏学浅，如果有不足之处欢迎留言！

‍

当代日式ACGN启发的立场体验装置

Sun, 19 May 2024 00:00:00 GMT

计算机学院

摘要

本研究通过分析当代日式 ACGN 作品，尤其是新海诚的《你的名字》，探讨了物品作为连接人与人之间情感和理解的象征。以此为灵感，提出了一个立场体验装置的设计概念，旨在促进深层次的人际理解和连接。该设计采用非人类中心主义视角，探索在技术进步和信息化社会背景下，人们如何通过设计促进真正的沟通和理解，从而解决现代社会中日益减少的人际连接和理解深度的问题。

关键词：立场体验装置、ACGN 文化、《你的名字》、人际理解与连接、非人类中心主义、设计思辨

从作品出发

在众多 ACGN（动画、漫画、游戏、轻小说）作品中，无论是近代还是现代，大部分都在探讨社会中人与人之间的联系与理解。是的，自 20 世纪中叶起，以《铁臂阿童木》为代表的一众作品，无论其媒介如何，是否受到西方风格影响，都将人之间的联系作为自身的重要组成部分。在当代日式 ACGN 作品中，最令我印象深刻的当属作家新海诚的作品，尤其是《你的名字》。

图 1 电影《君の名は。》主视觉图

自 2016 年在内地上映以来，这部电影以其独特的叙事手法和深刻的主题意义，在全球范围内引起了广泛关注。电影通过一个关于灵魂互换的故事和一个特殊物品，探讨了心灵和肉体、时间和空间以及人际间微妙的连接，这种连接触及了人类深层的情感和认同。它通过描绘两位主角——身处不同地点的少年男女，因超自然现象相遇而彼此交换身体，体验对方的生活——来展示这种连接和沟通的方式 1。《你的名字》不仅是一次视觉的享受，更是一次深刻的心灵旅程。它呈现了人们在追求理解和被理解的过程中所的重重阻碍。主角的经历，让我看到了理解和连接怎样发生，以及如何促使人们跨越时间和空间的障碍，感受彼此。身体互换不仅仅是一种剧情设定，更象征着深层次的心灵交换，提示着我们在现实世界中也应寻求更深刻的人际连接和理解。

新海诚 2 作为作家，对“物品对人心的象征意义”的描写似乎已经成为他的风格，这在他的作品中随处可见。链接角色的特殊物品在《云之彼端，约定的地方》中是自制飞机 Velaciela 和小提琴；在《秒速五厘米》中是花瓣和电车；在《追逐繁星的孩子》中是则歌薇丝矿石。

图 2Velaciela 上的重逢

除此之外，日式 ACGN 文化中不乏以物品为寄托探讨人与人之间连接的作品。例如，《星灵感应》通过模型火箭这一载体，讲述了同学之间心灵感应、建立友谊的故事，探讨了物品如何成为人类情感和记忆交换的载体。而《玉子市场》中的纸杯电话则象征着青梅竹马之间的互相的了解与交流。这些作品通过物品与人之间的互动，展现了日式 ACGN 中独有的对于人际连接和心灵理解的深刻见解。在本设计中采用的是《你的名字》中的元素——宫水家族的传统绳结（組紐くみひも）。这些绳结不仅是家族传统的体现，也象征着人与人之间的连接与纽带。这种物质文化中的象征意义，与产品主题形成了呼应。

图 3 近在咫尺，依然使用纸杯电话

通过以上展示的典型作品，我们可以看到，在日式 ACGN 文化中，物品不仅仅是故事中的道具，它们成为了连接人们内心世界的桥梁。这些作品通过精心设计的情节和信物，引导观众反思现实世界中人与人之间的联系与理解，激发了对更加深入人际理解和沟通方式的思考。在这样的背景下，探索如何通过设计来促进人们之间的理解和连接，成为了一个值得深入研究的课题。

寻找答案

在寻找设计灵感时，我发现《你的名字》稍不同于其他日式 ACGN 作品中那些微妙的人物关系和物品象征，它强调了深层的文化背景、在时间和空间上的跨度、见证了从陌生到联结的全过程，因此組紐 3 顺理成章地成为了立场体验装置的原形参考。

图 4 传统技艺在现代

问题的核心在于，尽管我们生活在一个技术日益进步、信息流通日益加快的时代，人与人之间真正的理解和深刻的连接似乎却在逐渐流失。这引出了一个深层次的探询：在现代社会中，人们是否还能够真正理解彼此？这个问题并不是留存与字面上的，它涉及到人类交流的本质、技术对人际关系的影响，以及我们如何在日益繁忙的生活中寻找意义和连接。

为了深入探讨这一问题，我选择了非人类中心主义 4 这一概念作为理论支撑。这一观点挑战了传统以人类为中心的世界观，提醒我们重新思考人类与自然、以及人与非人类实体之间的关系。通过这个视角，我开始思考设计不仅仅是满足人类需求的工具，更是一种促进所有生命体之间理解和和谐共存的手段。这种思考方式为我的设计带来了全新的视角，使我不再局限于人类自身，而是扩展到了更广阔的存在和多样性中，也即“物品”的形式。

在设计的物质选择上，宫水三叶家族的绳结作为装置的原型，在《你的名字》中，绳结不仅是家族传承的工艺品，更象征着时间、记忆以及人与人之间的不解之缘。这种传统的物品富含深厚的文化意义和情感价值，正是我想在设计中寻求的那种能够触动人心、促进深层次理解和连接的元素。通过将这种象征性的物品融入设计，我的目的是创造一个不仅仅是技术上的创新，而是能够触及人们内心、唤起共鸣和理解的装置。

图 5 绳结在无形之中连接

立场体验装置作为一个促进理解、启发思考的平台，核心功能是使使用者能够体验到其他人的感受和立场，这种体验超越了语言和文化的界限，触及了人类共有的情感和认知深层。我的设计目标是通过这种直观的体验，消除误解和偏见，建立更加深刻和真实的人际连接。

这个设计方案背后的意图并不仅仅是解决一个问题。我希望通过公众对这个装置的使用和体验，引发更广泛的社会讨论和反思。真正的理解是否可能？我们在追求技术进步的同时，是否忽略了人类情感和精神世界的深层需要？结合假设法和未来椎体模型，设计中还可能带来的思想上的隐私问题，以及在深层次的心灵连接中，精神污染的风险是否存在？儿童是否适合于成人共享内心？这些问题的探讨，使这个设计项目超越其物理形态，成为一个触发社会思考和对话的媒介。

图 6 产品概念图

研究总结

作品成为了我思辨设计的窗口。通过这种设计探究，我的立场体验装置旨在不仅仅是解决人们理解不足的问题，更重要的是激发人们对于人际关系、技术发展和个人内心世界的深入思考。在这个过程中，设计本身成为了一种语言，一种促进人类更加深刻相互理解和共情的语言，同时也是一个探索未来社会可能性的工具。在未来椎体模型 5 中，我相信我的设计可以拓展 Possible,提高 probable 在 plausible 中的占比，以求创造更美好的未来。

图 7 链接彼此-通向更好未来

图 8 思维导图

参考资料

你的名字。 - 维基百科，自由的百科全书[2024-3-18]
新海诚 - 萌娘百科万物皆可萌的百科全书[2023-10-12]
組み紐 - Wikipedia[2023-8-7]
人類中心主義與非人類中心主義辨難-王海明《哲學與文化》[2007-8]34 卷 8 期 P. 125-151
未来思维：一种心态，不是方法 - Design Research Design -[2020-12]

‍文中对于作品的引用和图片来自公开数据库和网络平台，如有侵权请通过邮箱联系。

宫崎骏谈《千与千寻》

Sat, 18 May 2024 00:00:00 GMT

宫崎骏谈《千与千寻》

:::note 摘自《The Art of Spirited Away-千与千寻官方艺术设定集》 北京联合出版公司出版 图像来源 IMDB 如有侵权请邮件联系删除 ::: 这是一个冒险故事。虽然故事里并没有出现什么神奇的武器或超能力，但它依然是一个冒险故事。只不过这个冒险故事并非以正邪对决为主题，而是讲述一名少女被扔在一个好人与坏人混杂的世界中，如何修行、学习友爱与奉献，并运用自己的智慧生存下来。最终她能够突破难关、逃脱劫难，回到原来的生活中，并不是因为恶被消灭了——恶是与这世间一样永存的，而是因为她获得了生存的能力。

当今社会，善恶变得暧昧不明，明明如此含糊，却又有着吞没与消费一切的欲望。而这部电影的主题，便是借用奇幻的体裁，将这样的社会清楚地描绘出来。

现在的小孩子们，在日常的生活中被圈养、被守护、被疏远，以至于对“活着”这件事只有一些稀薄而模糊的感受，他们只能让孱弱的自我越发膨胀。千寻软弱无力的手脚，经常挂着看什么都无聊的苦瓜脸，这些便是现在孩子们的象征。但是，当现实变得清晰，当她进退维谷而不得不直面危机的时候，一股她自己都不曾察觉的适应力与忍耐力涌现出来，她终于发现，她所拥有的生命，能够发挥出多么果断的判断力与行动力。

其实，大部分人遇事时只会陷入慌乱，反复咒骂着瘫坐在地上。而这样的人在落入千寻的处境时，恐怕很快就会被环境消灭掉，或者被强者吃掉吧。千寻之所以能成为主人公，绝不是因为她是个美少女，或者拥有多么稀世的灵魂，而是因为她拥有不为他人所吞噬的力量。这一点，才是这部作品的过人之处，所以也就不难理解，它得以成为一部给十来岁的女孩子们看的电影。

语言就是力量。在千寻所迷失的世界中，说话这件事是极有分量的，足以造成无法挽回的结果。在被汤婆婆支配的澡堂，只要说一句“我不愿意”“我想回家”，千寻当场就会被魔女赶出去。那时的她，要么流离失所最终在徘徊中消亡，要么变成不停下蛋的鸡直到被吃掉为止。相反，只要千寻说出“在这里工作”这句话，即使是魔女也不能无视她。现如今，人们将语言视为气泡般轻浮的行为，可以张口就来，而这不过是现实日益虚化的表现。语言依然是有力的，至今也是真理，只不过到处充斥的都是无力的空虚之词而已。

把他人的名字夺走，并不是要改变称呼，而是要完完全全地支配对方。小千毛骨悚然地发现，连她自己都在逐渐遗忘“千寻”这个名字。随着每次去猪舍，她也渐渐习惯父母变成了猪的模样。在汤婆婆的世界里，必须时时刻刻在被吃掉的危机中挣扎才能活下去。

在如此艰难的世间，千寻反而越来越有生气。电影的大团圆结局中，原本皱着一张苦瓜脸的角色，最后也会露出充满魅力、豁然开朗的表情。直到今天，这个世界的本质依然没有任何改变。这部电影就是要用自身的说服力向大众表明：语言就是意志，就是自我，就是力量。

选择以日本为舞台创作一部奇幻作品的意义也在于此。即使是童话故事，我也不想选那种退路多多的西欧童话风格。大家普遍觉得这部电影是效仿了常见的异世界故事，可我更愿意视其为《麻雀之家》或《老鼠的宫殿》的直系子孙。不说什么平行世界，我们的祖先本也是今天在麻雀的家里栽跟头、明天在老鼠大人的宴会上吃喝玩乐这么一路走来的。

汤婆婆居住的世界被设定成了仿欧风，为的是让人觉得似曾相识，从而产生似幻似真的感觉。同时，也是因为有日本传统造型这座宝库，为我们的想象提供了无尽的原料。民俗的空间——传说、传承、习俗、造型、祭祀甚至是咒术——如此丰富而独特，只是还不为大众所知。咔嚓咔嚓山和桃太郎这种故事已经无法让如今的孩子信服了。同时，难道包罗万象的传统艺术，就一定要局限在传统民间故事这么一个芝麻绿豆大小的世界中吗？不得不说，这就是一种想象力贫瘠的表现。如今的小孩子被高科技包围，在各种单薄的工业制品中渐渐失去了他们的根。所以必须传达给他们——我们拥有怎样丰富的传统。

我希望将传统的工艺与现代人愿意看的故事相结合，成为一片色彩斑斓的马赛克，镶嵌进电影的世界中，使其获得新鲜的认同感。同时，这也是我们对自己岛国居民身份的重新认知。

因为在这个无国界的时代，找不准自己定位的人，是最为别人所轻视的。你的定位就是你的过去、你的历史。没有历史的人、遗忘过去的民族，要么流离失所最终在徘徊中消亡，要么变成不停下蛋的鸡直到被吃掉为止。

愿这部作品能够让那些十来岁的女孩子观众领悟自己真正的期望。我想做的，就是这样的电影。

ACGN爽记-3-Komga、Mihon全平台漫画

Fri, 10 May 2024 00:00:00 GMT

:::warning
2024年6月起，由于一些原因，Docker镜像服务器的连通性存在问题，请确认您的网络质量。
:::

前言

在准备系列教程之初，我就计划将漫画库放在前面讲，因为它真的极大地改善了我追漫、收藏电子漫画的幸福感和方便程度。但是在 24 年初的时候，开源漫画阅读器项目 Tachiyomi 面临法务危机，其项目自身和众多第三方插件的后续更新都得不到保障，教程也就之好先略过这部分不讲。

不久后 Tachiyomi 的开发者将项目归档，并在 wiki 中发布了告别信，事件算是尘埃落定。不过好在开源社区有着极大的活力，仅仅数日后 Discord 上便成立了 Mihon 项目的发布服务器。作为 Tachiyomi 的后继者，Mihon 青出于蓝，不仅做到了全面向后兼容，在 UI 设计和稳定性上也积极更新。同时，作为阅读器灵魂所在的第三方插件仓库也得到了维护，目前来看 Mihon 已经稳定更新，适合用来日用了。

本期目标

这次我们将通过 Docker 来部署 Komga 漫画服务，以便在浏览器、手机、平板等设备上无缝阅读。推荐的方式是通过面板应用商店一键安装，不过对老司机，也会在文末提供 Docker Compose 配置供直接安装。

这次的效果图如下，多设备同时共享同一个漫画库：

‍

在服务端安装 Komga

来到我们之前设置过的面板后台，格式是 http://IP地址:端口/安全入口，如果忘记了可以在 Ubuntu 终端或者 SSH 中输入 sudo 1pctl user-info 来获得一个地址。

什么是终端、SSH？不妨看看教程第1篇吧。阅读

进入后台，在应用商店中搜索 komga 然后点击安装，记得勾选允许外部端口访问。

安装后来到容器页面，勾选“显示应用商店容器”，对着 komga 点击更多 > 编辑 > 挂载 > 添加 > 本机目录。第一个框填写 /home/你的用户名/comic 第二个空填写 /comic，保存即可。

导入已有漫画

无论是 Komga 还是 Mihon，对于漫画的目录结构都有一定要求。简单来说就是放漫画的文件夹里面，要有不同的作品文件夹，每个作品文件夹里面有 PDF、EPUB、ZIP、装在文件夹里的图片 等章节文件。例如，如果你和我一样用 comic 文件夹当做漫画库：

/comic/星电感应/第 1 话.cbz

/comic/你的名字/设定集/001.png

错误例子：/comic/葬送的芙莉莲 001.zip

/黄金拼图第 1 话.mobi

/comic/你的名字/你的名字第一话/你的名字第一话/第一话.cbz

方法一：Alist 上传。打开容器面板，选择左侧的容器，对着 Alist 点击更多-> 编辑-> 挂载，在这里设置目录映射关系。它自带的不需要动，我们直接添加

本机：/home/你的用户名/comic
容器：/mnt/comic

然后登录 Alist ，设置一个新的本地存储，把漫画上传进 comic 就好，这种方法以后上传都比较方便
方法二：面板直接上传。首先把漫画打包，然后在面板中打开主机 > 文件 > 找到 /home/用户名/comic> 上传压缩包 > 解压到此

这种方法最简单，但是每次导入都得这样操作一遍。
方法三：FTP/SFTP 客户端

在你的 SSH 软件里找到关于文件管理的按钮，直接把电脑里的漫画拖进去。例如Tabby就支持此功能。

应用内设置

点击快捷入口按钮进入 Komga 网页版，根据提示设置一下账号密码。点击“添加库”按钮，根文件夹设置为/comic 然后一路下一步即可。如果你是的机器性能不太够，可以取消勾选“计算文件哈希”，这个功能影响不大。

最后我们点一下扫描，自动分析就开始了，稍等就可以啦。

‍

移动端阅读

由于涉及到 Github 的 Mihon 和 Keiyoushi 仓库下载，但是由于一股神秘的东方力量，一些读者的网络连接不畅，所以我准备了能点开的下载链接。

iPhone 和 iPad 可以参考官方 wiki 安装软件，步骤相对简单，在此不在赘述（其实是我没有苹果手机，哭）。苹果教程

Mihon 本体：下载

Komga 插件：下载

全部安装好后打开 Mihon，选择存储位置时在手机根目录新建文件夹，起名为 Mihon，然后选择“使用此文件夹”。其他设置按照喜好选就好了。

选择浏览，插件，对着红色的 Komga 点击一下，信任他。之后点击 Komga 旁边的设置图标，关闭 Komga2 和 Komga3。点击 Komga(ALL)旁边的设置图标，在 address 里面填入 http://IP地址:25600 username 和 password 则是你设置的账号密码，填写后返回即可。

重启 Mihon，再次进入浏览 > 图源 >komga，长按漫画即可加入书架。

我个人推荐使用这种阅读方式而不是网页版，因为Mihon会预加载漫画，也可以缓存到本地，翻页更流畅。

看几乎任何漫画

如果本地没有多少漫画资源，或者想阅读更多漫画，可以使用 Mihon 的插件功能。如果你的网络比较好，可以在插件页面看见一个很长的列表，就可以下滑找到中文分类，然后随便安装几个喜欢的插件。信任他们后，回到主页搜索栏输入漫画名，点击全局搜索，点击全部结果就可以把在线资源加入书架啦。

如果连接不顺畅，可以尝试在网上或者码云搜索Tachiyomi插件来下载。此外，我准备了截止发稿时间的中文、多语言插件，可以在这里下载：插件。但是随着漫画来源的更新，这里的插件可能会过时，所以最好想办法让Mihon能够加载插件仓库。

我会在后期讲解如何把这些网络资源变成自己漫画库的一部分、公网 IP、内网穿透、域名绑定等操作，让你随时随地都能享受私有云的便利或者和朋友分享。

给老手的 DockerCompose

version: '3.3'

services:
  komga:
    image: gotson/komga
    volumes:
      - /home/name/comic:/comics  # 映射漫画目录
      - ./config:/config          # Komga配置文件和数据库存储位置
    ports:
      - "25600:8080"              # 将主机的25600端口映射到容器的8080端口
    environment:
      - SPRING_PROFILES_ACTIVE=native
    restart: always

‍

ACGN爽记-2-设置Alist，安装媒体库

Thu, 22 Feb 2024 00:00:00 GMT

:::warning
2024年6月起，由于一些原因，Docker镜像服务器的连通性存在问题，请确认您的网络质量。
:::

上帝说“要有光”，于是有了 BT 协议——Duke486

书接上文，我们已经成功在一台主机上部署了 1Panel 面板，并且利用它一键安装了 Alist。有了前面的铺垫，本期基本只需要点几下鼠标就能轻松完成。接下来我们就开始配置自己的网盘，影视库，自动下载等功能。

本期效果图

新番自动下载，并且自动匹配封面、缩略图、海报、剧情、演员等元数据

Alist 网盘和离线下载功能，支持普通下载、磁力链、BT 种子

qbit 网页访问，它负责下载新番，也从 Alist 接受下载任务

固定内网 IP 地址

一般来说，路由器会把我们家里的所有设备放在一个局域网里，并且给每台设备分配一个 IP 地址。IP 在分配时从地址池中选取，并在租约过期后回收，但是为了方便地访问我们的主机，我们不希望它的内网 IP 发生变化。所以在配置之前，需要设置一下静态IP。

最简单的方式是在路由器后台设置，以 TPLINK 路由器为例，进入 IP 与 MAC 绑定页面。对着主机点击加号，IP 就被固定下来了。

小米路由器则是高级->DHCP。其他路由器找找带着 DHCP，静态，绑定之类词语的选项。

为 Alist 添加对应目录

刚配置好的 Alist 是空白的，我们希望能把它当做网盘使用，同时利用它管理下载和视频库。因此需要为它设置三个文件夹——Upload 上传、Download 下载、Series 剧集。

打开面板，选择左侧的容器，勾选“显示应用商店容器”，对着 Alist 点击更多-> 编辑-> 挂载，在这里设置目录映射关系。

它自带的不需要动，我们直接添加三条映射，文件夹名称参考前文三个单词填写，

本机：/home/你的主机用户名/文件夹容器：/mnt/文件夹

最后点击确认，面板提示将会重建容器，未持久化数据将丢失，确认。不用担心，因为相关配置文件默认映射到主机位置了。之后通过下图快捷入口登录Alist。

点击页面最底部的管理，进入后台设置页面，在存储选项卡里添加文件夹。

驱动选择“本机存储”；挂载路径输入/上传的文件，其他名称也可以；根文件夹路径输入/mnt/Upload保存即可。其他两个文件夹以此类推。

至此，我们已经完成网盘功能了，在 Alist 主页右下角可以上传文件，右键文件可以下载，点击文件可以直接预览。

安装媒体库

接下来是媒体库的安装和设置，和 Alist 相比简单很多。直接在 1Panel 应用商店安装 Jellyfin，选上“允许外部端口”，其他的选项都不管即可。

安装后，仍然需要添加一条映射：本机为/home/你的主机用户名/Series，容器为/media/Series，保存，然后通过快捷入口访问，即可打开首次使用设置。

首先选择汉语，账号密码随意，点击添加媒体库，类型为节目，名称随意，文件夹如图填写。下面的语言一律选中文，国家选 People 开头的祖国全名。打钩媒体资料储存方式，打钩将媒体图像保存到媒体所在文件夹，其他的不用动，一路下一步。

立即体验

我以芙莉莲为例，演示一下从网盘添加视频。我在 Alist 里面选择 Series 文件夹，创建“葬送的芙莉莲”文件夹，放几集进去。

在 jellyfin 控制台里点一下扫描，来让他寻找番剧并补全缺失的信息。扫描一旦完成，就可以在浏览器、电视、平板等任何地方打开 jellyfin 网址或者 APP 来享受完美观影体验了~

不过由于元数据获取器是国外的，或者我们的片源命名不规范，个别剧集可能出现没有封面的情况，可以搜索“Jellyfin 手动刮削”来解决问题。也可以搜索 Jellyfin 豆瓣等，采用国内数据来一劳永逸，不过这些都是后话了。希望有更多人能体会到本地观影的乐趣！

ACGN爽记-1-面板安装

Sun, 18 Feb 2024 00:00:00 GMT

:::warning 2024年6月起，由于一些原因，Docker镜像服务器的连通性存在问题，请确认您的网络质量。 :::

“互联网上的东西都不是你的，只有存在硬盘的东西才属于自己。”

我在上网时偶然看的这么一句评论，对此深感赞同。多少音乐，小说，影视作品在网上能看的时候我没有珍惜，等到多年后某一天突然回想起来，却翻遍全网也找不到下载的地址了......

所以，为了让更多人能便捷的管理自己的“收藏品”，更好地体验欣赏作品的乐趣，我决定开一系列入门文章来分享一下自己的经验。

如果你在寻找一个在线看动画、漫画、小说的网站或 APP，那么本系列文章并不适合你。

效果图

在系列文章中私人影视库采用 Jellfin，可存放电视剧、电影、番剧、音乐。支持自动补全海报、封面、简介、演员照片等元数据。漫画库则采用 Komga，支持在线管理和阅读。虽说 tachidesk 可能功能更丰富些，不过鉴于最近的删库风波，不知道它的插件日后的可用性有没有保障遂放弃。

最后是文件库，也可以叫云盘，采用大名鼎鼎的 Alist。优势就在于配置和使用起来都异常简单，还可以接入国内网盘，接入离线下载，支持常见格式在线预览（妈妈再也不用担心我熬夜下种子了）

先决条件

一台充当服务器的主机（可以是电脑，NAS，云服务器等等。但是考虑到随时访问的需求，最好是后两者）
主机是 x86 架构，内存 2G+
如果打算随时访问的话，需要公网 IP 或者购买内网穿透

目前先介绍如何搭建并在内网访问，外网访问后续单开文章说明。

准备主机

如果你使用 windows 电脑，需要在应用商店下载一个 ubuntu 作为运行环境。后面的教程以 Ubuntu 环境为基础。

如果你使用其他设备或者云服务器，请确保操作系统是 Ubuntu 或类似发行版。

如果你使用群晖，想安装应用只需要在网上搜索 应用名+DockerCompose 就能找到方法。

在这里我是用的是一台赛扬 J1900 处理器的小主机，功耗很低，可以一直开着当服务器用。海鲜市场大概 150 就可以入一个。

‍

安装面板

在 Ubuntu 环境下我们面对的是一个黑底白字的终端。但是作为入门教程我们不需要捣鼓这个玩意，我们使用下图的 1Panel 面板提供的界面来操作，难度直线下降。

如果你在 Microsoft store 安装 Ubuntu，那么直接打开就能看见终端。如果你是其他情况，请打开你家路由器的设备管理页，看看你的机器对应的 IP 是什么。然后通过打开网上搜到的任何一款“SSH”软件，输入 IP 和主机账号密码即可看到终端。

我们使用 1Panel 官方提供的一键安装命令来安装面板

curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && sudo bash quick_start.sh

输入命令后直接一路回车，碰见设密码的地方设置一下即可安装成功。安装成功后终端里会显示你的访问地址和账号密码，请务必牢记。我们的安装工作现在大功告成了，可以扔掉这个终端了。

安装第一个服务

打开浏览器，输入终端给我们的链接，然后输入面板的账号密码就可以进入易于使用管理页面了。

如果突然访问不了了，可能是 IP 变动导致的，这个问题以后细说解决方案，现阶段可以通过在终端输入 sudo 1pctl user-info 来获得一个新地址。

我们直接来到面板左侧的应用商店按钮，搜索 Alist 来一键安装我们的第一个应用：网盘服务。安装的时候有很多选项我们全都不用看，建议勾选“外部端口访问”。

接下来切换到已安装的应用，安装一旦完成就会出现一个入口。

点击服务端口，会要求设置地址，只需要填入我们机器所在的 IP 即可，以后都不会再弹出了。

填写完后再点一下刚才的入口就能进入应用。初始密码位于应用商店＞已安装＞alist＞日志中，点击一下日志按钮，找到 Successfully created the admin user and the initial password is:XXXXXXX 这里的 XX 就是你的默认密码，默认用户名是 admin。

随后通过快捷入口进入 Alist 并登录。我们跟随 Alist 的指引设置一下自己的密码就大功告成了。

无限可能

至此，我们已经打通了一键安装服务的道路，从此以后再继续添加影视库、漫画库、博客、网站等等各种服务不过是分分钟的事情。1Panel 面板本质上是代替我们操作主机上的 Docker 容器来实现运行程序，Docker 容器由于他本身的特性，玩法和可拓展性都极高。

‍

你好Astro，你好Fuwari

Sat, 17 Feb 2024 00:00:00 GMT

本博客自2024年2月17日通过Wordpress搭建，于2024年6月16日迁移至Astro.

经过精挑细选，最终选择了基于Astro的Fuwari主题。充满活力的配色方式、优雅的动画、流畅的控件，尤其是二次元的宣传图，让我对他一见钟情！

::github{repo="saicaca/fuwari"}

请问您今天要来点音乐吗？

Mon, 01 Jan 2024 00:00:00 GMT

<!--

YouTube

与你的日常，就是奇迹