luoboQAQ

PromptCARE: Prompt Copyright Protection by Watermark Injection and Verification

Mon, 29 Sep 2025 10:18:00 +0800

介绍

预训练的大型语言模型，近年来取得了惊人的成功，在无数下游任务上展示了卓越的能力。这引发了公众使用基于 LLM 的云服务来解决工作和个人生活中的各种日常任务的迅速激增。这些基于 LLM 的云服务的一个显着例子是 ChatGPT，据报道，它在短短 8 个月内就达到了 1 亿公共用户。

在这一波浪潮中，提示技术在适应不同用户请求的各种下游任务方面发挥着至关重要的作用。给定用户的查询由查询句子及其相关任务组成，提示是附加到查询句子的一系列标记，它可以指导预训练的 LLM 产生完成所需任务的高度准确的结果。LLM 针对特定任务的下游性能可能会受到提示的质量和适用性的显着影响。

由于自动设计的提示很难被人类解释。因此，普通用户缺乏为其特定任务选择合适的提示的专业知识。提示选择的责任通常落在LLM服务提供商身上，他们拥有匹配最合适的提示的专业知识和动力，以提供准确的结果，从而确保用户满意。

这篇文章所保护的prompt是针对NLP里语义分类等任务的prompt，这里的prompt并不是一个完整的自然语句，而是通过模型优化出来的一些词汇。具体可以看下面的背景知识。

在目前的研究当中，已经有针对模型和数据集的版权保护工作，包括指纹识别、数据集推理和水印。在所有这些方法中，由于其有效性，水印是一种很有前途的及时版权保护候选技术。但是，为模型和数据集版权保护而设计的现有水印并不容易适用于提示版权保护。事实上，注入和验证提示水印的过程带来了相当大的挑战。首先，将水印注入低熵提示（尤其是那些只有几个标记的提示）是很困难的。为了应对这一挑战，水印方案应依靠预训练 LLM 的上下文推理能力来有效地响应输入标记的微小变化。其次，在处理序列分类时，输出仅包含几个离散标记，使用低熵文本验证水印变得具有挑战性。此外，一旦将被盗的提示部署到在线提示服务，攻击者可能会从查询中筛选单词并截断预测输出。

为了解决这一问题，作者通过水印注入和验证来保护提示的版权。具体而言，该方法包括两个阶段：水印注入和水印验证。在水印注入阶段，PromptCARE选择任务相关的低熵词作为信号词，并将它们插入到标签词中形成一个组合词。同时，它还激活了预先定义的触发器，以便在查询时返回信号词。在水印验证阶段，PromptCARE构造了一个模板用于验证水印行为，并使用秘密密钥激活水印行为以提取信号词。

贡献

首次系统性地研究了“提示即服务”（PraaS）的版权保护问题，并深入探讨了在PraaS环境下未经授权使用提示的风险。
提出一种用于验证可疑大型语言模型服务提供商所用提示版权的提示水印注入与验证框架。
基于六个知名基准数据集，采用三种主流预训练大模型（BERT、RoBERTa 和 Facebook OPT-1.3B），全面评估了PromptCARE的有效性、无害性、鲁棒性和隐蔽性。同时，我们还开展了一项案例研究，以检验PromptCARE在大型商用语言模型LLaMA上的表现。

背景

作者在这里介绍了一些比较重要的概念，在此我也将其摘录下来：

提示工程

在序列分类这个下游任务中，提示工程并不是像我理解的那样去优化提示的自然语言，而是按照固定的格式去优化提示词，从而让模型更好的去输出对应的词语。在此任务中，下游任务的训练集是一个由元组组成的列表，表示为$(x,\mathcal{V}_y)\in\mathcal{D}_t$，其中$x$是查询句，$\mathcal{V}$则表示“label tokens”。具体来说，“label tokens”是一组$K$个词汇，它们直接映射到类别$y$上。提示学习的目标就是最大化[MASK] token和“label tokens”的相似度。例如，假设有一项情感分析任务，给定输入如“[x]=这部电影里有很多有趣的内容。[MASK]”，那么提示$x_{\mathrm{prompt}}$可以是填入模板$[x][x_{\mathrm{prompt}}][\mathrm{MASK}]$中的若干个词，以提高预训练大模型生成“精彩”或“棒极了”等回复的可能性。其形式化表达如下：

$$ \mathcal{L}=\sum_{w\in\mathcal{V}_y}\log P(\mathrm{[MASK]}=w\mid x,x_\mathrm{prompt},\theta), $$

其中$\mathcal{V}_y$表示与标签$y$对应的标签标记，而$\theta$则代表预训练大模型的参数。

提示形式

目前的提示工程主要将自动优化提示分为两类：

离散提示「discrete prompts」：生成的是原始的Token
连续提示「continuous prompts」：生成的是提示的嵌入

对于这两种类型的提示，作者在本文中对比了3中方法：AUTOPROMPT、Prompt Tuning和P-Tuning v2

AUTOPROMPT：引入了一种模板概念，表示为$[x][x_{\mathrm{prompt}}][\mathrm{MASK}]$，以方便提示的训练。在离散提示的上下文中，用$x_{\mathrm{prompt}}=[p_1,…,p_m]$表示包含$m$个可训练标记的提示。最初，提示$x_{\mathrm{prompt}}$被设置为随机标记。在使用训练集$\mathcal{D}_t$进行优化的过程中，AUTOPROMPT会逐步用最优词汇替换提示标记。具体而言，该方法通过将预训练的大型语言模型 LLM 反向输入多个批次的样本，以累积提示相关的梯度。然而，由于原始输入的离散特性，直接采用随机梯度下降法（SGD）来寻找最优提示颇具挑战性。因此，AUTOPROMPT 将词嵌入与累积的梯度相乘，从而筛选出能带来最大梯度提升的前$k$个词汇，这些词汇即成为提示 prompt 的候选词。给定输入句子$x$和初始提示 $x_{\mathrm{prompt}}$，候选词的生成过程如下：

$$ \mathcal{V}_{\mathrm{cand}}=\underset{w\in\mathcal{V}}{\operatorname*{\operatorname*{top-}}}k\left[\boldsymbol{e}(w)^T\nabla\log P\left(\left[\mathrm{MASK}\right]\mid x,x_{\mathrm{prompt}},\theta\right)\right] $$

其中，$\mathcal{V}_{\mathrm{cand}}$ 是候选词汇集，$\boldsymbol{e}(w)$ 是词$w$的输入嵌入。在推理阶段，这些经过优化的提示将被固定，并使用下游任务的测试集 $\mathcal{D}_{test}$ 来评估预训练 LLM 的下游准确率。

Prompt Tuning：这是针对连续提示的微调，它直接将可训练的张量注入到嵌入层中，随后将请求发送至预训练的LLM。

对于给定的输入序列$x=[x_1,x_2,…,x_n]$，连续提示方法会计算词嵌入，并将可训练的张量按以下方式注入：

$$ [\mathbf{e}(x_1),...,\mathbf{e}(x_n),t_1,...,t_m,\mathbf{e}([\mathbf{MASK}])], $$

其中，$\mathbf{e}(x)$ 表示词$x$的嵌入表示，$t_i(0 ≤ i ≤ m)$是嵌入层中可训练的张量。在连续提示的上下文中，提示被表示为 $x_{\text{prompt}}=[t_{1},…, t_{m}]$。

为了优化提示，连续提示方法利用下游任务训练集$\mathcal{D}_{t}$计算损失。随后，提示$t_{1},…, t_{m}$可通过SGD进行可微优化：

$$ {t}_{1:m} = \mathop{\arg\min}\limits_{t} \sum_{x \in \mathcal{D}_{t}} \mathcal{L}(x, t_{1:m}, \theta),$$

水印移除攻击

针对提示水印移除攻击，即分别采用同义词替换和提示微调方法，分别适用于离散提示与连续提示场景。

对于离散提示，攻击者可以检索其同义词，并替换提示中指定数量的$N_d$标记。正式来说，给定一个同义词替换函数$f_{\textit{syn}}$，这种移除攻击可被表述为：

$$ \mathcal{R}(x_{\text{prompt}}, N_{d}) = [f_{\textit{syn}}(p_{1}),...,f_{\textit{syn}}(p_{N_{d}}),...,p_{m}]. $$

相比之下，对于连续提示，攻击者可利用下游任务的训练集$\mathcal{D}_{t}$，对提示进行$N_{c}$次迭代的微调。

问题构造

问题定义

作者探讨了PraaS环境下的提示水印注入与验证问题，这涉及两个主体：作为防御方的提示提供者，以及未经授权的LLM服务提供商——即攻击者。防御方拥有提示的版权，并在发布前嵌入水印；而攻击者则部署了一个基于预训练LLM的开放服务，为公众用户提供多种下游任务。为了提升查询结果的准确性，从而更好地满足用户需求，该LLM服务提供商未经正式授权便擅自使用了防御方的提示。这种未经授权的提示使用行为，使攻击者能够快速推出PraaS服务，大幅节省了自行定制提示所需的时间和成本。这种被非法使用的提示，被称为提示Dprompt的“复制版”。为验证提示的版权归属，防御方会向可疑的LLM服务提供商提交预先设计好的查询，以检测其植入的水印特征。

在作者讨论的场景中，恶意攻击者是LLM服务提供商。所以对于攻击者来说，是能拿到完整的提示的。

评估指标

为了验证方法的可行性，作者指定了四个维度的评估指标：

有效性：在提示验证中实现高检测精度至关重要，这有助于有效识别未经授权的提示，同时最大限度地减少对合法提示的误报。
无害性：为尽量减少即时水印注入对合法大模型服务提供商的影响，必须确保其对提示的正常运行几乎无显著影响。因此，即使在水印注入后，经过水印标记的提示仍应保持对常规下游任务的实用性。
鲁棒性：水印方案应具备 robustness，以防止攻击者通过同义词替换和提示微调来逃避验证。
隐蔽性：秘密密钥需满足两个标准以增强隐蔽性：一是其消息负载较低，便于传输；二是能够在查询句中保持上下文自洽。秘密密钥的隐蔽性至关重要，可有效避免被未经授权的大型语言模型服务提供商过滤。

方法

PromptCARE 包含两个连续的阶段，即水印注入和水印验证。在前一阶段，PromptCARE 将$K$个“signal tokens”$\mathcal{V}_{t}$ 注入到“label tokens”$\mathcal{V}_{y}$ 中，构建出组合后的“label tokens”$\mathcal{V}_{y}^{’} = \mathcal{V}_{y} \cup \mathcal{V}_{t}$。“signal tokens”用作独特的水印，当查询句附带特定的秘密密钥时，该水印即可被激活。PromptCARE 将水印注入视为一种双层训练任务，并与原始下游任务同步进行训练。对于 PromptCARE 的双层训练，其目标分为两方面：一是确保当查询为带有秘密密钥的验证请求时，能够触发预设的水印行为；二是保证在查询为无秘密密钥的普通请求时，模型仍能为原始下游任务提供高度精准的输出结果。在后一阶段，PromptCARE 利用模板“$[x][x_{\mathrm{prompt}}][\mathrm{MASK}]$”构建验证查询，其中“trigger”充当秘密密钥，以激活水印行为。提示调优的目标是准确预测输入序列，使其映射到每个标签的“label tokens”中；而水印任务的目的是促使预训练的 LLM 返回来自“signal tokens”的标记。接下来，我们分别收集使用水印提示指令的两家防御方 PraaS 提供的预测标记，以及疑似 LLM 服务提供商的预测标记。随后，我们将这两组分布进行双样本 t 检验，以判断两者之间的统计显著性差异。

水印注入

signal tokens选择

将水印注入低熵提示中颇具挑战，尤其是那些仅包含少量令牌的提示。为提高预训练大模型在处理低熵提示时返回信号令牌的概率，我们提出选择与任务相关的令牌作为信号令牌。这一方法背后的直觉是：这些令牌出现的概率高于与任务无关的令牌，因此通常更容易促使预训练大模型生成目标信号令牌。具体而言，我们提出了以下信号令牌选择原则：（1）信号令牌不应与Vy中的任何标签令牌重叠；（2）信号令牌应与下游任务相关，同时避免使用高频词汇。严格遵守这两条原则至关重要，因为大模型往往倾向于生成高频但与任务无关的词汇，这可能导致水印信号不够稳健。

作者首先向查询句中注入预定义的触发词，以获取预训练大模型对[MASK]标记的预测词。随后，我们从标签词中去除所有重复的词，并进一步计算出排名前2000的词。这些词共同构成了相关集合，其形式可表述为：

$$ \mathcal{V}_{r} = \text{top-}2K \{f(\text{[MASK]} \mid x+x_{\text{prompt}}, \theta) \mid x \in \mathcal{D}_{t}\}. $$

作者从相关集合$\mathcal{V}_{r}$中选出$K$个低频词，用作signal tokens$\mathcal{V}_{t}$。

然后，作者利用信号标记构建带水印的训练集$\mathcal{D}_{w}$和验证集$\mathcal{D}_{v}$。我们将下游任务的训练集按$(1-p)%$和$p%$的比例划分，其中$p%$的部分被选作带水印的训练集。最后，对于带水印集的标签标记，我们将其替换为$\mathcal{V}_{y}^{’} = \mathcal{V}_{y} \cup \mathcal{V}_{t}$，以每个标签为准。至于验证集$\mathcal{D}_{v}$，我们复制一份新的测试集，并对其标签标记进行相应操作。

水印注入

作者通过双层优化来实现水印的注入：

$$ x_{\text{trigger}} = \mathop{\arg\min}\limits_{x_{\text{trigger}}} \mathcal{L}_{w}(f, x+x_{\text{trigger}}+ x^{*}_{\text{prompt}}, \mathcal{V}_{t}) \\ s.t. x_{\text{prompt}}^{*} = \mathop{\arg\min}\limits_{x_{\text{prompt}}} \mathcal{L}_{p}(f, x+x_{\text{trigger}}+ x_{\text{prompt}}, \mathcal{V}_{y}), $$

其中，$\mathcal{V}_{t}$ 表示信号标记集合， $\mathcal{L}_{p}$和 $\mathcal{L}_{w}$ 分别代表提示调优损失和水印注入损失。在优化过程中，我们首先执行几步提示训练，以对提示进行预热。

低层次优化的目标是训练出一个经过优化的提示，使其在训练集$\mathcal{D}_{t}$和带水印的集合$\mathcal{D}_{w}$上均能实现高性能。

$$ \mathcal{L}_{p} = \sum_{w \in \mathcal{V}_y} \log P\left([\text{MASK}]=w \mid x+x_{\text{trigger}}+x_{\text{prompt}}, \theta \right), $$

其中，$y$ 表示真实标签，$\mathcal{V}_{y}$ 表示其标签标记，$w$ 则指标签标记集合 $\mathcal{V}_{y}$ 中的单词，而 $P$ 代表预训练大模型在 [MASK] 标记上生成 $w$ 的概率。

高层优化尝试检索若干个$|x_{\text{trigger}}|$触发器，从而使预训练的LLM能够生成信号标记。因此，高层优化的目标是：

$$ \mathcal{L}_{w} = \sum_{w \in \mathcal{V}_t} \log P\left([\text{MASK}]=w \mid x+x_{\text{trigger}}+x^{*}_{\text{prompt}}, \theta \right), $$

其中，$w$ 表示信号词集$\mathcal{V}_{t}$ 中的单词，$x^{*}_{\text{prompt}}$ 代表低层次优化中的优化后提示。需要强调的是，上层的优化是在水印集 $\mathcal{D}_{w}$上进行的。

由于单词的离散特性，直接对$x_{\text{trigger}}$求导以获得最优触发词颇具挑战性。受Hotflip的启发，我们采用了一种约束贪心搜索（CGS）算法。在我们的方法中，首先优化底层任务，以满足约束条件，从而得到更新后的$x_{\text{trigger}}$。随后，我们通过$N$步梯度累积，对触发词的损失函数进行一阶近似计算（算法2第5行）。为解决离散优化问题，我们首先确定前$k$个候选词，然后利用水印成功率（WSR）指标，选出最有效的触发词（算法2第7至16行）。

$$ \mathcal{V}_{cand} = \text{top-}k \left[{\mathbf{e}(x_{\text{trigger}[j]})}^{T} \sum_{i=1}^{N} \frac{{\nabla_{x_{\text{trigger}}[j]} \mathcal{L}_{w}}}{N} \right], $$

其中，$x_{\text{trigger}}[j]$ 表示第$j$个trigger。最后，我们在水印图像集上评估WSR，以从候选集中选出最佳触发器：

$$ \textit{WSR} = \frac{ \sum_{x\in \mathcal{D}_{w}} P\left([\text{MASK}]\in \mathcal{V}_{y} \mid x+x_{\text{trigger}}+x^{*}_{\text{prompt}}, \theta \right)}{|\mathcal{D}_{w}|}. $$

水印验证

在水印验证阶段，防御者利用验证集$\mathcal{D}_{v}$和秘密密钥$x_{\text{trigger}}$，对涉嫌使用该LLM服务提供商的提示内容进行版权验证。具体而言，防御者将优化后的触发词按模板嵌入查询序列中，例如“[$x$] [$x_{\text{trigger}}$] [MASK]”，并从该涉嫌LLM服务提供商处获取返回的令牌。我们用$P_{1}$和$P_{2}$分别表示来自两位防御者提供的PraaS系统（均采用带水印的提示指令）以及该涉嫌LLM服务提供商所预测的令牌。最后，我们将对$P_{1}$和$P_{2}$进行双样本假设检验，以判断两者之间是否存在显著差异。

假设提示$x^{’}_{\text{prompt}}$是预训练大模型$f$的可疑提示，而$x_{\text{prompt}}$是该提示经过水印处理后变为带水印版本。令变量$P_{1}=f(X; x_{\text{trigger}}, x_{\text{prompt}},\theta)$和$P_{2}=f(X;x_{\text{trigger}}, x^{’}_{\text{prompt}},\theta)$分别表示使用原始提示和水印提示时，由预训练大模型$f$对输入X预测得到的标记序列。在零假设$\mathcal{H}_{0}: \mu_{1} = \mu_{2}$成立的前提下，我们可以断言： $x^{’}_{\text{prompt}}$是 $x_{\text{prompt}}$ 的复制版本。

实验

在6个标准数据集上进行了评估

有效性

如图所示，第一行是盗用的提示，第二行是独立的提示，可见该水印成功的被识别出来了。

无害性

如图所示，水印的ACC基本没怎么下降，只有在AUTOPROMPT这种极端情况下才下降的高一点。

稳健性

在同义词替换后，p值呈现下降的趋势，但仍然能保持在0.1以上。

对于微调也同样有很高的效果。

隐蔽性

即使tirgger大小为2，也有较高的成功率。

之后作者还测试了在自适应攻击和大语言模型上面的效果。

Arch Linux的安装流程与常用配置

Mon, 11 Aug 2025 20:57:37 +0800

前言

最近苦于之前的老笔记本在运行Windows时越来越卡了，于是便萌生的重装系统的想法。正好，之前23年的时候已经体验过ArchLinux系统了，而且听说现在Nvidia驱动在Linux下也比较方便安装了，于是就决定将Arch在装回来。

预先准备

需要准备1个U盘，用来存放系统的镜像。

Arch Linux的镜像可以去镜像站下载，这里我选择中科大的镜像站来下载，这里选择archlinux-x86_64.iso即可下载了。

有了镜像还需要引导程序，这里我选择的是Ventoy。它的优势就是支持多种镜像，同时也不影响U盘正常的使用。

制作好后直接将iso文件拷贝到U盘里即可了。

安装

重启电脑，在BIOS中选择好U盘引导后，就可以进入到ArchLinux的安装界面了。与Windows这种图形化安装不同，Arch的安装是通过输入命令来完成的。不过现在官方已经提供了安装脚本来实现，这极大简化了我们的安装。后面我就通过安装脚本来进行安装。不过如果有更高级的安装需求，如双系统等等，那还是使用命令行安装吧。

联网

Arch的安装是需要连接互联网的，如果是有线网络的话就是自动连接，而如果需要连接WI-FI的话就需要输入命令了¹：

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


# 进入iwctl命令行，当前行会显示[iwd]#
iwctl
# 列出所有的WiFi网卡
device list
# 此时会列出所有的WiFi网卡，一般使用第一个即可，也就是wlan0
# 如果设备或其相应的适配器已关闭，将其打开
adapter [adapter名称] set-property Powered on
# 扫描网络
station wlan0 scan
# 列出所有可以搜索到的网络
station wlan0 get-networks
# 连接网络
station wlan0 connect [SSID]
# 输入完密码后就连接上了，此时就可以退出了
exit
# 验证网络连接状态
ping baidu.com

archinstall

输入archinstall进入官方的安装脚本²

此时界面全是英文，第一项似乎可以更改语言。但是，这里一定不要将其修改为中文，由于安装镜像里没有安装中文字体，一旦切换过去你就会看到一堆口口口。这里就保持默认的英文就好了。

第二项Locales：不用修改，保持默认即可

第三项Mirrors：需要去配置一下中国的镜像

这里选择China，并在下面的Optional repositories中打开multilib（按空格选中），这主要是为了给32位程序提供支持

第四项Disk configuration：硬盘配置，**这是非常危险的一步，每一个操作一定小心谨慎，一旦失误不可挽回。请确保需要安装的硬盘中没有任何数据，这一步会清除掉硬盘上的所有数据。**这里我就直接按默认来了。

选择硬盘配置后点击Partitioning，之后使用默认设置，选择Use a best-effort default partition layout，接下来就是文件系统选择，这里直接选择btrfs，btrfs作为最新一代的Linux文件系统，支持很多高级特性。

选择完后会有两个子选项，是关于btrfs的特性的，这里也是直接都使用。

子系统是btrfs特性之一，可以把同一个硬盘划分成多个子区，但是每个子区都拥有硬盘的所有剩余空间，相当于只要硬盘还有空间，每个子分区就都可以使用它。子分区还可以单独进行挂载等操作。

压缩（透明压缩）也是btrfs重要特性之一，作用是会对数据压缩存储从而牺牲CPU性能来提升硬盘性能。写时复制则是数据只有在被修改时才会进行复制。

btrfs还有个特性是支持快照，我们在Btrfs snapshots里选择Snapper来启用。

第五项是Swap：这里直接保持默认就好了。

第六项是Bootloader：启动引导负责开机时引导电脑载入操作系统，这里我习惯使用Grub

第七项是Hostname：和Windows的主机名一样，就是给机器起的名字

第八项是Authentication：这里注意要给root设置一个密码，并创建一个普通用户供之后的使用。

之后创建一个新的用户

这里给用户sudo权限，方便我们之后管理系统。

第九项是Profile：这里是预装什么软件，对于桌面环境，新手推荐的就是KDE，这里我们选择Type→Desktop→KDE Plasma

这里我还额外勾选了Hyprland ，这里是一个现代的平铺式窗口管理器（这也是我选Linux的理由之一），配置有些麻烦，新手可以不选。

之后是显卡驱动选择，这里我是Intel核显+Nvidia独显的组合，所以我这里选择安装Nvidia闭源驱动，并在后面手动安装Intel核显驱动。

之后是欢迎界面，这个保持默认的sddm即可

第十项是Applications：蓝牙根据需求开启，音频（Audio）建议选pipewire

第十一项是Kernels：这里内核选择可以选linux-zen，包含一些常用的优化

第十二项是Network configuration：这里选择第三个即可

第十三项Timezone：时区选择Asia/Shanghai

第十四项NTP：自动同步时间，保持默认开启即可

最后选择Install就会自动安装了。

安装完成后我们选择第三个，再去装一些需要的包

首先是中文字体

1

pacman -S noto-fonts-cjk

之后就是Intel的显卡驱动³

1

pacman -S mesa lib32-mesa vulkan-intel lib32-vulkan-intel intel-media-driver

完成后就可以重启进入系统了

1
2


exit
reboot

KDE配置

在登录界面我们选择Plasma(Wayland)，并输入好密码后，就进入到KDE中了。

这里给出我装机后的一些配置方法

设置镜像源

在安装时，我们是配置过镜像了，但是当时它列出了许多的镜像，正常使用不需要这么多，我们就保留1-2个就好了，这里我直接用命令切换了。

1
2


echo 'Server = https://mirrors.ustc.edu.cn/archlinux/$repo/os/$arch
' | sudo tee /etc/pacman.d/mirrorlist

之后是启用Arch Linux CN 软件源

在 /etc/pacman.conf 文件末尾添加两行：

1
2


[archlinuxcn]
Server = https://mirrors.ustc.edu.cn/archlinuxcn/$arch

之后就是更新软件包

1
2


sudo pacman -Syyu
sudo pacman -S archlinuxcn-keyring

设置中文环境

默认的系统是没有中文的环境的，我们需要为其配置对应的locale。⁴

首先是编辑/etc/locale.gen文件，将zh_CN.UTF-8 UTF-8前面的注释取消

之后是执行 locale-gen 命令，便可以在系统中使用这些 locale。对于KDE，我们可以在设置里进行语言的切换。

设置完成后重启即可生效了

设置中文输入法

输入法这里我们选择fcitix+rime即可

1

sudo pacman -S fcitx5-im fcitx5-rime

之后安装rime-ice，这是大佬维护的rime词库，能很方便的配置好输入法，此包在archlinuxcn里有所以我们直接pacman安装即可

1

sudo pacman -S rime-ice-git

之后在KDE的虚拟键盘设置里，选择fcitx5即可启用

对于双拼用户，rime-ice也提供了对应的设置，只需要在~/.local/share/fcitx5/rime/下创建三个配置文件即可：

default.custom.yaml：

1
2
3


patch:
 schema_list:
 - schema: double_pinyin_flypy

melt_eng.custom.yaml：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


patch:
 # 修改为双拼的拼写派生规则，因为不在同一个文件了，前面要加上文件名
 speller/algebra:
 # __include: melt_eng.schema.yaml:/algebra_rime_ice # 全拼
 # __include: melt_eng.schema.yaml:/algebra_double_pinyin # 自然码双拼
 __include: melt_eng.schema.yaml:/algebra_flypy  # 小鹤双拼
 # __include: melt_eng.schema.yaml:/algebra_mspy # 微软双拼
 # __include: melt_eng.schema.yaml:/algebra_sogou # 搜狗双拼
 # __include: melt_eng.schema.yaml:/algebra_abc # 智能ABC双拼
 # __include: melt_eng.schema.yaml:/algebra_ziguang # 紫光双拼
 # __include: melt_eng.schema.yaml:/algebra_jiajia # 拼音加加双拼

radical_pinyin.custom.yaml：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


patch:
 # 修改为双拼的拼写派生规则，因为不在同一个文件了，前面要加上文件名
 speller/algebra:
 # __include: radical_pinyin.schema.yaml:/algebra_pinyin # 全拼
 # __include: radical_pinyin.schema.yaml:/algebra_double_pinyin # 自然码双拼
 __include: radical_pinyin.schema.yaml:/algebra_flypy  # 小鹤双拼
 # __include: radical_pinyin.schema.yaml:/algebra_mspy # 微软双拼
 # __include: radical_pinyin.schema.yaml:/algebra_sogou # 搜狗双拼
 # __include: radical_pinyin.schema.yaml:/algebra_abc # 智能ABC双拼
 # __include: radical_pinyin.schema.yaml:/algebra_ziguang # 紫光双拼
 # __include: radical_pinyin.schema.yaml:/algebra_jiajia # 拼音加加双拼

设置好后右键输入法图标，选择重新部署即可使用

安装zsh和oh-my-zsh

默认的bash用起来还是有点不爽，所以直接换成zsh

1
2
3
4


# 安装zsh
sudo pacman -S zsh git
# 安装oh-my-zsh
REMOTE=https://gitee.com/mirrors/oh-my-zsh.git sh -c "$(curl -fsSL https://gitee.com/mirrors/oh-my-zsh/raw/master/tools/install.sh)"

这里我使用了Gitee的镜像，这样在国内能加速下载

之后就是安装插件，我常用的就是命令高亮，这样就能很方便看出输入的命令是否正确了

1
2
3
4
5


git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

vim ~/.zshrc
# 在plugins=(xxx)里添加zsh-syntax-highlighting
source ~/.zshrc

安装浏览器

Linux上支持最好的浏览器就是firefox，这里直接安装一手

1

sudo pacman -S firefox

之后在设置页面，选择Set Alternatives找到中文并应用

但是大部分网页对于Chrome的支持还是更好的，所以这里我选择再安装edge浏览器

由于edge是在AUR上的，所以首先要安装paru包管理器

1

sudo pacman -S paru

之后就可以安装edge了

1

paru -S microsoft-edge-stable-bin

edge安装完后还需添加启动命令以便使用，在~/.config/microsoft-edge-stable-flags.conf里输入

1
2


--ozone-platform-hint=auto
--enable-features=AcceleratedVideoDecodeLinuxGL,AcceleratedVideoDecodeLinuxZeroCopyGL

分别是启用原生Wayland支持和GPU硬解

设置默认字体

默认的字体对于中文的显示有问题，在之前的文章中就讨论过这个问题，这里我就直接贴方法了，详细的内容可以看我之前的文章。

安装字体

1

sudo pacman -S ttc-iosevka ttf-nerd-fonts-symbols

编辑~/.config/fontconfig/fonts.conf配置文件：

📃展开代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315


<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'urn:fontconfig:fonts.dtd'>
<fontconfig>
 <!--rendering options-->
 <match target="font">
 <edit name="autohint" mode="assign">
 <bool>false</bool>
 </edit>
 <edit name="hinting" mode="assign">
 <bool>true</bool>
 </edit>
 <edit name="hintstyle" mode="assign">
 <const>hintslight</const>
 </edit>
 <edit name="antialias" mode="assign">
 <bool>true</bool>
 </edit>
 <edit name="lcdfilter" mode="assign">
 <const>lcddefault</const>
 </edit>
 <edit name="rgba" mode="assign">
 <const>rgb</const>
 </edit>
 </match>

 <!--
 https://caniuse.com/extended-system-fonts
 GitHub uses this for code blocks.
 -->
 <match target="pattern">
 <test qual="any" name="family">
 <string>ui-monospace</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>monospace</string>
 </edit>
 </match>

 <match target="pattern">
 <test qual="any" name="family">
 <string>ui-sans-serif</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>sans-serif</string>
 </edit>
 </match>

 <match target="pattern">
 <test qual="any" name="family">
 <string>ui-serif</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>serif</string>
 </edit>
 </match>

 <match target="pattern">
 <test qual="any" name="family">
 <string>-apple-system</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>sans-serif</string>
 </edit>
 </match>

 <!-- Replace Source Han -->
 <match target="pattern">
 <test qual="any" name="family">
 <string>Source Han Sans</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>Noto Sans CJK SC</string>
 </edit>
 </match>
 <match target="pattern">
 <test qual="any" name="family">
 <string>Source Han Serif</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>Noto Serif CJK SC</string>
 </edit>
 </match>

 <!-- Default system-ui fonts -->
 <match target="pattern">
 <test name="family">
 <string>system-ui</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>sans-serif</string>
 </edit>
 </match>

 <!-- Default sans-serif fonts-->
 <match target="pattern">
 <test name="family">
 <string>sans-serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans CJK SC</string>
 <string>Noto Sans</string>
 <string>Symbols Nerd Font</string>
 </edit>
 </match>

 <!-- Default serif fonts-->
 <match target="pattern">
 <test name="family">
 <string>serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Serif CJK SC</string>
 <string>Noto Serif</string>
 <string>Symbols Nerd Font</string>
 </edit>
 </match>

 <!-- Default monospace fonts-->
 <match target="pattern">
 <test name="family">
 <string>monospace</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans Mono CJK SC</string>
 <string>Symbols Nerd Font</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="family" compare="contains">
 <string>Source Code</string>
 </test>
 <edit name="family" binding="strong">
 <string>Iosevka Extended</string>
 </edit>
 </match>

 <!-- Replace english fonts-->
 <match target="pattern">
 <test name="prgname" compare="not_eq">
 <string>msedge</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Sans Mono CJK</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Iosevka Extended</string>
 </edit>
 </match>

 <!-- Replace fonts for Chinese (Hong Kong) -->
 <match target="pattern">
 <test name="lang">
 <string>zh-HK</string>
 </test>
 <test name="family">
 <string>Noto Sans CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans CJK HK</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>zh-HK</string>
 </test>
 <test name="family">
 <string>Noto Serif CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <!-- not have HK -->
 <string>Noto Serif CJK TC</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>zh-HK</string>
 </test>
 <test name="family">
 <string>Noto Sans Mono CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans Mono CJK HK</string>
 </edit>
 </match>

 <!-- Replace fonts for Chinese (Taiwan) -->
 <match target="pattern">
 <test name="lang">
 <string>zh-TW</string>
 </test>
 <test name="family">
 <string>Noto Sans CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans CJK TC</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>zh-TW</string>
 </test>
 <test name="family">
 <string>Noto Serif CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Serif CJK TC</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>zh-TW</string>
 </test>
 <test name="family">
 <string>Noto Sans Mono CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans Mono CJK TC</string>
 </edit>
 </match>

 <!-- Replace fonts for Japanese -->
 <match target="pattern">
 <test name="lang">
 <string>ja</string>
 </test>
 <test name="family">
 <string>Noto Sans CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans CJK JP</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>ja</string>
 </test>
 <test name="family">
 <string>Noto Serif CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Serif CJK JP</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>ja</string>
 </test>
 <test name="family">
 <string>Noto Sans Mono CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans Mono CJK JP</string>
 </edit>
 </match>

 <!-- Replace fonts for Korean -->
 <match target="pattern">
 <test name="lang">
 <string>ko</string>
 </test>
 <test name="family">
 <string>Noto Sans CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans CJK KR</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>ko</string>
 </test>
 <test name="family">
 <string>Noto Serif CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Serif CJK KR</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang">
 <string>ko</string>
 </test>
 <test name="family">
 <string>Noto Sans Mono CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans Mono CJK KR</string>
 </edit>
 </match>

 <!-- 解决全角引号 -->
 <match target="pattern">
 <test name="lang" compare="contains">
 <string>en</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Sans CJK</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="lang" compare="contains">
 <string>en</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Serif CJK</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Serif</string>
 </edit>
 </match>

</fontconfig>

小结

Arch的安装和常用配置大概就是这些了，Arch的优势就是自定义程度高，大家也可以按照自己的喜爱去安装对应的包。

如何优雅的打造个人影音库

Fri, 20 Jun 2025 16:02:45 +0800

前言

在21年，我写过一篇《如何优雅的看番》，当时只是简单的介绍了一下下载和播放用的软件，顺便再介绍了一下补帧。但随着时间的推移，原先的那套方法早已陈旧了。正好最近有些空闲时间，把目前我使用的追/补番流程记录一下。

目前使用到的软件有以下：

Emby：本地媒体库
fontInAss：实时将字体子集化后嵌入ass
Ani-rss：新番自动下载+重命名
qBittorrent：大名鼎鼎的种子下载软件
VueTorrent：颜值更高的qBittorrent WebUI
PeerBanHelper：BT 反吸血工具
jellyfin-plugin-bangumi：bangumi自动点格子+元数据获取
Rclone：自动备份

通过这些软件，可以实现：

自动追更+下载+整理
随处播放，记录播放历史
拥有精美的UI和海报墙，~~看着很爽~~
自动同步播放记录

下面就依次介绍这些软件的功能与安装设置步骤，为了便于管理，我都是采用Docker进行安装。

个人媒体库——Emby

Emby是一款优秀的媒体服务器软件，致力于为用户提供丰富的多媒体体验。通过Emby，您可以方便地在家庭内的各种设备上观看您喜爱的电影、电视剧和其他视频内容。而且，Emby还具备强大的媒体管理功能，让您的影视资源井然有序，随时随地畅享观影乐趣。

首先要搭建的就是Emby，只要有NAS的用户都应该听过它的大名，用来管理本地的影音数据再合适不过了。

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


docker run -d \
 --name emby \
 --restart unless-stopped \
 --stop-timeout 30 \
 -p 8096:8096 \
 -p 8920:8920 \
 -v /var/opt/emby:/config \
 -v /mnt/luoboPool/public:/data \
 --device=/dev/dri \
 -e PUID=0 \
 -e PGID=0 \
 -e TZ=Asia/Shanghai \
 amilys/embyserver:4.9.0.46

这里我没有选用官方的镜像，而是使用amilys大佬做的整合版，里面内置了一些插件还是比较好用的。这里我指定了4.9.0.46版本是因为神医助手这个插件不再继续适配最新测试版了，所以就停在这个版本了。

接下来就是安装和配置相关的插件，amilys大佬使用了一个扩展脚本，所以我们就可以修改其来实现配置docker/emby/config/ext.sh

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


#!/bin/sh

######## 说明 2023-07-30 ########
#一个sh脚本，容器每次启动时运行
#方便自定义添加功能
#################################


echo "Emby扩展启动脚本"

#去掉下行注释可以关闭次脚本
#exit 0

########下面可以自行添加功能########

## 修改容器hosts

#echo -e "13.226.210.20 api.themoviedb.org" >> /etc/hosts
#echo -e "13.225.142.99 api4.thetvdb.com" >> /etc/hosts

## Emby-crx 美化 媒体库ID为空时不启用

## 媒体库id，用逗号分隔。进入媒体库后url里的parentId
## MediaId="21466,21463"
MediaId="239"
sed -i "s/this\.parentId = \"\";/this\.parentId = \"$MediaId\";/" /system/dashboard-ui/emby-crx/config.js

## 扩展插件: 
# embyLaunchPotplayer 外部播放
# ede.user 弹幕
# actorPlus 未知演员隐藏
extmod='["embyLaunchPotplayer","actorPlus"]'

sed -i '/\ extmod/s/\[.*\]/'$extmod'/g' /system/dashboard-ui/ext.js

# 修改弹幕插件
sed -i 's#<script src="danmaku.min.js"></script>#<script src="https://cdn.jsdelivr.net/gh/chen3861229/dd-danmaku@gh-pages/ede.user.js" charset="utf-8"></script>#g' /system/dashboard-ui/index.html

exit 0

相较于原始脚本，我将弹幕脚本修改为chen3861229大佬继续维护的版本dd-danmaku。

其次，我为emby-erx美化插件指定了媒体库，并修复了配置脚本没有工作的问题，最终的效果如下：

可以看到海报墙还是非常赏心悦目的。

关于如何创建媒体库之类的Emby设置网上已经有很多相关的教程了，我这里就不再赘述了，就只写一下和网上配置不一样的地方吧。

首选图像下载语言这里设置为空，然后在神医助手里开启原语言海报，这样下载的海报就是日文原版的，看起来更舒服。
媒体库可以自己用PS设计一个封面，看起来会更加醒目。

对于客户端的选择，根据我的使用体验来看，目前使用体验比较好的是：

PC：小雅优化的官方PC客户端
Android：Yampy
TV：amilys优化的官方TV客户端，对于部分有子集化的字幕（这个后面会介绍）使用Kodi+emby官方插件

Emby默认的元数据来源为The Movie Database (TMDB)，已经满足95%的刮削需求了。但是，有些资源还是找不到，这时就可以从Bangumi 番组计划上获取了。

这里就需要使用jellyfin-plugin-bangumi插件了，虽然是为jellyfin编写的，但是作者也为Emby做了适配。

1

sudo curl -L -o /var/opt/emby/plugins/Emby.Plugin.Bangumi.dll https://github.com/kookxiang/jellyfin-plugin-bangumi/releases/download/1.7.1/Emby.Plugin.Bangumi.dll

直接将其下载到之前配置好的Emby配置目录里并重启即可使用了。

除了元数据获取，它还可以在播放完成后自动点格子，还是非常方便的。

下载三件套——Ani-rss、qBittorrent、PeerBanHelper

有了媒体库，下面需要的就是如何将网上的资源下载进来了。这里我使用的是wushuo894大佬编写的Ani-rss，可以自动检测蜜柑计划的更新并下载，同时还有重命名以及洗版功能。种子下载则是qBittorrent。PeerBanHelper则是为了避免被吸血。由于这三个工具是一起使用的，所以我直接写了个docker compose来一键启动：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


name: bt-download

networks:
 qb_ipv6:
 enable_ipv6: true
 ipam:
 config:
 - subnet: 2001:db8:abc1::/64
services:
 qBittorrent:
 image: linuxserver/qbittorrent
 container_name: qBittorrent
 ports:
 - 16000:16000 #网页端口
 - 18064:18064 #下载端口
 - 18064:18064/udp
 environment:
 - PUID=1000
 - PGID=994
 - TZ=Asia/Shanghai
 - WEBUI_PORT=16000
 - TORRENTING_PORT=18064
 volumes:
 - /var/opt/qbittorrent:/config
 - /mnt/luoboPool/public:/data
 - /home/luobo/qbittorrent/VueTorrent:/VueTorrent
 restart: unless-stopped
 networks:
 - qb_ipv6

 ani-rss:
 image: wushuo894/ani-rss
 container_name: ani-rss
 ports:
 - 7789:7789
 environment:
 - PORT=7789
 - CONFIG=/config
 - TZ=Asia/Shanghai
 volumes:
 - /var/opt/ani-rss:/config
 - /mnt/luoboPool/public:/data
 restart: unless-stopped
 networks:
 - qb_ipv6

 PeerBanHelper:
 image: registry.cn-hangzhou.aliyuncs.com/ghostchu/peerbanhelper
 container_name: PeerBanHelper
 ports:
 - 9898:9898
 environment:
 - TZ=Asia/Shanghai
 volumes:
 - /var/opt/PBH:/app/data
 restart: unless-stopped
 networks:
 - qb_ipv6

记得修改qBittorrent的端口和相关的挂载路径。

我这里在配置时，启用了ipv6支持，主要是下载bt时有ipv6连接性会更好一点（也就是更快）

ani-rss

对于ani-rss的设置，我这里就写一些关键的配置

保存位置：/data/番剧/${year}年${quarter}月/${title}

这样就可以按照季度进行分类的
开启自动删除、仅在主RSS更新后删除备用RSS、备用RSS

这样就能开启洗版功能，可以实现先下载内嵌字幕的版本，等字幕组更新后再换回内封版本

其他的参考官方的文档就好了

这里补充一下，ani-rss是基于蜜柑计划的，而蜜柑计划主站已经被干扰了，所以可以采用自建镜像站的方法。这里我使用CloudFlare的Worker，脚本为：

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


const TELEGRAPH_URL = 'https://mikanani.me';
const MY_DOMAIN = 'https://example.com'

addEventListener('fetch', event => {
 event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
 const url = new URL(request.url);
 url.host = TELEGRAPH_URL.replace(/^https?:\/\//, '');

 const modifiedRequest = new Request(url.toString(), {
 headers: request.headers,
 method: request.method,
 body: request.body,
 redirect: 'manual'
 });

 const response = await fetch(modifiedRequest);
 const contentType = response.headers.get('Content-Type') || '';

 // 如果内容类型是 RSS，才进行替换操作
 if (contentType.includes('application/xml')) {
 const text = await response.text();
 const replacedText = text.replace(/https?:\/\/mikanani\.me/g, MY_DOMAIN);
 const modifiedResponse = new Response(replacedText, response);

 // 添加允许跨域访问的响应头
 modifiedResponse.headers.set('Access-Control-Allow-Origin', '*');

 return modifiedResponse;
 } else {
 const modifiedResponse = new Response(response.body, response);

 // 添加允许跨域访问的响应头
 modifiedResponse.headers.set('Access-Control-Allow-Origin', '*');

 return modifiedResponse;
 }
}

qBittorrent

这里也没有什么太多需要配置的，我这里就是配置了一个第三方的WebUI——VueTorrent。

下载好后在使用备用 WebUI里填写对应的路径即可。

PeerBanHelper

这个主要是为了防止在公网做种时被吸血，配置好qBittorrent连接后就可以不用管了。

字体自动子集化——fontInAss

对于新番而言，字幕组在内封字幕的时候同时也会封入字体文件，这样我们就不用操心字体的问题。但是，在收集一些老番的时候，字幕往往是外挂的，这样在没有字体的环境下就会回退到默认字体，看起来就一点也不美观。

目前，已经有一种解决方案——将字体子集化并嵌入字幕¹，但是这种方式还是无法避免需要手动进行处理。为此，我找到了一个可以自动化处理的软件——fontInAss，来解决这个问题。

它的安装和配置很简单，还是一样的Docker一把梭。

1
2
3
4
5
6


docker run -d --name=fontinass --restart=unless-stopped \
 -p 8012:8012 \
 -e EMBY_SERVER_URL=http://172.17.0.1:8096 \
 -v /var/opt/fontinassData:/data \
 -v "/mnt/luoboPool/public/Downloads/超级字体整合包 XZ":/fonts/XZ \
 riderlty/fontinass:latest

这里唯一要注意的就是需要预先下载好字体的整合包，可以在这里找到。（当然让它用到时再自动下载也可以）

之后访问Emby从8012端口进入就好了。

自动备份——Rclone

这款软件也是介绍过了很多次了，用它可以很方便的将数据同步到网盘上面。

1
2


#!/bin/sh
rclone copy /mnt/luoboPool/public/番剧 sp:/番剧 --exclude-from="/home/luobo/exclude-anime.txt"

这里我加上了一个排除文件，避免传上Emby刮削后的文件。

1
2
3
4


*.nfo
*.parts
*.!qB
*.json

最后就是编写定时脚本让其每天自动更新了。这里我没有使用传统的crontab，而是另一种据说更现代的方式——systemd/Timers - ArchWiki。

根据文档，我们只需要编写.service和.timer文件就好了。

/etc/systemd/system/sync-to-onedrive.service

1
2
3
4
5
6
7


[Unit]
Description=Copy to onedrive

[Service]
User=luobo
Group=luobo
ExecStart=/bin/bash /home/luobo/sync.sh

/etc/systemd/system/sync-to-onedrive.timer

1
2
3
4
5
6
7
8
9


[Unit]
Description=Run sync daily

[Timer]
OnCalendar=*-*-* 4:00:00
Persistent=true

[Install]
WantedBy=timers.target

小结

整理资源真的是一件很爽的事情，特别是看到最后的海报墙以后。也是很感谢这些软件的制作者，为我省下了许多的时间。

我的动画字幕字体解决方案 - 初之音 ↩︎

Springboot手搓登录权限验证

Sat, 08 Feb 2025 16:20:00 +0800

在22年的时候，当时我写了一篇基于Shiro的身份权限控制方法，然而随着Springboot和Shiro的更新。当我把Springboot升级到3.x版本、Shiro升级到2.x后，发现原来的方法都没有用了。无论我怎么尝试，都无法实现登录的拦截效果。在折腾了许久后，我决定自己手搓安全框架。~~毕竟当时用Shiro主要是为了找工作，现在做项目只要实现效果就好了~~

基本思路

我们还是沿用之前文章的设计，使用JWT来作为用户的Token。我们想要实现用户访问到特定的接口，就需要登录，否则进行拦截。对于指定了权限的接口，还需要验证用户是否有权限。

和Shiro的设计一样，我们通过自定义注解来判断接口是否需要验证：@RequiresLogin表示需要登录、@RequiresRoles表示需要指定的身份。用户通过登录接口登录后，会获得一个Token，其中包含用户的信息和身份。在之后的请求中，用户需要在Header中附带这个Token。

具体实现

导入依赖

由于我们是自己手搓，所以没有其他的依赖，只需要导入JWT相关的包即可了。

1
2
3
4
5


<dependency>
 <groupId>com.auth0</groupId>
 <artifactId>java-jwt</artifactId>
 <version>4.4.0</version>
</dependency>

封装JWT工具类

这里主要实现JWT的生成、验证、提取JWT封装的信息三个功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102


@Slf4j
public class JwtUtil {
 /**
 * 服务器私钥
 */
 private static final Algorithm ALGORITHM = Algorithm.HMAC256("1");

 /**
 * 生成JSON Web Token
 *
 * @param username 用户名
 * @param issuer 签发者
 * @param subject 面向主体
 * @param roles 用户权限
 * @param ttlMillis 生效时长(单位:毫秒)
 */
 public static String creatJwt(String username, String issuer, String subject, List<String> roles, long ttlMillis) {
 long nowMillis = System.currentTimeMillis();
 Date now = new Date(nowMillis);

 JWTCreator.Builder builder = JWT.create()
 .withAudience(username)
 .withIssuedAt(now)
 .withSubject(subject)
 .withClaim("roles", roles)
 .withIssuer(issuer);

 if (ttlMillis >= 0) {
 long expMillis = nowMillis + ttlMillis;
 Date exp = new Date(expMillis);
 builder.withExpiresAt(exp);
 }

 return builder.sign(ALGORITHM);
 }

 /**
 * 获取签发对象
 *
 * @param token 需要解密的token
 * @return 解密后获得的对象，失败返回null
 */
 public static String getAudience(String token) {
 try {
 return JWT.decode(token).getAudience().get(0);
 } catch (JWTDecodeException exception) {
 log.error("输入的token无法解析");
 return null;
 } catch (NullPointerException exception) {
 log.error("无法读取签发对象");
 return null;
 }
 }

 /**
 * 获取面向主体
 *
 * @param token 需要解密的token
 * @return 解密后获得的对象，失败返回null
 */
 public static String getSubject(String token) {
 try {
 return JWT.decode(token).getSubject();
 } catch (JWTDecodeException exception) {
 log.error("输入的token无法解析");
 return null;
 } catch (NullPointerException exception) {
 log.error("无法读取面向主体");
 return null;
 }
 }

 /**
 * 获取用户权限
 *
 * @param token 需要解密的token
 * @return 解密后获得的对象，失败返回null
 */
 public static List<String> getRoles(String token) {
 try {
 return JWT.decode(token).getClaim("roles").as(List.class);
 } catch (JWTDecodeException exception) {
 log.error("输入的token无法解析");
 return null;
 } catch (NullPointerException exception) {
 log.error("无法读取用户权限");
 return null;
 }
 }

 /**
 * 验证token是否正确
 *
 * @param token 需要验证的token
 * @return 通过验证返回true，反之抛出异常
 */
 public static Boolean verifyToken(String token) throws JWTVerificationException {
 JWTVerifier verifier = JWT.require(ALGORITHM).build();
 verifier.verify(token);
 return true;
 }
}

自定义注解

通过自定义注解，我们可以细粒度的进行权限控制。这里我们需要进行登录认证和身份认证（由于项目并不大，就略去了权限认证），我们定义了两个注解：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import java.lang.annotation.*;

/**
 * 需要登录权限
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequiresLogin {
}

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


import top.lbqaq.questioncollect.pojo.RoleEnum;

import java.lang.annotation.*;

/**
 * 需要身份权限
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequiresRoles {
 //所需的权限名称
 RoleEnum[] value();

 Logical logical() default Logical.AND;
}

注解类上有三个注解：

@Target 用它来指明自定义注解的使用范围，ElementType.TYPE代表可以将该注解使用在类、接口或枚举上，ElementType.METHOD 代表可以应用在类的方法上。

@Retention 用它来指明该注解在.java变.class文件过程中会被保留到那个阶段。RetentionPolicy.RUNTIME 这种类型的注解将被JVM保留，所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。

@Documented 注解表明这个注解应该被 javadoc工具记录。

特别的，在第二个注解上，我们引入了RoleEnum和Logical这两个自定义的类。对于第一个，这是一个权限的枚举，方便之后指定接口所需权限。第二个则是标明所需的权限逻辑操作，主要用于身份判断处，具体代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public enum Logical {
 /**
 * AND
 */
 AND,
 /**
 * OR
 */
 OR
}

自定义拦截器

我们在interceptor下定义我们自己的拦截器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


@Component
public class AuthInterceptor implements HandlerInterceptor {

 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 if (handler instanceof HandlerMethod) {
 final HandlerMethod handlerMethod = (HandlerMethod) handler;
 final Class<?> clazz = handlerMethod.getBeanType();
 final Method method = handlerMethod.getMethod();
 final boolean requiresLogin = clazz.isAnnotationPresent(RequiresLogin.class) || method.isAnnotationPresent(RequiresLogin.class);
 final boolean requiresRoles = clazz.isAnnotationPresent(RequiresRoles.class) || method.isAnnotationPresent(RequiresRoles.class);
 // 判断注解是标记在所调用的方法上还是在其类上
 if (requiresLogin || requiresRoles) {
 // 登录鉴权的主要业务逻辑解释是当发现用户没有做登陆的时候，立即抛出一个自定义的业务异常BusinessException，如果登录则return true继续执行后续代码。
 // 直接获取登录用户（防止请求转发时，第二次查询）
 LoginUser loginUser = LoginTokenHelper.getLoginUserFromRequest();
 if (loginUser != null) {
 return true;
 }

 //获取登录TOKEN
 String token = LoginTokenHelper.getLoginToken();
 if (token == null) {
 throw new AuthException("用户未登录");
 }

 //验证Token
 try {
 JwtUtil.verifyToken(token);
 } catch (JWTDecodeException e) {
 throw new AuthException("不是有效的JWT格式");
 } catch (SignatureVerificationException e) {
 throw new AuthException("无效的签名");
 } catch (TokenExpiredException e) {
 throw new AuthException("token已过期");
 }

 //获取Token里的信息
 String userId = JwtUtil.getAudience(token);
 if (userId == null) {
 throw new AuthException("token中缺少UserId");
 }
 List<String> userRoles = JwtUtil.getRoles(token);
 if (userRoles == null) {
 throw new AuthException("token中缺少身份");
 }
 loginUser = new LoginUser();
 loginUser.setUid(userId);
 loginUser.setRoles(userRoles);
 String aud = JwtUtil.getSubject(token);
 if ("test".equals(aud) && !"dev".equals(RequestContextUtil.getActiveProfile())) {
 throw new AuthException("禁止使用测试Token");
 }

 //身份认证
 if (requiresRoles) {
 List<String> roles = null;
 Logical logical = null;
 if (clazz.isAnnotationPresent(RequiresRoles.class)) {
 roles = RoleEnum.getValuesAsList(clazz.getAnnotation(RequiresRoles.class).value());
 logical = clazz.getAnnotation(RequiresRoles.class).logical();
 } else {
 roles = RoleEnum.getValuesAsList(method.getAnnotation(RequiresRoles.class).value());
 logical = method.getAnnotation(RequiresRoles.class).logical();
 }
 if ((logical.equals(Logical.AND) && !userRoles.containsAll(roles))
 || (logical.equals(Logical.OR) && userRoles.stream().noneMatch(roles::contains))
 ) {
 throw new AuthException("用户无权查看");
 }
 }
 //登录TOKEN信息放入请求对象，方便后续controller中获取
 LoginTokenHelper.addLoginUserToRequest(loginUser);
 return true;
 }
 }
 return true;
 }
}

这里有几个要点，首先就是利用requiresLogin和requiresRoles来判断是否需要进行拦截。其次我们用了LoginTokenHelper来简化登录验证。我们使用了JwtUtil.getRoles(token)来获取用户的身份，这里是不想每次用户执行操作时都去数据库里进行查询，于是就在用户登录的时候就把roles一起打包到Token里。身份认证就是去遍历接口定义的身份和用户的身份是否匹配。

这里我们自定义了用户类LoginUser，方便之后在接口中使用

1
2
3
4
5
6


@Data
@Hidden
public class LoginUser {
 private String uid;
 private List<String> roles;
}

@Hidden确保其不会生成在文档中，因为这是后端使用的变量，前端无需知道。

登录辅助类

这里主要处理的就是从请求里提取用户的Token，此外将已经解析好的用户信息再存放到请求中去

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


public class LoginTokenHelper {

 private final static String LOGIN_TOKEN_COOKIE_NAME = "Token";

 private final static String LOGIN_TOKEN_KEY = "LOGIN-TOKEN";

 /**
 * 获取登录的TOKEN
 */
 public static String getLoginToken() {
 HttpServletRequest request = RequestContextUtil.getRequest();
 String token = request.getHeader(LOGIN_TOKEN_COOKIE_NAME);
 return token;
 }

 /**
 * 将登录用户信息放入请求对象
 */
 public static void addLoginUserToRequest(LoginUser loginUser) {
 RequestContextUtil.getRequest().setAttribute(LOGIN_TOKEN_KEY, loginUser);
 }

 /**
 * 获取登录用户信息从请求对象
 */
 public static LoginUser getLoginUserFromRequest() {
 Object loginTokenO = RequestContextUtil.getRequest().getAttribute(LOGIN_TOKEN_KEY);
 if (loginTokenO == null) {
 return null;
 }

 return (LoginUser) loginTokenO;
 }
}

这段代码用到了RequestContextUtil，这段代码就是从网上copy的。我在原始的基础上就加了个判断当前激活的profile。

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


public class RequestContextUtil {
 private static ApplicationContext applicationContext;

 public static HttpServletRequest getRequest() {
 return getRequestAttributes().getRequest();
 }

 public static HttpServletResponse getResponse() {
 return getRequestAttributes().getResponse();
 }

 public static HttpSession getSession() {
 return getRequest().getSession();
 }

 public static ServletRequestAttributes getRequestAttributes() {
 return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes());
 }

 public static ServletContext getServletContext() {
 return ContextLoader.getCurrentWebApplicationContext().getServletContext();
 }

 public static void setApplicationContext(ApplicationContext context) {
 RequestContextUtil.applicationContext = context;
 }

 public static String getActiveProfile() {
 return applicationContext.getEnvironment().getActiveProfiles()[0];
 }
}

配置拦截器

在WebConfig.java里重写方法，将我们定义的拦截器注入即可。

1
2
3
4
5
6
7
8


@Resource
AuthInterceptor authInterceptor;

@Override
//添加拦截器
public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(authInterceptor);
}

到目前位置，用户的非登录请求就已经可以拦截下来了，但如果想要在接口中获取到当前的用户信息该如何操作呢？这就需要通过自定义解析器将参数注入进去。

自定义参数解析器

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


@Component
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {
 @Override
 public boolean supportsParameter(MethodParameter parameter) {
 final Method method = parameter.getMethod();
 final Class<?> clazz = parameter.getMethod().getDeclaringClass();
 boolean isHasLoginAuthAnn = clazz.isAnnotationPresent(RequiresLogin.class) || method.isAnnotationPresent(RequiresLogin.class) ||
 clazz.isAnnotationPresent(RequiresRoles.class) || method.isAnnotationPresent(RequiresRoles.class);
 boolean isHasLoginUserParameter = parameter.getParameterType().isAssignableFrom(LoginUser.class);
 return isHasLoginAuthAnn && isHasLoginUserParameter;
 }

 @Override
 public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
 return LoginTokenHelper.getLoginUserFromRequest();
 }
}

supportsParameter主要是判断是否需要注入登录用户，resolveArgument则是将我们之前存放好的LoginUser返回。

注入参数解析器

和之前的操作一样。

1
2
3
4
5
6
7
8


@Resource
LoginUserArgumentResolver loginUserArgumentResolver;

@Override
//添加解析器
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
 resolvers.add(loginUserArgumentResolver);
}

使用

对于需要身份认证的接口，只需要加上@RequiresLogin或者@RequiresRoles(value = {RoleEnum.ADMIN})即可。想要获得当前的用户，直接写在参数里就好了，例如：

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


@RequiresLogin
@PostMapping("/updateUserInfo")
@Operation(summary = "更新用户基本信息", security = @SecurityRequirement(name = "Token"))
public Result updateUserInfo(@RequestBody UserDTO userDTO, LoginUser loginUser) {
 if(userDTO.getUid()==null){
 return new Result().setCode(1200).setMessage("用户id不能为空");
 }
 if (!userDTO.getUid().equals(loginUser.getUid())) {
 return new Result().setCode(1200).setMessage("不能修改其他用户信息");
 }
 User user = new User();
 user.setUid(userDTO.getUid());
 user.setName(userDTO.getName());
 user.setPhone(userDTO.getPhone());
 user.setClassName(userDTO.getClassName());
 if(userService.updateByPrimaryKeySelective(user)==0){
 return new Result().setCode(1200).setMessage("更新失败");
 }
 return new Result().setCode(200).setMessage("成功");
}

这里我用了@SecurityRequirement，主要是为了让Swagger调试姛时候可以输入Token。Swagger配置如下：

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


@Configuration
public class SwaggerConfig {
 @Bean
 public OpenAPI getOpenAPI() {
 return new OpenAPI()
 .info(new Info().title("Question Collect API")
 .description("问卷收集系统")
 .version("1.0.0")
 )
 .components(new Components()
 .addSecuritySchemes("Token",
 new SecurityScheme().type(SecurityScheme.Type.APIKEY).in(SecurityScheme.In.HEADER).name("Token"))
 );
 }
}

参考文献

使用micromamba代替anaconda

Mon, 05 Aug 2024 09:34:00 +0800

经常使用anaconda的小伙伴都会遇到一个问题，每次想要安装新的包，但会在solve environment这一步卡上半天，之后装包又要花上不少的时间。于是我找到了一款替代品，就是micromamba，据其官网所属，它是纯用C++编写的，同时使用了多线程。经过我的体验，确实是比anaconda要快一点的。

安装

安装很简单，跟着官方文档做就好了。例如，Linux就只要输入下面的一串命令就可以了。

1

"${SHELL}" <(curl -L micro.mamba.pm/install.sh)

不过默认的命令是micromamba，这实在是太长了，所以我们可以设置一个别名，方便平时使用。在~/.bashrc加入下面的内容就可以了。

1

alias conda="micromamba"

由于默认是不含 Anaconda 仓库源的，所以我们还需要再配置一下，正好把镜像也配置好。在~/.condarc中加入下面的内容：

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


channels:
 - defaults
show_channel_urls: true
default_channels:
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
 conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 deepmodeling: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/

在vscode中使用

这边才是我这篇文章的重点，由于是第三方的软件，所以vscode的Python插件默认是读取不到环境的，我们需要改一下配置。

在安装的时候，如果没有修改默认的设置，则mamba的路径应该在~/micromamba

我们打开VSCode的设置，添加下面的设置：

python.venvFolders这一项，添加mamba的目录名，即micromamba
python.venvPath这一项，添加mamba虚拟环境的目录，即~/micromamba/envs

只要添加好这两个设置，就可以发现VSCode能读取到虚拟环境了。

此时我们已经完成了所有的配置，像以前一样创建虚拟环境、装包就能开始使用了。根据我的体验，anaconda的绝大部分功能都可以无缝使用。

我的rime：打造多端同步的本地输入法

Sun, 16 Jun 2024 20:59:00 +0800

身边的人总是提到，为什么我上一秒提到的东西，马上就出现在了相关搜索中呢？一个很大的可能性就是你的输入法暴露了。有研究指出¹，目前市面上许多输入法都存在安全隐私漏洞。输入法作为我们平时用到最多的系统级应用，我不想自己的隐私被其泄露。所以，我寻找到了一款纯本地的全平台输入法——rime输入法²。它的优势就是简洁、无广告、不联网，不过对应的缺点就是没有云输入，一些比较新的词不好打出来，还有就是配置比较麻烦。

然而，我们可以通过使用别人预先设计好的配置来缓解这个问题。我选择了雾凇拼音³这个开源的方案来实现，它的优势就是自己维护了一套常用的词库，同时配置好了一些默认的输入的方案，我就在它的方案上进行优化，打造一套属于自己的输入体验。

由于我现在输入的方式是小鹤双拼，所以我的方案也全部是基于双拼打造的，全拼的话可以参考雾凇拼音的文档来配置。（在这强烈安利双拼的输入方式，学习成本不高但收益很高，能很大程度的改善你输入的体验👍）

基本配置

rime输入法通过.yaml文件来管理配置，并支持以patch的形式对其进行修改。所以，我们只需要编写*.custom.yaml文件就可以在别人的框架上构建自己的输入法了。由于配置文件在全端都是通用的，这里就先介绍共同的配置，每个平台独立的配置在后面再介绍。

rime的配置入口是default.yaml，所以我们先从它开始修改。创建default.custom.yaml，并填入下面的内容：

1
2
3
4
5
6
7


patch:
 schema_list:
 - schema: double_pinyin_flypy
 - schema: rime_ice
 menu/page_size: 7
 ascii_composer/switch_key/Shift_L: commit_code
 ascii_composer/switch_key/Shift_R: clear

我们首先选择了需要用到的两个方案double_pinyin_flypy和rime_ice，分别是小鹤双拼和全拼，这里加入全拼是避免别人使用我电脑时不会使用所预留的。menu/page_size指定了候选词的个数，最后两个则是指定了左右Shift键的功能。

由于我们使用的是双拼，还需要修改“部件拆字”功能中的设置⁴。创建radical_pinyin.custom.yaml，填入下面的内容：

1
2
3
4


patch:
 # 修改为小鹤双拼的拼写派生规则，因为不在同一个文件了，前面要加上文件名
 speller/algebra:
 __include: radical_pinyin.schema.yaml:/algebra_flypy

同样，“拼写派生"功能也需要修改。创建melt_eng.custom.yaml文件，填入下面的内容：

1
2
3
4


patch:
 # 修改为小鹤双拼的拼写派生规则，因为不在同一个文件了，前面要加上文件名
 speller/algebra:
 __include: melt_eng.schema.yaml:/algebra_flypy

这样就配置完成了，还是很简单的。

同步的话，我同样使用的是跨平台的软件rclone，如果要使用它，需要先配置好远端。

通过执行rclone config并按照指示添加即可。之后，我分别介绍每个平台的具体配置和同步设置。

详细配置

Win

win下的客户端叫小狼毫，下载安装好后就可以进行配置了。配置目录为%APPDATA%\Rime，我直接将里面的文件清空，然后使用git将雾凇拼音的仓库整个克隆进来。接着将上面“基本配置”中提到的三个文件创建好。由于默认的皮肤我不是很喜欢，所以我找了一个微软拼音的皮肤来使用。

创建weasel.custom.yaml并填入下面的内容：

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


patch:
 preset_color_schemes:
 microsoft_sim:
 name: 仿微软输入法
 author: plutotree
 back_color: 0xF4F4F4
 border_color: 0xDCDCDC
 text_color: 0x000000
 hilited_text_color: 0xF4F4F4
 hilited_back_color: 0xFFD8A6
 hilited_candidate_text_color: 0x000000
 hilited_candidate_back_color: 0xFFD8A6
 candidate_text_color: 0x000000
 comment_text_color: 0x888888

 style:
 color_scheme: microsoft_sim
 label_format: "%s"
 font_face: "微软雅黑"
 font_point: 12
 horizontal: true
 inline_preedit: true
 layout:
 min_width: 140
 min_height: 0
 border_width: 1
 border_height: 1
 margin_x: 9
 margin_y: 9
 spacing: 9
 candidate_spacing: 20
 hilite_spacing: 7
 hilite_padding: 8
 round_corner: 0

接下来需要配置installation.yaml，我们主要修改里面的installation_id，这是同步文件夹中的名称，默认是一串UUID，但是这不方便我们同步，建议将其修改成便于操作的名称。

这样我们就配置好了rime输入法，接下来只需要将配置目录下的sync文件夹同步就好了。

同步的工具rclone在之前已经设置好了，我这里编写了一个cmd脚本来自动执行备份任务。使用时记得修改本地和远端的地址：

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


@echo off

set rime_path="D:\Program Files (x86)\Rime\weasel-0.16.1\WeaselDeployer.exe"
set remote_path=a1:\rime_sync
set local_path=C:\Users\luobo\AppData\Roaming\Rime
set sync_path=%local_path%\sync
set device_name=lab-Win

echo 更新输入法词库
cd /d %local_path%
git pull
%rime_path% /deploy
echo 同步输入法词库中...
%rime_path% /sync
rclone sync %sync_path%\%device_name% %remote_path%\%device_name% -P
echo 下载远端词库
rclone sync %remote_path% %sync_path% -P --exclude %device_name%/**

Android

安卓端的应用是fcitx5-android⁵，下载软件本体和rime插件后就可以进行配置了。安卓端的配置文件位于/sdcard/Android/data/org.fcitx.fcitx5.android/files/data/rime，我们直接将电脑端的配置文件复制进去就可以了，需要注意的是，installation.yaml里面的installation_id要改成不同的值。

同步的话，rclone并没有官方的安卓客户端。不过，我们可以使用termux——一款运行于Android 系统的开源终端模拟器⁶，并在里面安装rclone来使用。

下载并安装好后，首先进行换源：

1
2


sed -i 's@^\(deb.*stable main\)$@#\1\ndeb https://mirrors.tuna.tsinghua.edu.cn/termux/apt/termux-main stable main@' $PREFIX/etc/apt/sources.list
apt update && apt upgrade

之后安装rclone

1

apt install rclone

⚠由于安卓的安全性设置，普通应用是无权访问别的应用目录下的文件。所以，我们需要给予root权限（或者使用别的有权限的应用，我没有试过）

我这里同样是通过脚本来实现自动同步：

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


#!/bin/sh

export PATH="/data/data/com.termux/files/usr/bin:$PATH"
CONFIG_PATH="/data/data/com.termux/files/home/.config/rclone/rclone.conf"
RIME_PATH="/sdcard/Android/data/org.fcitx.fcitx5.android/files/data/rime/sync"
REMOTE_PATH="a1:/rime_sync"
LOCAL_FOLDER="K50U-Android"

echo "download..."
rclone sync $REMOTE_PATH $RIME_PATH -P --exclude $LOCAL_FOLDER/** --config $CONFIG_PATH
echo "upload..."
rclone sync $RIME_PATH/$LOCAL_FOLDER $REMOTE_PATH/$LOCAL_FOLDER -P --config $CONFIG_PATH

这里由于我们是使用root身份来执行的，所以需要额外设置PATH并手动指定配置文件的路径

体验

日常使用rime输入法已经有大半年了，测试下来与云输入法基本没有什么区别，一些比较新的词打一遍也能被词库学习到。配合上多端同步，使用还是非常方便的。此外，雾凇拼音还内置了一些便捷功能，例如：

symbols：全拼 v 开头、双拼大写 V 开头
部件拆字的反查：uU 开头，反查时前缀会消失影响打英文所以设定为两个字母，或可改成一个非字母符号。
部件拆字的辅码：` 触发。
Unicode：大写 U 开头，如 U62fc 得到「拼」。
数字、金额大写：大写 R 开头，如 R1234 得到「一千二百三十四、壹仟贰佰叁拾肆元整」。
农历指定日期：大写 N 开头，如 N20240210 得到「二〇二四年正月初一」。

如果是比较在乎个人隐私的用户，我是比较推荐使用这样一款不联网的本地输入法的。

参考文献

Backdoor Defense via Deconfounded Representation Learning

Tue, 07 May 2024 14:30:00 +0800

介绍

最近的研究表明，深度神经网络（DNN）容易受到后门攻击，攻击者通过毒害一些训练数据将隐蔽的后门注入 DNN。具体来说，后门攻击者将后门触发器（即特定模式）附加到一些良性训练数据，并将其标签更改为攻击者指定的目标标签。触发模式和目标标签之间的相关性将由 DNN 在训练期间学习。在推理过程中，后门模型在良性数据上表现正常，而当后门被激活时，其预测会被恶意改变。

相反，人类认知系统能够抵抗输入的扰动，例如后门攻击引起的隐蔽触发模式。这是因为人类对因果关系的敏感度高于干扰因素的关联。相比之下，经过训练以拟合中毒数据集的深度学习模型很难区分后门攻击带来的因果关系和统计关联。通过因果推理，我们可以识别因果关系并建立鲁棒的深度学习模型。因此，必须利用因果推理来分析和减轻后门攻击的威胁。

那么。什么是因果推理呢？因果推断在统计研究中有着悠久的历史。因果推理的目标是分析变量之间的因果效应，并减轻虚假相关性。

作者专注于图像分类任务，目标是在没有额外干净数据的情况下，在含有毒数据的数据集上训练出无后门的模型。作者首先构建了一个因果图来模拟后门数据的生成过程，特别考虑了干扰因素，即后门触发模式。借助因果图，发现后门攻击扮演了混杂因素的角色，并在输入图像与预测标签之间建立了一条虚假的联系。一旦深度神经网络学习了这种虚假联系，当附加了触发器时，它们的预测就会发生改变，转向目标标签。

作者在因果洞察的启发下，提出了一种新的后门防御方法，称为因果关系启发的后门防御（Causalityinspired Backdoor Defense，CBD），旨在学习去混淆的分类表示。由于后门攻击隐蔽且难以直接测量，无法通过因果推理直接阻断后门路径。受到解缠绕表征学习最新进展的启发，作者的目标是学习一种表征，它只保留与因果关系相关的信息。在CBD中，作者训练了两个深度神经网络（DNN）：一个专注于捕获虚假相关性，另一个专注于识别因果效应。第一个DNN通过提前停止策略有意地学习后门相关性。接着，我们通过最小化互信息训练第二个干净的模型，使其在隐藏空间中独立于第一个模型。训练完成后，只有干净的模型被用于下游的分类任务。

问题构造

作者假设攻击者已经预先生成了一组后门示例，并成功地将它们注入到训练数据集中。同时，作者假设防御者能够完全控制训练过程，但对数据集中后门示例的分布或比例一无所知。防御者的目标是训练出一个在中毒数据集上表现良好且无后门的模型，其性能应与在纯干净数据上训练的模型相当。一句话总结，就是在后门数据集上训练出一个干净模型。

因果分析

因果推理的优越性在于它使人类能够识别因果关系，同时忽略任务中的非必要因素。相比之下，深度神经网络通常无法区分因果关系和统计关联，并且倾向于学习那些“更容易”的相关性，而不是必要的信息。这种走捷径的解决方案可能导致对无关因素（例如触发模式）的过度拟合，从而增加了后门攻击的脆弱性。因此，作者利用因果推理来分析DNN模型的训练过程，并降低后门注入的风险。

作者通过构建因果图$G$来模拟中毒数据的生成过程。在因果图中，作者使用节点来表示抽象数据变量，其中$X$代表输入图像，$Y$代表标签，$B$代表后门攻击。有向链接则表示这些变量之间的关系。除了$X$对$Y$的因果效应（$X → Y$）之外，后门攻击者可以通过将触发模式附加到图像（$B → X$）并将标签更改为目标标签（$B → Y$）来实施攻击。因此，后门攻击 $B$ 作为 $X$ 和 $Y$ 之间的混杂因素，打开了虚假路径 $X ← B → Y$（其中 $B = 1$ 表示图像中毒，$B = 0$ 表示图像干净）。我们所说的“虚假”路径是指这条路径位于 $X$ 到 $Y$ 的直接因果路径之外，它使得 $X$ 和 $Y$ 之间产生了虚假的相关性，并在触发器被激活时导致错误的效果。深度神经网络（DNN）很难区分虚假相关性和因果关系。因此，如果在可能中毒的数据集上直接训练 DNN，模型将面临被后门攻击的风险。

为了探究 $X$ 对 $Y$ 的因果效应，研究者通常使用 do 演算在因果干预中进行后门调整：$P(Y|do(X)) = \sum_{B\in\{0,1\}}P(Y|X,B)P(B)$。然而，在作者的设置中，由于混杂变量 $B$ 几乎无法被检测和测量，不能简单地使用后门调整来阻断后门路径。相反，由于大多数深度学习模型的目标是学习下游任务的准确嵌入表示，所以目标是解开隐藏空间中的混淆效应和因果效应。

基于因果推理的后门防御

在现实应用中，直接识别数据空间中 $X$ 的混杂因素和因果因素可能相当困难。作者假设这些混杂因素和因果因素会在隐藏的表征中得到体现。通常，训练包括两个 DNN，即 $f_B$ 和 $f_C$，它们分别专注于捕获虚假相关性和因果关系。作者从 $f_B$ 和 $f_C$ 的倒数第二层提取嵌入向量，分别表示为 $R$ 和 $Z$。为了避免混淆，本文中使用大写字母表示变量，小写字母表示具体值。为了生成能够捕获因果关系的高质量变量 $Z$，作者在训练阶段，首先在中毒数据集上训练 $f_B$，以捕捉后门的虚假相关性。随后，训练另一个干净的模型 $f_C$，鼓励其在隐藏空间（即 $Z$ 与 $R$ 独立）中的独立性，并通过最小化互信息和实施样本重新加权策略。训练完成后，只有 $f_C$ 被用于下游的分类任务。

后门模型训练

首先，作者在具有交叉熵损失的毒数据集上训练 $f_B$，目的是捕获后门的虚假相关性。由于中毒数据仍然包含因果关系，作者有意通过早期停止策略来增强 $f_B$ 中的混杂偏差。具体来说，作者只对 $f_B$ 进行了少数几个时期的训练（例如，5 个时期），并在训练 $f_C$ 时冻结了其参数。这是因为先前的研究表明，后门关联比因果关系更容易被学习。

干净模型训练

作者提出了具有信息瓶颈和互信息最小化的训练目标：

$$\mathcal{L}_C=\min\underbrace{\beta I(Z;X)}_{1}-\underbrace{I(Z;Y)}_{2}+\underbrace{I(Z;R)}_{3}$$

其中$I(.;.)$表示互信息

①用来限制来自输入的不相关信息
②用来捕获变量 $Z$ 用于标签预测的核心信息
③描述了后门嵌入 $R$ 和去混淆嵌入 $Z$ 之间的依赖程度。它鼓励 $Z$ 独立于 $R$，通过最小化互信息来关注因果效应

互信息

互信息（mutual Information，MI）度量了两个变量之间相互依赖的程度。具体来说，对于两个随机变量，MI是一个随机变量由于已知另一个随机变量而减少的“信息量”（单位通常为比特）。
$$I(X;Y)=D_{\mathrm{KL}}(p(x,y)\|p(x)\otimes p(y))$$
直观上，互信息度量 X 和 Y 共享的信息：它度量知道这两个变量其中一个，对另一个不确定度减少的程度。例如，如果 X 和 Y 相互独立，则知道 X 不对 Y 提供任何信息，反之亦然，所以它们的互信息为零。在另一个极端，如果 X 是 Y 的一个确定性函数，且 Y 也是 X 的一个确定性函数，那么传递的所有信息被 X 和 Y 共享：知道 X 决定 Y 的值，反之亦然。

然而，上述的公式并不能直接求解，为此，作者放宽了限制。

公式1

$$\begin{aligned} I(Z;X)& =\sum_x\sum_zp(z,x)\mathrm{log}\frac{p(z,x)}{p(z)p(x)} \\ &=\sum_x\sum_zp(z|x)p(x)\mathrm{log}\frac{p(z|x)p(x)}{p(z)p(x)} \\ &=\sum_x\sum_zp(z|x)p(x)\mathrm{log~}p(z|x)-\sum_zp(z)\mathrm{log~}p(z) \end{aligned}$$

然而，边际概率$p(z)=\sum_xp(z|x)p(x)$在实践中很难计算，为此作者通过变分分布$q(z)$来近似$p(z)$，由于KL散度是非负的，根据吉布斯不等式：$D_{\mathrm{KL}}(p(z)||q(z)) \geq 0 \Rightarrow -\sum_zp(z)\mathrm{log~}p(z)\leq-\sum_zp(z)\mathrm{log~}q(z)$

将其代入上式：

$$\begin{aligned} I(Z;X)& \leq\sum_xp(x)\sum_zp(z|x)\mathrm{log~}p(z|x)-\sum_zp(z)\mathrm{log~}q(z) \\ &=\sum_xp(x)\sum_zp(z|x)\mathrm{log}\frac{p(z|x)}{q(z)} \\ &=\sum_xp(x)D_{\mathrm{KL}}(p(z|x)||q(z)) \end{aligned}$$

作者假设$p(z|x)=\mathcal{N}(\mu(x),\mathrm{diag}\{\sigma^2(x)\})$是高斯分布，其中$\mu(x)$是$x$的编码嵌入，$\mathrm{diag}\{\sigma^2(x)\}=\{\sigma_d^2\}_{d=1}^D$表示方差的对角矩阵，并假设$q(z)=\mathcal{N}(0,I)$，于是上式就可以改写成：

$$D_{\mathrm{KL}}(p(z|x)||q(z))=\frac{1}{2}||\mu(x)||_2^2+\frac{1}{2}\sum_d(\sigma_d^2-\mathrm{log}\sigma_d^2-1)$$

为了便于优化作者将$\sigma(x)$定义为全零矩阵，所以$z=\mu(x)$成为确定性嵌入。

最后推导出来，公式一就相当于直接在嵌入向量 $z$ 上应用L2正则化

公式2

根据互信息的定义，有$I(Z;Y)=H(Y)-H(Y|Z)$，其中$H(·)$ 和 $H(·|·)$ 分别表示熵和条件熵。由于$H(Y)$ 是一个正常数，可以忽略不计，因此有以下不等式：

$$-I(Z;Y)\leq H(Y|Z)$$

在实验中，$H(Y|Z)$可以计算并优化为交叉熵损失。为了进一步鼓励 $f_C$ 和 $f_B$ 之间的独立性，作者固定了 $f_B$ 的参数，并使用样本加权交叉熵损失来训练 $f_C$，权重的计算公式为：

$$w(x)=\frac{CE(f_B(x),y)}{CE(f_B(x),y)+CE(f_C(x),y)}$$

对于 $f_B$上损失较大的样本，$w(x)$接近1;而当损失非常小时，$w(x)$接近 0。从而让 $f_C$专注于 $f_B$的“难”示例，以鼓励其独立性。

公式3

基于互信息和KL散度的关系，有$I(Z;R)=D_{\mathrm{KL}}(p(Z,R)||p(Z)p(R))$，即$I(Z;R)$等价于联合分布$p(Z,R)$和两个边际$p(Z)p(R)$的乘积之间的KL散度。

为了最小化混杂惩罚项，作者采用了对抗学习。判别器$D_\phi$被训练成将联合分布$p(Z,R)$分类为1，将边际分布$p(Z)p(R)$分类为0。边际分布$p(Z)p(R)$的样本是通过对$p(Z,R)$训练批次中样本$(z,r)$的单个表示进行shuffle而获得的。优化函数如下：

$$\mathcal{L}_{adv}=\min_{\theta_C}\max_\phi\mathbb{E}_{p(z,r)}[D_\phi(z,r)]-\mathbb{E}_{p(z)p(r)}[D_\phi(z,r)]$$

其中$\theta_C$ 和$\phi$分别表示 $f_C$ 和 $D_\phi$ 的参数。

综上，$f_C$的损失函数为：

$$\mathcal{L}_C=\mathcal{L}_{wce}+\mathcal{L}_{adv}+\beta||\mu(x)||_2^2$$

算法的伪代码如下：

实验

数据集和模型

CIFAR-10：WideResNet
GTSRB：WideResNet
ImageNet：ResNet-34

攻击基线

BadNets、Trojan attack、Blend attack、Sinusoidal signal attack (SIG)、Dynamic attack、WaNet

防御基线

Fine-pruning (FP) 、Mode Connectivity Repair (MCR) 、 Neural Attention Distillation (NAD) 、 Anti-Backdoor Learning (ABL) 、Decoupling-based backdoor defense (DBD)

作者在10%中毒率下和其他防御方法进行了对比，证明了该方法的有效性。

同时，作者也考虑了不同中毒率下防御方法的有效性

此外，作者还绘制了t-SNE图，从a和b可以看出在训练后，混杂成分$r$和因果成分$z$之间存在明显的分离。从c和d中可以看出，中毒样本的嵌入在$r$中形成簇，这表明已经学习了后门触发器和目标标签之间的虚假相关性。相比之下，中毒样本与样本密切相关，其真实标签位于去混淆嵌入$z$中，这表明CBD可以有效地防御后门攻击。

作者最后还计算了防御所需的时间，可见防御并不需要更多额外的时间

基于DNS的分流方案

Fri, 22 Mar 2024 20:47:00 +0800

最近将路由器上的工具换为小猫，使用默认的redir-host模式虽然能用，但总是出现各种各样奇怪的问题，再加上小猫官方已经删除了redir-host模式，于是我便想找到一个基于fake-ip的分流方式。通过在互联网上检索发现，找到了这篇文章——《基于 DNS 的内网透明代理分流方案》。仔细研读下来，完美符合我的需求，然而，我使用的是内存捉襟见肘的硬路由，并没有足够的空间装下AdGuardHome+mosdns+小猫三员大将。于是，我便在他方案的基础上删除了AdGuardHome，优化出了现在的方案。

实现效果

和原来的方案一样，我就直接粘贴了。

基于DNS的流量分流，国内流量绕过小猫核心
用Fake-IP模式来解决DNS污染的问题，但限制Fake-IP的范围，不需要代理的域名仍返回正常IP
不用再费心找无污染的DNS服务器，使用运营商提供的DNS也没问题
因为彻底解决了DNS污染，可以放心缓存DNS请求结果
完美兼容IPv6。国内流量可正常使用IPv6服务。只要代理有IPv6出口，那国外也可正常使用。
兼容BT/PT应用，无需特殊配置也不会消耗代理流量
可以松切换内网设备是否走代理

遇到问题

在按照原来的方案构建并删去AdGuardHome后，可以实现大部分的功能。然而在我的使用中，却遇到了一个关键的问题：无法区分流量来源——由于mosdns是作为Dnsmasq的上游来使用的，所以无法识别请求的客户端，故无法实现是否走代理。

为此，我尝试将mosdns代替dnsmasq来监听53端口，结果又遇到了一个新的问题：所有的请求都返回fake-ip——由于dns存在主机名解析功能，导致请求被错误的发往小猫的DNS端口，从而返回了fake-ip。

方案设计

为了解决这两个问题，我重新设计了DNS解析的流程，从而得到了现在的这一套方案。

DNS分流

graph TB
client[DNS 请求] -- 防火墙劫持 --> mosdns
mosdns -- 需要代理的设备 --> query[按规则进行DNS查询]
mosdns -- 不需要代理的设备 --> dnsmasq
query -- 国内域名 --> dnsmasq
query -- 国外域名 --> drop_ipv6[\忽略 IPv6 请求/]
query -- 其它 --> fallback
fallback -- 国内IP --> dnsmasq
fallback -- 国外IP --> drop_ipv6
dnsmasq --> sp_dns[真实IP]
query -- 域名白名单 --> dnsmasq
query -- 域名灰名单 --> drop_ipv6
drop_ipv6 --> fake[Fake IP]

经过DNS分流后，所有需要代理的域名都分配到了Fake IP，无需代理的域名都是由运营商DNS返回的最优结果。小猫的DNS在Fake IP模式下可以无需请求网络直接返回结果，所以整体的DNS响应速度非常快。在处理Fake IP的流量时，小猫会把hostname发送到远端进行DNS解析，也就自然不存在DNS污染的问题了。

修复地址解析错误

由于dns存在主机名解析功能，会导致请求错误的转发。正所谓“头痛医头，脚痛医脚”，最简单和无脑的方法就是直接关闭这个功能：

在网络-DHCP/DNS-高级设置里，将本地域名里的值删除。（未测试，不确定🤔）

但是我们都使用了mosdns了，为什么不好好的利用它那强大的规则呢。所以，我们可以将有关主机名解析的流量全部转发到dnsmasq，这样就不会出问题了。

区分流量来源

一开始，mosdns是作为dnsmasq的上游的，所以所有的请求来源都是本地，这就导致了我们无法控制mosdns，让其为不需要代理的设备分配真实的IP。所以，我们将所有dns请求通过防火墙劫持到mosdns上，就能知道设备的来源的ip了。关于防火墙的写法，我参考了luci-app-adguardhome的开源代码。

但是这样还有一个问题，由于我们配置了ipv6，所以请求的客户端地址很大可能也是ipv6的。由于ipv6地址支持无状态分配，这就导致请求的地址会一直变动，这也导致无法为特定客户端实现分流。这里我选择了最简单和无脑的方法——直接关闭ipv6的DNS服务。通过查询Openwrt的官方文档，我们发现官方提供了关闭ipv6 DNS服务的方法。这样就可以让客户端始终通过ipv4来请求了。确保了这一点，我们的防火墙也只用劫持ipv4的流量了。

具体配置

上面都在讲思路，终于轮到具体的配置了。我们现在只需要小猫和luci-app-mosdns这两个包就好了。

小猫

插件设置 - 模式设置 - 运行模式：切换到 Fake-IP（增强）模式
插件设置 - DNS 设置 - 本地 DNS 劫持 选择 禁用
插件设置 - 流量控制 - 绕过中国大陆 IP 取消勾选
插件设置 - 流量控制 - 仅允许内网 开启
插件设置 - IPv6 设置 这页的选项全都关闭就行了
覆写设置 - 常规设置 这里都不用改，只需要记住 DNS 监听，后面配置 mosdns 要用
覆写设置 - DNS 设置 - 自定义上游 DNS 服务器 勾选
覆写设置 - DNS 设置 - 追加上游 DNS 勾选
覆写设置 - DNS 设置 - 追加默认 DNS 勾选
覆写设置 - DNS 设置 - Fake-IP 持久化 勾选
覆写设置 - DNS 设置 页面下方 NameServer，FallBack，Default-NameServer 里的 DNS 服务器全都取消勾选，我们只用运营商提供的 DNS 服务器就够了，一般运营商 DNS 都是最快的，也是 CDN 最优化的。
插件设置 - 开发者选项 里，我们自定义一下防火墙规则，增加如下这些行。

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


LOG_OUT "limit route to only fake ips with proxy port 7892"

/etc/mosdns/genipset.sh

iptables -t nat -D openclash -p tcp -j REDIRECT --to-ports 7892
iptables -t nat -A openclash -m set --match-set telegram dst -p tcp -j REDIRECT --to-ports 7892

LOG_OUT "restart mosdns"
/etc/init.d/mosdns restart

LOG_OUT "将53端口重定向到mosdns"
iptables -t nat -D PREROUTING -p udp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
iptables -t nat -A PREROUTING -p udp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
iptables -t nat -D PREROUTING -p tcp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
iptables -t nat -A PREROUTING -p tcp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335

这里有几个注意点，都是我踩过的坑😢：

可能是我内核版本太旧了，这里使用任何变量都是空值，所以我把所有地址都写死了，记得根据自己的路由器地址进行修改
不要忘记劫持TCP流量！我之前仅仅劫持了UDP流量导致浏览器一直请求到真实ip而无法访问。

2024.09.26更新使用nftables的高版本openwrt需要使用下面的脚本：

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


LOG_OUT "Start Add Custom Firewall Rules..."

FW4=$(command -v fw4)
en_mode=$(uci -q get openclash.config.en_mode)
proxy_port=$(uci -q get openclash.config.proxy_port)

if [ "$en_mode" == "fake-ip" ]; then
 LOG_OUT "limit route to only fake ips with proxy port $proxy_port"

 /root/genipset.sh

 if [ -n "$FW4" ]; then
 handle=$(nft -a list chain inet fw4 openclash | grep 'ip protocol tcp counter' | awk '{print $NF}')
 LOG_OUT "deleting nft rule handle $handle"
 nft delete rule inet fw4 openclash handle $handle
 nft add rule inet fw4 openclash ip protocol tcp ip daddr @telegram counter redirect to $proxy_port
 else
 iptables -t nat -D openclash -p tcp -j REDIRECT --to-ports $proxy_port
 iptables -t nat -A openclash -m set --match-set telegram dst -p tcp -j REDIRECT --to-ports $proxy_port
 fi

 LOG_OUT "restart mosdns"
 /etc/init.d/mosdns restart

 LOG_OUT "将53端口重定向到mosdns"

 if [ -n "$FW4" ]; then
 ! nft --check list table inet mosdns > "/dev/null" 2>&1 || nft delete table inet mosdns
 nft add table inet mosdns
 nft add chain inet mosdns prerouting "{ type nat hook prerouting priority -110; policy accept; }"
 nft add rule inet mosdns prerouting "meta nfproto { ipv4 } udp dport 53 ip daddr 192.168.6.1 counter redirect to :5335 comment \"MOSDNS HIJACK\""
 nft add rule inet mosdns prerouting "meta nfproto { ipv4 } tcp dport 53 ip daddr 192.168.6.1 counter redirect to :5335 comment \"MOSDNS HIJACK\""
 else
 iptables -t nat -D PREROUTING -p udp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
 iptables -t nat -A PREROUTING -p udp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
 iptables -t nat -D PREROUTING -p tcp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
 iptables -t nat -A PREROUTING -p tcp -d 192.168.6.1 --dport 53 -j REDIRECT --to-ports 5335
 fi
fi

genipset.sh 的代码如下，这是针对某些应用不通过DNS直接用ip访问，要将这部分流量劫持到小猫。这个文件放到路由器上后，记得要执行 chmod a+x /etc/mosdns/genipset.sh 给它赋予可执行权限。

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


#!/bin/bash

tag="telegram"
filename="/etc/mosdns/data/telegram-cidr.txt"
FW4=$(command -v fw4)

if test -f "$filename"; then
 if [ -n "$FW4" ]; then
 nft add set inet fw4 "$tag" { type ipv4_addr\; flags interval\; auto-merge\; }
 nft add set inet fw4 "${tag}6" { type ipv6_addr\; flags interval\; auto-merge\; }
 nft flush set inet fw4 "$tag"
 nft flush set inet fw4 "${tag}6"
 fi
 ipset create "$tag" hash:net -!
 ipset create "${tag}6" hash:net family inet6 -!
 ipset flush "$tag"
 ipset flush "${tag}6"
 while read p; do
 if ! grep -q ":" <<< "$p"; then
 if [ -n "$FW4" ]; then
 nft add element inet fw4 "$tag" { "$p" }
 fi
 ipset add "$tag" "$p"
 else
 if [ -n "$FW4" ]; then
 nft add element inet fw4 "${tag}6" { "$p" }
 fi
 ipset add "${tag}6" "$p"
 fi
 done <"$filename"
else
 echo "$filename missing."
fi

Mosdns

选自定义配置文件，关闭DNS 转发的勾，然后我就直接贴配置了

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209


# Powered by luoboQAQ
# 适配Clash的fake-ip模式
# 24-08-29：让灰名单优先生效，避免被geosite_cn抢答
log:
 level: info
 file: "/tmp/log/mosdns.log"

# API 入口设置
api:
 http: "0.0.0.0:9091"

plugins:
 # 国内域名
 - tag: geosite_cn
 type: domain_set
 args:
 files:
 - "/etc/mosdns/data/direct-list.txt"
 - "/etc/mosdns/rule/whitelist.txt"

 # 国内 IP
 - tag: geoip_cn
 type: ip_set
 args:
 files:
 - "/etc/mosdns/data/CN-ip-cidr.txt"

 # 国外域名
 - tag: geosite_no_cn
 type: domain_set
 args:
 files:
 - "/etc/mosdns/data/proxy-list.txt"

 # 灰名单域名，强制远程解析
 - tag: greylist
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/greylist.txt"

 # 黑名单域名：屏蔽 DNS 解析
 - tag: blocklist
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/blocklist.txt"

 # ddns域名
 - tag: ddnslist
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/ddnslist.txt"

 # 自定义 Hosts 重写
 - tag: hosts
 type: hosts
 args:
 files:
 - "/etc/mosdns/rule/hosts.txt"

 # 广告域名
 - tag: adlist
 type: domain_set
 args:
 files:
 - "/etc/mosdns/data/ad-domains.txt"

 # PTR黑名单
 - tag: local_ptr
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/local-ptr.txt"

 # 缓存插件
 - tag: cache
 type: cache
 args:
 size: 10240
 lazy_cache_ttl: 86400
 # 将缓存保存在磁盘
 # dump_file: /tmp/mosdns/cache.dump

 # 国内解析
 - tag: local_sequence
 type: sequence
 args:
 - exec: forward 127.0.0.1

 # 国外解析
 - tag: remote_sequence
 type: sequence
 args:
 - matches:
 - qtype 28
 exec: reject 0
 - exec: forward 127.127.127.127:7874
 - exec: ttl 1800-0

 # 有响应终止返回
 - tag: has_resp_sequence
 type: sequence
 args:
 - matches: qname $ddnslist
 exec: ttl 5-5
 - matches: has_resp
 exec: accept

 # fallback 用本地服务器 sequence
 # 返回非国内 ip 则 drop_resp
 - tag: fallback_local
 type: sequence
 args:
 - exec: $local_sequence
 - matches: "!resp_ip $geoip_cn"
 exec: drop_resp

 # fallback 用远程服务器 sequence
 - tag: fallback
 type: fallback
 args:
 primary: fallback_local
 secondary: remote_sequence
 threshold: 500
 always_standby: true

 # 主要的运行逻辑插件
 # sequence 插件中调用的插件 tag 必须在 sequence 前定义，
 # 否则 sequence 找不到对应插件。
 - tag: main_sequence
 type: sequence
 args:
 # 不走代理的ip
 #- matches: client_ip 192.168.6.144
 # exec: forward 127.0.0.1
 #- exec: jump has_resp_sequence

 # hosts
 - exec: $hosts
 - exec: jump has_resp_sequence

 - matches:
 - "!qname $ddnslist"
 - "!qname $blocklist"
 - "!qname $adlist"
 - "!qname $local_ptr"
 exec: $cache
 - exec: jump has_resp_sequence

 # 查询拒绝域名
 - matches: qname $blocklist
 exec: reject 3
 - matches: qname $adlist
 exec: reject 3
 - matches: qtype 65
 exec: reject 3
 - matches:
 - qtype 12
 - qname $local_ptr
 exec: reject 3

 # handle local ptr
 - matches:
 - qtype 12
 exec: forward 127.0.0.1
 - exec: jump has_resp_sequence

 # handle lan query
 - matches:
 - qname regexp:lan regexp:local regexp:arpa
 exec: forward 127.0.0.1
 - exec: jump has_resp_sequence

 - matches:
 - qname $ddnslist
 exec: $local_sequence
 - exec: jump has_resp_sequence

 # 灰名单在geosite_cn之前查询
 - matches:
 - qname $greylist
 exec: $remote_sequence
 - exec: jump has_resp_sequence

 - matches:
 - qname $geosite_cn
 exec: $local_sequence
 - exec: jump has_resp_sequence

 - matches:
 - qname $geosite_no_cn
 exec: $remote_sequence
 - exec: jump has_resp_sequence

 - exec: $fallback

 - tag: udp_server
 type: udp_server
 args:
 entry: main_sequence
 listen: ":5335"

 - tag: tcp_server
 type: tcp_server
 args:
 entry: main_sequence
 listen: ":5335"

在这个配置中，我使用了以下项目提供的域名/IP文件：

为了方便期间，我们可以使用脚本一键更新它们：

1
2
3
4
5
6
7


#!/bin/sh
curl -o "/etc/mosdns/data/direct-list.txt" "https://cdn.jsdelivr.net/gh/Loyalsoldier/v2ray-rules-dat@release/direct-list.txt"
curl -o "/etc/mosdns/data/proxy-list.txt" "https://cdn.jsdelivr.net/gh/Loyalsoldier/v2ray-rules-dat@release/proxy-list.txt"
curl -o "/etc/mosdns/data/CN-ip-cidr.txt" "https://cdn.jsdelivr.net/gh/Hackl0us/GeoIP2-CN@release/CN-ip-cidr.txt"
curl -o "/etc/mosdns/data/ad-domains.txt" "https://anti-ad.net/domains.txt"
curl --resolve core.telegram.org:443:`nslookup -port=5335 core.telegram.org 192.168.6.1 | grep 198 | cut -d ":" -f2 | tr -d " "` -o "/etc/mosdns/data/telegram-cidr.txt" "https://core.telegram.org/resources/cidr.txt"
/etc/init.d/mosdns restart

由于某个地址需要小猫才能访问，同时我们没有劫持路由器的dns查询，所以需要先手动查一下ip再下载。

后记

这也是一个大工程了，前前后后也花了好多天，不过做完后使用起来还是非常丝滑和顺畅的，最重要的是自己折腾出来这是在是太酷了🤓。这里还是要感谢方案的原作者和开源项目作者，我从中学到了许多🙏。

后续更新

2024.08.29

在使用时，会发现Google Play商店不能正常下载或更新应用。在《大陆用户 Google Play 商店无法下载或更新应用的原因分析与解决办法》这篇文章中，作者指出了这是由于国内版商店的api请求链接和下载链接分别通过直连和代理导致的问题，解决方案就是让请求都从代理出去。

具体而言，我们需要将下面这几个域名添加到代理规则中

1
2
3


domain:googleapis.cn
domain:googleapis.com
domain:xn--ngstr-lra8j.com

Mosdns

在规则列表-灰名单中添加上面的域名

小猫

在覆写设置-规则设置-自定义规则中添加下面的分流规则

1
2
3
4
5


rules:
 # Google Play
 - DOMAIN-SUFFIX,googleapis.cn,🚀 节点选择
 - DOMAIN-SUFFIX,googleapis.com,🚀 节点选择
 - DOMAIN-SUFFIX,xn--ngstr-lra8j.com,🚀 节点选择

这样就可以正常的使用Play商店了

2024.09.26

将路由器刷到了最新的immortalWrt，防火墙从iptables升级到了nftables，所以原来的命令不能用了，需要使用新的命令。

使用WireGuard+ipv6进行异地组网

Sat, 03 Feb 2024 23:00:08 +0800

放假回家，手里只有性能孱弱的轻薄本，用它跑个实验或者是打个游戏实在是太难为它了。于是，远程到实验室的高性能主机便是一个非常不错的选择。不过，和之前在宿舍局域网串流不一样，家里和实验室属于不同的局域网，之间无法相互连接。

在之前配置实验室路由器时，我已经配置过了WireGuard。通过在电脑上安装WireGuard，每次开机时启动一下就可以连入实验室的局域网了。似乎这样已经可以了，但是，如果我想在其他设备上访问实验室，就要重复上面的步骤，这实在是太麻烦了。同时，实验室想要访问位于家里的设备也无法实现。

于是，我决定通过折腾一波路由器，来实现无感知的异地组网。

准备工作

2台刷好OpenWrt的路由器，并保证拥有WireGuard包

如果你的固件里没有预装WireGuard，可以选择手动编译，就像我这篇文章一样（还没写🕊️）
2台路由器均拥有公网ipv6地址
一个域名，用来做ddns

如何配置ddns不是本篇文章的重点，可以参考我之前的文章或者百度一下

我们首先设计一下网络拓扑，其中实验室的ip段为192.168.6.0/24，家里的ip段为192.168.10.0/24。我这里选取192.168.100.0/24为WireGurad的虚拟局域网网段，并分别给家中和实验室路由器分配192.168.100.100/32和192.168.100.1/32两个地址。为了接下来使用方便，我建议用表格整理一下：

	实验室	家
局域网段	192.168.6.0/24	192.168.10.0/24
ddns地址	school.example.com	home.example.com
WireGurad接口ip地址	192.168.100.1/32	192.168.100.100/32

具体操作

接口配置

我们首先从实验室的路由器开始配置。登入OpenWrt后台，依次点击网络——接口——添加新接口，选择协议为WireGuard VPN，名称这里随意。

接着开始进行详细的配置

这里的监听端口按照个人喜好自己指定即可，为了演示我分别指定端口号为6789和7890。

可以看到较新的OpenWrt这里是有生成密钥的选项，所以我们可以不用命令行来生成密钥对，不过我这个版本缺少公钥的框，如果想查看公钥的话，要到状态——WireGuard里去查看。所以我建议还是使用命令行预先生成好公私钥：

1
2
3
4
5
6
7
8


# 创建公钥和私钥
wg genkey | tee privatekey | wg pubkey > publickey
# 获取私钥复制保存
cat privatekey
# 获取公钥复制保存
cat publickey
# 生成预共享密钥
wg genpsk

我们需要创建两次公私钥，预共享密钥是一致的，所以只需创建一次即可，为了便于之后的操作，我们将其存放到上文列好的表中：

	实验室	家
局域网段	192.168.6.0/24	192.168.10.0/24
ddns地址	school.example.com	home.example.com
WireGurad接口ip地址	192.168.100.1/32	192.168.100.100/32
监听端口	6789	7890
WireGurad公钥	YJF1c//jJ0K2HSZ+yNqfjBfJL6Z90lyfVCyML8To1lI=	Q/gtGW5xBK5sEgPTrSo3CWqGOv3SYhzkqw8CBOJ3ZHs=
WireGurad私钥	0MyNAHWVI0owbbZ3Et9gWtNFSVWiOqiHHYJAj86Wq0E=	eKGSiCzaVi9IHfDLv4atx//wE8LGCR2xWAwc3XBw9kg=
预共享密钥	OQrD6nvzMGQklARhwwhlrinFiumrGe2SIBxcRSOuIEo=	同左

特别注意

私钥和预共享密钥就像密码一样，不要轻易泄露，我这里只是演示用才展示出来。

有了这些信息，我们就可以很轻松的将前图中的配置填好了，不要勾选无主机路由。

之后我们要配置对端

有了之前的表格，这里的内容就很简单了。直接反着写就好了。我这里是实验室所以就对着家的那一列依次往里面填即可。

允许的IP我们直接添加两条，分别是对方的局域网段和接口ip地址，例如我这里就填192.168.10.0/24和192.168.100.100/32即可。
勾选路由允许的IP
端点主机和端口分别填写ddns地址和监听端口。
Keep-Alive使用默认值25即可。

这样我们的WireGuard就算配置好了。

防火墙配置

依次点击网络——防火墙，选择添加。

这里大部分人（包括之前的我）会说直接将WireGuard接口放入LAN中，不过这样还是不太优雅，所以我们还是创建一个新区域。

出站、入站、转发均为允许
勾选MSS 钳制：这主要是为了防止内网MTU过大导致WireGuard效率降低
涵盖的网络为之前创建的接口
允许转发到目标区域和允许来自源区域的转发都选择LAN

保存后选择上面的通信规则，我们需要开启路由器上的端口

由于WireGuard是基于UDP的，我们只需要放行UDP流量即可。端口为之前表中填写的。

至此，我们的配置就算完成了，另一台路由器也是同样的配置方法，我就不赘述了。

踩坑和一些注意事项

两端都要配置端点主机

WireGuard按原理来说，只要一方发起握手即可相互通信，所以我们可以只配置一个路由器，让它发起握手。不过我尝试后发现这样会导致只有发起握手的路由器可以连到对端，下面的设备就无法连接，被握手的路由器也无法ping通发起握手的路由器。（🤔难道是因为被握手的路由器中没有自动配置好路由表吗？）
WireGuard配置好后需要重启端口才能生效
ddns变动后，WireGuard只会尝试连接之前的地址而不会重新解析

可能是为了安全考虑吧，这样只能手动重启端口来让其重新解析，还有其他自动化的方法不过我就没有研究了

参考文献

【老湿基】WireGuard 异地组网手把手教学 | 从入门到精通 | 局域网融合_哔哩哔哩

红米AX6000折腾记

Sat, 21 Oct 2023 21:36:58 +0800

起因

由于实验室的网线口过于稀少且离我距离太远，学校的WIFI又是WIFI5，平时最多只能跑到30MB/s。但我的笔记本支持WIFi6，学校又是千兆网。两条原因一叠加，那就直接上WIFI6的路由器吧。首要的选择条件就是支持刷机，在恩山上逛了一阵子，就决定入手红米的AX6000。可解锁、有第三方固件、512MB内存。特别是这512MB内存，比起我之前用的红米AC2100，直接翻了4倍，相较于原来随便开个插件就没有内存的情况，直接起飞好吧😎。

成果

先来一手倒序(毕竟配置的过程比较无聊😇。使用南京大学测速站进行测试，可以看到网速直接拉满，下载东西的时候终于不用等那么久了。

再加上各种插件，真的很舒适🤤，上网体验直接拉满。下面就是将相关的配置过程做个记录。

配置

解锁与刷机

这里可以参考B站大佬的视频¹，步骤非常详细，直接跟着做就好了。为了备忘，我这里再简单把步骤写一下。

高版本的系统已经封堵了解锁的漏洞，我们要做的第一步就是使用小米修复工具进行降级。

之后进入管理界面并登录，此时地址格式类似下面这样：

1

http://192.168.31.15/cgi-bin/luci/;stok=030b24d39b1a4a549aa12dac23c52313/web/home#router

我们将/web/home#router删除，并加上下面一段：

1

/api/misystem/set_sys_time?timezone=%20%27%20%3B%20zz%3D%24%28dd%20if%3D%2Fdev%2Fzero%20bs%3D1%20count%3D2%202%3E%2Fdev%2Fnull%29%20%3B%20printf%20%27%A5%5A%25c%25c%27%20%24zz%20%24zz%20%7C%20mtd%20write%20-%20crash%20%3B%20

即连接应该为http://192.168.31.15/cgi-bin/luci/;stok=030b24d39b1a4a549aa12dac23c52313/api/......

回车访问，显示{"code":0}表示成功

同理，继续替换：

1

/api/misystem/set_sys_time?timezone=%20%27%20%3b%20reboot%20%3b%20

等待重启完成

登录路由器，替换：

1

/api/misystem/set_sys_time?timezone=%20%27%20%3B%20bdata%20set%20telnet_en%3D1%20%3B%20bdata%20set%20ssh_en%3D1%20%3B%20bdata%20set%20uart_en%3D1%20%3B%20bdata%20commit%20%3B%20

继续替换：

1

/api/misystem/set_sys_time?timezone=%20%27%20%3b%20reboot%20%3b%20

等待重启完成

此时telnet已经开启，连接进入，显示【ARE U OK】的界面，表示telnet成功。

输入下面的命令开启ssh：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


bdata set boot_wait=on
bdata commit
nvram set ssh_en=1
nvram set telnet_en=1
nvram set uart_en=1
nvram set boot_wait=on
nvram commit
sed -i 's/channel=.*/channel="debug"/g' /etc/init.d/dropbear
/etc/init.d/dropbear restart
echo -e 'admin\nadmin' | passwd root

继续输入下面的命令，关闭开发者模式：

1

mtd erase crash

使用ssh连接进入，将xwrt目录里的stock-initramfs-factory.ubi传入tmp目录

输入下面的命令查看系统分区

1

cat /proc/cmdline

输出类似这样：

1

console=ttyS0,115200n1 loglevel=8 firmware=1 uart_en=1

我们主要关注firmware=1这项

如firmware=0输入

1
2
3
4
5
6
7
8


nvram set boot_wait=on
nvram set uart_en=1
nvram set flag_boot_rootfs=1
nvram set flag_last_success=1
nvram set flag_boot_success=1
nvram set flag_try_sys1_failed=0
nvram set flag_try_sys2_failed=0
nvram commit

然后刷入固件

1

ubiformat /dev/mtd9 -y -f /tmp/stock-initramfs-factory.ubi

如firmware=1输入

1
2
3
4
5
6
7
8


nvram set boot_wait=on
nvram set uart_en=1
nvram set flag_boot_rootfs=0
nvram set flag_last_success=0
nvram set flag_boot_success=1
nvram set flag_try_sys1_failed=0
nvram set flag_try_sys2_failed=0
nvram commit

然后刷入固件

1

ubiformat /dev/mtd8 -y -f /tmp/stock-initramfs-factory.ubi

reboot重启固件后台：http://192.168.15.1/ 账户密码：admin/admin 在后台升级xwrt正式固件

进入xwrt正式固件后台—系统—管理权—ssh访问—打开密码验证和允许root用户凭密码登录-保存并应用。再次连接SSH（ip192.168.15.1用户名root密码admin），输入以下命令

1
2
3
4
5
6
7


fw_setenv boot_wait on
fw_setenv uart_en 1
fw_setenv flag_boot_rootfs 0
fw_setenv flag_last_success 1
fw_setenv flag_boot_success 1
fw_setenv flag_try_sys1_failed 8
fw_setenv flag_try_sys2_failed 8

之后刷入最新237大佬固件

刷入uboot

之前刷入的官方版的镜像，虽然很方便，但是可用空间并不是很多，为了榨干它全部的性能，我还是决定刷入第三方uboot，将官方原始的三个分区合并成一个大分区。

我这里刷入的hanwckf大佬制作的uboot，他支持多分区的切换，还是很方便的。具体的功能和下载链接可以看大佬的博客——mt798x uboot 功能介绍。

我们之前刷入过237大佬的固件了，所以FIP分区已经解锁，可以直接刷。

首先要备份原始的分区，像Factory为无线EEPROM分区；Bdata存储着你的SN和MAC。如果没了应该是无法使用别人的分区来使用的。所以一定要备份好。

我们使用dd命令备份分区到tmp文件夹：²

1
2
3
4
5


dd if=/dev/mtd1 of=/tmp/mtd1_BL2.bin
dd if=/dev/mtd2 of=/tmp/mtd2_Nvram.bin
dd if=/dev/mtd3 of=/tmp/mtd3_Bdata.bin
dd if=/dev/mtd4 of=/tmp/mtd4_Factory.bin
dd if=/dev/mtd5 of=/tmp/mtd5_FIP.bin

然后使用WinSCP等软件将备份的文件下载到电脑上。

备份好后，就可以通过WinSCP将uboot文件上传到tmp目录下，并执行下面的命令进行刷入：

1
2
3


d5sum /tmp/mt7986_redmi_ax6000-fip-fixed-parts-multi-layout.bin
mtd write /tmp/mt7986_redmi_ax6000-fip-fixed-parts-multi-layout.bin FIP
mtd verify /tmp/mt7986_redmi_ax6000-fip-fixed-parts-multi-layout.bin FIP

注意对比md5的值是否一致。最后如果成功则会输出Success

将路由器断电，按住Reset键并通电，持续按住10S即可进入uboot了。

由于H大的uboot没有配置DHCP，我们需要手动配置电脑ip：

IP地址：192.168.31.100
子网掩码：255.255.255.0
默认网关：192.168.31.1
DNS：192.168.31.1

访问192.168.31.1即可进入uboot页面，这时就可以刷入大分区的固件了

配置校园网自动连接

在我之前，已经有大佬针对校园网的登录写了自动化脚本

yzu-campusnet-login

public

校园网登录器

Python

然而，这并不适用我的环境。由于红米AX6000的官方布局采用了A/B分区，导致可用的软件包分区只有20多MB。在这么小的空间中安装个Python，再加上各种各样的库，想想就可怕。

为此，我需要使用一门可以打包成小体积的语言来重构此程序。一开始，我想选择C++，但是C++的网络编程我还没了解过，正在我思考要不要花些时间学习一下，突然想到了有一门语言完美符合我的需求——Golang。跨平台、有方便的网络库，于是我便花了一天时间学习Go，成功将大佬的程序重构了（正好当学习Go语言的练手程序。

yzu-campusnet-login

public

Go版本的校园网登录器

直接将编译好的二进制文件传入到路由器中，并写好配置文件，之后在后台——“系统”——“启动项”下面的本地启动脚本添加一条运行命令就可以开机启动了。

1

cd /root/login && nohup ./YzuCampusnetLogin > /tmp/login.log 2>&1 &

配置ipv6

学校的ipv6下发的是/64地址，一开始我参考这个大佬的教程，使用内网中继的方案来实现ipv6。然而无论我怎么配置，都无法连接互联网。最后发现是学校网关对每一个ipv6地址都会进行登录的校验，如果没有登录就不会放行，那这条路算是彻底堵死了😥。

这样的话，就只能使用nat6了,详细的步骤可以参考这篇教程³

将接口——LAN——IPV6设置中的路由通告服务选为“服务器模式”、DHCPv6 服务选为“服务器模式”、NDP 代理选为“禁用”、DHCPv6 模式选为“无状态的 + 有状态的”、总是通告默认路由勾上

使用ssh连接路由器，在/etc/init.d目录下新建nat6并填入下面的内容：

📃展开代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


#!/bin/sh /etc/rc.common
# NAT6 init script for OpenWrt // Depends on package: kmod-ipt-nat6

# edited by Sad Pencil at 2020-02-09
# replace route command with ip command to solve issues on new OpenWRT


# edited by Sad Pencil at 2021-11-29
# update line WAN6_INTERFACE=$(uci get "network.$WAN6_NAME.device" || uci get "network.$WAN6_NAME.ifname")


START=55

# Options
# -------

# Use temporary addresses (IPv6 privacy extensions) for outgoing connections? Yes: 1 / No: 0
PRIVACY=1

# Maximum number of attempts before this script will stop in case no IPv6 route is available
# This limits the execution time of the IPv6 route lookup to (MAX_TRIES+1)*(MAX_TRIES/2) seconds. The default (15) equals 120 seconds.
MAX_TRIES=15

# An initial delay (in seconds) helps to avoid looking for the IPv6 network too early. Ideally, the first probe is successful.
# This would be the case if the time passed between the system log messages "Probing IPv6 route" and "Setting up NAT6" is 1 second.
DELAY=5

# Logical interface name of outbound IPv6 connection
# There should be no need to modify this, unless you changed the default network interface names
# Edit by Vincent: I never changed my default network interface names, but still I have to change the WAN6_NAME to "wan" instead of "wan6"
WAN6_NAME="wan6"

# ---------------------------------------------------
# Options end here - no need to change anything below

boot() {
 [ $DELAY -gt 0 ] && sleep $DELAY
 WAN6_INTERFACE=$(uci get "network.$WAN6_NAME.ifname")
 logger -t NAT6 "Probing IPv6 route"
 PROBE=0
 COUNT=1
 while [ $PROBE -eq 0 ]
 do
 if [ $COUNT -gt $MAX_TRIES ]
 then
 logger -t NAT6 "Fatal error: No IPv6 route found (reached retry limit)" && exit 1
 fi
 sleep $COUNT
 COUNT=$((COUNT+1))
 PROBE=$(ip -6 route | grep -i '^default.*via' | grep -i -F "dev $WAN6_INTERFACE" | grep -i -o 'via.*' | wc -l)
 done

 logger -t NAT6 "Setting up NAT6"

 if [ -z "$WAN6_INTERFACE" ] || [ ! -e "/sys/class/net/$WAN6_INTERFACE/" ] ; then
 logger -t NAT6 "Fatal error: Lookup of $WAN6_NAME interface failed. Were the default interface names changed?" && exit 1
 fi
 #WAN6_GATEWAY=$(ip -6 route | grep -o '2001.*1102' | sed s'/1102/1101::1/g')
 WAN6_GATEWAY=$(ip -6 route | grep -i '^default.*via' | grep -i -F "dev $WAN6_INTERFACE" | grep -i -o 'via.*' | cut -d ' ' -f 2 | head -n 1)
 if [ -z "$WAN6_GATEWAY" ] ; then
 logger -t NAT6 "Fatal error: No IPv6 gateway for $WAN6_INTERFACE found" && exit 1
 fi
 LAN_ULA_PREFIX=$(uci get network.globals.ula_prefix)
 if [ $(echo "$LAN_ULA_PREFIX" | grep -c -E "^([0-9a-fA-F]{4}):([0-9a-fA-F]{0,4}):") -ne 1 ] ; then
 logger -t NAT6 "Fatal error: IPv6 ULA prefix $LAN_ULA_PREFIX seems invalid. Please verify that a prefix is set and valid." && exit 1
 fi

 ip6tables -t nat -I POSTROUTING -s "$LAN_ULA_PREFIX" -o "$WAN6_INTERFACE" -j MASQUERADE
 if [ $? -eq 0 ] ; then
 logger -t NAT6 "Added IPv6 masquerading rule to the firewall (Src: $LAN_ULA_PREFIX - Dst: $WAN6_INTERFACE)"
 else
 logger -t NAT6 "Fatal error: Failed to add IPv6 masquerading rule to the firewall (Src: $LAN_ULA_PREFIX - Dst: $WAN6_INTERFACE)" && exit 1
 fi

 ip -6 route add 2000::/3 via "$WAN6_GATEWAY" dev "$WAN6_INTERFACE"
 if [ $? -eq 0 ] ; then
 logger -t NAT6 "Added $WAN6_GATEWAY to routing table as gateway on $WAN6_INTERFACE for outgoing connections"
 else
 logger -t NAT6 "Error: Failed to add $WAN6_GATEWAY to routing table as gateway on $WAN6_INTERFACE for outgoing connections"
 fi

 if [ $PRIVACY -eq 1 ] ; then
 echo 2 > "/proc/sys/net/ipv6/conf/$WAN6_INTERFACE/accept_ra"
 if [ $? -eq 0 ] ; then
 logger -t NAT6 "Accepting router advertisements on $WAN6_INTERFACE even if forwarding is enabled (required for temporary addresses)"
 else
 logger -t NAT6 "Error: Failed to change router advertisements accept policy on $WAN6_INTERFACE (required for temporary addresses)"
 fi
 echo 2 > "/proc/sys/net/ipv6/conf/$WAN6_INTERFACE/use_tempaddr"
 if [ $? -eq 0 ] ; then
 logger -t NAT6 "Using temporary addresses for outgoing connections on interface $WAN6_INTERFACE"
 else
 logger -t NAT6 "Error: Failed to enable temporary addresses for outgoing connections on interface $WAN6_INTERFACE"
 fi
 fi

 exit 0
}

执行下面的命令，使脚本开机运行：

1
2


chmod +x /etc/init.d/nat6
/etc/init.d/nat6 enable

修改/etc/sysctl.conf，添加下面的内容：

1
2
3
4


net.ipv6.conf.default.forwarding=2
net.ipv6.conf.all.forwarding=2
net.ipv6.conf.default.accept_ra=2
net.ipv6.conf.all.accept_ra=2

最后在自定义防火墙中添加一行命令：

1

ip6tables -t nat -A POSTROUTING -o $(uci get network.wan6.ifname) -j MASQUERADE

由于硬件的BUG，还需要在开机脚本里添加一条命令，关闭ipv6的硬件加速，不然速度就会其慢无比

1

echo 8 0 > /sys/kernel/debug/hnat/hnat_setting

完成后重启就会发现有ipv6了

然而，在我使用的过程中发现，开启了ipv6后手机打开app时加载的速度肉眼可见的变慢。一开始以为是DNS的问题，但修改了默认的DNS服务器后还是不行。~~为了保证使用的体验，目前我还是把nat6给关闭了😭。~~

已经找到了解决方案😉，见下一节

配置mosdns

mosdns作为一款自定义程度很高的DNS转发器，在之前的博文《自建DNS实现分流及广告过滤》就已经使用过了，这里我们需要他来解决ipv6 NAT后的卡顿问题。同时，配置好mosdns后，也可以实现广告过滤，dns防污染的功能。

安装可以使用luci-app-mosdns这个项目来实现，直接执行它的脚本即可

1

sh -c "$(curl -ksS https://raw.githubusercontent.com/sbwml/luci-app-mosdns/v5/install.sh)"

和之前的方案一样，我们需要以下项目提供的域名/IP文件：

其实luci-app-mosdns默认提供了一套配置，但是我们需要使用mosdns的优先ipv4的功能，所以只能自己撸配置了。没错，解决ipv6卡顿的最好方式就是不用😥，通过mosdns可以避免操作系统使用优先ipv6的策略。这样既实现了不卡顿，又可以访问纯ipv6网站。

这套配置可以实现屏蔽广告，国内域名用本地DNS解析，国外域名走远程DNS解析。遇到不在列表中的域名，会查询本地DNS，如果返回的是国外地址，则以远程DNS的结果为准。

具体的配置如下：

📃展开代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183


# Powered by luoboQAQ
log:
 level: warn
 file: "/tmp/log/mosdns.log"

# API 入口设置
api:
 http: "0.0.0.0:9091"

plugins:
 # 国内域名
 - tag: geosite_cn
 type: domain_set
 args:
 files:
 - "/var/mosdns/direct-list.txt"

 # 国内IP
 - tag: geoip_cn
 type: ip_set
 args:
 files:
 - "/var/mosdns/CN-ip-cidr.txt"

 # 国外域名
 - tag: geosite_no_cn
 type: domain_set
 args:
 files:
 - "/var/mosdns/proxy-list.txt"

 # 黑名单域名
 - tag: blocklist
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/blocklist.txt"

 # 广告域名
 - tag: adlist
 type: domain_set
 args:
 files:
 - "/var/mosdns/ad-domains.txt"

 # PTR黑名单
 - tag: local_ptr
 type: domain_set
 args:
 files:
 - "/etc/mosdns/rule/local-ptr.txt"

 # 缓存插件
 - tag: cache
 type: cache
 args:
 size: 10240
 lazy_cache_ttl: 86400
 # 将缓存保存在磁盘
 dump_file: /tmp/mosdns/cache.dump

 # 转发至本地服务器的插件
 - tag: forward_local
 type: forward
 args:
 upstreams:
 - tag: alidns_dot
 addr: "tls://223.5.5.5"
 - tag: dnspod_dot
 addr: "tls://120.53.53.53"

 # 转发至远程服务器的插件
 - tag: forward_remote
 type: forward
 args:
 upstreams:
 # - tag: easymosdns
 # addr: "https://doh.apad.pro/dns-query"
 # bootstrap: "223.5.5.5"
 - tag: cloudflare_dot
 addr: "tls://1.1.1.1"

 # 国内解析
 - tag: local_sequence
 type: sequence
 args:
 - exec: $forward_local

 # fallback 用本地服务器 sequence
 # 返回不包含本地 ip 则 reject
 - tag: local_ip_sequence
 type: sequence
 args:
 - exec: $forward_local
 - matches: "!resp_ip $geoip_cn"
 exec: drop_resp

 # fallback 用远程服务器 sequence
 - tag: remote_sequence
 type: sequence
 args:
 - exec: $forward_remote

 # fallback插件
 - tag: fallback
 type: fallback
 args:
 primary: local_ip_sequence
 secondary: remote_sequence
 threshold: 500
 always_standby: true

 # 有响应终止返回
 - tag: has_resp_sequence
 type: sequence
 args:
 - matches: has_resp
 exec: accept

 # 查询国内域名
 - tag: query_is_local_domain
 type: sequence
 args:
 - matches: qname $geosite_cn
 exec: $local_sequence

 # 查询国外域名
 - tag: query_is_no_local_domain
 type: sequence
 args:
 - matches: qname $geosite_no_cn
 exec: $remote_sequence

 # 查询拒绝域名
 - tag: query_is_reject_domain
 type: sequence
 args:
 - matches: qname $blocklist
 exec: reject 3
 - matches: qname $adlist
 exec: reject 3
 - matches:
 - qtype 12
 - qname $local_ptr
 exec: reject 3
 - matches: qtype 65
 exec: reject 3

 # 主要运行逻辑插件
 - tag: main_sequence
 type: sequence
 args:
 # 去广告
 - exec: $query_is_reject_domain
 - exec: jump has_resp_sequence

 # ipv4地址优先，避免NAT占用CPU
 - exec: prefer_ipv4

 - exec: $cache
 - exec: jump has_resp_sequence

 - exec: $query_is_local_domain
 - exec: jump has_resp_sequence

 - exec: $query_is_no_local_domain
 - exec: jump has_resp_sequence 

 - exec: $fallback

 # 启动 udp 服务器。
 - tag: udp_server
 type: udp_server
 args:
 entry: main_sequence
 listen: ":5335"

 # 启动 tcp 服务器。
 - tag: tcp_server
 type: tcp_server
 args:
 entry: main_sequence
 listen: ":5335"

配置Wireguard

学院的服务器是在内网中的，如果没有连校园网就无法访问。为了随时随地可以访问，我们可以使用Wireguard进行虚拟组网。基于ipv6直接是公网的特点，我们可以很方便的实现这个功能。

连接路由器，使用命令创建预共享密钥

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 创建目录存放公钥私钥
mkdir wg
# 进入文件夹
cd wg
# 配置创建密钥的权限
umask 077
# 创建预共享密钥
wg genpsk > sharekey
# 获取密钥复制保存
cat sharekey

之后创建服务端公钥私钥

1
2
3
4
5
6


# 创建服务端公钥和私钥
wg genkey | tee server_privatekey | wg pubkey > server_publickey
# 获取服务端私钥复制保存
cat server_privatekey
# 获取服务端公钥复制保存
cat server_publickey

之后创建客户端的公钥私钥，有多少个就要执行几次 注意文件的命名，这里以clinet为例：

1
2
3
4
5
6


# 创建客户端公钥和私钥
wg genkey | tee clinet_privatekey | wg pubkey > clinet_publickey
# 获取客户端私钥复制保存
cat clinet_privatekey
# 获取客户端公钥复制保存
cat clinet_publickey

之后找到网络——接口——添加新接口，选择协议为WireGuard VPN

接着修改相应的配置：

接口基本设置

私钥 - 上文获取的服务端私钥
监听接口 - 随机一个高位的端口，我这里使用10800
IP地址 - 这里填一个专用的网段 IP，我选择192.168.100.1/24

Peers设置

选择预共享密钥 - 添加

公钥 - 填写上文获取的客户端公钥
允许的 IP - 为此客户端分配的固定 IP，我这里是192.168.100.2/32注意不要冲突
预共享密钥 - 填写上文获取的预共享密钥
路由允许的 IP - 勾选

防火墙设置

选择LAN

之前我尝试自己创建一个VPN分区进行管理，但是无法访问路由器上一层内网的地址，估计是防火墙之前的转发规则没设置好，如果不想折腾就选LAN吧

之后在防火墙中的——”打开路由器端口“，将之前设置的WireGuard监听端口的UDP流量放行

这样就算配置好了。

客户端的配置文件类似下面这样：

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


[Interface]
# 对应之前配置的静态地址
Address = 192.168.100.2/32
# 客户端的私钥
PrivateKey = ******
# 本地的 DNS 服务器或者公有 DNS 服务器,例如: 114.114.114.114
#DNS = 192.168.6.1
[Peer]
# 路由器公钥
PublicKey = ******
# 设置那些地址走WireGuard，如下设置只用局域网走WireGuard,互联网走本地网络.
#AllowedIPs = 192.168.6.0/24, 192.168.100.0/24, 192.168.101.0/24
# 全局模式
AllowedIps = 0.0.0.0/0
# 预共享密钥，同之前所配置
PresharedKey = ******
# 路由器的ip地址和端口
Endpoint = 10.134.10.10:10800
# 每隔多少秒检查一次连接
PersistentKeepalive = 25

配置ddns

虽然我们拥有了公网ipv6，但这是动态的，所以我们需要通过ddns使其自动对应到域名上。以后使用的时候只需要域名即可，无需记住ip。

237大佬的固件已经内置了ddns，我的域名是在cloudflare上，所以选择DDNS 服务提供商 [IPv6]为cloudflare.com-v4，域名填写需要ddns的域名，注意这里要用@隔离子域名和根，例如ddns@lbqaq.top，密码填写全局访问密钥。

在高级设置里，我将IP 地址来源 [IPv6]设置为了URL，这样避免了脚本错误读取ip地址的情况。

都设置好后，就可以看到域名所对应的地址已经被更新了。

小结

Openwrt作为一个开放的系统，可玩性还是很高的，通过装上所需的插件，极大的提高了我的上网体验，只能说：真香~

（本来是打算介绍我写的校园网连接程序，结果为了这碟醋包了这盘饺子QwQ）

更新日志

23.11.22：添加了uboot和mosdns的内容

参考文献

Graph Unlearning

Wed, 13 Sep 2023 16:38:20 +0800

介绍

数据保护最近引起了越来越多的关注，并且已经提出了一些法规来保护个人用户的隐私。在这些法规中，提到了「被遗忘权」，它赋予数据主体从存储数据的实体中删除其数据的权利。这也意味着在机器学习中，模型提供者有义务消除其所有者要求被遗忘的数据的任何影响，即遗忘学习。

最简单和有效的遗忘学习方法就是移除对应的样本后重新训练模型，然而当底层数据集很大时，这种方法在计算上可能令人望而却步。目前通用的遗忘学习方法是SISA (Sharded, Isolated, Sliced, and Aggregated) ——将训练集分为shards, shards中分为slices, 对于每个slice训练之后记录model parameters, 每个数据点被划分到不同的shards和slices中, unlearn时就是排除掉对应数据点然后retrain对应的shard和slices, 以空间开销换取训练的时间开销。

对于图像和文本数据，分割数据没有什么问题。然而，对于图来说，GNN依赖于图结构信息，像在SISA中那样将节点随机划分为子图可能会严重损坏生成的模型。对此，作者提出了GraphEraser，以实现GNN中的遗忘学习。

作者将图遗忘学习分为node unlearning「节点遗忘学习」和edge unlearning「边遗忘学习」，提出了两种图分割策略。第一种侧重于graph structural information「图结构信息」，另一种则是同时考虑graph structural and node feature information「图结构和节点特征信息」。

为了同时考虑图结构和节点特征信息，作者将节点特征和图结构转化为嵌入向量，然后将其聚类为不同的shards。但是由于现实世界图的结构特性，传统的群落检测和聚类方法划分会导致分片大小不平衡，而大部分需要被撤销的数据都在最大的分区，从而导致效率低下。作者提出了两种分割算法和一种聚合算法以解决此问题。

贡献

第一次提出了在GNN模型上的遗忘学习方法
提出了两种算法以平衡图分割块大小
提出了一种基于学习的聚合方法

问题构造

问题定义

节点遗忘学习

对于GNN模型$F_o$，每个数据主体的数据对应于GNN训练图$G_o$中的一个节点。数据主体$u$要删除其所有数据，则意味着从GNN的训练图中遗忘学习$u$的节点特征以及其于其他节点的链接。以社交网络为例，节点遗忘学习意味着需要从目标GNN的训练图中删除用户的个人资料信息和社交关系。

边遗忘学习

数据主体$u$要删除其节点于另一个节点$v$之间的一条边缘。仍然以社交网络为例，边缘遗忘意味着社交网络用户想要隐藏他们与另一个人的关系。

评估指标

unlearning efficiency「遗忘学习效率」：与在训练的时间有关，时间要尽可能短。
model utility「模型效用」：与准确性有关，越高越好。

在之前提过，图分割存在分片大小不均匀的问题。为此，作者提出了两种分片目标：

G1: Balanced Shards「均衡分片」：每个分片中的节点数量相似。这样，每个分片的再训练时间是相似的，从而提高了整个图遗忘学习过程的效率。
G2: Comparable Model Utility「可比模型效用」：图结构信息是决定GNN性能的主要因素，每个分片都应保留图的结构属性。

GraphEraser框架构造

作者将GraphEraser框架分为三个阶段：

Balanced Graph Partition「平衡图分区」：将训练图划分为不相交的分片
Shard Model Training「分片训练模型」：对每个分片进行训练一个模型，称之为shard model「分片模型」$F_i$
Shard Model Aggregation「分片模型聚合」：为了得到预测节点$w$的标签，将对应的数据（$w$的特征、其邻居的特征以及其中的图结构）同时发送到所有分片模型，并通过聚合所有分片模型的预测来获得最终预测。

GraphEraser框架的结构图如下所示：

平衡图分割

作者提出了三种图分区策略：

策略0：仅考虑节点特征信息，并随机对节点进行分区

该策略可以满足G1「均衡分片」要求，但不满足G2「可比模型效用」要求
策略1：依靠community detection「社区发现」，仅考虑结构信息，并尽可能保留它
策略2：同时考虑结构信息和节点特征。将节点特征和图结构表示为低维向量，即节点嵌入，然后将节点嵌入聚类到不同的分片中。

直接这样划分会导致划分区域不平衡，如下图所示：

接下来，作者便介绍了对应的平衡图分区算法。

社区发现算法

对于策略1，主要依赖的就是此算法。作者基于Label Propagation Algorithm (LPA)「标签传播算法」来设计图分区算法。在本文中，shard就是community。

标签传播算法

在初始阶段（图a），每个节点都随机分配一个分片标签。

在标签传播阶段（图b → 图 c），每个节点都会发送自己的标签，将自己更新成收到最多的那个标签

标签传播过程会对所有节点进行多次迭代，直到收敛（没有节点更改标签）

就如之前提到的，传统的LPA会导致高度不平衡的图形分区，严重影响了遗忘学习的效率。

对此，作者提出了一个实现平衡图分区的一般方法。给定所需的分片大小$k$和最大分片大小$\delta$，为每个节点-分片定义一个可能被分配到此分片的preference「偏好值」，代表该节点被分配给了分片（这被称为destination shard「目标分片」），从而产生$k \times n$个偏好值。对这些值进行排序，如果目标分片中的节点数不超过$\delta$，就将该节点分配给此分片。

具体而言，作者提出了Balanced LPA (BLPA)「平衡标签传播算法」，将偏好值定义为节点分片对的neighbor counts「邻居计数」（属于目标分片的邻居数量），并且具有较大邻居计数的节点分片对具有更高的优先级分配。

算法的步骤如下：

初始化：将每个节点随机分配给k个分片之一
重新分配配置文件计算：对于每个节点$u$，使用元组$\left\langle u, \mathbb{C}_{s r c}, \mathbb{C}_{d s t}, \xi\right\rangle$表示其重新分配的配置文件，其中$\mathbb{C}_{s r c}$和$\mathbb{C}_{d s t}$是节点$u$的当前分片和目标分片，$\xi$是目标分片$\mathbb{C}_{d s t}$的邻居计数，并将其存入$\mathbb{F}$
排序：邻居数量越多的重新分配配置文件应具有越高的优先级，所以按$\xi$对$\mathbb{F}$进行降序排序
传播标签：枚举$\mathbb{F}$里的所有元素，如果$\mathbb{C}_{d s t}$的大小不超过给定的阈值$\delta$，就将其添加到目标分片并从当前分片中删除。之后在$\mathbb{F}$中删除所有剩余的包含节点$u$的元组。

之后不断迭代，直到分片不更改或达到最大迭代$T$

算法的时间复杂度为$O(n·d_{ave})$，$n$为节点数，$d_{ave}$为训练图的平均节点数。

作者无法从理论上证明其收敛性，不过通过实验表示$T=30$时几乎是收敛的。

嵌入式聚类算法

对于策略2，作者使用预训练的GNN模型来获取所有节点嵌入，然后对生成的节点嵌入执行聚类。

思路是将GNN模型的所有节点投影到空间中，再使用K-Means进行聚类。同样也会导致分块的不平均这个问题。

对此，作者提出了Balanced Embedding k-means (BEKM)。定义preference「偏好值」为节点嵌入和所有节点分片对的分片质心之间的欧氏距离。

具体的算法如下：

初始化：随机选择$k$个质心$C^0=\{C^0_1,C^0_2,\dots,C^0_k\}$
计算嵌入质心距离：计算节点嵌入和质心之间的所有成对距离，从而得到$n\times k$个嵌入质心对。这些对存储在$\mathbb{F}$中。
排序质心距离：距离较近的嵌入质心对具有更高的优先级，所以按照升序对$\mathbb{F}$进行排序
重新分配节点和更新质心：枚举$\mathbb{F}$里的所有元素，如果$\mathbb{C}_{j}$的大小不超过给定的阈值$\delta$，就将其添加到目标分片。之后在$\mathbb{F}$中删除所有剩余的包含节点$i$的元组。最后，将新质心计算为其相应分片中所有节点的平均值。

同样，不断重复直到分片不更改或达到最大迭代$T$

算法的时间复杂度为$O(k·n)$，$n$个节点,$k$个分片。

基于学习的聚合

目前常见的聚合方式有两种：

MajAggr：每个分片模型预测一个标签，取最多预测的标签
MeanAggr：收集所有分片模型的后验向量，然后求平均值，得到聚合后验，选取最高后验值。

作者提出了一种基于学习的聚合方法LBAggr，为每个分片模型分配一个重要性分数，通过以下损失函数进行学习：

$$\min _{\alpha} \underset{w \in \mathcal{G}_{o}}{\mathbb{E}}\left[\mathcal{L}\left(\sum_{i=0}^{m} \alpha_{i} \cdot \mathcal{F}_{i}\left(X_{w}, \mathcal{N}_{w}\right), y\right)\right]+\lambda \sum_{i=0}^{m}\left\|\alpha_{i}\right\|$$

其中$X_{w}$和$\mathcal{N}_{w}$是训练图中节点$w$的特征向量和邻域，$y$是$w$的真实标签，$\mathcal{F}_{i}(\cdot)$表示分片模型$i$，$\alpha_{i}$是$\mathcal{F}_{i}(\cdot)$的重要性得分，$m$是分片总数。将所有重要性分数的总和调节为 1。

作者通过梯度下降来找到最优的$\alpha$，从而解决最优化问题。然而，直接梯度下降会导致$\alpha$为负数。为了解决此问题，作者使用softmax 函数在每次迭代中进行归一化处理。

为了提升运行速度，作者指出可以使用训练图中 10% 的节点进行重新训练。

GraphEraser

将上面提到的方法集合在一起，就得到了此算法。当某些节点或边缘被数据所有者撤销时，只需要重新训练相应的分片模型即可。

评估

数据集

作者采用了五个常用的图像数据集，分别为Cora, Citeseer, Pubmed, CS和Physics。

模型

作者在四个GNN模型上进行了测试，分别是SAGE，GCN，GAT和GIN。每个模型都经过100轮的训练，默认学习率设置为0.01，权重衰减为0.001。

指标

在问题构造中提过，就是遗忘学习效率和模型效用

遗忘学习效率：计算100个独立遗忘学习请求的平均遗忘学习时间。
模型效用：使用F1得分

基线

Scratch「从头开始训练」
Random「随机分区」

实验设置

将整个图分为两个不相交的部分，其中80%的节点用于训练GNN模型，20%的节点用于评估模型效用。

分片大小$k$设为20, 20, 50, 30, 和 100

片中节点最大个数$\delta$设为$\left \lceil \frac{n}{k} \right \rceil $

最大迭代次数$T$设为30

BLPA对应社区发现算法；BEKM对应嵌入式聚类算法

遗忘学习效率评估

如图所示，BLPA和BEKM相对于从头训练模型，可以显著的减少训练的时间。

相对于Random，时间略长是因为存在更长的图分割成本。BLPA 和 BEKM 都需要多次迭代以保留结构信息。但一旦完成图分割，就会将其固定下来。从这个意义上说，我们可以容忍这种代价，因为它只执行一次。

模型效用评分

绿色底色表示不需要聚合，红色底色表示作者提出的方法，蓝色字体表示最优得分。

有些随机得分和BLPA和BEKM差不多，作者认为这时由于图结构信息在GNN模型中作用不大导致的。

对此，作者提出了一个方法选择的技巧：可以首先比较MLP和GNN的F1分数，如果MLP和GNN之间的F1分数差距很小，随机方法可能是一个不错的选择，因为它更容易实现，并且可以实现与BLPA和BEKM相当的模型效用。否则，BLPA和BEKM是更好的选择，因为更好的模型实用程序。

如果 GNN 遵循 GCN 结构，则可以选择BLPA，否则可以采用 BEKM。这是因为 GCN 模型需要节点度信息来进行归一化，而BLPA 可以保留更多的局部结构信息，从而更好地保留节点度。

BEKM 在 Cora 数据集和 GIN 模型上的 F1 得分为 0.801，而 Scratch 的相应 F1 得分为 0.787。作者认为有两种可能的原因：抽样往往可以消除数据集中的一些“噪声”；其次，GraphEraser通过聚合所有子模型的结果来进行最终预测，从这个意义上说，GraphEraser执行集成，这是提高模型性能的另一种方法。

LBAggr 的效果

有效，可以提升F1分数。

比较不同的GNN模型，GCN从LBAggr中受益最大，而GIN受益最少。在模型效用方面，GraphEraser-BLPA方法从LBAggr中受益最大。我们推测这是因为BLPA划分方法可以捕获局部结构信息，同时丢失训练图的一些全局结构信息。

为了进一步提高忘却效率，可以使用训练图中的一小部分节点来学习重要性分数。这样做可以有效地减少 LBAggr 的遗忘学习时间。使用 10% 的节点和使用固定数量的 1，000 个节点都可以实现与使用所有节点相当的模型效用。

和其他遗忘学习方法对比

同样，也是作者的方法比较好。

浪潮人工智能平台使用心得

Sun, 03 Sep 2023 14:10:14 +0800

随着学习的深入，对算力的要求越来越高。但我实验室的电脑并没有配置显卡，所以便需要使用学院的服务器。成功拿到账号后，却发现这个平台并没有我想象的那么好用😇为了达到最舒适的使用体验，开搞！

配置开发镜像

平台里虽然预置了一些开发环境，但仍然缺少一些需要的软件，每次连入后再重新安装实在是不优雅。那么最好的方案就是配置好一套环境，直接拉取就能使用。在我之前，已经有位大佬构建了一套开发环境并进行了分享，可是镜像大小达到了惊人的18.4G😯（容量大说明功能多，此处并没有贬低的意思）。我个人比较喜欢Arch的哲学，即Keep It Simple, Stupid（对应中文为“保持简单，且一目了然”）。为此，我决定构建一个最小化的开发环境且可以开箱即用。

通过探究发现，这个平台上所有的开发环境都是一个Docker容器。所以，我们只要构建好镜像并上传就OK了。构建镜像有两种方式，一种是进入容器手动配置然后使用docker commit ...保存修改；另一种则是使用Dockerfile。为了便于维护和修改，我选择了第二种。

接下来就是明确需求了，我对其的要求有几点：

安装好显卡驱动，可以直接使用cuda
安装好conda，可以便捷的管理python开发环境
有一个易用的终端，方便调试

cuda很好解决，直接在nvidia官方的镜像上进行修改就行了

对于conda，原版的Anaconda过于臃肿，不符合KISS原则。同时，当环境复杂(conda和pip混用)时，solving environment这一步可以卡到你怀疑人生，于是我选择了使用C++重构的mamba，并选择micromamba进一步压缩体积。

对于终端，那就无脑使用zsh并加载oh-my-zsh并安装我日常使用的插件。

如此一来，就可以开写Dockerfile了。

📃展开代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


# base image
FROM nvidia/cuda:11.3.1-cudnn8-runtime-ubuntu20.04

MAINTAINER luoboQAQ

# 设置国内镜像源并安装软件
RUN set -ex \
 && sed -i 's@/archive.ubuntu.com/@/mirrors.bfsu.edu.cn/@g' /etc/apt/sources.list \
 && apt-get clean \
 && apt-get update \
 && apt-get install -y --no-install-recommends openssh-client openssh-server git zsh curl vim \
 && rm -rf /var/lib/apt/lists/* 

# 配置openssh[https://github.com/wjyzzu/inpsur-dockerfile/blob/main/base/ubuntu/Dockerfile]
RUN set -ex \
 && mkdir -p /var/run/sshd \
 && /usr/bin/ssh-keygen -A \
 && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
 && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
 && cat /etc/ssh/sshd_config | grep -v PermitRootLogin> /etc/ssh/sshd_config.new \
 && echo "PermitRootLogin yes" >> /etc/ssh/sshd_config.new \
 && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
 && mv /etc/ssh/sshd_config.new /etc/ssh/sshd_config

# 配置oh-my-zsh
RUN set -ex \
 && git clone https://gitee.com/mirrors/oh-my-zsh ~/.oh-my-zsh \  
 && cp ~/.oh-my-zsh/templates/zshrc.zsh-template ~/.zshrc \
 && git clone https://gitee.com/lightnear/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting \
 && sed -i "s/plugins=(git.*)$/plugins=(git zsh-syntax-highlighting)/" ~/.zshrc \
 && chsh -s /bin/zsh \
 && rm -rf /var/lib/apt/lists/*

# 安装micromamba并配置国内源
RUN set -ex \
 && curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj bin/micromamba \
 && ./bin/micromamba shell init -s zsh -p ~/micromamba \
 && echo "\nalias conda='micromamba'" >> ~/.zshrc \
 && echo "channels: \n\
 - defaults \n\
show_channel_urls: true \n\
default_channels: \n\
 - https://mirrors.bfsu.edu.cn/anaconda/pkgs/main \n\
 - https://mirrors.bfsu.edu.cn/anaconda/pkgs/r \n\
 - https://mirrors.bfsu.edu.cn/anaconda/pkgs/msys2 \n\
custom_channels: \n\
 conda-forge: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 msys2: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 bioconda: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 menpo: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 pytorch: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 pytorch-lts: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 simpleitk: https://mirrors.bfsu.edu.cn/anaconda/cloud \n\
 deepmodeling: https://mirrors.bfsu.edu.cn/anaconda/cloud/" > ~/.condarc \
 && echo "[global] \n\
index-url = https://mirrors.bfsu.edu.cn/pypi/web/simple" > /etc/pip.conf

# 配置网络代理
RUN set -ex \
 && echo "\nexport HTTP_PROXY='http://127.0.0.1:3128'" >> ~/.zshrc \
 && echo "export HTTPS_PROXY='http://127.0.0.1:3128'" >> ~/.zshrc \
 && echo "export ALL_PROXY='http://127.0.0.1:3128'" >> ~/.zshrc

EXPOSE 22
WORKDIR /root
ENTRYPOINT ["/bin/zsh"]

除了上面提到的几点，我还增加了：

镜像已配置好国内镜像源，方便构建以及使用时安装新的包
配置openssh，使其可以被浪潮平台接入并提供SSH服务
预先安装好vim，便于配置文件的修改
提前设置好网络代理，便于连接互联网
设置别名：conda->micromamba，方便日常使用

由于服务器没有网络，需要我们手动上传镜像，使用命令docker save -o [TAGS]打包成tar包并上传至系统中。

小结

希望这篇文章可以帮助大伙快速上手该平台，毕竟有这么好的资源就要好好利用起来。

从零开始编写Xposed模块

Fri, 21 Jul 2023 14:22:44 +0800

之前写过一篇关于Magisk模块的编写的文章，不过Magisk修改的都是比较偏系统的，一般情况下用的并不是很多。于是我便把目光转向Xposed，毕竟会Hook真的太酷辣😎

Xposed的基本概念

提到Xposed，爱玩机的用户都应该听过他的大名，作为一款可以在不修改APK的情况下影响程序运行的框架，可以基于它可以制作出许多功能强大的模块，且在功能不冲突的情况下同时运作。微信防撤回、步数修改、去广告、美化…….他能实现许许多多的功能，可以说没有它玩机的世界将会少很多的乐趣。

它的原理就是通过替换系统原本的app_process，加载一个额外的jar包，从而实现对zygote进程及其创建的Dalvik/ART虚拟机的劫持。

没听懂？没关系，~~我也不懂~~。目前我们只要关注如何使用即可了，至于原理可以先放一放。

环境准备

在开始之前，我们需要：

一台可以安装Xposed框架的手机（推荐LSPosed、Android 10+）
一台可以编写代码并且装有jdk的电脑
一个名叫Android Studio的软件（我主打一个叛逆，用IDEA同样可以）
一个反编译软件，如：JADX
一个可以查看布局的App，如：开发者助手

这次我打算从一个实例出发：小明手机上装了一些恶意软件，我们需要通过Xposed进行Hook，不让小明启动这些软件。

准备工作

创建项目&引入依赖

首先在IDEA选择新建项目，可以看到生成器下有Android这项，我们选择它。

第一次选择时可能会要求你下载安卓的SDK，按照指示一步一步进行就好。

Java

我们选择创建一个No Activity，语言选择Java，SDK选默认的API 24就可。

然后，我们需要引入Xposed的库，不过它并没有上传到MavenCentral上，所以我们需要在settings.gradle里修改一下(gradle 7.0+)

打开settings.gradle，添加一行代码

1
2
3
4
5
6
7
8


dependencyResolutionManagement {
 repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
 repositories {
 google()
 mavenCentral()
 maven { url 'https://api.xposed.info/' } // 添加这一行即可
 }
}

之后，进入我们app目录下的build.gradle，引入xposed的依赖

1
2
3
4


dependencies {
 compileOnly 'de.robv.android.xposed:api:82' //添加我
 // compileOnly 'de.robv.android.xposed:api:82:sources' // 不要导入源码，这会导致idea无法索引文件，从而让语法提示失效
}

我们还要在./app/src/main/res/values目录下创建arrays.xml，填入下面的内容：

1
2
3
4
5
6
7
8


<resources>
 <string-array name="xposedscope" >
 <!-- 这里填写模块的作用域应用的包名，可以填多个。 -->
 <item>ceui.lisa.pixiv</item>
 <item>com.xjs.ehviewer</item>
 <item>com.picacomic.fregata</item>
 </string-array>
</resources>

这一步主要是指定模块的作用域包名，效果就是在Lsposed中勾选作用域时会在应用下提示推荐应用。

最后，我们在Run那里编辑一下启动配置，勾选Always install with package manager并且将Launch Options改成Nothing

Kotlin

创建项目的部分和Java的设置没有什么区别，只不过是需要将语言切换一下。新版本的Android Studio将原来的打包语言换成了Kotlin，所以我们的设置有一些不一样的地方。2024.09.15更新

原来的settings.gradle变为settings.gradle.kts

1
2
3
4
5
6
7
8


dependencyResolutionManagement {
 repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
 repositories {
 google()
 mavenCentral()
 maven { url = uri("https://api.xposed.info/") } //添加这一行
 }
}

原来的build.gradle变为build.gradle.kts

1
2
3


dependencies {
 compileOnly("de.robv.android.xposed:api:82") //添加我
}

声明模块

接下来就是要声明我们是一个Xposed模块，方便框架发现。

在./app/src/main/AndroidManifest.xml里，我们将<application ... />改成以下形式（注意，是改成！就是把结尾的/>换成> </application>）

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


<application ... >
 <!-- 是否是xposed模块，xposed根据这个来判断是否是模块 -->
 <meta-data
 android:name="xposedmodule"
 android:value="true" />
 <!-- 模块描述，显示在xposed模块列表那里第二行 -->
 <meta-data
 android:name="xposeddescription"
 android:value="不可以涩涩" />
 <!-- 最低xposed版本号(lib文件名可知,一般填54即可) -->
 <meta-data
 android:name="xposedminversion"
 android:value="54" />
 <!-- 模块作用域 -->
 <meta-data
 android:name="xposedscope"
 android:resource="@array/xposedscope"/>
 </application>

然后在src/main目录下创建一个文件夹名叫assets，并且创建一个文件叫xposed_init，注意，它没有后缀名！！。

接着我们需要创建一个入口类，名叫MainHook（或者随便你想取什么名字都行），创建好后回到我们的xposed_init里并用文本文件的方式打开它，输入我们刚刚创建的类的完整路径。如：top.lbqaq.nosese.MainHook，同时注意大小写。

完成以上步骤后，我们就可以正式开始编写Xposed模块了。

模块编写

MainHook

在MainHook里，我们需要实现Xposed的IXposedHookLoadPackage接口，以便执行Hook操作。将以下内容替换原来的类

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


import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class MainHook implements IXposedHookLoadPackage {
 @Override
 public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
 // 过滤不必要的应用
 if (!lpparam.packageName.equals("ceui.lisa.pixiv")) return;
 // 执行Hook
 hook(lpparam);
 }

 private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
 // 具体流程
 }
}

对于Kotlin，代码如下：

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


import de.robv.android.xposed.IXposedHookLoadPackage
import de.robv.android.xposed.callbacks.XC_LoadPackage

class MainHook : IXposedHookLoadPackage {
 override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
 // 过滤不必要的应用
 if (lpparam.packageName != "ceui.lisa.pixiv") return
 // 执行Hook
 hook(lpparam)
 }

 private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
 // 具体流程
 }
}

到这里，我们的准备工作已经完成，安装模块并在框架中激活它！

阻止应用启动

接下来，我们需要反编译程序来找到需要Hook的点。根据实例的要求，我们需要阻止小明启动某些应用。那么，我们只需要Hook启动函数，让其无法运行即可。

在此之前，我们要先了解Android的四大组件之一——“Activity(活动)”

在应用中的一个Activity可以用来表示一个界面，意思可以理解为“活动”，即一个活动开始，代表 Activity组件启动，活动结束，代表一个Activity的生命周期结束。一个Android应用必须通过Activity来运行和启动，Activity的生命周期交给系统统一管理。

函数名称	描述
onCreate()	一个Activity启动后第一个被调用的函数，常用来在此方法中进行Activity的一些初始化操作。例如创建View，绑定数据，注册监听，加载参数等。
onStart()	当Activity显示在屏幕上时，此方法被调用但此时还无法进行与用户的交互操作。
onResume()	这个方法在onStart()之后调用，也就是在Activity准备好与用户进行交互的时候调用，此时的Activity一定位于Activity栈顶，处于运行状态。
onPause()	这个方法是在系统准备去启动或者恢复另外一个Activity的时候调用，通常在这个方法中执行一些释放资源的方法，以及保存一些关键数据。
onStop()	这个方法是在Activity完全不可见的时候调用的。
onDestroy()	这个方法在Activity销毁之前调用，之后Activity的状态为销毁状态。
onRestart()	当Activity从停止stop状态恢进入start状态时调用状态。

当 Activity 进入新状态时，系统会调用其中每个回调。

那么，我们的思路就很明确了：只要找到这些程序的起始Activity，并Hook它的onCreate()函数，在其启动时就将其杀死，这样能实现无法启动该程序。

我们使用开发者助手，选择布局查看，然后打开目标应用。可以看到，它显示了当前的包名和当前Activity。

接下来，我们使用jadx-gui，反编译该应用，找到该Activity(ceui.lisa.activities.MainActivity)，并寻找是否有onCreate()函数，如果存在直接Hook即可。

然而，这个程序居然没有😥，说明它没有重写该方法，那该如何做呢？这时就可以用第二种方法了。

遍历所有类下的所有方法

从标题就能看出来，我直接把你所有能Hook的方法全部读出来，那不就随便我挑了嘛。

我们知道，Java程序都运行在jvm虚拟机中，jvm虚拟机通过ClassLoader动态装载所需的class。那么，我们直接Hook ClassLoader ，不就知道你有哪些方法被加载进来了。

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


public void hook(XC_LoadPackage.LoadPackageParam lpparam) {
 XposedHelpers.findAndHookMethod(ClassLoader.class, "loadClass", String.class, new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param) throws Throwable {
 super.afterHookedMethod(param);
 Class clazz = (Class) param.getResult();
 String clazzName = clazz.getName();
 //排除非包名的类
 if(clazzName.contains("ceui.lisa")){
 Method[] mds = clazz.getDeclaredMethods();
 for(int i =0;i<mds.length;i++){
 final Method md = mds[i];
 int mod = mds[i].getModifiers();
 //去除抽象、native、接口方法
 if(!Modifier.isAbstract(mod)
 && !Modifier.isNative(mod)
 &&!Modifier.isAbstract(mod)){
 XposedBridge.hookMethod(mds[i], new XC_MethodHook() {
 @Override
 protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
 super.beforeHookedMethod(param);
 Log.d("lbqaq",md.toString());
 }
 });
 }
 }
 }
 }
 });
}

（PS：这个程序很奇怪，包名有pixiv，但类名没有，所以用ceui.lisa.pixiv会报空指针异常）

将上面这段代码复制到之前写好的MainHook中去，编译推送到手机。

在终端执行adb logcat "lbqaq:D *:S"开启logcat并进行过滤。

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


❯ adb logcat "lbqaq:D *:S"
--------- beginning of main
07-21 10:49:48.185 5050 5050 D lbqaq : public void ceui.lisa.activities.Shaft.onCreate()
07-21 10:49:48.194 5050 5050 D lbqaq : private void ceui.lisa.activities.Shaft.updateTheme()
07-21 10:49:48.216 5050 5050 D lbqaq : public static android.content.Context ceui.lisa.activities.Shaft.getContext()
07-21 10:49:48.238 5050 5050 D lbqaq : protected int ceui.lisa.activities.MainActivity.initLayout()
07-21 10:49:48.238 5050 5050 D lbqaq : public boolean ceui.lisa.activities.MainActivity.hideStatusBar()
07-21 10:49:48.276 5050 5050 D lbqaq : protected void ceui.lisa.activities.MainActivity.initView()
07-21 10:49:48.276 5050 5050 D lbqaq : public static com.tencent.mmkv.MMKV ceui.lisa.activities.Shaft.getMMKV()
07-21 10:49:48.276 5050 5050 D lbqaq : private void ceui.lisa.activities.MainActivity.initDrawerHeader()
07-21 10:49:48.278 5050 5050 D lbqaq : public androidx.drawerlayout.widget.DrawerLayout ceui.lisa.activities.MainActivity.getDrawer()
07-21 10:49:48.279 5050 5050 D lbqaq : protected void ceui.lisa.activities.MainActivity.initData()
07-21 10:49:48.279 5050 5050 D lbqaq : private void ceui.lisa.activities.MainActivity.initFragment()

可以看到该程序的调用方法。这里，我们选择靠后的ceui.lisa.activities.MainActivity.initFragment()作为我们的Hook目标。

为什么要选择靠后的方法作为我们的Hook目标呢？

这是由于如果选择较前的方法，有些变量还没初始化完成，这时调用finish()可能会报错。

Hook activity

我们使用最基础的hook方式，即Xposed自带的XposedHelpers.findAndHookMethod，使用方法如下：

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


private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
 // 它有两个重载，区别是一个是填Class，一个是填ClassName以及ClassLoader
 // 第一种 填ClassName
 XC_MethodHook.Unhook unhook = XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.MainActivity", // className
 lpparam.classLoader, // classLoader 使用lpparam.classLoader
 "onCreate", // 要hook的方法
 Bundle.class, // 要hook的方法的参数表，如果有多个就用逗号隔开 
 new XC_MethodHook() { // 最后一个填hook的回调
 @Override
 protected void beforeHookedMethod(MethodHookParam param) {} // Hook方法执行前 
 @Override
 protected void afterHookedMethod(MethodHookParam param) {} // Hook方法执行后
 });
 // 它返回一个unhook 在你不需要继续hook的时候可以调用它来取消Hook
 unhook.unhook(); // 取消空的Hook 

 // 第二种方式 填Class
 // 首先你得加载它的类 我们使用XposedHelpers.findClass即可 参数有两个 一个是类名 一个是类加载器
 Class<?> clazz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader);
 XposedHelpers.findAndHookMethod(clazz, "onCreate", Bundle.class, new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param){
 // 由于我们需要在Activity创建之后再弹出Toast，所以我们Hook方法执行之后
 Toast.makeText((Activity) param.thisObject, "模块加载成功！", Toast.LENGTH_SHORT).show();
 }
 });
}

根据上面的示例，我们就可以写出对应的方法了。那么，我们该如何结束这个程序呢？在前面我们介绍了Activity的生存周期，通过查询可知Activity存在一个关闭的方法finish()。所以我们只要手动调用即可，具体的代码如下。

1
2
3
4
5
6
7
8
9


if (lpparam.packageName.equals("ceui.lisa.pixiv")){
 XposedHelpers.findAndHookMethod("ceui.lisa.activities.MainActivity", lpparam.classLoader, "initFragment", new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param) throws Throwable {
 Toast.makeText((Activity) param.thisObject, "不许涩涩！", Toast.LENGTH_SHORT).show();
 ((Activity) param.thisObject).finish();
 }
 });
}

同样，另外两个应用也可以通过这种方式实现

1
2
3
4
5
6
7
8
9


if(lpparam.packageName.equals("com.xjs.ehviewer")){
 XposedHelpers.findAndHookMethod("com.hippo.ehviewer.ui.MainActivity", lpparam.classLoader, "initUserImage", new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param) throws Throwable {
 Toast.makeText((Activity) param.thisObject, "不许涩涩！", Toast.LENGTH_SHORT).show();
 ((Activity) param.thisObject).finish();
 }
 });
}

1
2
3
4
5
6
7
8
9


if(lpparam.packageName.equals("com.picacomic.fregata")){
 XposedHelpers.findAndHookMethod("com.picacomic.fregata.activities.SplashActivity", lpparam.classLoader, "onCreate", Bundle.class ,new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param) throws Throwable {
 Toast.makeText((Activity) param.thisObject, "不许涩涩！", Toast.LENGTH_SHORT).show();
 ((Activity) param.thisObject).finish();
 }
 });
}

这里要注意，使用findAndHookMethod时要hook的方法的参数表一定要填对。如果没有填对就会报java.lang.NoSuchMethodError错误。我之前被这个问题折磨了很久😭（仔细想想也是这样，Java里有重载机制，参数不同就不是同一个方法了）

kotlin所对应的代码如下：

1
2
3
4
5
6
7
8
9


if (lpparam.packageName == "com.xjs.ehviewer"){
 XposedHelpers.findAndHookMethod("com.hippo.ehviewer.ui.MainActivity", lpparam.classLoader, "initUserImage",object : XC_MethodHook() {
 override fun afterHookedMethod(param: MethodHookParam){
 Toast.makeText(param.thisObject as Activity,"不许涩涩！",Toast.LENGTH_SHORT).show()
 (param.thisObject as Activity).finish()
 }
 })
}

修改内部参数

虽然一股脑关闭程序非常简单，但小明不乐意了。对于ceui.lisa.pixiv来说，只有长按头像才会触发，直接一刀切实在是太粗暴了。没问题，直接安排上。

首先我们要定位到这个切换的方法究竟在哪？仔细观察，每次切换都会弹出一个颜文字的Toast，我们就从此处切入。这两个颜文字分别为ԅ(♡﹃♡ԅ)和X﹏X。

我们使用jadx-gui反编译程序，全局搜索，直接就找到了所在位置。

双击查看此处的代码，坏起来了，这是一个匿名函数，根据上面的方法，我们没有这个函数名，自然也就无法对其进行Hook。

难道就要卡在这里了吗？~~如果真是这样我就不会写这篇文章了~~

仔细分析这段代码，这里对this.userHead设置了一个OnLongClickListener。一个控件只能绑定一个侦听器，所以我们可以进行一个替换，不就实现对其的Hook了吗😎

直接Hook initView这个方法：

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


if (lpparam.packageName.equals("ceui.lisa.pixiv")){
 XposedHelpers.findAndHookMethod("ceui.lisa.activities.MainActivity", lpparam.classLoader, "initView", new XC_MethodHook() {
 @Override
 protected void afterHookedMethod(MethodHookParam param) throws Throwable {
 Field f = param.thisObject.getClass().getDeclaredField("userHead");
 f.setAccessible(true);
 ImageView v = (ImageView) f.get(param.thisObject);
// v.setLongClickable(false); //设置其无法响应
 v.setOnLongClickListener(v1 -> {
 Toast.makeText((Activity) param.thisObject, "不许涩涩！", Toast.LENGTH_SHORT).show();
 return true;
 });
 }
 });
}

我们这里使用了Java的反射机制，拿到了它内部的变量userHead，然后通过setAccessible将其设置为可访问。这样我们就能对其私有变量进行修改了。

我们可以简单的将其可点击关闭，但是这样一点也不酷。我直接使用自己的函数将其进行替换，这样每次点击都会出现一个Toast。

kotlin的代码如下：

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


if (lpparam.packageName == "ceui.lisa.pixiv"){
 XposedHelpers.findAndHookMethod("ceui.lisa.activities.MainActivity", lpparam.classLoader, "initView",object : XC_MethodHook() {
 override fun afterHookedMethod(param: MethodHookParam){
 val f = param.thisObject.javaClass.getDeclaredField("userHead")
 f.isAccessible = true
 val v = f[param.thisObject] as ImageView
 v.setOnLongClickListener{
 Toast.makeText(param.thisObject as Activity,"不许涩涩！",Toast.LENGTH_SHORT).show()
 true
 }
 }
 })
}

至此，一个简单的Xposed模块就写好了。

配置文件读取

现在的模块往往还会搭配一个UI来实现配置文件的设置，在安卓开发中，常用SharedPreferences来实现配置的保存。随着google的更新，现在的配置文件无法设置MODE_WORLD_READABLE的权限，即只允许本应用读取。虽然Xposed本身提供了XSharedPreferences来读取配置文件，然而模块是依附于宿主程序所执行的，它的访问权限和宿主一致，所以无法访问到我们的配置文件。2024.09.15更新

好在目前常用的框架LSPosed提供了New XSharedPreferences，我们只需要指定xposedAPI的最低版本≥93就可以了。

在AndroidManifest.xml里将xposedminversion的值改为93

对于模块的Activity来说，我们只需要指定权限为Context.MODE_WORLD_READABLE即可

1

val sharedPreferences : SharedPreferences = getSharedPreferences("config", Context.MODE_WORLD_READABLE)

对于hook的应用来说，我们使用原来的XSharedPreferences即可

1

val xsp = XSharedPreferences("top.lbqaq.nosese","config")

结语

完整的项目代码可以在Github仓库中查看，通过这次的编写，我发现Xposed实际上还是一个工具，想要实现去广告等功能，都是通过反编译来找到突破口，有了Hook的目标后才需要Xposed。

所以，之后的学习还是要以安卓逆向为主，只有打好基本功，才能写出优秀的代码。

后续更新

2024.09.15

将项目使用了目前流行的Kotlin重构了一波，并添加了UI和模块的配置读取的内容

参考文献

APMSA: Adversarial Perturbation Against Model Stealing Attacks

Thu, 20 Jul 2023 14:57:05 +0800

介绍

在大数据时代，机器学习（ML）为我们的生活提供了便利，并在各个领域发挥着不可或缺的作用。随着深度学习应用场景的丰富和数据的增长，主流云提供商（如谷歌、亚马逊和微软）推出了机器学习即服务（MLaaS）。

MLaaS

顾名思义，MLaaS是一系列提供机器学习工具作为云计算服务一部分的服务。这些服务的主要吸引力在于，就像其他任何云服务一样，客户无需安装软件或配置自己的服务器即可快速开始机器学习。它帮助资源和专业知识有限的数据所有者（小型企业或个人）解决数据处理、模型训练和评估等基础设施问题。模型提供者通过根据查询时间向用户收费来获得收益。

然而，MLaaS却容易受到模型提取攻击的影响。如下图所示，虽然模型托管在安全的云服务中，客户通过基于云的API进行查询。但是，攻击者可以基于预测输出来训练具有目标私有模型类似功能的替代模型。用户可以通过访问替代模型而无需向模型提供者付费，从而破坏了其商业价值。此外，攻击者还可以利用替代模型来制作优秀的可转移对抗性示例，从而有效地欺骗原始模型做出错误的预测，构成严重的安全威胁。

作者提出了APMSA来防御模型提取攻击。当攻击者窃取服务器中部署的 “model under attack” (MUA) 时，通过发散给定特定类别的特征空间中查询样本的置信向量距离，就会泄露足够的MUA内部信息，有利于替代模型的训练。对此，作者在MUA 之前将微妙的噪声注入每个传入的输入查询中，以限制其置信向量的多样性。

贡献

通过建设性地最小化对训练替代模型至关重要的发散置信度信息来禁用被盗模型的可用功能。
通过形式化的优化实现了置信向量对 MUA 决策边界的限制。
APMSA不会对具有硬标签推理的普通用户造成效用损失

问题构造

威胁模型

假设攻击者不了解系统的模型体系结构。攻击者只能通过迁移学习发起攻击，即攻击者使用恶意样本查询黑盒模型，以标记这些将用于训练替代模型的样本。攻击者从公众中识别预训练模型，并基于预训练模型通过迁移学习构建替代模型;训练数据集是通过 MUA 上的查询的一组输入输出对。具体算法如下：

攻击者只能通过 API 与模型交互，查询次数受预算限制。但是，他们可以自由选择任何样本进行查询（即未标记的公共数据集$X_{pub}$）。因此，攻击者完全了解输入（即样本类型）和输出（即标签集）的特征。但是，攻击者只能观察返回的预测置信向量，而不能观察模型架构和梯度信息。

攻击者旨在获得与私有模型$f$具有相似功能的替代模型$f’$。替代模型$f’$在公共数据集 $\mathbf{S}\subseteq\mathbf{X}_{pub}$ 的子集上进行训练：

$$f^{\prime}\approx\arg\min\mathcal{L}\left(\{(\mathbf{x},f(\mathbf{x})):\mathbf{x}\in\mathbf{S}\},f^{\prime}(\mathbf{x})\right)$$

防御者旨在将噪声注入每个查询的输入中，以间接干扰模型返回的预测。APMSA有两个主要目标。一方面，保留了模型的精度，即不使用APMSA时的精度应与原始精度相同。另一方面，被盗模型的准确性在很大程度上被破坏，使攻击者的免费私人查询不再有效。作者将使用 APMSA 前后模型准确性的下降程度作为指标。

APMSA的概述

APMSA的直觉是如果防御者策略性地混淆输入查询与其返回的置信度（向量）的输出之间的映射关系，则当攻击者利用这样的输入-输出对来训练其替代模型时，对攻击者有用的泄漏信息将被最小化甚至误导。

上图是APMSA的流程。当向API查询输入时，APMSA不直接将该输入馈送到模型并返回置信向量。相反，APMSA通过将对抗性噪声扰动注入到输入中来将该输入转换为对抗性输入。模型最终返回的是变换后的对抗性输入相对应的置信度向量。从攻击者的角度来看，其输入与返回的置信向量之间的关系映射已经被混淆。并且将给定类别样本的置信度向量约束在一个小的区域内，从而大大减少了泄漏信息，便于其替代模型的训练。同时，由于APMSA不会修改输入的硬标签，所以对于普通用户来说性能几乎没有损失。值得注意的是，APMSA是作为插件使用，不需要修改模型。

APMSA的实现

作者在此用一个例子来解释了APMSA。假设有一个二分类模型（性别分类），如果模型将$k$个男性类别的图像映射到$k$个不同的概率分布，则在给定不同分布的情况下，$k$个输入-输出对的映射关系将揭示更多关于模型的内部信息。（如图a所示）但是，如果控制$k$个不同的男性图像映射到特征空间中的相邻区域，则泄露的信息将大大减少。此外，这些混淆的输入-输出对将在很大程度上误导训练替代模型。（如图b所示）

也就是说如果输出都堆在一起，就可以混淆输入和输出之间的关系，并且可以更好地保护模型的隐私。

作者随后介绍了APMSA的详细原理。同样是以二分类的模型为例，$f$是原模型，$f’$是攻击者得到的替代模型。其中，攻击者利用查询$x$来获得预测$y=f(x)$，其中$y=\{y_1,y_2\}$，攻击者使用$(x,y)$来训练替代模型。APMSA则是通过将向输入空间中的$x$添加对抗性噪声来将样本$x$变为混淆样本$x_c$。这里应用了制作对抗性样本$x’$的技术。与$x’$不同的是，$x_c$的硬标签与APMSA中的$x$的硬标签相同。这样，攻击者通过$\{x,y_c=f(x_c)\}$训练出来的模型$f’$决策边界就会导致$x_t$被误分类，从而防止模型窃取攻击。

与传入的查询输入$x$相比，经变换的对抗输入$x_c$接近决策边界。作者将其转化成了一个优化问题：

混淆的输入$x’$与其对应的对抗示例$x_c$在特征空间中相似，但$x_c$的硬标签与原始输入$x$的类别相同
混淆输入$x_c$和原始输入$x$的置信向量之间的间隙应尽可能小

将其公式化表示为：

$$\begin{aligned}\mathcal{L}_1&=J\left(\mathbf{x}_c\right)=J(\mathbf{x}+\delta)\\&=\min_\delta\max\left(Z(\mathbf{x}+\delta)_s-Z(\mathbf{x}+\delta)_t,0\right)\end{aligned}$$

其中$Z(x_c)_t$表示目标类别$t$的对数值，$Z(x_c)_s$表示原类别$s$。

如果使$Z(x_c)_s-Z(x_c)_t$变小，就表明指定类别的对数值和源类别之间的差距越来越大，则混淆输入$x_t$更接近目标类别的对抗样本。作者提出了新的约束来提高优化速度。

$$\begin{cases}\mathcal{L}_2=Clip_{(0,\infty)}\left(\max\left\{Z(\mathbf{x}+\delta)_i:i\neq t,o\right\}-Z(\mathbf{x}+\delta)_t\right)\\ \mathcal{L}_3=Clip_{(0,\infty)}\left(\max\left\{Z(\mathbf{x}+\delta)_i:i\neq t,s\right\}-Z(\mathbf{x}+\delta)_s\right)\end{cases}$$

其中$Clip(·)$表示范围约束。

为了确保 APMSA 不会影响模型的性能（即标签不会更改），优化目标是：

$$\begin{aligned} \mathcal{L}_{4}& =\text{distance }(\mathbf{y},\mathbf{y}_c)=\min_\delta\|\mathbf{y}-\mathbf{y}_c\| \\ &=\min_\delta\|f(\mathbf{x})-f(\mathbf{x}+\delta)\| \end{aligned}$$

这是为了测量扰动输入前后的置信差，以减轻APMSA对模型效用对普通用户的影响。综上，可以得到优化函数：

$$\begin{aligned}\mathcal{L}&=\mathcal{L}_1+c_1\cdot\mathcal{L}_2+\mathcal{L}_3+c_2\cdot\mathcal{L}_4\\&=\min_\delta J(\mathbf{x}+\delta)+c_1\cdot\mathcal{L}_2+\mathcal{L}_3+c_2\cdot\|f\left(\mathbf{x}\right)-f\left(\mathbf{x}+\delta\right)\|\end{aligned}$$

其中超参数$c_1$和$c_2$用于正则化损失函数，在实验中根据经验分别设置为2和0.01。优化过程不是要找到对抗性样例，而是要识别以正确保存类别为条件的接近其对应对抗性样例的混淆输入$x_c$。

APMSA的具体过程如下：

实验评价

数据集：

CIFAR10
GTSRB

评估指标：

Top-1 精度

模型提取攻击评估

选择VGG16作为攻击者初始替代模型的模型结构。使用学习率为 0.0001 的 SGD 来最小化均方误差的损失。

使用CIFAR-10数据集训练了一个基于ResNet-18的模型，准确率为91.94%，并在不应用防御的情况下部署。对于初始替代模型，作者选择了在ImageNet上预训练的VGG 16模型，并使用STL 10数据集作为公共查询样本。

放宽限制，将查询样本设置为 CIFAR10 测试集的一小部分进行查询。

使用GTSRB数据集训练了一个基于ResNet-18的MUA模型，准确率为95.40%，并在不应用防御的情况下部署。对于初始替代模型，选择了在ImageNet上预训练的VGG 16模型。

上述案例表明：

查询样本的选择会影响模型窃取攻击的效率。具体来说，更接近目标域数据分布的查询样本始终有利于攻击。
基于决策边界的样本合成技术（即通过PGD、CW）可以提供比随机查询更有用的信息。
随着查询预算的增加，基于决策边界的样本生成并没有带来太大的性能提升。原因可能是所选样本分布与原始模型的训练集过于接近，基于决策边界的样本结构提供的信息量相对有限。
当样本数量较少时，基于迁移学习的模型窃取攻击可提高攻击效果。原因是样本越少，冗余信息越少。然而，由于获得的信息相似，更多的查询样本可能会导致信息冗余，这不会为促进攻击提供更多有用的信息。

作者进一步评估攻击者选择的不同替代模型架构对攻击效果的影响。替代模型的性能受所选模型架构的影响。如图所示，VGG16始终表现出优于CIFAR10其他模型的攻击性能。

同样，在在GTSRB数据集上评估时，ResNet50表现出最好的攻击效果，略好于VGG16，使用AlexNet的性能最差。这表明选择合适的替代模型可以降低攻击成本。

综上，查询样本的选择会影响模型窃取攻击的效率和替代模型的准确性。具体来说，攻击最好选择类似于目标域的数据分布的公共查询样本。

此外，基于决策边界的样本合成技术（PGD、CW等）可以提供比随机查询更有用的信息。但是，随着查询次数的增加，基于决策边界的样本并没有带来太大的性能提升。原因可能是所选样本分布与原始模型的训练集太接近。

防御验证

使用APMSA后，替代模型的准确率甚至低于基准，表明防御减少了模型预测引起的模型内部信息泄露。

APMSA的关键见解是，通过将输入映射到特征空间的小尺度区域，可以尽可能减少输入输出对携带的信息泄漏，甚至在很大程度上产生误导性信息。为了可视化这一关键见解，作者使用 t-SNE 和归一化操作来减少用于可视化的混淆输入的维度。

CIFAR10 数据集上的混淆输入和查询样本之间存在明显的分离——每个混淆输入都是从传入的查询样本中找到的。在将原始查询样本与混淆输出相关联时，通过干扰模型预测中泄露的信息，以减少模型窃取攻击的影响。

fontconfig：Linux下的字体配置

Wed, 05 Jul 2023 20:58:15 +0800

字体的分类

字体的数量可以说是成千上万，但一般在电脑上显示的基本为以下这三类¹：

monospace [等宽]

等宽字体是指字符宽度相同的字体，用于需要字符严格对齐的场合，例如控制台和源代码。与此相对，字符宽度各不相同的字体称为比例字体(其余四类字体都是)。不过，对于中文字体而言，并不存在等宽与比例的差别，因为所有中文字都是等宽的。中文字体中的“等宽”指的是字体的西文部分是等宽的，2个字母对应1个汉字。
sans-serif [无衬线]

是指笔画末端没有修饰(衬线)的字体，通常用于屏幕显示。中文的黑体与圆体就属于此类字体。
serif [有衬线]

是指笔画末端有修饰(衬线)的字体，通常用于打印。中文的宋体与仿宋就属于此类字体。

我们要做的字体配置主要就是针对上面这三类字体。

选字体

有了目标，下面就是选一个自己喜欢的字体了。不过，对于中文字体，目前现在 Linux 上常用的、在维护的开源中文字体就一套——“思源黑体”和“思源宋体”，同时被 Noto 和思源两个项目收录。Noto 系列字体是 Google 主导的，思源系列字体是 Adobe 主导的。²

对于编程字体，可以选择的余地就多多了，像是Source Code Pro，Consolas，Menlo等等。我一开始选择的是 Iosevka 。但是，这款字体给我感觉太瘦了，看起来很是别扭。最后，我选择了广受好评的 Fira Code 。

小结一下，我的选择是：

无衬线：西文 Noto Sans，中文 Noto Sans CJK
衬线：西文 Noto Serif，中文 Noto Serif CJK
等宽：西文 Fira Code，中文 Noto Sans Mono CJK

在ArchLiunx上，我们只需要安装noto-fonts和noto-fonts-cjk这两个包即可，他们分别提供了西文字体 Noto Sans / Noto Serif和中文字体 Noto Sans CJK / Noto Serif CJK / Noto Sans Mono CJK 。³

关于 emoji，我选择了 Twitter 推出的字体 Twemoji。

ttf-twemoji

另外，少不了人见人爱的图标字体 Nerd Fonts。

ttf-nerd-fonts-symbols

这里就有小伙伴开始好奇了，如何让西文和中文使用不同的字体呢？

在 Windows 下，我们可以选择合成字体，即将各类字体打包到一起。例如更纱黑体就是由思源黑体和西文字体 Iosevka 整合而来的。这种字体的好处就是方便，直接选择使用即可。但是缺点也是显而易见，就是打包太麻烦了，引入 Iosevka 要打一次包，想要支持 Nerd Fonts，又要打一次包。如果是别人帮你提供好的合成字体那还好说，从网上下载、从软件仓库安装就完事了，自己打包的话真的工作量巨大。

而在 Liunx 下，我们只需要配置 fontconfig 就好了，无论想怎么搭配都可以实现，听起来是不是特别酷😎。可惜的是，有一些程序对 fontconfig 支持并不完善，这就达不到我们想要的效果。（说的就是你，Chrome😠）

fontconfig

在我们开始正式配置前，还是有必要了解一些基本的知识。这里我就简单介绍一下，如果想要深入了解的话可以看看双猫大佬的这篇文章，里面详细介绍了Linux fontconfig 的字体匹配机制。

字体的属性

字体有很多属性，常用的有字族（family）、倾斜（slant）、字重（weight）。后两者合一起叫样式（style）。

字族就是它的名字啦。一个字体文件，可以提供多个字体族名 (family)。比如 Arch Linux 用户在安装 wqy-microhei 后，系统端增加了 wqy-microhei.ttc 这个字体文件，分别提供「WenQuanYi Micro Hei」「文泉驛微米黑」,「文泉驿微米黑」三个字体族名，它们是一个意思。我们可以运行 fontconfig 提供的命令行工具 fc-list 去查看系统上已安装的字体已经它们对应的字体族名。

倾斜就是斜不斜，英文叫「Roman」「Italic」或者「Oblique」，Italic 是专门的斜体写法（更接近手写样式）， Oblique 是把常规写法倾斜一下完事。

字重就更简单了，就是笔划的粗细。常见的有 Regular、Normal、Medium、Bold、Semibold、Black、Thin、Light、Extralight 等。

通用字族名

很多时候，程序并不在乎用户具体使用的是哪款字体，像很多网站的 CSS 那样把各个平台的常见字体全部列出来太傻了，又容易出问题。所以，人们发明了「通用字族名」，也就是 sans-serif (sans)、serif 和 monospace (mono) 这些。它们不是真实存在的字体，而是分别指示程序去使用无衬线、衬线、等宽字体。那么桌面程序又是如何知道具体使用哪些字体呢？它只需要去查询 fontconfig 就行了。由于它们必定要经过 fontconfig 的查询流程后才能使用字体，所以我们可以通过 fontconfig 的配置去精准控制程序使用的字体。

如何调试

传入环境变量FC_DEBUG=4即可，例如：

1

FC_DEBUG=4 kitty

fontconfig 就会打印调试信息，其中可以看到：

1
2
3
4
5
6
7


FcConfigSubstitute Pattern has 6 elts (size 16)
 family: "monospace"(s)
 slant: 0(i)(s)
 weight: 80(i)(s)
 pixelsize: 19.1667(f)(s)
 lang: "en"(w)
 prgname: "kitty"(s)

除了启动一个程序来看它字体的调用日志，我们也可以手动调用。例如，我想看 monospace 在系统里被修改成了什么字体，就可以执行：

1

FC_DEBUG=4 fc-match 'monospace'

打印出的调试信息会很长，我们主要看几个部分：

第一部分，Add Rule，指已添加的配置文件规则。这里面也包含了家目录下的配置文件，可以找来看看被解析成了什么。

第二部分，在 Add Rule 之后，迎来了最关键的、我们应当关心的 FcConfigSubstitute Pattern，它包含了 font pattern。(s) 和 (w) 分别代表强弱绑定；prgname 代表程序名，此时就是 fc-match。至于 lang，由于没有对 fc-match 指定语言，所以默认是 en。

接下来有很多条 FcConfigSubstitute editPattern，代表对 font pattern 的替换操作。但是必须当规则匹配的时候，也就是 Rule Set 不是 No match 的情况下，才执行 FcConfigSubstitute editPattern。那么，又应该怎么看 FcConfigSubstitute editPattern 呢？主要看 family，因为 family 代表着字体匹配顺序。它就是配置文件中的<edit target="pattern">操作。

最后应该关心 FcConfigSubstitute donePattern，这是 fontconfig 执行完字体替换后的结果。

配置文件

整个配置文件由如下几个部分依次拼接而成：

目录设置(<dir>, <cachedir>, <include>)
杂项设置(<config>)
扫描阶段(<match target="scan">)
匹配阶段(<alias>, <match target="pattern">)
渲染阶段(<match target="font">)

想要实现合成字体的效果，一个最简单的思路，本文也基于该思路：不让程序使用某个具体的字体，而是使用通用字体族名 (Generic Font Family)。比如，让程序使用 sans-serif，也就是默认的无衬线字体。

我们要关心第四个部分，即匹配阶段，使用 fontconfig 配置如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


<match target="pattern">
 <test name="family">
 <string>sans-serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans CJK SC</string>
 <string>Noto Sans</string>
 <string>Twemoji</string>
 </edit>
</match>

这种 font stack 的方式，即可让程序按照以下顺序渲染字体：

1

Noto Sans CJK SC —> Noto Sans -> Twemoji

这里的<test>就是条件判断，mode="prepend"指在前添加，binding="strong"则是强绑定

开始配置

我们的思路就是就是修改默认的字族，让其成为我们想要指定的字体。然后将所有程序的字体配置改为通用字体族名：sans-serif，serif，monospace。

我们的配置都放在此目录中~/.config/fontconfig/fonts.conf，我的完整配置在此仓库中。

设置默认字体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


 <!-- Default system-ui fonts -->
 <match target="pattern">
 <test name="family">
 <string>system-ui</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>sans-serif</string>
 </edit>
 </match>

 <!-- Default sans-serif fonts-->
 <match target="pattern">
 <test name="family">
 <string>sans-serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans CJK SC</string>
 <string>Noto Sans</string>
 <string>Twemoji</string>
 </edit>
 </match>

 <!-- Default serif fonts-->
 <match target="pattern">
 <test name="family">
 <string>serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Serif CJK SC</string>
 <string>Noto Serif</string>
 <string>Twemoji</string>
 </edit>
 </match>

 <!-- Default monospace fonts-->
 <match target="pattern">
 <test name="family">
 <string>monospace</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans Mono CJK SC</string>
 <string>Symbols Nerd Font</string>
 <string>Twemoji</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="family" compare="contains">
 <string>Source Code</string>
 </test>
 <edit name="family" binding="strong">
 <string>Fira Code</string>
 </edit>
 </match>

对 system-ui，sans-serif，serif，monospace 设置优先显示的字体。在这里我让 system-ui 默认为无衬线。注意，system-ui 必须在最前。由于 fontconfig 对 font pattern 的操作是按顺序执行的，所以必须先让 system-ui 能优先以 sans-serif 显示，然后才是对 sans-serif 的操作。

所有的 Noto CJK 字体都以 SC 结尾，因为我希望在没指定语言的默认情况下，以简体中文显示中文字形。

设置异形字

什么是异形字？Noto Sans CJK 中的异体字，是在 相同的 Unicode 码位下，不同的语言会使用不同的字形。

可以在双猫大佬的这个测试网站中看到，不同的语言环境下，这些字的显示是不同的。

我们想要实现在保留异体字的情况下，让它默认显示中国大陆字形；只在特定语言下显示异体字，比如用浏览器查看一个日文页面。

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


<!-- Replace fonts for Japanese -->
<match target="pattern">
 <test name="lang">
 <string>ja</string>
 </test>
 <test name="family">
 <string>Noto Sans CJK SC</string>
 </test>
 <edit name="family" binding="strong">
 <string>Noto Sans CJK JP</string>
 </edit>
</match>

在字体匹配时，将 Noto Sans CJK SC 替换成 Noto Sans CJK JP。除了，你还需要照葫芦画瓢分别指定 zh-TW、zh-HK、ja、ko，以及对宋体和等宽字体进行重复的步骤。在此我就不重复了。

解决全角引号

英文中的单引号有两种，'(U+0027) 和’(U+2019)。可能会觉得前一种出现在英文文本中，后一种出现在中文文本中，并且宽度和中文等宽。然而，英语世界中的一些人在英文文章中也是会使用后一种的。所以，字体在显示后一种引号的时候，究竟是和英文字母一样窄，还是该和中文字体等宽呢？如果在英文文章中显示成全宽字符则会显得突兀。

比如，思源黑体其实也包含了拉丁字母的字形，可以完全使用思源黑体去显示西文。此时，后一种单引号的宽度会显示成中文字形的宽度。导致即使在全英文环境中，单引号也会突兀地在文本中过宽。

同样地，‘(U+2018) “(U+201C) ”(U+201D) 也有类似的情况。

我们的目标是在不同语言环境下字形会有所区别，让引号只在中文文本中全宽。

同样，在双猫大佬的这个测试网站中可以进行测试：

利用fontconfig，可以方便的解决此问题

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


<!-- 解决全角引号 -->
<match target="pattern">
 <test name="lang" compare="contains">
 <string>en</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Sans CJK</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans</string>
 </edit>
</match>

覆盖西文字体

如果去观察 Noto Sans CJK 这个中文字体，会发现它的西文部分的字形其实和 Noto Sans 不一样，虽然它们都以 Noto 自称。中文字体携带的英文字符有可能十分糟糕，特别是 Windows 自带的 SimHei，也就是中易黑体，它的英文相当糟糕。另外，微软雅黑的字重实在是太少了，对于设计师来说很不友好。而各种流行的英文字体支持很多字重。

Noto Sans CJK 的英文还是比较不错的，为了字体的样式统一，这里就不修改sans-serif和seri了。主要将编程用的等宽字体换成Fira Code。

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


<!-- Replace english fonts-->
<match target="pattern">
 <test name="prgname" compare="not_eq">
 <string>msedge</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Sans Mono CJK</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Fira Code</string>
 </edit>
</match>

这里为什么要多加一句判断呢？这是因为有些程序居然只使用 font pattern 结果中的首个字体，比如 Chrome（以及衍生的Chromium），虽然 Chrome 接受了我们指定的西文字体，但是它忽略了紧接其后的中文字体，即使配置采用了强绑定！然后中文字体又不知道它 fallback 到哪去了，可能会出现你想要的中文字体，也可能不是。

这里是 msedge 主要是我平时都用 edge 而不是 Chrome。可惜由于 Chromium 在 Linux 上小问题实在是太多了，还是老老实实的用 firefox 吧。

在所有情况下，除了程序名为 msedge 的情况下，优先使用 Fira Code 显示西文，再用 Noto Sans Mono CJK 显示中文。虽然我不能让 msedge 使用 Fira Code，但它一定能用上 Noto Sans Mono CJK 显示中文。

替换任意字体

当系统里已经安装了一些不需要的字体，但又不想删除或者屏蔽它怎么办呢？替换掉 font pattern 就可以了。

我这里则是用来替换思源字体，毕竟它就是 Noto 嘛

1
2
3
4
5
6
7
8


<match target="pattern">
 <test qual="any" name="family">
 <string>Source Han Sans</string>
 </test>
 <edit name="family" mode="assign" binding="same">
 <string>Noto Sans CJK SC</string>
 </edit>
</match>

字体渲染参数

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


<!--rendering options-->
<match target="font">
 <edit name="autohint" mode="assign">
 <bool>false</bool>
 </edit>
 <edit name="hinting" mode="assign">
 <bool>true</bool>
 </edit>
 <edit name="hintstyle" mode="assign">
 <const>hintslight</const>
 </edit>
 <edit name="antialias" mode="assign">
 <bool>true</bool>
 </edit>
 <edit name="lcdfilter" mode="assign">
 <const>lcddefault</const>
 </edit>
 <edit name="rgba" mode="assign">
 <const>rgb</const>
 </edit>
</match>

这里主要设置了一些字体的渲染方式：

autohint：优先使用内嵌微调
hinting：开启微调
hintstyle：微调的程度，轻微
antialias：开启抗锯齿功能
lcdfilter：LCD filter 的风格，默认
rgba：LCD 子像素的排列顺序，rgb

这里就直接抄作业了。

遇到的问题

全角引号设置无效

一开始我遇到了这个问题，无论怎么设置都是半角，经过排查以及网友的留言后发现，这是由于系统变量中的LANG为en_US.utf-8，这会导致传递给 fontconfig 的 lang 是 lang: zh-cn(s) "en"(w)。于是就一直匹配西文字体。

解决办法有两个，一个是直接修改LANG环境变量为zh_CN.UTF-8，我目前采用的就是这种形式。

或者就是默认渲染英文，当网页声明是中文时再换字体，相关配置如下：

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


<!-- Default sans-serif fonts-->
<match target="pattern">
 <test name="family">
 <string>sans-serif</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans</string>
 <string>Noto Sans CJK SC</string>
 <string>Noto Color Emoji</string>
 </edit>
</match>

<!-- cn -->
<match target="pattern">
 <test name="lang" compare="contains">
 <string>cn</string>
 </test>
 <test name="family" compare="contains">
 <string>Noto Sans</string>
 </test>
 <edit name="family" mode="prepend" binding="strong">
 <string>Noto Sans CJK SC</string>
 </edit>
</match>

这样如果网页声明了lang=zh-cn，就会用Noto Sans CJK SC字体进行覆盖，也就实现了全宽引号。假如网页没有声明lang或者错误地声明了lang=en，这时就会出现半角引号+汉字的组合了。

不能解决的问题

Linux 不强迫程序必须使用特定的依赖，而是程序主动选择了约定俗成的依赖。老话重谈，程序可以自由选择完全遵守 fontconfig，也可以选择部分使用 fontconfig 的配置，或者完全不遵守它。这也导致了对一些程序无法实现字体的修改。以及上面提到的 chrome 对 fontconfig 并不是很好，或许面对这种程序，就需要合成字体的出场了。

参考文献

ReDroid+MAA：在Linux下游玩明日方舟

Sat, 17 Jun 2023 16:47:00 +0800

最近打算将ArchLinux作为主力系统挑战一下，由于平时有用电脑挂明日方舟的习惯，于是打算安装模拟器在Linux上。相较于Windows下各种xx模拟器百花齐放，Linux下就惨不忍睹了。网上搜索到的知名模拟器中，Anbox已经被作者弃坑了，Android Studio模拟器则是面向开发者，想要使用还要安装Android Studio开发环境。

在搜索中，我发现ReDroid可以满足我的需求。作为一个“云手机”的方案，自然是可以部署在本地，摸索明白了部署到服务器上也挺不错(雾。

具体的安装的教程我参考的是Ivon大佬的这篇文章，在此基础上作了一些小小的修改。

ReDroid配置

安装环境

ReDroid需要Linux内核启用binderfs模块，Arch Liunx默认的linux内核并不包含此模块，需要安装linux-zen模块。

1

pacman -S linux-zen

这里我强烈建议安装官方的安装指南来，我一开始按照Ivon大佬的教程尝试在默认的Linux内核里启用该模块，结果ReDroid一直启动不了。最后更换内核后就成功运行起来了QAQ。

接着安装docker和docker-compose，用来运行ReDroid的容器

1

sudo pacman -S docker docker-compose

还要安装ADB和Scrcpy，用于连接到安卓虚拟机

1
2


sudo pacman -S android-tools
sudo pacman -S scrcpy

[可选]配置ARM转译器

大部分安卓应用都只有ARM版，这也意味着无法在X86的电脑上运行，这时就需要安装ARM转译器了。

然而，明日方舟居然支持X86，我们可以通过压缩工具解压方舟的安装包，可以看到lib下有x86目录。这也意味着如果只是用来玩方舟的话，完全不需要配置ARM转译。

同时，根据大佬的教程配置好转译器后，方舟反而会闪退，所以完全不用做此步😥。如果需要安装arm应用，可以看上面大佬的教程来做。

我后面可能会考虑使用libhoudini来作为ReDroid的转译器。

启动镜像

我这里就使用不包含ARM转译器的ReDroid继续了。通过下面的命令即可部署ReDroid：

1
2
3
4
5


sudo docker run -itd --privileged \
 -v /home/luobo/redroid:/data \
 -p 5555:5555 \
 --name redroid11 \
 redroid/redroid:11.0.0-latest

然后使用adb连接，并执行Scrcpy，显示手机画面：

1
2


adb connect localhost:5555
scrcpy -s localhost:5555

对于Google服务框架，我并不是刚需，就不安装了。如果需要安装，可以查看之前提到的教程。

Scrcpy2.0版本，已经自带了声音模块，无需再安装额外的软件。

如果遇到报错Failed to initialize audio/opus, error 0xfffffffe

只需要手动指定其他的音频解析器即可，如下面所示：

1

scrcpy -s localhost:5555 --audio-codec=aac

如果不需要声音，只需要加上--no-audio，如下面所示：

1

scrcpy -s localhost:5555 --no-audio

安装应用及开关机

向ReDroid安装应用，只需要使用adb即可

1

adb -s localhost:5555 install "/mnt/data/Downloads/mrfz_2.0.11_20230605_102450_87eb5.apk"

开关机也很简单，我们只需对docker容器进行操作。

1
2


sudo docker stop redroid11 #关机
sudo docker start redroid11 #开机

MAA配置

MAA作为自动化的挂机长草神器，肯定是要安排上的。

安装MAA

~~Arch用户直接aur安装即可~~

1

yay -S maa-assistant-arknights

我使用yay安装时，会安装许多用不到的库，而且会因为依赖错误而无法安装。故还是去官网下载压缩包解压使用。

配置MAA

我们需要修改./MAA-v{版本号}-linux-{架构}/Python/ 目录下的 sample.py 文件

首先需要配置adb连接，由于我们之前已经安装过adb了，这里直接替换地址即可：

1

if asst.connect('adb', '127.0.0.1:5555'):

我们可以执行python sample.py，如果输出连接成功则配置成功

之后我们需要配置MAA的任务，这里可以参考官方的文档进行修改

这里附上我的配置

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


 asst.append_task('StartUp')
 asst.append_task('Fight', {
 'stage': '', # 关卡名，可选，默认为空，识别当前/上次的关卡。
 'report_to_penguin': True, # 是否汇报企鹅数据
 "expiring_medicine": 999, # 最大使用 48 小时内过期理智药数量，可选，默认 0
 # 'penguin_id': '1234567'
 })
 asst.append_task('Recruit', {
 'enable': True, # 是否启用本任务，可选，默认为 true
 'select': [4, 5], # 会去点击标签的 Tag 等级，必选
 'confirm': [3, 4],
 'times': 4
 })
 asst.append_task('Infrast', {
 'facility': [
 "Mfg", "Trade", "Control", "Power", "Reception", "Office", "Dorm"
 ],
 'drones': "Money", # 无人机用途 "_NotUse"、"Money"、"SyntheticJade"、"CombatRecord"、"PureGold"、"OriginStone"、"Chip"
 'replenish': True, # 贸易站“源石碎片”是否自动补货,
 'dorm_trust_enabled': True # 是否将宿舍剩余位置填入信赖未满干员
 })
 asst.append_task('Visit')
 asst.append_task('Mall', {
 'shopping': True,
 'buy_first': ['招聘许可', '龙门币'],
 'blacklist': ['家具', '碳'],
 })
 asst.append_task('Award')

配置好后只需要一行命令就可以执行脚本了

1

python sample.py

至此，我们终于可以愉快的挂机了，再也不用担心体力被浪费了（雾

由于ReDroid是基于Dokcer的，这也意味着可以将其配置到服务器上，就可以实现24小时自动挂机了。不过，要想流畅的运行方舟，最好还是有4G以上的内存，目前我的服务器还没有这么大的内存，之后有机会再尝试吧。

利用Grounding DINO自动标注数据

Fri, 14 Apr 2023 10:07:42 +0800

最近需要构建属于自己的YOLO训练数据集，如果手动标注2k张图片这工作量太大了，于是就寻找有什么可以自动标注的方法。碰巧的是，知乎正好推荐了一篇相关的文章，里面介绍了Grounding DINO这个项目完美符合我的需求。那就不用多说了，直接修改他来实现我所需的功能。

需求

首先要明确一下我的需求：

能根据prompt实现画框标注
能对文件夹内的数据进行批量处理
能将识别的结果保存为YOLO TXT格式

这个项目可以实现第一个功能，但对于第二和第三个功能就需要我自己来实现了。

实现

Grounding DINO可以在CPU上运行，不过为了效率考虑，最好还是运行在GPU上，为此我所有的代码都在Colab上实现。

首先是环境配置，我们要挂载Google云盘以及安装Grounding DINO。

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


from google.colab import drive
drive.mount('/content/drive')

import os
HOME = os.getcwd()
print(HOME)

%cd {HOME}
!git clone https://github.com/IDEA-Research/GroundingDINO.git
%cd {HOME}/GroundingDINO
!pip install -q -e .
!pip install -q roboflow

CONFIG_PATH = os.path.join(HOME, "GroundingDINO/groundingdino/config/GroundingDINO_SwinB.cfg.py")
print(CONFIG_PATH, "; exist:", os.path.isfile(CONFIG_PATH))

%cd {HOME}
!mkdir {HOME}/weights
%cd {HOME}/weights
!wget -q https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha2/groundingdino_swinb_cogcoor.pth

WEIGHTS_NAME = "groundingdino_swinb_cogcoor.pth"
WEIGHTS_PATH = os.path.join(HOME, "weights", WEIGHTS_NAME)
print(WEIGHTS_PATH, "; exist:", os.path.isfile(WEIGHTS_PATH))

%cd {HOME}/GroundingDINO
from groundingdino.util.inference import load_model, load_image, predict, annotate
model = load_model(CONFIG_PATH, WEIGHTS_PATH)

通过上面这些代码，我们就成功配置好Grounding DINO并载入了模型。

下面就是我自己实现的训练集自动标注代码。

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


TRAIN_DATA_PATH = os.path.join("/content/my_data/images")
print(TRAIN_DATA_PATH, "; exist:", os.path.isdir(TRAIN_DATA_PATH))

TEXT_PROMPT = "face . phone"
BOX_TRESHOLD = 0.35
TEXT_TRESHOLD = 0.25

for filename in os.listdir(TRAIN_DATA_PATH):
 if filename.endswith(".png"):
 image_path = os.path.join(TRAIN_DATA_PATH, filename)
 image_source, image = load_image(image_path)

 boxes, logits, phrases = predict(
 model=model,
 image=image,
 caption=TEXT_PROMPT,
 box_threshold=BOX_TRESHOLD,
 text_threshold=TEXT_TRESHOLD
 )

 save_path = os.path.join(TRAIN_DATA_PATH,os.path.splitext(filename)[0])
 with open(save_path + ".txt", "w") as f:
 for i in range(len(phrases)):
 class_id = 0 if phrases[i] == 'face' else 1
 f.write(f"{class_id} {boxes[i][0]} {boxes[i][1]} {boxes[i][2]} {boxes[i][3]}\n")
 print(f"{filename} is over")

我们的代码会自动遍历文件夹下面所有的.png格式的文件，并调用Grounding DINO进行标注。在这段代码中，face的class_id为0，phone的class_id为1。

特别的，参考这篇issue，我们的prompt使用了.分割，这是为了避免不同顺序对结果的影响。

测试

由于拿到的数据是txt格式，人类很难识别，所以我们可以借助cv2将识别的结果在图片中框出，直接写个小脚本。

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


import os
import cv2

DATA_PATH = "D:\Code\Python\yolo"

for filename in os.listdir(DATA_PATH):
 if filename.endswith(".png"):
 image_path = os.path.join(DATA_PATH, filename)
 txt_path = os.path.join(DATA_PATH,os.path.splitext(filename)[0]) + '.txt'
 with open(txt_path, 'r') as f:
 # 读取图像文件
 image = cv2.imread(image_path)
 w = image.shape[1]
 h = image.shape[0]
 while True:
 line = f.readline()
 if line:
 msg = line.split(" ")
 # print(x_center,",",y_center,",",width,",",height)
 x1 = int((float(msg[1]) - float(msg[3]) / 2) * w) # x_center - width/2
 y1 = int((float(msg[2]) - float(msg[4]) / 2) * h) # y_center - height/2
 x2 = int((float(msg[1]) + float(msg[3]) / 2) * w) # x_center + width/2
 y2 = int((float(msg[2]) + float(msg[4]) / 2) * h) # y_center + height/2
 print(x1,",",y1,",",x2,",",y2)
 if msg[0] == '0':
 # 画出框
 cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
 else:
 cv2.rectangle(image, (x1, y1), (x2, y2), (255, 0, 0), 2)
 else:
 break

 # 显示图像
 cv2.imshow('image', image)
 cv2.waitKey(0)

# cv2.destroyAllWindows()

这个模型识别的效果还是不错的，不过还是有些多余的识别需要手工去除。

Feature Inference Attack on Model Predictions in Vertical Federated Learning

Tue, 03 Jan 2023 16:27:11 +0800

介绍

近年来，人们对利用来自多个组织的分布式源的数据来设计复杂的机器学习模型越来越感兴趣。

但是，由于

用户敏感数据的使用被迫遵守标准隐私规章或法律，例如GDPR或CCPA
数据是组织保持业务竞争优势的宝贵资产，应该受到高度保护

这两个原因，专有数据不能被直接共享。于是，联邦学习便被提出。联邦学习是一种新兴的数据协作范例，它允许多个数据所有者联合构建ML模型而不向彼此泄露其私有数据。

联邦学习根据数据划分，被分为横向联邦学习、纵向联邦学习、联邦迁移学习三类。在本文中，作者主要考虑的是纵向联邦学习这一类。何为纵向联邦学习呢？也就是２个数据集的用户重叠部分较大，而用户特征重叠部分较小，作者给出了一个实例：

一家银行希望构建一个机器学习模型，通过加入Fintech公司的更多特性来评估是否批准用户的信用卡申请。这家银行拥有“年龄”和“收入”的特征，而Fintech公司拥有“存款”和“平均在线购物次数”的特征。只有银行拥有训练数据集和测试数据集中的标签信息，即：是否应批准申请。我们将带有标签的一方称为主动方，其余没有标签值的一方或者几方称为被动方。

在本篇文章中，把拥有标签值的一方看作进攻方，而没有标签值的一方或者几方所拥有的特征值看作目标值，进攻方通过一定的方法得到目标方的目标值，也就是通常模型中被动方的隐私数据。

本文贡献

首次提出了纵向联邦学习预测模型的特征推理攻击
提出了针对逻辑回归和决策树的两种特定的攻击思路
利用攻方积累的多种预测输出，来设计一种从中学习攻方特征和目标特征关联的通用攻击思路
在真实和合成的数据集上，实践了提出的方法并进行了大量的评估。结论显示了攻击的有效性，本文也分析和建议了几种潜在的应对思路

问题构造

系统模型

我们考虑一组m个分布方（或数据所有者）$\{P_1,…,P_m\}$，他们通过合并各自的数据集来训练纵向联邦学习模型。在获得经训练的纵向联邦学习模型参数$\theta$之后，各方协作地对其联合预测数据集$D_{pred}=\{D_1,…,D_m\}$进行预测。数据集中的每一行对应一个样本，每一列对应一个要素。设$n$为样本数，$d_i$为$D_i$中的特征数，其中$i\in\{1,…,m\}$。我们表示$D_i=\{x^t_i\}^n_{t=1}$，其中$x^t_i$表示$D_i$的第t个样本。在这篇文章中，作者考虑监督分类任务，并用$c$表示分类的数量。

威胁模型

我们考虑半诚实模型，其中每一方都严格按照规定遵循协议，但可能试图基于接收到的消息推断其他方的私有信息。具体而言，本文着重研究了主动方为对抗方的情形。主动方还可以与其他被动方串通来推断一组目标被动方的私有特征值。最强的概念是m-1个参与方（包括主动方）合谋推断其余被动方的特征值。

攻击方法

逻辑回归模型(LR)的等式求解攻击

给定预测输出$v$，对手$P_{adv}$可以构造一组方程，$P_{adv}$可以从该组方程推断出$P_{target}$所持有的特征值。也就是说攻击者利用纵向联邦学习预测结果以及自己所持有的参数推断数据其他提供方的参数。

作者分别讨论了二分类逻辑回归以及多分类逻辑回归。

二分类逻辑回归

将模型参数表示为$\theta = \theta (\theta_{adv},\theta_{target})$，其中$\theta_{adv}$和$\theta_{target}$分别是对应于$P_{adv}$和$P_{target}$所拥有的特征的权重。

令$v$为给定样本$x=(x_{adv},x_{target})$的预测输出。对于二元LR分类，$v$中只有一个有意义的置信度分数，我们令其为$v_1$。

给定$v_1$和对手自己的特征值$x_{adv}$，$P_{adv}$可以直接创建以$x_{target}$作为变量的方程，即，

$$\sigma\left(x_{\text {adv }} \cdot \theta_{\text {adv }}+x_{\text {target }} \cdot \theta_{\text {target }}\right)=v_{1}$$

其中$\sigma(\cdot)$是S形函数。显然，如果只有一个未知特征，即，$d_{target} = 1$，则方程只有一个解，这意味着可以精确地推断未知特征值$x_{target}$。

多分类逻辑回归

对于多分类逻辑回归，存在$c$个线性回归模型。设$\theta = (\theta^{(1)},…,\theta^{(c)})$分别为这些$c$模型的参数。

为了发起特征推理攻击，对手的目标是构造$k\in\{1,…,c\}$的线性方程。

$$x _ { a d v } \cdot \theta _ { a d v } ^ { ( k ) } + x _ { target } \cdot \theta _ { target } ^ { ( k ) } = z _ { k }$$

其中$z_k$是第$k$个线性回归模型的输出。然而，$P_{adv}$只知道置信度向量$v =(v_1,…,v_c)$，使得

$$v _ { k } = \frac { e x p ( z _ { k } ) } { \sum _ { k' } exp ( z _ { k' } ) }$$

上面两个式子是我们用逻辑回归解决多分类问题的通用的公式，其中作者在第一个式子中把x和θ分成了攻方和目标方的数据。

作者将第二个式子双方取对数

$$\ln v _ { k } = z _ { k } - \ln ( \sum _ { k ^ { \prime } } e x p ( z _ { k } ^ { \prime } ) )$$

等式右边的第二项对于所有$k\in\{1,…,c\}$是相同的。因此，对两个相邻类别概率v的对数取差值

$$\ln v _ { k } - \ln v _ { k'} = z _ { k } - z _ { k' }$$

最后可以得到一个无关z值的一个等式

$$x_{\text {adv }}\left(\theta_{\text {adv }}^{(k)}-\theta_{\text {adv }}^{(k+1)}\right)+x_{\text {target }}\left(\theta_{\text {target }}^{(k)}-\theta_{\text {target }}^{(k+1)}\right)=a_{k}^{\prime}$$

其中$a^\prime_k=\ln v_k-\ln v_{k+1},k\in\{1,…,c\}$。

但是在后面推理的时候本文有一些为了逻辑上方便而采用了一个把纵向联邦限制减少的做法：把目标方或者说被动方的参数θ看作进攻方或者主动方能够得到的数据。

实际情况中，主动方或者进攻方在一般的纵向联邦框架中是无法得到被动方的参数θ数据的。

本文中我们姑且认为进攻方能得到，那么上式中的未知数只有$x_{target}$了，而$x_{target}$的维数为$d_{target}$，数量为目标方所用拥有的特征数。

这里我们把$x_{target}$的未知数看作自变量，个数为目标放所拥有的特征数。那么也就是说，$d_{target}$个自变量，$c-1$个方程，当$d_{target}\le c-1$，那么$x_{target}$只有一个解，可以精确地推断出来。

决策树模型的路径限制攻击

攻击方可以根据自己的部分特征信息(蓝色方框) 限制树模型中可能的路径(灰色箭头 -> 蓝色箭头 5:2)，结合预测类别结果1进一步限制决策路径(蓝色 - > 红色箭头 2:1 )，可以推测目标方Target的deposit属性(绿色方框) > 5K。

生成回归网络攻击

上面介绍的两种攻击方式都是基于单个模型预测。然而，这些攻击很难应用于复杂的模型，如神经网络（NN）和随机森林（RF）。

针对上述缺陷，作者设计了一种基于多模型预测的通用特征推理攻击，即生成回归网络（GRN）攻击，这是本篇论文的重点。

基本思想：

计算出对手自身特征与攻击目标未知特征之间的总体相关性。在此基础上，推断未知特征值的问题等效于生成新值$\hat{x}_{target}$以匹配垂直FL模型的决策的问题，其中$\hat{x}_{target}$遵循由对手的已知特征值和特征相关性确定的概率分布。

目标函数：

$$\min _{\theta_{G}} \frac{1}{n} \sum_{t=1}^{n} \ell\left(f\left(x_{\mathrm{adv}}^{t}, f_{G}\left(x_{\mathrm{adv}}^{t}, r^{t} ; \theta_{G}\right) ; \theta\right), v^{t}\right)+\Omega\left(f_{G}\right)$$

其中$\theta$和$\theta_G$分别是纵向联邦学习模型和生成模型的参数。此外，$f_G$表示$\hat{x}_{target}^t$，即生成模型的输出,$f$表示给定所生成样本的纵向联邦学习模型的输出（由$x_{adv}^t$和$\hat{x}_{target}^t$连接）。此外，$\Omega(\cdot)$是生成的未知特征值$\{\hat{x}_{target}^t\}_{t=1}^n$的正则化项。

具体方法：

把进攻方所拥有的数据（蓝色）和随机生成的数据（橙色），合成一个d维向量，其中d为进攻方的特征数量和目标方特征数量之和，随机生成的数据是为了初始化生成模型的初始输入。
生成模型计算之后，输出生成模型对于目标方特征值的预测。
把生成模型生成的目标方特征值的预测（橙色）与进攻方所拥有的数据（蓝色）合并，得到另一个d维的向量，作为已经生成的纵向联邦学习预测模型（比如神经网络）的输入。
得到输出的对不同类别的预测概率矩阵（橙色），与真实的攻方特征值和目标方特征值得到的不同类别的预测概率矩阵（蓝色）求损失。
对得到的损失进行反向传播，修改生成模型的参数，得到新的生成模型对目标放特征值的预测。

这种方法对于目标函数为可微的情况下效果不错，也就说明可以用来对逻辑回归和神经网络进行生成模型攻击。

随机森林的生成模型的攻击

路径限制攻击不适用于随机森林的模型，特别是当随机森林的树数量很大的时候。

因此，在随机森林模型使用GRN攻击的思想。

但是，因为随机森林（RF）模型的目标函数并不是可微的，所以不能通过随机森林（RF）把预测损失反向传播给生成模型。

因此，本文在得到纵向联邦模型（比如随机森林RF）之后，攻方会另外训练一个可微的模型（比如神经网络NN）来近似RF模型。

实验评价

数据集：

四个数据集，分别是银行营销（20个特征的2分类），信用卡（23个特征的2分类），诊断（48个特征的11分类）和新闻流行（59个特征的5分类）。

此外，利用sklearn库生成了两个合成数据集，用于评估预测数据集中样本数n对生成回归网络攻击性能的影响。

指标：

对于等式求解攻击（ESA）和生成回归网络攻击（GRNA），由于是回归任务，因此使用每个特征的均方误差（MSE）来衡量它们在重建多个目标特征时的总体准确性。具体而言，每个特征的MSE计算如下：

$$\mathrm{MSE}=\frac{1}{n * d_{\text {target }}} \sum_{t=1}^{n} \sum_{i=1}^{d_{\text {target }}}\left(\hat{x}_{\text {target }, i}^{t}-x_{\text {target }, i}^{t}\right)^{2}$$

对于路径限制攻击（PRA），作者测量了正确分支率（CBR）。

$d_{target}$对等式求解攻击的影响

对于所有数据集，如果满足阈值条件$d_{target}\le c-1$（在每个子图中用“T”表示），则每个特征的MSE为0，这证明了上面讨论的性质正确。

通过观察b和c，我们发现即使不满足阈值条件，等式求解攻击仍然可以找到$x_{target}$的良好推断，这大大优于随机猜测方法。

还有一个明显的趋势，每个特征的MSE随着$d_{target}$分数的增加而增加，即攻方所掌握的特征数越少，供给的准确率越低。

同时，作者还分析了为什么Bank数据集的MSE增量远大于其他数据集的MSE增量，这是因为不同数据集的数据分布差异。

由伪逆矩阵计算出的解$\hat{x}_{target}$在所有解中具有最小的欧几里德范数，即$||\hat{x}_{target}||_2\le||x_{target}||_2$

其中

$$\sum_{i=1}^{d_{\text {target }}} \hat{x}_{\text {target }, i}^{2} \leq \sum_{i=1}^{d_{\text {target }}} x_{\text {target }, i}^{2}$$

因此，我们有

$$\begin{aligned} \mathrm{MSE} & =\frac{1}{d_{\text {target }}} \sum_{i=1}^{d_{\text {target }}}\left(\hat{x}_{\text {target }, i}-x_{\text {target }, i}\right)^{2} \\ & =\frac{1}{d_{\text {target }}} \sum_{i=1}^{d_{\text {target }}}\left(\hat{x}_{\text {target }, i}^{2}+x_{\text {target }, i}^{2}-2 \hat{x}_{\text {target }, i} x_{\text {target }, i}\right) \\ & \leq \frac{1}{d_{\text {target }}} \sum_{i=1}^{d_{\text {target }}}\left(\hat{x}_{\text {target }, i}^{2}+x_{\text {target }, i}^{2}\right) \\ & \leq \frac{1}{d_{\text {target }}} \sum_{i=1}^{d_{\text {target }}} 2 x_{\text {target }, i}^{2}, \end{aligned}$$

我们便推导出$\mathrm{MSE}(\hat{x}_{target},x_{target})$的上界。

作者分别计算了Bank、Credit、Drive和News四个数据集的上界，分别为0.60、0.14、0.45和0.34。

一般来说，上界越大，对手的攻击精度就越差。这就解释了为什么Bank的MSE比其他数据集增长得更快。

$d_{target}$对路径限制攻击的影响

与等式求解攻击类似，攻击精度随着$d_{target}$的增加而降低。这是因为通常更多的目标特征将导致更多可能的预测路径，从而导致选择正确路径的概率降低。

我们可以发现，第三个数据集是异常的，它甚至随着$d_{target}$的增加而增加了。这是因为Drive数据集有11个类，比其他数据集的类要多得多。因此，在Drive中，每个类别对应的树形路径数量较少。其次，决策树模型在训练过程中只选择信息量大的特征，这意味着Drive数据集中$d_{target}$的增加不一定会增加树中未知特征的数量，因为有些特征可能永远不会被选中。

综上，较大的目标数据并不总是能降低路径限制攻击的CBR。

$d_{target}$对生成回归网络攻击的影响

作者展示了生成回归网络攻击对三种模型的攻击性能（LR：逻辑回归、RF：随机森林、NN：神经网络）

类似地，每个特征的MSE都随着$d_{target}$的增加而上升。这是因为生成回归网络攻击依赖于$x_{adv}$和$x_{target}$之间的特征相关性来推断未知特征值。如果$d_{target}$所占比例较大，学习到的相关性会变弱，导致攻击性能相对较差。然而，即使在$d_{target}$的分数为60%时，生成回归网络攻击仍然比随机猜测方法获得了更好的效果，证明了其有效性。

作者发现，采用神经网络模型的生成回归网络攻击的性能优于逻辑回归和随机森林模型。原因在于神经网络模型比其他两种模型具有更复杂的决策边界，从而极大地限制了给定相同$x_{adv}$和$v$时$x_{target}$的可能分布。同时，神经网络模型本身具有更多的参数，可以捕获更多关于特征相关性的重要信息，从而获得更好的攻击性能。

作者还将CBR度量用于评估RF模型上的GRNA，同样效果也比随机猜测方法优秀。

需要预测的样本数对生成回归网络攻击的影响

四个数据集上的趋势表明，预测数据集中的样本越多，对手可以获得的每个特征的MSE越少。换句话说，对手可以长期积累更多的预测输出，以提高其攻击精度。

数据相关性对生成回归网络攻击的影响

由于LR和RF模型的性能低于NN模型，作者推断是因为一小部分推断出的特征值与真实相差甚远，导致整体攻击性能相对较低，于是作者研究数据相关性的影响。

数据相关性定义如下：

$$\begin{aligned} \operatorname{corr}\left(x_{\mathrm{adv}}, x_{\mathrm{target}, i}\right) & =\frac{1}{d_{\mathrm{adv}}} \sum_{j=1}^{d_{\mathrm{adv}}} a b s\left(r\left(x_{\mathrm{adv}, j}, x_{\mathrm{target}, i}\right)\right), \\ \operatorname{corr}\left(v, x_{\mathrm{target}, i}\right) & =\frac{1}{c} \sum_{j=1}^{c} a b s\left(r\left(v_{j}, x_{\mathrm{target}, i}\right)\right), \end{aligned}$$

其中$r(a,b)$表示a和b之间的皮尔逊相关系数，$abs(\cdot)$表示绝对值。本质上，两个系数越大，对手越容易通过生成回归网络攻击学习特征相关性。

我们可以观察到相关系数$x_{adv}$和$v$都会影响生成回归网络攻击的攻击性能。$x_{target}$，$i$与$x_{adv}$和$v$之间较弱的相关性导致较低的推断准确度，例如图10a中的特征1和3以及图10b中的特征4和6。

对策

作者讨论了几种可能减轻所提出的特征推断攻击的潜在防御方法。

策略名称	效果
Rounding confidence scores	等式求解攻击有效，但生成回归网络攻击效果甚微
Dropout for neural networks model	有效，但攻击者还是有一个很好的推断
Pre-processing before collaboration	未做测试
Post-processing for verification	导致模型预测计算的巨大开销
Hide the vertical FL model	可能会导致新的隐私泄露
Differential Privacy (DP)	不适用

参考文章

让Hugo优雅的显示公式

Mon, 02 Jan 2023 22:19:15 +0800

继上文《在PowerPoint里优雅的插入LaTeX公式》后，没想到我又遇到了LaTeX相关的问题，这次是我博客无法正确的显示公式了。当然，最简单和粗暴的方法就是直接转成图片，但本着能折腾就折腾的精神，还是研究了一下如何优雅的解决。

问题复现

由于在LaTeX语法中，_是用来表示下标，由于下标经常被使用，很容易就会导致一句话中出现两个_。而在Markdown语法里，下划线是表示斜体的意思，于是Hugo就会将其转义成<em>标签，导致公式格式错误，从而使KaTeX无法正确渲染。

这就很笨了，本地的Markdown编辑器都没有出现这样的问题，怎么到你Hugo这就拉了呢？

Is there any way to ignore underscore when rendering markdown? - support - HUGO (gohugo.io)

有这样问题的人也不止我一个，官方论坛上早在2017年就有人提问了，那么官方的答复是：

没错，官方并没有给出好的解决方案，只有在文档中稍微提到了一嘴，你可以使用pandoc来进行Markdown的转义。¹

🤔本来用你就是图你的生成速度快，这调用其他程序后，这速度不就慢了没优势了吗。

没办法，还是自己动手解决吧。

解决方案

在搜索过后，网上给出的解决方案是在下划线前面加上\，避免被Hugo进行转义。但是如果在写文档的时候就加上的话，就会导致本地公式无法正确渲染，所以边写边加是肯定不可能了。写完后手动添加，如果是一两个还好，但下划线在LaTeX里实在是太常用了，所以手工修改也不现实。

于是，我便决定写个小程序来自动修改。~~由于天天Apex大脑退化严重~~，我实在想不到什么比较好的字符串处理方法，只好用遍历大法。（这既视感，编译原理：……，什么……在想我的事情……？）

不玩梗了，直接上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103


#include <fstream>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

const bool DEBUG = false;

int main(int argc, char* argv[]) {
 string file;
 ifstream fin;
 if (argc <= 1) {
 cout << "请输入文件名称：";
 cin >> file;
 } else {
 file = argv[1];
 }
 fin.open(file);
 if (!fin.is_open()) {
 cout << "无法打开文件" << endl;
 system("pause");
 return 1;
 }
 // 读入文件
 string code((std::istreambuf_iterator<char>(fin)),
 std::istreambuf_iterator<char>());
 fin.close();
 if (DEBUG) {
 cout << code << endl;
 cout << "-----------------" << endl;
 }
 // 所有数学公式的开头和结尾
 vector<pair<int, int>> maths;
 cout << "开始寻找所有数学公式" << endl;
 for (int i = 0; i < code.length(); i++) {
 if (code[i] == '$') {
 i++;
 bool is_double = false;
 int start = i;
 if (code[i] == '$') {
 is_double = true;
 i++;
 start = i;
 }
 while (i < code.length() && code[i] != '$') {
 i++;
 }
 if (is_double) {
 i++;
 }
 if (i >= code.length() || code[i] != '$') {
 cout << "错误：缺少结束符" << endl;
 system("pause");
 return 1;
 }
 int end = i;
 if (!is_double){
 maths.push_back(pair<int, int>(start, end));
 cout << start << " " << end << endl;
 if (DEBUG) {
 string math = code.substr(start, end - start);
 cout << math << endl;
 }
 }
 }
 }
 cout << "寻找完成，开始处理" << endl;
 int count = 0;
 for (int i = 0; i < maths.size(); i++) {
 for (int j = maths[i].first + count; j < maths[i].second + count; j++) {
 if (code[j] == '_') {
 code.insert(j, "\\");
 count++;
 j++;
 } else if (code[j] == '\\') {
 j++;
 if (code[j] == '\\') {
 code.insert(j, "\\\\");
 count += 2;
 j += 2;
 } else if (code[j] == '{' || code[j] == '}') {
 code.insert(j, "\\");
 count++;
 j++;
 }
 }
 }
 }
 if (DEBUG) {
 cout << code << endl;
 }
 cout << "处理完成，开始写入文件" << endl;
 ofstream fout;
 string location = file.substr(0, file.find_last_of('\\') + 1);
 fout.open(location + "index.md");
 if (!fout.is_open()) {
 cout << "无法打开文件" << endl;
 system("pause");
 return 1;
 }
 fout << code;
 return 0;
}

由于只是随手写的小工具，所以也没有分函数啥的，直接全放一起了。

这个程序会匹配 $...$ ~~和$$...$$这两种格式~~，(在新版的hogo中，对于块级别的公式将不会去转移了，所以无需处理$$...$$），将其中所有的_替换为\_，所有的\\替换为\\\\，同时将文件在原位置保存为index.md。

这样每次写好文章，只要将其拖到该程序上就能自动转换完成了。

这样就能确保本地查看编辑和网页都可以正确显示公式了。缺点则是每个有公式的文件都会多保存一份，不过文本文件并不是很大，所以也无伤大雅。

当然，这个程序还有优化的空间，比如自动对含有公式的文章进行处理等等。不过看这我文章更新的速度🕊️，手动拖一下还是可以接受的。

更新记录

2025.9.29：

适配最新的hugo程序

2023.7.20：

增加对\{和\}的处理

2023.1.3：

增加对\\的处理

Content Formats |Hugo (gohugo.io) ↩︎

在PowerPoint里优雅的插入LaTeX公式

Sat, 31 Dec 2022 15:25:22 +0800

最近，需要我在PPT中插入公式的次数越来越多了。最传统的办法自然是将公式生成好后直接进行截图插入，但这种方式还是不够优雅，如果需要调节大小也十分的麻烦，于是我便通过检索找到了两种插入公式的方法，在此做一个记录。

使用原生的公式功能

2202年了，如果说PowerPoint本身不支持LaTeX公式那就大错特错了。

将LaTeX代码插入到文本框中
选中刚刚输入的代码，依次点击功能区上的“插入”——“公式”——“专用”

只需要简单两步即可转换完成。然而，这种方法却存在很大的问题，就是支持的公式太少了，一些简单的公式还可以成功转换，但如果是公式块或者用了一些宏包，就会导致转换不出来。

这种方式的优点就是无需额外配置，以及可以与文字放在一起，方便排版。但如果你的公式比较复杂，那我还是推荐下面的方法。

使用IguanaTex插件

要说对LaTeX支持最好的，那肯定就是使用你电脑上安装好的发行版进行生成，IguanaTex插件就是基于这种方式实现的。

所以想要使用IguanaTex，你必须要准备好一个LaTeX发行版，我这里推荐MiKTeX，它不会安装完整的宏包而是在你需要的时候进行安装，避免占用过大的空间，具体的安装方法这里就不展开了。

在官网上下载最新版本，下载后缀名为ppam的文件放入C:\Users\%APPDATA%\Microsoft\AddIns目录中
打开PPT，依此选择：文件->选项->加载项->管理（下拉框中选择：PowerPoint加载项）->转到

在弹出的对话框中选择：添加->选择刚下载的插件文件

此时功能区上面就已经有了IguanaTex，点击第一个New LaTeX display就可以插入公式了。我们现在可以点击Main Settings来进行修改相关设置。

我们在这里可以进行修改临时文件位置以及图片生成的方式

我推荐将Output修改成Vector，这样生成的公式就是矢量形状，即使放大也不会变形。

下面就是生成的公式，可以看出每个字母都是图形。同时公式也可以使用该插件进行修改，还是比较方便的。

综上，个人推荐还是使用第二种方式，唯一麻烦的地方就是你需要自备LaTeX环境。

~~最近的文章真的是越来越水了QAQ~~

自建DNS实现分流及广告过滤

Wed, 30 Nov 2022 11:05:31 +0800

由于运营商默认提供的DNS有很多的污染，许多域名直接0.0.0.0或者127.0.0.1伺候，导致上网体验并不是很好，故想到自建加密DNS来抵御污染。

一开始使用的是AdGuardHome，然而在我看到了CloudflareSpeedTest这个项目后，就萌生了ip重定向这个需求，为此我又套了一层mosdns（经典为醋包饺子）。既然上了mosdns，就干脆做配上分流吧，于是现在的这套方案就形成了。虽然我的这些需求一个mosdns就可以解决，但AdGuardHome的前端ui、更方便的广告过滤、数据统计这些功能是mosdns所没有的。

23.2.8新方案

由于CloudFlare的优选IP在不同设备上速度都不同，所以在设备本地搭建更优。于是，我现在将mosdns从服务器上移到了本地。当然，在路由器上部署要更好，但我家的路由器性能太弱了，就算了。同时，去广告就交给mosdns，这样就无需使用两个软件进行套娃了。

mosdns在这段时间也更新了V5版本，原先的配置文件也无法使用了，正好做出V5可用的配置。

在该配置文件中，需要用上以下项目提供的域名/IP文件：

reject-list.txt 和 direct-list.txt
CN-ip-cidr.txt
cloudflare.txt：由ip.txt和ipv6.txt合并而来
ad-domains.txt：下载domains.txt并改名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


# Powered by luoboQAQ
log:
 level: info

plugins:
 # 缓存插件
 - tag: cache
 type: cache
 args:
 size: 10240
 lazy_cache_ttl: 86400
 # 将缓存保存在磁盘
 dump_file: ./cache.dump

 # 转发至本地服务器的插件
 - tag: forward_local
 type: forward
 args:
 upstreams:
 - tag: alidns_doh
 addr: "https://223.5.5.5/dns-query"
 - tag: dnspod_doh
 addr: "https://120.53.53.53/dns-query"

 # 转发至远程服务器的插件
 - tag: forward_remote
 type: forward
 args:
 upstreams:
 - tag: easymosdns
 addr: "https://doh.apad.pro/dns-query"
 bootstrap: "223.5.5.5"
 - tag: dns_sb
 addr: "https://45.11.45.11/dns-query"

 # fallback 用本地服务器 sequence
 # 返回不包含本地 ip 则 reject
 - tag: local_ip_sequence
 type: sequence
 args:
 - exec: $forward_local
 - matches: resp_ip &./data/CN-ip-cidr.txt
 exec: accept
 - exec: drop_resp # v5.1.2 以后不能用 reject

 # fallback 用远程服务器 sequence
 - tag: remote_sequence
 type: sequence
 args:
 - exec: $forward_remote
 # CloudFlare劫持到优选IP
 - matches:
 - resp_ip &./data/cloudflare.txt
 exec: black_hole 172.67.210.33
 - exec: accept

 # fallback插件
 - tag: fallback
 type: fallback
 args:
 primary: local_ip_sequence
 secondary: remote_sequence
 threshold: 500
 always_standby: true

 # 主要运行逻辑插件
 - tag: main
 type: sequence
 args:
 - matches: qtype 65
 exec: reject 3

 # 去广告
 - matches: qname &./data/reject-list.txt
 exec: reject 3
 - matches: qname &./data/ad-domains.txt
 exec: reject 3 

 - exec: prefer_ipv4

 - exec: $cache
 - matches: has_resp
 exec: accept

 - matches: qname &./data/direct-list.txt
 exec: $forward_local
 - matches: has_resp
 exec: accept

 - exec: $fallback

 # 启动 udp服务器
 - type: udp_server
 args:
 entry: main
 listen: 127.0.0.1:53

此配置文件参考了该回答

方案设计

首先由AdGuardHome接受请求，判断是否为广告域名:

是：直接拦截，结束流程
否：继续传入mosdns

判断是否为国内域名：

是：向本地DNS查询
否：向远端DNS查询

判断是否为CloudFlare的IP：

是：修改响应为优选的IP
否：不进行操作

系统搭建

搭建mosdns

如何安装和配置mosdns，官方文档已经写的非常详细了，直接看文档就好了。

配置文件主要参考了pmkol/easymosdns

这里主要分享一下我的配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


# Powered by luoboQAQ
log:
 file: "./mosdns.log"
 level: error

# 数据源设置
data_providers:
 - tag: CloudFlareIP
 file: "./rules/cloudflare.txt"
 auto_reload: true
 - tag: chinalist
 file: "./rules/geosite_cn.txt"
 auto_reload: true

plugins:
 # 缓存的插件
 - tag: cache
 type: cache
 args:
 size: 10240
 lazy_cache_ttl: 86400
 cache_everything: true

 # 匹配PTR类型请求的插件
 - tag: query_is_ptr
 type: query_matcher
 args:
 qtype: [12]

 # 匹配TYPE65类型请求的插件
 - tag: qtype65
 type: query_matcher
 args:
 qtype: [65]

 # 屏蔽请求的插件
 - tag: black_hole
 type: blackhole
 args:
 rcode: 0
 ipv4: "127.0.0.1"
 ipv6: "::1"

 # 匹配本地域名的插件
 - tag: query_is_cn_domain
 type: query_matcher
 args:
 domain:
 - "provider:chinalist"

 # 转发至本地服务器的插件
 # [local|alidns]
 - tag: forward_local
 type: fast_forward
 args:
 upstream:
 - addr: "udp://100.100.2.138"
 - tag: forward_alidns
 type: fast_forward
 args:
 upstream:
 - addr: "https://dns.alidns.com:443/dns-query"
 dial_addr: "223.5.5.5"

 # CloudFlare劫持的插件
 - tag: response_is_cloudflare_ip
 type: response_matcher
 args:
 ip:
 - "provider:CloudFlareIP"
 - tag: hijack_cloudflare_ip
 type: blackhole
 args:
 ipv4: 104.16.111.240

 # 转发至远端服务器的插件
 - tag: forward_easymosdns
 type: fast_forward
 args:
 upstream:
 - addr: "https://doh.apad.pro/dns-query"
 bootstrap: "223.5.5.5"

 # 主要的运行逻辑插件
 - tag: main_sequence
 type: sequence
 args:
 exec:
 # 缓存
 - cache

 # 屏蔽TYPE65类型请求
 - if: qtype65
 exec:
 - black_hole
 - _return 

 # 分流
 - if: "(query_is_cn_domain) || (query_is_ptr)"
 exec:
 - forward_alidns
 else_exec:
 - forward_easymosdns
 # CloudFlare劫持到优选IP
 - if: response_is_cloudflare_ip
 exec:
 - hijack_cloudflare_ip
 - _return


servers:
 - exec: main_sequence
 timeout: 5
 listeners:
 - addr: 127.0.0.1:5533
 protocol: udp

其中，cloudflare.txt来自于上面的CloudflareSpeedTest项目，是包含ipv4和ipv6的CloudflareIP段。

geosite_cn.txt是国内域名的集合，来自Loyalsoldier/v2ray-rules-dat，将geosite.dat使用mosdns v2dat unpack-domain 解包得到。

~~这里我没有启用mosdns的缓存，因为我在AdGuardHome里启用，就不重复缓存了。如果你是直接使用mosdns，那么就可以启用缓存。~~

事实上，还是要开启mosdns的缓存，以此来减小DNS查询的延时。

搭建AdGuardHome

这里我为了方便，就直接使用了docker，其实可以不用的说

1
2
3
4
5
6


docker run --name adguardhome\
 --restart unless-stopped\
 -v /root/adguardhome/work:/opt/adguardhome/work\
 -v /root/adguardhome/conf:/opt/adguardhome/conf\
 --net=host\
 -d adguard/adguardhome

我比较懒，就直接让容器使用了host模式，这样就不用配置端口了。

设置方面

上游DNS服务器填入127.0.0.1:5533，即mosdns的端口。
启用启用 EDNS 客户端子网，使DNS查询附上用户的ip，使解析的ip地址靠近本地位置。
开启乐观缓存，设置覆盖最小TTL值为600，覆盖最大TTL值为3600，避免每次都要查询
开启启用加密（HTTPS、DNS-over-HTTPS、DNS-over-TLS），启用DoH
根据自己的喜好添加过滤规则

我推荐启用CHN: anti-AD，这个列表还是很不错的

Nginx反代配置

这里为了避免DoH被滥用，我修改了默认的路径，同时将默认路径返回444（中断连接）。

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


server {
 listen 80;
 listen 443 ssl http2;
 server_name you.domain;

 if ($server_port !~ 443){
 rewrite ^(/.*)$ https://$host$1 permanent;
 }

 ssl_certificate ./cert/xxx.pem;
 ssl_certificate_key ./cert/xxxx.key;
 ssl_session_timeout 5m;
 ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
 #表示使用的加密套件的类型。
 ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #表示使用的TLS协议的类型。
 ssl_prefer_server_ciphers on;

 location /set/ {
 proxy_pass http://127.0.0.1:11451/;
 proxy_redirect / /set/;
 proxy_cookie_path / /set/;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header Host $host;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 }

 location /query {
 proxy_http_version 1.1;
 proxy_pass https://127.0.0.1:11450/dns-query;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header Host $host;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 }

 location / {
 return 444;
 }

}

客户端配置

Windows

在win11 22H2中，在设置——网络和Internet中就可以设置加密DNS，输入服务器ip地址后选择手动模板就可以输入DoH地址了。

如果还没有升级到这个版本，可以用管理员模式运行powershell执行下面的命令

1

Add-DnsClientDohServerAddress -ServerAddress '123.xx.xx.xx' -DohTemplate 'https://your.domain/dns-query' -AllowFallbackToUdp $False -AutoUpgrade $True

随后直接将你服务器的ip设置成DNS服务器就可以了，系统会自动使用DoH进行请求。

Android

安卓系统从9开始支持DoT，只要在连接与共享——私人DNS填入服务器的域名即可。

根据谷歌的公告，从13开始，安卓开始支持DoH。在此之前，想要使用DoH就只能依靠第三方软件了。

后记

单独使用AdGuardHome的情况下，开启缓存平均处理时间是5ms；AdGuardHome+mosdns目前是11ms。

折腾了两层解析，只是为了实现CloudFlare的IP优选，速度果然不出所料的慢了一点（当然也可能是缓存还没完全）。就当是学习了，正常使用留其一即可。_(:з)∠)_

通过这次折腾，对DNS的认识更加深了一步，~~也水了一篇博客~~。

简易Magisk模块的制作

Fri, 07 Oct 2022 11:30:17 +0800

前言

说到搞机，那肯定绕不开大名鼎鼎的Magisk。就我来说，root完后做的第一件事，就是安装各种各样的模块，但是，我却从来没有研究过Magisk的内容。同时，现在也有许多心怀不轨的人制作锁机模块骗人刷入。所以，了解Magisk模块的一些基本内容就显得比较重要了。

认识Magisk模块

根据官方的文档，一个典型的Magisk模块的目录应该如下所示：¹

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


module.zip
│
├── META-INF
│ └── com
│ └── google
│ └── android
│ ├── update-binary <--- 从官方仓库上下载的module_installer.sh
│ └── updater-script <--- 只有一行文字为 "#MAGISK"
│
├── module.prop <--- 模块的标识信息
├── customize.sh <--- (可选)用于自定义模块安装过程
├── ...
├── ... /* 模块的其余文件 */
│

可以看出来，META-INF目录是由官方提供，并不需要我们进行修改。

module.prop

这个文件是模块的标识信息，模块的基本信息就存放在这里，文件的格式如下。¹

1
2
3
4
5
6
7


id=<string>
name=<string>
version=<string>
versionCode=<int>
author=<string>
description=<string>
updateJson=<url> (optional)

各键值的作用说明如下：

名称	说明
id	模块的唯一标识符，需符合该正则表达式`^[a-zA-Z][a-zA-Z0-9._-]+$`
name	模块名称
version	模块版本号
versionCode	模块版本标识，必须为整数，用于更新
author	作者信息
description	模块描述
updateJson	更新信息链接，现在Magisk移除了内部的更新功能，这个属性应该是无用了

system文件夹

Magisk的一个主要作用就是对系统文件进行注入或替换，只要将文件按顺序放入此目录中即可。例如我想修改hosts文件，只需要将修改好的hosts文件放入system/etc这个目录下，Magisk就会自动将其替换了。

如果要替换/vendor、/product或/system_ext中的文件，只需将它们分别放在system/vendor、system/product和system/system_ext下。Magisk就会自动替换完成。

customize.sh

这是自定义模块安装过程，如果只是简单的替换文件就不需要用到它。但是，很多时候我们并不是仅需替换文件，还需要执行一些脚本，这里就需要使用到它了。

根据官方文档，这里支持以下的环境变量：

变量名	作用
MAGISK_VER (string)	当前安装的Magisk的版本字符串（例如v20.0）
MAGISK_VER_CODE (int)	当前安装的Magisk的版本代码（例如20000）
BOOTMODE (bool)	如果模块正在Magisk应用程序中安装，则为true
MODPATH (path)	安装模块文件的路径
TMPDIR (path)	可以临时存储文件的位置
ZIPFILE (path)	您的模块的安装zip
ARCH (string)	设备的CPU架构，值可以是`arm`、`arm 64`、`x86`或`x64`
IS64BIT (bool)	如果`$ARCH`为`arm 64`或`x64`，则为true
API (int)	设备的API级别（Android版本）（例如，Android 5.0为21）

以及以下的命令：

ui_print <msg>：在页面上显示信息
abort <msg>：将错误消息打印到控制台并终止安装
set_perm和set_perm_recursive：修改文件权限

实践

修改系统Hosts

我一开始想研究Magisk的契机，就是想要修改我手机的Hosts文件。一开始按百度的教程做，但没有效果，后来就尝试了一下Magisk模块，直接就成功了。

有了前面知识的铺垫，想要实现这个功能就非常简单了，下面列出我们程序的目录树。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


ChangeHosts.zip
├── META-INF
│ └── com
│ └── google
│ └── android
│ └── update-binary
│ └── updater-script
├── module.prop
├── system
 └── etc
 └── hosts

实际我们需要修改的部分只有module.prop和hosts，hosts是我们需要修改的文件，所以我们就只要关注module.prop。

1
2
3
4
5
6


id=ChangeHosts
name=ChangeHosts
version=v1.0.0
versionCode=100
author=luoboQAQ
description=修改hosts文件来屏蔽广告

如此看来，如果只要替换文件，基本没有任何难度。

使用dnscrypt-proxy实现DoH

这部分我正在研究，等研究明白了就补上🕊️。

Magisk官方开发指导 ↩︎ ↩︎

在Linux下安装SVP4

Tue, 23 Aug 2022 09:58:00 +0800

之前在《如何优雅的看番》这篇文章中我提到了补帧的3款软件，在Windows系统上我使用的是dmitriRender这款软件，而其并没有提供Linux版本的程序。与之相反的是，SVP不但提供了Linux版本，而且还是免费的。

由于官方文档是英文且有些地方没有表述清楚，这里我就将我安装和配置的方式记录下来供大家参考。

安装

对于Arch用户非常简单，直接yay -S svp-bin即可完成安装。

对于其他发行版，可以选择在官网上下载并安装。
安装播放器，这里我推荐安装VLC，因为其安装简便，并且后面配置SVP也很容易。

安装直接输入sudo pacman -S vlc即可
如果需要GPU加速，还需要安装相应的插件sudo pacman -S ocl-icd。我之前就是没有安装，导致一直无法读取到我的显卡。

安装好后就可以在SVP菜单——应用程序设置——GPU加速里看到你的显卡了

配置

修改VLC插件目录权限，以便SVP写入插件。

1

sudo chmod 777 /usr/lib/vlc/plugins/video_filter

在SVP的菜单里选择“工具”——“VLC的SVP插件”，将其选中
检查/usr/lib/vlc/plugins/video_filter目录下的libsvpcontrol_plugin.so和libvapoursynth_plugin.so是否有可执行权限，我之前就是因为没有给执行权限，导致VLC一直不会调用SVP
1 2

chmod +x /usr/lib/vlc/plugins/video_filter/libsvpcontrol_plugin.so chmod +x /usr/lib/vlc/plugins/video_filter/libvapoursynth_plugin.so
官网表示需要开启“反交错”才会启用，但实测好像不开启也可以运行。

如果VLC偏好设置——显示设置——全部——控制界面有SVP control interface

以及滤镜里有Vapoursynth filter即表明安装成功了。

小结

官网上的安装文档写了很长，但实际上对于VLC使用SVP并不复杂，复杂的是MPV使用SVP。本来打算配几张图的，但实际写下来也没有发现需要图片辅助说明的，那就算了，相信聪明的你一定能看懂 _(:з)∠)_

我的智慧物流之旅

Sun, 21 Aug 2022 21:20:00 +0800

随着答辩的结束，智慧物流这个项目就算是彻底结束了。不出意外的话，这应该是我大学生涯的参加的最后一个比赛了。看了看git的记录，提交的代码超过了1k行，同时也花了不少的时间在上面。做了这么多东西，不留下点什么总觉得不好，想来想去，还是把比赛做的东西做个小结吧，也算是纪念我这不算丰富的比赛时光吧（雾）

这里非常感谢我们队长，比赛里许多关键的问题是他解决的，他的动手能力和善于提出创新性想法的能力，都是值得我去学习的。也感谢另一位队友，在赛前紧张的准备时间里独自一人分担了制作PPT的工作，并且能做出如此精美的PPT。（大佬带带我 _(:з)∠)_ ）

感想也就写这么多吧，下面主要介绍我们比赛时所做的一些工作和创新。

程序的大体思路和流程

根据赛题要求，程序要实现下面几个功能：

导航至邮件分拣台
运用视觉算法识别邮件
机械臂定位抓取邮件
机器人运送邮件投入正确的邮箱

所以程序大致的步骤就是：建图->导航至分拣台->识别->抓取->导航至投递点->投递->导航至分拣台->……

这里我就按上面的要求一部分一部分的讲了。

建图

建图算法是Gmapping算法，这是一种基于2D激光雷达通过使用RBPF粒子滤波方法所完成的二维栅格地图构建SLAM算法，它也是移动机器人中适用最多的算法。它对激光雷达频率要求相对较低，稳定性较高，且能够结合里程计、陀螺仪等进行定位与地图构建，构建小场景地图时速度快、计算量小，缺点就是非常依赖里程计，所以无法适应不平坦的地面，无法使用回环检测，在大场景、粒子多的情况下，特别消耗资源。

当然我们并没有去仔细研究这个算法，建图的话按照官方提供的教程来一步步做就好了。不得不吐槽的是我们的小车一开始后轮是偏高的，导致雷达会打到地面，预选赛建图的时候一直建不好，最终只能靠侧边的雷达才把图建好，当时以为车就是这样的，直到正赛时才知道是车的问题。所以这种硬件问题一定要及时和厂商联系，不然全是泪啊😭。

导航这里不是我们写，而是使用了官方提供的导航包。根据培训文档，这里主要采用了AMCL自适应蒙特卡罗算法，它是机器人在二维移动过程中的一种概率定位系统，通过它实现了自适应（或 kld 采样）的蒙特卡罗定位方法。由于采用粒子滤波器来跟踪已经知道的地图中机器人位姿，故对于大范围的局部定位问题工作良好。路径规划则是最短路径规划算法，例如采用Floyd算法、Dijkstra算法、Bellman-Ford算法等。

导航这里其实是有大坑的，我们最终比赛时就栽在这里了。我们发现小车运行时，激光雷达经常会发生错位，导致导航发生偏移。这种情况基本是出现在小车转向时，我们怀疑是轮子打滑，也调紧了后轮的弹簧，但也没有用。我们当时认为这就是小车本身的局限性，同时在小车运行时也会自动调整至正确位置，我们就没有特别重视这个问题。结果在正式比赛时导航就出现偏移，导致好几个包裹都错位抓取了，虽然最终都全部抓取上了，但浪费了很多时间，非常的可惜。所以有时间的话，一定要看看官方提供的导航定位算法，或者联系厂家看看雷达有无问题，不然程序没问题，却因为硬件问题而出错还是很难受的。( ‘-ωก̀ )

图像识别

图像识别这里我们是调用是百度的PaddleOCR模块，由于ROS里的Python是2版本的，我们采用的也是PaddleOCR里的develop分支而非最新版本。

我们一开始是打算自己训练PaddleOCR模型的，然而我尝试了一晚上，不是很清楚模型训练的方法，好不容易运行了一个公开的训练集，发现训练时间要一天多，同时还需要自己做训练集。考虑到时间的问题，最终还是选择采用官方的模型。当然，最主要的原因还是分布式图像识别提升了性能，这部分我在下面会提到，这里就先按下不表。

机械臂抓取及投递

根据机械臂的官方文档，这里涉及的坐标系主要是两种，一种是关节坐标系，一直是笛卡尔坐标系。关节坐标系比较难以理解，我们还是采用比较直观的笛卡尔坐标系。

同样，机械臂的抓取也有3种不同模式：MOVJ、MOVL、JUMP。MOVJ模式相较于MOVL模式，速度快；MOVJ模式相较于JUMP模式，稳定性高，不易越界。¹

综上，我们的机械臂控制都采用的是笛卡尔坐标系里的MOVEJ模式，这样能保证机械臂抓取时不会出现超出抓取范围的异常。

控制机械臂基本就只要用到下面这几个话题，还是比较容易的：

DobotServer/SetPTPCmd：移动机械臂到指定坐标
DobotServer/SetEndEffectorSuctionCup：机械臂气泵控制
DobotServer/ClearAllAlarmsState：清除机械臂警报

投递就没什么好说的了，根据文字识别的结果进行投递，只要能抓取到，基本上不会出现投递错位的情况。这里会出现的问题主要还是导航不准，容易偏或者撞。解决办法只能是不停的测试找准坐标以及将导航目的位置远离投递点。

一些创新点

键盘操控程序

在我们的程序中，主要是通过开启两个线程来实现程序的暂停和恢复，如果使用input函数进行键盘输入的接收，则会阻塞线程，同时在输入完成后还需要按下回车，不是很合适。官方是提供了一个键盘控制程序的样例，然而这个程序有个我认为很大的BUG，会导致程序的输出偏移。

作为一个对代码美观有洁癖的人，这怎么能忍，于是我开始了百度，下面是我找到的可以在Windows和Linux两种环境下实现类似C语言getchar()函数的代码。²

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


def getChar():
 # figure out which function to use once, and store it in _func
 if"_func" not in getChar.__dict__:
 try:
 # for Windows-based systems
 import msvcrt # If successful, we are on Windows
 getChar._func=msvcrt.getch

 except ImportError:
 # for POSIX-based systems (with termios & tty support)
 import tty, sys, termios # raises ImportError if unsupported

 def _ttyRead():
 fd = sys.stdin.fileno()
 oldSettings = termios.tcgetattr(fd)

 try:
 tty.setcbreak(fd)
 answer = sys.stdin.read(1)
 finally:
 termios.tcsetattr(fd, termios.TCSADRAIN, oldSettings)

 return answer

 getChar._func=_ttyRead

 return getChar._func()

answer = getChar()

这里和官方提供的程序主要不同就在是tty.setcbreak(fd)，但我不知道原理，不过既然能用，就算了😇。

上面的代码还包括在Windows环境下的情况，我们不需要如此复杂，稍作修改将其整合进我们的程序，就构成了一个多线程程序的模板。

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


#!/usr/bin/env python
# coding=utf-8
import rospy
import threading
import sys
import termios
import tty

def main():
 '''程序主要逻辑入口'''
 pass


def getKey():
 '''获取输入的字符'''
 fd = sys.stdin.fileno()
 oldSettings = termios.tcgetattr(fd)
 try:
 tty.setcbreak(fd)
 key = sys.stdin.read(1)
 finally:
 termios.tcsetattr(fd, termios.TCSADRAIN, oldSettings)
 return key

def initKeyListener():
 '''输入监听程序'''
 while(1):
 key = getKey()
 if key == 'k':
 rospy.loginfo("退出程序")
 os._exit(0)
 elif key == 'a':
 rospy.loginfo("恢复导航")
 elif key == 's':
 rospy.loginfo('取消导航')
 elif key == 'q':
 rospy.loginfo('开始执行程序')

if __name__ == "__main__":
 # 给本程序初始化一个节点名称
 rospy.init_node('match_topic')

 # 开一个线程处理键盘监听
 key_thread = threading.Thread(target=initKeyListener)
 key_thread.start()
 # 开一个线程处理任务
 main_thread = threading.Thread(target=main)
 main_thread.start()

摄像头分辨率提升及去畸变

由于ROS默认从摄像头中获取的图像是640*480，且去畸变也是根据这个分辨率进行设置的，这会导致文字识别很容易识别不出文字。我们将小车上的摄像头接入电脑，发现是720P的，既然你能清晰，那为什么不用呢？于是，我们修改了相关的lanuch文件，将摄像头的分辨率提升到了720P，并使用我们自己打印的标定板进行标定。

下面介绍一下修改的方法

在moveit_ws/src/moveit/probot_vision/launch目录下，我们可以看到usb_cam_in_hand.launch文件。

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


<launch>

 <node name="usb_cam" pkg="usb_cam" type="usb_cam_node" output="screen" >
 <param name="video_device" value="/dev/video0" />
 <param name="image_width" value="1280" />
 <param name="image_height" value="720" />
 <param name="pixel_format" value="yuyv" />
 <param name="camera_frame_id" value="cameral_base" />
 <param name="io_method" value="mmap"/>

 <param name="camera_info_url" type="string" value="file://$(find probot_vision)/ost-720p.yaml" />
 <!--rosparam file="$(find probot_vision)/ost_4_new.yaml" command="load" /-->
 </node>

</launch>

对其的image_width和image_height进行修改，改为1280和720即可实现摄像头画质提升至720P。

对于手动标定，我们需要准备标定板，可以自己打印也可以上淘宝购买，就是像下面这样的黑白方格。

然后在小车上启动标定程序（为什么不在自己电脑上启动呢，因为小车上已经帮你做好硬件端口绑定了，在自己电脑上还要再来一次）

1
2
3
4


# 启动摄像头
roslaunch usb_cam usb_cam-test.launch
# 启动标定程序
rosrun camera_calibration cameracalibrator.py --size 8x6 --square 0.024 image:=/usb_cam/image_raw camera:=/usb_cam

这里要注意修改size参数，改成你标定板的黑白格中间交点的个数。 square参数这里则是你标定板上方格的边长，单位是米。

启动完成以后就可以看到标定界面了，通过调整标定板的上下左右以及角度，让右边的进度条全变绿就算标定完成了。点击计算按钮得到数据，将保存的yml文件路径替换上面的camera_info_url。

仅仅是这样还不算是完成，我们还需要修改去畸变程序里的参数，将moveit_ws/src/moveit/probot_vision/src/image_correct.cpp里的相关参数按照yml文件的参数进行修改。（这里有疑似是自动读取的代码，但被注释了，我们也没测试能不能用）修改好后就可以执行编译了，我们在moveit_ws目录下执行catkin_make --pkg probot_vision，等待编译完成后这项工作就算完成了。

后退距离判断

由于小车的后面是没有雷达的，为了避免碰撞，我们编写了基于摄像头的后退距离判断。当小车到达分拣台前时，调用摄像头进行拍照，对其进行蓝色区域的识别，得到分拣台在图像中的像素位置，再利用公式进行转化，得到小车当前距离分拣台的距离，最后使用check话题控制小车后退至距离分拣台5cm左右的位置，既避免了碰撞，又最大化了抓取范围。

由消息驱动程序逻辑

在一开始，我们的程序是在函数里调用小车导航，并阻塞直到导航成功再继续执行。这样的程序有个问题，就是当小车出现错误时，无法立即停下小车并保存当前程序执行的进度。于是，我们便将程序修改为基于ROS消息来驱动。这样的好处是程序只有收到成功或者失败的消息后才会执行对应的逻辑，便于失败后状态的恢复。

想要实现相关的功能，首先是导航不能采用原来基于动作的模式了，而是改成基于消息的模式。我们在程序运行的一开始注册相关的话题发布者。

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


def initPublisher():
 # 微调发布器
 global checkPub
 # 暂停导航发布器
 global pauseNav
 # 目标点发布器
 global goalPub
 goalPub = rospy.Publisher(
 'move_base/goal', MoveBaseActionGoal, queue_size=1)
 # 目标点里面的goal_id的id与上一次的id不能相同
 checkPub = rospy.Publisher('check', String, queue_size=1)
 pauseNav = rospy.Publisher(
 'move_base/cancel', GoalID, queue_size=1)

同时，我们也需要注册相关话题的监听者以及对应的回调函数

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


def initListener():
 # 订阅导航结果话题数据
 rospy.Subscriber('move_base/result', MoveBaseActionResult,
 navCallback)
 # 订阅（微调）走固定距离结果话题数据
 rospy.Subscriber('check_server/result', check_msgActionResult,
 checkCallback)
 rospy.loginfo("初始化订阅话题成功")

def checkCallback(data):
 '''位置微移回调'''
 if data.result.issuccess:
 rospy.loginfo("位置微调完成")
 pass

def navCallback(data):
 '''导航消息回调'''
 PROVINCES = {"四川", "安徽", "湖南", "广东", "浙江", "江苏", "福建", "河南"}
 if data.status.status == 3:
 rospy.loginfo("导航到达指定地点")
 goal_name = data.status.goal_id.id.split('_')[0]
 if goal_name[:9] == "分拣台":
 # 到达分拣台前
 pass
 elif goal_name[:6] in PROVINCES:
 # 到达投递点
 pass
 else:
 rospy.logwarn("未知的节点:{}".format(data.status.goal_id.id))
 elif data.status.status == 4:
 rospy.logwarn("导航失败,当前id为:{}".format(data.status.goal_id.id))
 else:
 rospy.logwarn("导航被取消:{}".format(data.status.status))

在导航消息回调中，我们使用goal_id.id来进行目标地点的传递，其构造模式为targetName +'_' + str(time.time())[-9:-3]。这样既有目标地点信息，也避免了id重复。这里一个汉字占3位，所以看到上面的[:6]的写法也就代表前2个字。

分布式部署图像识别

对于图像识别，我们一开始是放在小车上进行的，结果发现在小车上识别速度并不是很快，平均每张图片需要5~6秒的时间才能完成。

检查小车的CPU发现，这性能还是不要指望其来跑图像识别算法了，还是采用在自己的电脑上跑图像识别，将结果返回给小车吧。

想要实现这样的功能，就需要在电脑里装好ROS环境，我们是直接使用虚拟机，里面已经配置好相关的环境了。

在~/.bashrc里增加export ROS_MASTER_URI=http://192.168.31.200:11311，让虚拟机使用小车作为服务端。之后就是编写程序注册服务，供主程序调用了，为了方便调用，我们自己编写了相应的数据结构。

我们注册了Province.msg，存放识别到的快递盒上所需的数据。name代表省份名称，x和y分别是相对偏移量。

1
2
3


string name
float32 x
float32 y

然后注册了ProvinceList.srv，作为我们服务的消息。

1
2


---
Province[] provinces

由于使用了自定义消息类型，要注意修改CMakeLists.txt，将相应的文件添加进去，并注意引入message_generation，否则不会生成供Python调用的消息类。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


cmake_minimum_required(VERSION 3.0.2)
project(imgocr)

## Compile as C++11, supported in ROS Kinetic and newer
# add_compile_options(-std=c++11)

## Find catkin macros and libraries
## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
## is used, also find other catkin packages
find_package(catkin REQUIRED COMPONENTS
 rospy
 std_msgs
 sensor_msgs
 message_generation
)

## System dependencies are found with CMake's conventions
# find_package(Boost REQUIRED COMPONENTS system)


## Uncomment this if the package has a setup.py. This macro ensures
## modules and global scripts declared therein get installed
## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
# catkin_python_setup()

## Generate messages in the 'msg' folder
add_message_files(
 FILES
 Province.msg
 )

## Generate services in the 'srv' folder
add_service_files(
 FILES
 ProvinceList.srv
 )

## Generate added messages and services with any dependencies listed here
generate_messages(
 DEPENDENCIES
 std_msgs
 sensor_msgs
 )
 
catkin_package(
 CATKIN_DEPENDS rospy std_msgs message_runtime
)

include_directories(
# include
 ${catkin_INCLUDE_DIRS}
)

同样，在package.xml里也要添加message_generation等依赖

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


<?xml version="1.0"?>
<package format="2">
 <name>imgocr</name>
 <version>0.0.0</version>
 <description>The imgocr package</description>

 <maintainer email="eaibot@todo.todo">eaibot</maintainer>

 <license>TODO</license>

 <buildtool_depend>catkin</buildtool_depend>
 <build_depend>rospy</build_depend>
 <build_depend>std_msgs</build_depend>
 <build_depend>message_generation</build_depend>
 <build_export_depend>rospy</build_export_depend>
 <build_export_depend>std_msgs</build_export_depend>
 <exec_depend>rospy</exec_depend>
 <exec_depend>std_msgs</exec_depend>
 <exec_depend>message_runtime</exec_depend>
 <export>
 </export>
</package>

这样，就可以完成一个文字识别节点了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


#!/usr/bin/env python
# encoding: utf-8
from imp import reload
import sys
import rospy
import cv2
from imgocr.srv import ProvinceList, ProvinceListResponse
from imgocr.msg import Province
from sensor_msgs.msg import CompressedImage
from cv_bridge import CvBridge, CvBridgeError
import time

# 支持中文
reload(sys)
sys.setdefaultencoding("utf8")


def getImage():
 '''获取摄像头的图片'''
 data = rospy.wait_for_message(
 '/usb_cam/image_correct/compressed', CompressedImage, timeout=15.0)
 try:
 cv_image = CvBridge().compressed_imgmsg_to_cv2(data, "bgr8")
 except CvBridgeError as e:
 rospy.logerr(e)
 cv_image = cv2.rotate(cv_image, cv2.ROTATE_180)
 cv_image = cv2.flip(cv_image, 1)
 return cv_image


def doReq(req):
 rospy.loginfo("开始执行文字识别")
 start_time = time.time()
 img = getImage()
 pass
 rospy.loginfo("识别用时：{}".format(time.time()-start_time))
 resp = ProvinceListResponse()
 for pro in ans:
 a = Province()
 a.name = pro["province"]
 a.x = pro["x"]
 a.y = pro["y"]
 resp.provinces.append(a)
 return resp


def main():
 rospy.init_node("imgocr")
 server = rospy.Service("imgocr/getProvince", ProvinceList, doReq)
 rospy.loginfo("节点初始化完成")
 rospy.spin()


if __name__ == "__main__":
 main()

这里我们一开始获取摄像头的图片是采用/usb_cam/image_correct这个话题，但这个话题得到的图片是未压缩的，使用rostopic bw /usb_cam/image_correct可以看出大小差不多是好几M，这就会导致获取图像的时长远超文字识别时长，甚至是无法获取到图片。我们根据探索，发现/usb_cam/image_correct/compressed话题提供的是压缩后的图片，使用后获取图像的时长大大减小。

使用分布式图像识别后，识别时长基本控制在2S内。

由于我们是使用虚拟机，无法调用真机的显卡，如果有机会的话，可以尝试在真机上装相应的环境，使用GPU来进行图像识别，速度应该会更进一步。

机械臂异常自动检测和清除

在上面一小节中，我们获取到省份的坐标就可以送至机械臂进行抓取了。但是，机械臂的抓取范围是有限的，一旦超出抓取范围机械臂就会停止执行直至执行清除警报。一种思路是我们首先是在一个固定的定去识别邮件，首先记录这个点的高度，然后我们需要降到桌面去吸取邮件，这是第二个高度，我们只需要测定这两个高度Z的前提下，Y的移动范围就可以了。¹

这种思路确实可行，但如果后期更换了机械臂高度，又要手动测量，十分麻烦。于是，我想了另一个思路，通过查询API文档，我找到了警报检测的API，那就好说了。在执行可能越界的指令后接上异常检测，如果异常就自动清除，这样就能自动化的判断了。

话不多说，直接上代码：

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


#!/usr/bin/env python
# coding=utf-8
import rospy
from dobot.srv import GetAlarmsState, ClearAllAlarmsState

def getAlarmsState():
 '''
 查询机械臂报警状态，并自动进行清除
 return 是否存在报警
 '''
 rospy.wait_for_service('DobotServer/GetAlarmsState')
 rospy.wait_for_service('DobotServer/ClearAllAlarmsState')
 try:
 client = rospy.ServiceProxy(
 'DobotServer/GetAlarmsState', GetAlarmsState)
 client2 = rospy.ServiceProxy(
 'DobotServer/ClearAllAlarmsState', ClearAllAlarmsState)
 a = client()
 isError = False
 if a.alarmsState != "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0":
 rospy.loginfo("检测到警报，自动进行清除")
 client2()
 isError = True
 return isError
 except rospy.ServiceException as e:
 rospy.logerr("查询机械臂报警状态失败: %s" % e)

ROS日志输出级别控制

在上面我提到过，我对代码美观有洁癖，那程序输出也自然不能放过。这个项目里所有的输出我都使用rospy.log来输出，这就带来一个问题，有些输出我将其设为DEBUG级别，而ROS默认的日志级别为INFO，导致这些信息根本看不到。每次想看时手动将代码换为INFO再换回去，虽然可行，但不优雅。于是我研究了一下ROS的日志方面的文档，发现是有方法来实现日志输出级别的控制的。

在终端运行rqt_logger_level，之后选择你的程序节点中的rosout，在后面修改就可以修改ROS日志输出的级别了。

时间有限，我就找到了这一个可行的方法，其余方法我测试后并没生效，如果有更好的方法欢迎在评论区留言。

一些小工具

在写程序时，为了避免重复工作，还是做了一些小工具，本着“不要重复造轮子”的精神，在此一并开源了，希望能帮助到有需要的同学。

随机快递箱顺序生成

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


#!/usr/bin/env python
# coding=utf-8
import random

provinces = []

for i in range(3):
 provinces.append('四川')
for i in range(2):
 provinces.append('安徽')
for i in range(2):
 provinces.append('湖南')
for i in range(3):
 provinces.append('广东')
for i in range(3):
 provinces.append('浙江')
for i in range(2):
 provinces.append('江苏')
for i in range(3):
 provinces.append('福建')
for i in range(2):
 provinces.append('河南')
random.shuffle(provinces)

for pro in provinces:
 print(pro)

EAI资源点坐标格式转yaml格式

将官方QTEAIBotDemoPub(VER2)这个程序创建的导航目标点转成yaml格式，方便人修改及程序调用

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


#!/usr/bin/env python
# coding=utf-8

loacate = input("file loacate:")
file = open(loacate, "r")
file_data = file.readlines()
for row in file_data:
 tmp_list = row.split(',')
 print(tmp_list[0]+":")
 positions = tmp_list[2].split('#')
 print(" x: "+positions[0])
 print(" y: "+positions[1])
 orientations = tmp_list[3].split('#')
 print(" z: "+orientations[2])
 print(" w: "+orientations[3])

小结

这个项目到此也就完全结束了，回头看来，这个项目也是涉及了许多知识，诸如图像识别、自主定位等等，不过时间有限，基本都没怎么了解其中原理，只是调用了相关的接口，如果以后有空，可以继续研究研究😇。

一步到位，自动申请SSL证书

Thu, 21 Jul 2022 19:05:52 +0800

前言

阿里云最近发短信给我，提示我之前免费申请的SSL证书要到期了。借此机会，正好将acme.sh配置到服务器上，一劳永逸的解决证书问题。相较于在阿里云上申请证书，使用acme.sh的优势在于可以申请泛域名证书及可以自动续期。

下面我就记录一下我使用的步骤吧。我这里采用的是使用阿里云的API自动进行DNS方式的申请，不同的服务商命令有稍许不同，可以参考官方文档。

步骤

在阿里云控制台申请api https://ram.console.aliyun.com/users
在阿里云的角色控制里赋予刚刚申请的用户控制DNS的权限AliyunDNSFullAccess https://ram.console.aliyun.com/permissions

安装acme.sh

1

curl https://get.acme.sh | sh -s email=my@example.com

配置API环境
1 2

export Ali_Key="xxxx" export Ali_Secret="xxxxx"
这里是配置API环境，填入刚刚申请的密钥。这步只需要做一次，acme.sh会将其保存下来。
生成证书，这里填入刚刚申请API得到的密钥
1

acme.sh --issue --dns dns_ali -d lbqaq.top -d "*.lbqaq.top"
通过上面命令，可以申请到包含lbqaq.top和*.lbqaq.top这两个DNS记录的证书。这里如果有*，是需要加双引号的，我之前没加就报错了。

复制证书到nginx目录

1
2
3
4


acme.sh --install-cert -d lbqaq.top \
--key-file /usr/local/nginx/conf/cert/lbqaq.top.key \
--fullchain-file /usr/local/nginx/conf/cert/lbqaq.top.pem \
--reloadcmd "nginx -s reload"

这里key-file对应的是Nginx配置里的ssl_certificate_key，fullchain-file对应的是ssl_certificate

接下来修改Nginx配置文件即可

附上我的模板

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


#如果不是https就跳转至https
if ($server_port !~ 443){
 rewrite ^(/.*)$ https://$host$1 permanent;
}

ssl_certificate ./cert/lbqaq.top.pem;
ssl_certificate_key ./cert/lbqaq.top.key;
ssl_session_timeout 5m;
#表示使用的加密套件的类型。
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
#表示使用的TLS协议的类型。
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
add_header Strict-Transport-Security "max-age=31536000";

常用命令

在附上一些我用到的一些acme.sh相关的命令。~~才不是水字数呢~~

acme.sh --list查看已申请的证书
acme.sh --remove -d example.com删除指定的证书

云计算学习笔记

Wed, 08 Jun 2022 09:33:43 +0800

云计算的三个特点

资源池化

大部分云计算资源，都是池化了的资源。什么叫池化？池化就是物理资源的基础上，通过软件平台，封装成虚拟的计算资源，也就是我们常说的虚拟化。
弹性伸缩

云计算的计算资源，可以按需付费。你想要用多少，就租多少，想什么时候要就什么时候要，配置是支持自定义的。
安全可靠

而云计算，从物理角度来说，所有的计算资源都汇集在大型互联网数据中心（IDC），那里有严格的安保、抗震的建筑、安全的供电，有非常全面的容灾设计和应急方案，能够更好地保护计算资源，不会轻易地中断服务。

从软件上来说，云计算服务提供商有更专业的技术团队，更成熟的技术储备，能够更好地保护计算资源不被入侵或破坏。

云计算服务

应该不考，为了完备性还是放进来吧

Infrastructure as a Service (IaaS)：基础设施即服务
Platform as a Service (PaaS) ：平台即服务
Software as a Service (SaaS) ：软件即服务

云计算类型

公有云

公有云通常指第三方提供商用户能够使使用的云，公有云一般可通过 Internet 使用，可能是免费或成本低廉的。公有云的最大意义是能够以低廉的价格，提供有吸引力的服务给最终用户，创造新的业务价值，公有云作为一个支撑平台，还能够整合上游的服务（如增值业务，广告）提供者和下游最终用户，打造新的价值链和生态系统。它使客户能够访问和共享基本的计算机基础设施，其中包括硬件、存储和带宽等资源。

公有云是为大众建的，所有入驻用户都称租户，不仅同时有很多租户，而且一个租户离开，其资源可以马上释放给下一个租户。

优点：

成本低
方便
易扩展

缺点：

安全顾虑
性能超卖问题
管理要复杂

私有云

是为一个客户单独使用而构建的，因而提供对数据、安全性和服务质量的最有效控制。该公司拥有基础设施，并可以控制在此基础设施上部署应用程序的方式。私有云可部署在企业数据中心的防火墙内(本地私有云)，也可以将它们部署在一个安全的主机托管场所（托管私有云）。

优点：

安全
自主可控

缺点：

成本高
远程访问困难

社区云

社区云的核心特征是云端资源只给两个或者两个以上的特定单位组织内的员工使用，除此之外的人和机构都无权租赁和使用云端计算资源。与私有云类似，社区云的云端也有两种部署方法，即本地部署和托管部署。

混合云

是两个或两个以上不同类型的云（私有云、社区云、公共云）服务的结合，这种结合可以是计算的、存储的，也可以两者兼而有之。

优点：

操作灵活
弹性
成本效益。混合云模式具有成本效益，因为企业可以根据需要决定使用成本更昂贵的云计算资源。

缺点：

安全性不强
费用高。公有云+私有云管理费用高昂
兼容性问题

RDD的创建

使用makeRDD即可，例如val rdd = sc.makeRDD(List(1, 2, 3, 4)) 。在使用makeRDD时我们也可以指定分区数量，如val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 3)，这里我们就创建了3个分区。

当然，除了从程序中创建，我们也可以从文件中读取数据，使用sc.textFile("input")函数来按行读取文件里的数据。如val lineRDD: RDD[String] = sc.textFile("E:\\datas")

Value类型转换算子

map

def map[U: ClassTag](f: T => U ): RDD[U]

将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


val rdd = sc.makeRDD(List(1, 2, 3, 4))

def mapFunction(num: Int): Int = {num * 2} //转换函数
val mapRDD1: RDD[Int] = rdd.map(mapFunction)

val mapRDD2 = rdd.map((num: Int) => {num * 2}) //匿名函数
val mapRDD3 = rdd.map((num: Int) => num * 2) //函数的代码逻辑只有一行的时候，{}可省略
val mapRDD4 = rdd.map((num) => num * 2) //参数类型可以推断出来，参数类型可以省略
val mapRDD5 = rdd.map(num => num * 2) //参数列表中的参数只有一个，()可以省略
val mapRDD6 = rdd.map(_ * 2) //参数在逻辑中只出现一次，且顺序出现，参数可用_代替

注意要认识最后的简写形式。

mapPartiotions

def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U],preservesPartitioning: Boolean = false): RDD[U]

以分区为单位进行数据转换操作，但是会将整个分区的数据加载到内存进行引用，由于存在对象的引用，因此处理完的数据不会被释放掉。

1
2
3
4
5
6
7
8


val lineRdd = sc.makeRDD(List(1, 2, 3, 4),2)
val rdd2: RDD[Int] = lineRdd.mapPartitions(
 iter => {
 println("+++++++++++++++")
 iter.map(_ * 2)
 }
)
rdd2.collect().foreach(println)

结果：

1
2
3
4
5
6


+++++++++++++++
+++++++++++++++
2
4
6
8

上面代码的意思是将每个数据乘以2，并在每次计算时输出+++++，从输出两条+++++可知，mapPartiotions算子确实是按分区进行操作。

map 和 mapPartitions 的区别？

Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子是以分区为单位进行批处理操作。
Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传入一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据。
Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处理，所以性能较高。但是mapPartitions 算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。

mapPartitionWithIndex

def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U] ,preservesPartitioning: Boolean = false): RDD[U]

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


val lineRdd = sc.makeRDD(List(1, 2, 3, 4), 2)
val rdd2: RDD[Int] = lineRdd.mapPartitionsWithIndex(
 (index, iter) => {
 if (index == 1) {
 iter
 } else {
 Nil.iterator //Nil是空List
 }
 }
)
rdd2.collect().foreach(println)

结果：

在上面的程序中，我们对第0个分区进行抛弃，对第1个分区进行保留。如所示，程序仅输出了第1分区里的内容。

flatMap

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

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


val lineRdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5), 2)

val groupRDD: RDD[(Int, Iterable[Int])] = lineRdd.groupBy(_ % 2)
groupRDD.foreach(println)

val rdd1: RDD[Int] = groupRDD.flatMap( _._2)
println("Iterable[Int]的flatMap：" + rdd1.collect().mkString(","))

val data2: RDD[List[Int]] = groupRDD.map(_._2.toList)
val rdd2: RDD[Int] = data2.flatMap(t => t)

println("List[Int]的flatMap：" + rdd2.collect().mkString(","))

val lineRdd2 = sc.makeRDD(List(List(1, 2), 3, List(4,5)),2)
val rdd22: RDD[Any] = lineRdd2.flatMap {
 case list: List[_] => list
 case num: Int => List(num)
}
rdd22.collect().foreach(println)

结果：

1
2
3
4
5
6
7
8
9


(0,CompactBuffer(2, 4))
(1,CompactBuffer(1, 3, 5))
Iterable[Int]的flatMap：2,4,1,3,5
List[Int]的flatMap：2,4,1,3,5
1
2
3
4
5

在第一段程序中，我们看出RDD[List]和RDD[iterable]都可以被flaMap算子进行扁平化。在第二段程序中，我们将将 List(List(1,2),3,List(4,5))进行扁平化操作。

重新分区与数据筛选

coalesce

def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null): RDD[T]

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率。

当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本。

coalesce方法默认情况下不会将分区的数据打乱重新组合，只是将多个分区合并为1一个分区。

1
2
3
4
5


val rdd = sc.makeRDD(List(1, 2, 3, 4, 5,6),3)
val rdd2: RDD[Int] = rdd.coalesce(2)

//1:1 2
//2:3 4 5 6

上面代码的含义是将3个分区缩减成2个，可见成功执行，一个分区里有2个数，而另一个分区里有4个数。

repartition

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的RDD，还是将分区数少的 RDD 转换为分区数多的RDD，repartition 操作都可以完成，因为无论如何都会经 shuffle 过程。

1
2
3
4
5


val rdd = sc.makeRDD(List(1, 2, 3, 4, 5,6),3)
val rdd2: RDD[Int] = rdd.repartition(2)

//1:1 4 5
//2:2 3 6

由于参数 shuffle 的值为 true，将分区的数据打乱重新组合以保证不会出现数据倾斜

distinct

def distinct()(implicit ord: Ordering[T] = null): RDD[T]

将数据集中重复的数据去重

1
2
3
4
5


val rdd = sc.makeRDD(List(1, 2, 3, 4, 1, 2, 3, 4))
val disRDD = rdd.distinct()

disRDD.collect().foreach(println)
//4 1 3 2

filter

def filter(f: T => Boolean): RDD[T]

将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡

1
2
3
4
5


val lineRdd = sc.makeRDD(List(1,2,3,4),2)
val filterRDD: RDD[Int] = lineRdd.filter((num => num % 2 == 0))

filterRDD.collect().foreach(println)
//2 4

在上面的程序中，我们过滤掉所有的奇数，仅仅保留偶数

groupBy

将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


val lineRdd = sc.makeRDD(List(1, 2, 3, 4), 2)

def groupFunction(num: Int): Int = {
 num % 2
}

//val groupRDD: RDD[(Int, Iterable[Int])] = lineRdd.groupBy(_ % 2)
val groupRDD: RDD[(Int, Iterable[Int])] = lineRdd.groupBy(groupFunction)

groupRDD.collect().foreach(println)

结果：

1
2


(0,CompactBuffer(2, 4))
(1,CompactBuffer(1, 3))

在上面的代码中，按奇偶数进行分组

sortBy

def sortBy[K] ( f: (T) => K, ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

该操作用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。排序后新产生的 RDD 的分区数与原RDD 的分区数一致。中间存在 shuffle 的过程

1
2
3
4
5
6
7


val rdd = sc.makeRDD(List(("11", 2), ("1", 1), ("2", 3)), 2)
val sortRDD: RDD[(String, Int)] = rdd.sortBy(t => t._1)

sortRDD.collect().foreach(println)
//(1,1)
//(11,2)
//(2,3)

上面是字符串排序，按字典序。下面转换成数字，注意两者区别

1
2
3
4
5
6
7


val rdd = sc.makeRDD(List(("11", 2), ("1", 1), ("2", 3)), 2)
val sortRDD: RDD[(String, Int)] = rdd.sortBy(t => t._1.toInt)

sortRDD.collect().foreach(println)
//(1,1)
//(2,3)
//(11,2)

集合类型算子操作

intersection

def intersection(other: RDD[T]): RDD[T]

对源RDD 和参数RDD 求交集后返回一个新的RDD

1
2
3
4
5
6


val rdd1 = sc.makeRDD(List(1, 2, 3, 4, 5,6),3)
val rdd2 = sc.makeRDD(List(1, 2, 3),1)
val rdd3 = rdd1.intersection(rdd2)

rdd3.collect().foreach(println)
//3 1 2

union

def union(other: RDD[T]): RDD[T]

对源RDD 和参数RDD 求并集后返回一个新的RDD

1
2
3
4
5
6


val rdd1 = sc.makeRDD(List(1, 2, 3))
val rdd2 = sc.makeRDD(List(4, 5, 6))
val rdd3 = rdd1.union(rdd2)

rdd3.collect().foreach(println)
//1 2 3 4 5 6

subtract

def subtract(other: RDD[T]): RDD[T]

以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集

1
2
3
4
5
6


val rdd1 = sc.makeRDD(List(1, 2, 3, 4, 5, 6))
val rdd2 = sc.makeRDD(List(4, 5, 6))
val rdd3 = rdd1.subtract(rdd2)

rdd3.collect().foreach(println)
//1 2 3

zip

def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

1
2
3
4
5


val rdd1 = sc.makeRDD(List(1, 2, 3, 4), 2)
val rdd2 = sc.makeRDD(List(3, 4, 5, 6), 2)
val zipRDD: RDD[(Int, Int)] = rdd1.zip(rdd2)
println(zipRDD.collect().mkString(","))
//(1,3),(2,4),(3,5),(4,6)

如果两个RDD 数据类型不一致，对于交集，并集，差集，两个RDD的数据类型必须相同。对于拉链操作，两个RDD的数据类型可以不同。
如果两个RDD的分区中数据量不一致，对于交集，并集，差集，两个RDD的分区中数据量不需要相同；对于拉链操作分区中数据量必须相同。

Key-Value类型算子

reduceByKey

def reduceByKey(func: (V, V) => V): RDD[(K, V)]

可以将数据按照相同的Key 对Value 进行聚合，聚合操作是两两进行聚合的。reduceByKey中如果key的数据只有一个，是不会参与运算的。

1
2
3
4
5


val rdd: RDD[(String)] = sc.makeRDD(List("Hello Scala", "Hello Spark", "Hello Spark", "Hello 123"),2)
val wordRDD: RDD[String] = rdd.flatMap(_.split(" "))
val wordOneRDD: RDD[(String, Int)] = wordRDD.map((_, 1))
val result: RDD[(String, Int)] = wordOneRDD.reduceByKey(_ + _)
result.collect().foreach(println)

结果：

1
2
3
4


(Hello,4)
(123,1)
(Scala,1)
(Spark,2)

在上面的代码中，根据参数_+_，即表示将两个value进行相加。

groupByKey

def groupByKey(): RDD[(K, Iterable[V])]

将数据源的数据根据 key，对 value 进行分组，将数据源中相同key的数据分在一个组中，行成一个对偶元祖，元组中的第一个元素就是key，元组中的第二个元素就行相同key的value的集合。

1
2
3
4
5
6


val rdd = sc.makeRDD(List(("a", 1), ("a", 1), ("a", 1), ("b", 1), ("b", 1), ("b", 1), ("b", 1), ("a", 1)), 2)
val groupRDD: RDD[(String, Iterable[Int])] = rdd.groupByKey()

groupRDD.collect().foreach(println)
//(b,CompactBuffer(1, 1, 1, 1))
//(a,CompactBuffer(1, 1, 1, 1))

aggregateByKey

def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

将数据根据不同的规则进行分区内计算和分区间计算。

aggregateByKey存在函数柯里化，有两个参数列表。

第一个参数列表，需要传递一个参数，表示初始值。主要用于当碰见第一个key的时候，和value进行分区内计算。

第二个参数列表需要传递两个参数

参数2.1：分区内的计算规则
参数2.2：分区间的计算规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


val rdd = sc.makeRDD(List(("a", 1), ("a", 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)), 2)

//同分区获取最大值，不同分区相加求和
val rdd2: RDD[(String, Int)] = rdd.aggregateByKey(0)(
 (x, y) => math.max(x, y),
 (x, y) => x + y
)

rdd2.collect().foreach(println)
//(b,8)
//(a,8)

foldByKey

def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为foldByKey

1
2
3
4
5
6
7
8


val rdd = sc.makeRDD(List(("a", 1), ("a", 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)), 2)

//同分区相加求和，不同分区相加求和
val rdd2: RDD[(String, Int)] = rdd.foldByKey(0)(_ + _)

rdd2.collect().foreach(println)
//(b,12)
//(a,9)

combineByKey

def combineByKey[C]( createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)]

对key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。

combineByKey方法需要三个参数

第一个参数：表示将相同key的第一个数据进行结构的转换，实现操作
第二个参数：表示分区内的计算规则
第三个参数：表示分区间的计算规则

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


val rdd = sc.makeRDD(List(("a", 1), ("a", 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)), 2)

val rdd2: RDD[(String, (Int, Int))] = rdd.combineByKey(
 (t) => (t, 1),
 (t: (Int, Int), v) => {
 (t._1 + v, t._2 + 1)
 },
 (t1: (Int, Int), t2: (Int, Int)) => {
 (t1._1 + t2._1, t1._2 + t2._2)
 }
)

val rdd3: RDD[(String, Int)] = rdd2.map {
 case (str, (t1, t2)) => {
 (str, t1 / t2)
 }
}

rdd3.collect().foreach(println)
//(b,4)
//(a,3)

在上面的例子中，首先将相同key的格式转为(t,1)，分区内计算对于第一个数据进行相加，第二个数据+1，分区间将第一和第二个数据对应相加。

join

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

在类型为(K,V)和(K,W)的RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的RDD

两个RDD中的元素对进行笛卡尔乘积性质的匹配，但只会打印出匹配成功的。

1
2
3
4
5
6
7
8


val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val rdd2 = sc.makeRDD(List(("b", 5), ("a", 4), ("c", 6)), 2)
var joinRDD: RDD[(String, (Int, Int))] = rdd1.join(rdd2)

joinRDD.collect().foreach(println)
//(b,(2,5))
//(a,(1,4))
//(c,(3,6))

在上面的例子里，成功将a,b,c后面的值合在一起了

如果两个数据源中有多个相同的key，那么数据源a中的key会与数据源b中相同的key多次匹配成功，因此会数据量会几何性质增长

1
2
3
4
5
6
7


val rdd1 = sc.makeRDD(List(("a",1), ("b", 2),("c", 3)),2)
val rdd2 = sc.makeRDD(List(("b", 5), ("d",4), ("b", 6)),2)
var joinRDD: RDD[(String, (Int, Int))] = rdd1.join(rdd2)

joinRDD.collect().foreach(println)
//(b,(2,5))
//(b,(2,6))

leftOuterJoin

def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

类似于 SQL 语句的左外连接，根据左边第一个元素将两个RDD连接起来，和join算子类似，但这个可以支持key不匹配的情况。

1
2
3
4
5
6
7
8
9


val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val rdd2 = sc.makeRDD(List(("a", 5), ("b", 4)), 2)

val leftJoinRDD: RDD[(String, (Int, Option[Int]))] = rdd1.leftOuterJoin(rdd2)

leftJoinRDD.collect().foreach(println)
//(b,(2,Some(4)))
//(a,(1,Some(5)))
//(c,(3,None))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val rdd2 = sc.makeRDD(List(("a", 5), ("b", 4), ("b", 5), ("b", 6)), 2)

val leftJoinRDD: RDD[(String, (Int, Option[Int]))] = rdd1.leftOuterJoin(rdd2)

leftJoinRDD.collect().foreach(println)
//(b,(2,Some(4)))
//(b,(2,Some(5)))
//(b,(2,Some(6)))
//(a,(1,Some(5)))
//(c,(3,None))

rightOuterJoin

类似于左外连接，两者区别在于左连接是以左边的RDD为主，右连接以右边的RDD为主。

1
2
3
4
5
6
7
8
9


val rdd1 = sc.makeRDD(List(("a",1), ("b", 2)),2)
val rdd2 = sc.makeRDD(List(("a", 5), ("b",4),("c", 3)),2)

val rightJoinRDD: RDD[(String, (Option[Int], Int))] = rdd1.rightOuterJoin(rdd2)

rightJoinRDD.collect().foreach(println)
//(b,(Some(2),4))
//(a,(Some(1),5))
//(c,(None,3))

行动算子

reduce

def reduce(f: (T, T) => T): T

聚集RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据

1
2
3
4
5


val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 聚合数据
val reduceResult: Int = rdd.reduce(_+_)
println(reduceResult)
//10

在上面的例子中，10=1+2+3+4

collect

def collect(): Array[T]

在驱动程序中，方法会将不同分区的数据按照分区顺序采集到Driver端内存中，形成数组。

1
2
3
4
5


val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)

//收集数据到Driver
rdd.collect().foreach(println)
//1 2 3 4

first

def first(): T

返回RDD 中的第一个元素

1
2
3
4


val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
val firstResult: Int = rdd.first()
println(firstResult)
//1

take

def take(num: Int): Array[T]

返回一个由RDD 的前 n 个元素组成的数组

1
2
3
4
5


val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

val takeResult: Array[Int] = rdd.take(2)
println(takeResult.mkString(","))
//1,2

takeOrdered

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

返回该 RDD 排序后的前 n 个元素组成的数组

1
2
3
4


val rdd: RDD[Int] = sc.makeRDD(List(1, 3, 2, 4))
val result: Array[Int] = rdd.takeOrdered(2)
result.foreach(println)
//1 2

aggregate

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合；即，初始值不仅参与分区内计算，同时也参与分区间计算。

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


val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
/*
 * 组内：
 * 初值10,分区1(1)，组内结果11
 * 初值10,分区2(2)，组内结果12
 * 初值10,分区3(3)，组内结果13
 * 初值10,分区4(4)，组内结果14
 * 初值10,分区5(0)，组内结果10
 * 初值10,分区6(0)，组内结果10
 * 初值10,分区7(0)，组内结果10
 * 初值10,分区8(0)，组内结果10
 *
 * 组间：
 * 初值10,分区(11,12,13,14,10,10,10,10)，结果100
 */
val result: Int = rdd.aggregate(10)(_ + _, _ + _)
println(result)
//100

fold

def fold(zeroValue: T)(op: (T, T) => T): T

折叠操作，aggregate的简化版操作

1
2
3
4


val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val foldResult: Int = rdd.fold(0)(_ + _)
println(foldResult)
//10

countByKey

def countByKey(): Map[K, Long]

统计每种 key 的个数

1
2
3
4
5


val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2, "b"), (3, "c"), (3, "c")))
// 统计每种 key 的个数
val result: collection.Map[Int, Long] = rdd.countByKey()
println(result)
//Map(1 -> 3, 2 -> 1, 3 -> 2)

RDD 依赖关系

窄依赖

窄依赖表示每一个父(上游)RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用，窄依赖我们形象的比喻为独生子女。

宽依赖

宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生。

WordCount

典中典程序，必考

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


import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
 def main(args: Array[String]): Unit = {
 val sparkConf = new SparkConf().setMaster("local").setAppName("WordCount");
 val sc = new SparkContext(sparkConf)

 val rdd: RDD[String] = sc.textFile("spark-core/src/main/resources/words")
 val wordRDD: RDD[String] = rdd.flatMap(_.split(" "))
 val wordOneRDD: RDD[(String, Int)] = wordRDD.map((_, 1))
 val result: RDD[(String, Int)] = wordOneRDD.reduceByKey(_ + _)
 result.collect().foreach(println)

 //关闭连接
 sc.stop();
 }
}

有向无环图

DAG(Directed Acyclic Graph)叫做有向无环图，原始的RDD通过一系列的转换就形成了DAG。

stage的划分

一个Job会被拆分为多组Task，每组任务被称为一个stage。stage表示不同的调度阶段，一个spark job会对应产生很多个stage。

根据RDD之间依赖关系的不同将DAG划分成不同的Stage(调度阶段)

对于窄依赖，partition的转换处理在一个Stage中完成计算
对于宽依赖，由于有Shuffle的存在，只能在parent RDD处理完成后，才能开始接下来的计算

划分stage的依据就是宽依赖

首先根据rdd的算子操作顺序生成DAG有向无环图，接下里从最后一个rdd往前推，创建一个新的stage，把该rdd加入到该stage中，它是最后一个stage。
在往前推的过程中运行遇到了窄依赖就把该rdd加入到本stage中，如果遇到了宽依赖，就从宽依赖切开，那么最后一个stage也就结束了。
重新创建一个新的stage，按照第二个步骤继续往前推，一直到最开始的rdd，整个划分stage也就结束了

划分完stage之后，每一个stage中有很多可以并行运行的task，后期把每一个stage中的task封装在一个taskSet集合中，最后把一个一个的taskSet集合提交到worker节点上的executor进程中运行。

rdd与rdd之间存在依赖关系，stage与stage之前也存在依赖关系，前面stage中的task先运行，运行完成了再运行后面stage中的task，也就是说后面stage中的task输入数据是前面stage中task的输出结果数据。

缓存和检查点区别

必考，也是非常重要

Cache 缓存只是将数据临时保存起来。Cache 缓存的数据通常存储在内存，可靠性低。不切断血缘依赖，只会在血缘关系中添加新的依赖，一旦出现问题，可以重头读取数据。
persisit：将数据临时存储在磁盘文件中进行数据重用，涉及到磁盘IO，性能较低，但是数据安全。如果作业执行完毕，临时保存的数据文件就会丢失。
CheckPoint：将数据长久地保存在磁盘文件中进行数据重用，涉及到磁盘IO，性能较低，但是数据安全。为了包装数据安全，所以一般情况下，会独立执行作业，就是把当前需要持久化的RDD重新创建并保存。为了能够提高效率，通常和cache联合使用。
Checkpoint 检查点会切断血缘依赖，重新建立新的血缘关系。
cache 机制是每计算出一个要 cache 的 partition 就直接将其 cache 到内存了。但 checkpoint 没有使用这种第一次计算得到就存储的方法，而是等到 job 结束后另外启动专门的 job 去完成 checkpoint 。也就是说需要 checkpoint 的 RDD 会被计算两次。因此，在使用checkpoint() 的时候，建议加上 rdd.cache()，这样第二次运行的 job 就不用再去计算该 rdd 了，直接读取 cache 写磁盘。建议对checkpoint()的RDD 使用Cache 缓存，这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可，否则需要再从头计算一次RDD。Checkpoint 检查点切断血缘依赖。

combineByKey和aggregateByKey的异同

相同点

都有三个参数
第二个和第三个参数都是分区内操作和分区间操作
都属于聚合操作，使数据量减少
都是转换算子，不触发程序执行

不同点

对于第一个参数，aggregateByKey是设置初始值，combineByKey是进行转换
combineByKey组内计算和组间计算数据格式不一样； aggregateByKey组内计算和组间计算数据格式一样

aggregate和aggregateByKey的异同

相同点

都是具有分区内操作和分区间操作
都是聚合类型的算子

不同点

aggregateByKey的初始值不会参与分区间计算；对key进行操作，需要键值对
aggregate的初始值会参与分区间计算，会触发程序运行，进行读数据

求平均值

典中典程序，这也是必考

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


import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object exam {
 def main(args: Array[String]): Unit = {
 val sparkConf = new SparkConf().setMaster("local").setAppName("exam");
 val sc = new SparkContext(sparkConf)

 val lineRdd: RDD[(String, Int)] = sc.makeRDD(List(("Spark", 5), ("Hadoop", 3), ("Scala", 4), ("Spark", 3), ("Hadoop", 1)))
 val rdd1: RDD[(String, (Int, Int))] = lineRdd.map(t => (t._1, (t._2, 1)))
 val rdd2: RDD[(String, (Int, Int))] = rdd1.reduceByKey((t, k) => ((t._1 + k._1), (t._2 + k._2)))
 val rdd3: RDD[(String, Int)] = rdd2.map(
 t => (t._1, t._2._1 / t._2._2)
 )
 rdd3.collect().foreach(println)

 sc.stop()
 }
}

算子补充

glom

def glom(): RDD[Array[T]]

将同一个分区的数据直接转换为一个相同类型的内存数组进行处理，分区不变

1
2
3
4
5


val lineRdd = sc.makeRDD(List(1, 2, 3, 4),2)
val glomRDD: RDD[Array[Int]] = lineRdd.glom()
glomRDD.collect().foreach(data => println(data.mkString(",")))
//1,2
//3,4

sample

def sample( withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]

根据指定的规则从数据集中抽取数据

第1个参数withReplacement表示：抽取后是否将数据返回，true（放回），false（丢弃）
第2个参数fraction表示：当第一参数为true，第二个参数表示：抽取不放回的概率；基准值的概念（每个数有一个0~1随机值，用随即值与基准值进行比较）；当第一个参数为false，第二个参数表示，可能抽取的次数。
第3个参数seed表示：抽取数据时，随机算法的种子；如果不传第三个参数，那么使用的当前系统时间

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


val dataRDD = sparkContext.makeRDD(List( 1,2,3,4),1)
// 抽取数据不放回（伯努利算法）
// 伯努利算法：又叫 0、1 分布。例如扔硬币，要么正面，要么反面。
// 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不要
// 第一个参数：抽取的数据是否放回，false：不放回
// 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取；
// 第三个参数：随机数种子
val dataRDD1 = dataRDD.sample(false, 0.5)
// 抽取数据放回（泊松算法）
// 第一个参数：抽取的数据是否放回，true：放回；false：不放回
// 第二个参数：重复数据的几率，范围大于等于 0.表示每一个元素被期望抽取到的次数
// 第三个参数：随机数种子
val dataRDD2 = dataRDD.sample(true, 2)

partitionBy

def partitionBy(partitioner: Partitioner): RDD[(K, V)]

将数据按照指定的Partitioner规则重新进行重新分区。Spark 默认的分区器是HashPartitioner

太冷门了，应该不考，就不放代码了

cogroup

def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

在类型为(K,V)和(K,W)的RDD 上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


val rdd1 = sc.makeRDD(List(("a",1), ("b", 2), ("x", 44)),2)
val rdd2 = sc.makeRDD(List(("a", 5), ("b",4),("c", 3), ("c", 99)),2)

val cgRDD: RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd1.cogroup(rdd2)

cgRDD.collect().foreach(println)
//(x,(CompactBuffer(44),CompactBuffer()))
//(b,(CompactBuffer(2),CompactBuffer(4)))
//(a,(CompactBuffer(1),CompactBuffer(5)))
//(c,(CompactBuffer(),CompactBuffer(3, 99)))

下面都是行动算子

count

def count(): Long

返回RDD 中元素的个数

saveAsTextFile

def saveAsTextFile(path: String): Unit

保存成 Text 文件

1

rdd.saveAsTextFile("output")

特征工程学习笔记

Fri, 20 May 2022 13:18:58 +0800

卷积神经网络(CNN)

CNN的基本架构

一个典型的卷积网络是由卷积层、汇聚层、全连接层交叉堆叠而成。

一个卷积块为连续 𝑀 个卷积层和 𝑏 个汇聚层（ 𝑀 通常设置为2 ∼ 5，𝑏为0或1）。一个卷积网络中可以堆叠𝑁 个连续的卷积块，然后在后面接着 𝐾 个全连接层（ 𝑁 的取值区间比较大，比如 1 ∼ 100 或者更大；𝐾 一般为0 ∼ 2）。

上面这张图里的汇聚层也就是下面图中的池化层

输入层。在上图中就是最左边的船的图像，计算机理解为输入若干个矩阵。
卷积层(Convolution Layer)。卷积层的激活函数使用的是ReLU，$ReLU(x) = max(0,x)$。
池化层(Pooling layer)。池化层没有激活函数。

卷积层+池化层的组合可以在隐藏层出现很多次，上图中出现两次。这里卷积层+池化层可随意组合，如卷积层+卷积层，或者卷积层+卷积层+池化层。不过我们一般都是若干卷积层+池化层的组合。

全连接层(Fully Connected Layer, 简称FC)，输出层使用了Softmax激活函数来做图像识别的分

为了统一起见，我们下面对于Pooling layer的中文翻译都为汇聚层。

卷积

对于一维卷积，我们假设滤波器长度为$K$，它和一个信号序列$x_1,x_2,…$的卷积为：

$$ y_t=\sum_{k=1}^{K}w_kx_{t-k+1} $$

为了简单起见，这里假设卷积的输出$y_t$ 的下标$t$从$k$开始

信号序列$x$和滤波器$w$（也叫卷积核）的卷积定义为：

$$ y=w*x $$

其中$*$表示卷积运算。

对于二维矩阵，给定图像$X(M\times N)$，滤波器$W(U \times V)$我们定义：

$$ y_{ij}=\sum_{u=1}^{U}\sum_{v=1}^{V} w_{uv}x_{i-u+1,j-v+1} $$

光看公式还是比较抽象的，还是要举个例子：

图中的输入是一个二维的3x4的矩阵，而卷积核是一个2x2的矩阵。这里我们假设卷积是一次移动一个像素来卷积的，那么首先我们对输入的左上角2x2局部和卷积核卷积，即各个位置的元素相乘再相加，得到的输出矩阵S的$S_{00}$的元素，值为$aw+bx+ey+fz$。接着我们将输入的局部向右平移一个像素，现在是(b,c,f,g)四个元素构成的矩阵和卷积核来卷积，这样我们得到了输出矩阵S的$S_{01}$的元素，同样的方法，我们可以得到输出矩阵S的$S_{02}，S_{10}，S_{11}， S_{12}$的元素。

最终我们得到卷积输出的矩阵为一个2x3的矩阵S。

如果这个例子还是不直观，可以看下面这个动图：

可是，考试时可不仅仅会考二维的矩阵，还会考三维矩阵。

在介绍三维矩阵之前，我们先引入两个概念：

步长(Stride)：指卷积核在滑动时的时间间隔。说人话就是矩阵每次右移的长度，比如下面要说的例子中步长为2就右移2个像素。
零填充(Zero Padding)：是在输入向量两端进行补零。比如下面要说的例子pad=1，就在矩阵周围填一圈0

在斯坦福大学的cs231n的课程上，有一个动态的例子，我们就看这个例子。

Convolution demo

可以看出来，对于三维的矩阵，我们是将其拆成3个二维的矩阵，然后对应的将输入$X$和卷积核$W$进行卷积运算。

汇聚层

其作用是进行特征选择，降低特征数量，从而减少参数数量。说人话就是输入张量的各个子矩阵进行压缩。假如是2x2的汇聚，那么就将子矩阵的每2x2个元素变成一个元素，如果是3x3的汇聚，那么就将子矩阵的每3x3个元素变成一个元素，这样输入矩阵的维度就变小了。

要想将输入子矩阵的每nxn个元素变成一个元素，那么需要一个汇聚标准。常见的汇聚标准有2个，MAX或者是MEAN。即取对应区域的最大值或者平均值作为汇聚后的元素值。

下面这个例子采用取最大值的汇聚方法。同时采用的是2x2的汇聚。步幅为2。

首先对红色2x2区域进行汇聚，由于此2x2区域的最大值为6。那么对应的汇聚输出位置的值为6，由于步幅为2，此时移动到绿色的位置去进行汇聚，输出的最大值为8。同样的方法，可以得到黄色区域和蓝色区域的输出值。最终，我们的输入4x4的矩阵在汇聚后变成了2x2的矩阵，进行了压缩。

例题

有了上面这些内容的铺垫，我们就会惊喜的发现，下面这道题可以轻松的完成了

循环神经网络(RNN)

在前面讲到的DNN和CNN中，训练样本的输入和输出是比较的确定的。但是有一类问题DNN和CNN不好解决，就是训练样本输入是连续的序列,且序列的长短不一，比如基于时间的序列：一段段连续的语音，一段段连续的手写文字。这些序列比较长，且长度不一，比较难直接的拆分成一个个独立的样本来通过DNN/CNN进行训练。

这时就需要RNN了。RNN是一类具有短期记忆能力的神经网络，RNN的模型如下：

单一神经元的RNN

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


class SingleLayerRNN(nn.Module):
 def __init__(self, inputSize, hiddenSize):
 super(SingleLayerRNN, self).__init__()
 # inputSize x hiddenSize : 4 x 1
 self.Wx = torch.randn(inputSize, hiddenSize)
 # hiddenSize x hiddenSize : 1 x 1
 self.Wy = torch.randn(hiddenSize, hiddenSize)
 self.b = torch.zeros(1, hiddenSize) # 1 xhiddenSize : 1 x 4

 def forward(self, X0, X1):
 # batchSize x hiddenSize : 1 x 4
 self.Y0 = torch.tanh(torch.mm(X0, self.Wx) + self.b)
 # batchSize x hiddenSize : 1 X 4
 self.Y1 = torch.tanh(torch.mm(X1, self.Wx) +
 self.b + torch.mm(self.Y0, self.Wy))
 return self.Y0, self.Y1

INPUT_SIZE = 4
HIDDEN_SIZE = 1
# t=0 => batchSize x inputSize : 4 x 4
X0_batch = torch.tensor([[0, 1, 2, 0], [3, 4, 5, 0], [6, 7, 8, 0],
 [9, 0, 1, 0]], dtype=torch.float)
# t=1 => batchSize x inputSize : 4 x 4
X1_batch = torch.tensor([[9, 8, 7, 0], [0, 0, 0, 0], [6, 5, 4, 0],
 [3, 2, 1, 0]], dtype=torch.float)
model = SingleLayerRNN(INPUT_SIZE, HIDDEN_SIZE)
Y0_batch, Y1_batch = model(X0_batch, X1_batch)

print(Y0_batch)
print(Y1_batch)

使用RNN进行MNIST训练

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127


import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
import os

os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
BATCH_SIZE = 64
DOWNLOAD_DATASET = False

# list all transformations
transform = transforms.Compose([
 transforms.Resize((28, 28)),
 transforms.ToTensor(),
])

# download and load training dataset
trainDataset = torchvision.datasets.MNIST(root='./MNIST/', train=True, download=DOWNLOAD_DATASET, transform=transform)
trainLoader = torch.utils.data.DataLoader(trainDataset, batch_size=BATCH_SIZE, shuffle=True)

# download and load testing dataset
testDataset = torchvision.datasets.MNIST(root='./MNIST/', train=False, download=DOWNLOAD_DATASET, transform=transform)
testLoader = torch.utils.data.DataLoader(testDataset, batch_size=BATCH_SIZE, shuffle=False)

# functions to show an image
def imshow(img):
 # img = img / 2 + 0.5 # unnormalize
 npimg = img.numpy()
 plt.imshow(np.transpose(npimg, (1, 2, 0)))

# get some random training images
dataIter = iter(trainLoader)
images, labels = dataIter.next()

# show images
imshow(torchvision.utils.make_grid(images))

# parameters
INPUT_SIZE = 28
HIDDEN_SIZE = 150
OUTPUT_SIZE = 10
TIME_STEP = 28
MAX_EPOCH = 10

class ImageRNN(nn.Module):
 def __init__(self, batchSize, timeStep, inputSize, hiddenSize, outputSize):
 super(ImageRNN, self).__init__()

 self.hiddenSize = hiddenSize
 self.batchSize = batchSize
 self.timeStep = timeStep
 self.inputSize = inputSize
 self.outputSize = outputSize

 self.RNN = nn.RNN(self.inputSize, self.hiddenSize)

 self.fc = nn.Linear(self.hiddenSize, self.outputSize)

 def initializeHidden(self, ):
 # (num_layers, batch_size, hidden_size)
 return torch.zeros(1, self.batchSize, self.hiddenSize)

 def forward(self, X):
 # transforms X to dimensions: timeStep x batchSize x inputSize
 X = X.permute(1, 0, 2)

 self.batchSize = X.size(1)
 self.hidden = self.initializeHidden()

 # rnnOutput => timeStep, batchSize, hiddenSize (hidden states for each time step)
 # self.hidden => 1, batchSize, hiddenSize (final state from each rnnOutput)
 rnnOutput, self.hidden = self.RNN(X, self.hidden)
 out = self.fc(self.hidden)

 return out.view(-1, self.outputSize) # batchSize x outputSize

dataIter = iter(trainLoader)
images, labels = dataIter.next()
model = ImageRNN(BATCH_SIZE, TIME_STEP, INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE)
ypred = model(images.view(-1, 28, 28))
print(ypred[0:10])

# Device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Model instance
model = ImageRNN(BATCH_SIZE, TIME_STEP, INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
def computeAccuracy(output, target):
 ''' Obtain accuracy for training round '''
 corrects = (torch.max(output, 1)[1].view(target.size()).data == target.data).sum()
 accuracy = 100.0 * corrects / torch.numel(target)
 return accuracy.item()
for epoch in range(MAX_EPOCH): # loop over the dataset multiple times
 trainLoss = 0.0
 trainAccuracy = 0.0
 model.train()
 # TRAINING ROUND
 for i, data in enumerate(trainLoader):
 # reset hidden states
 model.hidden = model.initializeHidden()
 # get the inputs
 inputs, labels = data
 inputs = inputs.view(-1, 28, 28)
 # forward
 ypred = model(inputs)
 loss = criterion(ypred, labels)
 # backward + optimize
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()
 trainLoss += loss.detach().item()
 trainAccuracy += computeAccuracy(ypred, labels)
 model.eval()
 print('Epoch: {:2d} | Loss: {:8.4f} | Train Accuracy: {:5.2f}'.format(epoch, trainLoss / i, trainAccuracy / i))
model.eval()
testAccuracy = 0.0
for i, (images, labels) in enumerate(testLoader, 0):
 images = images.to(device)
 labels = labels.to(device)
 outputs = model(images.view(-1, 28, 28))
 testAccuracy += computeAccuracy(outputs, labels)
print('Test Accuracy: {:6.2f}'.format(testAccuracy / len(testLoader)))

参考资料

回归分析学习笔记

Fri, 20 May 2022 12:50:16 +0800

线性回归

线性回归遇到的问题一般是这样的。我们有m个样本，每个样本对应于n维特征和一个结果输出，如下：

$$ (x_1^{(0)}, x_2^{(0)}, ...x_n^{(0)}, y_0), (x_1^{(1)}, x_2^{(1)}, ...x_n^{(1)},y_1), ... (x_1^{(m)}, x_2^{(m)}, ...x_n^{(m)}, y_m) $$

我们的问题是，对于一个新的$(x_1^{(x)}, x_2^{(x)}, …x_n^{(x)})$, 他所对应的$y_x$是多少呢？如果这个问题里面的y是连续的，则是一个回归问题，否则是一个分类问题。

对于n维特征的样本数据，如果我们决定使用线性回归，那么对应的模型是这样的：

$h_\theta(x_1, x_2, …x_n) = \theta_0 + \theta_{1}x_1 + … + \theta_{n}x_{n}$, 其中$\theta_i$ (i = 0,1,2… n)为模型参数，$x_i$ (i = 0,1,2… n)为每个样本的n个特征值。这个表示可以简化，我们增加一个特征$x_0 = 1$，这样$h_\theta(x_0, x_1, …x_n) = \sum\limits_{i=0}^{n}\theta_{i}x_{i}$。

💡 均方误差(MSE)
$$ > MSE=\frac{1}{n}\sum_{i=1}^{m}w_i(y_i-\widehat{y_i})^2 > $$

其中$y_i$是真实数据，$\widehat{y_i}$是拟合的数据，$w_i>0$

得到了模型，我们需要求出需要的损失函数，一般线性回归我们用 均方误差(MSE) 作为损失函数。损失函数的代数法表示如下：

$$ J(\theta_0, \theta_1..., \theta_n) = \sum\limits_{i=1}^{m}(h_\theta(x_0^{(i)}, x_1^{(i)}, ...x_n^{(i)}) - y_i)^2 $$

由于矩阵形式不好理解，这里就不列出了。

如何求损失函数最小化时候的$\mathbf{\theta}$参数，这时就需要使用梯度下降法了。

梯度下降法

梯度

在微积分里面，对多元函数的参数求∂偏导数，把求得的各个参数的偏导数以向量的形式写出来，就是梯度。那么这个梯度向量求出来有什么意义呢？他的意义从几何意义上讲，就是函数变化增加最快的地方。

梯度下降的直观解释

首先来看看梯度下降的一个直观的解释。比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去，一直走到觉得我们已经到了山脚。当然这样走下去，有可能我们不能走到山脚，而是到了某一个局部的山峰低处。

从上面的解释可以看出，梯度下降不一定能够找到全局的最优解，有可能是一个局部最优解。当然，如果损失函数是凸函数，梯度下降法得到的解就一定是全局最优解。

梯度下降法的代数方式描述

在上面的内容中，我们知道了线性回归的函数为：

$$ h_\theta(x_0, x_1, ...x_n) = \sum\limits_{i=0}^{n}\theta_{i}x_{i} $$

损失函数为：

$$ J(\theta_0, \theta_1..., \theta_n) = \sum\limits_{i=1}^{m}(h_\theta(x_0^{(i)}, x_1^{(i)}, ...x_n^{(i)}) - y_i)^2 $$

算法相关参数初始化：主要是初始化$\theta_0, \theta_1…, \theta_n$ ,算法终止距离$\varepsilon$ 以及步长$\alpha$ 。在没有任何先验知识的时候，我喜欢将所有的$\theta$ 初始化为0，将步长初始化为1，在调优的时候再优化。

算法过程：

确定当前位置的损失函数的梯度，对于$\theta_i$ ,其梯度表达式如下：
$$ \frac{\partial}{\partial\theta_i}J(\theta_0, \theta_1..., \theta_n)= \frac{1}{m}\sum\limits_{j=0}^{m}(h_\theta(x_0^{(j)}, x_1^{(j)}, ...x_n^{(j)}) - y_j)x_i^{(j)} $$
用步长乘以损失函数的梯度，得到当前位置下降的距离，即 $\alpha\frac{\partial}{\partial\theta_i}J(\theta_0, \theta_1…, \theta_n)$ 对应于前面登山例子中的某一步。
确定是否所有的 $\theta_i$ ,梯度下降的距离都小于 $\varepsilon$ ，如果小于 $\varepsilon$ 则算法终止，当前所有的 $\theta_i$ (i=0,1,…n)即为最终结果。否则进入步骤4.
更新所有的$\theta$ ，对于 $\theta_i$ ，其更新表达式如下。更新完毕后继续转入步骤1.
$$ \theta_i = \theta_i - \alpha\frac{\partial}{\partial\theta_i}J(\theta_0, \theta_1..., \theta_n) = \theta_i - \alpha (h_\theta(x_0^{(j)}, x_1^{(j)}, ...x_n^{(j)}) - y_j)x_i^{(j)} $$

从这个例子可以看出当前点的梯度方向是由所有的样本决定的，加 $\frac{1}{m}$ 是为了好理解。由于步长也为常数，他们的乘机也为常数，所以这里 $\alpha\frac{1}{m}$ 可以用一个常数表示。

在下面第4节会详细讲到的梯度下降法的变种，他们主要的区别就是对样本的采用方法不同。这里我们采用的是用所有样本。

随机梯度下降法(SGD)

随机梯度下降法，其实和批量梯度下降法原理类似，区别在与求梯度时没有用所有的m个样本的数据，而是仅仅选取一个样本j来求梯度。对应的更新公式是

$$ \theta_i = \theta_i - \alpha (h_\theta(x_0^{(j)}, x_1^{(j)}, ...x_n^{(j)}) - y_j)x_i^{(j)} $$

随机梯度下降法，和批量梯度下降法是两个极端，一个采用所有数据来梯度下降，一个用一个样本来梯度下降。自然各自的优缺点都非常突出。对于训练速度来说，随机梯度下降法由于每次仅仅采用一个样本来迭代，训练速度很快，而批量梯度下降法在样本量很大的时候，训练速度不能让人满意。对于准确度来说，随机梯度下降法用于仅仅用一个样本决定梯度方向，导致解很有可能不是最优。对于收敛速度来说，由于随机梯度下降法一次迭代一个样本，导致迭代方向变化很大，不能很快的收敛到局部最优解。

编程实现

网上找的代码，没验证，看个思路就行

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


function [ theta,J_history ] = StochasticGD( X, y, theta, alpha, num_iter )
m = length(y);
J_history = zeros(20, 1);
temp = 0;
n = 0;
for iter = 1:num_iter
 temp = temp + 1;
 index = randi(m);
 theta = theta -alpha * (X(index, :) * theta - y(index)) * X(index, :)';
 if temp>=100
 temp = 0;
 n = n + 1;
 J_history(n) = ComputeCost(X, y, theta);
 end
end
end

小批量梯度下降法(Mini-Batch SGD)

也就是对于m个样本，我们采用x个样子来迭代，1<x<m。一般可以取x=10，当然根据样本的数据，可以调整这个x的值。

岭回归

~~助教妹说就是不考~~ 反转了，居然要考

在原先的线性回归的代价函数上加入了一个L2正则项，就是岭回归

$$ J(\theta_0, \theta_1..., \theta_n) = \sum\limits_{i=1}^{m}(h_\theta(x_0^{(i)}, x_1^{(i)}, ...x_n^{(i)}) - y_i)^2+\lambda \sum_{i=1}^m\theta_i^2 $$

非线性形式

助教妹说就是不考

参考链接

友链

Thu, 19 May 2022 17:36:00 +0800

如果你的博客符合社会主义核心价值观，欢迎按下面的格式在评论区或者发邮件提交你的博客，我会在审核后添加至此页面。

1
2
3
4


- title: #在本页展示的名称，一般为你的昵称或博客名称
 description: #一句话描述你或你的博客
 website: #你站点的 URL
 image: #你头像的 URL

你申请友链无需将我的博客添加至你博客友链。

如果你想添加我的博客至你博客友链，可以参照下面的信息

1
2
3
4


- title: luoboQAQ的博客
 description: 快乐学习每一天
 website: https://lbqaq.top/
 image: https://cdn.jsdelivr.net/gh/luoboQAQ/luoboQAQ.github.io/android-chrome-192x192.png

数据可视化笔记

Tue, 17 May 2022 22:45:18 +0800

主成分分析(PCA)

基本思想

PCA顾名思义，就是找出数据里最主要的方面，用数据里最主要的方面来代替原始数据。具体的，假如我们的数据集是n维的，共有m个数据$(x^{(1)},x^{(2)},…,x^{(m)})$。我们希望将这m个数据的维度从n维降到n’维，希望这m个n’维的数据集尽可能的代表原始数据集。

通过计算数据矩阵的协方差矩阵，然后得到协方差矩阵的特征值特征向量，选择特征值最大(即方差最大)的k个特征所对应的特征向量组成的矩阵。这样就可以将数据矩阵转换到新的空间当中，实现数据特征的降维。

由于得到协方差矩阵的特征值特征向量有两种方法：特征值分解协方差矩阵、奇异值分解协方差矩阵，所以PCA算法有两种实现方法：基于特征值分解协方差矩阵实现PCA算法、基于SVD分解协方差矩阵实现PCA算法。

特征值分解(EVD)

特征值和特征向量的定义如下：

$$ Ax=\lambda x $$

其中A是一个$n \times n$的实对称矩阵，$x$是一个$n$维向量，则我们说$\lambda$是矩阵A的一个特征值，而$x$是矩阵A的特征值$\lambda$所对应的特征向量。

求出特征值和特征向量有什么好处呢？就是我们可以将矩阵A特征分解。如果我们求出了矩阵A的$n$个特征值$\lambda_1 \leq \lambda_2 \leq … \leq \lambda_n$,以及这$n$个特征值所对应的特征向量${q_1,q_2,…q_n}$，如果这$n$个特征向量线性无关，那么矩阵A就可以用下式的特征分解表示：$A=Q\Sigma Q^{-1}$ 。

其中，Q是这个矩阵A的特征向量组成的矩阵，Σ是一个对角矩阵，每一个对角线元素就是一个特征值，里面的特征值是由大到小排列的，这些特征值所对应的特征向量就是描述这个矩阵变化方向（从主要的变化到次要的变化排列）。也就是说矩阵A的信息可以由其特征值和特征向量表示。

注意到要进行特征分解，矩阵A必须为方阵。那么如果A不是方阵，即行和列不相同时，我们还可以对矩阵进行分解吗？答案是可以，此时我们的SVD登场了。

奇异值分解(SVD)

SVD也是对矩阵进行分解，但是和特征分解不同，SVD并不要求要分解的矩阵为方阵。假设我们的矩阵A是一个$m \times n$的矩阵，那么我们定义矩阵A的SVD为：

$$ A = U\Sigma V^T $$

其中U是一个$m \times m$的矩阵，$\Sigma$是一个$m \times n$的矩阵，除了主对角线上的元素以外全为0，主对角线上的每个元素都称为奇异值，V是一个$n \times n$的矩阵。

计算方法：

我们将A的转置和A做矩阵乘法，那么会得到$n \times n$的一个方阵$A^TA$。对其进行特征值分解，得到n个特征值和对应的n个特征向量$v$了。将$A^TA$的所有特征向量张成一个$n \times n$的矩阵V，就是我们SVD公式里面的V矩阵了。
对$AA^T$进行特征值分解，得到m个特征值和对应的m个特征向量$u$了。将$AA^T$的所有特征向量张成一个$m \times m$的矩阵U，就是我们SVD公式里面的U矩阵了。一般我们将U中的每个特征向量叫做A的左奇异向量。
由于奇异值矩阵$\Sigma$除了对角线上是奇异值其他位置都是0，那我们只需要求出每个奇异值$\sigma$就可以了。求解奇异值可以用$\sigma_i = Av_i / u_i$或$\sigma_i = \sqrt{\lambda_i}$

算法过程

输入：n维样本集$D=(x^{(1)}, x^{(2)},…,x^{(m)})$，要降维到的维数n'.

输出：降维后的样本集$D'$

对所有的样本进行中心化： $x^{(i)} = x^{(i)} - \frac{1}{m}\sum\limits_{j=1}^{m} x^{(j)}$
计算样本的协方差矩阵$XX^T$
对矩阵$XX^T$进行特征值分解
取出最大的n’个特征值对应的特征向量$(w_1,w_2,…,w_{n’})$, 将所有的特征向量标准化后，组成特征向量矩阵W。
对样本集中的每一个样本$x^{(i)}$,转化为新的样本$z^{(i)}=W^Tx^{(i)}$
得到输出样本集$D’ =(z^{(1)}, z^{(2)},…,z^{(m)})$

上面是采用EVD，如果采用SVD，在第二第三步时就用SVD进行解决。

编程实现

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


load fisheriris;
X = meas;
%% 中心化
meanX = ones(size(X,1), 1) * mean(X);
centredX = X - meanX;
% 直接调用cov直接计算协方差矩阵即可
C = cov(centredX);
%% 特征值分解
[W, Lambda] = eig(C);
% 提取特征值
ev = (diag(Lambda))';
% eig计算出的特征值是升序的，这里手动倒序（W同理）
ev = ev(:, end:-1:1);
W = W(:, end:-1:1);
% 提取前两个主成分的特征向量
Wr = W(:, 1:2);
% 新坐标空间的数据点
Tr = centredX * Wr;
%% 作图
figure(1);
scatter(Tr(:,1), Tr(:,2), 130, categorical(species), '.');
colormap(winter);
xlabel('Principal Component 1');
ylabel('Principal Component 2');
%% SVD分解
% 可以检验，W和V完全相同（向量的正负号不影响）
[U, Sigma, V] = svd(X);
% 提取前两个主成分的特征向量
Vr = V(:, 1:2);
% 新坐标空间的数据点
Tr = X * Vr;
%% 作图
figure(2);
scatter(Tr(:,1), Tr(:,2), 130, categorical(species), '.');
colormap(winter);
xlabel('Principal Component 1');
ylabel('Principal Component 2');

MATLAB三维数据绘图

三维线

使用plot3()函数即可绘制三维线,输入应为三个向量

1
2
3
4
5
6
7
8


turns = 40*pi;
t = linspace(0,turns,4000);
x = cos(t).*(turns-t)./turns;
y = sin(t).*(turns-t)./turns;
z = t./turns;
plot3(x,y,z);
grid on;
axis square;

三维图形绘制及等高线

我们可以通过使用mesh()命令绘制三维面，使用contour()命令可以绘制三维图形的等高线。与之前的命令一样，我们也可以通过向其传递不同的参数来改变图形的细节。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


x = -3.5:0.2:3.5; y = -3.5:0.2:3.5;
[X,Y] = meshgrid(x,y);
Z = 10.*X.*exp(-X.^2-Y.^2);

grid on;
axis square;
subplot(1,2,1);
mesh(X,Y,Z);
subplot(1,2,2);
contour(X,Y,Z,'ShowText', 'on', 'LevelStep', 1);

三维图形绘制及等高线

参考资料

分类算法学习笔记

Tue, 10 May 2022 14:00:16 +0800

分类算法的作用

分类是在一群已经知道类别标号的样本中，训练一种分类器，让其能够对某种未知的样本进行分类。分类算法属于一种有监督的学习。分类算法的分类过程就是建立一种分类模型来描述预定的数据集或概念集，通过分析由属性描述的数据库元组来构造模型。分类的目的就是使用分类对新的数据集进行划分，其主要涉及分类规则的准确性、过拟合、矛盾划分的取舍等。

有监督学习和无监督学习的区别
- 有监督学习是指数据集的正确输出已知情况下的一类学习算法。因为输入和输出已知，意味着输入和输出之间有一个关系，监督学习算法就是要发现和总结这种“关系”。
- 无监督学习是指对无标签数据的一类学习算法。因为没有标签信息，意味着需要从数据集中发现和总结模式或者结构。
- 简单来说，是否有监督（supervised），就看输入数据是否有标签（label）

交叉验证

基本思想

交叉验证的基本思想是把在某种意义下将原始数据(dataset)进行分组，一部分做为训练集(train set)，另一部分做为验证集(validation set or test set)，首先用训练集对分类器进行训练，再利用验证集来测试训练得到的模型(model)，以此来做为评价分类器的性能指标。用交叉验证的目的是为了得到可靠稳定的模型。

K折交叉验证(K-fold cross-validation)

K折交叉验证就是进行多次train_test_split划分；每次划分时，在不同的数据集上进行训练、测试评估，从而得出一个评价结果；如果是10折交叉验证，意思就是在原始数据集上，进行10次划分，每次划分进行一次训练、评估，最后得到10次划分后的评估结果，一般在这几次评估结果上取平均得到最后的评分。其中，k一般取5或10。

K折交叉验证的步骤：

将原始数据集划分为相等的K部分（“折”）
将第1部分作为测试集，其余作为训练集
训练模型，计算模型在测试集上的准确率
每次用不同的部分作为测试集，重复步骤2和3 K次
将平均准确率作为最终的模型准确率

💡 要会给定数据集进行K折交叉验证要会计算模型准确率（每次的准确率、最终的准确率）

支持向量机(SVM)

基本思想

SVM学习的基本思想是求解能够正确划分训练数据集并且几何间隔最大的分离超平面。对于线性可分的数据集来说，这样的超平面有无穷多个（即感知机），但是几何间隔最大的分离超平面却是唯一的。

用我自己的理解，就是找一条线将两个数据集分开，要保证这条线到两边的数据集距离最大。那么，如何才能保证距离最大呢，这就是下面要讨论的难点了。

支持向量

在支持向量机中，距离超平面最近的且满足一定条件的几个训练样本点被称为支持向量。

在上图中，处于虚线上的点（即红色的点）我们就将其定义为支持向量。那么，如何得到支持向量到超平面的距离呢？我们引入几何间隔的概念：

$$ \gamma = \frac{y(w^Tx + b)}{||w||_2} = \frac{\gamma^{'}}{||w||_2} $$

一般我们都取函数间隔$\gamma^{’}$为1，这样我们就可以得到支持向量到超平面的距离为$\frac{1}{||w||_2}$，两个支持向量之间的距离为$\frac{2}{||w||_2}$

SVM模型目标函数

SVM的模型是让所有点到超平面的距离大于一定的距离，也就是所有的分类点要在各自类别的支持向量两边。用数学式子表示为：

$$ max \\;\\; \frac{1}{||w||_2} \\;\\; s.t \\;\\; y_i(w^Tx_i + b) \geq 1 (i =1,2,...m) $$

其中，$||w||_2$为向量$w$的L2范数，即：

$$ ||w||_2=\sqrt{w_1^2+w_2^2} $$

为了去除根号方便计算，我们将原式转化为：

$$ min \\;\\; \frac{1}{2}||w||_2^2 \\;\\; s.t \\;\\; y_i(w^Tx_i + b) \geq 1 (i =1,2,...m) $$

由于目标函数$\frac{1}{2}||w||_2^2$是凸函数，同时约束条件不等式是仿射的，根据凸优化理论，我们可以通过拉格朗日函数将我们的优化目标转化为无约束的优化函数。于是根据拉格朗日乘子法，我们得到：

$$ L(w,b,\alpha) = \frac{1}{2}||w||_2^2 - \sum \limits _{i=1}^{m} \alpha_i [y_i(w^Tx_i + b) - 1] \\; 满足\alpha_i \geq 0 $$

其中$\alpha_i$为拉格朗日乘子。

KKT条件

我们对上面的式子求偏导，可以得到

$$ \frac{\partial L }{\partial w}=0,\frac{\partial L }{\partial b}=0 $$

解得

$$ \boldsymbol{w}=\sum_{i=1}^N{\alpha_iy_i\boldsymbol{x}_{\boldsymbol{i}}} $$$$ \sum_{i=1}^N{\alpha_iy_i}=0 $$

解方程可得

$$ \begin{cases} \alpha_i\geq 0 \\\\ y_i(\overrightarrow{w_i}\cdot \overrightarrow{x_i}+b)-1\geq 0 \\\\ \alpha_i(y_i(\overrightarrow{w_i}\cdot\overrightarrow{x_i}+b)-1)=0 \end{cases} $$

上面的式子即为KKT条件

SVM对偶性

现在我们令

$$ \theta \left( \boldsymbol{w} \right) =\underset{\alpha _{_i}\ge 0}{\max}\ L\left( \boldsymbol{w,}b,\boldsymbol{\alpha } \right) $$

当样本点不满足约束条件时，即在可行解区域外$y_i\left(\boldsymbol{w}\cdot \boldsymbol{x}_{\boldsymbol{i}}+b\right)<1$。此时，将$\alpha_i$设置为无穷大，则$\theta \left( \boldsymbol{w} \right)$也为无穷大。

当样本点不满足约束条件时，即在可行解区域内$y_i\left(\boldsymbol{w}\cdot \boldsymbol{x}_{\boldsymbol{i}}+b\right)\ge1$。此时，$\theta \left( \boldsymbol{w} \right)$为原函数本身。

于是，将两种情况合并起来就可以得到我们新的目标函数：

$$ \theta \left( \boldsymbol{w} \right) =\begin{cases} \frac{1}{2}\lVert \boldsymbol{w} \rVert ^2\ ,\boldsymbol{x}\in \text{可行区域}\\\\ +\infty \ \ \ \ \ ,\boldsymbol{x}\in \text{不可行区域}\\\\ \end{cases} $$

于是原约束问题就等价于：

$$ \underset{\boldsymbol{w,}b}{\min}\ \theta \left( \boldsymbol{w} \right) =\underset{\boldsymbol{w,}b}{\min}\underset{\alpha _i\ge 0}{\max}\ L\left( \boldsymbol{w,}b,\boldsymbol{\alpha } \right) $$

由上小节，我们可以知道该函数满足拉格朗日函数对偶性：

优化问题是凸优化问题
满足KKT条件

于是，我们可以将其最小和最大的位置交换一下，这样就变成了：

$$ \underset{\alpha _i\ge 0}{\max}\underset{\boldsymbol{w,}b}{\min}\ L\left( \boldsymbol{w,}b,\boldsymbol{\alpha } \right) $$

从上式中，我们可以先求优化函数对于$w$和$b$的极小值。接着再求拉格朗日乘子$\alpha$的极大值。

通过在上节中由偏导推出的两个式子，我们得到了$w$和$\alpha$的关系，就可以带入优化函数$L(w,b,\alpha)$消去$w$了

此时原式为

我们对目标式子加一个负号，将求解极大转换为求解极小

SVM核（Kernel）方法

基本概念

在上节我们推导出的式子中，我们可以看到上式低维特征仅仅以内积$x_i \bullet x_j$ 的形式出现，如果我们定义一个低维特征空间到高维特征空间的映射$T$，将所有特征映射到一个更高的维度，让数据线性可分，我们就可以求出分离超平面和分类决策函数了。

但是，将数据从低维映射到高维，将会大大增加计算的复杂度，如果遇到无穷维的情况，就根本无从计算了。这时，就需要引入核函数了。

我们定义果存在函数$K(x,z)$，对于任意$x, z$ ，都有：

$$ K(x, z) = T(x) \bullet T(z) $$

那么我们就称$K(x, z)$为核函数。

通过核函数，就避免了在刚才我们提到了在高维维度空间计算内积的恐怖计算量。也就是说，我们可以好好享受在高维特征空间线性可分的红利，却避免了高维特征空间恐怖的内积计算量。

下面我们来看看常见的核函数, 选择这几个核函数介绍是因为scikit-learn中默认可选的就是下面几个核函数。

线性核函数（Linear Kernel）

其实就是线性可分SVM，表达式为：

$$ K(x, z) = x \bullet z $$

也就是说，线性可分SVM我们可以和线性不可分SVM归为一类，区别仅仅在于线性可分SVM用的是线性核函数。

多项式核函数（Polynomial Kernel）

多项式核函数是线性不可分SVM常用的核函数之一，表达式为：

$$ K(x, z) = （\gamma x \bullet z + r)^d $$

其中，$\gamma, r,d$都需要自己调参定义。

高斯核函数（Gaussian Kernel）

在SVM中也称为径向基核函数（Radial Basis Function,RBF），它是非线性分类SVM最主流的核函数。libsvm默认的核函数就是它。表达式为：

$$ K(x, z) = exp(-\gamma||x-z||^2) $$

其中，$\gamma$大于0，需要自己调参定义。

💡 高斯核函数很重要，一定要记住

Sigmoid核函数

也是线性不可分SVM常用的核函数之一，表达式为：

$$ K(x, z) = tanh（\gamma x \bullet z + r) $$

其中，$\gamma, r$都需要自己调参定义。

SVM软间隔

有时候本来数据的确是可分的，也就是说可以用线性分类SVM的学习方法来求解，但是却因为混入了异常点，导致不能线性可分，比如下图

这种情况下，SVM引入了软间隔最大化的方法来解决。

SVM对训练集里面的每个样本$(x_i,y_i)$引入了一个松弛变量$\xi_i \geq 0$,使函数间隔加上松弛变量大于等于1，也就是说：

$$ y_i(w\bullet x_i +b) \geq 1- \xi_i $$

对比硬间隔最大化，可以看到我们对样本到超平面的函数距离的要求放松了，之前是一定要大于等于1，现在只需要加上一个大于等于0的松弛变量能大于等于1就可以了。当然，松弛变量不能白加，这是有成本的，每一个松弛变量$\xi_i$, 对应了一个代价$\xi_i$，这个就得到了我们的软间隔最大化的SVM学习条件如下：

$$ min\\;\\; \frac{1}{2}||w||_2^2 +C\sum\limits{i=1}^{m}\xi_i $$$$ s.t. \\;\\; y_i(w^Tx_i + b) \geq 1 - \xi_i \\;\\;(i =1,2,...m) $$$$ \xi_i \geq 0 \\;\\;(i =1,2,...m) $$

这里，$C>0$为惩罚参数，可以理解为我们一般回归和分类问题正则化时候的参数。$C$越大，对误分类的惩罚越大，$C$越小，对误分类的惩罚越小。

也就是说，我们希望$\frac{1}{2}||w||_2^2$尽量小，误分类的点尽可能的少。C是协调两者关系的正则化惩罚系数。在实际应用中，需要调参来选择。

SVM编程实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


%% 生成测试数据
classCount= 2;
p= 100;
bound =[0 10];
data =[...
 [2,2]+ randn(p,2),-1*ones(p,1);...
 [6,6]+ randn(p,2),+1*ones(p,1);...
 ];
X= data(:,1:end-1);
Y = data(:,end);
%% 显示生成的测试数据
figure(1)
clf;
gscatter(X(:,1), X(:,2), Y, 'rb', 'X+');
legend({'分类-1', '分类+1'});
title("原始数据散点图");
xlim(bound);
ylim(bound);
%% 拆分训练集和测试集
trainIndex = (mod(1:size(X,1),3)==1);
testIndex = ~trainIndex;

Xtrain=X(trainIndex,:);
Ytrain=Y(trainIndex,:);
Xtest=X(testIndex,:);
Ytest=Y(testIndex,:);
%% 将拆分的结果展示
figure(2)
clf;
hold on;
gscatter(Xtrain(:,1),Xtrain(:,2),Ytrain,'rb','X+');
scatter(Xtest(:,1),Xtest(:,2),'k.');
hold off;
legend({'分类-1','分类+1','测试数据'});
title("划分测试数据后的散点图");
xlim(bound);
ylim(bound);
%% 使用SVM进行训练
svm=fitcsvm(Xtrain,Ytrain);
%% 展示SVM训练的结果
figure(3)
clf;
gscatter(Xtrain(:,1), Xtrain(:, 2), Ytrain, 'rb', 'X+');
hold on;
gscatter(svm.SupportVectors(:,1), svm.SupportVectors(:,2),svm.SupportVectorLabels,'rb','oo',13);
xg = bound;
yg = [-svm.Bias/svm.Beta(2) -svm.Beta(1)/svm.Beta(2) * bound(2)-svm.Bias/svm.Beta(2)];
plot(xg, yg, 'g', 'Linewidth', 2);
delta = -svm.Beta(1)/svm.Beta(2)*svm.SupportVectors(1,1)-svm.SupportVectors(1,2)-svm.Bias/svm.Beta(2);
plot(xg, yg-delta, '--g', 'LineWidth', 2);
plot(xg, yg+delta, '--g', 'LineWidth', 2);
hold off;
xlim(bound);
ylim(bound);
legend({'分类-1', '分类+1', '支持向量-1', '支持向量+1', '超平面', '超平面-1', '超平面+1'});
title("SVM训练后的散点图");
%% 使用训练好的模型进行预测
Ypred = predict(svm, Xtest);
%% 绘制预测后的结果
figure(4)
clf;
gscatter(Xtest(:,1), Xtest(:, 2), Ypred, 'rb', 'X+');
hold on;
g = gscatter(svm.SupportVectors(:,1), svm.SupportVectors(:,2), svm.SupportVectorLabels, 'rb','oo',13);
plot(xg, yg, 'g', 'Linewidth', 2);
plot(xg, yg-delta, '--g', 'Linewidth', 2);
plot(xg, yg+delta, '--g', 'Linewidth', 2);
hold off;
xlim(bound);
ylim(bound);
legend({'分类-1', '分类+1', '支持向量-1', '支持向量+1', '超平面', '超平面-1', '超平面+1'});
title("SVM预测后的散点图");
%% 计算误差
fprintf('正确率为：%.2f%%\n',(sum(Ypred==Ytest)/numel(Ytest)).*100);

SVM实现多分类

SVM算法最初是为二值分类问题设计的，当处理多类问题时，就需要构造合适的多类分类器。

目前，构造SVM多类分类器的方法主要有两类：

（1）直接法，直接在目标函数上进行修改，将多个分类面的参数求解合并到一个最优化问题中，通过求解该最优化问题“一次性”实现多类分类。这种方法看似简单，但其计算复杂度比较高，实现起来比较困难，只适合用于小型问题中；

（2）间接法，主要是通过组合多个二分类器来实现多分类器的构造，常见的方法有one-against-one和one-against-all两种。

一对多法（OVR）

训练时依次把某个类别的样本归为一类,其他剩余的样本归为另一类，这样k个类别的样本就构造出了k个SVM。分类时将未知样本分类为具有最大分类函数值的那类。

假如我有四类要划分（也就是4个Label），他们是A、B、C、D。

于是我在抽取训练集的时候，分别抽取

A所对应的向量作为正集，B，C，D所对应的向量作为负集；
B所对应的向量作为正集，A，C，D所对应的向量作为负集；
C所对应的向量作为正集，A，B，D所对应的向量作为负集；
D所对应的向量作为正集，A，B，C所对应的向量作为负集；

使用这四个训练集分别进行训练，然后的得到四个训练结果文件。在测试的时候，把对应的测试向量分别利用这四个训练结果文件进行测试。最后每个测试都有一个结果f1(x),f2(x),f3(x),f4(x)。

于是最终的结果便是这四个值中最大的一个作为分类结果。

一对一法（OVO）

一般都是用一对多法，这里就不展开了，知道有这个东西就行。

参考资料

支持向量机（SVM）——原理篇 - 知乎
支持向量机原理(一) 线性支持向量机 - 刘建平Pinard - 博客园等同系列文章
【数之道25】机器学习必经之路-SVM支持向量机的数学精华_哔哩哔哩_bilibili 等同系列视频

聚类算法学习笔记

Tue, 10 May 2022 08:23:41 +0800

Kmeans

算法步骤

从样本中选择 K 个点作为初始质心（完全随机）
计算每个样本到各个质心的距离，将样本划分到距离最近的质心所对应的簇中
计算每个簇内所有样本的均值，并使用该均值更新簇的质心
重复步骤 2 与 3 ，直到达到以下条件之一：
- 质心的位置变化小于指定的阈值（默认为 0.0001）
- 达到最大迭代次数

欧氏距离

衡量的是多维空间中两个点之间的绝对距离

在二维和三维空间中的欧氏距离就是两点之间的实际距离

计算方法：对应坐标值相减的平方和再开方

$$ dist(X,Y)=\sqrt{\sum_{i=1}^{n}(x_i-y_i)^2} $$

对于二维来说，就是

$$ dist(X,Y)=\sqrt{(x_1-y_1)^2+(x_2-y_2)^2} $$

注意理解输入？输出？类别中心？迭代过程中做什么？

编程实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


%% 生成测试数据
clear
p=100; % 每簇的样本数
sigma = [0.1 0;0 0.1]; % 协方差矩阵
R = chol(sigma);
% 生成测试数据集
data=[...
 [0 0] + randn(p,2)*R,1*ones(p,1);...
 [0 2] + randn(p,2)*R,2*ones(p,1);...
 [2 0] + randn(p,2)*R,3*ones(p,1);...
 [2 2] + randn(p,2)*R,4*ones(p,1);...
 ];
%% 绘制样本散点图
figure(1)
scatter(data(:,1),data(:,2),'r.')
title("无样式样本散点图")
X=data(:,1:end-1);
g=data(:,end);
n=size(X,1);
%% K-means实现
k=4; % 指定分成的簇数

%从n个数据样本中不重复地随机选择k个样本作为质
centerIndex = randperm(n, k);
C = X(centerIndex, :);

result = struct('y',[],'C',[],'objectives',[]);
iter = 0;
maxIter = 10; % 指定最大迭代的次数
while (iter < maxIter)
 iter = iter + 1;

 % 求出每个样本到中心点的距离，按照距离自身最近的中心点进行聚类
 D = pdist2(X, C);
 [d, ypred] = min(D, [], 2);

 % 保存结果
 result(iter).y = ypred;
 result(iter).C = C;
 result(iter).objectives = sum(d.*d);

 % 当距离没变时结束迭代
 if(iter > 1 && result(iter).objectives == result(iter-1).objectives)
 break;
 end

 % 依据上次聚类结果，求出新的中心点
 for cid = 1: size(C,1)
 C(cid, :) = mean (X(ypred == cid, :));
 end
end
%% 绘制结果散点图
figure(2);
for t = 1: numel(result)
 figure(2);
 clf
 % 绘制聚类结果
 gscatter(X(:,1), X(:,2), result(t).y,'rgbm');
 hold on;
 Ct = result(t).C;
 % 绘制聚类中心
 h=gscatter(Ct(:,1), Ct(:,2), (1: size(Ct,1)), 'kkkk', 'x+od', 10);
 title("第"+t+"次迭代后散点图")
 set(h,'LineWidth', 2.0);
 waitforbuttonpress;
 %pause(1);
end
%% 计算误差
% 输出混淆矩阵
confusionmat(g,ypred)

缺点

容易受初始质心的影响；算法聚类时，容易产生空簇；算法可能收敛到局部最小值。

解决办法：重新执行K-means算法，重新分配质心

谱聚类(Spectral Clustering)

算法思想

把所有的数据看做空间中的点，这些点之间可以用边连接起来。距离较远的两个点之间的边权重值较低，而距离较近的两个点之间的边权重值较高，通过对所有数据点组成的图进行切图，让切图后不同的子图间边权重和尽可能的低，而子图内的边权重和尽可能的高，从而达到聚类的目的。

度矩阵D

对于一个图$G$，我们一般用点的集合$V$和边的集合$E$来描述。即为$G(V,E)$。其中$V$即为我们数据集里面所有的点$(v_1, v_2,…v_n)$。对于$V$中的任意两个点，可以有边连接，也可以没有边连接。我们定义权重$w_{ij}$为点$v_i$和点$v_j$之间的权重。由于我们是无向图，所以$w_{ij} = w_{ji}$。

对于有边连接的两个点$v_i$和$v_j$，$w_{ij} > 0$,对于没有边连接的两个点$v_i$和$v_j$，$w_{ij} = 0$。对于图中的任意一个点$v_i$，它的度$d_i$定义为和它相连的所有边的权重之和，即

$$ d_i = \sum\limits_{j=1}^{n}w_{ij} $$

利用每个点度的定义，我们可以得到一个nxn的度矩阵$D$,它是一个对角矩阵，只有主对角线有值，对应第i行的第i个点的度数，定义如下：

$$ \mathbf{D} = \left( \begin{array}{ccc} d_1 & \ldots & \ldots \\\\ \ldots & d_2 & \ldots \\\\ \vdots & \vdots & \ddots \\\\ \ldots & \ldots & d_n \end{array} \right) $$

利用所有点之间的权重值，我们可以得到图的邻接矩阵$W$，它也是一个nxn的矩阵，第i行的第j个值对应我们的权重$w_{ij}$。

除此之外，对于点集$V$的的一个子集$A \subset V$，我们定义：

$$ |A|: = 子集A中点的个数 $$$$ vol(A): = \sum\limits_{i \in A}d_i $$

相似矩阵

构建邻接矩阵$W$的方法有三类：

$\epsilon$-邻近法

它设置了一个距离阈值$\epsilon$，然后用欧式距离$s_{ij}$度量任意两点$x_i$和$x_j$的距离。然后根据$s_{ij}$和$\epsilon$的大小关系，来定义邻接矩阵$W$。距离小于$\epsilon$为$\epsilon$，距离大于$\epsilon$为0
K邻近法

利用KNN算法遍历所有的样本点，取每个样本最近的k个点作为近邻，只有和样本距离最近的k个点之间的$w_{ij} > 0$。但是这种方法会造成重构之后的邻接矩阵W非对称。
全连接法（最常用）

相比前两种方法，第三种方法所有的点之间的权重值都大于0，因此称之为全连接法。可以选择不同的核函数来定义边权重，常用的有多项式核函数，高斯核函数和Sigmoid核函数，最常用的是高斯核函数RBF。

$$ w_{ij}=s_{ij}=exp(-\frac{||x_i-x_j||_2^2}{2\sigma^2}) $$

💡 exp(x)表示$e^x$

拉普拉斯矩阵

拉普拉斯矩阵$L= D-W$

$D$即为度矩阵，它是一个对角矩阵。$W$为邻接矩阵。

无向图切图

对于无向图$G$的切图，我们的目标是将图$G(V,E)$切成相互没有连接的k个子图，每个子图点的集合为：$A_1,A_2,..A_k$，它们满足$A_i \cap A_j = \emptyset$,且$A_1 \cup A_2 \cup … \cup A_k = V$.

对于任意两个子图点的集合$A, B \subset V$, $A \cap B = \emptyset$, 我们定义A和B之间的切图权重为：

$$ W(A, B) = \sum\limits_{i \in A, j \in B}w_{ij} $$

最小化切图
$$ \min cut(A,B)=\sum\limits_{i \in A, j \in B}w_{ij} $$
RatioCut切图
$$ RatioCut(A,B)=cut(A,B)(\frac{1}{|A|}+\frac{1}{|B|}) $$
Ncut切图
$$ Ncut(A,B)=cut(A,B)(\frac{1}{vol(A)}+\frac{1}{vol(B)}) $$

算法流程

最常用的相似矩阵的生成方式是基于高斯核距离的全连接方式，最常用的切图方式是Ncut。而到最后常用的聚类方法为K-Means。

输入：样本集D=$(x_1,x_2,…,x_n)$，相似矩阵的生成方式, 降维后的维度$k_1$, 聚类方法，聚类后的维度$k_2$

输出：簇划分$C(c_1,c_2,…c_{k_2})$.

根据输入的相似矩阵的生成方式构建样本的相似矩阵S
根据相似矩阵S构建邻接矩阵W，构建度矩阵D
计算出拉普拉斯矩阵L
构建标准化后的拉普拉斯矩阵$D^{-1/2}LD^{-1/2}$
计算$D^{-1/2}LD^{-1/2}$最小的$k_1$个特征值所各自对应的特征向量$f$
将各自对应的特征向量$f$组成的矩阵按行标准化，最终组成$n \times k_1$维的特征矩阵F
对F中的每一行作为一个$k_1$维的样本，共n个样本，用输入的聚类方法进行聚类，聚类维数为$k_2$
得到簇划分$C(c_1,c_2,…c_{k_2})$

编程实现

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


rng('default')
%% 生成测试数据
p= 200;
theta = linspace(0,2*pi,p)';
data =[...
 2*[cos(theta) sin(theta)]+ rand(p,1),1*ones(p,1);
 4*[cos(theta) sin(theta)]+ rand(p,1),2*ones(p,1);
 ];
X = data(:,1:end-1);
y = data(:,end);
gscatter(X(:,1),X(:,2),y,'rg');
%% 距离矩阵
Q = pdist2(X, X);
imagesc(Q);
colorbar;
%% 构造图的相似度矩阵A
sigma = 0.1;
A = exp(-Q.*Q / (2*sigma*sigma));
imagesc(A);
colorbar;
%% 构造图的拉普拉斯矩阵L
D = diag(sum(A,2));
L = D - A;
imagesc(L);
colorbar;
%% 对拉普拉斯矩阵进行特征值分解
[V,S] = eig(L);
s = diag(S);
plot(s);
%% 取最小的k个特征值对应的特征向量
k = 2;
Vr = V(:,1:k);
Vr([1:2, end-1:end],:)
%% 对映射后的特征矩阵Vr进行kmeans聚类
idx = kmeans(Vr,k);
gscatter(X(:,1),X(:,2),idx,'rg');
title(['谱聚类 \sigma = ',num2str(sigma)])

简化考试专用代码

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


% 数据为X,y
%% 距离矩阵
Q = pdist2(X, X);
%% 构造图的相似度矩阵A
sigma = 0.1;
A = exp(-Q.*Q / (2*sigma*sigma));
%% 构造图的拉普拉斯矩阵L
D = diag(sum(A,2));
L = D - A;
%% 对拉普拉斯矩阵进行特征值分解
[V,S] = eig(L);
%% 取最小的k个特征值对应的特征向量
k = 2;
Vr = V(:,1:k);
%% 对映射后的特征矩阵Vr进行kmeans聚类
idx = kmeans(Vr,k);

gscatter(X(:,1),X(:,2),idx,'rg');
title(['谱聚类 \sigma = ',num2str(sigma)])

参考文档

二分查找是个啥啊

Mon, 04 Apr 2022 22:54:54 +0800

打了两次力扣的周赛，都败在了第三题上，而且都是二分查找的题目。这下不能忍了，必须来总结一波。

第一次二分查找

二分查找是用来在一个有序数组中查找某一元素的算法。它的工作原理如下：

它每次考察数组当前部分的中间元素，如果中间元素刚好是要找的，就结束搜索过程；如果中间元素小于所查找的值，那么左侧的只会更小，不会有所查找的元素，只需到右侧查找；如果中间元素大于所查找的值同理，只需到左侧查找。

使用二分查找就能将原先$\Omicron(n)$时间复杂度的线性查找降低为$\Omicron(\log(n))$。但是一定要注意，二分查找一定要在有序的数组上进行。

下面放上模板：

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


int binary_search(vector<int>& nums, int target) {
 int left = 0, right = nums.size() - 1;
 int ret = -1; // 未搜索到数据返回-1下标
 int mid;
 while (left <= right) {
 mid = left + ((right - left) >> 1); // 直接平均可能会溢出，所以用这个算法
 if (nums[mid] < target)
 left = mid + 1;
 else if (nums[mid] > target)
 right = mid - 1;
 else { // 最后检测相等是因为多数搜索情况不是大于就是小于
 ret = mid;
 break;
 }
 }
 return ret; // 单一出口
}

在上面的代码中，我们每次搜索的是[left,right]这个闭区间，所以在while中要使用<=。

但是，这样的算法还是存在一些缺陷。比如对于条件nums = [1,2,2,2,3],target=2，使用上面的算法返回的下标是2。虽然答案是正确的，但我们想要得到target的左侧边界或右侧边界就不能使用上面的算法了。虽然可以先查出结果再向左或右线性搜索，但这样时间复杂度就被提高了。

寻找左侧边界的二分查找

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


int left_bound(vector<int>& nums, int target) {
 if (nums.size() == 0)
 return -1;
 int left = 0;
 int right = nums.size(); // 注意

 while (left < right) { // 注意
 int mid = (left + right) / 2;
 if (nums[mid] == target) {
 right = mid;
 } else if (nums[mid] < target) {
 left = mid + 1;
 } else if (nums[mid] > target) {
 right = mid; // 注意
 }
 }
 // target 比所有数都大
 if (left == nums.size())
 return -1;
 // 未查到目标值
 return nums[left] == target ? left : -1;
}

在这里我们搜索的区间变成了左闭右开[left,right)，所以在while中使用<。

由于搜索区间变为[left,right)，所以当 nums[mid]被检测之后，下一步的搜索区间应该去掉 mid分割成两个区间，即 [left, mid)或 [mid + 1, right)。在代码中体现为left = mid + 1;和right = mid;

那么，这个模板为什么能找到左边界呢？关键在于nums[mid] == target这种情况的处理：

right = mid;

我们找到 target 时没有立即返回，而是缩小「搜索区间」的上界 right，在区间 [left, mid)中继续搜索，即不断向左收缩，达到锁定左侧边界的目的。

寻找右侧边界的二分查找

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


int right_bound(vector<int>& nums, int target) {
 if (nums.size() == 0)
 return -1;
 int left = 0, right = nums.size();

 while (left < right) {
 int mid = (left + right) / 2;
 if (nums[mid] == target) {
 left = mid + 1; // 注意
 } else if (nums[mid] < target) {
 left = mid + 1;
 } else if (nums[mid] > target) {
 right = mid;
 }
 }
 if (left == 0)
 return -1;
 return nums[left - 1] == target ? (left - 1) : -1; // 注意要-1
}

由于我们对 left的更新必须是 left = mid + 1，这就导致了 while 循环结束时，nums[left]一定不等于 target了，而 nums[left-1]可能是 targe。所以我们在返回结果时要进行-1操作。

第二次二分查找

虽说上面的模板已经够好了，但是有些题目并不是只考一个二分，如果照着敲一遍模板还是比较费时的。这是就不得不祭出<algorithm>里的两个内置函数了：

lower_bound

返回指向范围 [first, last) 中首个不小于（即大于或等于） value 的元素的迭代器，或若找不到这种元素则返回 last 。

仔细考虑一下，就会发现这就是上面提到的寻找左侧边界的二分查找，一下就把原来那么长的代码变成了一行，太香了。（但是上面的模板还是要掌握，有些题目是无法调库）

使用举例：

1
2
3
4
5
6


int main() {
 vector<int> nums = {1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6};
 auto lower = lower_bound(nums.begin(), nums.end(), 3);
 cout << lower - nums.begin() << endl; //3
 return 0;
}

一个小细节，lower_bound返回的是迭代器，所以lower的真实类型是vector<int>::iterator，太长了所以我们用的时候还是使用auto让编译器来补全QuQ。

upper_bound

返回指向范围 [first, last) 中首个大于 value 的元素的迭代器，或若找不到这种元素则返回 last 。

其实就是上面寻找右侧边界的二分查找，只不过我们进行了-1操作而该函数没有而已。

使用举例：

1
2
3
4
5
6


int main() {
 vector<int> nums = {1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6};
 auto upper = upper_bound(nums.begin(), nums.end(), 3);
 cout << upper - nums.begin() << endl; //7
 return 0;
}

终极二分查找

上面的都是对一个数组进行二分查找，我们也可以把思路放开一点，对答案进行二分查找。我们都知道暴力法就是枚举答案然后检验枚举的值是否正确，当答案满足单调性时，我们就可以将枚举换为二分，这样能大大降低时间复杂度。

放两道例题，就是引言里我说的周赛题

参考资料

进制转换和位运算

Sun, 03 Apr 2022 09:45:04 +0800

进制转换

在数学中，不止只有我们常见的10进制，最近刷了几道关于进制转换的题目，在这里做个总结和记录吧。

基本概念

首先我们要先了解进制的基本概念，这里我直接从LeetCode官方这里引用了。

任何一种进位计数制都有一个基数，基数为 X 的进位计数制称为 X 进制，表示每一个数位上的数运算时都是逢 X 进一。

对于一个 X 进制的数，其具体数值由其中的每个数码和数码所在的数位决定。整数部分从右往左的第 m 个数位表示的权重是 $X^m$，其中 m 最小为 0；小数部分从左往右的第 n 个数位表示的权重是$X^{-n}$，其中 n 最小为 1。

八进制的 $720.5$ 可以写成如下形式：

$720.5_{(8)} = 7 \times 8^2 + 2 \times 8^1 + 0 \times 8^0 + 5 \times 8^{-1}$

用我自己的话来说，就是数值*权重

进制转换的一般思路

一般来说，我们习惯将进制转换成十进制，这样便于理解和手算。当然，我们也可以不通过十进制作为中间态过度，比如我们熟悉的二进制和十六进制的转换。

非十进制转十进制

将非十进制数转成十进制数，只要将每个数位的加权和即可。

例如，将八进制数 $720.5_{(8)}$ 转成十进制：

$720.5_{(8)} = 7 \times 8^2 + 2 \times 8^1 + 0 \times 8^0 + 5 \times 8^{-1} = 464.625$

下面是程序的实现(只考虑整数)，我们可以从高位到低位进行读取，按照下面的方式读入,其中n表示是几进制数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int read() {
 char c = getchar();
 int k = 0;
 while (isint(c) == -1) c = getchar();
 while (isint(c) != -1) {
 k *= n;
 k += isint(c);
 c = getchar();
 }
 return k;
}

十进制转非十进制

首先我们先来看手算，将十进制数转成 X 进制数，需要对整数部分和小数部分分别转换。

对于整数部分，转换方式是将十进制数的整数部分每次除以 X 直到变成 0，并记录每次的余数，反向遍历每次的余数即可得到 X 进制表示。

对于小数部分，转换方式是将十进制数的小数部分每次乘以 X 直到变成 0，并记录每次的整数部分，正序遍历每次的整数部分即可得到 X 进制表示。

下面是整数转换的过程，这里要注意的是转换时是从低位到高位，如果要输出的话要进行倒序，体现在程序中就是先递归再输出。

1
2
3
4
5
6


void print(int a) {
 if (!a)
 return;
 print(a / m);
 putchar(itc(a % m));
}

负进制

[NOIP2000 提高组] 进制转换

在洛谷的这道题中，我们遇到了一个新的概念：负进制

在负进制数中是用 $-R$ 作为基数，例如 $−15$（十进制）相当于 $110001$ （$-2$进制），并且它可以被表示为 $2$ 的幂级数的和数：

$110001=1\times (-2)^5+1\times (-2)^4+0\times (-2)^3+0\times (-2)^2+0\times (-2)^1 +1\times (-2)^0$

如果按照上面所写的转换过程，就会出现一个问题，比如在C++里对$-15$进行取模和相除的结果是：

$-15%-2=-1$ ； $-15\div-2=7$ ； $7\times-2+(-1)=-15$

虽然式子是成立的，但我们得到的余数是负数，这肯定是不行的，所以我们要想办法进行转换。

所以我们可以将余数减去一个除数，同时将商+1。由于除数（绝对值）肯定是大于余数的，此时余数就会转换成正数。

下面是具体实现的代码：

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


void slove(int n, int r) {
 if (n == 0)
 return;
 int m = n % r; // m为余数
 if (m < 0) // 如果余数小于0，转化为正数
 m -= r, n += r; //商+1 => 被除数+除数
 if (m >= 10)
 m = 'A' + m - 10;
 else
 m += '0';
 slove(n / r, r);
 putchar(m);
}

位运算

位运算的基本概念在组成原理这些课上已经讲过不知道多少遍了，这里就只提一下我觉得重要的点。

位运算共有6种，分别是：与(&)、或(|)、异或(^)、取反(~)、左移(<<)和右移(>>)。

这里要特别注意一下右移运算，它分为逻辑右移和算术右移：

算术右移时，高位补最高位
逻辑右移时，高位补0

在C++中，数据类型包含有符号类型和无符号类型，其中有符号类型使用关键字 signed 声明，无符号类型使用关键字 unsigned 声明，两个关键字都不使用时，默认是有符号类型。对于有符号类型，右移运算为算术右移；对于无符号类型，右移运算为逻辑右移。

在学习和刷题时，我们容易发现，左移运算对应乘法运算。将一个数左移 $k$ 位，等价于将这个数乘以 $2^k$。例如，$29$ 左移 $2$ 位的结果是 $116$，等价于 $29 \times 4$。

算术右移运算对应除法运算。将一个数右移 $k$ 位，相当于将这个数除以 $2^k$。例如，$50$ 右移 $2$ 位的结果是 $12$，等价于 $50 / 4$，结果向下取整。

这里要注意，对于负数，整数除法是向 $0$ 取整，右移运算是向下取整，两者就不相同了。例如，$(-50)»2$的结果是 $−13$，而 $(-50) / 4$ 的结果是$-12$，两者是不相等的。

参考资料

位运算和数学 - LeetBook

初探区间求和问题

Mon, 14 Mar 2022 20:46:19 +0800

最近看了很多篇关于如何刷题的文章，其中都不约而同的提到了"总结"这个关键词。仔细想想自己确实是从来没有做过一篇总结，刷过的题目就过去了，导致同样的题目再做一次又不会了。

我的第一篇总结就以最近刷到的「区间求和」问题展开吧。首先，先上一般问题的模板（其中加粗的为最佳方案）：

数组不变，区间查询：前缀和、树状数组、线段树；
数组单点修改，区间查询：树状数组、线段树；
数组区间修改，单点查询：差分、线段树；
数组区间修改，区间查询：线段树。

前缀和

前缀和的作用就是为了帮助我们快速求某一段的和，是「差分」的逆运算。

前缀和数组的每一位记录的是当前位置距离起点位置，这连续一段的和区间和。

一维前缀和

假设有一个一维数组$x$和该数组的一维前缀和数组$y$，则$x$和$y$满足以下关系：

$$y_0=x_0、y_1=x_0+x_1、y_2=x_0+x_1+x_2、......、y_n=x_0+x_1+...+x_n$$

所以我们可以通过 $y_n=y_{n-1}+x_n$ 这个公式计算出前缀和，代码实现如下：

1
2
3
4


for (int i = 0; i < n; i++) {
 if (i == 0) y[i] = x[i];
 else y[i] = y[i - 1] + x[i];
}

但是在实际使用中，常常会遇到左边界溢出的情况，为了避免这种情况，我们可以将前缀和数组整体向后移动一位，下面给出前缀给计算代码：

1
2
3
4


int n = x.size();
vector<int> y(n + 1);
for (int i = 1; i <= n; i++)
 y[i] = y[i - 1] + x[i - 1];

这样当我们想求区间$[a,b]$之和时只需要计算$y[b+1]-y[a]$即可。

二维前缀和

有一个二维数组$a$和该数组的二维前缀和数组$b$（其同样是个二维数组)

右侧标注橙色的二维前缀和元素，其值是左侧的原二维数组中标注橙色的所有元素的和。

二维前缀和实际上就是一个矩阵内值的和，而矩阵又可以由两个行数或列数少一的子矩阵组合后，删去重合部分再加上右下角的值来构成，也就是以下式子：

$$b_{x,y}=b_{x-1,y}+b_{x,y-1}-b_{x-1,y-1}+a_{x,y}$$

详细的代码如下：

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


for (int y = 0; y < n; y++) // n行
 for (int x = 0; x < m; x++) // m列
 {
 if (x == 0 && y == 0)
 b[y][x] = a[y][x]; //左上角的值
 else if (x == 0)
 b[y][x] = b[y - 1][x] + a[y][x]; //第一列
 else if (y == 0)
 b[y][x] = b[y][x - 1] + a[y][x]; //第一行
 else
 b[y][x] = b[y - 1][x] + b[y][x - 1] - b[y - 1][x - 1] + a[y][x];
 }

通过二维前缀和，我们可以很方便的计算出给定矩阵的和，即上面求前缀和的逆运算。假设所求矩阵的左上角点为$(x1,y1)$，右下角点为$(x2,y2)$，则有公式：

$sum=B[y2][x2]+B[y1-1][x1-1]-B[y1-1][x2]-B[y2][x1-1]$

这里结合图形会更好理解一点。

例题

力扣303. 区域和检索 - 数组不可变

就是一维前缀和的模板题，直接上模板即可做出。

差分

差分是一种处理数据的巧妙而简单的方法，它应用于区间的修改和询问问题。如果我们要经常对数组A某个区间内的所有元素做相同的加减操作，如果一个一个修改效率很差，但是使用差分数组后，这个操作的时间复杂度就能降到$\Omicron(1)$,当所有的修改操作结束后，再利用差分数组，计算出新的A。

一维差分

我们定义原数组为$a[]$、差分数组为$D[]$，则有计算公式：$D[k]=a[k]-a[k-1]$,即原数组$a[]$的相邻元素的差。从定义我们可以推出$a[k]=D[0]+D[1]+…+D[k]$。也就是说$a[]$是$D[]$的前缀和，所以「差分」和「前缀和」就是一组逆运算。

当我们想要对区间$[L,R]$每个元素加上$d$，则只要进行下面的两步操作：

1
2


D[L] += d;
D[R+1] -= d;

当所有修改都完成时，我们可以通过复杂度为$\Omicron(n)$的操作计算出新的$a[]$

当然，差分也不是万能的，它只能解决 区间修改+单点查询 这类问题。当遇到需要多次查询的问题，比如有$m$次修改，$k$次查询，此时修改的复杂度为$\Omicron(m)$,查询的复杂度为$\Omicron(kn)$，总复杂度为$\Omicron(m+kn)$，和暴力法$\Omicron(mn+k)$的复杂度一致了。

二维差分

从一维差分可以很容易的推广到二维差分，我们可以通过下面的公式计算$D[][]$：

$$D[i][j]=a[i][j]-a[i-1][j]-a[i][j-1]+a[i-1][j-1]$$

我们想修改坐标点$(x1,y1)$~$(x2,y2)$定义的区间，则需要修改矩阵的四个点：

1
2
3
4


D[y1][x1] += d; //二维区间的起点
D[y1][x2+1] -= d; //把y看成常数，x从x1到x2+1
D[y2+1][x1] -= d; //把x看成常数，y从y1到y2+1
D[y2+1][x2+1] += d; //由于前两式把d减了2次，多减了1次，这里加1次回来

前缀和$a[][]$的计算可以用下面的公式：

$$a[i][j]=D[i][j]+a[i-1][j]+a[i][j-1]-a[i-1][j-1]$$

在计算$a[][]$时，我们可以不新开一个数组，而是以用过的$D[][]$作为$a[][]$，以此来节约空间。使用的话只需要将上面式子中的$a$全部换为$D$

树状数组

树状数组的优点在于查询和修改的时间复杂度都为$\Omicron(logn)$，且比线段树好写。

单点修改、区间查询

树状数组的原理由于时间有限，这里就不展开说了（之后有空再补上😇），先上模板：

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


int c[MAXN]; //树状数组(下标从1开始)
int n; //数组的长度

inline int lowbit(int i) {
 return i & (-i);
}

//在位置i加上k
void update(int i, int k) {
 while (i <= n) {
 c[i] += k;
 i += lowbit(i);
 }
}

//求A[1]~A[i]的和
int getsum(int i) {
 int res = 0;
 while (i > 0) {
 res += c[i];
 i -= lowbit(i);
 }
 return res;
}

这里一定要注意，树状数组和原数组下标都是从1开始的。

由此就解决了单点修改、区间查询的问题，我们想要得到区间$(a,b)$的和，只需使用getsum(b) - getsum(a - 1)。

例题：P3374【模板】树状数组 1

区间修改、单点查询

在上面的差分中我们分析了，如果有多次查询，仅仅使用差分的时间复杂度就和暴力差不多了。这时，我们可以采用树状数组+差分的方法。

我们将上面模板中的原始数组改为差分数组。由差分的性质可知，当我们修改一个区间时，只需要修改区间的两个端点即可，此时区间修改的问题便被转化成了单点修改的问题。同时，树状数组前n项和也就变成了原数组第n项的值。

例题：P3368【模板】树状数组 2

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


//前面还是树状数组的模板，这里就不放了

int main() {
 cin >> n >> m;
 int pre = 0, now;
 for (int i = 1; i <= n; i++) {
 cin >> now;
 //这里每次求差分来生成树状数组
 update(i, now - pre);
 pre = now;
 }
 while (m--) {
 int a, x, y, k;
 cin >> a >> x;
 if (a == 1) {
 cin >> y >> k;
 //更新即为对D[X]、D[y+1]进行修改
 update(x, k);
 update(y + 1, -k);
 } else if (a == 2) {
 //求D[1]~D[i]的和,即A[i]的值
 cout << getsum(x) << endl;
 }
 }
 system("pause");
 return 0;
}

参考资料

JavaWeb期末复习

Mon, 03 Jan 2022 19:52:31 +0800

题目类型

选择（10分） 10题
填空（10分） 10题
问答（30分） 4题
编程题（30分） 3-4题
综合题（20分）

上机题整理

这里只存放核心的代码，完整的程序见Gitee仓库

使用Maven

通过使用Maven可以让程序自动配置和导入包，不必自己手动配置和导入，非常方便，推荐大家使用。

我的配置文件已经把考试会用的包都导入了，包括Servlet、JSP、JSTL、MySQl驱动，版本都已经调整为最佳，保证开箱即用。

新建项目，选择Maven，直接下一步
填写项目名称和目录位置，其他的可填可不填

在pom.xml文件增加这样一句<packaging>war</packaging>

接着粘贴下面的代码，并点击右上角的图标应用（或者使用快捷键Ctrl+Shift+O）

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


<dependencies>
 <!-- servlet 依赖 -->
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
 <version>3.1.0</version>
 </dependency>
 <!-- jsp 依赖 -->
 <dependency>
 <groupId>javax.servlet.jsp</groupId>
 <artifactId>javax.servlet.jsp-api</artifactId>
 <version>2.3.3</version>
 </dependency>
 <!-- jstl -->
 <dependency>
 <groupId>javax.servlet.jsp.jstl</groupId>
 <artifactId>jstl-api</artifactId>
 <version>1.2</version>
 </dependency>
 <!-- standard标签库 -->
 <dependency>
 <groupId>taglibs</groupId>
 <artifactId>standard</artifactId>
 <version>1.1.2</version>
 </dependency>
 <!-- mysql驱动 -->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>8.0.25</version>
 </dependency>
</dependencies>

在左边src的main这个目录下建立一个名叫webapp的目录，再这下面建立一个名叫WEB-INF的目录，再在其中建立web.xml这个文件

在里面填入下面的内容

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


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
 version="4.0">
 <!--默认启用EL表达式-->
 <jsp-config>
 <jsp-property-group>
 <url-pattern>*.jsp</url-pattern>
 <el-ignored>false</el-ignored>
 </jsp-property-group>
 </jsp-config>
</web-app>

这样就配置好了，如果你还是觉得麻烦，可以下载我这个配置好的懒人包，解压即可使用，注意在IDEA打开时要选择“信任MAVEN项目”，否则无法生效。

Servlet生成三角形

正三角

1
2
3
4
5
6
7
8
9


for (int i = 0; i < num; i++) {
 for (int j = 0; j < num - i; j++) {
 out.print("&nbsp;");
 }
 for (int k = 0; k <= i * 2; k++) {
 out.print("*");
 }
 out.println("</br>");
}

倒三角

1
2
3
4
5
6
7
8
9


for (int i = num; i > 0; i--) {
 for (int j = num - i; j > 0; j--) {
 out.print("&nbsp;");
 }
 for (int k = (i * 2) - 1; k > 0; --k) {
 out.print("*");
 }
 out.println("</br>");
}

JSP生成乘法表

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


<table>
 <tbody>
 <%
 String s = request.getParameter("num");
 int num = Integer.parseInt("".equals(s) ? "0" : s);
 for (int i = 1; i <= num; i++) {
 out.println("<tr>");
 for (int j = 1; j <= num; j++) {
 if (j <= i) {
 out.println("<td>" + i + "*" + j + "=" + i * j + "</td>");
 }else{
 out.println("<td></td>");
 }
 }
 out.println("</tr>");
 }
 %>
 </tbody>
</table>

登录界面，三次禁用

数据用数组存储application，但我没使用，如果要使用可以调用request.getServletContext()

用户信息存在session

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


@WebServlet(name = "Servlet3", value = "/Servlet3")
public class Servlet3 extends HttpServlet {
 private static final String[] USER_NAME = {"a", "b", "c"};
 private static final String[] PASSWORD = {"1", "2", "3"};

 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 String username = req.getParameter("username");
 String password = req.getParameter("password");
 if (username == null || password == null || "".equals(username) || "".equals(password)) {
 req.setAttribute("msg", "用户名或密码不能为空！");
 req.getRequestDispatcher("/3.jsp").forward(req, resp);
 return;
 }
 HttpSession mySession = req.getSession();
 int errTime = (int) (mySession.getAttribute("errTime") == null ? 0 : mySession.getAttribute("errTime"));
 Date dbDate = (Date) mySession.getAttribute("dbDate");
 Date nowDate = new Date();
 if (errTime >= 3) {
 if (dbDate.after(nowDate)) {
 req.setAttribute("msg", "您被禁止登录！");
 req.getRequestDispatcher("/3.jsp").forward(req, resp);
 return;
 } else {
 errTime = 0;
 }
 }
 int i;
 for (i = 0; i < USER_NAME.length; i++) {
 if (username.equals(USER_NAME[i]) && password.equals(PASSWORD[i])) {
 errTime = 0;
 req.setAttribute("msg", "登陆成功！");
 break;
 }
 }
 if(i>=USER_NAME.length)
 {
 errTime += 1;
 if (errTime >= 3) {
 //单位为毫秒
 nowDate.setTime(nowDate.getTime() + 1 * 60 * 1000);
 }
 req.setAttribute("msg", "用户名或密码错误！");

 }
 mySession.setAttribute("errTime", errTime);
 mySession.setAttribute("dbDate",nowDate);
 req.getRequestDispatcher("/3.jsp").forward(req, resp);
 }

 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 doGet(request, response);
 }
}

用户认证

不使用Filter

1
2
3
4
5
6
7


<%
 Object username = session.getAttribute("username");
 if(username==null){
 request.setAttribute("msg","您没有登陆");
 request.getRequestDispatcher("/4-1.jsp").forward(request,response);
 }
%>

使用Filter

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


//filterName：过滤器名称 urlPatterns：过滤的范围 过滤全部为"/*"
@WebFilter(filterName = "Filter4", urlPatterns = "/4-3.jsp")
public class Filter4 implements Filter {
 public void init(FilterConfig config) throws ServletException {}

 public void destroy() {}

 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
 HttpServletRequest req = (HttpServletRequest) request;
 HttpServletResponse resp = (HttpServletResponse) response;
 Object username = req.getSession().getAttribute("username");
 if (username == null) {
 req.setAttribute("msg", "您没有登陆");
 req.getRequestDispatcher("/4-1.jsp").forward(req, resp);
 } else {
 chain.doFilter(request, response);
 }
 }
}

录入用户信息并回显

如姓名爱好（checkbox数组）提交后，在界面上显示提交的信息

修改数据时，如何将原数据显示在表单中也在此段中。特别是select radio

使用EL表达式即可

注意点：

checkbox传递的值为数组，需使用request.getParameterValues("b");获取
可以将数组转换为列表，方便使用相关方法
- List<String> list = Arrays.asList(strArray); 只能查看，不支持修改和删除
- ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)); 可以修改和删除
checkbox和radio选中为checked；select中的option为selected

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


<form method="post" action="${pageContext.request.contextPath}/Servlet5">
 <label for="a">文本框</label>
 <input type="text" id="a" name="a" value="${A}"/>
 <br/>
 <label for="b">多选框</label>
 <input type="checkbox" id="b" name="b" value="1" ${BL.contains("1")?"checked":""}/>
 <input type="checkbox" name="b" value="2" ${BL.contains("2")?"checked":""}/>
 <input type="checkbox" name="b" value="3" ${BL.contains("3")?"checked":""}/>
 <br/>
 <label for="c1">单选框 4</label>
 <input type="radio" id="c1" name="c" value="4" ${"4".equals(C)?"checked":""}/>
 <label for="c2">单选框 5</label>
 <input type="radio" id="c2" name="c" value="5" ${"5".equals(C)?"checked":""}/>
 <br/>
 <label for="d">下拉框</label>
 <select name="d" id="d">
 <option value="6" ${"6".equals(D)?"selected":""}>6</option>
 <option value="7" ${"7".equals(D)?"selected":""}>7</option>
 <option value="8" ${"8".equals(D)?"selected":""}>8</option>
 </select>
 <br/>
 <input type="submit" value="提交">
</form>

请求转发、重定向，实现传值

请求转发：

request.setAttribute("D", d);
或者存放到Session里request.getSession().setAttribute("D", d);

重定向：

只能放在Session里
或者通过构造URL参数传递，如response.sendRedirect("/1.jsp?a="+a+"&b="+b);

在servlet如何使用jsp:usebean jsp来接收form内的值

jsp中使用下面的代码

1
2


<jsp:useBean id="s" class="yzu.calc" scope="request" />
<jsp:setProperty name="s" property="*" />

servlet中使用

1
2


request.getRequestDispatcher("getForm.jsp").include(request,response);
calc mybean=(calc)request.getAttribute("s");

从web表单接收数据

request.getParameter
request.getParameterValues

数据库实现

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


private static final String DRIVER = "com.mysql.cj.jdbc.Driver";
private static final String URL = "jdbc:mysql://localhost:3306/web?serverTimezone=Asia/Shanghai&characterEncoding=utf-8";
private static final String USERNAME = "root";
private static final String PASSWORD = "root";

//加载驱动
try {
 Class.forName(DRIVER);
 connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
} catch (Exception e) {
 e.printStackTrace();
}

if (connection != null) {
 String sql = "select * from user where name=?";
 PreparedStatement pstm = null;
 ResultSet rs = null;
 try {
 //加载SQL语句
 pstm = connection.prepareStatement(sql);
 //填入变量
 pstm.setObject(1, username);
 //执行SQL（查询）
 rs = pstm.executeQuery();
 //执行SQL（增删改）
 updateRows = pstm.executeUpdate();
 //读取数据（多行使用while）
 if (rs.next()) {
 dbPassword = rs.getString("password");
 dbDate = new Date(rs.getTimestamp("time").getTime());
 dbErrorTime = rs.getInt("error_count");
 }
 //释放资源
 rs.close();
 pstm.close();
 connection.close();
 }SQLException (e) {
 e.printStackTrace();
 }

注册用户多个信息

不懂什么意思，有懂哥可以评论区留言

DB CRUD查询组合查询不需要分页

见上面

用会话对象实现购物车的CRUD商品名称，单价，数量购物车列表，总价

具体代码见仓库Servlet6

问答题

C/S B/S优缺点

C/S架构

全称是Client/Server，即客户端服务器端架构

优点：

C/S架构的界面和操作可以很丰富。
安全性能可以很容易保证，实现多层认证也不难。
由于只有一层交互，因此响应速度较快。

缺点：

适用面窄，通常用于局域网中。
用户群固定。由于程序需要安装才可使用，因此不适合面向一些不可知的用户。
维护成本高，发生一次升级，则所有客户端的程序都需要改变。

B/S架构

全称为Browser/Server，即浏览器/服务器结构。

优点：

客户端无需安装，有Web浏览器即可。
BS架构可以直接放在广域网上，通过一定的权限控制实现多客户访问的目的，交互性较强。
BS架构无需升级多个客户端，升级服务器即可。

缺点：

在跨浏览器上，BS架构不尽如人意。
表现要达到CS程序的程度需要花费不少精力。
在速度和安全性上需要花费巨大的设计成本，这是BS架构的最大问题。

JSTL EL JDBC VO DAO MVC JSP中英文全称

JSTL:Java server pages standarded tag library，JSP标准标签库
EL:Expression Language,EL表达式
JDBC:Java Database Connectivity,Java数据库连接
VO:Value Object,值对象
DAO:Data Access Object,数据库访问对象
MVC:Model View Controller,模型视图控制器
JSP:Java Server Pages,JAVA服务器页面

多层架构的优点

高内聚低耦合，便于团队开发

内聚：一个模块内各个元素彼此结合的紧密程度；

耦合：一个软件结构内不同模块之间关联程度的度量。

在团队开发中，分层可以让软件开发人员专注于自己负责的层，而不必关心其他层的设计，也不必担心自己的设计会影响其它层。如果不分层，根本不可能进行团队开发，只会一团糟。
使软件升级和维护更为容易

分层设计使得程序结构清晰，升级和维护都变得十分容易，更改层的具体实现代码，只要层接口保持稳定，其他层可以不必修改。即使层的接口发生变化，也只影响上层和下层，修改工作量小而且错误可以控制，不会带来意外的风险。

MVC的特点和优点

MVC主要分模型、视图、控制器三层。

模型(model)

它是应用程序的主体部分，主要包括业务逻辑模块和数据模块。模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性
视图(view)

用户与之交互的界面、在 web 中视图一般由 jsp,html 组成
控制器(controller)

接收来自界面的请求并交给模型进行处理在这个过程中控制器不做任何处理只是起到了一个连接的作用

优点：

降低代码耦合性。在 MVC 模式中，三个层各施其职，所以如果一旦哪一层的需求发生了变化，就只需要更改相应的层中的代码而不会影响到其他层中的代码。
有利于分工合作。在 MVC 模式中，由于按层把系统分开，那么就能更好的实现开发中的分工。网页设计人员可进行开发视图层中的 JSP，而对业务熟悉的人员可开发业务层，而其他开发人员可开发控制层。
有利于组件的重用。如控制层可独立成一个能用的组件，表示层也可做成通用的操作界面。可以为一个模型在运行时同时建立和使用多个视图。

GET、POST特点和优缺点

GET

查询字符串（名称/值对）是在GET请求的URL中发送的

优点：

GET请求可被缓存
GET请求速度快
GET请求可被收藏为书签
GET请求保留在浏览器历史记录中

缺点：

GET请求不安全
GET请求有url长度限制

POST

查询字符串（名称/值对）是在POST请求的HTTP消息主体中发送的

优点：

POST请求对数据长度没有要求
POST请求相对GET请求更安全

缺点：

POST请求不会被缓存
POST请求速度慢

重定向与请求转发的优缺点实现的核心代码

重定向

优点：

不限制应用范围，可以重定向到服务器内部其他资源，也可以是外部的应用

缺点：

重定向解决方案需要在浏览器与服务器之间进行多次往返，大量时间消耗在往返次数上，增加用户等待服务时间

核心代码：response.sendRedirect("请求地址")

请求转发

优点：

安全性高，在内部发生跳转，浏览器地址不变
转发只需要一次请求，就可以访问至少两个servlet或jsp页面。

缺点：

只能在同一web应用内使用，不能转发到外部的url地址。

核心代码：request.getRequestDispatcher("URL地址").forward(request, response)

JSP Servlet 区别与联系

区别：

jsp更擅长表现于页面显示,servlet更擅长于逻辑控制。
Servlet中没有内置对象，Jsp中有内置对象。
Servlet在Java代码中通过HttpServletResponse对象动态输出HTML内容；JSP在静态HTML内容中嵌入Java代码，Java代码被动态执行后生成HTML内容

联系：

jsp是对servlet的一种高级封装。本质还是servlet。
jsp会由TomCat自动编译成“类servlet”。

JSP内置对象

对象	描述
request	HttpServletRequest 接口的实例
response	HttpServletResponse 接口的实例
out	JspWriter类的实例，用于把结果输出至网页上
session	HttpSession类的实例
application	ServletContext类的实例，与应用上下文有关
config	ServletConfig类的实例
pageContext	PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问
page	类似于Java类中的this关键字
Exception	Exception类的对象，代表发生错误的JSP页面中对应的异常对象

JavaBean相关动作标记有哪些，用代码说明之

语法	描述
jsp:useBean	寻找或者实例化一个JavaBean。
jsp:setProperty	设置JavaBean的属性。
jsp:getProperty	输出某个JavaBean的属性。

<jsp:useBean id = "name" class = "package.class" scope= "page | request | session | application" />

其中：

1）id

表示 Bean 实例化对象的变量名，可以在指定范围内使用该变量名。

2）class

表示需要实例化 Bean 的类路径，指定的类必须包含 public 且无参数的构造方法。

3）scope

指定 Bean 的作用域，取值为：

page：只能在当前页面使用该 Bean 对象；
request：只能在一次请求范围内使用该 Bean 对象；
session：只能在一次会话范围内使用该 Bean 对象；
application：可以在整个应用范围内使用该 Bean 对象。

<jsp:setProperty name = "beanName" property = "attributeName" value = "attributeValue"/>

<jsp:setProperty> 通常和 <jsp:useBean> 一起使用，分为两种情况。

在 <jsp:useBean> 标签外使用<jsp:setProperty>

以上情况，无论 <jsp:useBean> 是否实例化了 User 对象，<jsp:setProperty> 都会执行。
在 <jsp:useBean> 标签里使用 <jsp:setProperty>

只有 <jsp:useBean> 实例化了 User 对象，<jsp:setProperty> 才会执行

<jsp:getProperty name = "beanName" property = "attributeName">

其中，name 指定需要获取属性的 Bean 的名称；property 指定 Bean 的属性，即 Bean 类中的属性。

当 property 的取值为 * 时，要求 Bean 属性的名称与类型要与 request 请求中参数的名称及类型一致，以便用 Bean 中的属性来接收客户输入的数据，系统会根据名称来自动匹配。

注意：<jsp:setProperty> 和 <jsp:getProperty> 动作都会按照 page、request、session 和 application 的顺序依次查找指定 Bean 的实例对象，直到第一个实例被找到。如果任何范围内都不存在这个 Bean 实例，则会拋出异常。

EL与作用城相关的隐含对象有哪些

内置对象	说明
pageScope	获取 page 范围的变量
requestScope	获取 request 范围的变量
sessionScope	获取 session 范围的变量
applicationScope	获取 application 范围的变量
param	相当于 request.getParameter(String name)，获取单个参数的值
paramValues	相当于 request.getParameterValues(String name)，获取参数集合中的变量值
header	相当于 request.getHeader(String name)，获取 HTTP 请求头信息
headerValues	相当于 request.getHeaders(String name)，获取 HTTP 请求头数组信息
initParam	相当于 application.getInitParameter(String name)，获取 web.xml 文件中的参数值
cookie	相当于 request.getCookies()，获取 cookie 中的值
pageContext	表示当前 JSP 页面的 pageContext 对象

EL 表达式可以输出 4 种属性范围的内容。如果在不同的属性范围中设置了同一个属性名称，则按照 page、request、session、application 的顺序依次查找。

${person.name} person存放在request属性中person对象的类yzu.Person，对象的java代码是什么(JavaBean) <%=((yzu.Person)request.getAttribute("person")).getName()%>

过滤器与Servlet区别与联系，他有什么作用

过滤器（Filter）：对Request请求起到过滤的作用，作用在Servlet之前

Servlet：处理Request请求和Response响应

Java和JSP的区别

Java是一种通用的计算机编程语言，它是并发的，基于类的，面向对象的，并且专门设计为具有尽可能少的实现依赖性。而JSP是一种技术，可帮助软件开发人员基于HTML，XML或其他文档类型创建动态生成的Web页面。
Java applet是使用Java编程语言编写的。JSP使用“scriptlet元素”（Java代码）和“标记”（通常是HTML或XML）的混合编程，以提供数据驱动（“动态”）网页。
Java为面向对象语言，JSP可以理解为一种脚本
Java主要负责逻辑，业务处理，而JSP主要负责页面展现
JSP的本质是servlet，而servlet的本质是Java类

JSP开发的优点

将内容的生成和显示分离

借助jsp技术，web页面发开人员可以使用html或者xml标签来设计和格式化最终页面，使用jsp标签或者脚本程序来生成动态web页面的内容（页面的内容是根据请求来变化的，例如，请求账户信息或者特定的一本书的价格）。生成内容的逻辑被封装在标签和javabean组件中，并且捆绑在脚本程序中，所有的脚本程序在服务器端运行。因此，其他人能够方便地编辑和使用jsp页面，而不影响内容的生成。
强调可重用的组件

jsp页面可借助可重用的、跨平台的组件来执行应用程序所要求的极为复杂的业务逻辑。开发人员能够共享和交换执行普通操作的组件，或者让这些组件被别的开发人员或开发团队所使用。基于组件的方法加速了总体开发进程，并且使得各种组织在他们现有的技能和优化结果的开发努力中得到平衡。
采用标签简化页面开发

通过使用jsp提供的标准标签库，web页面开发人员能够访问和实例化javabean组件、设置或者检索组件属性、下载applet以及执行用其他方法更难于编码和耗时的功能。此外，web页面开发人员还可以为常用功能创建自己的标签库，这是的web页面开发人员能够使用熟悉的工具盒如同标签一样的执行特定功能的构件来工作。
一次编写、处处运行

由于jsp页面的内置脚本是基于java语言的，而且所有的jsp页面都被编译为java servlet，因此jsp页面就具有java技术的所有好处，包括健壮性和安全性等。作为java平台的一部分，jsp拥有java语言“一次编写，处处运行”的特点。jsp几乎可以运行于所有的平台，如windows nt、linux、unix等。
更高的效率和安全性

jsp程序在执行之前先被编译成字节码文件，字节码文件有java虚拟机解释执行，比源代码解释的效率高。此外，服务器端还有字节码的cache机构，能提高字节码的访问效率。第一次调用jsp网页可能稍慢，因为它被编译成cache，以后就快的多了。同时，jsp源程序不大可能被下载，特别是javabean程序，完全可能放到不对外的目录中。

如何优雅的看番

Tue, 26 Oct 2021 15:39:41 +0800

新番“先审后播”政策已经实行了快半年了，现在看来在哔哩哔哩上追番的体验已经没有之前那样舒适了，更不用提还有好多番剧连上线都没有上线。这时本地看番就成了一个比较不错的选择了。这篇文章就记录以下这段时间我本地追番使用的工具和网站，大家也可以以此为参照，打造属于自己的追番体验。

找番

“巧妇难为无米之炊”，没有片源的话，本文使用的一切工具也就无从谈起了。下面我就列举几个我知道的找番网址：

（推荐）萌番组

只能说是良心网站了，国内可以直连，支持RSS订阅和筛选
動漫花園

老牌网站了，国内无法直连，但分享内容不止番剧，还有音乐等内容
Nyaa

一般是英文资源，可做为备用网站

下载

找到了需要的资源（一般都是BT链接），下一步就是下载了，这里我推荐qBittorrent，我认为是BT下载的最优解了。Windows平台我建议选择增强版qBittorrent-Enhanced-Edition

对于新番来说，速度基本是不慢的。但如果要下载旧番的话，如果分享的人不多的话速度就不太理想了。

面对这种情况我知道的有这样几种解决方法：

使用115等支持离线的网盘

这里我推荐一个安卓的APP，叫PikPak。由于是新出的，现在有会员免费领取的活动，可以无限次离线+3T空间。我个人测试了一下离线成功率和下载速度还是不错的，乘现在还能白嫖就多用用吧_(:з)∠)_
租一台国外的VPS，先在上面下载好再转存到国内（因为有些资源分享的人在国内无法连接到，所以这个方法才有用😂）
看看百度云等网盘上有没有人分享
使用PT，当然这个难度过大了，就连我也没整过😇

播放

说到本地播放器，那就不得不提到PotPlayer的大名了，这基本是播放器的最优解了，在这里我就不过多阐述它的优点了，我主要是想提一提另外的一款播放器——弹弹play

相比PotPlayer，它最大的优点就是支持弹幕的播放。在看了这么多年的B站以后，现在看番不带弹幕就觉得缺了些什么，这款播放器就很好的解决了我这个痛点。当然它的功能不止这些，比如可以配置自动下载、开启远程访问等等。但我一般不会让一个播放器后台常驻+开机自启的，所以这些功能对我来说并没有多大的作用。

当然还是有缺点的，比如不能像pakku那样将重复弹幕合并成一条大弹幕，使用自带的重复弹幕屏蔽会有肉眼可见的弹幕消失等BUG。不过瑕不掩瑜，这款播放器我还是很推荐的。

补帧

终于到这个环节了，这才是我写这篇文章的主要动力。

国际惯例，先来一段名词解释：

帧数(Frames)，为帧生成数量的简称。由于口语习惯上的原因，我们通常将帧数与帧率混淆。每一帧都是静止的图象，快速连续地显示帧便形成了运动的假象，因此高的帧率可以得到更流畅、更逼真的动画。

而帧率（Frame rate）是用于测量显示帧数的量度。所谓的测量单位为每秒显示帧数(Frames per Second，简称：FPS）或“赫兹”（Hz）。此词多用于影视制作和电子游戏。

所以说补帧就是将低帧率的视频通过一定的算法提升到高帧率。直观来看，就是画面变得更加流畅丝滑了，还不理解的话可以看下面的动图或者看看极客湾的这期视频，通过不同帧率的对比能有个更清晰的认识。

当然，上面的视频中使用的是AI补帧，对显卡和时间要求都十分高。我们正常看番是用不到这些的。这里就列举本地实时插帧的三款软件。

	AMD Fluid Motion	SVP	dmitriRender
硬件需求	支持此功能的A卡	无	高性能的显卡
是否收费	免费	收费（可试用）	收费（可试用）
正版体验	/	优秀	较差
配置难度	不知道	复杂	简单
支持格式	全部	不支持HEVC	全部

至于补帧效果，我感觉对于动漫dmitriRender要比SVP要好一点。当然由于动漫的画面一般不具有逻辑连续，所以还是会有一点虚影的，不过不影响观看。

两款软件的正版激活体验来说，还是SVP比较好，不限次数反激活，支持官网反激活。而dmitriRender不但不支持官网反激活，而且只有20次反激活的限制，更要命的是如果系统重装、硬件更新都可能会掉激活，贴吧上也有好多丢失激活的情况。

dmitriRender的官网售价是$15.00（我当时买的是12刀，居然涨价了）

SVP的官网售价是$19.99（太贵了，等黑五促销再说）

SVP是支持支付宝付款的，而dmitriRender需要一张信用卡

不过，上面两块软件都有爱心分享版，这里就不直接写出来了（避免查水表），如果有需要可以在评论里留言。

小结

这篇文章还是拖更了好久，每次在心里列下想写的内容，一到电脑前就懒得动手了😭之后一定会补上两款补帧软件的安装和配置方法。

MySQL8开启远程访问

Thu, 21 Oct 2021 10:19:52 +0800

最近把服务器重装成Ubuntu了，所以要重装MySQL，没想到在这里踩了好几个坑，在这里记录下来备忘。

安装

这其实很简单，直接通过Ubuntu的包管理器直接安装就行了（我把系统转为Ubuntu也有这方面的原因）。

1

sudo apt-get install mysql-server

通过这条命令安装的MySQL的root账号是没有密码的，所以只要输入mysql就直接可以进入了

开启远程访问

这里就是本文的重点了，我在这里花了很多时间😇

设定MySQL的监听端口

通过apt安装的MySQL默认是只监听本地的端口的，我们要修改使其监听所有ip地址的请求。

1
2
3
4


vim /etc/mysql/mysql.conf.d/mysqld.cnf
#把bind - address后面的127.0.0.1改为0.0.0.0
#重启MySQL服务器
systemctl restart mysql

设置root账号密码并开启远程访问

默认root账号是没有密码的，这当然是不行的，我们需要给一个密码

1
2
3
4


use mysql;
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新的密码';
update user set host = '%' where user='root';
flush privileges;

还要注意把防火墙的3306端口放行，这样就可以实现MySQL的远程访问了。

shiro整合JWT

Fri, 08 Oct 2021 15:19:44 +0800

在我现在在做的项目中需要进行身份和权限认证，在网上找了些教程，推荐都是使用JWT来进行身份认证，于是便决定使用此方法来实现。~~（然而用完了才发现JWT也有缺点）~~

何为JWT

所谓JWT，全称是JSON Web Token。下面是从官网摘抄的定义：

JWT是一个开放的标准（RFC 7519），它定义了一种紧凑和独立的方式，以JSON对象的形式在各方之间安全地传输信息。这种信息可以被验证和信任，因为它是经过数字签名的。JWTs可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公共/私人密钥对进行签名。

按我的理解，JWT其实就是将传统的session认证中的token存储位置从服务器上下发给用户，服务器只需要判断传来的token是否合法而无需存储。这样做的好处就是可以做分布式的服务器，无需考虑用户是在哪一台服务器上登录的。

详细的定义和构成我这里就不展开了，这里主要关注JWT中Payload（载荷）。这是有效信息存放的地方，我们一般关注这里就行了。

下面是官方提供且建议（并不强制）使用的声明：

iss: jwt签发者
sub: 主题
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 生效时间，在此时间之前该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

当然，在载荷中还可以存放自定义的信息，在本项目中使用官方提供的就足以了，故不展开。

认证流程

用户使用用户名密码来请求服务器
服务器进行验证用户的信息
服务器通过验证发送给用户一个token
客户端存储token，并在每次请求时附送上这个token值
服务端验证token值，并返回数据

具体实现

导入依赖包

第一步当然是导入相关依赖了，使用Maven进行包管理。

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


<!-- shiro -->
<dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-spring</artifactId>
 <version>1.8.0</version>
</dependency>
<!-- jwt -->
<dependency>
 <groupId>com.auth0</groupId>
 <artifactId>java-jwt</artifactId>
 <version>3.18.1</version>
</dependency>

封装JWT工具类

这里主要实现JWT的生成、验证、提取用户名三个功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87


@Slf4j
public class JwtUtil {
 /**
 * 服务器私钥
 */
 private static final Algorithm ALGORITHM = Algorithm.HMAC256("test");

 /**
 * 生成JSON Web Token
 *
 * @param username 用户名
 * @param issuer 签发者
 * @param subject 面向主体
 * @param ttlMillis 生效时长(单位:毫秒)
 */
 public static String creatJwt(String username, String issuer, String subject, long ttlMillis) {
 long nowMillis = System.currentTimeMillis();
 Date now = new Date(nowMillis);

 JWTCreator.Builder builder = JWT.create()
 .withAudience(username)
 .withIssuedAt(now)
 .withSubject(subject)
 .withIssuer(issuer);

 if (ttlMillis >= 0) {
 long expMillis = nowMillis + ttlMillis;
 Date exp = new Date(expMillis);
 builder.withExpiresAt(exp);
 }

 return builder.sign(ALGORITHM);
 }

 /**
 * 生成JSON Web Token
 *
 * @param username 用户名
 * @param issuer 签发者
 * @param subject 面向主体
 * @param expDate 失效日期
 */
 public static String creatJwt(String username, String issuer, String subject, Date expDate) {
 Date now = new Date();

 JWTCreator.Builder builder = JWT.create()
 .withAudience(username)
 .withIssuedAt(now)
 .withSubject(subject)
 .withIssuer(issuer);

 if (now.before(expDate)) {
 builder.withExpiresAt(expDate);
 }

 return builder.sign(ALGORITHM);
 }

 /**
 * 获取签发对象
 *
 * @param token 需要解密的token
 * @return 解密后获得的对象，失败返回null
 */
 public static String getAudience(String token) {
 String audience;
 try {
 audience = JWT.decode(token).getAudience().get(0);
 } catch (JWTDecodeException exception) {
 log.error("输入的token无法解析");
 return null;
 }
 return audience;
 }

 /**
 * 验证token是否正确
 *
 * @param token 需要验证的token
 * @return 通过验证返回true，反之抛出异常
 */
 public static Boolean verifyToken(String token) throws JWTVerificationException {
 JWTVerifier verifier = JWT.require(ALGORITHM).build();
 verifier.verify(token);
 return true;
 }
}

配置Shiro

这里的ShiroConfig.java与一般Shiro项目的配置有以下几点不同：

禁用Session
使用自定义的jwtFilter过滤器，用来拦截并处理携带JWT token的请求
使用自定义的Realm认证器，用于验证用户是否存在及查询用户权限

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


@Configuration
public class ShiroConfig {

 @Autowired
 private MyRealm myRealm;

 @Bean
 public DefaultWebSecurityManager getDefaultWebSecurityManager() {
 DefaultWebSecurityManager manger = new DefaultWebSecurityManager();
 manger.setRealm(myRealm);
 // 关闭shiro自带的session
 DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
 subjectDAO.setSessionStorageEvaluator(sessionStorageEvaluator());
 manger.setSubjectDAO(subjectDAO);
 return manger;
 }

 @Bean
 public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager manger) {
 ShiroFilterFactoryBean bean = new CustomShiroFilterFactoryBean();
 bean.setSecurityManager(manger);
 Map<String, Filter> filterMap = new HashMap<>();
 filterMap.put("jwt", getJwtFilter());
 bean.setFilters(filterMap);
 Map<String, String> map = new LinkedHashMap<>();
 //设置过滤规则，anon表示无需认证，其余的请求都通过自定义的jwt认证器
 map.put("/", "anon");
 map.put("/swagger-ui/**", "anon");
 map.put("/v3/api-docs", "anon");
 map.put("/swagger-resources/**", "anon");
 map.put("/unauthorized/**", "anon");
 map.put("/**", "jwt");
 bean.setFilterChainDefinitionMap(map);
 bean.setLoginUrl("/login");
 // 设置无权限时跳转的 url
 bean.setUnauthorizedUrl("/unauthorized/无权限");
 return bean;
 }


 public JwtFilter getJwtFilter() {
 return new JwtFilter();
 }

 /**
 * 开启注解代理
 */
 @Bean
 public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
 AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
 authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
 return authorizationAttributeSourceAdvisor;
 }

 /**
 * 禁用session, 不保存用户登录状态。保证每次请求都重新认证
 */
 @Bean
 protected SessionStorageEvaluator sessionStorageEvaluator() {
 DefaultSessionStorageEvaluator sessionStorageEvaluator = new DefaultSessionStorageEvaluator();
 sessionStorageEvaluator.setSessionStorageEnabled(false);
 return sessionStorageEvaluator;
 }
}

自定义Token

由于使用了JWT当token，自然要写自定义的Token

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


public class JwtToken implements AuthenticationToken {
 private String token;

 public JwtToken(String token) {
 this.token = token;
 }

 @Override
 public Object getPrincipal() {
 return token;
 }

 @Override
 public Object getCredentials() {
 return token;
 }
}

自定义过滤器

由于使用了JWT，所以不能使用shiro中自带的过滤器，而是自定义自己的过滤器 JWTFilter，JWTFilter 继承了 BasicHttpAuthenticationFilter，并部分原方法进行了重写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {
 @Override
 protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
 //判断请求的请求头是否带上 "Token"
 if (isLoginAttempt(request, response)) {
 //如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
 try {
 executeLogin(request, response);
 return true;
 } catch (Exception e) {
 //token 错误
 responseError(response, e.getMessage());
 }
 }
 //如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
 return true;
 }


 /**
 * 判断用户是否想要登入。
 * 检测 header 里面是否包含 Token 字段
 */
 @Override
 protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
 HttpServletRequest req = (HttpServletRequest) request;
 String token = req.getHeader("Token");
 return token != null;
 }

 @Override
 protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
 HttpServletRequest httpServletRequest = (HttpServletRequest) request;
 String token = httpServletRequest.getHeader("Token");
 JwtToken jwtToken = new JwtToken(token);
 // 提交给realm进行登入，如果错误他会抛出异常并被捕获
 getSubject(request, response).login(jwtToken);
 // 如果没有抛出异常则代表登入成功，返回true
 return true;
 }

 /**
 * 将非法请求跳转到 /unauthorized/**
 */
 private void responseError(ServletResponse response, String message) {
 try {
 HttpServletResponse httpServletResponse = (HttpServletResponse) response;
 //设置编码，否则中文字符在重定向时会变为空字符串
 message = URLEncoder.encode(message, "UTF-8");
 //允许跨域请求
 httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
 httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST");
 httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
 httpServletResponse.setHeader("Access-Control-Max-Age", "3600");

 httpServletResponse.sendRedirect("/unauthorized/" + message);
 } catch (IOException e) {
 log.error(e.getMessage());
 }
 }
}

该过滤器有这几大步骤：

检验请求头是否带有Token
如果带有 token，执行 shiro 的 login() 方法，将 token 提交到 Realm 中进行检验；如果没有 token，说明当前状态为游客状态（或者其他一些不需要进行认证的接口）
如果在 token 校验的过程中出现错误，如 token 校验失败，那么我会将该请求视为认证不通过，则重定向到 /unauthorized/**

自定义Realm

这里主要是进行身份认证和权限认证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


@Component
public class MyRealm extends AuthorizingRealm {
 @Autowired
 UserService userService;
 @Autowired
 RoleService roleService;
 @Autowired
 PermissionService permissionService;

 @Override
 public boolean supports(AuthenticationToken token) {
 return token instanceof JwtToken;
 }

 /**
 * 权限认证
 * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的
 */
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
 String userName = (String) principals.iterator().next();
 Set<String> roles = roleService.getAllRoleByUserName(userName);
 Set<String> permissions = permissionService.getAllPermissionByUserName(userName);
 SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
 info.setRoles(roles);
 info.setStringPermissions(permissions);
 return info;
 }

 /**
 * 身份认证
 */
 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
 JwtToken jwtToken = (JwtToken) token;
 String jwtTokenPrincipal = (String) jwtToken.getPrincipal();
 String userName = JwtUtil.getAudience(jwtTokenPrincipal);
 if (userName == null) {
 throw new AuthenticationException("token认证失败！");
 }
 try {
 JwtUtil.verifyToken(jwtTokenPrincipal);
 } catch (JWTDecodeException e) {
 throw new AuthenticationException("不是有效的JWT格式");
 } catch (SignatureVerificationException e) {
 throw new AuthenticationException("无效的签名");
 } catch (TokenExpiredException e) {
 throw new AuthenticationException("token已过期");
 }
 User user = userService.getUserByUserName(userName);
 if (user == null) {
 throw new AuthenticationException("该用户不存在！");
 }
 return new SimpleAuthenticationInfo(userName, jwtTokenPrincipal, user.getUserId());
 }
}

这里有个细节，在Controller中要求进行身份认证时，Shiro会自动把上面doGetAuthenticationInfo方法中返回的Info存起来。这样我们就可以在Controller中调用这里面的值了。

userName可以通过(String) SecurityUtils.getSubject().getPrincipal()取出来

userId可以通过SecurityUtils.getSubject().getPrincipals().getRealmNames().iterator().next()取出来。当然，这里根据Shiro的设计，SimpleAuthenticationInfo的第三个构造参数应该填入RealmName，用来区分用户该使用哪一个Realm进行验证的。但我这个项目就只有一个Realm，所以在这里就偷了个懒，就没按官方标准来了。

异常处理

第一个是专门处理身份认证时的异常

1
2
3
4
5


@ApiOperation(value = "接收未授权错误", notes = "返回错误信息")
@GetMapping("/unauthorized/{message}")
public Result unauthorized(@PathVariable String message) {
 return new Result().setCode(233).setMessage(message);
}

第二个则是全局接管Shiro的异常，在其中进行处理

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


@RestControllerAdvice
public class ExceptionController {
 /**
 * 捕捉shiro的异常
 */
 @ExceptionHandler(ShiroException.class)
 public Result handle401(ShiroException e) {
 Result result = new Result();
 result.setCode(666);
 if(e instanceof UnauthenticatedException){
 result.setMessage("您没有登录！");
 }else if(e instanceof UnauthorizedException){
 result.setMessage("您没有权限访问！");
 }
 else {
 result.setMessage(e.toString());
 }
 return result;
 }
}

解决中文报错

在Shiro1.7版本之后增加了url校验，如果有中文字符就不通过。然而我们项目里返回错误信息就是通过url来实现的。参考这篇文章知道，需要自己重写ShiroFilterFactoryBean来实现关闭url校验

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


public class CustomShiroFilterFactoryBean extends ShiroFilterFactoryBean {
 @Override
 protected FilterChainManager createFilterChainManager() {
 FilterChainManager manager = super.createFilterChainManager();
 // URL携带中文400，servletPath中文校验bug
 Map<String, Filter> filterMap = manager.getFilters();
 Filter invalidRequestFilter = filterMap.get(DefaultFilter.invalidRequest.name());
 if (invalidRequestFilter instanceof InvalidRequestFilter) {
 ((InvalidRequestFilter) invalidRequestFilter).setBlockNonAscii(false);
 }
 return manager;
 }
}

开始使用

身份认证在Controller上添加@RequiresAuthentication
角色认证在Controller上添加@RequiresRoles("xxx")
权限认证在Controller上添加@RequiresPermissions("xxx")

测试

测试接口的代码：

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


@GetMapping("/test")
@ResponseBody
public Result test() {
 return new Result().setCode(200).setMessage("当你看到这段话时，说明服务成功运行了");
}

@GetMapping("/test2")
@ResponseBody
@RequiresPermissions("user:insert")
public Result test2() {
 return new Result().setCode(200).setMessage("当你看到这段话时，说明你已经通过了验证");
}

@GetMapping("/test3")
@ResponseBody
@RequiresPermissions("noBody")
public Result test3() {
 return new Result().setCode(200).setMessage("当你看到这段话时，说明认证系统出现了问题");
}

参考文章

更新日志

2021.11.7：

增加解决跳转时的跨域请求
更细粒度的展示JWT错误原因
增加SecurityUtils的使用
增加测试接口的代码

Vue学习笔记

Wed, 22 Sep 2021 08:21:14 +0800

最近看了很久的Vue教程，为了避免之后的遗忘，还是停下脚步，花点时间讲笔记写出来吧。

这篇笔记是基于B站上的尚硅谷Vue2.0+Vue3.0全套教程而成，在此感谢提供这么优秀的学习教程。

Vue2基础

想要学好Vue，那肯定还是从Vue2开始学起。那么这一章主要是Vue2中的基础内容，没有使用到脚手架。

初识Vue

每学一个新的语言，HelloWord是必不可少的。话不多说，上代码：

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


<!-- 准备好一个容器 -->
<div id="demo">
 <h1>Hello，{{name.toUpperCase()}}，{{address}}</h1>
</div>

<script type="text/javascript" >
 Vue.config.productionTip = false //阻止 vue 在启动时生成生产提示。

 //创建Vue实例
 new Vue({
 el:'#demo', //el用于指定当前Vue实例为哪个容器服务，值通常为css选择器字符串。
 data:{ //data中用于存储数据，数据供el所指定的容器去使用，值我们暂时先写成一个对象。
 name:'vue',
 address:'北京'
 }
 })
</script>

这样就完成了一个基础的Vue程序。

1.想让Vue工作，就必须创建一个Vue实例，且要传入一个配置对象；

2.root容器里的代码依然符合html规范，只不过混入了一些特殊的Vue语法；

3.root容器里的代码被称为【Vue模板】；

4.Vue实例和容器是一一对应的；

5.真实开发中只有一个Vue实例，并且会配合着组件一起使用；

6.{{xxx}}中的xxx要写js表达式，且xxx可以自动读取到data中的所有属性；

7.一旦data中的数据发生改变，那么页面中用到该数据的地方也会自动更新；

Vue模板语法

Vue模板语法有2大类：

1.插值语法：

功能：用于解析标签体内容。

写法：{{xxx}}，xxx是js表达式，且可以直接读取到data中的所有属性。

2.指令语法：

功能：用于解析标签（包括：标签属性、标签体内容、绑定事件…..）。

举例：v-bind:href=“xxx” 或简写为 :href=“xxx”，xxx同样要写js表达式，

且可以直接读取到data中的所有属性。

备注：Vue中有很多的指令，且形式都是：v-????，此处我们只是拿v-bind举个例子。

其实很好理解，想要显示在页面上的内容就使用{{value}}这样的写法，而v-bind:则是用于html标签中的属性绑定。

数据绑定

Vue中有2种数据绑定的方式：

1.单向绑定(v-bind)：数据只能从data流向页面。

2.双向绑定(v-model)：数据不仅能从data流向页面，还可以从页面流向data。

备注：

1.双向绑定一般都应用在表单类元素上（如：input、select等）

2.v-model:value 可以简写为 v-model，因为v-model默认收集的就是value值。

1
2
3
4
5
6
7


<!-- 普通写法 -->
单向数据绑定：<input type="text" v-bind:value="name"><br/>
双向数据绑定：<input type="text" v-model:value="name"><br/>

<!-- 简写 -->
单向数据绑定：<input type="text" :value="name"><br/>
双向数据绑定：<input type="text" v-model="name"><br/>

el与data的两种写法

data与el的2种写法

1.el有2种写法

(1).new Vue时候配置el属性。

(2).先创建Vue实例，随后再通过vm.$mount(’#root’)指定el的值。

1
2
3
4
5
6
7


const v = new Vue({
 //el:'#root', //第一种写法
 data:{
 name:'Vue'
 }
})
v.$mount('#root') //第二种写法

2.data有2种写法

(1).对象式

(2).函数式

如何选择：目前哪种写法都可以，以后学习到组件时，data必须使用函数式，否则会报错。

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


new Vue({
 el:'#root',
 //data的第一种写法：对象式
 /* data:{
 name:'Vue'
 } */

 //data的第二种写法：函数式
 data(){
 console.log('@@@',this) //此处的this是Vue实例对象
 return{
 name:'Vue'
 }
 }
})

3.一个重要的原则：

由Vue管理的函数，一定不要写箭头函数，一旦写了箭头函数，this就不再是Vue实例了。

数据代理

在讲Vue中的数据代理之前，先讲一下js中Object.defineproperty方法

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


let number = 18
let person = {
 name:'张三',
 sex:'男',
}

Object.defineProperty(person,'age',{
 // value:18,
 // enumerable:true, //控制属性是否可以枚举，默认值是false
 // writable:true, //控制属性是否可以被修改，默认值是false
 // configurable:true //控制属性是否可以被删除，默认值是false

 //当有人读取person的age属性时，get函数(getter)就会被调用，且返回值就是age的值
 get(){
 console.log('有人读取age属性了')
 return number
 },

 //当有人修改person的age属性时，set函数(setter)就会被调用，且会收到修改的具体值
 set(value){
 console.log('有人修改了age属性，且值是',value)
 number = value
 }

})

// 输出person中所有的key
// console.log(Object.keys(person))

console.log(person)

通过Object.defineProperty添加进的属性，默认是不可枚举、不可修改、不可删除的，可以通过上面的三条配置项，让其和普通的属性一样。

所谓数据代理，就是指通过一个对象代理对另一个对象中属性的操作（读/写）。

1.Vue中的数据代理：

通过vm对象来代理data对象中属性的操作（读/写）

2.Vue中数据代理的好处：

更加方便的操作data中的数据

3.基本原理：

通过Object.defineProperty()把data对象中所有属性添加到vm上。

为每一个添加到vm上的属性，都指定一个getter/setter。

在getter/setter内部去操作（读/写）data中对应的属性。

1
2
3
4
5
6
7


const vm = new Vue({
 el:'#root',
 data:{
 name:'Vue',
 password:123
 }
})

通过在控制台查看vm，可以发现data中的数据都通过数据代理在vm身上了

事件处理

事件的基本使用：

1.使用v-on:xxx 或 @xxx 绑定事件，其中xxx是事件名；

2.事件的回调需要配置在methods对象中，最终会在vm上；

3.methods中配置的函数，不要用箭头函数！否则this就不是vm了；

4.methods中配置的函数，都是被Vue所管理的函数，this的指向是vm 或组件实例对象；

5.@click=“demo” 和 @click=“demo($event)” 效果一致，但后者可以传参；

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


<!-- 准备好一个容器-->
<div id="root">
 <h2>Hello,{{name}}</h2>
<!-- <button v-on:click="showInfo">点我提示信息</button> -->
 <button @click="showInfo1">点我提示信息1（不传参）</button>
 <button @click="showInfo2($event,66)">点我提示信息2（传参）</button>
</div>
<script type="text/javascript">
 const vm = new Vue({
 el:'#root',
 data:{
 name:'Vue',
 },
 methods:{
 showInfo1(event){
 // console.log(event.target.innerText)
 // console.log(this) //此处的this是vm
 alert('同学你好！')
 },
 showInfo2(event,number){
 console.log(event,number)
 // console.log(event.target.innerText)
 // console.log(this) //此处的this是vm
 alert('同学你好！！')
 }
 }
 })
</script>

Vue中的事件修饰符：

1.prevent：阻止默认事件（常用）；

2.stop：阻止事件冒泡（常用）；

3.once：事件只触发一次（常用）；

4.capture：使用事件的捕获模式；

5.self：只有event.target是当前操作的元素时才触发事件；

6.passive：事件的默认行为立即执行，无需等待事件回调执行完毕；

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


<!-- 阻止默认事件（常用） -->
<a href="http://www.baidu.com" @click.prevent="showInfo">点我提示信息</a>

<!-- 阻止事件冒泡（常用） -->
<div class="demo1" @click="showInfo">
 <button @click.stop="showInfo">点我提示信息</button>
 <!-- 修饰符可以连续写 -->
 <!-- <a href="http://www.baidu.com" @click.prevent.stop="showInfo">点我提示信息</a> -->
</div>

<!-- 事件只触发一次（常用） -->
<button @click.once="showInfo">点我提示信息</button>

1.Vue中常用的按键别名：

回车 => enter

删除 => delete (捕获“删除”和“退格”键)

退出 => esc

空格 => space

换行 => tab (特殊，必须配合keydown去使用)

上 => up

下 => down

左 => left

右 => right

2.Vue未提供别名的按键，可以使用按键原始的key值去绑定，但注意要转为kebab-case（短横线命名）

3.系统修饰键（用法特殊）：ctrl、alt、shift、meta

(1).配合keyup使用：按下修饰键的同时，再按下其他键，随后释放其他键，事件才被触发。

(2).配合keydown使用：正常触发事件。

4.也可以使用keyCode去指定具体的按键（不推荐）

5.Vue.config.keyCodes.自定义键名 = 键码，可以去定制按键别名

一般都是@keydown.xxx或者@keyup.xxx来绑定按键

计算属性

计算属性：

1.定义：要用的属性不存在，要通过已有属性计算得来。

2.原理：底层借助了Objcet.defineproperty方法提供的getter和setter。

3.get函数什么时候执行？

(1).初次读取时会执行一次。

(2).当依赖的数据发生改变时会被再次调用。

4.优势：与methods实现相比，内部有缓存机制（复用），效率更高，调试方便。

5.备注：

1.计算属性最终会出现在vm上，直接读取使用即可。

2.如果计算属性要被修改，那必须写set函数去响应修改，且set中要引起计算时依赖的数据发生改变。

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


const vm = new Vue({
 el:'#root',
 data:{
 firstName:'张',
 lastName:'三',
 x:'你好'
 },
 computed:{
 fullName:{
 //get有什么作用？当有人读取fullName时，get就会被调用，且返回值就作为fullName的值
 //get什么时候调用？1.初次读取fullName时。2.所依赖的数据发生变化时。
 get(){
 console.log('get被调用了')
 // console.log(this) //此处的this是vm
 return this.firstName + '-' + this.lastName
 },
 //set什么时候调用? 当fullName被修改时。
 set(value){
 console.log('set',value)
 const arr = value.split('-')
 this.firstName = arr[0]
 this.lastName = arr[1]
 }
 }
 }
})

计算属性调用就和普通属性的调用一样，用{{key}}就行了。

当我们不需要计算属性的set方法时，我们就可以使用简写方法：

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


const vm = new Vue({
 el:'#root',
 data:{
 firstName:'张',
 lastName:'三',
 },
 computed:{
 //简写
 fullName(){
 console.log('get被调用了')
 return this.firstName + '-' + this.lastName
 }
 }
})

监视属性

监视属性watch：

1.当被监视的属性变化时, 回调函数自动调用, 进行相关操作

2.监视的属性必须存在，才能进行监视！！

3.监视的两种写法：

(1).new Vue时传入watch配置

(2).通过vm.$watch监视

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


<!-- 准备好一个容器-->
<div id="root">
 <h2>今天天气很{{info}}</h2>
 <button @click="changeWeather">切换天气</button>
</div>
<script type="text/javascript">
 const vm = new Vue({
 el:'#root',
 data:{
 isHot:true,
 },
 computed:{
 info(){
 return this.isHot ? '炎热' : '凉爽'
 }
 },
 methods: {
 changeWeather(){
 this.isHot = !this.isHot
 }
 },
 /* watch:{
 isHot:{
 immediate:true, //初始化时让handler调用一下
 //handler什么时候调用？当isHot发生改变时。
 handler(newValue,oldValue){
 console.log('isHot被修改了',newValue,oldValue)
 }
 }
 } */
 })

 vm.$watch('isHot',{
 immediate:true, //初始化时让handler调用一下
 //handler什么时候调用？当isHot发生改变时。
 handler(newValue,oldValue){
 console.log('isHot被修改了',newValue,oldValue)
 }
 })
</script>

深度监视：

(1).Vue中的watch默认不监测对象内部值的改变（一层）。

(2).配置deep:true可以监测对象内部值改变（多层）。

备注：

(1).Vue自身可以监测对象内部值的改变，但Vue提供的watch默认不可以！

(2).使用watch时根据数据的具体结构，决定是否采用深度监视。

计算属性也同样可以简写：

1
2
3
4
5
6


watch:{
 //简写
 isHot(newValue,oldValue){
 console.log('isHot被修改了',newValue,oldValue,this)
 }
}

computed和watch之间的区别：

1.computed能完成的功能，watch都可以完成。

2.watch能完成的功能，computed不一定能完成，例如：watch可以进行异步操作。

两个重要的小原则：

1.所被Vue管理的函数，最好写成普通函数，这样this的指向才是vm 或组件实例对象。

2.所有不被Vue所管理的函数（定时器的回调函数、ajax的回调函数等、Promise的回调函数），最好写成箭头函数，

这样this的指向才是vm 或组件实例对象。

绑定样式

绑定样式：

class样式

写法:class=“xxx” xxx可以是字符串、对象、数组。

字符串写法适用于：类名不确定，要动态获取。

对象写法适用于：要绑定多个样式，个数不确定，名字也不确定。

数组写法适用于：要绑定多个样式，个数确定，名字也确定，但不确定用不用。
style样式

:style="{fontSize: xxx}“其中xxx是动态值。

:style="[a,b]“其中a、b是样式对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


<div id="root">
 <!-- 绑定class样式--字符串写法，适用于：样式的类名不确定，需要动态指定 -->
 <div class="basic" :class="mood" @click="changeMood">{{name}}</div> <br/><br/>

 <!-- 绑定class样式--数组写法，适用于：要绑定的样式个数不确定、名字也不确定 -->
 <div class="basic" :class="classArr">{{name}}</div> <br/><br/>

 <!-- 绑定class样式--对象写法，适用于：要绑定的样式个数确定、名字也确定，但要动态决定用不用 -->
 <div class="basic" :class="classObj">{{name}}</div> <br/><br/>

 <!-- 绑定style样式--对象写法 -->
 <div class="basic" :style="styleObj">{{name}}</div> <br/><br/>
 <!-- 绑定style样式--数组写法 -->
 <div class="basic" :style="styleArr">{{name}}</div>
</div>
<script type="text/javascript">
 Vue.config.productionTip = false

 const vm = new Vue({
 el:'#root',
 data:{
 name:'尚硅谷',
 mood:'normal',
 classArr:['atguigu1','atguigu2','atguigu3'],
 classObj:{
 atguigu1:false,
 atguigu2:false,
 },
 styleObj:{
 fontSize: '40px',
 color:'red',
 },
 styleObj2:{
 backgroundColor:'orange'
 },
 styleArr:[
 {
 fontSize: '40px',
 color:'blue',
 },
 {
 backgroundColor:'gray'
 }
 ]
 },
 methods: {
 changeMood(){
 const arr = ['happy','sad','normal']
 const index = Math.floor(Math.random()*3)
 this.mood = arr[index]
 }
 },
 })
</script>

条件渲染

条件渲染：

1.v-if

写法：

(1).v-if=“表达式”

(2).v-else-if=“表达式”

(3).v-else=“表达式”

适用于：切换频率较低的场景。

特点：不展示的DOM元素直接被移除。

注意：v-if可以和:v-else-if、v-else一起使用，但要求结构不能被“打断”。

2.v-show

写法：v-show=“表达式”

适用于：切换频率较高的场景。

特点：不展示的DOM元素未被移除，仅仅是使用样式隐藏掉

3.备注：使用v-if的时，元素可能无法获取到，而使用v-show一定可以获取到。

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


<!-- 使用v-show做条件渲染 -->
<h2 v-show="false">欢迎来到{{name}}</h2>
<h2 v-show="1 === 1">欢迎来到{{name}}</h2>

<!-- 使用v-if做条件渲染 -->
<h2 v-if="1 === 1">欢迎来到{{name}}</h2>
<h2 v-if="false">欢迎来到{{name}}</h2>

<!-- v-else和v-else-if -->
<div v-if="n === 1">Angular</div>
<div v-else-if="n === 2">React</div>
<div v-else-if="n === 3">Vue</div>
<div v-else>哈哈</div>

<!-- v-if与template的配合使用 -->
<template v-if="n === 1">
 <h2>你好</h2>
 <h2>尚硅谷</h2>
 <h2>北京</h2>
</template>

列表渲染

基本列表

v-for指令:

1.用于展示列表数据

2.语法：v-for="(item, index) in xxx” :key=“yyy”

3.可遍历：数组、对象、字符串（用的很少）、指定次数（用的很少）

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


<!-- 遍历数组 -->
<h2>人员列表（遍历数组）</h2>
<ul>
 <li v-for="(p,index) of persons" :key="index">
 {{p.name}}-{{p.age}}
 </li>
</ul>

<!-- 遍历对象 -->
<h2>汽车信息（遍历对象）</h2>
<ul>
 <li v-for="(value,k) of car" :key="k">
 {{k}}-{{value}}
 </li>
</ul>

<!-- 遍历字符串 -->
<h2>测试遍历字符串（用得少）</h2>
<ul>
 <li v-for="(char,index) of str" :key="index">
 {{char}}-{{index}}
 </li>
</ul>

<!-- 遍历指定次数 -->
<h2>测试遍历指定次数（用得少）</h2>
<ul>
 <li v-for="(number,index) of 5" :key="index">
 {{index}}-{{number}}
 </li>
</ul>
<script>
 new Vue({
 el:'#root',
 data:{
 persons:[
 {id:'001',name:'张三',age:18},
 {id:'002',name:'李四',age:19},
 {id:'003',name:'王五',age:20}
 ],
 car:{
 name:'奥迪A8',
 price:'70万',
 color:'黑色'
 },
 str:'hello'
 }
 })
</script>

面试题：react、vue中的key有什么作用？（key的内部原理）

虚拟DOM中key的作用：

key是虚拟DOM对象的标识，当数据发生变化时，Vue会根据【新数据】生成【新的虚拟DOM】,

随后Vue进行【新虚拟DOM】与【旧虚拟DOM】的差异比较，比较规则如下：

2.对比规则：

(1).旧虚拟DOM中找到了与新虚拟DOM相同的key：

①.若虚拟DOM中内容没变, 直接使用之前的真实DOM！

②.若虚拟DOM中内容变了, 则生成新的真实DOM，随后替换掉页面中之前的真实DOM。

(2).旧虚拟DOM中未找到与新虚拟DOM相同的key

创建新的真实DOM，随后渲染到到页面。

3. 用index作为key可能会引发的问题：

1. 若对数据进行：逆序添加、逆序删除等破坏顺序操作:

会产生没有必要的真实DOM更新 ==> 界面效果没问题, 但效率低。

2. 如果结构中还包含输入类的DOM：

会产生错误DOM更新 ==> 界面有问题。

4. 开发中如何选择key?:

1.最好使用每条数据的唯一标识作为key, 比如id、手机号、身份证号、学号等唯一值。

2.如果不存在对数据的逆序添加、逆序删除等破坏顺序操作，仅用于渲染列表用于展示，

使用index作为key是没有问题的。

列表过滤

可以通过watch或者computed实现。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


<!-- 准备好一个容器-->
<div id="root">
 <h2>人员列表</h2>
 <input type="text" placeholder="请输入名字" v-model="keyWord">
 <ul>
 <li v-for="(p,index) of filPerons" :key="index">
 {{p.name}}-{{p.age}}-{{p.sex}}
 </li>
 </ul>
</div>

<script type="text/javascript">
 Vue.config.productionTip = false

 //用watch实现
 //#region
 new Vue({
 el:'#root',
 data:{
 keyWord:'',
 persons:[
 {id:'001',name:'马冬梅',age:19,sex:'女'},
 {id:'002',name:'周冬雨',age:20,sex:'女'},
 {id:'003',name:'周杰伦',age:21,sex:'男'},
 {id:'004',name:'温兆伦',age:22,sex:'男'}
 ],
 filPerons:[]
 },
 watch:{
 keyWord:{
 immediate:true,
 handler(val){
 this.filPerons = this.persons.filter((p)=>{
 return p.name.indexOf(val) !== -1
 })
 }
 }
 }
 })
 //#endregion

 //用computed实现
 new Vue({
 el:'#root',
 data:{
 keyWord:'',
 persons:[
 {id:'001',name:'马冬梅',age:19,sex:'女'},
 {id:'002',name:'周冬雨',age:20,sex:'女'},
 {id:'003',name:'周杰伦',age:21,sex:'男'},
 {id:'004',name:'温兆伦',age:22,sex:'男'}
 ]
 },
 computed:{
 filPerons(){
 return this.persons.filter((p)=>{
 return p.name.indexOf(this.keyWord) !== -1
 })
 }
 }
 })
</script>

列表排序

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


<!-- 准备好一个容器-->
<div id="root">
 <h2>人员列表</h2>
 <input type="text" placeholder="请输入名字" v-model="keyWord">
 <button @click="sortType = 2">年龄升序</button>
 <button @click="sortType = 1">年龄降序</button>
 <button @click="sortType = 0">原顺序</button>
 <ul>
 <li v-for="(p,index) of filPerons" :key="p.id">
 {{p.name}}-{{p.age}}-{{p.sex}}
 <input type="text">
 </li>
 </ul>
</div>

<script type="text/javascript">
 Vue.config.productionTip = false

 new Vue({
 el:'#root',
 data:{
 keyWord:'',
 sortType:0, //0原顺序 1降序 2升序
 persons:[
 {id:'001',name:'马冬梅',age:30,sex:'女'},
 {id:'002',name:'周冬雨',age:31,sex:'女'},
 {id:'003',name:'周杰伦',age:18,sex:'男'},
 {id:'004',name:'温兆伦',age:19,sex:'男'}
 ]
 },
 computed:{
 filPerons(){
 const arr = this.persons.filter((p)=>{
 return p.name.indexOf(this.keyWord) !== -1
 })
 //判断一下是否需要排序
 if(this.sortType){
 arr.sort((p1,p2)=>{
 return this.sortType === 1 ? p2.age-p1.age : p1.age-p2.age
 })
 }
 return arr
 }
 }
 })

</script>

Vue监视数据的原理：

vue会监视data中所有层次的数据。
如何监测对象中的数据？

通过setter实现监视，且要在new Vue时就传入要监测的数据。

(1).对象中后追加的属性，Vue默认不做响应式处理

(2).如需给后添加的属性做响应式，请使用如下API：

Vue.set(target，propertyName/index，value) 或

vm.$set(target，propertyName/index，value)

如何监测数组中的数据？

通过包裹数组更新元素的方法实现，本质就是做了两件事：

(1).调用原生对应的方法对数组进行更新。

(2).重新解析模板，进而更新页面。

4.在Vue修改数组中的某个元素一定要用如下方法：

1.使用这些API:push()、pop()、shift()、unshift()、splice()、sort()、reverse()

2.Vue.set() 或 vm.$set()

特别注意：Vue.set() 和 vm.$set() 不能给vm 或 vm的根数据对象添加属性！！！

收集表单数据

若：<input type="text"/>，则v-model收集的是value值，用户输入的就是value值。

若：<input type="radio"/>，则v-model收集的是value值，且要给标签配置value值。

若：<input type="checkbox"/>

1.没有配置input的value属性，那么收集的就是checked（勾选 or 未勾选，是布尔值）

2.配置input的value属性:

(1)v-model的初始值是非数组，那么收集的就是checked（勾选 or 未勾选，是布尔值）

(2)v-model的初始值是数组，那么收集的的就是value组成的数组

备注：v-model的三个修饰符：

lazy：失去焦点再收集数据

number：输入字符串转为有效的数字

trim：输入首尾空格过滤

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


<form @submit.prevent="demo">
 账号：<input type="text" v-model.trim="userInfo.account"> <br/><br/>
 密码：<input type="password" v-model="userInfo.password"> <br/><br/>
 年龄：<input type="number" v-model.number="userInfo.age"> <br/><br/>
 性别：
 男<input type="radio" name="sex" v-model="userInfo.sex" value="male">
 女<input type="radio" name="sex" v-model="userInfo.sex" value="female"> <br/><br/>
 爱好：
 学习<input type="checkbox" v-model="userInfo.hobby" value="study">
 打游戏<input type="checkbox" v-model="userInfo.hobby" value="game">
 吃饭<input type="checkbox" v-model="userInfo.hobby" value="eat">
 <br/><br/>
 所属校区
 <select v-model="userInfo.city">
 <option value="">请选择校区</option>
 <option value="beijing">北京</option>
 <option value="shanghai">上海</option>
 <option value="shenzhen">深圳</option>
 <option value="wuhan">武汉</option>
 </select>
 <br/><br/>
 其他信息：
 <textarea v-model.lazy="userInfo.other"></textarea> <br/><br/>
 <input type="checkbox" v-model="userInfo.agree">阅读并接受<a href="http://www.atguigu.com">《用户协议》</a>
 <button>提交</button>
</form>
<script>
 new Vue({
 el:'#root',
 data:{
 userInfo:{
 account:'',
 password:'',
 age:18,
 sex:'female',
 hobby:[],
 city:'beijing',
 other:'',
 agree:''
 }
 },
 methods: {
 demo(){
 console.log(JSON.stringify(this.userInfo))
 }
 }
 })
</script>

过滤器

过滤器：

定义：对要显示的数据进行特定格式化后再显示（适用于一些简单逻辑的处理）。

语法：

1.注册过滤器：Vue.filter(name,callback) 或 new Vue{filters:{}}

2.使用过滤器：{{ xxx | 过滤器名}} 或 v-bind:属性 = “xxx | 过滤器名”

备注：

1.过滤器也可以接收额外参数、多个过滤器也可以串联

2.并没有改变原本的数据, 是产生新的对应的数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


<div id="root">
 <h2>显示格式化后的时间</h2>
 <!-- 计算属性实现 -->
 <h3>现在是：{{fmtTime}}</h3>
 <!-- methods实现 -->
 <h3>现在是：{{getFmtTime()}}</h3>
 <!-- 过滤器实现 -->
 <h3>现在是：{{time | timeFormater}}</h3>
 <!-- 过滤器实现（传参） -->
 <h3>现在是：{{time | timeFormater('YYYY_MM_DD') | mySlice}}</h3>
 <h3 :x="msg | mySlice">尚硅谷</h3>
</div>

<div id="root2">
 <h2>{{msg | mySlice}}</h2>
</div>
<script>
 Vue.filter('mySlice',function(value){
 return value.slice(0,4)
 })

 new Vue({
 el:'#root',
 data:{
 time:1621561377603, //时间戳
 msg:'你好，尚硅谷'
 },
 computed: {
 fmtTime(){
 return dayjs(this.time).format('YYYY年MM月DD日 HH:mm:ss')
 }
 },
 methods: {
 getFmtTime(){
 return dayjs(this.time).format('YYYY年MM月DD日 HH:mm:ss')
 }
 },
 //局部过滤器
 filters:{
 timeFormater(value,str='YYYY年MM月DD日 HH:mm:ss'){
 // console.log('@',value)
 return dayjs(value).format(str)
 }
 }
 })

 new Vue({
 el:'#root2',
 data:{
 msg:'hello,atguigu!'
 }
 })
</script>

内置指令

我们学过的指令：

v-bind : 单向绑定解析表达式, 可简写为 :xxx

v-model : 双向数据绑定

v-for : 遍历数组/对象/字符串

v-on : 绑定事件监听, 可简写为@

v-if : 条件渲染（动态控制节点是否存存在）

v-else : 条件渲染（动态控制节点是否存存在）

v-show : 条件渲染 (动态控制节点是否展示)

v-text指令：

1.作用：向其所在的节点中渲染文本内容。

2.与插值语法的区别：v-text会替换掉节点中的内容，{{xx}}则不会。

v-html指令：

1.作用：向指定节点中渲染包含html结构的内容。

2.与插值语法的区别：

(1).v-html会替换掉节点中所有的内容，{{xx}}则不会。

(2).v-html可以识别html结构。

3.严重注意：v-html有安全性问题！！！！

(1).在网站上动态渲染任意HTML是非常危险的，容易导致XSS攻击。

(2).一定要在可信的内容上使用v-html，永不要用在用户提交的内容上！

v-cloak指令（没有值）：

1.本质是一个特殊属性，Vue实例创建完毕并接管容器后，会删掉v-cloak属性。

2.使用css配合v-cloak可以解决网速慢时页面展示出{{xxx}}的问题。

v-once指令：

1.v-once所在节点在初次动态渲染后，就视为静态内容了。

2.以后数据的改变不会引起v-once所在结构的更新，可以用于优化性能。

v-pre指令：

1.跳过其所在节点的编译过程。

2.可利用它跳过：没有使用指令语法、没有使用插值语法的节点，会加快编译。

生命周期

话不多说先上图：

生命周期：

1.又名：生命周期回调函数、生命周期函数、生命周期钩子。

2.是什么：Vue在关键时刻帮我们调用的一些特殊名称的函数。

3.生命周期函数的名字不可更改，但函数的具体内容是程序员根据需求编写的。

4.生命周期函数中的this指向是vm 或组件实例对象。

常用的生命周期钩子：

1.mounted: 发送ajax请求、启动定时器、绑定自定义事件、订阅消息等【初始化操作】。

2.beforeDestroy: 清除定时器、解绑自定义事件、取消订阅消息等【收尾工作】。

关于销毁Vue实例

1.销毁后借助Vue开发者工具看不到任何信息。

2.销毁后自定义事件会失效，但原生DOM事件依然有效。

3.一般不会在beforeDestroy操作数据，因为即便操作数据，也不会再触发更新流程了。

组件

Vue中使用组件的三大步骤：

一、定义组件(创建组件)

二、注册组件

三、使用组件(写组件标签)

一、如何定义一个组件？

使用Vue.extend(options)创建，其中options和new Vue(options)时传入的那个options几乎一样，但也有点区别；

区别如下：

1.el不要写，为什么？ ——— 最终所有的组件都要经过一个vm的管理，由vm中的el决定服务哪个容器。

2.data必须写成函数，为什么？ ———— 避免组件被复用时，数据存在引用关系。

备注：使用template可以配置组件结构。

二、如何注册组件？

1.局部注册：靠new Vue的时候传入components选项

2.全局注册：靠Vue.component(‘组件名’,组件)

三、编写组件标签：

<school></school>

几个注意点：

1.关于组件名:

一个单词组成：

第一种写法(首字母小写)：school

第二种写法(首字母大写)：School

多个单词组成：

第一种写法(kebab-case命名)：my-school

第二种写法(CamelCase命名)：MySchool (需要Vue脚手架支持)

备注：

(1).组件名尽可能回避HTML中已有的元素名称，例如：h2、H2都不行。

(2).可以使用name配置项指定组件在开发者工具中呈现的名字。

2.关于组件标签:

第一种写法：<school></school>

第二种写法：<school/>

备注：不用使用脚手架时，<school/>会导致后续组件不能渲染。

3.一个简写方式：

const school = Vue.extend(options) 可简写为：const school = options

关于VueComponent：

1.school组件本质是一个名为VueComponent的构造函数，且不是程序员定义的，是Vue.extend生成的。

2.我们只需要写<school/>或<school></school>，Vue解析时会帮我们创建school组件的实例对象，

即Vue帮我们执行的：new VueComponent(options)。

3.特别注意：每次调用Vue.extend，返回的都是一个全新的VueComponent！！！！

4.关于this指向：

(1).组件配置中：

data函数、methods中的函数、watch中的函数、computed中的函数它们的this均是【VueComponent实例对象】。

(2).new Vue(options)配置中：

data函数、methods中的函数、watch中的函数、computed中的函数它们的this均是【Vue实例对象】。

5.VueComponent的实例对象，以后简称vc（也可称之为：组件实例对象）。

Vue的实例对象，以后简称vm。

Vue2进阶

到这一部分，就要使用到脚手架了，同时也向正式的项目靠近了。

脚手架文件结构

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


├── node_modules
├── public
│ ├── favicon.ico: 页签图标
│ └── index.html: 主页面
├── src
│ ├── assets: 存放静态资源
│ │ └── logo.png
│ │── component: 存放组件
│ │ └── HelloWorld.vue
│ │── App.vue: 汇总所有组件
│ │── main.js: 入口文件
├── .gitignore: git版本管制忽略的配置
├── babel.config.js: babel的配置文件
├── package.json: 应用包配置文件
├── README.md: 应用描述文件
├── package-lock.json：包版本控制文件

关于不同版本的Vue

vue.js与vue.runtime.xxx.js的区别：
1. vue.js是完整版的Vue，包含：核心功能 + 模板解析器。
2. vue.runtime.xxx.js是运行版的Vue，只包含：核心功能；没有模板解析器。
因为vue.runtime.xxx.js没有模板解析器，所以不能使用template这个配置项，需要使用render函数接收到的createElement函数去指定具体内容。也就是代码中的这句render: h => h(App)

vue.config.js配置文件

使用vue inspect > output.js可以查看到Vue脚手架的默认配置。
使用vue.config.js可以对脚手架进行个性化定制，详情见：https://cli.vuejs.org/zh

ref属性

被用来给元素或子组件注册引用信息（id的替代者）
应用在html标签上获取的是真实DOM元素，应用在组件标签上是组件实例对象（vc）
使用方式：
1. 打标识：<h1 ref="xxx">.....</h1> 或 <School ref="xxx"></School>
2. 获取：this.$refs.xxx

props配置项

功能：让组件接收外部传过来的数据
传递数据：<Demo name="xxx"/>
接收数据：
1. 第一种方式（只接收）：props:['name']
2. 第二种方式（限制类型）：props:{name:String}
3. 第三种方式（限制类型、限制必要性、指定默认值）：
  1 2 3 4 5 6 7
  
  props:{ name:{ type:String, //类型 required:true, //必要性 default:'老王' //默认值 } }
备注：props是只读的，Vue底层会监测你对props的修改，如果进行了修改，就会发出警告，若业务需求确实需要修改，那么请复制props的内容到data中一份，然后去修改data中的数据。

mixin(混入)

功能：可以把多个组件共用的配置提取成一个混入对象
使用方式：

第一步定义混合：
1 2 3 4 5

{ data(){....}, methods:{....} .... }
第二步使用混入：

全局混入：Vue.mixin(xxx) 局部混入：mixins:['xxx']

插件

功能：用于增强Vue
本质：包含install方法的一个对象，install的第一个参数是Vue，第二个以后的参数是插件使用者传递的数据。

定义插件：

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


对象.install = function (Vue, options) {
 // 1. 添加全局过滤器
 Vue.filter(....)

 // 2. 添加全局指令
 Vue.directive(....)

 // 3. 配置全局混入(合)
 Vue.mixin(....)

 // 4. 添加实例方法
 Vue.prototype.$myMethod = function () {...}
 Vue.prototype.$myProperty = xxxx
}

使用插件：Vue.use()

scoped样式

作用：让样式在局部生效，防止冲突。
写法：<style scoped>

总结TodoList案例

组件化编码流程：

(1).拆分静态组件：组件要按照功能点拆分，命名不要与html元素冲突。

(2).实现动态组件：考虑好数据的存放位置，数据是一个组件在用，还是一些组件在用：

1).一个组件在用：放在组件自身即可。

2). 一些组件在用：放在他们共同的父组件上（状态提升）。

(3).实现交互：从绑定事件开始。
props适用于：

(1).父组件 ==> 子组件通信

(2).子组件 ==> 父组件通信（要求父先给子一个函数）
使用v-model时要切记：v-model绑定的值不能是props传过来的值，因为props是不可以修改的！
props传过来的若是对象类型的值，修改对象中的属性时Vue不会报错，但不推荐这样做。

webStorage

存储内容大小一般支持5MB左右（不同浏览器可能还不一样）
浏览器端通过 Window.sessionStorage 和 Window.localStorage 属性来实现本地存储机制。
相关API：
1. xxxxxStorage.setItem('key', 'value'); 该方法接受一个键和值作为参数，会把键值对添加到存储中，如果键名存在，则更新其对应的值。
2. xxxxxStorage.getItem('person');
  
  该方法接受一个键名作为参数，返回键名对应的值。
3. xxxxxStorage.removeItem('key');
  
  该方法接受一个键名作为参数，并把该键名从存储中删除。
4. xxxxxStorage.clear()
  
  该方法会清空存储中的所有数据。
备注：
1. SessionStorage存储的内容会随着浏览器窗口关闭而消失。
2. LocalStorage存储的内容，需要手动清除才会消失。
3. xxxxxStorage.getItem(xxx)如果xxx对应的value获取不到，那么getItem的返回值是null。
4. JSON.parse(null)的结果依然是null。

组件的自定义事件

一种组件间通信的方式，适用于：子组件 ===> 父组件
使用场景：A是父组件，B是子组件，B想给A传数据，那么就要在A中给B绑定自定义事件（事件的回调在A中）。
绑定自定义事件：
1. 第一种方式，在父组件中：<Demo @atguigu="test"/> 或 <Demo v-on:atguigu="test"/>
2. 第二种方式，在父组件中：
  1 2 3 4 5
  
  <Demo ref="demo"/> ...... mounted(){ this.$refs.xxx.$on('atguigu',this.test) }
3. 若想让自定义事件只能触发一次，可以使用once修饰符，或$once方法。
触发自定义事件：this.$emit('atguigu',数据)
解绑自定义事件this.$off('atguigu')
组件上也可以绑定原生DOM事件，需要使用native修饰符。
注意：通过this.$refs.xxx.$on('atguigu',回调)绑定自定义事件时，回调要么配置在methods中，要么用箭头函数，否则this指向会出问题！

全局事件总线（GlobalEventBus）

一种组件间通信的方式，适用于任意组件间通信。

安装全局事件总线：

1
2
3
4
5
6
7


new Vue({
 ......
 beforeCreate() {
 Vue.prototype.$bus = this //安装全局事件总线，$bus就是当前应用的vm
 },
 ......
})

使用事件总线：
1. 接收数据：A组件想接收数据，则在A组件中给$bus绑定自定义事件，事件的回调留在A组件自身。
  1 2 3 4 5 6 7
  
  methods(){ demo(data){......} } ...... mounted() { this.$bus.$on('xxxx',this.demo) }
2. 提供数据：this.$bus.$emit('xxxx',数据)
最好在beforeDestroy钩子中，用$off去解绑当前组件所用到的事件。

消息订阅与发布（pubsub）

一种组件间通信的方式，适用于任意组件间通信。
使用步骤：
1. 安装pubsub：npm i pubsub-js
2. 引入: import pubsub from 'pubsub-js'
3. 接收数据：A组件想接收数据，则在A组件中订阅消息，订阅的回调留在A组件自身。
  1 2 3 4 5 6 7
  
  methods(){ demo(data){......} } ...... mounted() { this.pid = pubsub.subscribe('xxx',this.demo) //订阅消息 }
4. 提供数据：pubsub.publish('xxx',数据)
5. 最好在beforeDestroy钩子中，用PubSub.unsubscribe(pid)去取消订阅。

nextTick

语法：this.$nextTick(回调函数)
作用：在下一次 DOM 更新结束后执行其指定的回调。
什么时候用：当改变数据后，要基于更新后的新DOM进行某些操作时，要在nextTick所指定的回调函数中执行。

Vue封装的过度与动画

作用：在插入、更新或移除 DOM元素时，在合适的时候给元素添加样式类名。
图示：无了
写法：
1. 准备好样式：
  - 元素进入的样式：
    1. v-enter：进入的起点
    2. v-enter-active：进入过程中
    3. v-enter-to：进入的终点
  - 元素离开的样式：
    1. v-leave：离开的起点
    2. v-leave-active：离开过程中
    3. v-leave-to：离开的终点
2. 使用<transition>包裹要过度的元素，并配置name属性：
  1 2 3
  
  <transition name="hello"> <h1 v-show="isShow">你好啊！</h1> </transition>
3. 备注：若有多个元素需要过度，则需要使用：<transition-group>，且每个元素都要指定key值。

vue脚手架配置代理

方法一

在vue.config.js中添加如下配置：

1
2
3


devServer:{
 proxy:"http://localhost:5000"
}

说明：

优点：配置简单，请求资源时直接发给前端（8080）即可。
缺点：不能配置多个代理，不能灵活的控制请求是否走代理。
工作方式：若按照上述配置代理，当请求了前端不存在的资源时，那么该请求会转发给服务器（优先匹配前端资源）

方法二

编写vue.config.js配置具体代理规则：

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


module.exports = {
 devServer: {
 proxy: {
 '/api1': {// 匹配所有以 '/api1'开头的请求路径
 target: 'http://localhost:5000',// 代理目标的基础路径
 changeOrigin: true,
 pathRewrite: {'^/api1': ''}
 },
 '/api2': {// 匹配所有以 '/api2'开头的请求路径
 target: 'http://localhost:5001',// 代理目标的基础路径
 changeOrigin: true,
 pathRewrite: {'^/api2': ''}
 }
 }
 }
}
/*
 changeOrigin设置为true时，服务器收到的请求头中的host为：localhost:5000
 changeOrigin设置为false时，服务器收到的请求头中的host为：localhost:8080
 changeOrigin默认值为true
*/

说明：

优点：可以配置多个代理，且可以灵活的控制请求是否走代理。
缺点：配置略微繁琐，请求资源时必须加前缀。

插槽

作用：让父组件可以向子组件指定位置插入html结构，也是一种组件间通信的方式，适用于父组件 ===> 子组件。
分类：默认插槽、具名插槽、作用域插槽

使用方式：

默认插槽：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


父组件中：
 <Category>
 <div>html结构1</div>
 </Category>
子组件中：
 <template>
 <div>
 <!-- 定义插槽 -->
 <slot>插槽默认内容...</slot>
 </div>
 </template>

具名插槽：

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


父组件中：
 <Category>
 <template slot="center">
 <div>html结构1</div>
 </template>

 <template v-slot:footer>
 <div>html结构2</div>
 </template>
 </Category>
子组件中：
 <template>
 <div>
 <!-- 定义插槽 -->
 <slot name="center">插槽默认内容...</slot>
 <slot name="footer">插槽默认内容...</slot>
 </div>
 </template>

作用域插槽：

理解：数据在组件的自身，但根据数据生成的结构需要组件的使用者来决定。（games数据在Category组件中，但使用数据所遍历出来的结构由App组件决定）

具体编码：

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


父组件中：
 <Category>
 <template scope="scopeData">
 <!-- 生成的是ul列表 -->
 <ul>
 <li v-for="g in scopeData.games" :key="g">{{g}}</li>
 </ul>
 </template>
 </Category>

 <Category>
 <template slot-scope="scopeData">
 <!-- 生成的是h4标题 -->
 <h4 v-for="g in scopeData.games" :key="g">{{g}}</h4>
 </template>
 </Category>
子组件中：
 <template>
 <div>
 <slot :games="games"></slot>
 </div>
 </template>

 <script>
 export default {
 name:'Category',
 props:['title'],
 //数据在子组件自身
 data() {
 return {
 games:['红色警戒','穿越火线','劲舞团','超级玛丽']
 }
 },
 }
 </script>

Vuex

概念

在Vue中实现集中式状态（数据）管理的一个Vue插件，对vue应用中多个组件的共享状态进行集中式的管理（读/写），也是一种组件间通信的方式，且适用于任意组件间通信。

何时使用？

多个组件需要共享数据时

搭建vuex环境

创建文件：src/store/index.js

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


//引入Vue核心库
import Vue from 'vue'
//引入Vuex
import Vuex from 'vuex'
//应用Vuex插件
Vue.use(Vuex)

//准备actions对象——响应组件中用户的动作
const actions = {}
//准备mutations对象——修改state中的数据
const mutations = {}
//准备state对象——保存具体的数据
const state = {}

//创建并暴露store
export default new Vuex.Store({
 actions,
 mutations,
 state
})

在main.js中创建vm时传入store配置项

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


......
//引入store
import store from './store'
......

//创建vm
new Vue({
 el:'#app',
 render: h => h(App),
 store
})

基本使用

初始化数据、配置actions、配置mutations，操作文件store.js

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


//引入Vue核心库
import Vue from 'vue'
//引入Vuex
import Vuex from 'vuex'
//引用Vuex
Vue.use(Vuex)

const actions = {
 //响应组件中加的动作
 jia(context,value){
 // console.log('actions中的jia被调用了',miniStore,value)
 context.commit('JIA',value)
 },
}

const mutations = {
 //执行加
 JIA(state,value){
 // console.log('mutations中的JIA被调用了',state,value)
 state.sum += value
 }
}

//初始化数据
const state = {
 sum:0
}

//创建并暴露store
export default new Vuex.Store({
 actions,
 mutations,
 state,
})

组件中读取vuex中的数据：$store.state.sum
组件中修改vuex中的数据：$store.dispatch('action中的方法名',数据) 或 $store.commit('mutations中的方法名',数据)

备注：若没有网络请求或其他业务逻辑，组件中也可以越过actions，即不写dispatch，直接编写commit

getters的使用

概念：当state中的数据需要经过加工后再使用时，可以使用getters加工。

在store.js中追加getters配置

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


......

const getters = {
 bigSum(state){
 return state.sum * 10
 }
}

//创建并暴露store
export default new Vuex.Store({
 ......
 getters
})

组件中读取数据：$store.getters.bigSum

四个map方法的使用

mapState方法：用于帮助我们映射state中的数据为计算属性

1
2
3
4
5
6
7


computed: {
 //借助mapState生成计算属性：sum、school、subject（对象写法）
 ...mapState({sum:'sum',school:'school',subject:'subject'}),

 //借助mapState生成计算属性：sum、school、subject（数组写法）
 ...mapState(['sum','school','subject']),
},

mapGetters方法：用于帮助我们映射getters中的数据为计算属性

1
2
3
4
5
6
7


computed: {
 //借助mapGetters生成计算属性：bigSum（对象写法）
 ...mapGetters({bigSum:'bigSum'}),

 //借助mapGetters生成计算属性：bigSum（数组写法）
 ...mapGetters(['bigSum'])
},

mapActions方法：用于帮助我们生成与actions对话的方法，即：包含$store.dispatch(xxx)的函数

1
2
3
4
5
6
7


methods:{
 //靠mapActions生成：incrementOdd、incrementWait（对象形式）
 ...mapActions({incrementOdd:'jiaOdd',incrementWait:'jiaWait'})

 //靠mapActions生成：incrementOdd、incrementWait（数组形式）
 ...mapActions(['jiaOdd','jiaWait'])
}

mapMutations方法：用于帮助我们生成与mutations对话的方法，即：包含$store.commit(xxx)的函数

1
2
3
4
5
6
7


methods:{
 //靠mapActions生成：increment、decrement（对象形式）
 ...mapMutations({increment:'JIA',decrement:'JIAN'}),

 //靠mapMutations生成：JIA、JIAN（对象形式）
 ...mapMutations(['JIA','JIAN']),
}

备注：mapActions与mapMutations使用时，若需要传递参数需要：在模板中绑定事件时传递好参数，否则参数是事件对象。

模块化+命名空间

目的：让代码更好维护，让多种数据分类更加明确。

修改store.js

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


const countAbout = {
 namespaced:true,//开启命名空间
 state:{x:1},
 mutations: { ... },
 actions: { ... },
 getters: {
 bigSum(state){
 return state.sum * 10
 }
 }
}

const personAbout = {
 namespaced:true,//开启命名空间
 state:{ ... },
 mutations: { ... },
 actions: { ... }
}

const store = new Vuex.Store({
 modules: {
 countAbout,
 personAbout
 }
})

开启命名空间后，组件中读取state数据：

1
2
3
4


//方式一：自己直接读取
this.$store.state.personAbout.list
//方式二：借助mapState读取：
...mapState('countAbout',['sum','school','subject']),

开启命名空间后，组件中读取getters数据：

1
2
3
4


//方式一：自己直接读取
this.$store.getters['personAbout/firstPersonName']
//方式二：借助mapGetters读取：
...mapGetters('countAbout',['bigSum'])

开启命名空间后，组件中调用dispatch

1
2
3
4


//方式一：自己直接dispatch
this.$store.dispatch('personAbout/addPersonWang',person)
//方式二：借助mapActions：
...mapActions('countAbout',{incrementOdd:'jiaOdd',incrementWait:'jiaWait'})

开启命名空间后，组件中调用commit

1
2
3
4


//方式一：自己直接commit
this.$store.commit('personAbout/ADD_PERSON',person)
//方式二：借助mapMutations：
...mapMutations('countAbout',{increment:'JIA',decrement:'JIAN'}),

路由

理解：一个路由（route）就是一组映射关系（key - value），多个路由需要路由器（router）进行管理。
前端路由：key是路径，value是组件。

基本使用

安装vue-router，命令：npm i vue-router
应用插件：Vue.use(VueRouter)

编写router配置项:

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


//引入VueRouter
import VueRouter from 'vue-router'
//引入Luyou 组件
import About from '../components/About'
import Home from '../components/Home'

//创建router实例对象，去管理一组一组的路由规则
const router = new VueRouter({
 routes:[
 {
 path:'/about',
 component:About
 },
 {
 path:'/home',
 component:Home
 }
 ]
})

//暴露router
export default router

实现切换（active-class可配置高亮样式）

1

<router-link active-class="active" to="/about">About</router-link>

指定展示位置
1

<router-view></router-view>

几个注意点

路由组件通常存放在pages文件夹，一般组件通常存放在components文件夹。
通过切换，“隐藏”了的路由组件，默认是被销毁掉的，需要的时候再去挂载。
每个组件都有自己的$route属性，里面存储着自己的路由信息。
整个应用只有一个router，可以通过组件的$router属性获取到。

多级路由（多级路由）

配置路由规则，使用children配置项：

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


routes:[
 {
 path:'/about',
 component:About,
 },
 {
 path:'/home',
 component:Home,
 children:[ //通过children配置子级路由
 {
 path:'news', //此处一定不要写：/news
 component:News
 },
 {
 path:'message',//此处一定不要写：/message
 component:Message
 }
 ]
 }
]

跳转（要写完整路径）：

1

<router-link to="/home/news">News</router-link>

路由的query参数

传递参数

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


<!-- 跳转并携带query参数，to的字符串写法 -->
<router-link :to="/home/message/detail?id=666&title=你好">跳转</router-link>

<!-- 跳转并携带query参数，to的对象写法 -->
<router-link
 :to="{
 path:'/home/message/detail',
 query:{
 id:666,
 title:'你好'
 }
 }"
>跳转</router-link>

接收参数：
1 2

$route.query.id $route.query.title

命名路由

作用：可以简化路由的跳转。

如何使用

给路由命名：

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


{
 path:'/demo',
 component:Demo,
 children:[
 {
 path:'test',
 component:Test,
 children:[
 {
 name:'hello' //给路由命名
 path:'welcome',
 component:Hello,
 }
 ]
 }
 ]
}

简化跳转：

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


<!--简化前，需要写完整的路径 -->
<router-link to="/demo/test/welcome">跳转</router-link>

<!--简化后，直接通过名字跳转 -->
<router-link :to="{name:'hello'}">跳转</router-link>

<!--简化写法配合传递参数 -->
<router-link
 :to="{
 name:'hello',
 query:{
 id:666,
 title:'你好'
 }
 }"
>跳转</router-link>

路由的params参数

配置路由，声明接收params参数

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


{
 path:'/home',
 component:Home,
 children:[
 {
 path:'news',
 component:News
 },
 {
 component:Message,
 children:[
 {
 name:'xiangqing',
 path:'detail/:id/:title', //使用占位符声明接收params参数
 component:Detail
 }
 ]
 }
 ]
}

传递参数

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


<!-- 跳转并携带params参数，to的字符串写法 -->
<router-link :to="/home/message/detail/666/你好">跳转</router-link>

<!-- 跳转并携带params参数，to的对象写法 -->
<router-link
 :to="{
 name:'xiangqing',
 params:{
 id:666,
 title:'你好'
 }
 }"
>跳转</router-link>

特别注意：路由携带params参数时，若使用to的对象写法，则不能使用path配置项，必须使用name配置！

接收参数：

1
2


$route.params.id
$route.params.title

路由的props配置

作用：让路由组件更方便的收到参数

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


{
 name:'xiangqing',
 path:'detail/:id',
 component:Detail,

 //第一种写法：props值为对象，该对象中所有的key-value的组合最终都会通过props传给Detail组件
 // props:{a:900}

 //第二种写法：props值为布尔值，布尔值为true，则把路由收到的所有params参数通过props传给Detail组件
 // props:true

 //第三种写法：props值为函数，该函数返回的对象中每一组key-value都会通过props传给Detail组件
 props(route){
 return {
 id:route.query.id,
 title:route.query.title
 }
 }
}

`<router-link>`的replace属性

作用：控制路由跳转时操作浏览器历史记录的模式
浏览器的历史记录有两种写入方式：分别为push和replace，push是追加历史记录，replace是替换当前记录。路由跳转时候默认为push
如何开启replace模式：<router-link replace .......>News</router-link>

编程式路由导航

作用：不借助<router-link> 实现路由跳转，让路由跳转更加灵活

具体编码：

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


//$router的两个API
this.$router.push({
 name:'xiangqing',
 params:{
 id:xxx,
 title:xxx
 }
})

this.$router.replace({
 name:'xiangqing',
 params:{
 id:xxx,
 title:xxx
 }
})
this.$router.forward() //前进
this.$router.back() //后退
this.$router.go() //可前进也可后退

缓存路由组件

作用：让不展示的路由组件保持挂载，不被销毁。

具体编码：

1
2
3


<keep-alive include="News">
 <router-view></router-view>
</keep-alive>

两个新的生命周期钩子

作用：路由组件所独有的两个钩子，用于捕获路由组件的激活状态。
具体名字：
1. activated路由组件被激活时触发。
2. deactivated路由组件失活时触发。

路由守卫

作用：对路由进行权限控制
分类：全局守卫、独享守卫、组件内守卫

全局守卫:

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


//全局前置守卫：初始化时执行、每次路由切换前执行
router.beforeEach((to,from,next)=>{
 console.log('beforeEach',to,from)
 if(to.meta.isAuth){ //判断当前路由是否需要进行权限控制
 if(localStorage.getItem('school') === 'atguigu'){ //权限控制的具体规则
 next() //放行
 }else{
 alert('暂无权限查看')
 // next({name:'guanyu'})
 }
 }else{
 next() //放行
 }
})

//全局后置守卫：初始化时执行、每次路由切换后执行
router.afterEach((to,from)=>{
 console.log('afterEach',to,from)
 if(to.meta.title){
 document.title = to.meta.title //修改网页的title
 }else{
 document.title = 'vue_test'
 }
})

独享守卫:

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


beforeEnter(to,from,next){
 console.log('beforeEnter',to,from)
 if(to.meta.isAuth){ //判断当前路由是否需要进行权限控制
 if(localStorage.getItem('school') === 'atguigu'){
 next()
 }else{
 alert('暂无权限查看')
 // next({name:'guanyu'})
 }
 }else{
 next()
 }
}

组件内守卫：

1
2
3
4
5
6


//进入守卫：通过路由规则，进入该组件时被调用
beforeRouteEnter (to, from, next) {
},
//离开守卫：通过路由规则，离开该组件时被调用
beforeRouteLeave (to, from, next) {
}

路由器的两种工作模式

对于一个url来说，什么是hash值？—— #及其后面的内容就是hash值。
hash值不会包含在 HTTP 请求中，即：hash值不会带给服务器。
hash模式：
1. 地址中永远带着#号，不美观。
2. 若以后将地址通过第三方手机app分享，若app校验严格，则地址会被标记为不合法。
3. 兼容性较好。
history模式：
1. 地址干净，美观。
2. 兼容性和hash模式相比略差。
3. 应用部署上线时需要后端人员支持，解决刷新页面服务端404的问题。

Swagger3初体验

Thu, 09 Sep 2021 15:09:04 +0800

最近做项目需要前后端分离，所以需要接口文档给前端方便联调。手写文档是不可能的，这时就需要使用Swagger了。网上的教程大部分版本都在2.x甚至是1.x，很少有3.0的教程，我个人就是喜欢用最新版，所以我就来分享一下我使用Swagger3的体验和坑吧。

配置

这里就分享springboot版本的方法了，现在的项目应该都用springboot创建了吧。

导入Maven依赖

1
2
3
4
5


<dependency>
 <groupId>io.springfox</groupId>
 <artifactId>springfox-boot-starter</artifactId>
 <version>3.0.0</version>
</dependency>

在启动类上加上@EnableOpenApi就行了。

当然，这样只是默认的，我们要用肯定要配置一下，我们去创建一个Config类，在里面建立一个函数返回Docket类，我们所有的配置就在这个Docket类里配置。

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


@Configuration
@EnableOpenApi
public class SwaggerConfig {
 @Bean
 public Docket docket(){
 return new Docket(DocumentationType.OAS_30) //3.0版本用OAS_30这个标准
 .apiInfo(getApiInfo())
 .select()
 //扫描指定包下的接口
 .apis(RequestHandlerSelectors.basePackage("top.lbqaq.controller"))
 .build();
 }

 /**
 * 配置swagger信息
 */
 private ApiInfo getApiInfo(){
 //这里是作者信息，分别为姓名、个人主页、邮箱
 Contact contact = new Contact("luoboQAQ","https://lbqaq.top","123@xx.com");
 return new ApiInfo(
 "项目名",
 "项目描述",
 "版本",
 "项目主页",
 contact,
 "Apache 2.0",
 "https://www.apache.org/licenses/LICENSE-2.0",
 new ArrayList());
 }
}

这样一个带有个人信息的配置页就做好了。

注解

首先是2.0版本的注解，当然新版本也同样通用。

Swagger注解	简单说明
@Api(tags = “xxx模块说明”)	作用在模块类上
@ApiOperation(“xxx接口说明”)	作用在接口方法上
@ApiModel(“xxxPOJO说明”)	作用在模型类上：如VO、BO
@ApiModelProperty(value = “xxx属性说明”,hidden = true)	作用在类方法和属性上，hidden设置为true可以隐藏该属性
@ApiParam(“xxx参数说明”)	作用在参数、方法和字段上，类似@ApiModelProperty

既然用了3.0，也就可以使用3.0的新注释。

先放上官网链接：

Swagger是底层，实现是由SpringFox来完成的，所以有些在Swagger文档里的注解放到SpringFox里就无法实现，比如@RequestBody这个注解就无法实现。下面就列举我测试过可以成功的注解：

在方法上进行注释

1
2
3


@Operation(summary = "这会显示在主页上",
 description = "这显示在内页里",
 tags = {"test"}) //会将接口分类出去

在参数上注释

1

@Parameter(description = "这里是描述", required = true)

只测了这么多，之前为了测试@RequestBody花了太多时间，结果一无所获。因为2.0的注解还能用，这里就挖个坑，等之后有时间再来完善吧。

使用Webhooks实现自动部署

Mon, 23 Aug 2021 15:44:59 +0800

每次写完博客，需要在本地编译，然后再手动通过WinSCP送到服务器上。作为一个懒人，这上面几步下来还是觉得麻烦，而且每次编译又会生成一顿不需要的文件，于是便决定整点自动化的流程，直接解放双手。

因为我的博客在没买服务器之前都是托管在Github上的，于是自然而然地就想到了Webhook，在每次Push后自动发送消息给服务器，让其自动拉取代码。

网上的教程大多都是在本地编译，然而我觉得既然要懒，就一懒到底吧，编译也直接通过Github Actions来完成就行了。

流程

需要2个Github仓库（1个应该也可以），一个存放网站的源码，一个是存放编译好的html文件。整个工作流程就如下图所示：

步骤

设置脚本

首先要写一个shell脚本，功能很简单就是自动拉取代码。

1
2
3


#!/bin/bash
cd /home/luobo/Blog
git pull

创建webhook服务后端

这里就直接使用NodeJS来创建，使用的原因很简单，因为已经有现成的插件可以使用了。

首先安装依赖

1
2


npm i -S github-webhook-handler
npm i -g pm2

然后创建webhook.js作为后端

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


var http = require('http');
var spawn = require('child_process').spawn;
var createHandler = require('github-webhook-handler');
//注意要将 secret 修改你自己的
var handler = createHandler({ path: '/webhook', secret: 'xxxxx' });

http.createServer(function (req, res) {
 handler(req, res, function (err) {
 res.statusCode = 404;
 res.end('no such location');
 })
}).listen(6666);

handler.on('error', function (err) {
 console.error('Error:', err.message)
});

handler.on('push', function (event) {
 console.log('Received a push event for %s to %s',
 event.payload.repository.name,
 event.payload.ref);

 runCommand('sh', ['./deploy.sh'], function( txt ){
 console.log(txt);
 });
});

function runCommand( cmd, args, callback ){
 var child = spawn( cmd, args );
 var resp = 'Deploy OK';
 child.stdout.on('data', function( buffer ){ resp += buffer.toString(); });
 child.stdout.on('end', function(){ callback( resp ) });
}

最后启动服务即可

1

pm2 start webhook.js

Nginx设置反代

1
2
3


location /webhook {
 proxy_pass http://127.0.0.1:6666;
}

配置Github Webhook

在 html仓库的 Settings - webhooks 设置中创建一个新的 webhook。

将Content Type 设置为 application/json，secret 设置成与 webhook.js 中的相同。

trigeer选择Just the push event. 。

完成后Github会自动发起一个测试请求，如果返回为200说明配置完成，

配置自动编译

在源代码仓库的.github/workflows目录下创建deploy.yml，并填入以下内容。

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


name: Build and Deploy
on: [push]

# 任务
jobs:
 build-and-deploy:
 # 服务器环境：最新版 Ubuntu
 runs-on: ubuntu-latest
 steps:
 # 拉取代码
 - name: Checkout
 uses: actions/checkout@v2

 # 安装Hugo
 - name: Setup Hugo
 uses: peaceiris/actions-hugo@v2
 with:
 hugo-version: latest
 extended: true

 - name: Build 
 run: hugo

 # 部署到 GitHub Pages
 - name: Deploy to GitHub Pages
 uses: JamesIves/github-pages-deploy-action@4.1.4
 with:
 BRANCH: main
 FOLDER: public
 token: ${{ secrets.GP_TOKEN }}
 repository-name: luoboQAQ/luoboQAQ.github.io

注意要将最后的repository-name换为你自己的仓库，同时需要申请和配置Github Token，这里我就不展开了。

参考

使用 GitHub Webhook 实现静态网站自动化部署

为博客添加评论系统

Sat, 21 Aug 2021 15:37:44 +0800

一个完整的博客，怎么能少的了评论系统呢。评论的实现已经有许许多多的方法了，挑来挑去，还是选择了Waline。

一开始我是采用官方推荐的LeanCloud+Vercel的方式进行部署的，结果步骤全部走完后才发现Vercel已经在国内被墙了，不科学根本上不去😇。总不能要求用户还要开梯子才能评论吧，所幸官方提供了其他的部署方式，因为我才买了自己的服务器~~（不榨干怎么行呢）~~，所以就选择本地部署+SQLlite的方式了。

部署步骤

安装node.js

由于Waline的服务端是由js写的，所以需要安装node.js

在nodejs中文网找到需要的版本，选择阿里云镜像，将下载链接复制下来
连接服务器，选择nodejs的安装目录，这里我安装在/usr/local/bin/
1

cd /usr/local/bin/

下载安装包到本地

1

wget https://npm.taobao.org/mirrors/node/v14.17.5/node-v14.17.5-linux-x64.tar.gz

解压

1

tar -xvf node-v14.17.5-linux-x64.tar.gz

重命名目录
1

mv node-v14.17.5-linux-x64 nodejs
添加目录到系统变量
1 2

cd /etc/profile.d vim custom.sh
在文件末尾添加export PATH=$PATH:/usr/local/bin/nodejs/bin
测试，输入下面3条命令，如果不报错则安装成功。
1 2 3

node -v npm version npx -v

（可选）安装cnpm

1

npm install -g cnpm --registry=https://registry.npm.taobao.org

安装Waline服务端

安装waline的服务端
1

npm install -g @waline/vercel
配置数据库。这里我采用的是SQLite，只需要下载 waline.sqlite 文件至合适的位置。

其他的数据库可以看官方文档来配置。
配置环境变量。

这里我选择新建waline.sh，方便日后维护。
1 2 3 4

cd /etc/profile.d vim waline.sh export SQLITE_PATH=/home/luobo export JWT_TOKEN=eqdVMaEwd
- SQLITE_PATH：表示SQLite文件的位置。
- JWT_TOKEN：随机一串字符串就行。

启动模块

1
2


cd /usr/local/bin/nodejs/lib
node node_modules/@waline/vercel/vanilla.js

配置nginx反代

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


#waline
server {
 listen 80;
 listen 443 ssl http2;

 server_name waline.lbqaq.top;

 if ($server_port !~ 443){
 rewrite ^(/.*)$ https://$host$1 permanent;
 }

 ssl_certificate cert/waline.lbqaq.top.pem;
 ssl_certificate_key cert/waline.lbqaq.top.key;
 ssl_session_timeout 5m;
 ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
 ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
 ssl_prefer_server_ciphers on;

 location / {
 proxy_pass http://127.0.0.1:8360;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Proto $scheme;
 proxy_set_header REMOTE-HOST $remote_addr;
 add_header X-Cache $upstream_cache_status;
 # cache
 add_header Cache-Control no-cache;
 expires 12h;
 }
}

在hugo中启用Waline

由于我用的主题已经支持Waline评论，所以只需要填入serverURL就行了。

添加QQ推送（可选）

官方提供了四种通知方法，分别为邮箱、微信、QQ、Telegram。

邮箱基本不会去看，Telegram没科学也上不去，微信由于是走的Server酱，没有捐赠一天就支持5条消息。

最终还是决定采用Qmsg 酱。

注册就不在这展开了，具体写一下环境变量的配置。

1
2
3
4
5
6
7


cd /etc/profile.d
vim waline.sh
export QMSG_KEY=xxxxxx
export QQ_ID=xxxxxx
export AUTHOR_EMAIL=xxxxxxx
export SITE_NAME=Blog
export SITE_URL=lbqaq.top

踩坑

本以为启用评论是一件很简单的事，结果花了整个下午加晚上，踩了好多好多坑。在这里就把我踩的坑记录下来，避免之后出现一样的问题。

npm install -g @waline/vercel报错

使用cnpm进行安装

2021/10/21更新：

更新系统后再尝试安装无论是npm还是cnpm都无法安装，故使用Docker进行安装和运行

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


docker run -d \
 -e SQLITE_PATH=/data \
 -e JWT_TOKEN=xxx \
 -e QMSG_KEY=xxxx \
 -e QQ_ID=123 \
 -e AUTHOR_EMAIL=xxx@xx.com \
 -e SITE_NAME=Blog \
 -e SITE_URL=lbqaq.top \
 -p 8360:8360 \
 -v /home/admin/waline:/data \
 --name=waline \
 lizheming/waline

想使用lbqaq.top/waline/这样的链接来设置服务端

直接报404错误，还是选择上文中的子域名方法
nginx提示没找到http2模块

在安装nginx时加上--with-http_v2_module如果已经安装好了，可以重新安装一遍
设置了server_name waline.lbqaq.top还是跳转首页

增加一个默认的server，将所有不匹配的链接阻止
1 2 3 4 5

server { listen 80 default_server; server_name _; return 444; }
nginx配置不生效

如果配置没有问题，除了nginx -s reload还可以尝试重启nginx

参考链接

SpringMVC学习笔记

Sun, 15 Aug 2021 09:06:00 +0800

SpringMVC也告一段落了，终于要到SpringBoot了。

还是和之前一样，笔记是基于遇见狂神说的SpringMVC视频教程而来，在此感谢能提供这么优秀的教程。

回顾MVC

什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
将业务逻辑、数据、显示分离的方法来组织代码。

**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

拓展：在前端数据传输给后端时，有些字段是不需要的，这是可能会细分出Vo层（视图）

比如：用户有账号、密码、年龄等一系列字段

这时前端登录只传了账号密码

此时可以用UserVo来表示，里面只有账号和密码

**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

用户发请求
Servlet接收请求数据，并调用对应的业务逻辑方法
业务处理完毕，返回更新后的数据给servlet
servlet转向到JSP，由JSP来渲染页面
响应给前端更新后的页面

职责分析：

Controller：控制器

取得表单数据
调用业务逻辑
转向指定的页面

Model：模型

业务逻辑
保存数据的状态

View：视图

显示页面

复习Servlet

父工程添加依赖

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


<dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.13</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>5.3.9</version>
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
 <version>3.1.0</version>
 <scope>provided</scope>
 </dependency>
 <dependency>
 <groupId>javax.servlet.jsp</groupId>
 <artifactId>jsp-api</artifactId>
 <version>2.2</version>
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jstl</artifactId>
 <version>1.2</version>
 </dependency>
</dependencies>

编写Servlet

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


public class HelloServlet extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 //获取前端操作
 String method = req.getParameter("method");
 if (method.equals("add")){
 req.getSession().setAttribute("msg","执行了add方法");
 }
 if (method.equals("delete")){
 req.getSession().setAttribute("msg","执行了delete方法");
 }
 //调用业务层
 //视图转发或重定向
 req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
 }

 @Override
 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 doGet(req, resp);
 }
}

编写test.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建test.jsp

1
2
3
4
5
6
7
8
9


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

在web.xml中注册Servlet

1
2
3
4
5
6
7
8
9


<servlet>
 <servlet-name>hello</servlet-name>
 <servlet-class>top.lbqaq.servlet.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
 <servlet-name>hello</servlet-name>
 <url-pattern>/hello</url-pattern>
</servlet-mapping>

配置TomCat，进行测试

MVC框架要做哪些事情

将url映射到java类或java类的方法 .
封装用户提交的数据 .
处理请求–调用相关的业务处理–封装响应数据 .
将响应的数据进行渲染 . jsp / html 等表示层数据 .

说明：

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM 等等….

什么是SpringMVC

概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

中文文档

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

轻量级，简单易学
高效 , 基于请求响应的MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活

中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

SpringMVC的原理如下图所示：

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

SpringMVC执行原理

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

如上url拆分成三部分：

http://localhost:8080服务器域名

SpringMVC部署在服务器上的web站点

hello表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

这里比较绕，所以直接把原文搬来了，之后等理解加深了再来补充自己的看法。

第一个SpringMVC程序

由于我们是采用子模块的方式，那么需要去IDEA里设置一下让lib会打包出去。否则就会提示404错误。

在点击IDEA右上角的小齿轮，选择项目结构，在工件下看WEB-INF里是否有lib目录，没有的话就创建一个，然后点击+号，选择库文件将所有的包导入进去。

配置版

准备要看的视图。在WEB-INF目录下创建jsp目录，在里面创建test.jsp，填入${msg}

配置SpringMVC。在web.xml里添加下面的代码。

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


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
 version="4.0">

 <!--配置DispatchServlet：这是SpringMVC的核心：请求分发器、前端控制器-->
 <servlet>
 <servlet-name>springmvc</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <!--DispatchServlet要绑定Spring的配置文件-->
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:springmvc-servlet.xml</param-value>
 </init-param>
 <!--启动级别1：随服务器一起启动-->
 <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
 <servlet-name>springmvc</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>
</web-app>

备注：/和/*的区别：/匹配所有请求，不匹配jsp页面；/*会匹配jsp页面，这样会导致嵌套，一般不会用

编写SpringMVC的配置文件springmvc-servlet.xml

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


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">

 <!--处理器映射器-->
 <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
 <!--处理器适配器-->
 <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

 <!--视图解析器-->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
 <!--前缀-->
 <property name="prefix" value="/WEB-INF/jsp/"/>
 <!--后缀-->
 <property name="suffix" value=".jsp"/>
 </bean>
</beans>

实现Controller接口

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


package top.lbqaq.Controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {
 @Override
 public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
 ModelAndView mv = new ModelAndView();
 //业务代码
 String result = "HelloSpringMVC";
 mv.addObject("msg",result);
 //视图跳转
 mv.setViewName("test");
 return mv;
 }
}

将Controller在Spring中注册(springmvc-servlet.xml)

1
2


<!--BeanNameUrlHandlerMapping:按BeanName匹配-->
<bean id="/hello" class="top.lbqaq.Controller.HelloController"/>

运行TomCat查看结果

然而正常开发并不会使用这样的方式，这样做只是为了理解底层的操作。_(:з)∠)_

注解版

配置Web.xml

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


 <!--配置DispatchServlet：这是SpringMVC的核心：请求分发器、前端控制器-->
 <servlet>
 <servlet-name>springmvc</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <!--DispatchServlet要绑定Spring的配置文件-->
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:springmvc-servlet.xml</param-value>
 </init-param>
 <!--启动级别1：随服务器一起启动；越小级别越高-->
 <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
 <servlet-name>springmvc</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>

还是老样子，这里没有什么需要改动的。

在resources目录下添加SpringMVC配置文件springmvc-servlet.xml

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


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context
 https://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/mvc
 https://www.springframework.org/schema/mvc/spring-mvc.xsd">

 <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
 <context:component-scan base-package="top.lbqaq.controller"/>
 <!-- 让Spring MVC不处理静态资源 -->
 <mvc:default-servlet-handler />
 <!--
 支持mvc注解驱动
 在spring中一般采用@RequestMapping注解来完成映射关系
 要想使@RequestMapping注解生效
 必须向上下文中注册DefaultAnnotationHandlerMapping
 和一个AnnotationMethodHandlerAdapter实例
 这两个实例分别在类级别和方法级别处理。
 而annotation-driven配置帮助我们自动完成上述两个实例的注入。
 -->
 <mvc:annotation-driven />

 <!-- 视图解析器 -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
 id="internalResourceViewResolver">
 <!-- 前缀 -->
 <property name="prefix" value="/WEB-INF/jsp/" />
 <!-- 后缀 -->
 <property name="suffix" value=".jsp" />
 </bean>

</beans>

创建Controller

1
2
3
4
5
6
7
8
9


@Controller
public class HelloController {
 @RequestMapping("/hello")
 public String hello(Model model){
 //封装数据
 model.addAttribute("msg","Hello,SpringMVCAnnotation!");
 return "hello"; //会被视图解析器处理
 }
}

@Controller是为了让Spring IOC容器初始化时自动扫描到；
@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/hello；
方法中声明Model类型的参数是为了把Action中的数据带到视图中；
方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

创建视图层，在WEB-INF/jsp目录中创建hello.jsp

1
2
3
4
5
6
7
8
9


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

运行TomCat查看结果

小结

实现步骤其实非常的简单：

新建一个web项目
导入相关jar包
编写web.xml , 注册DispatcherServlet
编写springmvc配置文件
接下来就是去创建对应的控制类 , controller
最后完善前端视图和controller之间的对应
测试运行调试.

使用springMVC必须配置的三大件：

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

RestFul风格

概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应添加、删除、修改、查询。

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RESTful操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET

http://127.0.0.1/item 新增,POST

http://127.0.0.1/item 更新,PUT

http://127.0.0.1/item/1 删除,DELETE

使用方法

创建一个类RestFulController

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


@Controller
public class RestFulController {

 //原来的：localhost:8085/add?a=1&b=2
 //Restful:localhost:8085/add/1/2
 @RequestMapping("/add/{a}/{b}")
 public String test1(@PathVariable int a,@PathVariable int b, Model model){
 int res = a+b;
 model.addAttribute("msg","结果为"+res);
 return "test";
 }
}

@RequestMapping里面的{a}就代表这里是传给a变量的值；下面的a变量前要加@PathVariable

使用路径变量的好处？

使路径变得更加简洁；
获得参数更加方便，框架会自动进行类型转换。
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

我们也可以进行方法约束，让其只响应某一种请求

1
2
3
4
5


@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

拿@GetMapping来说，就是@RequestMapping(method =RequestMethod.GET)意思，如果使用其他的方法，将会报405错误。

重定向和转发

重定向不需要视图解析器，本质就是重新请求一个新地方。

可以重定向到另外一个请求实现。

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


@Controller
public class ResultSpringMVC2 {
 @RequestMapping("/rsm2/t1")
 public String test1(){
 //转发
 return "test";
 }

 @RequestMapping("/rsm2/t2")
 public String test2(){
 //重定向
 return "redirect:/index.jsp";
 //return "redirect:hello.do"; //hello.do为另一个请求/
 }

}

数据处理

处理提交数据

1、提交的域名称和处理方法的参数名一致

提交数据 : http://localhost:8080/hello?name=lbqaq

处理方法 :

1
2
3
4
5


@RequestMapping("/hello")
public String hello(String name){
 System.out.println(name);
 return "hello";
}

后台输出 : lbqaq

2、提交的域名称和处理方法的参数名不一致

提交数据 : http://localhost:8080/hello?username=lbqaq

处理方法 :

1
2
3
4
5
6


//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
 System.out.println(name);
 return "hello";
}

后台输出 : lbqaq

3、提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

1、实体类

1
2
3
4
5
6
7
8


public class User {
 private int id;
 private String name;
 private int age;
 //构造
 //get/set
 //tostring()
}

2、提交数据 : http://localhost:8080/mvc04/user?name=lbqaq&id=1&age=15

3、处理方法 :

1
2
3
4
5


@RequestMapping("/user")
public String user(User user){
 System.out.println(user);
 return "hello";
}

后台输出 : User { id=1, name=‘lbqaq’, age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

数据显示到前端

第一种 : 通过ModelAndView

我们前面一直都是如此 . 就不过多解释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class ControllerTest1 implements Controller {

 public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
 //返回一个模型视图对象
 ModelAndView mv = new ModelAndView();
 mv.addObject("msg","ControllerTest1");
 mv.setViewName("test");
 return mv;
 }
}

第二种 : 通过ModelMap

ModelMap

1
2
3
4
5
6
7
8


@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
 //封装要显示到视图中的数据
 //相当于req.setAttribute("name",name);
 model.addAttribute("name",name);
 System.out.println(name);
 return "hello";
}

第三种 : 通过Model

Model

1
2
3
4
5
6
7
8


@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
 //封装要显示到视图中的数据
 //相当于req.setAttribute("name",name);
 model.addAttribute("msg",name);
 System.out.println(name);
 return "test";
}

对比

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

这里都是概念性的内容，所以就直接复制笔记了😌

解决乱码

直接把Spring的乱码处理器放入web.xml里

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


<filter>
 <filter-name>encoding</filter-name>
 <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
 <init-param>
 <param-name>encoding</param-name>
 <param-value>utf-8</param-value>
 </init-param>
</filter>
<filter-mapping>
 <filter-name>encoding</filter-name>
 <url-pattern>/*</url-pattern>
</filter-mapping>

JSON

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

使用Jackson

导入依赖

1
2
3
4
5
6


<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-core</artifactId>
 <version>2.12.4</version>
</dependency>

编写Controller

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


@Controller
public class UserController {

 @RequestMapping("/json1")
 @ResponseBody
 public String json1() throws JsonProcessingException {
 //创建一个jackson的对象映射器，用来解析数据
 ObjectMapper mapper = new ObjectMapper();
 //创建一个对象
 User user = new User("小明", 3, "男");
 //将我们的对象解析成为json格式
 String str = mapper.writeValueAsString(user);
 //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
 return str;
 }

如果出现乱码，可以指定编码格式为UTF8来解决

@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

这样处理乱码还是太麻烦了，可以让Spring统一管理，在SpringMVC的配置文件里加上下面的代码。

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


<mvc:annotation-driven>
 <mvc:message-converters register-defaults="true">
 <bean class="org.springframework.http.converter.StringHttpMessageConverter">
 <constructor-arg value="UTF-8"/>
 </bean>
 <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
 <property name="objectMapper">
 <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
 <property name="failOnEmptyBeans" value="false"/>
 </bean>
 </property>
 </bean>
 </mvc:message-converters>
</mvc:annotation-driven>

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

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


@RestController
public class UserController {
 //produces:指定响应体返回类型和编码
 @RequestMapping(value = "/json1")
 public String json1() throws JsonProcessingException {
 //创建一个jackson的对象映射器，用来解析数据
 ObjectMapper mapper = new ObjectMapper();
 //创建一个对象
 User user = new User("小明", 3, "男");
 //将我们的对象解析成为json格式
 String str = mapper.writeValueAsString(user);
 //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
 return str;
 }

}

自定义工具类，可以是JSON转换变得更简单

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


public class JsonUtils {

 public static String getJson(Object object) {
 return getJson(object,"yyyy-MM-dd HH:mm:ss");
 }

 public static String getJson(Object object,String dateFormat) {
 ObjectMapper mapper = new ObjectMapper();
 //不使用时间差的方式
 mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
 //自定义日期格式对象
 SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
 //指定日期格式
 mapper.setDateFormat(sdf);
 try {
 return mapper.writeValueAsString(object);
 } catch (JsonProcessingException e) {
 e.printStackTrace();
 }
 return null;
 }
}

使用FastJson

1
2
3
4
5
6


<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>fastjson</artifactId>
 <version>1.2.78</version>
</dependency>

为了使@RestController有效，需要在Spring配置里加上下面的内容

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


<mvc:annotation-driven>
 <mvc:message-converters register-defaults="true">
 <!-- 配置Fastjson支持 -->
 <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
 <property name="supportedMediaTypes">
 <list>
 <value>application/json</value>
 <value>text/html;charset=UTF-8</value>
 </list>
 </property>
 </bean>
 </mvc:message-converters>
</mvc:annotation-driven>

fastjson 三个主要的类：

JSONObject 代表 json 对象

JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

JSON类源码分析与使用
仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

测试代码

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



public class FastJsonDemo {
 public static void main(String[] args) {
 //创建一个对象
 User user1 = new User("1号", 3, "男");
 User user2 = new User("2号", 3, "男");
 User user3 = new User("3号", 3, "男");
 User user4 = new User("4号", 3, "男");
 List<User> list = new ArrayList<User>();
 list.add(user1);
 list.add(user2);
 list.add(user3);
 list.add(user4);

 System.out.println("*******Java对象 转 JSON字符串*******");
 String str1 = JSON.toJSONString(list);
 System.out.println("JSON.toJSONString(list)==>"+str1);
 String str2 = JSON.toJSONString(user1);
 System.out.println("JSON.toJSONString(user1)==>"+str2);

 System.out.println("\n****** JSON字符串 转 Java对象*******");
 User jp_user1=JSON.parseObject(str2,User.class);
 System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

 System.out.println("\n****** Java对象 转 JSON对象 ******");
 JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
 System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

 System.out.println("\n****** JSON对象 转 Java对象 ******");
 User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
 System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
 }
}

Jackson刚刚测试没成功，还是选择FastJson吧😇。

拦截器

概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

**过滤器与拦截器的区别：**拦截器是AOP思想的具体应用。

过滤器

servlet规范中的一部分，任何java web工程都可以使用
在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的

使用方法

自定义拦截器需要实现接口HandlerInterceptor

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


public class MyInterceptor implements HandlerInterceptor {
 //在请求处理的方法之前执行
 //如果返回true执行下一个拦截器
 //如果返回false就不执行下一个拦截器
 public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
 System.out.println("------------处理前------------");
 return true;
 }

 //在请求处理方法执行之后执行
 public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
 System.out.println("------------处理后------------");
 }

 //在dispatcherServlet处理后执行,做清理工作.
 public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
 System.out.println("------------清理------------");
 }
}

在springmvc的配置文件中配置拦截器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<!--关于拦截器的配置-->
<mvc:interceptors>
 <mvc:interceptor>
 <!--/** 包括路径及其子路径-->
 <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
 <!--/admin/** 拦截的是/admin/下的所有-->
 <mvc:mapping path="/**"/>
 <!--bean配置的就是拦截器-->
 <bean class="top.lbqaq.interceptor.MyInterceptor"/>
 </mvc:interceptor>
</mvc:interceptors>

执行顺序如下：

1
2
3
4


------------处理前------------
Controller方法
------------处理后------------
------------清理------------

拦截器可以用来做登录验证等等内容，这里就不展开了（才不是懒得写）

文件传输

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

对表单中的 enctype 属性做个详细的说明：

application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

1
2
3
4


<form action="" enctype="multipart/form-data" method="post">
 <input type="file" name="file"/>
 <input type="submit">
</form>

文件上传

导入依赖包

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


<!--文件上传-->
<dependency>
 <groupId>commons-fileupload</groupId>
 <artifactId>commons-fileupload</artifactId>
 <version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
 <version>4.0.1</version>
</dependency>

配置multipartResolver

这个bena的id必须为：multipartResolver ，否则上传文件会报400的错误！

1
2
3
4
5
6
7
8


<!--文件上传配置-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
 <property name="defaultEncoding" value="utf-8"/>
 <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
 <property name="maxUploadSize" value="10485760"/>
 <property name="maxInMemorySize" value="40960"/>
</bean>

编写前端页面

1
2
3
4


<form action="/upload" enctype="multipart/form-data" method="post">
 <input type="file" name="file"/>
 <input type="submit" value="upload">
</form>

配置Controller

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


package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.*;

@Controller
public class FileController {
 //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
 //批量上传CommonsMultipartFile则为数组即可
 @RequestMapping("/upload")
 public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

 //获取文件名 : file.getOriginalFilename();
 String uploadFileName = file.getOriginalFilename();

 //如果文件名为空，直接回到首页！
 if ("".equals(uploadFileName)){
 return "redirect:/index.jsp";
 }
 System.out.println("上传文件名 : "+uploadFileName);

 //上传路径保存设置
 String path = request.getServletContext().getRealPath("/upload");
 //如果路径不存在，创建一个
 File realPath = new File(path);
 if (!realPath.exists()){
 realPath.mkdir();
 }
 System.out.println("上传文件保存地址："+realPath);

 InputStream is = file.getInputStream(); //文件输入流
 OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流

 //读取写出
 int len=0;
 byte[] buffer = new byte[1024];
 while ((len=is.read(buffer))!=-1){
 os.write(buffer,0,len);
 os.flush();
 }
 os.close();
 is.close();
 return "redirect:/index.jsp";
 }
}

方法二：使用file.Transto 来保存上传的文件

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


/*
* 采用file.Transto 来保存上传的文件
*/
@RequestMapping("/upload2")
public String fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

 //上传路径保存设置
 String path = request.getServletContext().getRealPath("/upload");
 File realPath = new File(path);
 if (!realPath.exists()){
 realPath.mkdir();
 }
 //上传文件地址
 System.out.println("上传文件保存地址："+realPath);

 //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
 file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

 return "redirect:/index.jsp";
}

文件下载

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


@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
 //要下载的图片地址
 String path = request.getServletContext().getRealPath("/upload");
 String fileName = "基础语法.jpg";

 //1、设置response 响应头
 response.reset(); //设置页面不缓存,清空buffer
 response.setCharacterEncoding("UTF-8"); //字符编码
 response.setContentType("multipart/form-data"); //二进制传输数据
 //设置响应头
 response.setHeader("Content-Disposition",
 "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));

 File file = new File(path,fileName);
 //2、 读取文件--输入流
 InputStream input=new FileInputStream(file);
 //3、 写出文件--输出流
 OutputStream out = response.getOutputStream();

 byte[] buff =new byte[1024];
 int index=0;
 //4、执行 写出操作
 while((index= input.read(buff))!= -1){
 out.write(buff, 0, index);
 out.flush();
 }
 out.close();
 input.close();
 return null;
}

或者直接用a标签

<a href="/1.jpg">点击下载</a>