把开关封装成一对函数写进 shell 配置文件，启动即常驻，敲一个命令完成切换。Bash 与 PowerShell 各一份对称实现，共同点三个：默认端口集中在顶部、大小写变量都设、开启后立即验证连通性并在失败时自动回滚。

设计要点​

默认端口集中配置。 端口写在脚本顶部的 GLOBAL_DEFAULT_PROXY_PORT 变量里，换端口只改这一处，所有调用点自动生效，避免硬编码散落各处。

大小写变量都设。 http_proxy 和 HTTP_PROXY 同时 export。不同工具读取的变量名并不统一：curl、wget 读小写，而 .NET、Go 的部分 HTTP 客户端读大写。两套都设上，覆盖面最广。

all_proxy 用 socks5。 http_proxy / https_proxy 走 HTTP 代理，all_proxy 额外指定 socks5 入口，给那些支持 socks 的工具使用。

开启即验证，失败自动回滚。 enable 后立即请求一次 Google，3 秒超时。拿不到 200 就说明代理没通（端口写错、代理软件没开等），此时自动调用 disable 清理变量——否则环境里留着一组指向不通地址的代理变量，后续所有命令都会卡在连接超时上，排查很费时间。

Bash 实现​

# ================= 配置区 =================
# 修改常用默认端口，改一次全局生效
GLOBAL_DEFAULT_PROXY_PORT="7897"
# ==========================================

# 关闭代理
proxy_disable() {
    # 同时卸载小写和大写的代理变量
    unset http_proxy https_proxy all_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY
    echo -e "\033[33m❌ 代理已关闭\033[0m"
}

# 开启代理
# 用法: proxy_enable [端口号]
proxy_enable() {
    # 未指定端口时提示用法
    if [ -z "$1" ]; then
        echo -e "\033[90m💡 提示命令用法: proxy_enable <端口号>\033[0m"
        echo -e "\033[36m🔄 检测到未指定端口，将使用默认端口: ${GLOBAL_DEFAULT_PROXY_PORT}\033[0m"
    fi

    # $1 为空则回退到全局默认端口
    local port=${1:-$GLOBAL_DEFAULT_PROXY_PORT}

    # 设置代理变量（兼顾大小写）
    export http_proxy="http://127.0.0.1:${port}"
    export https_proxy="http://127.0.0.1:${port}"
    export all_proxy="socks5://127.0.0.1:${port}"

    export HTTP_PROXY="http://127.0.0.1:${port}"
    export HTTPS_PROXY="http://127.0.0.1:${port}"
    export ALL_PROXY="socks5://127.0.0.1:${port}"

    echo -e "\033[36m🚀 代理变量已设置 (端口: ${port})，正在验证网络...\033[0m"

    # 验证是否生效，3 秒超时
    local status_code=$(curl -I -s --connect-timeout 3 -w "%{http_code}" https://www.google.com -o /dev/null)

    if [ "$status_code" = "200" ]; then
        echo -e "\033[32m✅ 代理连接成功！Google 响应正常。\033[0m"
    else
        echo -e "\033[31m❌ 代理连接失败 (状态码: ${status_code:-超时/无法连接})\033[0m"
        echo -e "\033[33m🔄 正在自动清理代理环境变量...\033[0m"
        proxy_disable
        return 2
    fi
}

几个细节：

• [ -z "$1" ] 判断是否传了端口，没传就提示用法；${1:-$GLOBAL_DEFAULT_PROXY_PORT} 是参数默认值语法，$1 为空时回退到全局默认端口。
• unset 一次性卸载大小写共六个变量。
• curl -I -s --connect-timeout 3 -w "%{http_code}" -o /dev/null：只取响应头、静默、3 秒连接超时、末尾打印 HTTP 状态码、正文丢弃。拿到 200 即通。
• 失败分支先 proxy_disable 清理变量，再 return 2，用非零返回值标记失败，方便在脚本里判断。

WSL：宿主机地址不是 127.0.0.1​

WSL2 默认走独立的 NAT 网络，127.0.0.1 指向 WSL 自身而非 Windows 宿主机，直接连 127.0.0.1:7897 连不到宿主机上的代理。宿主机 IP 记在 /etc/resolv.conf 的 nameserver 一行里：

grep nameserver /etc/resolv.conf | awk '{print $2}'

要让上面的 proxy_enable 在 WSL 下也直接可用，在解析端口后加一段 host 判断：非 WSL 用 127.0.0.1，WSL 用宿主机 IP。/proc/version 里带 microsoft 字样即可识别 WSL：

proxy_enable() {
    if [ -z "$1" ]; then
        echo -e "\033[90m💡 提示命令用法: proxy_enable <端口号>\033[0m"
        echo -e "\033[36m🔄 检测到未指定端口，将使用默认端口: ${GLOBAL_DEFAULT_PROXY_PORT}\033[0m"
    fi

    local port=${1:-$GLOBAL_DEFAULT_PROXY_PORT}

    # ↓↓↓ 新增：WSL 下用宿主机 IP，否则 127.0.0.1 连不到宿主机代理
    local host="127.0.0.1"
    if grep -qi microsoft /proc/version 2>/dev/null; then
        host=$(grep nameserver /etc/resolv.conf | awk '{print $2}')
        echo -e "\033[36m🌐 检测到 WSL，使用宿主机 IP: ${host}\033[0m"
    fi
    # ↑↑↑

    # 6 个 export 把原来的 127.0.0.1 全部换成 ${host}
    export http_proxy="http://${host}:${port}"
    export https_proxy="http://${host}:${port}"
    export all_proxy="socks5://${host}:${port}"
    export HTTP_PROXY="http://${host}:${port}"
    export HTTPS_PROXY="http://${host}:${port}"
    export ALL_PROXY="socks5://${host}:${port}"

    echo -e "\033[36m🚀 代理变量已设置 (${host}:${port})，正在验证网络...\033[0m"

    # 后续验证、回滚逻辑不变……
}

改动只有两处：插入一段 host 变量判断，再把 6 个 export 里的 127.0.0.1 换成 ${host}。proxy_disable 不用动。Windows 侧代理软件还需开启「允许局域网连接（Allow LAN）」，否则宿主机会拒绝来自 WSL 网段的请求。

换 mirrored 模式：127.0.0.1 直接可用​

不想改脚本的话，切到 WSL2 的 mirrored 网络模式更省事——该模式下 WSL 与宿主机共享网卡，localhost 互通，127.0.0.1 直接连到宿主机代理，上面的 host 判断也就不必加。前提是 Windows 11 22H2 及以上（Win10 不支持）。

在 Windows 用户目录（%USERPROFILE%）下新建 .wslconfig，写入：

[wsl2]
networkingMode=mirrored

保存后执行 wsl --shutdown 关掉再重开 WSL 即可生效。

PowerShell 实现​

# ================= 配置区 =================
# 修改常用默认端口，改一次全局生效
$GLOBAL_DEFAULT_PROXY_PORT = "7897"
# ==========================================

# 关闭代理
function ProxyDisable {
    # 移除小写和大写的代理环境变量（不存在时静默忽略）
    Remove-Item env:http_proxy, env:https_proxy, env:all_proxy, env:HTTP_PROXY, env:HTTPS_PROXY, env:ALL_PROXY -ErrorAction SilentlyContinue
    Write-Host "❌ 代理已关闭" -ForegroundColor Yellow
}

# 开启代理
# 用法: ProxyEnable [端口号]
function ProxyEnable {
    param (
        [string]$Port = $GLOBAL_DEFAULT_PROXY_PORT
    )

    # 仅在用户未显式传参时提示用法
    if ($PSBoundParameters.Count -eq 0) {
        Write-Host "💡 提示命令用法: ProxyEnable <端口号>" -ForegroundColor Gray
        Write-Host "🔄 检测到未指定端口，将使用默认端口: $GLOBAL_DEFAULT_PROXY_PORT" -ForegroundColor Cyan
    }

    # 设置代理变量（兼顾大小写）
    $env:http_proxy = "http://127.0.0.1:$Port"
    $env:https_proxy = "http://127.0.0.1:$Port"
    $env:all_proxy = "socks5://127.0.0.1:$Port"

    $env:HTTP_PROXY = "http://127.0.0.1:$Port"
    $env:HTTPS_PROXY = "http://127.0.0.1:$Port"
    $env:ALL_PROXY = "socks5://127.0.0.1:$Port"

    Write-Host "🚀 代理变量已设置 (端口: $Port)，正在验证网络..." -ForegroundColor Cyan

    # 验证是否生效，3 秒超时
    try {
        $response = Invoke-WebRequest -Uri "https://www.google.com" -TimeoutSec 3 -Method Head -ErrorAction Stop
        $statusCode = $response.StatusCode
    }
    catch {
        $statusCode = "超时或无法连接"
    }

    if ($statusCode -eq 200) {
        Write-Host "✅ 代理连接成功！Google 响应正常。" -ForegroundColor Green
    }
    else {
        Write-Host "❌ 代理连接失败 (状态: $statusCode)" -ForegroundColor Red
        Write-Host "🔄 正在自动清理代理环境变量..." -ForegroundColor Yellow
        ProxyDisable
    }
}

几个细节：

• param([string]$Port = $GLOBAL_DEFAULT_PROXY_PORT) 给参数带默认值，不传也能跑。但「不传」和「传了一个等于默认值的参数」在 PowerShell 里是两回事——前者 $PSBoundParameters（实际绑定的参数字典）为空，后者非空。这里用 $PSBoundParameters.Count -eq 0 精确区分，只在用户真的没传时才打印用法提示。
• Remove-Item env:xxx -ErrorAction SilentlyContinue：卸载变量时若某个变量本就不存在会报错，加 SilentlyContinue 静默忽略。
• 验证用 Invoke-WebRequest -Method Head -TimeoutSec 3。和 Bash 不同，PowerShell 里连接超时或请求失败是抛异常而非返回状态码，所以必须用 try/catch 接住，在 catch 里把状态记为失败，再走清理逻辑。

加载到配置文件​

函数定义只有被 shell 启动时加载进会话，才能随时敲 proxy_enable / ProxyEnable 调用。两个脚本各自走自己平台的配置加载机制。

Bash 侧，把 proxy.sh 放进 ~/.profile.d/，由 ~/.profile（或 .bashrc / .zshrc）统一遍历加载：

if [ -d ~/.profile.d ]; then
  for f in ~/.profile.d/*.sh; do
    [ -r "$f" ] && . "$f"
  done
  unset f
fi

具体的拆分思路与加载方式见 配置文件正确使用姿势。

PowerShell 侧，把 Proxy.ps1 放进 $PROFILE 同目录下的 ProfileScripts/，由主配置文件 dot-source 加载：

$ConfigDir = Join-Path (Split-Path -Parent $PROFILE) "ProfileScripts"
Get-ChildItem -Path $ConfigDir -Filter *.ps1 | ForEach-Object { . $_.FullName }

完整结构与 dot-source 的作用见 PowerShell 配置文件最佳实践。

使用​

# Bash
proxy_enable            # 开启，用默认端口 7897
proxy_enable 10808      # 开启，指定端口
proxy_disable           # 关闭

# PowerShell
ProxyEnable             # 开启，用默认端口 7897
ProxyEnable 10808       # 开启，指定端口
ProxyDisable            # 关闭

开启时会打印当前端口并自动验证；代理不通则立即回滚并给出失败状态码。代理变量的含义以及 no_proxy 等其它相关变量，见 Linux 命令行设置代理。

在编程中用到的各种 random 库，都是通过算法进行一系列复杂的运算生成的序列。每次生成的结果其实都是可预测的，并不是真正的随机数。

真随机数（也被称为硬件随机数）是那种不依赖于任何逻辑算法，仅依赖于物理世界的不可预测性。计算机通过硬件捕捉真实环境中的熵（如热噪声、光电效应、放射性衰变等），转换得到的数字序列才是真随机数。各种编程语言提供的真随机数生成器（如 C++ 的 std::random_device），本质都是 CPU 提供的真随机数指令（如 Intel 的 RDRAND 指令）驱动硬件捕捉物理噪声源（电路上的电热噪声来产生熵）实现的。

算法生成伪随机数就是一次计算 $f(x)$ 值的过程，正态分布（std::normal_distribution）、均匀离散分布（std::uniform_int_distribution）和伯努利分布（std::binomial_distribution）这些复杂的算法可能不懂，但是简单的还是能轻松拿捏的，比如二次函数：

你不要在意 $ax^2+b$，你需要将该函数想象为是一个正态分布函数，当输入 $x$ 通过该函数能计算出一个“随机数”。之后将该“随机数”继续执行 $f(x)$ 计算，又能得到一个新的“随机数”。然后无限套娃：

这就是通过算法（数学公式）生成伪随机数的基本原理，每次计算的结果都是一个随机数，每一个随机数又是下一个随机数的输入值（也就是 seed）。只不过为了保证数字平均分布，实现的数学公式计算过程更加复杂而已。

到这里也能看出使用算法生成的的特点：只要初始值相同，后续计算出来的序列就完全相同，也就是说伪随机数具有可预测（可复现）性（其中初始值就是 random 库中的 seed，即种子）。

实际在使用时，为了让计算的序列表现的像“真随机”一样，在设置 seed 时都很有讲究。因为伪随机数算法本质就是确定性算法，所以想让结果不确定就需要尽可能的保证 seed 不容易被预测。常见的做法是选择当前系统的毫秒级（或微秒级）时间作为随机数的 seed，有些程序可能会使用进程ID作为 seed。

另外，伪随机数生成器的可复现性在游戏和科研领域特别重要。比如游戏中除了角色之外就是 NPC，而这个 NPC 就是通过伪随机数生成的。在玩游戏时你会发现，特定的关卡不管重开多少次，NPC 出现的时间、场景以及动作总是固定的。作为玩家，可以根据游戏场景出专属攻略。如果游戏出现 bug，作为开发者也可以通过相同的 seed 复现场景解决 bug。

在多核编程中，真共享（True Sharing）和伪共享（False Sharing）是影响并发性能的两个核心概念，它们都与 CPU 数据交换的最小单位——缓存行（Cache Line）密切相关。

CPU 从主内存（DRAM）读取数据（到 CPU 缓存）不是按单个字节或变量读取，而是以“块”为单位加载，这个块就是 Cache Line。Cache Line 大小主要由 CPU 架构决定， 现代主流（Intel/AMD 处理器）的 CPU 架构（x86_64/ARM64）多为 ‌64 字节（所以接下来都以 64 字节为例说明）。

当 CPU 需要从主内存读取数据时，它不会只读取单个字节或单个字（word），而是一次性读取 Cache Line 大小到 CPU 缓存中。这表示即使你只需要一个 4 字节的整数（int32），CPU 也会把其相邻的 60 字节一并加载到缓存中。

getconf LEVEL1_DCACHE_LINESIZE

$ uname -a
Linux debian 6.1.0-41-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.158-1 (2025-11-09) x86_64 GNU/Linux

$ getconf LEVEL1_DCACHE_LINESIZE
64

比如有如下结构体：

struct Data {
    a: i64, // 8 字节
    b: i64, // 8 字节
}

因为 CPU 每次读取一“行”数据（64 字节），编译器并不保证结构体中的字段在内存中连续性，但如果 a 和 b 在内存中是连续的（或距离很近），那么在读取 a 时，b 极大概率会被同时加载进 CPU Cache Line 中：

一次将两个数据都加载到同一个 CPU Cache Line 中，这带来一个好处：当需要访问 b 时不需要再次访问主内存，减少了 CPU 缓存与主内存的数据交换频率，可提高性能。

但如果是在多线程情况下，可能就是性能杀手。由于 a 和 b 都在同一“行”，分别被加载到 CPU 的不同核心：

• 当核心 1 修改 a，由于缓存一致性协议（MESI），一个核心修改了该变量，必须通知其他核心将对应的缓存行失效
• 所以当其他核心读取 b 时，会发现该 Cache Line 已失效（即使 b 的值根本没变），就会重新从主内存中加载该“行”数据
• 反过来，当其他核心修改 b。由于缓存一致性（MESI），同样会导致核心 1 的 Cache Line 失效。如果后续核心 1 不需要访问 a 还好，一旦需要读写就需要重新从主内存中加载最新数据

在多线程场景下，这种频繁的 MESI 通信就是拖慢程序性能的罪魁祸首（如下图）

这就是真伪共享的问题。

真共享​

真共享是多个线程（核心）访问和修改同一个变量。

为了保证缓存一致性，缓存一致性协议（MESI 协议）会强制一个核心修改后，其他核心的缓存行失效，需要重新从内存或上级缓存加载。频繁的缓存同步，虽然逻辑上没错，但性能会大幅下降。

这是不可避免的，属于程序逻辑上的真实数据共享，只能通过减少共享或使用锁/无锁机制缓解。

伪共享​

伪共享是多个线程（核心）访问不同的变量，但这些变量恰好位于同一个缓存行内。其中一个线程修改自己的变量，会导致整个缓存行在其他核心上失效（MESI 协议），即使其他线程访问的变量并未真正改变。

伪共享被称为“缓存行乒乓”（Cache Line Ping-Pong），会导致 CPU 性能大幅下降，甚至比单线程还慢。

如何解决伪共享​

解决伪共享的核心思路是：空间换时间。也就是通过填充，让不同的变量位于不同的缓存行。

如下 Rust 结构体：

/// 存在伪共享
struct FalseSharing {
    a: AtomicU64, // 8byte
    b: AtomicU64, // 8byte
}

编译器虽然不保证属性 a 和 b 在内存中的连续性，但是当 CPU 加载 a 时，b 极大概率也会被加载到同一缓存行中（因为 $a + b$ 占用的总字节数只有 16，远远小于缓存行 64 字节）。

为了保证 a 和 b 不被加载到同一 Cache Line，通常的做法是在 a 之后填充（Padding）一下无意义的字节，使其独占一个缓存行，这样 b 如果被加载，也是在新的 Cache Line 中。

Rust 中最直接的方式是使用 #[repr(align(64))] 强制一个结构体或其中的字段按照 64 字节内存对齐：

/// 自动填充 64 字节，消除伪共享
#[repr(align(64))]
struct Aligned<T>(T);

struct TureSharing {
    a: Aligned<AtomicU64>,
    b: Aligned<AtomicU64>,
}

效果如下：

Microsoft Windows 10 Professional
13th Gen Intel(R) Core(TM) i7-13700KF
rustc 1.92.0 (ded5c06cf 2025-12-08)

$ RUSTFLAGS="-C target-cpu=native" cargo run --release

伪共享地址差: 0x6000037a51b0 vs 0x6000037a51b8 = 8 字节
伪共享 (False Sharing): 4.414882127s

对齐后地址差: 0x7f91448040c0 vs 0x7f9144804100 = 64字节
非伪共享 (No False Sharing): 502.600092ms

use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::thread;
use std::time::Instant;

/// 存在伪共享
struct FalseSharing {
    a: AtomicU64,
    b: AtomicU64,
}

/// 使用对其消除伪共享
#[repr(align(64))]
struct Aligned<T>(T);

struct TureSharing {
    a: Aligned<AtomicU64>,
    b: Aligned<AtomicU64>,
}

fn run_benchmark<F>(name: &str, f: Arc<F>)
where
    F: Fn(usize) + Send + Sync + 'static,
{
    let start = Instant::now();
    let mut threads = Vec::new();
    for i in 0..2 {
        let func = Arc::clone(&f);
        threads.push(thread::spawn(move || {
            for _ in 0..100_000_000 {
                func(i);
            }
        }))
    }

    for t in threads {
        t.join().unwrap();
    }

    println!("{}: {:?}", name, start.elapsed());
}

fn main() {
    let fs = Arc::new(FalseSharing {
        a: AtomicU64::new(0),
        b: AtomicU64::new(0),
    });
    println!(
        "伪共享地址差: {:p} vs {:p} = {} 字节",
        &fs.a,
        &fs.b,
        (&fs.b as *const _ as usize) - (&fs.a as *const _ as usize)
    );

    run_benchmark(
        "伪共享 (False Sharing)",
        Arc::new(move |i| {
            if i == 0 {
                // 强制 CPU 执行更严格的缓存一致性同步，放大伪共享延迟
                fs.a.fetch_add(1, Ordering::SeqCst);
            } else {
                fs.b.fetch_add(1, Ordering::SeqCst);
            }
        }),
    );

    let ts = Arc::new(TureSharing {
        a: Aligned(AtomicU64::new(0)),
        b: Aligned(AtomicU64::new(0)),
    });
    println!(
        "\n对齐后地址差: {:p} vs {:p} = {}字节",
        &ts.a,
        &ts.b,
        (&ts.b as *const _ as usize) - (&ts.a as *const _ as usize)
    );

    run_benchmark(
        "非伪共享 (No False Sharing)",
        Arc::new(move |i| {
            if i == 0 {
                ts.a.0.fetch_add(1, Ordering::SeqCst);
            } else {
                ts.b.0.fetch_add(1, Ordering::SeqCst);
            }
        }),
    );
}

[profile.release]
opt-level = 3          # 确保是最高等级优化
lto = true             # 开启链接时优化 (Link Time Optimization)，跨模块优化
codegen-units = 1      # 限制并行编译单元，允许编译器进行更全局的优化
panic = 'abort'        # 去掉异常处理栈追踪，减小二进制体积并提速

struct Stats {
    count_a: i64,
    count_b: i64,
}

对于个人用户来说，建站最快方式就是使用赛博菩萨（CloudFlare）提供的 Pages，只需要在界面简单点几下，就能快速的部署一个静态网站，而且每天提供 10W 次免费请求额度，对个人用户真就是“白嫖”。

加上其强大的 DNS，在全球任意一个地方基本上都能实现毫秒级访问。另外如果你有自己的专属域名，配合 CloudFlare Pages 简直不要太爽。

对于 IT 开发者来说，CloudFlare Pages 最常用的方式是搭建博客、知识文档一类的站点。接下来就以 Docusaurus 为例，从头到尾的快速演示如何使用 CloudFlare Pages 搭建自己的知识网站。

创建 docusaurus 文档​

首先我假设你已经安装过 Node.js，知道如何使用 npm 和 yarn。下面是我的 Node.js 信息：

$ node -v
v24.11.1

$ npm -v
11.6.2

$ yarn -v
1.22.22

# 启用 yarn
$ corepack enable yarn

# 验证(实际是自动帮你下载安装)
$ yarn -v

首先使用 docusaurus 脚手架创建一个项目，命令如下：

npx create-docusaurus@latest website classic --typescript

其中 website 是创建的项目名，可以随意指定。 --typescript 指定项目使用 typescript，如果不指定的话默认使用 javascript，这个随意即可。

命令执行完成后，你会得到类似如下的项目结构：

.
├── README.md
├── blog
├── docs
├── node_modules
├── docusaurus.config.ts
├── package-lock.json
├── package.json
├── sidebars.ts
├── src
├── static
└── tsconfig.json

运行 npm run start 等待编译完成，在浏览器中打开 http://localhost:3000/ 你会看到如下界面：

现在一个简单的静态文档就生成好了~

接下来，关闭终端重新输入 npm run build 。等编译完成，就会发现项目根目录多了一个 build 文件夹，这个文件夹中的内容就是静态站点的全部信息，也是部署静态站点的内容。

之后将该项目上传到 Github 或 GitLab，就可以到 CloudFlare Pages 部署静态站点了。

CloudFlare Pages 部署静态站点​

进入 CloudFlare Pages，你会看到如下界面：

不要直接点击右侧的 Create application 按钮，该功能创建的是 Workers，并不是我们部署静态站点使用的 Pages。正确的姿势是依此点击 Add » Pages，接下来就会进入下图这个界面：

此时有两个选择，直接上传静态文档或者从 Git 导入构建。如果你想直接上传，只需要将前面生成的 build 文件夹上传即可。不过这种每次做修改时都需要手动执行一次上传，简直不要太麻烦。

我们需要的效果是，每次 Git 分支有新的提交就自动触发构建。所以，这里应该选择第一种 Import an existing Git repository。

接下来就需要关联自己的 Github 或 GitLab，根据自己上传的平台关联即可，关联成功后选择刚上传的项目：

继续下一步，开始设置 Pages 项目名和要构建的分支。项目名随意即可，分支的话推荐使用主分支：

继续向下，开始设置项目框架和构建命令（如下图）。CloudFlare 已经内置了所有主流的静态网站框架，你能想到的这里都有。我使用的是 Docusaurus 所以我就选择该框架：

构建命令使用 npm run build 或 yarn run build ，实际上 CloudFlare Pages 已经根据项目框架自动帮你填充了。输出目录就指定 build 即可，这是 Node.js 默认的输出目录。

另外，最后别忘记设置一下 Node.js 的 Version 环境变量。CloudFlare Pages 默认使用的版本可能与你项目不一致，为了防止潜在的问题，建议设置下你构建项目时使用的版本。

所有设置都填写完成后，就可以点击保存部署了：

从构建日志中就可以看到使用了我们环境变量中配置的 Node.js 版本，构建完成后也就表示部署完成了。现在你就可以使用 CloudFlare 为你提供的域名访问你的静态站点了。

如果你有自己的域名，并想为该 Pages 设置自己的域名，可以继续点击下方的 Add custom domain：

直接点击 Set up a custom domain：

接下来就可以填写自己的域名了：

域名填写完成后还有一个激活步骤，点击激活即可：

当激活成功之后就可以使用你的自定义域名访问网站了🎉🎉🎉🎉：

接下来你提交到 Github 的任意变更都会触发 Pages 的自动构建，真是一劳永逸~

分辨率指的是屏幕上显示像素的数量，通常用宽 × 高表示，例如：

• 2K 分辨率像素点数量为 2560×1440（约 370 万）
• 4K 分辨率像素点数量为 3840×2160（约 830 万）

2. 屏幕尺寸与像素密度​

分辨率影响的是像素点数量，屏幕尺寸决定了显示区域的物理大小，两者集合就会影响 像素密度（PPI，Pixels Per Inch）。

PPI (Pixels Per Inch，每英寸像素) 是衡量屏幕像素密度的指标，它表示在一英寸的屏幕对角线上容纳的像素点数量。

所以：

• 小屏幕+高分辨率：像素密度高，图像更细腻。
• 大屏幕+低分辨率：像素密度低，可能显得不够清晰。

例如：

• 24英寸的屏幕如果使用 4K 分辨率，图像会非常清晰，因为 PPI 很高。
• 55英寸的屏幕如果使用 4K 分辨率，图像可能看起来较模糊，因为 PPI 比较低。

如何计算 PPI 呢？计算公式如下：

根据这个公式，我们就很容易比较 4K 分辨率下，27 英寸和 32 英寸屏幕那个画面细节更强：

3. 屏幕尺寸对分辨率的实际要求​

屏幕尺寸越大，为了保持较高的清晰度（PPI），需要更高的分辨率。以下是一些推荐：

• 小于24英寸：1080p 或 2K 分辨率通常足够。
• 24-32英寸：2K 分辨率适中，4K 分辨率提供更高细节。
• 超过32英寸：建议至少 4K 分辨率，尤其是近距离使用（如电脑显示器）。

对于电视等远距离使用的大屏幕，4K 在 50英寸及以上会更有意义。

4. 用户体验与实际需求​

• 近距离使用（如电脑显示器）：高分辨率能提升细节，减少颗粒感。
• 远距离观看（如电视）：屏幕尺寸的物理限制让高分辨率的提升不如近距离明显（例如在3米外观看，4K 和 1080p 的差别可能不大）。

5. 屏幕尺寸与分辨率的权衡​

购买屏幕时，不仅要看分辨率，还要考虑：

• 视距（观看距离）：近距离需要更高分辨率。
• 预算：高分辨率通常更贵。
• 硬件性能：更高分辨率需要更强大的显卡支持，特别是玩游戏时。

6. 总结​

分辨率和屏幕尺寸没有硬性要求，但它们影响显示效果。较大的屏幕通常需要更高的分辨率以保持良好的清晰度。购买时需综合屏幕尺寸、观看距离、使用需求和硬件性能做出选择。

Ventoy 是一个开源的多功能 U 盘启动工具，用于创建可引导的 USB 驱动器。与以往的刻录工具不同（一个U盘只能制作一个系统），它可以在一个U盘上存储多个操作系统安装文件、Live CD 镜像和其他实用工具，而无需重复格式化驱动器或重新制作引导镜像。

最重要的是使用起来特别简单。

首先在官网（https://www.ventoy.net/cn/download.html）或者 GitHub 发布页（https://github.com/ventoy/Ventoy/releases）进行下载 Ventoy。

下载完成后并解压，进入文件夹后会看到类似如下的文件结构：

.
├── FOR_X64_ARM.txt
├── Ventoy2Disk.exe
├── VentoyPlugson.exe
├── VentoyVlnk.exe
├── altexe
│   ├── Ventoy2Disk_ARM.exe
│   ├── Ventoy2Disk_ARM64.exe
│   ├── Ventoy2Disk_X64.exe
│   └── VentoyPlugson_X64.exe
├── boot
├── plugin
└── ventoy

其中，我们需要使用的就是 Ventoy2Disk.exe，直接双击运行，选择具体的U盘，就可以将Ventoy安装在U盘上。具体可以参考官网文档：https://www.ventoy.net/cn/doc_start.html。

安装完成后，使用起来就特简单。只需要将系统镜像（或其他工具）直接拷贝到U盘就可以了：

之后其使用U盘启动时就会看到类似如下界面，选择某一个系统镜像即可：

关于镜像超过4G的问题：

在安装Ventoy时，默认会将U盘系统类型格式化为 exFAT，该格式支持直接拷贝4G大小镜像问题，所以这个问题理论上不存在。如果你发现无法拷贝，可能的原因就是系统格式选择了FAT32。这个时候你只需要重新打开 Ventoy2Disk.exe，在 “配置选项 — 分区设置” 中指定下分区格式重新安装即可：

Verification failed: (0X1A) Security violation​

在选择U盘启动时，如果遇到 “Verification failed: (0X1A) Security violation” 错误：https://forums.ventoy.net/showthread.php?tid=2280

出现这个问题的原因是 BIOS 打开了安全启动模式。有两种解决方案：

1、直接禁用安全模式即可

2、按照官网文档说明进行操作：https://www.ventoy.net/cn/doc_secure.html

Normal 模式 or GRUB2 模式？​

在安装时，需要选择一个安装模式：normal mode 或 grub2 mode。可能有点不知道该怎么选择，直接说答案：

1、只有在默认启动方式（Normal 模式）有问题的时候才需要用到 GRUB2 模式

2、GRUB2 模式只能用来启动含有 grub2 配置文件的 Linux 系统，不能启动 Windows/WinPE/Unix 等。

具体可以看下文档说明：https://www.ventoy.net/cn/doc_grub2boot.html

关于镜像存放问题​

我们通常将镜像放在U盘的根目录，因为有 Ventoy 的加持，我们可以正常的使用U盘（比如某种学习资料）。但是如果文件非常多的话，Ventoy 启动就会很慢（因为默认情况下，Ventoy 会遍历U盘中的所有目录及其子目录以找出所有支持的镜像文件。一般情况下U盘中的文件数目都不会很多，因此这个过程比较快，几乎感觉不到。但是如果你的U盘中有非常非常多文件的话，整个搜素过程就会很慢，就会卡很久才能进入启动菜单）。

一种简单的方式是，指定 Ventoy 扫描的具体目录！比如将上面示例中的镜像全部移动到 images 目录下：

.
├── deb
└── images
    ├── debian-11.9.0-amd64-DVD-1.iso
    ├── ubuntu-22.04.4-desktop-amd64.iso
    ├── ubuntu-22.04.4-live-server-amd64.iso
    ├── Win10_22H2_zh_CN_x64.iso
    └── Win10_22H2_en_US_x64.iso

之后双击 VentoyPlugson.exe，即可自动在网页上开发控制面板。之后再左侧菜单栏找到“全局控制插件”，并找到“指定搜索目录”。在设置中指定U盘中存放系统镜像的目录即可（必须是绝对路径）：

之后就会在U盘中根据路中自动创建一个 ventoy 文件夹，文件夹内的就是具体的配置内容。特别强调，不要手动修改！！！

具体可以参考官网文档：

https://www.ventoy.net/cn/doc_search_path.html

https://www.ventoy.net/cn/plugin_control.html

wrk 是 HTTP 基准测试工具，在单个多核 CPU 上运行时能够产生大量负载，能充分利用CPU资源，是常用的压测工具，不过缺点是不支持 Windows。

对应的Github地址是：https://github.com/wg/wrk。

类 UNIX 系统安装 wrk 非常简单，基本上都可以直接使用对应的包管理工具直接安装，具体可见：https://command-not-found.com/wrk。

如果你的发行版没有提供对应的安装方式，就只能选择编译安装了：

$ git clone https://github.com/wg/wrk.git
$ make

make之后，会在项目路径下生成可执行文件wrk，随后就可以用其进行HTTP压测了。可以把这个可执行文件拷贝到某个已在path中的路径，比如/usr/local/bin，这样就可以在任何路径直接使用wrk了。

默认情况下wrk会使用自带的LuaJIT和OpenSSL，如果你想使用系统已安装的版本，可以使用WITH_LUAJIT和WITH_OPENSSL这两个选项来指定它们的路径。比如：

$ make WITH_LUAJIT=/usr WITH_OPENSSL=/usr

参数及使用方式​

wrk 命令基本语法如下：

$ wrk <options> <url>

其中可选参数如下：

-c, --connections <N>  TCP建立连接数
-d, --duration    <T>  请求持续时间
-t, --threads     <N>  使用线程数

-H, --header      <H>  指定HTTP请求头
    --latency          打印延迟统计信息
    --timeout     <T>  超时时间

-s, --script      <S>  Lua脚本(高级使用方式)

<N> 代表数字参数, 支持国际单位 (1k, 1M, 1G)
<T> 代表时间参数, 支持时间单位 (2s, 2m, 2h)

基本使用：

$ wrk -t12 -c400 -d30s --latency http://baidu.com

以上命令使用400个连接，使用12个线程对 baidu 进行了30秒压测。下面是输出示例：

Running 30s test @ http://baidu.com
  12 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     0.00us    0.00us   0.00us    -nan%
    Req/Sec     0.00      0.00     0.00      -nan%
  Latency Distribution
     50%    0.00us
     75%    0.00us
     90%    0.00us
     99%    0.00us
  0 requests in 30.06s, 0.00B read
  Socket errors: connect 0, read 8446, write 0, timeout 0
Requests/sec:      0.00
Transfer/sec:       0.00B

Lua 脚本​

上面这种简单的压测可能不能满足我们的需求。比如我们可能需要使用POST请求跟服务器交互；可能需要为每一次请求使用不同的参数，以更好的模拟服务的实际使用场景等。wrk支持用户使用指定Lua脚本，来定制压测过程，满足个性化需求。

wrk 提供了一些 Lua 脚本示例，具体可以参考：

https://github.com/wg/wrk/tree/master/scripts

想要了解更多就需要稍微花点时间研究 Lua 脚本如何编写了~

下面是一个 POST JSON 请求示例：

post.lua：

wrk.method = "POST"
wrk.body = '{"seqname": "commons"}'
wrk.headers["Content-Type"] = "application/json"

wrk POST 请求压测示例：

$ wrk -s post.lua -t8 -c200 -d30s  http:://localhost:8080/adduser

生成 rsa 密匙对有许多中方式，而在系统中使用最多的就是 openssl。如果你的操作系统还没有 openssl，就需要手动安装。

Windows 用户需要到官网 https://www.openssl.org 进行下载安装。

Unix 用户可以直接使用默认的包管理工具进行安装。具体可以参考：https://command-not-found.com/openssl，这里提供了各种发行版对应的安装命令。

OpenSSL 生成 RSA 密钥对​

生成私钥​

$ openssl genrsa -out private_key.pem length

• private_key.pem：输出的私钥文件名
• length：指定私钥长度（如 1024、2048），越长表示加密性越强。

openssl genrsa 命令默认生成的是 PEM 格式私钥文件，PEM (Privacy-Enhanced Mail) 是一种常见的密钥和证书格式，它使用 Base64 编码的 ASCII 文本表示密钥和证书，并且通常以 .pem 作为文件扩展名。

如何区分生成的私钥是 PKCS#1 标准还是 PKCS#8 标准呢？只需要打开生成的私钥文件，看开头和结尾内容标识即可：

PKCS#1 标准文件内容开头和结尾标识：

-----BEGIN RSA PRIVATE KEY-----
.....
-----END RSA PRIVATE KEY-----

PKCS#8 标准文件内容开头和结尾标识：

-----BEGIN PRIVATE KEY-----
.....
-----END PRIVATE KEY-----

示例：

$ openssl genrsa -out private_key.pem 2048

命令执行完成之后就会看到在当前目录下多了一个 private_key.pem 私钥文件：

$ ls
private_key.pem

如果私钥文件内容以 “-----BEGIN RSA PRIVATE KEY-----” 开头，“-----END RSA PRIVATE KEY-----” 结尾，说明私钥是 PKCS#1 标准。

如果私钥文件内容以 “-----BEGIN PRIVATE KEY-----” 开头，“-----END PRIVATE KEY-----” 结尾，说明私钥是 PKCS#8 标准。

导出公钥（默认X.509格式）​

从 rsa 私钥中提取公钥，命令如下：

$ openssl rsa -in private_key.pem -pubout -out public_key.pem

private_key.pem 就是之前生成的私钥的文件名（公钥生成规则是通过计算私钥数值）。public_key.pem 表示要导出的公钥的文件。

之后的就产生了对应的公钥文件 id_rsa_pub：

$ ls
private_key.pem  public_key.pem

私钥转 PKCS8 格式​

PKCS#8 格式是一种更通用的私钥格式标准（如果你使用的是 Java、C## 开发语言就需要将私钥转换为 PKCS8 格式），相比 PKCS#1 更加通用，可以表示任意类型的私钥，不仅限于 RSA。

命令如下：

$ openssl pkcs8 -topk8 -inform PEM -in private_key.pem -outform PEM -out private_key_pkcs8.pem [-nocrypt]

• private_key_pkcs8.pem：要输出的 PSCK#8 格式文件
• -nocrypt：用于指定不对 PKCS#8 文件内容加密（根据实际需要使用，不过通常都会加上该参数）。如果不指定该参数，那么 OpenSSL 会提示你输入一个密码来加密私钥。通常提示信息如下：

Enter Encryption Password:

现在除了私钥公钥之外，当前目录下还多了一个 PKCS8 格式私钥文件：

$ ls
private_key.pem  public_key.pem  private_key_pkcs8.pem

因为 PEM 格式内容本身就是 Base64 编码的 ASCII 文本。如果程序不想以文件的形式读取 private_key_pkcs8.pem 文件，而是通过字符串的形式使用，只需要删除文件首尾两行并去除换行即可。

DER 和 PEM 格式区别​

rsa 密匙对除了 PEM 格式之外，还有 DER 格式。简单地说，他们之间的区别只是内容形式不同。DER 使用二进制编码，文件内容是原始的二进制数据。而 PEM 使用 Base64 编码，文件内容是 Base64 编码的文本。另外：

格式转换​

PKCS#1 转 DER​

openssl rsa -in private_key.pem -outform DER -out private_key.der

PKCS#1 转 PKCS#8​

openssl pkcs8 -topk8 -inform PEM -in private_key.pem -outform PEM -out private_key_pkcs8.pem [-nocrypt]

PKCS#8 转 DER​

openssl pkcs8 -topk8 -in private_key.pem -outform DER -out private_key_pkcs8.der [-nocrypt]

公钥为什么不需要做格式转换​

公钥不需要像私钥那样转换格式的主要原因有以下几点：

扩展​

使用Java生成RSA密匙对​

Java 程序生成的 RSA 密匙对私钥默认为 PKCS#8 格式，公钥则是 X.509 格式。具体的代码也很简单，直接上码：

public static void main(String[] args) throws Exception {
    genKeyPair();
}

public static void genKeyPair() throws Exception {

    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

    keyPairGen.initialize(2048); // 密匙长度

    KeyPair keyPair = keyPairGen.generateKeyPair();

    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

    System.out.println("私钥格式:" + privateKey.getFormat()); // PKCS#8
    System.out.println("公钥格式:" + publicKey.getFormat());  // X.509

    System.out.println("私钥内容: \n" + encodeToString(privateKey.getEncoded()));
    System.out.println("公钥内容: \n" + encodeToString(publicKey.getEncoded()));
}

private static String encodeToString(byte[] encoded) {
    return Base64.getEncoder().encodeToString(encoded);
}

private static byte[] decodeToByte(String decoded) {
    return Base64.getDecoder().decode(decoded);
}

使用 Go 生成RSA密匙对​

使用 Go 生成 rsa 密匙对需要使用 golang.org/x/crypto 密码库：

go install golang.org/x/crypto

相比较 Java，使用 Go 生成 rsa 密匙对就方便很多，而且将公钥和私钥转换为其他格式也特别简单，下面是示例：

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"os"
)

func main() {
	// 生成私钥
	privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)

	// 输出 pkcs1 私钥
	pem.Encode(os.Stdout, &pem.Block{
		Type:    "RSA PRIVATE KEY",
		Headers: nil,
		Bytes:   x509.MarshalPKCS1PrivateKey(privateKey),
	})

	// 输出 pkcs8 私钥
	pkcs8Private, _ := x509.MarshalPKCS8PrivateKey(privateKey)
	pem.Encode(os.Stdout, &pem.Block{
		Type:    "PRIVATE KEY",
		Headers: nil,
		Bytes:   pkcs8Private,
	})

	// 输出 X.509 公钥
	x509Public, _ := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
	pem.Encode(os.Stdout, &pem.Block{
		Type:    "PUBLIC KEY",
		Headers: nil,
		Bytes:   x509Public,
	})
}

参考资料​

https://www.cryptosys.net/pki/rsakeyformats.html

https://stackoverflow.com/questions/10783366/how-to-generate-pkcs1-rsa-keys-in-pem-format

SSH Key​

用途：

典型的应用是 SSH 客户端远程连接（登录）服务器、SCP（安全复制）和 SFTP（安全文件传输）

协议： 基于 SSH 协议

典型场景：

1. 登录远程服务器时用于身份验证（无密码登录）
2. Git 代码托管平台（如 GitHub、GitLab）上的身份验证

OpenSSH 格式（推荐）​

这是现代 OpenSSH 客户端（如 ssh-keygen）的默认格式，尤其对于较新的算法如 Ed25519。

公钥文件 (Public Key)：

1. 通常以 .pub 结尾（例如：id_rsa.pub）。
2. 是一个单行文本，包含算法类型、Base64 编码的公钥数据以及一个可选的注释（Comment）。

私钥文件 (Private Key)：

1. 通常没有文件扩展名（例如：id_rsa）或使用 .key。
2. 从 OpenSSH 7.8 版本开始，默认使用一种新的、更安全的 OpenSSH 私钥格式，该格式比旧的 PEM 格式更安全。
3. 新格式是一种带报头的 ASCII 文本块，格式本身是专用于 SSH 协议的。

PEM 格式（传统/兼容性）​

PEM（Privacy-Enhanced Mail）格式是一种通用容器格式，最初是为电子邮件安全设计的，但现在广泛用于存储加密密钥和证书。

特点： 以 Base64 编码的文本形式存储，并由明确的文本报头和报尾包围，便于在系统之间复制和传输。

旧的私钥格式： 旧版本的 ssh-keygen（在 OpenSSH 7.8 之前）默认生成的是 PEM 格式私钥。

ssh-keygen -p -f id_rsa

SSL Key​

用途：

主要用于建立客户端（如网页浏览器）和服务器之间的安全通道，以加密传输中的数据，防止窃听和篡改。典型的应用是 HTTPS，也用于 SMTPS (安全邮件) 和 FTPS (安全文件传输)。

协议： 基于 TLS/SSL 协议

典型场景：

1. 为网站配置 HTTPS。
2. 在 Web 服务器（如 Apache、Nginx）中用于加密通信。
3. 生成服务器证书或客户端证书。

格式​

所有 SSL/TLS 证书（包括公钥）都必须符合 X.509 标准，这是一个定义了公钥证书格式的 ITU-T 标准。

证书包含信息：X.509 证书不只包含公钥，它还包括：版本号、序列号、签名算法、公钥、主题（Subject，如域名）、颁发者（Issuer，如 CA 名称）、有效期、CA 的数字签名等。

虽然证书结构是 X.509，但却可以以不同的编码方式和容器格式存储。

核心区别​

总结​

1. 如果你要通过 SSH 远程连接服务器，请使用 SSH key。
2. 如果你要为网站配置 HTTPS，请使用 SSL key。

非对称加密算法是密码学的一种算法，它需要两个密钥，一个是公开密钥（简称为：公钥），另一个是私有密钥（简称为：私钥）；一个用作加密，另一个则用作解密。

使用其中一个密钥把明文加密后所得的密文，只能用相对应的另一个密钥才能解密得到原本的明文；甚至连最初用来加密的密钥也不能用作解密。

由于加密和解密需要两个不同的密钥，故被称为非对称加密；不同于加密和解密都使用同一个密钥的对称加密。

虽然两个密钥在数学上相关，但如果知道了其中一个，并不能凭此计算出另一个；因此其中一个可以公开，称为公钥，任意向外发布；不公开的密钥称为私钥，必须由用户自行严格秘密保管，绝不透过任何途径向任何人提供，也不会透露给被信任的要通信的另一方。

应用场景​

非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。

非对称加密主要应用于两个场景：数据加密和签名

加密过程​

1. A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。
   
2. A传递自己的公钥给B，B使用A的公钥对消息进行加密。
   
3. A接收到B加密的消息，利用A自己的私钥对消息进行解密。
   

整个过程中，只用A的私钥才能对消息进行解密，防止消息被泄露。

签名过程​

1. A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。
   
2. A用自己的私钥对消息进行加签，形成签名，并将签名和消息本身一起传递给B。
   
3. B收到消息后，通过A的公钥进行验签，如果验签成功，则证明消息是A发送的。
   

整个过程，只有使用A私钥签名的消息才能被验签成功。即使知道了消息内容，也无法伪造签名，防止消息被篡改。

Java 代码示例​

Rsa 加解密工具类​

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * Rsa 非对称加密解密工具类
 */
public class RsaUtil {

    /**
     * 公钥加密
     *
     * @param plaintext 明文
     * @param pubKey    公钥
     */
    public static <R> R encrypt(String plaintext, PublicKey pubKey, Production<R> production) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        byte[] encrypted = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8)); // 密文
        return production.apply(encrypted);
    }

    /**
     * 公钥加密
     *
     * @param pubKeyBase64 base64格式公钥
     */
    public static <R> R encrypt(String plaintext, String pubKeyBase64, Production<R> production) throws Exception {
        // 公钥证书
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodeBase64ToByte(pubKeyBase64));
        PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(keySpec);

        return encrypt(plaintext, publicKey, production); // 加密
    }

    /**
     * 公钥加密
     *
     * @param pubKeyBase64 base64格式公钥
     */
    public static String encryptToBase64String(String plaintext, String pubKeyBase64) throws Exception {
        // 公钥证书
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodeBase64ToByte(pubKeyBase64));
        PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(keySpec);

        return encrypt(plaintext, publicKey, RsaUtil::toBase64String); // 加密
    }

    /**
     * 私钥解密
     *
     * @param encrypted 密文
     * @param priKey    私钥
     */
    public static <R> R decrypt(String encrypted, PrivateKey priKey, Production<R> production) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        byte[] decrypted = cipher.doFinal(decodeBase64ToByte(encrypted));
        return production.apply(decrypted);
    }

    public static String decryptToString(String encrypted, PrivateKey priKey) throws Exception {
        return decrypt(encrypted, priKey, String::new);
    }

    /**
     * 私钥解密
     *
     * @param priKeyBase64 base64格式私钥
     */
    public static <R> R decrypt(String encryptedText, String priKeyBase64, Production<R> production) throws Exception {
        // 私钥证书
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodeBase64ToByte(priKeyBase64));
        PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(keySpec);

        return decrypt(encryptedText, privateKey, production);
    }

    public static String decryptToString(String encryptedText, String privateKeyBase64) throws Exception {
        return decrypt(encryptedText, privateKeyBase64, String::new);
    }

    public static String toBase64String(byte[] encoded) {
        return java.util.Base64.getEncoder().encodeToString(encoded);
    }

    public static byte[] decodeBase64ToByte(String decoded) {
        return java.util.Base64.getDecoder().decode(decoded);
    }

    @FunctionalInterface
    public interface Production<R> {
        /**
         * @return the function result
         */
        R apply(byte[] data);
    }

    /**
     * 生成密匙对
     *
     * @param keySize 密钥大小
     */
    public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException {
        // 初始化一个RSA算法的密钥对生成器
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(keySize);
        return keyGen.generateKeyPair();
    }

    public static Map<String, String> generateBase64KeyPair(int keySize) throws Exception {
        KeyPair keyPair = generateKeyPair(keySize);
        RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, String> keyMap = new HashMap<>(2);
        keyMap.put("private", toBase64String(priKey.getEncoded()));
        keyMap.put("public", toBase64String(pubKey.getEncoded()));

        return keyMap;
    }
}

Rsa 签名验签工具类​

import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.concurrent.Callable;

/**
 * <p>该类提供常见的 HashWithRSA 组合算法，用于提供数据签名和验签。</p>
 *
 * <p>HashWithRSA 指的是使用 RSA 加密算法结合哈希函数进行数字签名或数据加密。
 * RSA（Rivest–Shamir–Adleman）是一种非对称加密算法，而哈希函数则用于生成消息
 * 摘要（即签名）。</p>
 *
 * <p>加密和签名的区别:
 * 加密和签名都是为了安全性考虑，但有所不同。加密是为了防止信息被泄露，签名是为了防止信息被篡改。</p>
 *
 * <h3>加密过程：</h3>
 *
 * <ul>
 * <li>A生成一对密钥（公钥和私钥）。私钥不公开，A自己保留。公钥为公开的，任何人可以获取。</li>
 * <li>A传递自己的公钥给B，B使用A的<em>公钥对消息进行加密</em>。</li>
 * <li>A接收到B加密的消息，利用A自己的<em>私钥对消息进行解密</em></li>
 * </ul>
 *
 * <p>整个过程中，只用A的私钥才能对消息进行解密，防止消息被泄露。</p>
 *
 * <h3>签名过程:</h3>
 *
 * <ul>
 * <li>A生成一对密钥(公钥和私钥)。私钥不公开，A自己保留。公钥为公开的，任何人可以获取。</li>
 * <li>A用自己的私钥对消息进行加签，形成签名，并将签名和消息本身一起传递给B。</li>
 * <li>B收到消息后，通过A的公钥进行验签。如果验签成功，则证明消息是A发送的。</li>
 * </ul>
 *
 * <p>整个过程，只有使用A私钥签名的消息才能被验签成功。即使知道了消息内容，也无法伪造签名，防止消息被篡改。
 */
public enum HashWithRSA {

    MD5withRSA("MD5withRSA"),
    SHA1withRSA("SHA1withRSA"),
    SHA256withRSA("SHA256withRSA"),
    SHA384withRSA("SHA384withRSA"),
    SHA512withRSA("SHA512withRSA"),

    ;

    private final String algorithm;

    HashWithRSA(String algorithm) {
        this.algorithm = algorithm;
    }

    /**
     * 私钥签名
     *
     * @param priKey    私钥
     * @param plaintext 原文
     */
    public byte[] signature(byte[] priKey, byte[] plaintext) throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, SignatureException {
        // 私钥证书
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(priKey);
        PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(keySpec);

        // 进行签名
        Signature spi = Signature.getInstance(algorithm);
        spi.initSign(privateKey);
        spi.update(plaintext);

        return spi.sign();
    }

    public <R> R signature(byte[] priKey, byte[] plaintext, Production<R> production) throws Exception {
        return production.apply(signature(priKey, plaintext));
    }

    public byte[] signature(Callable<byte[]> priKey, Callable<byte[]> plaintext) throws Exception {
        return signature(priKey.call(), plaintext.call());
    }

    public <R> R signature(Callable<byte[]> priKey, Callable<byte[]> plaintext, Production<R> production) throws Exception {
        return production.apply(signature(priKey, plaintext));
    }

    public byte[] signature(String priKeyBase64, String plaintext) throws Exception {
        return signature(decodeBase64ToByte(priKeyBase64), plaintext.getBytes(StandardCharsets.UTF_8));
    }

    public <R> R signature(String priKeyBase64, String plaintext, Production<R> production) throws Exception {
        return production.apply(signature(priKeyBase64, plaintext));
    }

    /**
     * 验签
     *
     * @param pubKey    公钥
     * @param plaintext 原文
     * @param signature 私钥签名{@link #signature(byte[], byte[])}
     */
    public boolean verify(byte[] pubKey, byte[] plaintext, byte[] signature) throws NoSuchAlgorithmException, InvalidKeySpecException, SignatureException, InvalidKeyException {

        // 公钥证书
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pubKey);
        PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(keySpec);

        Signature spi = Signature.getInstance(algorithm);
        spi.initVerify(publicKey);
        spi.update(plaintext);

        // 验签
        return spi.verify(signature);
    }

    public boolean verify(String pubKeyBase64, byte[] plaintext, byte[] signature) throws NoSuchAlgorithmException, InvalidKeySpecException, SignatureException, InvalidKeyException {
        return verify(decodeBase64ToByte(pubKeyBase64), plaintext, signature);
    }

    public boolean verify(String pubKeyBase64, String plaintext, byte[] signature) throws NoSuchAlgorithmException, InvalidKeySpecException, SignatureException, InvalidKeyException {
        return verify(decodeBase64ToByte(pubKeyBase64), plaintext.getBytes(StandardCharsets.UTF_8), signature);
    }

    public boolean verify(String pubKeyBase64, String plaintext, String signature) throws NoSuchAlgorithmException, InvalidKeySpecException, SignatureException, InvalidKeyException {
        return verify(decodeBase64ToByte(pubKeyBase64), plaintext.getBytes(StandardCharsets.UTF_8), signature.getBytes(StandardCharsets.UTF_8));
    }

    public static String toBase64String(byte[] encoded) {
        return java.util.Base64.getEncoder().encodeToString(encoded);
    }

    public static byte[] decodeBase64ToByte(String decoded) {
        return java.util.Base64.getDecoder().decode(decoded);
    }

    @FunctionalInterface
    public interface Production<R> {
        /**
         * @return the function result
         */
        R apply(byte[] data);
    }
}

HMAC 工具类​

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

/**
 * <p>HMAC(Hash-based Message Authentication Code)是一种使用哈希函数
 * 和秘密密钥来生成消息认证码的算法.</p>
 *
 * <p>HMAC通过将密钥混入哈希运算中,提供了一种更强大的消息认证方法,防范了一
 * 些针对普通哈希的攻击.</p>
 *
 * <p>用于验证消息的完整性和认证消息发送者的身份.</p>
 */
public enum Hmac {
    MD5("HmacMD5"),
    SHA1("HmacSHA1"),
    SHA256("HmacSHA256"),
    SHA384("HmacSHA384"),
    SHA512("HmacSHA512"),
    ;

    private final String algorithm;

    Hmac(String algorithm) {
        this.algorithm = algorithm;
    }

    public byte[] hmac(byte[] secret, byte[] plaintext) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac mac = Mac.getInstance(this.name());
        SecretKeySpec keySpec = new SecretKeySpec(secret, algorithm);
        mac.init(keySpec);
        return mac.doFinal(plaintext);
    }

    public <R> R hmac(byte[] secret, byte[] plaintext, Production<R> production) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac mac = Mac.getInstance(this.name());
        SecretKeySpec keySpec = new SecretKeySpec(secret, algorithm);
        mac.init(keySpec);
        return production.apply(mac.doFinal(plaintext));
    }

    public String hmacHex(String secret, String plaintext) throws NoSuchAlgorithmException, InvalidKeyException {
        return hmac(secret.getBytes(StandardCharsets.UTF_8), plaintext.getBytes(StandardCharsets.UTF_8), Hex::encodeHexString);
    }

    public String hmacBase64(String secret, String plaintext) throws NoSuchAlgorithmException, InvalidKeyException {
        return hmac(secret.getBytes(StandardCharsets.UTF_8), plaintext.getBytes(StandardCharsets.UTF_8), Base64::encodeBase64String);
    }

    @FunctionalInterface
    public interface Production<R> {
        /**
         * @return the function result
         */
        R apply(byte[] data);
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {

        String secret = "f$s1f@9.";
        String plaintext = "hello,world";

        System.out.println(SHA1.hmacHex(secret, plaintext));
        System.out.println(SHA1.hmacBase64(secret, plaintext));
    }
}