Kara

2023

2026-01-01T08:11:41+00:00

数据

废话少说，先上数据。

数字生活

RescueTime

ManicTime

游戏

微软

XGP 游戏为主，其实主要就三：

卧龙 61H
P5R 49H
光环无限：45H

索尼

就玩了个 TLOU 重置（DLC 烂尾），其他的是上半年舍友玩的。

任天堂

就玩了三：

塞尔达王国之泪（烂尾）
马里奥惊奇（烂尾）
幽灵轨迹重制版

PC

心灵杀手 2
博德之门 3
仁王 2（烂尾）
近月少女的礼仪
天使☆嚣嚣RE-BOOT!

音乐

Apple Music

网易云音乐

工作

GitLab

个人榜单

剁手

最好评

AMD Radeon 7800XT

最差评

Surface Pro 9

只有 ARM 才能拯救 Surface

游戏

TaoGN GOTY: Alan Wake 2

幽灵诡计也非常非常棒，遗憾今年没有保留个人传统，把这种温暖的小品游戏留在每年结束时玩。

因为打 MOD 的原因，博德之门 BUG 太多了，体验一般，当然是我自己的问题。

音乐

Anger's Remorse

剧集

葬送的芙莉莲

另外，跨年档的《年会不能停！》和《三大队》都挺不错的，年终算是和朋友看过瘾了

总结

如果在船上就不要想凿船的事
家门不幸，别润
脑子被短视频浸泡时间过长，变不好使了
过肺也就那样，我没烟瘾，尽量不抽
重大事项和工作商谈，要长远考虑、多和朋友家人商量；前些年自己坚持“想做技术一线”的回旋镖打到自己头上了
买了两个 fufu，可爱，开心

来年

锻炼、减脂
做饭
储蓄
驾考 / 软考 / N2
少刷短视频
少看擦边和情绪输出
少导管

今年就这么稀里糊涂的过去了，给各位点一首略整蛊的《忆雾》，希望大家万事 take it easy，希望 2024 一切顺利平安，祝你开心，祝我开心。

2023 年，如何简单方便地迁移系统

2026-01-01T08:11:41+00:00

最近买了两条 P44 Pro，给三台设备换了硬盘，同时系统也要跟着换，情况如下：

一条 P44 Pro 插在台式机，需要把装在三丧 980 上的系统迁到新固态，换下的 980 准备给 NAS 用做系统盘
一条 P44 Pro 插工作笔记本，把狗屎 Intel 660P 上的系统迁到新固态上
NAS 的系统（OpenMediaVault）装在金士顿的一块廉价 SATA 固态上，准备迁到 980

总之是要克隆三个系统：两个 Windows 11，一个 Debian 11。

最终选定的解决方案是傲梅轻松备份和 Clonezilla 再生龙。

Windows

迁移

我使用的是傲梅轻松备份，使用非常简单，不用做启动盘、不用重启进入 PE，可以直接在当前系统运行的状态下克隆系统。

安装并打开软件后，点击克隆 - 系统克隆（系统迁移），按引导进行操作。

唯二需要注意的是：

新盘的数据会被擦除
新盘空间要大于或等于旧盘。

迁移后问题处理

启动到新的系统后，可能会有些在线账号权限或应用权限问题。以我出现的问题为例，可以进行如下检查：

打开设置 - 账户，检查 Microsoft 账户是否正常，一般有问题会弹出提示，按提示输入账号密码重新登陆微软账户就好
所有 UWP 应用都无法启动，出现“离线或不在磁盘上”之类的错误，我是这么处理的：
- 检查新系统的盘符是否紊乱，如果盘符和旧系统不一致，在计算机管理 - 磁盘管理中，右键目标磁盘 - 更改驱动器号和路径，将盘符恢复为旧系统的即可：
- 使用管理员权限运行 Powershell，键入以下两行命令：
```
$manifest = (Get-AppxPackage Microsoft.WindowsStore).InstallLocation + '\AppxManifest.xml' ; Add-AppxPackage -DisableDevelopmentMode -Register $manifest

Get-AppXPackage -AllUsers |Where-Object {$_.InstallLocation -like "*SystemApps*"}
```
- 重启

Linux

迁移

使用再生龙（Clonezilla）进行系统克隆，直接下载最新稳定版：

Clonezilla - Browse /clonezilla_live_stable at SourceForge.net
上面的下载慢可以从 OSDN 下载：Download File List - Clonezilla - OSDN

下载并用 Rufus 等工具录好 Live CD 启动后，跟随程序引导，十几分钟就能搞定系统迁移工作，而且不用操心引导修复之类的问题，真心好用。

最后，如果是同一机器系统克隆，在迁移完后，记得关机、拆掉原来的系统盘，然后再开机。不然按官方所说，可能会造成一些非预期的问题。

迁移后问题处理（扩容）

因为赶时间又不熟悉再生龙，所以一路选的默认配置：

最终效果是硬盘对拷 + 引导自动修复，有 200G+ 空间未分配，造成了浪费。我猜再生龙配置途中应该要选一个类似于“按扇区倍数放大”的选项，才能直接利用所有空间（风险未知，博主未验证）。克隆后系统盘的状况如下（这码打了跟没打一样）：

此种浪费当然是不能容忍的，于是准备把 /dev/nvme0n1 上未利用的 200G 分配到 / 去。

可以看到 nvme01n1p3 作为 swap 在扇区末尾，比较简单粗暴的扩容方式是直接删去交换区，扩容 ovme01n1p2，随后再手动添加 swap。博主也正是使用此方式进行的扩容。

删除 Swap

关闭系统 swap：

swapoff --all

编辑 fatab 配置，注释 swap 部分：

vim /etc/fstab
# 注释部分：
# swap was on /dev/sdb3 during installation
#UUID=764d78f5-c416-46db-985f-69808aefcdf8 none            swap    sw              0       0

另外再编辑 initramfs 的 resume 文件，注释掉 swap 的 UUID，并添加新行（不明觉厉）：

vim /etc/initramfs-tools/conf.d/resume

# 内容：
#RESUME=UUID=764d78f5-c416-46db-985f-69808aefcdf8
RESUME=none

更新 initramfs:

update-initramfs -u

# 输出：
update-initramfs: Generating /boot/initrd.img-6.0.0-0.deb11.6-amd64

启动 fdisk，删除 swap 分区：

p - 显示分区

d - 删除分区

n - 添加分区

w - 保存设置

fdisk /dev/nvme0n1

Welcome to fdisk (util-linux 2.36.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.


Command (m for help): p
Disk /dev/nvme0n1: 465.76 GiB, 500107862016 bytes, 976773168 sectors
Disk model: Samsung SSD 980 500GB                   
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 16384 bytes / 131072 bytes
Disklabel type: gpt
Disk identifier: 4F5E1E90-9B68-4492-8080-9FB7EB89CAFF

Device             Start       End   Sectors   Size Type
/dev/nvme0n1p1      2048   1050623   1048576   512M EFI System
/dev/nvme0n1p2   1050624 466862079 465811456 222.1G Linux filesystem
/dev/nvme0n1p3 466862080 468860927   1998848   976M Linux swap

Command (m for help): d
Partition number (1-3, default 3): 3

Partition 3 has been deleted.

Command (m for help): p               
Disk /dev/nvme0n1: 465.76 GiB, 500107862016 bytes, 976773168 sectors
Disk model: Samsung SSD 980 500GB                   
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 16384 bytes / 131072 bytes
Disklabel type: gpt
Disk identifier: 4F5E1E90-9B68-4492-8080-9FB7EB89CAFF

Device           Start       End   Sectors   Size Type
/dev/nvme0n1p1    2048   1050623   1048576   512M EFI System
/dev/nvme0n1p2 1050624 466862079 465811456 222.1G Linux filesystem

Command (m for help): w       
The partition table has been altered.
Syncing disks.

扩容

运行 fdisk，编辑 / 对应分区的扇区记录，直接把所有后续扇区划给 nvme0n1p2。

这里有几个操作需要注意：

d 删除分区后，千万不要手贱立即 w 保存
n 新建分区后，可能会提示我们存在 ext4 signature，根据这个解答：linux - What is a vfat signature? - Unix & Linux Stack Exchange，我输入的是 N

fdisk /dev/nvme0n1

Command (m for help): p
Disk /dev/nvme0n1: 465.76 GiB, 500107862016 bytes, 976773168 sectors
Disk model: Samsung SSD 980 500GB                   
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 16384 bytes / 131072 bytes
Disklabel type: gpt
Disk identifier: 4F5E1E90-9B68-4492-8080-9FB7EB89CAFF

Device           Start       End   Sectors   Size Type
/dev/nvme0n1p1    2048   1050623   1048576   512M EFI System
/dev/nvme0n1p2 1050624 466862079 465811456 222.1G Linux filesystem


Command (m for help): d
Partition number (1,2, default 2): 2

Partition 2 has been deleted.

Command (m for help): n
Partition number (2-128, default 2): 
First sector (1050624-976773134, default 1050624): 
Last sector, +/-sectors or +/-size{K,M,G,T,P} (1050624-976773134, default 976773134): 

Created a new partition 2 of type 'Linux filesystem' and of size 465.3 GiB.
Partition #2 contains a ext4 signature.

Do you want to remove the signature? [Y]es/[N]o: N

Command (m for help): p

Disk /dev/nvme0n1: 465.76 GiB, 500107862016 bytes, 976773168 sectors
Disk model: Samsung SSD 980 500GB                   
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 16384 bytes / 131072 bytes
Disklabel type: gpt
Disk identifier: 4F5E1E90-9B68-4492-8080-9FB7EB89CAFF

Device           Start       End   Sectors   Size Type
/dev/nvme0n1p1    2048   1050623   1048576   512M EFI System
/dev/nvme0n1p2 1050624 976773134 975722511 465.3G Linux filesystem

Command (m for help): w
The partition table has been altered.
Syncing disks.

应用分区变化：

partprobe /dev/nvme0n1

扩容：

resize2fs /dev/nvme0n1p2

# 输出：
resize2fs 1.46.5 (30-Dec-2021)
Filesystem at /dev/nvme0n1p2 is mounted on /; on-line resizing required
old_desc_blocks = 28, new_desc_blocks = 59
The filesystem on /dev/nvme0n1p2 is now 121965313 (4k) blocks long.

检查容量：

df -TH

# 输出：
文件系统       类型      容量  已用  可用 已用% 挂载点
udev           devtmpfs   17G     0   17G    0% /dev
tmpfs          tmpfs     3.4G  8.6M  3.4G    1% /run
/dev/nvme0n1p2 ext4      491G   84G  385G   18% /
tmpfs          tmpfs      17G   87k   17G    1% /dev/shm
tmpfs          tmpfs     5.3M  4.1k  5.3M    1% /run/lock
tmpfs          tmpfs      17G  1.1M   17G    1% /tmp
/dev/nvme0n1p1 vfat      536M  156k  536M    1% /boot/efi
...

扩容完毕。

重新添加 swap

OMV 自动设置的 swap 大小是 1G，我根据 RHEL7 的文档，决定稍微增加 swap 大小（4GB）。

不准备再创建分区了，偷懒用 swap 文件进行替代（虽然 RHEL 更推荐分区）。

步骤如下：

➜ dd if=/dev/zero of=/swapfile bs=1G count=4     
记录了4+0 的读入
记录了4+0 的写出
4294967296字节（4.3 GB，4.0 GiB）已复制，2.25421 s，1.9 GB/s


➜ ls -alh /swapfile 
-rw-r--r-- 1 root users 4.0G  2月  3 14:09 /swapfile


➜ mkswap /swapfile
mkswap: /swapfile: insecure permissions 0644, 0600 suggested.
Setting up swapspace version 1, size = 4 GiB (4294963200 bytes)
no label, UUID=809ad6c4-90bf-4dcc-9e62-7f3655b05491


➜ chmod 0600 /swapfile


➜ vim /etc/fstab                            
# 添加以下行：
/swapfile          swap            swap    defaults        0 0

➜ systemctl daemon-reload


➜ swapon /swapfile


➜ cat /proc/swaps
Filename				Type		Size		Used		Priority
/swapfile                               file		4194300		0		-2


➜ free -h
               total        used        free      shared  buff/cache   available
内存：       31Gi       5.7Gi        15Gi        51Mi       9.8Gi        25Gi
交换：      4.0Gi          0B       4.0Gi

重启，随后使用这几个命令简单检查一下运行情况：

free -h
cat /proc/swaps
df -h
lsblk
fdisk /dev/nvme0n1

Ref.

使用 FFmpeg 将 ManicTime 的截图转成视频

2026-01-01T08:11:41+00:00

最近用上了 ManicTime，其截图占用空间实在是太大，所以准备归档一下。

写了个小脚本，功能非常简单，把 ManicTime 的截图通过 FFmpeg 转成视频。代码大致是这样子：

# -*- coding: UTF-8 -*-

import os
import subprocess
from glob import glob

if __name__ == '__main__':
    path = input("path: ")
    num = input("num per second: ")
    file_list = glob(path + "\\*.jpg")
    video_name = input("video name: ")
    encode_type = int(input("encode type (1 - nvidia, 2 - intel): "))
    with open(path + "\\input.txt", "w") as f:
        for i in file_list:
            file_name = i.split('\\')[-1]
            if file_name.__contains__("thumbnail"):
                continue
            f.write("file " + file_name + "\n")
            f.write("duration {}\n".format(1 / int(num)))
    command = '''ffmpeg -f concat -i {}\input.txt -c:v {} -r 25 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -loglevel error -y {}\{}.mp4'''.format(
        path, "h264_qsv" if 2 == encode_type else "h264_nvenc", path, video_name)
    print("executing command: " + command)
    code = subprocess.call(command, shell=True)
    print("subprocess exit code: {}".format(code))
    del_pic = int(input("delete pics? 1 or 0: "))
    if (del_pic):
        print("deleting...")
        for i in file_list:
            os.remove(i)
        print("delete finished")

图片转视频的 FFmpeg 调用大致是这样：

ffmpeg -f concat -i {{input.txt}} -c:v h264_qsv -r 25 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -loglevel error -y {{target}}

算是自己第一次的 FFmpeg 实践吧，这玩意真是个好东西🤣

自建 RSS 服务迁移至 Miniflux

2026-01-01T08:11:41+00:00

起因

TTRSS 的 web 页面在小屏移动设备根本不可用。 Reeder 对 TTRSS 的 Fever API 的支持同样烂，好半天同步不下来阅读列表。不过可以理解，毕竟 Reeder 早就把 Fever 标记成 Deprecated，给用户打过预防针了。

寻觅许久，终于找到了一款 iOS 上对 Fever 支持良好的阅读器，名叫 Unread。交互极佳，界面好看，不用付费就能使用大部分功能，十分良心。

关于 RSS 的事情本该在此告一段落了，但是我总感觉 TTRSS 太慢了——前端通常要花费数秒钟才能加载到可用程度。另外 Reeder 也始终让我心痒痒：我花钱买的软件就这么搁置了——不行，太浪费，必须找个理由用起来！

Reeder 另外支持的自建协议是 FreshRSS 和 Google Reader API，根据这两种协议找到了另外两款比较主流的能够自建的 RSS 服务：FreshRss 和 Miniflux。

FreshRSS 也是基于 PHP 开发的，提供 Fever 和 Google Reader API，界面比较简单。FreshRSS 可以使用 SQLite 作为数据库，对内存或者磁盘不足的机器十分友好。

Minuflux V1 由 PHP 开发（2013 - 2018），V2 使用 Golang 开发（2018 - ），提供 Fever 和 Google Reader API。

最终选用 Miniflux 的大体原因是因为：

Miniflux 的官网和介绍很有趣，能感受到作者对作品的自信、对“精简”这一理念的坚持
Miniflux V2 使用 Golang，比起 PHP 我更喜欢 Go
FreshRSS 用了一个叫 MinZ 的、连文档都没有的框架，我不喜欢

此外，Miniflux 还有许多吸引人的特性：

Golang 开发，性能和部署优势
内存占用比较低（我通过 Portainer 观察是 25MB - 50MB 左右，作为对比 TTRSS 大概是 100MB - 180MB）
提供 OpenAPI、Fever API、Google Reader API
精简、专注核心功能、无插件，JavaScript 使用很克制
（不需要插件的）全文拉取功能
服务端渲染~~不算优势吧~~
界面简洁，PWA 支持，小屏移动端体验良好
快捷键支持
提供许多 Read It Later 服务的接入功能
开发理念很棒，代码质量把控严格

部署

docker-compose.yml:

version: '3.4'
services:
  miniflux:
    image: miniflux/miniflux:latest
    container_name: miniflux_rss_server
    restart: always
    ports:
      - "183:8080"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgres://miniflux:password@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=password
      - BASE_URL=https://rss2.bolitao.xyz
      - CLEANUP_ARCHIVE_UNREAD_DAYS=-1
      - CLEANUP_ARCHIVE_READ_DAYS=200
      - POLLING_FREQUENCY=20
    healthcheck:
      test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]
  db:
    image: postgres:15
    container_name: miniflux_db_postgres
    environment:
      - POSTGRES_USER=miniflux
      - POSTGRES_PASSWORD=password
    volumes:
      - miniflux-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "miniflux"]
      interval: 10s
      start_period: 30s
volumes:
  miniflux-db:

之后使用 docker-compose up -d 命令运行，打开 <ip>:<port> 即可访问页面：

添加自定义 CSS，把链接中（github/fengkx/miniflux-theme-pure/master/dist/style.css）的内容复制到 Miniflux 设置中“自定义 CSS”输入框即可。~~后来我觉得默认样式也不错又把自定义 CSS 去掉了。~~

完成基础部署后，导入从 TTRSS 导出的 OPML 文件，恢复订阅链接。导入之后有一个问题，就是阅读进度都被重置了，我的未读变成了恐怖的 10k+，不过问题不大，历史文章我几乎都已经阅读过了，所以只需要浏览完近几天更新的 RSS，然后直接把所有文章标记成已读就好。

域名

在域名管理界面配置 DNS。

接着配置 Nginx 反向代理：

vim /etc/nginx/sites-enabled/miniflux.conf

配置内容：

server {
  server_name rss2.bolitao.xyz;

  client_max_body_size        128M;

  location / {
    proxy_pass http://127.0.0.1:183;
    proxy_set_header    Host                $http_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-Ssl     on;
    proxy_set_header  X-Forwarded-Proto   $scheme;
    proxy_set_header  X-Frame-Options     SAMEORIGIN;
    
    client_max_body_size        128M;
    client_body_buffer_size     128k;

    proxy_buffer_size           4k;
    proxy_buffers               4 32k;
    proxy_busy_buffers_size     64k;
    proxy_temp_file_write_size  64k;
  }
}

检查配置：

nginx -t
# output:
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reload nginx：

nginx -s reload

启动 certbot：

certbot
# output:
Saving debug log to /var/log/letsencrypt/letsencrypt.log

Which names would you like to activate HTTPS for?
We recommend selecting either all domains, or all domains in a VirtualHost/server block.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: docker.bolitao.xyz
2: pw.bolitao.xyz
3: rss.bolitao.xyz
4: rss2.bolitao.xyz
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel): 4

然后就可以通过域名访问网站了：

在此之后，可以在 Cloudflare 的 DNS 配置中，把代理打开：

备份方案

Miniflux 本身不在机器产生什么数据，只需要备份数据库就好。所以参考原来的 TTRSS 备份脚本，简单改改就能用了。

vim /root/scripts/miniflux_backup.sh

脚本内容：

#!/bin/bash

SCRIPT_DIR="/root"
NOW=$(date +"%Y%m%d")
TMP_PATH='/tmp'
DOCKER_NAME='miniflux_db_postgres'
MINIFLUX_DB="$TMP_PATH/miniflux_db.sql"
BAK_FILE_NAME="miniflux_db-$NOW.tar.gz"
BAK_FILE="$TMP_PATH/$BAK_FILE_NAME"
DROPBOX_DIR="/root/dropbox"

docker exec "$DOCKER_NAME" pg_dumpall -c -U miniflux > "$MINIFLUX_DB"
echo "数据库 SQL 导出完毕，正在打包压缩..."
tar cfzP "$BAK_FILE" "$MINIFLUX_DB"
echo "打包完成，准备上传..."
"$SCRIPT_DIR"/dropbox_uploader.sh upload "$BAK_FILE" "$DROPBOX_DIR/$BAK_FILE_NAME"
if [ $? -eq 0 ];then
     echo "上传完成"
else
     echo "上传失败"
fi
rm -f "$MINIFLUX_DB" "$BAK_FILE"

随后赋权，试运行一遍：

chmod +x /root/scripts/miniflux_backup.sh && bash /root/scripts/miniflux_backup.sh

输出：

数据库 SQL 导出完毕，正在打包压缩...
打包完成，准备上传...
 > Uploading "/tmp/miniflux_db-20230111.tar.gz" to "/root/dropbox/miniflux_db-20230111.tar.gz"... DONE
上传完成

然后配置定时任务：

crontab -e

打开的编辑器中添加以下行：

0 3 * * 0 /bin/bash /root/scripts/miniflux_backup.sh > /dev/null

完毕。

TTRSS 星标数据处理

把数据迁得差不多之后，为了节省一些 VPS 的资源，我准备关闭原来的 TTRSS 实例、进行一些清理工作。但我发现待办中还有最后一项让我头疼的事，那就是我的 TTRSS 有许多收藏的文章，我得想办法把它们导出。

我首先想到的是把这些东西导出到 Miniflux，但是有点困难，退而求其次准备把他们导出到 wallabag。

插件方式

首先，需要在 TTRSS 部署 ttrss-to-wallabag-v2 插件。我使用的是 Awesome TTRSS 的镜像，默认已经自带 ttrss-to-wallabag-v2 插件，只需要将其开启即可。

编辑 TTRSS 的 docker-compose.yml 文件，修改环境变量，在 ENABLE_PLUGINS 后添加 wallabag_v2：

添加完成后重启 TTRSS。

之后去到 wallabag 页面，右上角点击头像 - API 客户端管理，创建一个新的客户端：

将该值填入 TTRSS 的设置 - Wallbag V2 设置：

然后就可以在 TTRSS 通过快捷键 a w，把文章加入 wallabag 了。

但是我有数百篇 Star，一篇篇添加太费劲。我想过用 TTRSS 的 Filter 功能把星标文章导出到 wallabag，但是 Filter 没有针对 Star 文章或 labels 进行操作的功能。于是，这个方案被我废弃掉。

通过 API 自行导出

我看了下 TTRSS Fever API 和 wallabag API 的文档，发现其调用不算困难，于是在 ttrss-to-wallabag-v2 这个插件的提示下，准备自己写一个小玩具进行导出。

开发过程中使用 Unirest 库调用 Wallabag 的 /api/entries.json API 时一直出现 HTTP 500，Wallabag 的文档和日志太烂，根本没地方查错，差点想放弃。最后干脆摆烂拷贝 Apifox 生成的调用示例代码竟然调通了...原来是 Header 需要多加个 Content-Type: application/json。

玩具的功能很简单，调用 Fever API，获取 TTRSS 加星标的文章，然后通过 wallabag 的 API 导入，没有日志，没有异常保护，没有多线程。我自己跑 716 篇文章迁移耗时大概十五分钟，检查后没有出现数据丢失。~~如果真丢了，也定位不到哪篇丢了，因为我没加日志框架。~~

代码在这里，需要 JDK 8：

bolitao/ttrss-starred-to-wallabag: Tiny-Tiny-RSS starred articles to wallabag

体验

完爆 TTRSS，Miniflux 的全文拉取很好用，页面体验非常舒适，还支持 PWA！

有一个小瑕疵——iOS 字体显示有问题，我在 Miniflux 设置的字体是 Serif，但是 PWA 应用依旧是显示非衬线字体。猜测是 iOS 的通病，因为即使我用 Reeder 阅读器设置衬线字体，也依旧会使用系统默认的非衬线字体显示中文。

最后，诚心推荐 RSSHub 及 RSSHub Radar，RSSHub 可以将许多网站内容转为 RSS 订阅链接，Radar 可以检查网站的可订阅内容、一键订阅内容到 TTRSS / Miniflux。我主要用它订阅一些视频和社交博主的更新~~以及订阅一些瑟瑟内容~~。服务可以免费部署在 Vercel 上，记得在环境变量设置一下访问密钥以避免 Vercel 用量超量。

Ref.

2022：未来不会更好

2026-01-01T08:11:41+00:00

只会更烂。

效率

今年失去了自驱力，完全没有学习，工作也是领导催了我才会推进。

GitHub 提交：

工作方面好多做过的事情记不清了，只记得被支付宝停车助手的对接工作折磨了数个月；用 RocketMQ 重构了公司原本基于 Socket 的通信业务；负责重构项目中同步模块的设计和实现；负责重构项目中停车业务的计费器实现。

工作 GitLab 提交：

今年由 RescueTime 记录的时间依旧难看，娱乐时间占了大半，LOL 说实话很不好玩、很无聊、匹配机制非常烂，活动策划也非常恶心，但依旧成了今年最耗费我时间的游戏。另外我在下半年又玩了数月的碧蓝航线，浪费了很多时间和钱，在十一月份感受到这游戏的虚无和策划的无耻后，我以非常轻松的心态删除了这款游戏，希望未来自己不要再入坑手游。

RescueTime Category:

RescueTime 所记录的今年超过十小时的活动:

消费

iPhone 14

原来的 iPhone 电池不行了，我在年中购入一台 GT Neo3 作为主力机，但国产 OS 的表现实在令人失望：4000+ 毫安电池要一天两充；除了微信 QQ 的通知，其他软件通知随缘；后台控制低能——关掉拼多多自启还能弹假通知广告、开启带有 FCM 软件的自启也经常被误杀导致收不到通知；相机纸面参数够带劲，实拍效果一片糊。

最后忍无可忍，iPhone 14 面市后首发购买，除了高刷其他还算满意，没上 Pro 是因为我太贫穷了，为了高刷这一特性加价数千元感觉很划不来。

自建 NAS

i5 10400 + 32G 内存，系统是 OMV。体验还不错，媒体库、转码、照片库、追番等功能切实为我带来了便利。

12600KF

主力机的 CPU 换成了 12600KF。一开始的主板是铭瑄的 Z690，用的不爽遂换成了 B660 迫击炮，终于不用降压使用 CPU 了。目前把内存升级到了 64G，平时体验良好，但因为大小核关系，虚拟机性能表现一泡污。

大小核这玩意我实际用下来只感觉跑分好看，不知道猴年马月能看到虚拟机发挥出大小核 100% 性能。

吉他

618 活动时购买的，买来根本就没怎么练过，很失败的一次购物。

机械革命无界 16

原来工作用的 AMD 笔记本太热了，而且 16G 应付日常开发有点捉襟见肘，公司发的 MBP 又太老，所以自己买了台无界 16。32G 内存 + i7 12700H + Windows 11 体验还不错。

臻享视界 165Hz 2K 显示器

1300 元拿下的，K7E 面板，性价比挺高，但是有一个坏点，略有遗憾。

红米 AX6S

为了更快的 VR 无线串流换的，比之前那个提升挺多。中途折腾坏过一个，表现为没有 5GHz 信号，京东售后很快换新了一个。新的这个没再折腾安装 Clash 或者 Openwrt 了，默认固件也够用。

Jetbrains IntelliJ IDEA

Jetbrains 订阅的第二年，我把全家庭转成了 IDEA 单独订阅。因为我发现自己对全家桶利用率不高，并且自己常用的 Datagrip 功能 IDEA 直接就有集成，前端、Go、Python 也可以通过 IDEA 安装官方插件实现。

游戏

有剧透。

艾尔登法环

菈妮的支线太浪漫了。火焰巨人后的地图和 BOSS 连战太过瘾了。10 / 10，我的年度游戏。

异度神剑 3

今年最期待的游戏。结果主线乏力、支线弱智，乐子人反派的塑造更是失败，完全不如预期。本来想给八分，但是五章结尾有极其失败的交互设计，容易让人跳过一大段爆点剧情，再扣一分最终 7 / 10。希望能有类似于黄金国般高质量的 DLC 拯救这款游戏。

荒野大镖客：救赎 2

玩落泪，操作太拖沓扣一分，9 / 10。

AI：梦境档案涅槃计划

揭秘关键诡计的时候看的我一头雾水，龙木线 jump scare 扣大分，7 / 10。

十三機兵防衛圏

玩法一般，好看，很青春，8 / 10。

TLOU2

编剧是神经病，而恰好我也是神经病，我很喜欢这种矛盾又无力的剧情，就跟我的大便人生一样。当然过于激烈的剧情编排让系列粉丝无法接受也是事实，8 / 10。

死亡搁浅岛剪版

虽然大伙都赞不绝口，但说实话这个玩法把我折腾得够难受，结局沙滩奔跑玩得我也很焦躁，8 / 10。

死亡循环

跟着引导走莫名其妙就通关了，本以为会做成掠食那样充满药劲，但说实话还是少了点味儿，略带遗憾之作 8 / 10。

战神：诸神黄昏

整篇感觉就是为了父子情这碟醋包的诸神黄昏这顿饺子。游戏正篇父子情和父子的成长还是好好体现了的，结尾处奎托斯看到神龛预示自己成为受人敬仰的神而猛男落泪时，也是让人感慨，战神的新篇章也就此告一段落了。但是因为原定三部但是要合成两部导致的工期和经费紧张在游戏后期也随处有体现，尤其在矮人死后剧情质量直线下跌；中期铁森林那段突然的插入太让人烦躁；与北欧众神之战也完全没有大开大合的快感或者极致的演出，海姆达尔——小丑，索尔——分不清敌我、逃避现实的酒鬼，奥丁——神神叨叨的臭老头，难怪有人恶搞该作标题为《战神 5：村口械斗》；后期节奏太赶、格局太小，8 / 10。

神秘海域：盗贼传奇合辑

神秘海域盗贼末路和失落的遗产两作合集，比较不错的爆米花 3A，8 / 10。

音乐

又重新听起了国语，万青永不过时。

剧集

孤独摇滚！

挺有趣。

Cyberpunk: Edgerunners

挺绝望。

相合之物

挺温馨。

异世界舅舅

挺乐。

我

今年最让我受挫的事物是“我自己”，自从年初的乙流感康复后，我的状态变得极差，今年的自己完全失去了自制力，无法控制自己的消费冲动、食欲，甚至性欲。十二月底阳后，我还出现了类似于 19 年底时极度焦虑下的阅读和思考障碍，我不知道这是不是脑雾症状。另外，从阳性康复后我变得容易疲惫，从不在工位睡觉的我竟然首次在工位上打起了瞌睡。身体总体状况变得极糟糕，虽然戒掉了糖分依赖，但依旧把无糖可口当作代餐，导致我的口腔健康状况非常差；长期不运动和暴食也导致了我体能和肌肉的退化；熬夜和焦虑让我的发量越发稀少。

今年在自我提升方面本来是这么打算的：精进计算机技能、学习外语、练习乐器、锻炼厨艺。遗憾一条都没完成，每天下班我都感到十分疲惫，每次都是无所事事发呆或者跟朋友开黑打游戏。

工作方面，我原以为会继续担任重构负责人，结果在我完全不知情的情况下，负责人被换成了另一位资历更老的人，这让我感到气愤和气馁。当然，能者多劳、谁拿钱多谁干活，我现在已经不为这事感到失落了。而且我的管理确实不到位，太“软”了，没法有效推进进度和安排加班。虽然我不再感到失落，但在我不知情情况下换负责人已成为我在这家公司工作的一个芥蒂，如果未来离职，这一定是最核心的原因。

我开始焦虑，焦虑自己没钱，焦虑自己的原生家庭，焦虑婚姻，焦虑自己技不如人，焦虑工作流和效率工具。各种开发工具、操作系统、效率工具换了又换，越换越焦虑。

我不确定是否要去上海或者其他一线城市，如果不想加班、不去大厂，上海的薪资并不如想象中的有吸引力。我不想刷八股刷算法，我只想遇到问题的时候查查文档、搜搜谷歌，我想当混子，想就这么不上不下地挂在这里。换工作好麻烦，而且以我目前的状态，我感觉自己很容易辞职即失业。

对薇的愧疚减轻很多。虽然我经常幻想如果我在大二换一种对待她的态度，我们的未来会不会重新交织，我们会不会重归于好。但这只是幻想，我只能如此后悔甚至愧疚一辈子。听闻她感情顺利准备结婚，我只能祝福她一切都好。以前的感情的破事该放一放了。

认识到了一个新词叫“回避型依恋人格”，我好像有点符合。今年与 Q 重新联系上，关系迅速拉近感情也变得暧昧，可我突然开始厌恶一切、开始失踪不理人，我又开始封闭自己、开始自我保护。我很容易愧疚，我害怕再次伤害她、也害怕再次伤害自己。我感觉自己很可耻，但是就这样吧，暂时就先这样独身吧。我跟 Q 性格过于相似，都过于阴沉，也许注定就不合适。未来怎么办？未来再说吧，我头痛欲裂，我不想仔细思考。

我想在家乡的小县城平平淡淡地生活、死去，但以我的性格肯定无法接受这么平淡的生活。我想在长沙普普通通当一名上班族，普普通通买房结婚生子死去，但我无法忍受原生家庭带给我的焦虑、思索、痛苦，我的家庭注定了我的不开心。如果润出去呢？润去哪？有无润的本事？以及原生家庭怎么办、父母怎么办？我好痛苦。

针对疫情的突然开放让大家都有点手足无措，新的一年希望熟人们都健健康康。至于我在新一年的目标，应该是不要猝死。

这个世界在向着无法挽回的社达和法西斯方向奔去。2022 很糟，未来不会更好。

AI 梦境档案 2 通关

2026-01-01T08:11:41+00:00

《AI梦境档案2》通关了。

可能因为当社畜了，与学生时代时玩一代的心境完全不同，整个过程急躁的很，连推理剧情都没怎么思考就草率通关了，另加上被人剧透了一部分关键诡计，所以整体体验很一般。

但是她真可爱🥰。

接下来的八天就苦等 XB3 的发售了。好急好急。

从 0 到 1 的 NAS 记录

2026-01-01T08:11:41+00:00

新组的 NAS 已经运行三个月了，记录一下捣鼓这玩意的笔记和碎碎念，文章结构比较乱，算是给自己看的备忘。

前任

刚工作时我就产生了添置一台 NAS 的想法，但是当时并不打算常在那家公司干下去、而且住的是公司通过某种奇怪方式租的公租房（两人住一起空间不足），想法没有实现。

在去年四月换了份工作以及搬家后，捣鼓一套 NAS 的冲突愈演愈烈，最终在淘宝买了一套整机：一个四盘位的星际蜗牛，有着 J1900 CPU 和 4G RAM 的强悍配置，店家还帮预装了黑群晖（到手后自己装了 Windows）。

与其度过的开始几个月十分开心满意，因为这套配置差不多满足我的需求：

存视频（SMB）
存游戏（SMB）
存书籍、漫画（SMB）
日常文件备份（SMB）
四盘位 RAID，总可用容量能有 8T 就好

后来看大家分享的 NAS 的强大功能，自己心里也越来越痒痒：我也想捣鼓虚拟机、想用 Docker、想拥有一票好看的媒体海报墙、也想身处家外也能够连回家看视频...

之前那套 NAS 虽然能用，但是各处细节都说不上好用，几乎所有功能都是基于 SMB 实现，啥操作都得用个文件管理器来捣鼓、看个视频都得点开层层目录。性能也不太行，作为游戏下载盘 Steam 经常会卡死。

本来吧，是打算这么将就着用的，但因为我消费主义入脑，着了 Intel 12 代 CPU 的魔...

第二台 NAS

在今年春节后，我受不住诱惑，把主力机的 CPU 换成了 12600KF，于是就有了一颗闲置的 i5 10400。

硬件

当时家里还有一个吃灰的【航嘉暗夜猎手5】垃圾机箱和先马电源，加上这块 CPU，我组了个 mATX 的 NAS。后来自己加装了一块 4T 硬盘、和曾导通过一顿饭成功 PY 到一个【安钛克 GX900】机箱。目前配置大概是这样子：

配件	型号
CPU	Intel i5 10400
散热器	玄冰 400
显卡	N/A
内存	主力机拆下来的 DDR4 2666 16G * 2
电源	先马金牌 500W
主板	微星 B460M 迫击炮 WiFi 版
机箱	安钛克 GX900
系统盘	金士顿 250G
数据盘 1	WD 1T
数据盘 2	WD 3T
数据盘 3	DW 4T

系统选择

机器装好后自然是装系统，NAS 可选系统真的很多，而且各自都很有特色。当时装系统到处看了很久，以下是我针对我个人需求的一些调研结果：

Windows：原来的 J1900 小鸡就是跑的 Windows 10 LTSC，不过因为性能关系，只开了一个 BitComet 和 SMB 服务。说实话 Windows 用作 NAS 系统没啥大问题，有很多丰富的软件和快捷的驱动支持，比如原生的 OneDrive、Office 套件、115、百度网盘，不需要额外操心的硬件解码等，没事甚至还能通过远程桌面连过来写代码（目前这台 NAS 的配置其实比我工作用的笔电要好）。除开一些独占原生软件的优势，像 Jellyfin、qBittorrent 等软件也有跨平台支持，还能用 Docker 弥补 Linux 独有软件的缺陷。最终没选择的原因是那个狗屎一般的 Hyper-V，不论是跑 Docker 还是 WSL2 都必须开 Hyper-V，隔着 Hyper-V 用 Docker 经常让我有种隔靴搔痒的感受，pass
unRAID：真实满足 NAS 各种需求的系统，但要购买授权，需要缓存盘，pass
Ubuntu：我最熟悉的 Linux 发行版，但作为 NAS 系统什么都要从零捣鼓，太费劲，pass
TrueNAS：官方建议使用 ECC 内存、Core 版本残疾 Docker，pass
ESXi：我没有那么多的虚拟化需求。而且虽然我没有版权洁癖，但这玩意其实是要许可证的，而我又买不起。考虑到破解可能带来的不稳定性和学习成本，pass。当然以后可能会以学习用途装一个玩玩
PVE：又是一个主打虚拟化的系统，我没那么多的这种类型的需求，所以 pass
群晖：富佬专用，作为一款商业产品捆绑搭载的系统，我不想用没有官方支持的盗版，pass
OpenMediaVault：其实我对 OMV 印象就是一加了一套 OMV web 管理软件的 Ubuntu。当然这玩意基于 Debian，还有一些开箱即用的插件，比如 KVM、ZFS、Docker 等，用起来意外的顺手。最终选用 OMV 也是习惯使然，deb 系实在太亲切了

~~其实嘛，对我来说除了存储管理策略和包管理器外各系统用起来也没什么大差别，毕竟到最后都是跑 Docker。~~

装 OMV5 的时候有一些小插曲，OMV5 没有 b460m 迫击炮的 8125B 网卡驱动，查了下方案有以下：

没网卡驱动的情况下硬装 OMV，进系统后想办法把驱动装上
安装 Debian、安装驱动，然后安装 OMV 相关软件包

不论哪种都很复杂和畸形啊，看了下网上说 OMV6 内核比较新，直接支持这个网卡，遂上官网下载 testing (即 OMV6) 版本，一路顺利安装。

截至目前（2022 年 5 月 17 日），OMV6 已推出正式版。

OMV 系统装好后，进行一些配置：

omv extras

wget -O - https://github.com/OpenMediaVault-Plugin-Developers/packages/raw/master/install | bash

修改 ssh 端口
日期：面板设置
- 时区：Asia/Shanghai
- 允许 ntp，设置服务器为阿里云 ntp ntp1.aliyun.com
在 OMV 面板设置 S.M.A.R.T
在 OVM 面板设置邮件提醒
在 OMV 面板挂载磁盘
在 OMV 面板设置 SMB 服务
去插件面板安装 KVM、fail2ban、ZFS、Docker 等需要的插件

软件

V2rayA

安装：

curl -Ls https://mirrors.v2raya.org/go.sh | sudo bash
sudo systemctl disable v2ray --now
wget -qO - https://apt.v2raya.mzz.pub/key/public-key.asc | sudo tee /etc/apt/trusted.gpg.d/v2raya.asc
echo "deb https://apt.v2raya.mzz.pub/ v2raya main" | sudo tee /etc/apt/sources.list.d/v2raya.list
sudo apt update
sudo apt install v2raya
sudo systemctl start v2raya.service
sudo systemctl enable v2raya.service
# 打开 ip:2017，进行节点配置

这款软件好像是默认开启系统代理的，开启后常用的一些命令行工具都会使用系统代理：

curl ipinfo.io

# output:
{
  "ip": "",
  "hostname": "",
  "city": "Hong Kong",
  "region": "Central and Western",
  "country": "HK",
  "loc": "",
  "org": "
  "timezone": "Asia/Hong_Kong",
  "readme": "https://ipinfo.io/missingauth"
}

proxychains

使用 V2rayA 提供的系统代理一般就够用了，不过还是可以装一个 proxychains 备用。

# 安装：
apt install proxychains4

# 配置：
vim /etc/proxychains4.conf

# 添加以下行
socks5  127.0.0.1 10808

命令行代理

vim ~/.bashrc

添加以下行：

#proxy
LANTERN=127.0.0.1:8787
COW='127.0.0.1:7777'
LO='127.0.0.1:10809'
defp=$LO

# No Proxy
function noproxy
{
    unset http_proxy HTTP_PROXY https_proxy HTTPS_PROXY all_proxy ALL_PROXY ftp_proxy FTP_PROXY dns_proxy DNS_PROXY JAVA_OPTS GRADLE_OPTS MAVEN_OPTS
    echo "clear proxy done"
}


function setproxy
{
        if [ $# -eq 0 ]
        then
                inArg=$defp
        else
                inArg=$1
        fi
        HOST=$(echo $inArg |cut -d: -f1)
        PORT=$(echo $inArg |cut -d: -f2)
        http_proxy=http://$HOST:$PORT
        HTTP_PROXY=$http_proxy
        all_proxy=$http_proxy
        ALL_PROXY=$http_proxy
        ftp_proxy=$http_proxy
        FTP_PROXY=$http_proxy
        dns_proxy=$http_proxy
        DNS_PROXY=$http_proxy
        https_proxy=$http_proxy
        HTTPS_PROXY=$https_proxy
        JAVA_OPTS="-Dhttp.proxyHost=$HOST -Dhttp.proxyPort=$PORT -Dhttps.proxyHost=$HOST -Dhttps.proxyPort=$PORT"
        GRADLE_OPTS="-Dgradle.user.home=$HOME/.gradle"
        MAVEN_OPTS=$JAVA_OPTS
        no_proxy=".cn,.aliyun.com,localhost,127.0.0.1,localaddress,.huaweicloud.com,.localdomain.com,.coding.net,.ruby-china.org"
        echo "current proxy is ${http_proxy}" >> /dev/stderr
        export no_proxy http_proxy HTTP_PROXY https_proxy HTTPS_PROXY all_proxy ALL_PROXY ftp_proxy FTP_PROXY dns_proxy DNS_PROXY JAVA_OPTS GRADLE_OPTS MAVEN_OPTS
}

Docker

为 Docker 启用代理（可选）：

sudo mkdir -p /etc/systemd/system/docker.service.d
sudo vim /etc/systemd/system/docker.service.d/http-proxy.conf

编辑内容：

[Service]
Environment="HTTP_PROXY=http://192.168.79.1:10809"
Environment="HTTPS_PROXY=http://192.168.79.1:10809"
Environment="NO_PROXY=localhost,127.0.0.1,docker-registry.example.com,.corp"

重启：

sudo systemctl daemon-reload
sudo systemctl restart docker

检查代理设置：

sudo systemctl show --property=Environment docker

Pointer

我自认为最好用的 Docker UI 工具，可以在 OMV 面板通过 Extras 安装。

yacht

又一个 Docker UI 工具，前端基于 Vue 开发，如果你喜欢也可以在 OMV 面板通过 Extras 安装。

cockpit

一个系统管理面板，通过 apt 安装。我主要用来管理虚拟机，比 OMV 自带的那个 KVM 面板好用一点。

允许 http 访问

vim /etc/cockpit/cockpit.conf

添加以下内容：

[WebService]
AllowUnencrypted=true

重启：

systemctl restart cockpit

qbittorrent

作为服务运行

PPA: https://software.opensuse.org//download.html?project=home%3Anikoneko%3Atest&package=qbittorrent-enhanced

sudo vim /etc/systemd/system/qbittorrent-nox.service

# content:
[Unit]
Description=qBittorrent nox
After=network.target

[Service]
Type=forking
ExecStart=/usr/bin/qbittorrent-nox -d --webui-port=6777
Restart=always

[Install]
WantedBy=multi-user.target

# restart:
systemctl daemon-reload
systemctl enable qbittorrent-nox.service
systemctl start qbittorrent-nox.service
systemctl status qbittorrent-nox.service

或者使用 docker 运行

version: "2.1"
services:
  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent
    container_name: qbittorrent
    environment:
      - PUID=998
      - PGID=100
      - TZ=Asia/Shanghai
      - WEBUI_PORT=6777
    volumes:
      - /apps/qb:/config
      - /path/to/downloads:/downloads
    ports:
      - 6881:6881
      - 6881:6881/udp
      - 6777:6777
    restart: unless-stopped

web ui
- 设置用户名密码
- 设置 ip 白名单（如果有需要）
rss
- 设置里开启 rss 功能
- 添加蜜柑 project 的 RSS 订阅链接到 qbittorrent 中
- 设置里开启 rss 自动下载并添加自动下载规则，将规则应用到蜜柑 project 订阅

FRP

强烈推荐腾讯云搞活动的那个 2C 4G 8M 三年的轻量云服务器，用来跑 FRPS 很合适。

安装

# download:
wget https://github.com/fatedier/frp/releases/download/v0.39.1/frp_0.39.1_linux_amd64.tar.gz
tar xzvf frp_0.39.1_linux_amd64.tar.gz

# config:
vim frpc.ini

[common]
server_addr = xxx
server_port = xxx
admin_addr = 127.0.0.1
admin_port = 7400
admin_user = admin
admin_pwd = admin
token = xxx
protocol = tcp

[rdp]
type = tcp
local_ip = 127.0.0.1
local_port = 2323
remote_port = 7788
sk=xxx

# systemd:
vim systemd/frpc.service

# content:
[Unit]
Description=Frp Client Service
After=network.target

[Service]
Type=simple
User=nobody
Restart=on-failure
RestartSec=5s
ExecStart=/apps/frp/frpc -c /apps/frp/frpc.ini
ExecReload=/apps/frp/frpc reload -c /apps/frp/frpc.ini
LimitNOFILE=1048576

[Install]
WantedBy=multi-user.target

# restart
cp systemd/frpc.service /etc/systemd/system/
systemctl daemon-reload
systemctl enable frpc
systemctl start frpc
systemctl status frpc

转发 web
转发 ssh
转发其他各种服务 emby, netdata, nextcloud, etc.

Jellyfin

不熟悉 Plex 和 Emby 的人可以从 Jellyfin 入手，这个开源免费，界面和操作都跟 Emby 很像，经过数年迭代，解码已经很好用了，刮削器没试过不做评价。

deb 包管理器安装：

sudo apt install apt-transport-https
wget -O - https://repo.jellyfin.org/jellyfin_team.gpg.key | sudo apt-key add -
echo "deb [arch=$( dpkg --print-architecture )] https://repo.jellyfin.org/$( awk -F'=' '/^ID=/{ print $NF }' /etc/os-release ) $( awk -F'=' '/^VERSION_CODENAME=/{ print $NF }' /etc/os-release ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
sudo apt update
sudo apt install jellyfin
systemctl enable jellyfin

docker 方式

https://docs.linuxserver.io/images/docker-jellyfin

version: "2.1"
services:
  jellyfin:
    image: lscr.io/linuxserver/jellyfin
    container_name: jellyfin
    devices:
      - /dev/dri:/dev/dri
    environment:
      - PUID=998
      - PGID=100
      - TZ=Asia/Shanghai
    volumes:
      - /apps/jellyfin/confs:/config
      - /srv:/data/tvshows
      - /srv:/data/movies
    ports:
      - 8096:8096
      - 8920:8920
      - 7359:7359/udp
      - 1900:1900/udp
    restart: unless-stopped

Emby

https://emby.media/linux-server.html

Emby 在 Linux 的安装比较简单，根据文档一把梭就好，硬件加速配置也比较方便。附上我的 docker-compose 配置：

version: "2.3"
services:
  emby:
    image: emby/embyserver
    container_name: embyserver
    environment:
      - UID=998
      - GID=44
      - GIDLIST=107
    volumes:
      - ./data:/config
      - /srv:/mnt/share1
    ports:
      - 8096:8096
    devices:
      - /dev/dri:/dev/dri
    restart: unless-stopped

市面上几项主流播放器和影音库我都稍微用过，对他们的看法和最终选用 Emby 的原因有以下：

Emby: 是我现在使用的方案。Emby 各平台客户端体验都还不错，在 Jellyfin 还很拉胯的那段时间没得其他好选择，就这么用习惯了。加上自己前阵子消费主义入脑跟人一起买了 Premium，于是就被捆在这里了。另说一句很多人都说这玩意的刮削拉胯，我感觉其实还好，使用 TMDB 刮削器、遵守官方推荐命名，准确度还是非常高的。~~其实我更喜欢用 TMM，重命名功能太好用了。~~

但是我并不向所有人推荐 Emby：刮削和 Plex 比差上不少，转码也被 Jellyfin 追上。建议要不就用免费的，要不就加钱上 Plex，最好不要捣鼓 Emby 这种目前显得有点尴尬的玩意。
Jellyfin: 转码日趋完善，现在已经变得非常成熟稳定，刮削能力和 Emby 类似。如果不想为这类软件付费，Jellyfin 是我认为唯一的选择。如果觉得其客户端不好用，可以搭配 Kodi 或者 Infuse。
Plex: 我唯一推荐付费的媒体软件，刮削能力非常强。贵不是它的缺点，是我的缺点。
Kodi: 和三大媒体库相比，其更适合作为播放器，比较适合配合电视或者 Jellyfin 使用。
Infuse: Apple 生态下的媒体管理工具和播放器，是我见过对 SMB 支持最好的播放器，年订阅价格也比较合理。但是这玩意不支持调用 Emby 字幕插件，而且 Emby 的客户端也不算难用，最终还是放弃了。但这软件真的美观易用，不管你最终决不决定用，我都推荐你下载来试试。

bookstack

一个 wiki/文档管理系统。

~~笔记文档类工具实在太多了，搭上去我就没用过，尴尬。~~

version: "2"
services:
  bookstack:
    image: lscr.io/linuxserver/bookstack
    container_name: bookstack
    environment:
      - PUID=1000
      - PGID=100
      - APP_URL=http://
      - DB_HOST=172.17.0.1:3306 # docker0 地址
      - DB_USER=bolitao
      - DB_PASS=
      - DB_DATABASE=bookstackapp
    volumes:
      - ./:/config
    ports:
      - 6875:80
    restart: unless-stopped

qiandao

一个自动签到的 Docker 服务。

~~虽然它一直在占内存但我一致没用。~~

DNF server

https://github.com/1995chen/dnf

DNF 私服服务器，当初折腾这玩意花了起码两个晚上，结果因为我过于开放 GM 权限，导致游戏寿命只有两周不到（开了本地 GM 后所有史诗代码都能查到，都在网关给自己发东西 hhhh）。

RabbitMQ

自己开发需要用到：

services:
    rabbitmq:
        image: rabbitmq:latest
        volumes:
            - /data/rabbitmq/etc/:/etc/rabbitmq/
            - /data/rabbitmq/data/:/var/lib/rabbitmq/
            - /data/rabbitmq/logs/:/var/log/rabbitmq/
        environment:
            RABBITMQ_ERLANG_COOKIE: "SWQOKODSQALRPCLNMEQG"
            RABBITMQ_DEFAULT_USER: "bolitao"
            RABBITMQ_DEFAULT_PASS: ""
            RABBITMQ_DEFAULT_VHOST: "/"
        ports:
            - 5672:5672
            - 15672:15672
        restart: always

RCON

用来管理 Minecraft server。

version: "3"

services:
  rcon:
    image: itzg/rcon  # 服务器远程管理面板，具体使用自行百度
    container_name: "RCON"
    ports: #这两个端口都需要防火墙放行
      - "3999:4326" # Web UI
      - "4327:4327" # Connection from Web UI
    volumes:
      - "rcon:/opt/rcon-web-admin/db"
      - /etc/timezone:/etc/timezone:ro
    environment:
      RWA_ENV: "TRUE"
      RWA_ADMIN: "TRUE"
      RWA_PASSWORD: ""
      RWA_RCON_HOST: "172.17.0.1" # 填写 docker0 地址
      RWA_RCON_PASSWORD: "" # RCON server to control
      RWA_RCON_PORT: 25563
    restart: unless-stopped

volumes:
  rcon:

Minecraft

跑的 1.12.2 SpongeForge 版本。装了这么些玩意：

ll
# output:
-rw-r--r--  1 root root    2  4月 19 13:39 banned-ips.json
-rw-r--r--  1 root root    2  4月 19 13:39 banned-players.json
drwxr-xr-x  4 root root 4.0K  4月 12 23:48 config
drwxr-xr-x  2 root root 4.0K  4月 30 11:13 crash-reports
-rw-r--r--  1 root root  180  4月 12 16:48 eula.txt
-rw-r--r--  1 root root 4.3M  4月 12 16:46 forge.jar
drwxr-xr-x  3 root root 4.0K  4月 12 23:48 journeymap
drwxr-xr-x  7 root root 4.0K  4月 12 16:46 libraries
drwxr-xr-x  2 root root 4.0K  4月 30 11:13 logs
-rw-r--r--  1 root root  29M  4月 12 16:46 minecraft_server.1.12.2.jar
drwxr-xr-x  2 root root 4.0K  4月 13 00:01 mods
-rw-r--r--  1 root root  135  4月 19 13:39 ops.json
-rw-r--r--  1 root root  818  4月 19 13:39 server.properties
-rwxr-xr-x  1 root root 2.0K  4月 14 21:23 start.sh
-rw-r--r--  1 root root  106  4月 30 11:13 usercache.json
-rw-r--r--  1 root root   55  4月 12 18:35 usernamecache.json
-rw-r--r--  1 root root    2  4月 12 16:49 whitelist.json
drwxr-xr-x 10 root root 4.0K  4月 30 11:12 world

ll mods
# output:
总用量 67M
-rw-r--r-- 1 root root 1.6M  4月 12 23:37 animania-1.12.2-base-2.0.3.28.jar
-rw-r--r-- 1 root root 542K  4月 12 23:37 animania-1.12.2-catsdogs-1.0.0.28.jar
-rw-r--r-- 1 root root 1.9M  4月 12 23:37 animania-1.12.2-extra-1.0.2.28.jar
-rw-r--r-- 1 root root 5.3M  4月 12 23:37 animania-1.12.2-farm-1.0.2.28.jar
-rw-r--r-- 1 root root 106K  4月 12 23:37 AutoRegLib-1.3-32.jar
-rw-r--r-- 1 root root  89K  4月 12 23:47 CraftStudioAPI-universal-1.0.1.95-mc1.12-alpha.jar
-rw-r--r-- 1 root root  46K  4月 12 23:37 ftb-ultimine-1202.3.5.jar
-rw-r--r-- 1 root root 824K  4月 12 23:46 Mantle-1.12-1.3.3.55.jar
-rw-r--r-- 1 root root 1.1M  4月 12 23:37 natura-1.12.2-4.3.2.69.jar
-rw-r--r-- 1 root root 127K  4月 12 23:37 obfuscate-0.4.2-1.12.2.jar
-rw-r--r-- 1 root root 108K  4月 12 23:37 OpenGlider-1.12.1-1.1.0.jar
-rw-r--r-- 1 root root 3.7M  4月 12 23:37 Quark-r1.6-179.jar
-rw-r--r-- 1 root root  22M  1月  9 01:38 spongeforge-1.12.2-2838-7.4.7.jar
-rw-r--r-- 1 root root  28M  4月 12 23:37 twilightforest-1.12.2-3.11.1021-universal.jar
-rw-r--r-- 1 root root 2.1M  4月 12 23:37 vehicle-mod-0.44.1-1.12.2.jar

启动脚本：

#/usr/lib/jvm/zulu8/bin/java -Xms12G -Xms12G -XX:+UseG1GC -XX:+UnlockExperimentalVMOptions -XX:MaxGCPauseMillis=100 -XX:+DisableExplicitGC -XX:TargetSurvivorRatio=90 -XX:G1NewSizePercent=40 -XX:G1MaxNewSizePercent=60 -XX:G1MixedGCLiveThresholdPercent=35 -XX:+AlwaysPreTouch -XX:+ParallelRefProcEnabled -jar forge.jar
#/usr/lib/jvm/zulu8/bin/java -Xms2G -Xms8G -XX:+UseG1GC -XX:+UnlockExperimentalVMOptions -XX:MaxGCPauseMillis=100 -XX:+DisableExplicitGC -XX:TargetSurvivorRatio=90 -XX:G1NewSizePercent=50 -XX:G1MaxNewSizePercent=80 -XX:G1MixedGCLiveThresholdPercent=35 -XX:+AlwaysPreTouch -XX:+ParallelRefProcEnabled -Dusing.aikars.flags=mcflags.emc.gs -jar forge.jar

#/usr/lib/jvm/zulu8/bin/java -Xms8G -Xmx8G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar forge.jar

#/apps/jvm/oracle_server_jre8/bin/java -Xms8G -Xmx8G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar forge.jar

/apps/jvm/oracle_server_jre8/bin/java -Xms2G -Xmx6G -jar forge.jar

四年前我用着 1M 内网穿透、客户端服务端在同一台机器一起开着，顶着时不时掉线的风险跟曾哥联机，那时好像有大把的时间浪费，挖到第一枚矿石都欣喜若狂。

现在我能有足够的带宽和配置开设服务器，可成天忙于工作和闲时的焦虑，曾哥人也找不到了，人生还真是奇妙。

tinymediamanager

当我下载了一整季的番剧后，就会用 TMM 来刮削，因为很多番剧命名都非常奇葩（比如 11.5 集啦，各种 SP、OVA 啦），这种时候总要对着 TMDB 改目录结构和名字的，所以我一般都索性改完后再拿 TMM 进行一遍刮削和重命名，这样子效果就会好很多。

软件界面：

这是通过 TMM 重命名后的目录结构，不论是人去翻还是 Emby 去扫都非常便利：

➜  无职转生～到了异世界就拿出真本事～ (2021) ls
 fanart.jpg   poster.jpg   season02-poster.jpg  'Season 1'   Specials   theme.mp3   tvshow.nfo
 
 
 ➜  无职转生～到了异世界就拿出真本事～ (2021) ls Specials
'无职转生～到了异世界就拿出真本事～ - S00E01 - 番外篇：艾莉丝的哥布林讨伐.jpg'
'无职转生～到了异世界就拿出真本事～ - S00E01 - 番外篇：艾莉丝的哥布林讨伐.mp4'
'无职转生～到了异世界就拿出真本事～ - S00E01 - 番外篇：艾莉丝的哥布林讨伐.nfo'
 season-specials.jpg
 
 
 ➜  无职转生～到了异世界就拿出真本事～ (2021) ls Season\ 1
'无职转生～到了异世界就拿出真本事～ - S01E01 - 无职转生.jpg'                '无职转生～到了异世界就拿出真本事～ - S01E12 - 拥有魔眼的女人.nfo'
'无职转生～到了异世界就拿出真本事～ - S01E01 - 无职转生.mp4'                '无职转生～到了异世界就拿出真本事～ - S01E13 - 擦肩而过.jpg'
'无职转生～到了异世界就拿出真本事～ - S01E01 - 无职转生.nfo'                '无职转生～到了异世界就拿出真本事～ - S01E13 - 擦肩而过.mp4'
'无职转生～到了异世界就拿出真本事～ - S01E02 - 老师.jpg'                    '无职转生～到了异世界就拿出真本事～ - S01E13 - 擦肩而过.nfo'
'无职转生～到了异世界就拿出真本事～ - S01E02 - 老师.mp4'                    '无职转生～到了异世界就拿出真本事～ - S01E14 - 没有比免费更贵的东西.jpg'
'无职转生～到了异世界就拿出真本事～ - S01E02 - 老师.nfo'                    '无职转生～到了异世界就拿出真本事～ - S01E14 - 没有比免费更贵的东西.mp4'
'无职转生～到了异世界就拿出真本事～ - S01E03 - 朋友.jpg'                    '无职转生～到了异世界就拿出真本事～ - S01E14 - 没有比免费更贵的东西.nfo'
'无职转生～到了异世界就拿出真本事～ - S01E03 - 朋友.mp4'                    '无职转生～到了异世界就拿出真本事～ - S01E15 - 德路迪亚村的悠哉生活.jpg'
'无职转生～到了异世界就拿出真本事～ - S01E03 - 朋友.nfo'                    '无职转生～到了异世界就拿出真本事～ - S01E15 - 德路迪亚村的悠哉生活.mp4'
'无职转生～到了异世界就拿出真本事～ - S01E04 - 紧急家族会议.jpg'            '无职转生～到了异世界就拿出真本事～ - S01E15 - 德路迪亚村的悠哉生活.nfo'
'无职转生～到了异世界就拿出真本事～ - S01E04 - 紧急家族会议.mp4'            '无职转生～到了异世界就拿出真本事～ - S01E16 - 父子吵架.jpg'
'无职转生～到了异世界就拿出真本事～ - S01E04 - 紧急家族会议.nfo'            '无职转生～到了异世界就拿出真本事～ - S01E16 - 父子吵架.mp4'
'无职转生～到了异世界就拿出真本事～ - S01E05 - 大小姐与暴力.jpg'            '无职转生～到了异世界就拿出真本事～ - S01E16 - 父子吵架.nfo'
# ... 
'无职转生～到了异世界就拿出真本事～ - S01E11 - 孩子与战士.mp4'              '无职转生～到了异世界就拿出真本事～ - S01E23 - 醒来，跨出一步.jpg'
'无职转生～到了异世界就拿出真本事～ - S01E11 - 孩子与战士.nfo'              '无职转生～到了异世界就拿出真本事～ - S01E23 - 醒来，跨出一步.mp4'
'无职转生～到了异世界就拿出真本事～ - S01E12 - 拥有魔眼的女人.jpg'          '无职转生～到了异世界就拿出真本事～ - S01E23 - 醒来，跨出一步.nfo'
'无职转生～到了异世界就拿出真本事～ - S01E12 - 拥有魔眼的女人.mp4'           season01.jpg

通过 Docker 运行

docker run -d --name=tinymediamanager \
-v ./config:/config \
-v /srv:/media \
-e GROUP_ID=100 -e USER_ID=1000 -e TZ=Asia/Shanghai \
-e VNC_PASSWORD= \
-p 5901:5900 \
romancin/tinymediamanager:v4-latest

解决字体问题：添加字体到 fonts 目录

ls
config  fonts  run.sh

ls fonts
msyhbd.ttc  msyhl.ttc  msyh.ttc

百度网盘

除了虚拟机方案之外，还有 Docker 方案可以运行百度网盘。

用的是这个方案：johngong/baidunetdisk - Docker Image | Docker Hub

ELK

个人开发和实验用，推荐用这个项目：deviantony/docker-elk: The Elastic stack (ELK) powered by Docker and Compose.

JDK

跑 MC server 需要 JDK，我一般用 Zulu：

https://docs.azul.com/core/zulu-openjdk/install/debian#install-from-azul-apt-repository

或者使用 Oracle JRE/ JDK：

Java Downloads | Oracle

MySQL

自己开发的时候会用到，简单粗暴用 DEB 包管理器直接装了。

https://dev.mysql.com/downloads/repo/apt/

开机启动：

systemctl enable mysql

mysql-cli 中创建一个远程账号：

CREATE USER 'bolitao'@'%' IDENTIFIED BY 'pw';
GRANT ALL PRIVILEGES ON *.* TO 'bolitao'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;

redis

开发使用，直接用包管理器装：

apt install redis-server
systemctl enable redis-server

私有网盘服务 NextCloud

docker 方式安装：

version: '2'

volumes:
  nextcloud:
  db:

services:
  db:
    image: mariadb
    restart: always
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    volumes:
      - db:/var/lib/mysql
			# 添加更多磁盘映射
    environment:
      - MYSQL_ROOT_PASSWORD=
      - MYSQL_PASSWORD=
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud

  app:
    image: nextcloud
    restart: always
    ports:
      - 8090:80
    links:
      - db
    volumes:
      - nextcloud:/var/www/html
    environment:
      - MYSQL_PASSWORD=
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_HOST=db

开启外部存储插件，添加额外磁盘

进入 contailer，编辑 config.php，添加其他 IP 访问权限：

1 => preg_match('/cli/i',php_sapi_name())?'127.0.0.1':$_SERVER['SERVER_NAME'],

netdata

提供非常详尽美观的性能监控数据和报警服务。

安装

apt install netdata

vim /etc/netdata/netdata.conf

# content:
bind socket to IP = 0.0.0.0

# restart
systemctl enable netdata
systemctl restart netdata

calibre web

虽然搭了套这玩意，但是很惭愧，很久没看书了。Kindle 都吃灰一层了。

安装

PhotoPrism

个人非常推荐的一款相册软件，能根据深度学习模型识别照片并打标签。

回来检查的时候才发现码没打全，不过算了，反正这定位飘到天涯海角去了。

通过 Docker 安装，一定要记得给硬件加速，不然索引会很慢：

version: '3.5'

# Example Docker Compose config file for PhotoPrism (Linux / AMD64)
#
# Note:
# - Running PhotoPrism on a server with less than 4 GB of swap space or setting a memory/swap limit can cause unexpected
#   restarts ("crashes"), for example, when the indexer temporarily needs more memory to process large files.
# - If you install PhotoPrism on a public server outside your home network, please always run it behind a secure
#   HTTPS reverse proxy such as Traefik or Caddy. Your files and passwords will otherwise be transmitted
#   in clear text and can be intercepted by anyone, including your provider, hackers, and governments:
#   https://docs.photoprism.app/getting-started/proxies/traefik/
#
# Documentation : https://docs.photoprism.app/getting-started/docker-compose/
# Docker Hub URL: https://hub.docker.com/r/photoprism/photoprism/
#
# DOCKER COMPOSE COMMAND REFERENCE
# see https://docs.photoprism.app/getting-started/docker-compose/#command-line-interface
# --------------------------------------------------------------------------
# Start    | docker-compose up -d
# Stop     | docker-compose stop
# Update   | docker-compose pull
# Logs     | docker-compose logs --tail=25 -f
# Terminal | docker-compose exec photoprism bash
# Help     | docker-compose exec photoprism photoprism help
# Config   | docker-compose exec photoprism photoprism config
# Reset    | docker-compose exec photoprism photoprism reset
# Backup   | docker-compose exec photoprism photoprism backup -a -i
# Restore  | docker-compose exec photoprism photoprism restore -a -i
# Index    | docker-compose exec photoprism photoprism index
# Reindex  | docker-compose exec photoprism photoprism index -f
# Import   | docker-compose exec photoprism photoprism import
#
# To search originals for faces without a complete rescan:
# docker-compose exec photoprism photoprism faces index
#
# All commands may have to be prefixed with "sudo" when not running as root.
# This will point the home directory shortcut ~ to /root in volume mounts.

services:
  photoprism:
    ## Use photoprism/photoprism:preview for testing preview builds:
    image: photoprism/photoprism:latest
    depends_on:
      - mariadb
    ## Don't enable automatic restarts until PhotoPrism has been properly configured and tested!
    ## If the service gets stuck in a restart loop, this points to a memory, filesystem, network, or database issue:
    ## https://docs.photoprism.app/getting-started/troubleshooting/#fatal-server-errors
    restart: unless-stopped
    security_opt:
      - seccomp:unconfined
      - apparmor:unconfined
    ports:
      - "2342:2342" # HTTP port (host:container)
    environment:
      PHOTOPRISM_ADMIN_PASSWORD: ""          # !!! PLEASE CHANGE YOUR INITIAL "admin" PASSWORD !!!
      PHOTOPRISM_SITE_URL: "http://192.168.31.5:2342/"  # public server URL incl http:// or https:// and /path, :port is optional
      PHOTOPRISM_ORIGINALS_LIMIT: 5000               # file size limit for originals in MB (increase for high-res video)
      PHOTOPRISM_HTTP_COMPRESSION: "gzip"            # improves transfer speed and bandwidth utilization (none or gzip)
      PHOTOPRISM_DEBUG: "false"                      # run in debug mode (shows additional log messages)
      PHOTOPRISM_PUBLIC: "false"                     # no authentication required (disables password protection)
      PHOTOPRISM_READONLY: "false"                   # don't modify originals directory (reduced functionality)
      PHOTOPRISM_EXPERIMENTAL: "false"               # enables experimental features
      PHOTOPRISM_DISABLE_CHOWN: "false"              # disables storage permission updates on startup
      PHOTOPRISM_DISABLE_WEBDAV: "false"             # disables built-in WebDAV server
      PHOTOPRISM_DISABLE_SETTINGS: "false"           # disables Settings in Web UI
      PHOTOPRISM_DISABLE_TENSORFLOW: "false"         # disables all features depending on TensorFlow
      PHOTOPRISM_DISABLE_FACES: "false"              # disables facial recognition
      PHOTOPRISM_DISABLE_CLASSIFICATION: "false"     # disables image classification
      PHOTOPRISM_DARKTABLE_PRESETS: "false"          # enables Darktable presets and disables concurrent RAW conversion
      PHOTOPRISM_DETECT_NSFW: "true"                # flag photos as private that MAY be offensive (requires TensorFlow)
      PHOTOPRISM_UPLOAD_NSFW: "true"                 # allows uploads that MAY be offensive
      # PHOTOPRISM_DATABASE_DRIVER: "sqlite"         # SQLite is an embedded database that doesn't require a server
      PHOTOPRISM_DATABASE_DRIVER: "mysql"            # use MariaDB 10.5+ or MySQL 8+ instead of SQLite for improved performance
      PHOTOPRISM_DATABASE_SERVER: "mariadb:3306"     # MariaDB or MySQL database server (hostname:port)
      PHOTOPRISM_DATABASE_NAME: "photoprism"         # MariaDB or MySQL database schema name
      PHOTOPRISM_DATABASE_USER: "photoprism"         # MariaDB or MySQL database user name
      PHOTOPRISM_DATABASE_PASSWORD: ""       # MariaDB or MySQL database user password
      PHOTOPRISM_SITE_TITLE: "PhotoPrism"
      PHOTOPRISM_SITE_CAPTION: "Boli's AI-Powered Photos Server"
      PHOTOPRISM_SITE_DESCRIPTION: ""
      PHOTOPRISM_SITE_AUTHOR: "boli.tao"
      ## Run/install on first startup (options: update, gpu, tensorflow, davfs, nano, clean):
      PHOTOPRISM_INIT: "gpu tensorflow"
      ## Hardware video transcoding config (optional)
      # PHOTOPRISM_FFMPEG_BUFFERS: "64"              # FFmpeg capture buffers (default: 32)
      # PHOTOPRISM_FFMPEG_BITRATE: "32"              # FFmpeg encoding bitrate limit in Mbit/s (default: 50)
      # PHOTOPRISM_FFMPEG_ENCODER: "h264_v4l2m2m"    # use Video4Linux for AVC transcoding (default: libx264)
      PHOTOPRISM_FFMPEG_ENCODER: "h264_qsv"        # use Intel Quick Sync Video for AVC transcoding (default: libx264)
      ## Run as a specific user, group, or with a custom umask (does not work together with "user:")
      PHOTOPRISM_UID: 0
      PHOTOPRISM_GID: 0
      PHOTOPRISM_UMASK: 022
    ## Start as a non-root user (see https://docs.docker.com/engine/reference/run/#user)
    # user: "1000:1000"
    ## Share hardware devices with FFmpeg and TensorFlow (optional):
    devices:
      - "/dev/dri:/dev/dri"
    #  - "/dev/nvidia0:/dev/nvidia0"
    #  - "/dev/nvidiactl:/dev/nvidiactl"
    #  - "/dev/video11:/dev/video11" # Video4Linux (h264_v4l2m2m)
    working_dir: "/photoprism"
    ## Storage Folders: "~" is a shortcut for your home directory, "." for the current directory
    volumes:
      - "/srv/dev-disk-by-uuid-BE9213C892138455/nextcloudupload:/photoprism/originals"               # original media files (photos and videos)
      - "/srv/dev-disk-by-uuid-D0C01CEDC01CDB92/next_up:/photoprism/originals/driver2t"
      - "./storage:/photoprism/storage"                  # *writable* storage folder for cache, database, and sidecar files (never remove)

  ## Database Server (recommended)
  ## see https://docs.photoprism.app/getting-started/faq/#should-i-use-sqlite-mariadb-or-mysql
  mariadb:
    ## If MariaDB gets stuck in a restart loop, this points to a memory or filesystem issue:
    ## https://docs.photoprism.app/getting-started/troubleshooting/#fatal-server-errors
    restart: unless-stopped
    image: mariadb:10.6
    security_opt:
      - seccomp:unconfined
      - apparmor:unconfined
    command: mysqld --innodb-buffer-pool-size=128M --transaction-isolation=READ-COMMITTED --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --max-connections=512 --innodb-rollback-on-timeout=OFF --innodb-lock-wait-timeout=120
    ## Never store database files on an unreliable device such as a USB flash drive, an SD card, or a shared network folder:
    volumes:
      - "./database:/var/lib/mysql" # important, don't remove
    environment:
      MYSQL_ROOT_PASSWORD: 
      MYSQL_DATABASE: photoprism
      MYSQL_USER: photoprism
      MYSQL_PASSWORD: 

  ## Watchtower upgrades services automatically (optional)
  ## see https://docs.photoprism.app/getting-started/updates/#watchtower
  #
  watchtower:
    restart: unless-stopped
    image: containrrr/watchtower
    environment:
      WATCHTOWER_CLEANUP: "true"
      WATCHTOWER_POLL_INTERVAL: 7200 # checks for updates every two hours
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
      #- "~/.docker/config.json:/config.json" # optional, for authentication if you have a Docker Hub account

调用 tensorflow 进行索引和识别、归类过程中占用硬件资源还是很多的：

实机 CPU 占用在 70% 左右，2.5W 张图片索引时间大概两个半小时：

跑完 index 后，应用数据高达 23GB，而这 2.5W 张图片和视频也才 33GB 大而已，除了地图视图的一次前端崩溃之外，总体还挺好用的，而且局域网内非常流畅。

Piwigo

另一款相册软件，装上来主要是想和 PhotoPrism 对比下看哪个更好用，毕竟 Piwigo 是一款持续开发已有十多年历史的软件，在功能丰富程度和稳定性上可能更有优势~~不如 PhotoPrism 好用~~。

使用 linuxserver 制作的 docker 镜像：

version: "2.1"
services:
  piwigo:
    image: lscr.io/linuxserver/piwigo
    container_name: piwigo
    environment:
      - PUID=1000
      - PGID=100
      - TZ=Asia/Shanghai
    volumes:
      - ./config:/config
      - /path/to/photo:/gallery
    ports:
      - 9088:80
    restart: unless-stopped

启动：

docker-compose up -d

浏览器输入 NAS 地址 + 9088 端口即可进入 piwigo 页面：

我已经在 NAS 装了一个 MySQL 实例，所以 Piwigo 准备直接使用主机的 MySQL。回到 bash，创建 piwigo 所需要的数据库：

# 172.17.0.1 是 docker0 的地址
mysql -ubolitao -pdbpw -h172.17.0.1 -e "create database piwigo;"  # 创建数据库
mysql -ubolitao -pdbpw -h172.17.0.1 -e "show databases"     # 确认是否存在 piwigo 数据库

配置完后重新输入 NAS 地址 + 9088 端口，进入应用：

KMS

激活 LTSC 用：

https://hub.docker.com/r/teddysun/kms

Jav

硬盘里难免塞些日本成人黄色电影，我用这个工具做元数据整理：

https://github.com/yoshiko2/Movie_Data_Capture/releases/

然后直接把 jav 库导入到 Jellyfin / Emby 即可。

code server

闲得蛋疼装了一个，没什么用就是了。

https://github.com/coder/code-server

数据存储

影音媒体
- 丢了也无所谓的（番剧、电影、黄色视频）：NAS
- 丢了有所谓的：NAS + 115，极重要的还会传百度云和 OneDrive
个人媒体
- 拍的照片、录的视频、做的歌等，很难在公共互联网找到的：iCloud + OneDrive + NAS (nextcloud) + 百度云
文档
- 工作文档：线上文档平台居多，其余的放在 OneDrive
- 私人文档：OneDrive + nextcloud
代码
- 工作相关：公司 gitlab
- 私有：GitHub

虚拟机

我有使用 115、百度云和 OneDrive 的需求，所以装了一个 Windows。

后来发现 Windows 版的 qBittorrent 更稳定，于是 qb 也跑在虚拟机里了。

OMV web 面板中安装 openmediavault-kvm 和 sharerootfs 插件。查漏补缺，额外安装以下：

sudo apt install qemu qemu-kvm qemu-utils bridge-utils net-tools libvisual-0.4-plugins gstreamer1.0-tools gstreamer1.0-plugins-ugly vde2 qemu-block-extra debootstrap gstreamer1.0-plugins-base ibverbs-providers gstreamer1.0-libav gstreamer1.0-plugins-good qemu-system-gui ovmf

cockpit:

apt install cockpit\*

ip:9090 登录 cockpit，虚拟机：

创建并激活文件系统存储池
激活网络
创建 Windows 虚拟机，不要立即启动
进入 win 虚拟机选项，编辑具体内存、CPU 设置
添加 ISO
启动顺序
最后启动即可

总结

三个月时间使用下来，我还不敢说已经完全掌握这套新系统，毕竟 X86 Linux 生态可玩的和好玩的都太多了，但这台家庭服务器在这段时间实打实给了我（尤其是媒体方面的）很棒的体验。

当然，这台家庭服务器也有一些小缺点：

配置浪费：我日常使用中，CPU 占用率很少有超过 50% 的情景。如果不启动 Minecraft server 和 DNF server，内存也几乎浪费了一半多。印象中唯一例外就是 PhotoPrism，其索引时可以占用超过 70% 的内存和 CPU
时间杀器：从 0 到 1 的过程中，各种系统配置、软件配置、文档阅读都花费了我巨量时间，~~但也是真的好玩跟快乐~~

如果你对价格不敏感、不喜欢折腾，直接上群辉吧，他们提供了可靠的售后服务和一些比较稳定开箱即用的套件。

关于这套平台以后的升级方向：

硬件方面
- 系统 SSD 换成大牌子货，现在这个金士顿 SATA 盘用得实在胆战心惊（其实也没那么怕，勤用软件备份方案备份系统和软件数据就好，这个不急）
- 电源换成模组的，目前我已经出现了 SATA 硬盘供电线捉鸡的情况了（短时间内可以用分线器解决，这个不急）
- 换个机箱，现役的这个【安钛克 GX900】能装 7+ 硬盘，但是我的梦中情箱果然还是【SilverStone CS381】或者【安钛克 P101-S】（现在的又不是不能用，这个不急）
- HC550 拉满（现在空间还够我用，这个不急）
软件方面
- 目前看漫画用的是 ComicShare + SMB，想整个 Web 方案
- 系统备份方案
- NAS 重要数据备份方案：我个人重要数据已经在云端存了一至多份，所以不打算组 RAID，打算用 GoodSync 这类工具把数据拷贝到其他硬盘，本地存只是为了更多安心感和快速访问的便利

以后可能会写更多关于 NAS 的博文，我们下回再见。

NAS 下载 & 刮削新番的正确姿势

2026-01-01T08:11:41+00:00

蕾皇无职转生那波事情过去后，我追新番的方式回归到了下载。这里分享下 NAS 自动下载和刮削番剧的一些参考经验。

初始

我的第一台 NAS CPU 是 J1900、4G 内存。因为初接触这个产品，系统用的自己最熟的 Windows 10 LTSC。由于配置不足，常驻后台的只有 BitComet 和 SMB 服务。

那时候追新番统一用蜜柑计划进行订阅，然后在 BitComet 中设置自己账号订阅的最近一周发布的 RSS 链接，最后由 BitComet 统一下载到一个目录，这样子就是一个最基础的方案：能够实现自动下载、下班后通过 SMB 点开即看。

正确之路

在换了第二台配置好点的 NAS 后，我开始使用容器化的 qBittorrent 和 Emby。但其中还是有些让我不快的事：

容器版 qBittorrent Enhanced 在管理 RSS 时 webUI 经常卡死，并且只要 qBittorrent 中的任务一多，Netdata 就会发来 udp buffer error 的提醒，很烦人
RSS 下载和目录管理方式仍和以前一样，单集全塞在一个目录里——Emby 无法刮削出有效的媒体信息。并且点进媒体库目录有的单集无法直接打开，还得转到“文件夹”标签页、一个个目录点进去才能看

第一个问题我懒得查，直接通过在 Windows 虚拟机内跑 qBittorrent 规避，Windows 版的 QT 界面比 webUI 稳定，而且那之后没再爆出过 UDP 相关的错误。

第二个问题在我参阅了新番订阅自动化- 某不科学的技术博客这篇文章后得到了解决：取消原来下载一周之内订阅到一个目录的方式，通过 qBittorrent 的分类和 RSS 功能，将剧集下载到单独的目录。

以下说下 qB 的设置和 Emby 的设置步骤。

qBittorrent 设置

选项 - 下载中，“默认 Torrent 管理模式”设置为自动，勾选“对不完整的 torrent 使用另一个路径”：
点击添加分类：

为这个目录设置一个单独的路径（一定要写上季度名，如果只有一季那么写 Season 1），比如：
在 RSS 面板添加 RSS 订阅，我一般习惯用蜜柑计划提供的 RSS，输入一个字幕组的发布 RSS 即可。比如我添加由【极影字幕社+辉夜汉化组】制作的【辉夜第三季】的 RSS 地址：
打开 RSS 面板右上角的“RSS 下载器”，添加下载规则，并为其设置之前添加的分类：
通过此方式下载的剧集目录结构长这样：

Emby 设置

我之前使用 Emby 的 Ani 插件进行刮削，哪怕我组织好目录结构，其刮削结果也不尽让人满意：番剧标题、简介等都是英文的，而且没有单集介绍之类信息。

其实在使用上述方法设置好目录结构后，使用自带的 TMDB 刮削即可做到比较好的效果：

设置如下：

添加新番媒体库后，设置语言为中文：
在“电视剧的元数据下载器”部分，启用 TheMovieDb 刮削器，并将其顺序放在最上面：
在“电视剧的图像获取器”部分，启用 TheMovieDb 并将其顺序设在顶级：
我还开启了“季的图像获取器”和“集的元数据下载器”，当然我不确定有没有用

以上。

参考：

新番订阅自动化- 某不科学的技术博客

2021

2026-01-01T08:11:41+00:00

大家好，懒狗来写总结了，随便写写，别太认真。

学习 & 工作 & 生产力

学习

买了两门课，一门讲源码的、一门讲 Java + Vue 2 应用的。不过基本没怎么学习，很惭愧。

2021 年本来还想学习 Vue 和 Java 的一些高级应用，也没有实现，~~2022 年一定学~~。

工作

今年找到了新工作，马马虎虎，待遇比上一份好一点。

今年做的有印象的事情有以下：

一个演示环境的数据抽取和伪装
配合加密狗做的软件防盗版措施
负责产品的 V2 重构工作，初步计划是四项产品。目前才进行到第一项，任重道远，使用的技术是 Spring Boot + MySQL + Redis + RocketMQ 那套
推动了公司一点点的 Dev ops 和 Code Review（最后好像并没有推很动），不算成功但至少也是踏出了第一步
把一款关键应用从 Linux 移植到了 Windows，并制作了附带运行时和常用中间件的 Windows 安装包
Windows 远程运维工具，其实就是 Cygwin + FRP 的应用，不算好用但是也算能一定程度解决售后的问题
每月 500W 左右的自动化数据迁移、校验和删除和通知，做这个是为了缓解数据量过大的权宜之计，冷数据通过 Sharding 查询。2022 年应该会用上 ClickHouse
产品的新功能开发和 BUG 修复

总之，很感谢亮哥、军哥给我的信任和机会，再接再厉。

数据

GitHub：

公司私有 GitLab：

今年 RescueTime 好像也开摆了，至今（2022 年 2 月 14 日）都还没出 2022 年数据报告。只好我自己截图并说明。

今年娱乐时间非常多，占了将近有一半，干得最多的是就是打 LOL，其次是哔哩哔哩和少女前线，S1 几个客户端和网页加起来时间也非常久，又是摸得透彻的一年。希望 2022 把更多时间放在学习、健身、厨艺等方面，对了，要学车，所以时间更要好好计划。

生活 & 健康

搬了家，新家原来是酒店，倒闭后变成出租了，算是个二人间，和同事一起租。刚来时还挺满意，随着一日一日的剁手，这里也越发显得狭窄，尤其做饭，砧板都不好放。到 2022 年 6 月过期准备再找其他住处。

开始做饭了，勉强能做几个小菜和炒饭、面条，有空时做饭给自己吃还挺开心的，我很喜欢这种慢悠悠的感觉。

经过半年过渡，算是戒掉了糖，奶茶和有糖可乐几乎不喝了，目前是零卡芬达和无糖可乐交替着喝。当然水源摄入的大头还是纯净水。

今年还是经常性熬夜，掉发也挺多的。自从一月下旬从乙型流感引起的感冒发烧中康复后，我的精神状态变得极差，每天都睡不醒、起床困难，午休起来时浑身不适。以前我几乎不睡懒觉，现在如果时间充足我能够睡十小时、甚至十二小时。2022 年目标是尽量 0 点前入睡，以及多锻炼。

今年竟然胖了将近 20 斤，目前身体数据大致是 186CM / 79.25KG，体脂 20.4%，BMI 22.9。长胖的想法倒是完成了，不过完成得并不健康，估计都长肥肉了，我的理想体重为 74.2 KG，2022 年就以此体重为目标，并且把体脂降到 19 以下。

游戏

今年又买了一亿个游戏。开了个数个不同区域的 Steam 小号，一年屯了 400+ 游戏。PS5、Switch 屯不少、Epic 领了一堆、XGP 也了一堆，但是打通的好像寥寥无几，欠下一堆游戏债。我可能是患上了电子游戏 ED，如果我能活到退休，那就退休再打这些游戏吧。

游戏名	评价	个人评分
极乐迪斯科	2021 年度游戏。和《尼尔：机械纪元》一样，对上电波就会爱不释手。这是一款让我百分之百沉浸于主角、与其情感共鸣的游戏。在这款游戏里，我能构筑“我自己”，或许这就是 CRPG 的魅力吧。2021 年一月份通关的，那时还没出增强版，今年如果有空我还会再打一遍增强版。	5/5
Half Life Alyx	因为上单四姐妹可以有五个，所以 2021 年年度游戏我想评 2 个，Alyx 就是其二。拿到罗素手套时，我站在原地观摩了估计有十分钟，仔细观察完这玩意的建模和光线反射后，我心里就一个感受：“卧槽，这太特么牛逼了”。Alyx 为我带来了十足的沉浸感和视觉冲击，无与伦比的自由度和想象力，同时 VALVE 把游戏里的一切都设计得如此符合直觉和物理规则：路障、掩体、头盔、重力。另外终章是我梦中才能体会到的情景，VALVE 把它做出来了，太酷了，太完美了。	5/5
对马岛之鬼：导演剪辑版	很难相信这是欧美人做的游戏，我实在喜欢这种明亮干净的光影、格调拉满的色彩和过场分镜。片头主角骑马在草原驰骋时给我带来的冲击堪比旷野之息开场。这游戏另一个地方就是没有卡人的地方，过主线异常流畅，打到化身战鬼的时候我在血红的屏幕下一边颤抖一边疯狂杀戮，这种感觉实在妙不可言，~~这就是电子鸦片~~。	4.5/5
地铁离去	今年唯一让我爆哭的游戏，沉浸感和气氛营造一如既往的好，结局对情感高低起伏把控得很细致，两个 DLC 也并非灌水凑数。而且今年更新的 PC 增强版画面实在是厉害。不过其各方面如此优秀，为什么不是我的年度游戏？因为其作为打枪游戏，打枪部分体验却很一般，大部分情况下，为了取得一个好结局，我不能随意开火。而且我很讨厌游戏预设两个结局而通过道德点数来决定解决结局分叉的设计，因为获取道德点数完全没提示，指不定在哪个章节你兄弟就莫名其妙不跟你上火车了，结局要是兄弟数量不够就 BE 了。在末世绝望的背景下，我需要摸清谁是好人谁是坏人、分清楚敌对阵营谁是有善意的谁是恶意的，心惊胆战地区分哪些人能杀、哪些人不能杀实在是一种过大的心智负担。	4.5/5
Beat Saber	VR 玩家人手一款的游戏，挺好玩的，而且听说打 5 以上歌曲还能达到健身效果。我太菜了，至今还只能在 4 以下节奏玩玩。	4.5/5
风来之国	无聊的剧情和战斗，缓慢的节奏，我对这种游戏本应该是爱不起来的，但在国庆期间还是好好把它通了，可能是国产游戏情怀加成？总之制作组好好感谢音乐和美术吧，不然这游戏会成为一滩淤泥。	3.5/5
少女前线	曾经因为立绘和剧情让我沉迷。但和粥游一样，产能越发不足、越发摆烂。虽然不是他的错，但因为被人举报的原因，国服大破立绘彻底被删除、正常立绘被加了一堆布料，反和谐都救不回来的那种。开夏活和 VA-11 联动复刻的时候下回来过，但实在不想过图和刷材料了，玩个游戏跟上班一样还有什么意思。我虽然喜欢这款游戏，但实在是太肝了而且官方禁止脚本，加上产能及和谐的各种风波、以及成本极高的皮肤氪金方式，总之 Goodbye 了，未来云云剧情听听歌完事，谢谢少前为我带来过的快乐的时光。	4.5/5
碧蓝航线	优点是色，缺点是无聊。在朋友推荐下买了个初始号还氪金买了好多皮肤，某天玩着玩着发现感受跟上班一样，所以直接弃了。	3/5
原神	嗯...角色挺好看，画质很强。玩完新手指引后打完几个任务，节奏无聊内容空洞，没发现有趣之处。据说肝氪力度也不小，所以没玩了，不过未来可能还是会健起来玩，因为社交。	2/5
英雄联盟	我放弃这款游戏已经五年之久了，国服运营垃圾 + 垃圾环境。但年初在家 neet 的那段日子，为了和朋友玩还是捡起了这游戏。今年还氪了不少皮肤，十分后悔。总之是一个不折不扣的破烂游戏，不过没办法放弃。	2/5
王者荣耀	本质社交游戏，虽然我承诺和朋友开黑，但实际上一个月都不会打开一次，总之今年打算把玩 LOL 的精力转移到学习及其他游戏上去，比如单机或者王者，总比联盟好。	3/5
PS5 使用指南	忘记叫啥名了，反正就是那个让你体验 PS5 特性的第一方小游戏，意外的不错。	4.5/5

今年 JRPG 普遍拉跨，我甚至拿模拟器又开了个 XB2 的头。希望这两年内能玩到像 Nier2、XB2 这样让我沉浸的 JRPG。

在完善这篇博文的 2022年 2 月 14 日：今年能玩到 XB3 了！好耶！新尼亚，好耶！谢谢你 Monolith！谢谢你任天堂！

音乐

《One Last Kill》 - 宇多田ヒカル
《雨打风吹去》 - 无边界音乐
《法兰西多士》 - 告五人
《爱人错过》 - 告五人
《阿司匹林》 - 王以太
《面朝大海》 - 福禄寿FloruitShow
《杀死那个石家庄人》 - 万青
《Hollow》 - Yosh

另外今年网易的年度歌手又是 Two Door Cinema Club，其实嘛今年我更喜欢福禄寿。

动画

实质上看完的就那么几部。其他的？留到退休后看吧。

Title	个人评价	T(ao)GN评分
EVA 终	年度动画。我原本期待痞子变本加厉地输出抑郁、发病，继续折磨观众。但当剧中人物有了各自归宿、当我看见碇唯和司令拥抱真嗣时、当《One Last Kiss》在片尾响起时，自己还是忍不住落泪了。“就这样吧，结束了”，我想着，不论好或不好，再见了，所有的 Evangelion。	5/5
赛马娘第二季	动画的主线和人物关系简单，但感情渲染一点也不简单，今年让我落泪的动画之二。果然，梦想、永不言弃和突破自我这类东西还是容易打动人。	4.5/5
无职转生	最强异世界轻改，连我这种几乎不看异世界穿越番的人也看得津津有味。中文互联网引起过一阵风波，环大陆好评。我很喜欢这部作品对世界观的构筑，以及亲情、家庭、友情在这部作品中有着很大的比重，这才是真正的异世界动画标杆。另外最近在看原作，看到主角取二老婆、三老婆的部分，实在感觉膈应，可能是我对主角感情共鸣不足，也可能是我在虚拟世界中太严格了？希望动画未来能更好地呈现这一部分。原作打 4 分，动画改编满分。	5/5
双城之战	拳头和腾讯太有钱、太强了。无可挑剔的节奏、美术、音乐、人设，以及还算过得去的剧情，Perfect！	5/5
小林家的龙女仆	京都动画重启之作，没什么好说的，看的过程满是开心喜悦。	5/5

影视 & 剧集

Title	评价	个人评分
Dark	又臭又长、不讲人话。至今留了个第三季的尾巴，不知道为什么这么多人说好看。	3.5/5
鱿鱼游戏	高开低走，莫名其妙。	3.5/5

剁手

今年最魔幻的事情是，我一个果黑竟然使用上了全套 Apple 产品。

惯例列个表，记录下买的大件和有意思的玩意。推荐度是以我自己需求和使用情况写的，不一定适合在阅读的你。

产品	简评	推荐度
JetBrains IntelliJ IDEA	今年最自豪的事情之一，就是自己终于可以够购买用以赚钱的工具了。谢谢你 JetBrains。	强烈推荐
64GB DDR4 内存	事实表明根本没有这个必要，原来 32G 内存就已经够用，更何况我那 16G 的工作笔记本用得也很欢乐。	（对我）不推荐
RTX 3070	5K+ 价位狠心买的，打算用三年，但是很惭愧，没让他发挥应有的价值，打游戏时间很少，每天都抱着电脑刷微博、打 LOL。其实我觉得 PC 2060 级别显卡就足够，用以游玩独立游戏和黄油等，其他需求一律游戏机解决。	（加价）不推荐
Oculus Quest 2	性价比极高的 VR 产品，玩完 Alyx = 值回票价。这玩意真是懒狗福音——如果你不想锻炼，至少可以戴上头显打开 Beat Saber 打几首歌。不过 Facebook 没 🐎，我已经被封了两个号、买了三份 VirtualDesktop 了。另外，最近似乎还看见 S1 VR 群的群友在 VRChat 中开淫趴奇怪的聚会，等我有空一定也搞个皮上去开开眼界。	推荐
三星 S20 FE	买来当备用机用的，脑抽买的国行...后来发现其实我没备机需求，所以给家人了。	在厂商相互比烂的现在，推荐
iPad pro	11 inch。公司发 MacBook 了，还因为奇怪的原因获得了一台 iPhone，理所当然得整一整套吧。结局就是买来后这玩意用得实在不多，只用来睡前看看睿站以及极少数的写字。	不推荐
Apple Pencil	二代，配合 iPad 用的，这玩意对于我简单写字和标注 PDF 的需求来说，性价比实在是不高。但上了 Apple 的贼船，你也没得选。	一般
Apple Watch	七代 41 毫米蓝色，对我的身高来说还是显得小了，未来换代考虑换成 45 的。久坐上班族、不爱运动群体的好帮手。	强烈推荐
PS5	加价 1.2K 买的国行，虽然买了不少游戏，但十月买回来就持续性吃灰，感觉自己像个小丑。	（原价）推荐
Nintendo Switch	好像是三度买 Switch 了，这玩意讲来将去也没啥，买它的原因就是我就想要，哪怕 XB2 之后好像没啥我挺喜欢的游戏了。我不用掌机模式，一般就一个座机一样摆显示器下方，健身环专用机。	推荐
健身环大冒险	买的良值环，因为整套下来比原装便宜些。配合 Apple Watch，是懒狗健身的好帮手。	强烈推荐
1000XM3	头戴的那个。1000XM4 实在太贵，看评测 XM3 降噪已经很棒了，所以买了 XM3。从 AirPods 换过来的，综合体验实在不如 AirPods，早知道就换成 AirPods Pro。而且这玩意夏天只能在空调房里戴，还夹头，甚至还不如我那使用已有四年之久的 SHP9500。	一般
漫步者 MR4	因为算是半独居了，所以买了一副音响，不想带耳机的时候可以外放。本木耳也听不出什么音质，总之还算好用。	推荐
GPW	想玩 COD16 网战一时上头买的东西，~~结果我连游戏战役都没玩完，号就被封了，淘宝代购害人~~。说回鼠标，今年还买了个 G502 和 G304，原来的 G402 算是退役，我觉得 G304 才是真正的王，轻便便宜、足够好用。	一般
微星 B460M 迫击炮	心路：因为换了显卡，所以准备换电源，电源都换了，干脆把机箱也换掉，既然整个机箱都得拆，干脆把主板也换掉！从 B410 换过来的，鸟枪换炮，东西到手时我像初进大观园的刘姥姥：蓝牙、无线、2.4 Ghz 网卡，是这个价位能享受的？Awesome！	推荐
三星 980 M2 固态	从 Intel 760P 换过来的，其实没啥感受，再快也没 PS5 快，不过还是够用的，很满意。	推荐
Redmi 路由器AX5	这款产品好像常被诟病，不过这玩意目前能做到 Virtual Desktop 120Mbps 串流拉满，暂时不那么多废话了。	一般
R2C	作软路由用。有这玩意一切都轻松很多，比如 Oculus Quest2 的升级、PS5 听歌看剧、iPhone 后台上传 Google Photos 等。	强烈推荐
NAS	J1900 组的垃圾 NAS，不丢数据就算成功。蜜柑 RSS + qBittorrent 真是非常棒的组合，番剧无忧，叔叔走开。	强烈推荐
小米体脂秤	好东西，健康助手。	强烈推荐
优派 VX2771-4K	我的第一款 4K 显示器，同时是一款廉价显示器。但我没啥不满的，又不是不能用。另外显示器支架真是好东西，有效节省桌面空间。	推荐
2C2G VPS	CloudCone 家的。主要用来做 TTRSS 和 VaultWarden，因为有订阅国外 RSS 和密码备份到 Dropbox 的需求所以只能选国外的。	推荐
2C4G VPS	腾讯云家的。8Mbps 带宽，三年不到 300 的价格实在实惠，主要用来做 frp 转发。	推荐
Typora	写 Markdown 的工具，收费的正式版推出时我妄图使用 VSCode 达到相似的体验，显然不行，遂购买。	推荐

还买了其他许多东西，但都列出来实在费劲。总之明年不能再这么剁手，省钱！

意难平

考试

那是可能改变我人生轨迹的考试——家乡市事业单位招聘的一场考试，我最终的成绩定在招一排二。也就是说我无缘获得一份在老家踏实工作的机会。那时的自己很失落，很痛苦。因为落榜，三月开始出来找工作。

如果那时进体制内还有着“为人民服务”、“为自己打工”的想法，那么经过今年的魔幻事件之后，现在我对体制的倾向已经没那么高。

妈妈的劳动纠纷

小县城的劳动纠纷，必定伴随着乱七八糟的关系和理论。我妈在事业单位上班，受到了待遇方面的不公平对待，最终决定劳动仲裁，我自认证据已经十分充足，但是失败了。天高皇帝远，小地方的关系错节盘根，企事业单位和政府相互勾结。开始我感到异常愤怒，平息后我对这个地方失望至极。

失信

我原以为只有小地方法律才是一纸空文，但当我听闻长沙货拉拉事件不允许被告指定律师、货拉拉二审不开庭、上海小红楼事件、某明星结婚的传闻能被全网封禁等新闻或事件后，我失去了对很多东西的信任。和小 Y 的感受一致——到处都这样子发烂发臭？

有润的打算，只是我这样子的懒狗，还有原生家庭的牵制，真的能吗？

总之走一步看一步吧，在这魔幻的、对好人太坏、对坏人太好的环境下，我也不能对人和事太乐观。

感情

提及这方面的话题实在让人难过。

希望 2022 不要这么社恐这么缩卵，找机会试试看吧。

年度句子

因为害怕自己并非明珠而不敢刻苦琢磨，又因为有几分相信自己是明珠，而不能与瓦砾碌碌为伍，遂逐渐远离世间，疏避人群，结果在内心不断地用愤懑和羞怒饲育着自己懦弱的自尊心。世上每个人都是驯兽师，而那匹猛兽，就是每人各自的性情。对我而言，猛兽就是这自大的羞耻心了。老虎正是它。我折损自己，施苦妻儿，伤害朋友。末了，我就变成了这副与内心一致的模样。

如今想起来，我真是空费了自己那一点仅有的才能，徒然在口头上卖弄着什么“人生一事不为则太长，欲为一事则太短”的警句，可事实是，唯恐暴露才华不足的卑怯的畏惧，和厌恶钻研刻苦的惰怠，就是我的全部了。但远比我缺乏才华，可由于专念磨砺而成就堂堂诗家的，也颇不乏其人。成为老虎后的今天，我才总算看到了这一点。

——《山月记》

2022

2021 我给自己定的目标是在本命年好好活着，这个任务算是完成了。希望自己明年能够：

找个对象
考驾照
减少开支，储蓄以及理财
学习一门乐器
学习英语
写一个 Blog 系统（Java + Vue）
买辆车

将网易云音乐导出至 Spotify/ Youtube Music/ Apple Music

2026-01-01T08:11:41+00:00

宅家那段时间想逃离网易云，用了这个工具：网易云 / QQ音乐到Youtube Music, Spotify, Apple Music，只支持 1000 首，所以自己捣鼓了个小工具来导出歌单。

项目地址：bolitao/netease_music_playlist_to_text

流程：

在本地启动网易云音乐 NodeJS 版 API
运行本项目，输入歌单 ID，会生成 txt 格式的歌单信息
打开 Tune My Music 将歌单转移至目标服务（Sporify、YM、AM 啥的都可以）

使用

注：需在本地启动 网易云音乐 NodeJS 版 API。

使用以下命令运行：

java -jar netease_music_api_test-1.0-SNAPSHOT.jar

或者 clone 项目，使用 IDE 运行

获得音乐文件后，使用 Tune My Music 将歌单转移至目标服务。比如 Youtube Music：

RabbitMQ 笔记

2026-01-01T08:11:41+00:00

一些简单的 RabbitMQ 学习和使用笔记。

安装

手动安装麻烦，要装 erlang、rabbitmq-admin，还要配置插件。

直接用 docker-compose 吧！

demo

demo1

三种常用模式的简单示例

demo2

使用 RabbitMQ 进行邮件发送和重试

rabbitTemplate 设置

在确认 MQ 发送成功时，修改 status 为成功状态。

@Bean
RabbitTemplate rabbitTemplate() {
    RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
    rabbitTemplate.setConfirmCallback((data, ack, cause) -> {
        LOGGER.info("{}, {}, {}", data, ack, cause);
        String msgId = data.getId();
        LOGGER.warn(msgId);
        if (ack) { // 消息发送成功
            LOGGER.info(msgId + " 消息发送成功[MQ Config]");
            mailSendLogService.updateMailSendLogStatus(msgId, 1); // 修改记录表中为成功
        } else {
            LOGGER.error(msgId + " 消息发送失败[MQ Config] ack 异常");
        }
    });
    // TODO
    rabbitTemplate.setReturnCallback((msg, repCode, repText, exchange, routingKey) -> {
        LOGGER.error("消息发送失败[MQ Config 回调]");
    });
    return rabbitTemplate;
}

MQ Listener

在 MQ 消费者收到消息后，调用 MailService 发送邮件:

@RabbitListener(queues = {MailConstants.MAIL_QUEUE_NAME})
public void handler(Message message, Channel channel) {
    logger.info("已收到 " + MailConstants.MAIL_QUEUE_NAME + " Queue 的消息，开始邮件发送");
    Integer empId = (Integer) message.getPayload();
    MessageHeaders headers = message.getHeaders();
    Long tag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
    String msgId = (String) headers.get("spring_returned_message_correlation");
    if (redisTemplate.opsForHash().entries("mail_log").containsKey(msgId)) {
        //redis 中包含该 key，说明该消息已经被消费过
        logger.info(msgId + ":消息已经被消费");
        try {
            channel.basicAck(tag, false);//确认消息已消费
        } catch (IOException e) {
            logger.error("ack 异常: ", e);
        }
        return;
    }
    // 收到消息，发送邮件
    try {
        // 以下是构造 mail 相关 ，略去
        // ...
        mailSender.send(mail);
        redisTemplate.opsForHash().put("mail_log", msgId, "mail");
        channel.basicAck(tag, false);
        logger.info(msgId + ":邮件发送成功");
    } catch (Exception e) {
        try {
            channel.basicNack(tag, false, true);
        } catch (IOException ioException) {
            logger.error("nact 异常: ", ioException);
        }
        e.printStackTrace();
        logger.error("邮件发送失败：" + e.getMessage());
    }
}

重试机制

其实就是定时任务，定时查询重试次数小于五次、状态为”投递中“的消息，查到的话就将 ID 通过 MQ 重新投递，以触发 MQ Listener、调用 MailService 发送邮件

@Scheduled(cron = "0/10 * * * * ?")
public void mailResendTask() {
    List<MailSendLog> logs = mailSendLogService.getMailSendLogByStatus();

    logs.forEach(mailSendLog -> {
        if (mailSendLog.getCount() >= 5) {
            mailSendLogService.updateMailSendLogStatus(mailSendLog.getMsgid(), 2);
        } else {
            mailSendLogService.updateCount(mailSendLog.getMsgid(), new Date());
            Integer empId = mailSendLog.getEmpid();
            rabbitTemplate.convertAndSend(MailConstants.MAIL_EXCHANGE_NAME, MailConstants.MAIL_ROUTING_KEY_NAME, empId, new CorrelationData(mailSendLog.getMsgid()));
        }
    });
}

测试类

public Integer addEmp(int empId) {
    String msgId = UUID.randomUUID().toString();

    MailSendLog mailSendLog = new MailSendLog();
    mailSendLog.setMsgid(msgId);
    mailSendLog.setCreatetime(new Date());
    mailSendLog.setExchange(MailConstants.MAIL_EXCHANGE_NAME);
    mailSendLog.setRoutekey(MailConstants.MAIL_ROUTING_KEY_NAME);
    mailSendLog.setEmpid(empId);
    mailSendLog.setCount(0);
    mailSendLog.setTrytime(new Date(System.currentTimeMillis() + 1000L * 60 * MailConstants.MSG_TIMEOUT));

    mailSendLogService.insert(mailSendLog);

    rabbitTemplate.convertAndSend(MailConstants.MAIL_EXCHANGE_NAME, MailConstants.MAIL_ROUTING_KEY_NAME, empId, new CorrelationData(msgId));

    return 0;
}

在这一步：

如果 MQ 运行异常，消息未正常投递（convertAndSend 出错），那么 rabbitTemplate 中的 updateMailSendLogStatus 不会运行，MQ Listener 接收不到消息，不会调用 MailService，此时消息状态不会更改，由重试 Task 进行邮件的重新投递。
如果消息投递正常（RabbitMQ 工作正常），那么 Listener 会收到消息，调用 MailService 发送邮件；rabbitTemplate 中的回调会更新邮件状态为 1（已成功投递）

TODO

高可用

转自我的个人 wiki：RabbitMQ 相关 - Tiki

FastDFS 笔记（4）—— 防盗链

2026-01-01T08:11:41+00:00

设置

编辑文件：

sudo vim /etc/fdfs/http.conf

修改如下：

# 是否启用密钥访问
http.anti_steal.check_token = true
# 访问密钥
http.anti_steal.secret_key = FastDFS1234567890
# 错误密钥访问返回的文件
http.anti_steal.token_check_fail = /home/bolitao/图片/error.jpg

之后重启 nginx：

systemctl restart nginx

测试

使用一张已上传的图片：group1/M00/00/00/wKhPg2BO-gGAeSHoAAMQ7sedL08620.jpg。

开启防盗链前可以直接访问：

开启防盗链后，使用原地址访问文件，Nginx 返回 400：

使用错误的 token (http://192.168.79.131:8888/group1/M00/00/00/wKhPg2BO-gGAeSHoAAMQ7sedL08620.jpg?token=123&ts=1614571854) 进行访问：

通过 java client 获取正确的访问地址：

@Test
void testAntiSteal() throws UnsupportedEncodingException, NoSuchAlgorithmException, MyException {
  int ts = (int) (System.currentTimeMillis() / 1000 + 900);
  String remoteFilename = "M00/00/00/wKhPg2BO-gGAeSHoAAMQ7sedL08620.jpg";
  String fastDfsUrl = "http://192.168.79.131:8888/";
  String token = ProtoCommon.getToken(remoteFilename, ts, "bolitao");
  System.out.println(fastDfsUrl + "group1/" + remoteFilename + "?token=" + token + "&ts=" + ts);
}

注意： ProtoCommon.getToken() 的第一个参数中，文件名不加 groupx。

使用生成的 token 和时间戳进行访问，可发现访问成功：

FastDFS 笔记（3）—— FastDFS Java Client

2026-01-01T08:11:41+00:00

依赖（用的其他人传的老版本的）：

<dependency>
    <groupId>net.oschina.zcx7878</groupId>
    <artifactId>fastdfs-client-java</artifactId>
    <version>1.27.0.0</version>
</dependency>

上传

测试代码：

@SpringBootTest
class FastdfsdemoApplicationTests {
    @Test
    void contextLoads() throws IOException, MyException {
        ClientGlobal.initByProperties("fastdfs-client.properties");
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        StorageServer storageServer = null;
        StorageClient1 storageClient1 = new StorageClient1(trackerServer, storageServer);
        NameValuePair[] pairs = null;
        String fileId = storageClient1.upload_file1(
                "C:\\cyrZkTcSj6-c0.jpg", "jpg", pairs);
        System.out.println(fileId);
    }
}

运行结果：

group1/M00/00/00/wKhPg2BOF0-AGBo3AAMQ7sedL08948.jpg

实际上传位置：

结合 Spring MultipartFile 进行上传：

public static String upload(MultipartFile file) {
    String oldName = file.getOriginalFilename();
    try {
        return storageClient1.upload_file1(file.getBytes(), oldName.substring(oldName.lastIndexOf(".") + 1), null);
    } catch (IOException e) {
        log.error("xxx", e)
    } catch (MyException e) {
        log.error("xxx", e)
    }
    return null;
}

下载

@Test
void download() throws IOException, MyException {
    ClientGlobal.initByProperties("fastdfs-client.properties");
    TrackerClient trackerClient = new TrackerClient();
    TrackerServer trackerServer = trackerClient.getConnection();
    StorageServer storageServer = null;
    StorageClient1 storageClient1 = new StorageClient1(trackerServer, storageServer);
    byte[] bytes = storageClient1.download_file1("group1/M00/00/00/wKhPg2BOIdmAdmeRAAMQ7sedL08168.jpg");
    FileOutputStream fileOutputStream = new FileOutputStream(new File("C:\\Users\\xxx\\Downloads\\test.jpg"));
    fileOutputStream.write(bytes);
    fileOutputStream.close();
}

结果：

获得文件信息

@Test
void testFileInfo() throws IOException, MyException {
    ClientGlobal.initByProperties("fastdfs-client.properties");
    TrackerClient trackerClient = new TrackerClient();
    TrackerServer trackerServer = trackerClient.getConnection();
    StorageServer storageServer = null;
    StorageClient1 storageClient1 = new StorageClient1(trackerServer, storageServer);
    // 以下两种方法效果一样
    System.out.println(storageClient1.get_file_info("group1", "M00/00/00/wKhPg2BTAsWAM_9gAAT2YBE-JU0174.jpg"));
    System.out.println(storageClient1.get_file_info1("group1/M00/00/00/wKhPg2BTAsWAM_9gAAT2YBE-JU0174.jpg"));
}

输出：

source_ip_addr = 192.168.79.131, file_size = 325216, create_timestamp = 2020-02-18 15:35:33, crc32 = xx
source_ip_addr = 192.168.79.131, file_size = 325216, create_timestamp = 2020-02-18 15:35:33, crc32 = xx

获得文件 meta data

获得的是 NameValuePair 数组，其实就是上传文件的第三个参数。

NameValuePair[] metadata1 = storageClient1.get_metadata1("group1/M00/00/00/wKhPg2BTAsWAM_9gAAT2YBE-JU0174.jpg");

删除文件

返回 0 则为删除成功：

@Test
void testDeleteFile() throws IOException, MyException {
    ClientGlobal.initByProperties("fastdfs-client.properties");
    TrackerClient trackerClient = new TrackerClient();
    TrackerServer trackerServer = trackerClient.getConnection();
    StorageServer storageServer = null;
    StorageClient1 storageClient1 = new StorageClient1(trackerServer, storageServer);
    System.out.println(storageClient1.delete_file1("group1/M00/00/00/wKhPg2BTAsWAM_9gAAT2YBE-JU0174.jpg"));
}

清除浏览器缓存后再通过 token 访问该图片，Nginx 会返回 404。

拓展阅读

FastDFS 笔记（2）—— 集群部署和 cli 操作

2026-01-01T08:11:41+00:00

集群部署

准备三台服务器，其 IP 为 192.168.15.130、192.168.15.131、192.168.15.132（简记为 130、131、132）。三台服务器均已安装 FastDFS tracker、FastDFS storage、FastDFS client 和 Tengine。

修改三台机器的 tracker 配置：

sudo vim /etc/fdfs/tracker.conf

# 修改以下内容
port=22122  # tracker 服务器端口
base_path=/home/dfs  # 存储日志和数据的根目录

修改三台机器的 storage 配置：

sudo vim /etc/fdfs/storage.conf

# 修改以下配置
tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122
port=23000
base_path=/home/dfs
store_path0=/home/dfs
http.server_port=8888

重启 tracker 和 storage 服务，检查是否 storage 服务器是否登记到 tracker：

sudo /etc/init.d/fdfs_trackerd restart # 重启 tracker 服务
sudo /etc/init.d/fdfs_storaged restart # 重启 storage 服务

sudo /usr/bin/fdfs_monitor /etc/fdfs/storage.conf # 检查服务状态
# 以下是输出，省略部分非关键信息
...
tracker server is 192.168.15.132:22122

group count: 1

Group 1:
group name = group1
...
        Storage 1:
                id = 192.168.15.130
                ip_addr = 192.168.15.130  ACTIVE
                http domain =
                version = 6.06
                join time = 2020-07-14 10:08:26
                up time = 2020-07-14 15:57:34
...
        Storage 2:
                id = 192.168.15.131
                ip_addr = 192.168.15.131  ACTIVE
                http domain =
                version = 6.06
...
        Storage 3:
                id = 192.168.15.132
                ip_addr = 192.168.15.132  ACTIVE
                http domain =
                version = 6.06

可以看到三台存储服务器都处于激活状态，多运行几次 fdfs_monitor 命令会发现 tracker server 有所变换，即多个 tracker 的切换功能也是生效的。

测试 client，修改 client 配置文件：

sudo vim /etc/fdfs/client.conf

# 需要修改的内容如下：
base_path=/home/moe/dfs
tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122

测试 client 文件上传：

fdfs_upload_file /etc/fdfs/client.conf /home/bolitao/apps/screenfetch/screenfetch-dev
# 返回上传的文件位置和文件名：
group1/M00/00/00/wKgPgl8Nau-AcXEFAAPBDqCqwtI9997099

由于三台 storage 处于同一 group，组内文件互备，所以可以在三台存储服务器中发现上传的文件：

ls -l /home/dfs/data/00/00 # 列出文件
# 以下是命令输出：
-rw-r--r-- 1 root root 246030 7月  14 16:21 wKgPgl8Nau-AcXEFAAPBDqCqwtI9997099

配置 nginx 访问，修改服务器的 /etc/fdfs/mod_fastdfs.conf 文件：

tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122
url_have_group_name=true
store_path0=/home/dfs

在 nginx 中添加以下 server：

server {
    listen       8888;    ## 该端口为storage.conf中的http.server_port相同
    server_name  localhost;
    location ~/group[0-9]/ {
        ngx_fastdfs_module;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    root   html;
    }
}

重启三台 nginx 后，可在三台服务器下载文件，比如访问 http://192.168.15.130:8888/group1/M00/00/00/wKgPgl8Nau-AcXEFAAPBDqCqwtI9997099（或其他两个 host），会弹出下载对话框：

备注：这里配置了三台服务器既作 tracker 服务器也作存储服务器。实际运用时更多情况是将 tracker 和 storage 划分，tracker 用作负载均衡和调度，storage 用来存储，如下图所示：

基本操作

tracker 服务管理：

sudo /etc/init.d/fdfs_trackerd start # 启动 tracker 服务
sudo /etc/init.d/fdfs_trackerd restart # 重启动 tracker 服务
sudo /etc/init.d/fdfs_trackerd stop # 停止 tracker 服务
sudo chkconfig fdfs_trackerd on # 自启动 tracker 服务

storage 服务管理：

sudo /etc/init.d/fdfs_storaged start # 启动 storage 服务
sudo /etc/init.d/fdfs_storaged restart # 重启 storage 服务
sudo /etc/init.d/fdfs_storaged stop # 停止 storage 服务
sudo chkconfig fdfs_storaged on # 自启动 storage 服务

检查集群（会输出所有服务器的信息）：

sudo /usr/bin/fdfs_monitor /etc/fdfs/storage.conf
# 以下是命令输出：
[sudo] bolitao 的密码：
[2020-07-14 10:24:49] DEBUG - base_path=/home/dfs, connect_timeout=5, network_timeout=60, tracker_server_count=1, anti_steal_token=0, anti_steal_secret_key length=0, use_connection_pool=1, g_connection_pool_max_idle_time=3600s, use_storage_id=0, storage server id count: 0

server_count=1, server_index=0

tracker server is 192.168.188.130:22122

group count: 1

Group 1:
group name = group1
disk total space = 48,096 MB
disk free space = 44,515 MB
trunk free space = 0 MB
storage server count = 1
active server count = 1
storage server port = 23000
storage HTTP port = 8888
store path count = 1
subdir count per path = 256
current write server index = 0
current trunk file id = 0
...

上传：使用 fdfs_upload_file 命令，命令跟的第一个参数表示客户端配置文件，第二个参数表示要上传的文件，比如：
```
sudo fdfs_upload_file /etc/fdfs/client.conf /home/bolitao/apps/apache-tomcat-9.0.37/BUILDING.txt
```
下载：使用 fdfs_download_file 命令进行下载，第一个参数是客户端配置文件，第二个参数是要下载的文件，比如：
```
fdfs_download_file /etc/fdfs/client.conf group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt
```

删除：使用 fdfs_delete_file 命令进行文件删除，第一个参数是配置文件，第二个参数是要删除的文件，比如：

fdfs_delete_file /etc/fdfs/client.conf group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt

# 再次下载该文件
fdfs_download_file /etc/fdfs/client.conf 
group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt
# 提示文件不存在
[2020-07-14 10:39:16] ERROR - file: tracker_proto.c, line: 50, server: 192.168.188.130:23000, response status 2 != 0
[2020-07-14 10:39:16] ERROR - file: ../client/storage_client.c, line: 598, fdfs_recv_header fail, result: 2
download file fail, error no: 2, error info: No such file or directory

设置多个组：

修改 /etc/fdfs/storage.conf 文件中：
- store_path_count 的值
- 新增 store_path，比如 store_path1、store_path2

修改 mod_fastdfs.conf 文件：

store_path_count 的值
store_pathx 的值

仿照 group 添加更多 group，比如：

[group1]
group_name=group1
storage_server_port=23000
store_path_count=3
store_path0=/home/dfs/data/group1/M00
store_path1=/home/dfs/data/group1/M01

[group2]
group_name=group2
storage_server_port=23000
store_path_count=3
store_path0=/home/dfs/data/group2/M00
store_path1=/home/dfs/data/group2/M01

修改 nginx 反向代理配置：

location ~/group[0-9]/M00 {
    root /home/dfs/data/group1
    ngx_fastdfs_module;
}

location ~/group[0-9]/M01 {
    root /home/dfs/data/group2
    ngx_fastdfs_module;
}

FastDFS 笔记（1）—— 单机部署

2026-01-01T08:11:41+00:00

FastDFS

# 安装编译所需的库和工具
sudo apt -y install libev-dev git gcc g++ make automake autoconf libtool pcre2-utils libpcre2-dev zlib1g zlib1g-dev openssl libssh-dev wget vim

# fastdfs 文件存储路径
sudo mkdir /home/dfs

cd /usr/local/src

# libfastcommon
sudo git clone https://github.com/happyfish100/libfastcommon.git --depth 1
cd libfastcommon/
sudo sh ./make.sh && sudo sh ./make.sh install

# FastDFS
cd ..
sudo git clone https://github.com/happyfish100/fastdfs.git --depth 1
cd fastdfs/
sudo sh ./make.sh
sudo sh ./make.sh install
sudo cp /usr/local/src/fastdfs/conf/http.conf /etc/fdfs/ #供nginx访问使用
sudo cp /usr/local/src/fastdfs/conf/mime.types /etc/fdfs/ #供nginx访问使用

# fastdfs-nginx-module
cd ..
sudo git clone https://github.com/happyfish100/fastdfs-nginx-module.git --depth 1
sudo cp /usr/local/src/fastdfs-nginx-module/src/mod_fastdfs.conf /etc/fdfs

Nginx

# dependencies
sudo apt install -y perl libperl-dev libgd3 libgd-dev libgeoip1 libgeoip-dev geoip-bin libxml2 libxml2-dev libxslt1.1 libxslt1-dev

# PCRE version 8.44
sudo wget https://ftp.pcre.org/pub/pcre/pcre-8.44.tar.gz && sudo tar xzvf pcre-8.44.tar.gz
# zlib version 1.2.11
sudo wget https://www.zlib.net/zlib-1.2.11.tar.gz && sudo tar xzvf zlib-1.2.11.tar.gz
# openssl 1.1.1j
sudo wget https://www.openssl.org/source/openssl-1.1.1j.tar.gz && sudo tar xzvf openssl-1.1.1j.tar.gz
# nginx 1.18.0
sudo wget http://nginx.org/download/nginx-1.18.0.tar.gz && sudo tar -xzvf nginx-1.18.0.tar.gz
cd nginx-1.18.0

# man help
sudo cp man/nginx.8 /usr/share/man/man8
sudo gzip /usr/share/man/man8/nginx.8

# configure
sudo sh ./configure --prefix=/etc/nginx \
            --sbin-path=/usr/sbin/nginx \
            --modules-path=/usr/lib/nginx/modules \
            --conf-path=/etc/nginx/nginx.conf \
            --error-log-path=/var/log/nginx/error.log \
            --pid-path=/var/run/nginx.pid \
            --lock-path=/var/run/nginx.lock \
            --user=nginx \
            --group=nginx \
            --build=Ubuntu \
            --builddir=nginx-1.18.0 \
            --with-select_module \
            --with-poll_module \
            --with-threads \
            --with-file-aio \
            --with-http_ssl_module \
            --with-http_v2_module \
            --with-http_realip_module \
            --with-http_addition_module \
            --with-http_xslt_module=dynamic \
            --with-http_image_filter_module=dynamic \
            --with-http_geoip_module=dynamic \
            --with-http_sub_module \
            --with-http_dav_module \
            --with-http_flv_module \
            --with-http_mp4_module \
            --with-http_gunzip_module \
            --with-http_gzip_static_module \
            --with-http_auth_request_module \
            --with-http_random_index_module \
            --with-http_secure_link_module \
            --with-http_degradation_module \
            --with-http_slice_module \
            --with-http_stub_status_module \
            --with-http_perl_module=dynamic \
            --with-perl_modules_path=/usr/share/perl/5.30.0 \
            --with-perl=/usr/bin/perl \
            --http-log-path=/var/log/nginx/access.log \
            --http-client-body-temp-path=/var/cache/nginx/client_temp \
            --http-proxy-temp-path=/var/cache/nginx/proxy_temp \
            --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp \
            --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp \
            --http-scgi-temp-path=/var/cache/nginx/scgi_temp \
            --with-mail=dynamic \
            --with-mail_ssl_module \
            --with-stream=dynamic \
            --with-stream_ssl_module \
            --with-stream_realip_module \
            --with-stream_geoip_module=dynamic \
            --with-stream_ssl_preread_module \
            --with-compat \
            --with-pcre=../pcre-8.44 \
            --with-pcre-jit \
            --with-zlib=../zlib-1.2.11 \
            --with-openssl=../openssl-1.1.1j \
            --with-openssl-opt=no-nextprotoneg \
            --with-debug \
            --add-module=/usr/local/src/fastdfs-nginx-module/src/

# compile and install
sudo make && sudo make install

# add nginx user & group
sudo adduser --system --shell /bin/false --no-create-home --disabled-login --disabled-password --gecos "nginx user" --group nginx

# create folder
sudo mkdir -p /var/cache/nginx/client_temp /var/cache/nginx/fastcgi_temp /var/cache/nginx/proxy_temp /var/cache/nginx/scgi_temp /var/cache/nginx/uwsgi_temp
sudo chmod 700 /var/cache/nginx/*
sudo chown nginx:root /var/cache/nginx/*

# test nginx
sudo nginx -t
# output:
#nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
#nginx: configuration file /etc/nginx/nginx.conf test is successful

systemd:

sudo vim /etc/systemd/system/nginx.service

copy following:

[Unit]
Description=nginx - high performance web server
Documentation=https://nginx.org/en/docs/
After=network-online.target remote-fs.target nss-lookup.target
Wants=network-online.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t -c /etc/nginx/nginx.conf
ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

[Install]
WantedBy=multi-user.target

test systemd:

sudo systemctl daemon-reload
sudo systemctl enable nginx.service
sudo systemctl start nginx.service
sudo systemctl status nginx.service

create directories & grant permissions:

sudo mkdir /etc/nginx/{conf.d,snippets,sites-available,sites-enabled}
sudo chmod 640 /var/log/nginx/*
sudo chown nginx:adm /var/log/nginx/access.log /var/log/nginx/error.log

FastDFS 单机配置

tracker

sudo vim /etc/fdfs/tracker.conf

修改内容：

# 端口
port = 22122
# 存储日志和数据的根目录
base_path=/home/dfs

storage

sudo vim /etc/fdfs/storage.conf

修改内容：

# 数据和日志文件存储根目录
base_path=/home/dfs
# 第一个存储目录
store_path0=/home/dfs
# tracker服务器IP和端口，这里是单机部署所以就用本机的
tracker_server=192.168.79.131:22122
# http访问文件的端口(默认8888,看情况修改,和nginx中保持一致)
http.server_port=8888

client 测试

sudo vim /etc/fdfs/client.conf

修改内容：

base_path=/home/dfs
tracker_server=192.168.79.131:22122

重启 tracker 和 storage：

sudo /usr/bin/fdfs_trackerd /etc/fdfs/tracker.conf restart
sudo /usr/bin/fdfs_storaged /etc/fdfs/storage.conf restart

使用 fdfs_monitor 验证：

sudo /usr/bin/fdfs_monitor /etc/fdfs/storage.conf

输出如下（输出太长，省略部分）：

[2021-03-01 12:45:37] DEBUG - base_path=/home/dfs, connect_timeout=5, network_timeout=60, tracker_server_count=1, anti_steal_token=0, anti_steal_secret_key length=0, use_connection_pool=1, g_connection_pool_max_idle_time=3600s, use_storage_id=0, storage server id count: 0

server_count=1, server_index=0

tracker server is 192.168.79.131:22122

group count: 1

Group 1:
group name = group1

测试：

# 测试，有文件路径返回表示成功，如：group1/M00/00/00/wKhPg2BN6Z6AXk8WADVIAIo8asI.tar.gz
fdfs_upload_file /etc/fdfs/client.conf /usr/local/src/zlib-1.2.11.tar.gz

配置 Nginx 访问

sudo vim /etc/fdfs/mod_fastdfs.conf

修改如下：

tracker_server=192.168.79.131:22122  #tracker服务器IP和端口
url_have_group_name=true
store_path0=/home/dfs

配置 nginx.config:

sudo vim /etc/nginx/nginx.conf

添加 server 段如下：

server {
    listen       8888;    ## 该端口为storage.conf中的http.server_port相同
    server_name  localhost;
    location ~/group[0-9]/ {
        ngx_fastdfs_module;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    root   html;
    }
}

reload nginx：

sudo nginx -s reload

在测试章节中，我上传了名为 group1/M00/00/00/wKhPg2BN6Z6AXk8WADVIAIo8asI.tar.gz 的文件。

于是通过此链接测试 nginx 文件下载：http://192.168.79.131:8888/group1/M00/00/00/wKhPg2BN6Z6AXk8WADVIAIo8asI.tar.gz。

可以看到 FastDFS Nginx 模块是工作正常的：

Docker 部署

TODO: season/fastdfs

FastDFS 分布式部署

分布式部署部分是在工作机部署和测试的，IP 和系统有所不同可能造成与本篇内容的脱节，所以单独形成了一篇文章：

FastDFS 学习（2）—— 集群部署和 cli 操作 | Kara

参考

Home · happyfish100/fastdfs Wiki
[How to Compile Nginx From Source on Ubuntu 20.04 LTS](How to Compile Nginx From Source on Ubuntu 20.04 LTS)

Spring Security 笔记（4）——持久化

2026-01-01T08:11:41+00:00

在前面的章节中，我使用的用户信息都是基于代码配置、信息存于内存，在实际项目中，用户认证和角色信息肯定是持久化的，需通过连接数据库存取。

修改

之前我使用基于内存的 InMemoryUserDetailsManager，对于从数据库存取 Spring Security 关系，需要使用 JdbcUserDetailsManager，其提供了 users.ddl：

create table users(username varchar_ignorecase(50) not null primary key,password varchar_ignorecase(500) not null,enabled boolean not null);
create table authorities (username varchar_ignorecase(50) not null,authority varchar_ignorecase(50) not null,constraint fk_authorities_users foreign key(username) references users(username));
create unique index ix_auth_username on authorities (username,authority);

要使用 JdbcUserDetailsManager，需手动执行建表语句：

create table users(username varchar(50) not null primary key,password varchar(500) not null,enabled boolean not null);
create table authorities (username varchar(50) not null,authority varchar(50) not null,constraint fk_authorities_users foreign key(username) references users(username));
create unique index ix_auth_username on authorities (username,authority);

添加 JDBC 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

添加 datasource 配置：

spring.datasource.username=root
spring.datasource.password=bolitao
spring.datasource.url=jdbc:mysql://192.168.79.131:3306/spring_security_demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai

修改密码加密方式：

@Bean
PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
    //        return NoOpPasswordEncoder.getInstance();
}

修改 UserDetailsService：

@Autowired
DataSource dataSource;

@Override
@Bean
protected UserDetailsService userDetailsService() {
    JdbcUserDetailsManager userDetailsManager = new JdbcUserDetailsManager(dataSource);
    if (!userDetailsManager.userExists("bolitao")) {
        userDetailsManager.createUser(
            User.withUsername("bolitao").password(passwordEncoder().encode("bolitao")).roles("ADMIN").build());
    }
    if (!userDetailsManager.userExists("test1")) {
        userDetailsManager.createUser(
            User.withUsername("test1").password(passwordEncoder().encode("test")).roles("USER").build());
    }
    return userDetailsManager;
}

测试：

修改代码后启动项目，可发现 authorities 和 users 表多了数据：

测试

将数据库 username 为 bolitao 的记录修改，enabled 设置为 0，注销后进行登录，可发现提示账户被禁用：

Spring Security 笔记（3）——授权

2026-01-01T08:11:41+00:00

测试用户（暂用 inMemoryAuthentication）：

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.inMemoryAuthentication()
            .withUser("bolitao")
            .password("bolitao")
            .roles("ADMIN")
            .and()
            .withUser("test1")
            .password("test")
            .roles("USER");
}

或者：

@Override
@Bean
protected UserDetailsService userDetailsService() {
    InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
    inMemoryUserDetailsManager
            .createUser(User.withUsername("bolitao").password("bolitao").roles("ADMIN").build());
    inMemoryUserDetailsManager
            .createUser(User.withUsername("test1").password("test").roles("USER").build());
    return inMemoryUserDetailsManager;
}

URL 角色拦截

http.authorizeRequests()
        .antMatchers("/admin/**").hasRole("ADMIN")
        .antMatchers("/user/**").hasRole("USER")
        .anyRequest().authenticated()
    	// ...

注意：anyRequest 只能放在最后配，具体见源码 AbstractRequestMatcherRegistry：

无参构造函数会进行 anyRequestConfigured 赋值：
public C anyRequest() {
	Assert.state(!this.anyRequestConfigured, "Can't configure anyRequest after itself");
	C configurer = requestMatchers(ANY_REQUEST);
	this.anyRequestConfigured = true;
	return configurer;
}
设置 anyMatchers 时会调用 Assert.state() 判断 anyRequestConfigured 的值，在 anyRequest 被配置后，任何 anyMatchers 都无法被配置：
public C antMatchers(HttpMethod method, String... antPatterns) {
	Assert.state(!this.anyRequestConfigured, "Can't configure antMatchers after anyRequest");
	return chainRequestMatchers(RequestMatchers.antMatchers(method, antPatterns));
}

配置完毕后进行测试：

使用 test1（身份为 USER）登录后访问 /user/test 返回 user test，能够正常访问；访问 admin/test 则返回 403 Forbidden：

{
    "timestamp": "2020-11-21T03:42:38.104+00:00",
    "status": 403,
    "error": "Forbidden",
    "message": "",
    "path": "/admin/test"
}

类似的，使用 bolitao（身份为 ADMIN）登陆后访问 user/test 提示 403；而 admin/test 能够正常访问。

ROLE 继承

按常理，ADMIN 应该能够访问角色权限为 USER 的 URL，因此需要角色继承，实现如下：

@Bean
RoleHierarchy roleHierarchy() {
    RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
    roleHierarchy.setHierarchy("ROLE_ADMIN > ROLE_USER");
    return roleHierarchy;
}

当指定 ROLE_ADMIN > ROLE_USER 后，就可以使用 ADMIN 角色访问权限是 USER 的 URL 了：

Spring Security 笔记（2）——RESTful

2026-01-01T08:11:41+00:00

登陆成功返回 json

修改 configure(HttpSecurity http) 如下：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login.html")
            .loginProcessingUrl("/login")
            .usernameParameter("username")
            .passwordParameter("passwd")
            .successHandler((req, resp, authentication) -> {
                resp.setContentType("application/json;charset=utf-8");
                PrintWriter writer = resp.getWriter();
                writer.write(new ObjectMapper().writeValueAsString(authentication.getPrincipal()));
                writer.flush();
                writer.close();
            })
            .permitAll()
            .and()
            .logout()
            .logoutRequestMatcher(new AntPathRequestMatcher("/logout", "POST"))
            .and()
            .csrf().disable();
}

主要添加了 successHandler 部分，指定登陆成功后返回的内容，我指定为 json 格式的登录认证信息。

此时使用 POST 方式请求登录接口 127.0.0.1:8080/login?username=bolitao&passwd=bolitao，返回结果如下：

{
    "password": null,
    "username": "bolitao",
    "authorities": [
        {
            "authority": "ROLE_ADMIN"
        },
        {
            "authority": "ROLE_USER"
        }
    ],
    "accountNonExpired": true,
    "accountNonLocked": true,
    "credentialsNonExpired": true,
    "enabled": true
}

登陆失败返回 json

和上节类似，添加 failureHandler 即可应对失败的返回情况：

.failureHandler((req, resp, exception) -> {
    resp.setContentType("application/json;charset=utf-8");
    PrintWriter writer = resp.getWriter();
    String exceptionMessage = exception.getMessage();
    if (exception instanceof LockedException) {
        exceptionMessage = "账户被锁";
    } else if (exception instanceof CredentialsExpiredException) {
        exceptionMessage = "密码过期";
    } else if (exception instanceof AccountExpiredException) {
        exceptionMessage = "账户过期";
    } else if (exception instanceof DisabledException) {
        exceptionMessage = "账户已被禁用";
    } else if (exception instanceof BadCredentialsException) {
        exceptionMessage = "用户名或密码错误";
    }
    writer.write(new ObjectMapper().writeValueAsString(exceptionMessage));
    writer.flush();
    writer.close();
})

这里未作特殊处理，仅返回了具体错误信息。

Q：为什么用户名或密码错误不返回确定的错误呢？账户输错提示用户名错误、密码输错提示密码错误，这样不是更友好吗？

A：为了防止被穷举撞库。

在 Spring Security 源码中，其实确实是有密码错误的异常的，但默认不会返回，只会统一返回 BadCredentialsException。

具体见 Spring Security 源码的 AbstractUserDetailsAuthenticationProvider 类：
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
	Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
			() -> this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports",
					"Only UsernamePasswordAuthenticationToken is supported"));
	String username = determineUsername(authentication);
	boolean cacheWasUsed = true;
	UserDetails user = this.userCache.getUserFromCache(username);
	if (user == null) {
		cacheWasUsed = false;
		try {
			user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
		}
		catch (UsernameNotFoundException ex) {
			this.logger.debug("Failed to find user '" + username + "'");
			if (!this.hideUserNotFoundExceptions) {
				throw ex;
			}
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
		Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract");
	}
    // ...
可以看到 Spring Security 通过 hideUserNotFoundExceptions 这个布尔值判断是否返回 UsernameNotFoundException（用户不存在异常）。并且 hideUserNotFoundExceptions 的默认值为 true。

未登录提示

Spring Security 默认会跳转到 loginURL 让用户进行登陆，在前后端分离场景下返回未登录 json 消息才是更合适的方式。在 config 添加一小段即可实现：

.exceptionHandling().authenticationEntryPoint(
(req, resp, exception) -> {
    resp.setStatus(HttpStatus.UNAUTHORIZED.value());
    resp.setContentType("application/json;charset=utf-8");
    PrintWriter writer = resp.getWriter();
    writer.write(new ObjectMapper().writeValueAsString("尚未登陆"));
    writer.flush();
    writer.close();
});

这里仅返回了一句话，在实际场景应该用统一返回类进行包装。实际效果：

注销成功提示

和上面的登陆成功返回 json 类似，定义一个 lambda 函数描述返回值：

.logoutSuccessHandler((req, resp, authentication)-> {
    resp.setContentType("application/json;charset=utf-8");
    PrintWriter writer = resp.getWriter();
    writer.write(new ObjectMapper().writeValueAsString("注销成功"));
    writer.flush();
    writer.close();
})

Spring Security 笔记（1）——入门

2026-01-01T08:11:41+00:00

使用 spring-boot，依赖添加 starter-web 和 starter-security。

默认配置

对于一个没有任何额外配置的 controller，默认会使用 spring security 进行保护：

项目启动时会在控制台给出一个随机密码：

Using generated security password: 2fb8492d-410e-4333-998f-5fa5f68ed52f

使用用户名 user 和密码 2fb8492d-410e-4333-998f-5fa5f68ed52f 即可进行登录。

设置密码

通过配置文件配置

在 spring 配置文件添加如下：

spring.security.user.name=bolitao
spring.security.user.password=bolitao

通过配置类配置

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("bolitao")
                .password("bolitao")
                .roles("USER", "ADMIN")
                .and()
                .withUser("testuser")
                .password("test")
                .roles("USER");
    }
}

以上代码以内存方式配置了两个用户：bolitao 和 testuser，并配置了他们的角色和密码。PasswordEncoder 暂时不管，后面会换成 bcrypt。

配置优先级：代码中的配置 > properties 中的配置

表单认证

做一个简陋的登录表单：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
<img src="image/test.png" width="10%" alt="img">
<form action="/login" method="post">
    <div class="input">
        <label for="username">用户名</label>
        <input type="text" name="username" id="username">
        <span class="spin"></span>
    </div>
    <div class="input">
        <label for="password">密码</label>
        <input type="password" name="passwd" id="password">
        <span class="spin"></span>
    </div>
    <div class="button login">
        <button type="submit">
            <span>登录</span>
            <i class="fa fa-check"></i>
        </button>
    </div>
</form>
</body>
</html>

在 Spring Security 配置类添加：

@Override
public void configure(WebSecurity web) throws Exception {
    web.ignoring().antMatchers("/image/**", "/css/**", "/js/**");
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login.html")
            .loginProcessingUrl("/login")
            .usernameParameter("username")
            .passwordParameter("passwd")
            .permitAll()
            .and()
            .logout()
            .logoutRequestMatcher(new AntPathRequestMatcher("/logout", "POST"))
            .and()
            .csrf().disable();
}

第一个 configure：对所有 URL 允许特定三个文件夹下的内容。

第二个 configure：

所有请求都需要认证
指定 form 方式登录，页面地址（GET）为 login.html，login API 地址（POST）为 /login；自定义表单 username 和 password 名为 username 和 passwd（一般不需要改，默认的语义更好）；最后放行这两个地址
设定注销 URL 为 /logout（POST 方式）
暂关闭 CSRF

之后就可以使用自定义的页面，通过表单登录进行 Spring Security 认证了。

ElasticSearch —— 使用 ES 实现一个搜索项目

2026-01-01T08:11:41+00:00

依赖

spring boot 2.2.5.RELEASE，其他：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

<!-- jsoup -->
<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.10.2</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

配置 ES 连接

指定了用户名、密码和地址、端口：

@Configuration
public class ElasticSearchConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials("elastic", "XCkZUSgrTHOF0krUsXgJ"));
        return new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.79.131", 9200, "http"))
                        .setHttpClientConfigCallback(httpClientBuilder -> {
                            httpClientBuilder.disableAuthCaching();
                            return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                        }));
    }
}

准备数据

从京东爬点数据存到 ES。

使用 Jsoup 解析 HTML：

public class HtmlParseUtil {
    public static void main(String[] args) throws IOException {
        new HtmlParseUtil().parseJd("高效").forEach(System.out::println);
    }

    public List<JdContent> parseJd(String keyword) throws IOException {
        ArrayList<JdContent> jdContents = new ArrayList<>();

        String url = "https://search.jd.com/Search?keyword=" + keyword + "&enc=utf-8";
        Document document = Jsoup.parse(new URL(url), 30000);
        Element jGoodsList = document.getElementById("J_goodsList");
        Elements elementsByTag = jGoodsList.getElementsByTag("li");
        for (Element element : elementsByTag) {
            String img = element.getElementsByTag("img").eq(0).attr("data-lazy-img");
            String price = element.getElementsByClass("p-price").eq(0).text();
            String title = element.getElementsByClass("p-name").eq(0).text();
            jdContents.add(new JdContent(title, img, price));
        }
        return jdContents;
    }
}

准备一个 service，传入搜索关键字，调用上面的 HtmlParseUtil 爬取数据、存入 ES：

public Boolean parseContent(String keyword) throws IOException {
    List<JdContent> contents = new HtmlParseUtil().parseJd(keyword);
    BulkRequest bulkRequest = new BulkRequest();
    bulkRequest.timeout("2m");
    for (JdContent content : contents) {
        bulkRequest.add(
                new IndexRequest("goods")
                        .source(JSON.toJSONString(content), XContentType.JSON));
    }
    BulkResponse bulk = restHighLevelClientt.bulk(bulkRequest, RequestOptions.DEFAULT);
    return bulk.hasFailures();
}

返回 false 则表示数据存入 ES 时未发生错误。

搜索

关键字搜索

public List<Map<String, Object>> searchPageable(String keyword, Integer currentPage, Integer pageSize) throws IOException {
    if (currentPage <= 1) {
        currentPage = 1;
    }
    SearchRequest searchRequest = new SearchRequest("goods");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

    // 分页
    searchSourceBuilder.from(currentPage);
    searchSourceBuilder.size(pageSize);

    //        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", keyword);
    //        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", keyword).analyzer("ik_max_word");
    WildcardQueryBuilder queryBuilder = QueryBuilders.wildcardQuery("title", "*" + keyword + "*");
    searchSourceBuilder.query(queryBuilder);
    searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

    searchRequest.source(searchSourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);


    ArrayList<Map<String, Object>> ret = new ArrayList<>();
    for (SearchHit searchHit : searchResponse.getHits().getHits()) {
        Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();

        ret.add(searchHit.getSourceAsMap());
    }
    return ret;
}

测试：

高亮

和关键字搜索非常相似，只是把搜索出的 field 关键字部分添加 span 标签和 color: red 属性~~（我不太喜欢这种方式）~~：

public List<Map<String, Object>> highlightSearchPageable(String keyword, Integer currentPage, Integer pageSize) throws IOException {
    if (currentPage <= 1) {
        currentPage = 1;
    }
    SearchRequest searchRequest = new SearchRequest("goods");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

    // 分页
    searchSourceBuilder.from(currentPage);
    searchSourceBuilder.size(pageSize);

    //        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", keyword);
    //        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", keyword).analyzer("ik_max_word");
    WildcardQueryBuilder queryBuilder = QueryBuilders.wildcardQuery("title", "*" + keyword + "*");
    searchSourceBuilder.query(queryBuilder);
    searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

    // highlight
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.field("title");
    highlightBuilder.preTags("<span style='color:red'>");
    highlightBuilder.postTags("</span>");
    searchSourceBuilder.highlighter(highlightBuilder);

    searchRequest.source(searchSourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);


    ArrayList<Map<String, Object>> ret = new ArrayList<>();
    for (SearchHit searchHit : searchResponse.getHits().getHits()) {
        Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
        HighlightField title = highlightFields.get("title");
        Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();

        if (title != null) {
            Text[] fragments = title.fragments();
            String n_title = "";
            for (Text fragment : fragments) {
                n_title += fragment;
            }
            sourceAsMap.put("title", n_title);
        }

        ret.add(sourceAsMap);
    }
    return ret;
}

测试：

ElasticSearch —— ELK 安装和配置

2026-01-01T08:11:41+00:00

[TOC]

安装

使用 docker-compose:

git clone https://github.com/deviantony/docker-elk.git
cd docker-elk
sudo docker-compose up -d

配置

配置密码

执行下列命令，生成 ES 集成用户的密码：

sudo docker-compose exec -T elasticsearch bin/elasticsearch-setup-passwords auto --batch

比如我的输出：

Changed password for user apm_system
PASSWORD apm_system = mkiFZAiUFtYusw0hKidx

Changed password for user kibana_system
PASSWORD kibana_system = 8KnPbnm5doTZBBfk5lxd

Changed password for user kibana
PASSWORD kibana = 8KnPbnm5doTZBBfk5lxd

Changed password for user logstash_system
PASSWORD logstash_system = IZILJ4Z9cqC6oARU2DJb

Changed password for user beats_system
PASSWORD beats_system = ZwZV65JUoQPq4Drwx79V

Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = yGD4EK9o9fDDFpPGaC34

Changed password for user elastic
PASSWORD elastic = XCkZUSgrTHOF0krUsXgJ

编辑 kibana 配置文件 /path/to/docker-elk/kibana/config/kibana.yml，修改其中用户信息：

elasticsearch.username: kibana_system
elasticsearch.password: 8KnPbnm5doTZBBfk5lxd

编辑 logstash 配置文件 /path/to/docker-elk/logstash/config/logstash.yml，修改用户信息：

xpack.monitoring.elasticsearch.username: logstash_system
xpack.monitoring.elasticsearch.password: IZILJ4Z9cqC6oARU2DJb

编辑 /path/to/docker-elk/logstash/pipeline/logstash.conf，修改 es 连接配置：

output {
        elasticsearch {
                hosts => "elasticsearch:9200"
                user => "elastic"
                password => "XCkZUSgrTHOF0krUsXgJ"
                ecs_compatibility => disabled
        }
}

最后重启 kibana 和 logstash：

sudo docker-compose restart kibana logstash

分词器插件 ik

安装

方法 1

推荐使用此方法安装插件，能比较方便未来自定义分词字典。

将插件解压为文件夹 analysis-ik，随后把这个文件夹拷贝至 /path/to/docker-elk/elasticsearch/plugins。

编辑 dockerfile 文件 /path/to/docker-elk/elasticsearch/Dockerfile，添加如下：
```
COPY plugins plugins
```
build 并重启：
```
sudo docker-compose build
sudo docker-compose up -d
```
方法 2（不推荐）

编辑 es dockerfile 文件 /path/to/docker-elk/elasticsearch/Dockerfile，添加：
```
RUN elasticsearch-plugin install -b http://192.168.79.1:8000/elasticsearch-analysis-ik-7.11.2.zip
```
PS: 自行替换插件包地址。

之后 build 并重启：
```
sudo docker-compose build
sudo docker-compose up -d
```

ik_smart

GET _analyze 
{
  "analyzer": "ik_smart",
  "text": "vue.js 教程"
}

输出：

{
  "tokens" : [
    {
      "token" : "vue.js",
      "start_offset" : 0,
      "end_offset" : 6,
      "type" : "LETTER",
      "position" : 0
    },
    {
      "token" : "教程",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 1
    }
  ]
}

ik_max_word

GET _analyze 
{
  "analyzer": "ik_max_word",
  "text": "vue.js 教程"
}

输出：

{
  "tokens" : [
    {
      "token" : "vue.js",
      "start_offset" : 0,
      "end_offset" : 6,
      "type" : "LETTER",
      "position" : 0
    },
    {
      "token" : "vue",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "ENGLISH",
      "position" : 1
    },
    {
      "token" : "js",
      "start_offset" : 4,
      "end_offset" : 6,
      "type" : "ENGLISH",
      "position" : 2
    },
    {
      "token" : "教程",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 3
    }
  ]
}

自定义字典

有的常见人名/专有词 IK 不能识别，比如：

GET _analyze 
{
  "analyzer": "ik_max_word",
  "text": "阮一峰的网络日志"
}

// 输出：
{
  "tokens" : [
    {
      "token" : "阮",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "一",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "TYPE_CNUM",
      "position" : 1
    },
    {
      "token" : "峰",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "CN_CHAR",
      "position" : 2
    },
    {
      "token" : "的",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "网络日志",
      "start_offset" : 4,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "网络",
      "start_offset" : 4,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "日志",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 6
    }
  ]
}

可以看到“阮一峰”这个名字没有被正确分词，因此需要自定义一个词典，将改名字添加进去。

首先新增自定义字典文件 /path/to/docker-elk/elasticsearch/plugins/analysis-ik/config/boli.dic，添加内容很简单：

阮一峰

之后编辑 ik 配置文件，指定自定义词典：

vim elasticsearch/plugins/analysis-ik/config/IKAnalyzer.cfg.xml

编辑内容：

<!--用户可以在这里配置自己的扩展字典 -->
 <entry key="ext_dict">boli.dic</entry>

随后 build、重启 ES：

sudo docker-compose build
sudo docker-compose up -d

再次进行测试：

GET _analyze 
{
  "analyzer": "ik_max_word",
  "text": "阮一峰的网络日志"
}

// 输出：
{
  "tokens" : [
    {
      "token" : "阮一峰",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "一",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "TYPE_CNUM",
      "position" : 1
    },
    {
      "token" : "峰",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "CN_CHAR",
      "position" : 2
    },
    {
      "token" : "的",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "网络日志",
      "start_offset" : 4,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "网络",
      "start_offset" : 4,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "日志",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 6
    }
  ]
}

可看到搜索内容已被正确分词。

集群

TODO

2020 总结

2026-01-01T08:11:41+00:00

终于差不多把 2020 熬过来了。

学业

七月初拿到了毕业证和学位证，晚了几天，但总归是拿下了。

工作

因为疫情，年初至五月底公司一直没让去实习，六月返校后学校开了最后一场校招，趁此机会投了些简历，换了家公司。

由于和原公司毁约三方、新公司强制签三方协议、学校必须要原公司的解约函才给开新三方，于是赔偿了原公司违约费，拮据着过了一个月。

工作方面，做 to B 业务。

七月至十月做的 PaaS 开发，工作内容大致为基于某些中间件的应用和开发，以及线上运维、部署支撑。

十月后做的具体业务开发，开始出差，开始 907。

因为以下一些原因，我在 12 月中旬辞职了：

强度高，五十多天的出差、没有一天休息的 907 节奏（周末偶尔能休半天 XD）

压力大，因为组里极度缺人，我被派到广东省医保局单独负责一个市的财务模块上线；测试人员敷衍了事，更加加剧了我的不安和压力

心累，一个人像个孤儿一样，白天一堆碎事、会议、扯皮，晚上开始加班

管理混乱，交付部有人专门负责需求和沟通，但极不靠谱。搞到最后竟然成了要我（开发）去客户现场培训和整理需求，之后再把需求发给交付，交付拿着我整理的东西汇报后再发回给我，魔幻

目前在按家人期望准备考编，考不上还是要去外面找工作。

健康

因为加班熬夜和较大的工作压力，疯狂掉头发。

胖了十多斤，目前 186/72，估计纯长膘了，毕竟每天都是坐着，没什么时间运动。

其他

对今年其实还有挺多想说的，但要去忙备考了，就到此为止吧，有空可能会在 垃圾桶 更新更多。

使用 Dropbox 备份 TTRSS

2026-01-01T08:11:41+00:00

前阵子误操作 docker-compose，玩坏了 TTRSS，订阅全无。经历了血的教训后，我觉得有必要对 TTRSS 进行备份。

Dropbox 配置

使用 root 身份登入服务器，下载 Dropbox 脚本：

cd /root && wget https://raw.github.com/andreafabrizi/Dropbox-Uploader/master/dropbox_uploader.sh

赋可执行权限、运行脚本进行配置：

chmod +x dropbox_uploader.sh && ./dropbox_uploader.sh

之后根据输出进行配置，我的输出大致如下：

# output: 
This is the first time you run this script, please follow the instructions:

(note: Dropropbox will change there API from 30.9.2021.
When using dropbox_uploader.sh configured in the past with the old API, have a look at README.md, before continue.)

 1) Open the following URL in your Browser, and log in using your account: https://www.dropbox.com/developers/apps
 2) Click on "Create App", then select "Choose an API: Scoped Access"
 3) "Choose the type of access you need: App folder"
 4) Enter the "App Name" that you prefer (e.g. MyUploader13057149876349), must be uniqe

 Now, click on the "Create App" button.

 5) Now the new configuration is opened, switch to tab "permissions" and check "files.metadata.read/write" and "files.content.read/write"
 Now, click on the "Submit" button.

 6) Now to tab "settings" and provide the following information:
 App key: app_key
 App secret: app_secret
  Open the following URL in your Browser and allow suggested permissions: https://www.dropbox.com/oauth2/authorize?client_id=xxx&token_access_type=offline&response_type=code
 Please provide the access code: xxx

 > App key: app_key
 > App secret: 'app_secret
 > Access code: 'access_code'. Looks ok? [y/N]: y
   The configuration has been saved.

检查是否配置成功：

./dropbox_uploader.sh info

# output:
Dropbox Uploader v1.0

 > Getting info...

Name:           Tao Boli
UID:            dbid:xx
Email:          name@gmail.com
Country:        HK

备份脚本

创建目录和 ttrss_backup.sh 脚本：

mkdir /root/scripts && mkdir /root/dropbox && vim /root/scripts/ttrss_backup.sh

内容填写如下：

#!/bin/bash

SCRIPT_DIR="/root"
NOW=$(date +"%Y%m%d")
TMP_PATH='/tmp'
DOCKER_NAME='postgres'
TTRSS_DB="$TMP_PATH/ttrss.sql"
BAK_FILE_NAME="vps-$NOW.tar.gz"
BAK_FILE="$TMP_PATH/$BAK_FILE_NAME"
DROPBOX_DIR="/root/dropbox"

docker exec "$DOCKER_NAME" pg_dumpall -c -U postgres > "$TTRSS_DB"
echo "数据库备份完成，打包网站数据中..."
tar cfzP "$BAK_FILE" "$TTRSS_DB"
echo "所有数据打包完成，准备上传..."
# 用脚本上传到dropbox
"$SCRIPT_DIR"/dropbox_uploader.sh upload "$BAK_FILE" "$DROPBOX_DIR/$BAK_FILE_NAME"
if [ $? -eq 0 ];then
     echo "上传完成"
else
     echo "上传失败，重新尝试"
fi

# 删除本地的临时文件
rm -f "$TTRSS_DB" "$BAK_FILE"

我在脚本用的是 pg_dumpall 【导出全部】，如果只需要备份 ttrss 的数据库，建议换成 pg_dump <db_name>。

赋予可执行权限、并验证一下脚本：

chmod +x ttrss_backup.sh && /root/scripts/ttrss_backup.sh

输出如下：

数据库备份完成，打包网站数据中...
所有数据打包完成，准备上传...
 > Uploading "/tmp/vps-20201213.tar.gz" to "/root/dropbox/vps-20201213.tar.gz"... DONE
上传完成

VPS 的上传带宽是真的很行 😋

到 Dropbox 客户端检查下文件是否上传成功：

验证脚本无问题后，进入下一步编写定时任务。

Crontab 定时任务

如果跟我一样不熟悉 cron，推荐下这个网站：crontab.guru - the cron schedule expression editor

我个人定时是每周日和周三上午三点：0 3 * * 0,3。

打开 crontab 编辑器：

crontab -e

添加内容如下：

0 3 * * 0,3 /bin/bash /root/scripts/ttrss_backup.sh > /dev/null

最后 reload crontab:

service cron reload

# output:
* Reloading configuration files for periodic command scheduler cron                     [ OK ]

参考

解决 vercel hugo 版本过老导致的编译出错

2026-01-01T08:11:41+00:00

今天升级了主题和本地 hugo 版本，推到 git 仓库后，不出所料 vercel 编译出问题：

Error: add site dependencies: load resources: loading templates: "/vercel/workpath0/themes/meme/layouts/partials/third-party/lunr-search.html:8:1": parse failed: template: partials/third-party/lunr-search.html:8: function "warnf" not defined

解决办法也很简单，hugo 项目的根目录添加 vercel.json 文件，添加以下内容：

{
  "build": {
    "env": {
      "HUGO_VERSION": "0.79.0"
    }
  }
}

更新这个文件后，vercel 恢复正常：

参考：

Build Step - Vercel Documentation

Java 程序启动慢的一些原因

2026-01-01T08:11:41+00:00

一、熵/随机数相关

dd count=50 ibs=1024 if=/dev/random > /dev/null
记录了0+50 的读入
记录了7+1 的写出
3712字节(3.7 kB)已复制，2.57967 秒，1.4 kB/秒

dd count=50 ibs=1024 if=/dev/urandom > /dev/null
#
记录了50+0 的读入
记录了100+0 的写出
51200字节(51 kB)已复制，0.00034067 秒，150 MB/秒

1. 在 Tomcat 环境中解决

catalina.sh 中加入：

-Djava.security.egd=file:/dev/./urandom

2. JVM 环境解决

修改此文件 $JAVA_PATH/jre/lib/security/java.security：

# securerandom.source=file:/dev/urandom
# 替换为以下值：
securerandom.source=file:/dev/./urandom

3. jar 启动命令行

添加以下启动参数：

-Djava.security.egd=file:/dev/./urandom

二、网络原因

未设置 hosts 地址可能造成相关问题：

127.0.0.1 localhost <hostname>.local

freezes when running debug on Mac : IDEA-157303

三、其他

1. 使用性能分析工具

Arthas：Slow Start | Troubleshooting

2. JDK 问题

2.1 执行模式

java 有三种执行模式：

interpreted mode：解释执行模式
compiled mode：编译执行模式
mixed mode：混合模式，会使用 JIT

只建议使用 mixed mode。

2.2 java 运行方式

有 client 方式和 server 方式。64 位只有 server 模式，32 位有两种模式。

只建议使用 server 模式。

2.3 硬件问题

内存
磁盘

JWT 学习和 jjwt 的使用

2026-01-01T08:11:41+00:00

原理

TODO

简单测试

maven 添加以下依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>

encode

java code:

public class TempTest {
    private static final Logger log = LoggerFactory.getLogger(TempTest.class);

    public static void main(String[] args) {
        String keyStr = "Boli's blog website: https://bolitao.xyz";
        Key jwtKey = Keys.hmacShaKeyFor(keyStr.getBytes(StandardCharsets.UTF_8));
        // 自定义 header parameters
        Map<String, Object> headerParams = new HashMap<>(5);
        headerParams.put("kid1", "myKeyId1");
        headerParams.put("kid2", "myKeyId2");
        // 自定义 claims
        Map<String, Object> claims = new HashMap<>(5);
        claims.put("claimKey1", "claimValue1");
        claims.put("claimKey2", "claimValue2");
        String jws = Jwts.builder().setSubject("Hello").setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000))
                .setId(String.valueOf(UUID.randomUUID())).addClaims(claims)
                .signWith(jwtKey).setHeaderParams(headerParams).compact();
        log.info(jws);
    }
}

output:

20:12:52.647 [main] INFO xyz.bolitao.jjwt_test.jjwt.TempTest - eyJraWQxIjoibXlLZXlJZDEiLCJraWQyIjoibXlLZXlJZDIiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJIZWxsbyIsImlhdCI6MTU5Njg4ODgzMSwiZXhwIjoxNTk2ODg4NzcxLCJqdGkiOiI2NDFkZWNlMC1kM2MzLTQ5ZmYtYTZiNy0xNDU5NmNjZDVlMGUiLCJjbGFpbUtleTEiOiJjbGFpbVZhbHVlMSIsImNsYWltS2V5MiI6ImNsYWltVmFsdWUyIn0.p0IXgzrK9yOUu4_QuKJ_0qYX5VKCL5sWEF-zATDmhJA

decode

添加以下代码：

log.info(String.valueOf(Jwts.parserBuilder().setSigningKey(jwtKey).build().parseClaimsJws("eyIxMjMiOiJxd2UiLCJraWQxIjoibXlLZXlJZDIxIiwia2lkMiI6Im15S2V5SWQyIiwiYWxnIjoiSFMyNTYifQ.eyJzdWIiOiJIZWwyMTMyMTMxMjNkbG8iLCJpYXQiOjE1OTY4ODk1ODQsImV4cCI6MTU5Njg5MzE4NCwianRpIjoiOTU2ZGVmM2ItNDJxd2UxZS00N2IxLWFmOTAtODRkN2FjN2NkZWIwIiwiY2xhaW1LZXkxIjoiY2xhaW1WYWx1ZTEiLCJjbGFpbUtleTIiOiJjbGFpbVZhbHVlMiJ9.Ke6mEdcWpzQCdkd_uS4T82oFgR4fM2fMwbvxSa2W2Z4")));

输出：

20:54:00.632 [main] INFO xyz.bolitao.jjwt_test.jjwt.TempTest - header={123=qwe, kid1=myKeyId21, kid2=myKeyId2, alg=HS256},body={sub=Hel213213123dlo, iat=1596889584, exp=1596893184, jti=956def3b-42qwe1e-47b1-af90-84d7ac7cdeb0, claimKey1=claimValue1, claimKey2=claimValue2},signature=Ke6mEdcWpzQCdkd_uS4T82oFgR4fM2fMwbvxSa2W2Z4

常见错误（以下情况不该信任 token）：

过期

这是一个有效期仅为 1s 的 token：

过去数秒后，使用以下代码解析：

log.info(String.valueOf(Jwts.parserBuilder().setSigningKey(jwtKey).build().parseClaimsJws("eyJraWQxIjoibXlLZXlJZDEiLCJraWQyIjoibXlLZXlJZDIiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJIZWxsbyIsImlhdCI6MTU5Njg5MDk5MSwiZXhwIjoxNTk2ODkwOTkyLCJqdGkiOiI2NjI2M2UxMy00ZWZmLTRlZDItODBmYS0wZjZiMzA4Njg5MTEiLCJjbGFpbUtleTEiOiJjbGFpbVZhbHVlMSIsImNsYWltS2V5MiI6ImNsYWltVmFsdWUyIn0.8YmXYlpR6OJ4cxtDRvRVRRSgiQzNMjof904K7_xy4FU")));

会抛出 jwt 时间相关异常：

token 被修改

单独/同时修改 header、payload 或者 signature 都会抛出 JWT 相关的异常。

JJWT 源码

TODO

使用 bucket4j 进行限流

2026-01-01T08:11:41+00:00

使用 bucket4j 进行限流。

bucket4j

介绍

TODO: 令牌桶、算法

用途

TODO

实现

基于注解

参考：Pixiv-Illustration-Collection-Backend。

Maven 依赖：

<dependency>
    <groupId>com.github.vladimir-bukhtoyarov</groupId>
    <artifactId>bucket4j-core</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

注解

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimit {
}

具体实现

@Aspect
@Order(1)
@Component
public class RateLimitProcessor implements HandlerInterceptor {
    private static final Logger logger = LoggerFactory.getLogger(RateLimitProcessor.class);

    /**
     * 最大容积为 2，每三秒生成一个令牌
     */
    private Bucket freeBucket = Bucket4j.builder().addLimit(Bandwidth.classic(2, Refill.intervally(1,
            Duration.ofSeconds(3)))).build();

    /**
     * 在使用 RateLimit 注解的方法上生效
     */
    @Pointcut(value = "@annotation(xyz.bolitao.asynclearn.aop.limit.RateLimit)")
    public void pointCut() {
    }

    @Around(value = "pointCut()")
    public Object handleLimit(ProceedingJoinPoint joinPoint) throws Throwable {
        Bucket requestBucket = this.freeBucket;
        ConsumptionProbe consumptionProbe = requestBucket.tryConsumeAndReturnRemaining(1);
        if (consumptionProbe.isConsumed()) {
            return joinPoint.proceed();
        }
        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body(new RateLimitException(HttpStatus.TOO_MANY_REQUESTS, "请求太频繁"));
    }
}

异常处理

基础异常类 BaseException：

public class BaseException extends RuntimeException {
    private HttpStatus httpStatus;
    private String message;

    public BaseException() {
    }

    public BaseException(HttpStatus httpStatus, String message) {
        this.httpStatus = httpStatus;
        this.message = message;
    }
    // ... 省略 setter、getter、equals 等
}

限流异常类：

public class RateLimitException extends BaseException {
    private HttpStatus httpStatus;
    private String message;

    public RateLimitException(HttpStatus httpStatus, String message) {
        this.httpStatus = httpStatus;
        this.message = message;
    }
    // ... 省略部分
}

Controller

@RestController
public class LimitController {
    @RateLimit
    @GetMapping("/testLimit")
    public ResponseEntity<Object> testLimit() {
        return ResponseEntity.ok().body(new Date());
    }
}

测试

基于 Filter

参考：bucket4j/basic-usage.md at master · vladimir-bukhtoyarov/bucket4j

VMware Workstation 下的 CentOS 使用固定 IP

2026-01-01T08:11:41+00:00

简略写下，有空补充详细。

VMware Workstation

windows

find the VMware Workstation NAT Network Adapter, then change the IPV4 config:

CentOS network config

sudo vi /etc/sysconfig/network-scripts/ifcfg-ens33

content:

TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
BOOTPROTO=static
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=ens33
UUID=7ef0da97-7e3f-4052-85e5-e90c8386167f
DEVICE=ens33
ONBOOT=yes
IPADDR=192.168.11.6
GATEWAY=192.168.11.2
NETMASK=255.255.255.0
DNS1=192.168.11.2

network.service isn't available on CentOS8 by default, so we should use NetworkManager.service and restart it:

sudo systemctl restart NetworkManager
# or use the below command:
# sudo nmcli connection reload

Check either IP is changed:

ip addr

output:

done!

修复 WSL“参考的对象类型不支持尝试的操作”错误

2026-01-01T08:11:41+00:00

同时使用 WSL 2 和 Proxifier 时会出现此问题。

工作需要装了个 Proxifier ，之后发现 WSL 打不开，提示“参考的对象类型不支持尝试的操作”：

搜了下，这个问题常出现在使用游戏加速器和代理的机器。WSL 社区已有相关问题的讨论和解决方案：Winsock module breaks WSL2 · Issue #4177 · microsoft/WSL。

解决办法

下载 proxifier.com/tmp/Test20200228/NoLsp.exe，以管理员身份运行此程序：

.\NoLsp.exe C:\Windows\System32\wsl.exe

提示 success：

会发现注册表 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinSock2\Parameters\AppId_Catalog 下多了项配置：

WSL 恢复正常：

Mybatis Plus 执行 SQL 打印

2026-01-01T08:11:41+00:00

简单的

mybatis-plus:
  mapper-locations: classpath*:/mapper/**Mapper.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

复杂的

依赖

<!-- p6spy -->
<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.1</version>
</dependency>

配置

spring:
  datasource:
    username: bolitao
    password: bolitao
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://127.0.0.1:3306/boliblog?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai

其他

src/main/resources/spy.properties:

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

使用 Typora + PicGo 进行图片上传

2026-01-01T08:11:41+00:00

简略写下，有空补充详细。

new public github repository

new token

PicGo settings

set github and jsdelivr

https://cdn.jsdelivr.net/gh/bolitao/PicRepository

set picgo local server

Typora settings

All done!

自建 bitwarden 服务

2026-01-01T08:11:41+00:00

白嫖的 1Password 到期，该考虑续费或者换用其他服务了。

PS: 在更新这篇文章时，bitwarden_rs wiki 更新了 docker-compose 相关文档，建议使用 docker-compose。

Using Docker Compose · dani-garcia/bitwarden_rs Wiki

换还是不换

很久前就在 V2EX 看过讨论，一般有三大推荐：1Password、KeePass、bitwarden。

1Password：用了一年，体验没有网友说的那么神，可能是因为我不用苹果设备。

KeePass：复杂度高，全平台解决方案需要一点折腾。

bitwarden：分为两派，一派是掏钱买 bitwarden 服务，还有一派是自建 bitwarden。

这三个综合比较下来果然还是对 bw 印象更好：

官方的免费方案足够良心
所有代码都开源，精神可嘉，用得安心
支持自建服务，自建可获得 All Feature 体验

决定自建 bw，官方 C# 写的服务端要求有点高，可能是想上天：

Processor: x64, 2 GHz dual core

Memory: 4 GB RAM (system memory)

Storage: 25 GB

Docker: Engine 19+ and Compose 1.24+

最终选用了社区用 rust 写的 bitwarden_rs。bitwarden_rs 支持 SQLite、MySQL 和 PostgreSQL，如果是自己一人用，SQLite 就好，同时方便备份。

Docker 安装

跟着 bitwarden_rs 文档一路下一步就好。

拉镜像：

sudo docker pull bitwardenrs/server:latest

启动：

sudo docker run -d --name bitwarden \
-v /bw-data/:/data/ \
-p 10080:80 \
bitwardenrs/server:latest

我还添加了一些必要的参数，主要是邮件服务和管理相关：

sudo docker run -d --name bitwarden \
-e SMTP_HOST=smtp.office365.com \
-e SMTP_FROM= \
-e SMTP_PORT=587 \
-e SMTP_SSL=true \
-e SMTP_USERNAME= \
-e SMTP_PASSWORD= \
-e SIGNUPS_ALLOWED=false \
-e ADMIN_TOKEN= \
-v /bw-data/:/data/ \
-p 10080:80 \
bitwardenrs/server:latest

Nginx

Nginx 配置

新建 bw 的 nginx 配置：

sudo vim /etc/nginx/sites-enabled/bw.conf

内容如下：

server {
  server_name pw.bolitao.xyz;

  client_max_body_size 128M;

  location / {
    proxy_pass http://127.0.0.1:10080;
    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;
  }
}

证书

老规矩 certbot 一把梭：

sudo certbot --nginx

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx

Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: pw.bolitao.xyz
2: rss.bolitao.xyz
3: ...
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel):

选中 bw 然后按提示一路下一步就好。

备份

注：以下操作在 root 用户下进行。

创建备份文件夹和脚本：

mkdir /bw-data/bw-backup && vim /root/scripts/bw_backup.sh

内容如下：

#!/bin/bash
SCRIPT_DIR="/root"
NOW=$(date +"%Y%m%d")
TMP_PATH='/tmp'
DROPBOX_DIR="/root/dropbox"
SOURCE_SQLITE_DB="/bw-data/db.sqlite3"                   # bw sqlite3 文件
BACKUP_SQLITE_FILE="/bw-data/bw-backup/backup.sqlite3"   # 使用 sqlite3 的 backup 指令导出的文件
BAK_ARCHIVE_FILE_NAME="bw-$NOW.tar.gz"                   # 上传至 Dropbox 的压缩包文件名
BAK_ARCHIVE_FULL_PATH="$TMP_PATH/$BAK_ARCHIVE_FILE_NAME" # 上传至 Dropbox 压缩包文件

sqlite3 $SOURCE_SQLITE_DB ".backup '$BACKUP_SQLITE_FILE'"
echo "数据库备份完成，打包中..."
tar cfzP "$BAK_ARCHIVE_FULL_PATH" "$BACKUP_SQLITE_FILE"
echo "所有数据打包完成，准备上传..."
# 用脚本上传到dropbox
"$SCRIPT_DIR"/dropbox_uploader.sh upload "$BAK_ARCHIVE_FULL_PATH" "$DROPBOX_DIR/$BAK_ARCHIVE_FILE_NAME"
if [ $? -eq 0 ]; then
    echo "上传完成"
else
    echo "上传失败，重新尝试"
fi

# 删除本地的临时文件，sqlite3 backup 命令的导出文件不用删，下次会覆盖
rm -f "$BAK_ARCHIVE_FULL_PATH"

赋可执行权限：

chmod +x /root/scripts/bw_backup.sh

编辑 crontab 定时任务：

crontab -e

每周三和周日的上午两点进行备份，内容如下：

0 2 * * 0,3 /bin/bash /root/scripts/bw_backup.sh > /dev/null

修改后保存退出。

恢复备份

把备份的文件覆盖掉 /bw-data 下的 db.sqlite3 就好。

参考

Home · dani-garcia/bitwarden_rs Wiki

以二进制包方式手动升级 MySQL

2026-01-01T08:11:41+00:00

虽然我非常反对手动编译或使用 generic 二进制文件安装 Linux 软件包，但我们公司的运维组似乎十分热衷于此，好巧不巧我在运维组工作过几天，接手了升级 MySQL 的活，于是记录一下使用二进制包升级 MySQL 的操作。

1. MySQL 安装包准备

软件压缩包名：

mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz

从 FTP 服务器下载（或随便其他方式拿到二进制包）：

wget -P /mysql/ http://ip:port/path/to/ftp_dir/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz

2. 数据库服务器确认

测试环境服务器：见 Excel 表格
生产环境服务器：见 Excel 表格

3. 数据备份

创建备份文件夹：

mkdir /mysql/dbbackup

备份 MySQL 库：

mysqldump -uroot -p'mysql_password' --master-data=2 -c db_name > /mysql/dbbackup/db_name_20200909.sql

4. 升级前准备

先升级从，再升级主。

4.1 关闭 keepalived

service keepalived stop

4.2 关闭 MySQL

su - //切换到超级用户
service mysql stop

4.3 备份 binlog

mkdir /mysql/log_20200909_bak && cp -pr /mysql/log/* /mysql/log_20200908_bak

5. 正式升级

解压、修改目录名、赋权：

tar -xvf /mysql/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz -C /mysql/service/ && mv /mysql/service/mysql-5.7.31-linux-glibc2.12-x86_64/ /mysql/service/mysql-5.7.31/ && chown -R mysql.mysql /mysql/service/mysql-5.7.31

删除压缩文件

rm /mysql/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz

6. 修改 my.cnf 配置文件

备份旧的配置文件、修改新的配置：

cp /etc/my.cnf /etc/my_5.7.28.cnf && vi /etc/my.cnf

修改以下行：

basedir=/mysql/service/mysql-5.7.31

执行 MySQL 的启动：

/mysql/service/mysql-5.7.31/bin/mysqld --defaults-file=/etc/my.cnf &

检查是否启动：

ps -ef | grep mysqld | grep -v grep

7. 运行 mysql_upgrade 升级数据字典

关闭 MySQL：

/mysql/service/mysql-5.7.31/bin/mysql -uroot -p'mysql_password' --execute="SET GLOBAL innodb_fast_shutdown=0" && /mysql/service/mysql-5.7.31/bin/mysqladmin -uroot -p'mysql_password' shutdown

启动新版 MySQL：

/mysql/service/mysql-5.7.31//bin/mysqld --defaults-file=/etc/my.cnf &

检查兼容性：

/mysql/service/mysql-5.7.31/bin/mysql_upgrade -uroot -p'mysql_password'

检查无误后停止 MySQL：

/mysql/service/mysql-5.7.31/bin/mysqladmin -uroot -p'mysql_password' shutdown

8. 修改启动脚本重启 MySQL

备份原启动脚本、复制新启动脚本：

mv /etc/init.d/mysql /etc/init.d/mysql_20200908 && cp /mysql/service/mysql-5.7.31/support-files/mysql.server /etc/init.d/mysql

修改启动脚本：

vi /etc/init.d/mysql

# 修改内容：
basedir=/mysql/service/mysql-5.7.31/
datadir=/mysql/data/

添加开机启动、启动 MySQL：

chkconfig --add mysql && chkconfig mysql on && service mysql restart

9. 设置环境变量

编辑：

vi /etc/profile

修改 PATH：

/mysql/service/mysql-5.7.31/bin:$PATH

刷新环境变量
```
source /etc/profile
```

10. 验证升级

mysql -V

11. 恢复 keepalived

su - //切换到超级用户
service keepalived restart

12. 主从连接检查

检查 MySQL 主从状态：
```
show slave status\G;
```
检查 keepalived 状态：
```
cat /app/log/keepalived/status
```

MySQL 慢查询排查

2026-01-01T08:11:41+00:00

先简略写写，有时间做详细描述。

查询慢 SQL

查询慢 SQL：

select id, db, user, host, command, time, state, info  FROM information_schema.processlist WHERE command!="Sleep" order by time desc;

如果使用了【双主、主从】之类的同步，忽略前三个最长时间的 process，那是同步用的。

其他两个实用的命令：

/mysql/service/mysql-5.7.28/bin/mysql -u root -p'root$123' -e'select id, db, user, host, command, time, state, info  FROM information_schema.processlist WHERE command!="Sleep" order by time desc\G' > /tmp/20200923-SlowQuery.txt

select concat('kill ', id, ';')  from information_schema.processlist where command != 'Sleep' and time > 10*60 and user='gzsz' order by time desc;

其他

1、查询是否锁表 show OPEN TABLES where In_use > 0;

2、查询进程 show processlist 查询到相对应的进程===然后 kill id

补充：查看正在锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;

查看等待锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCK_WAITS;

SELECT * from information_schema.INNODB_TRX kill trx_mysql_thread_id

可直接在mysql命令行执行：show engine innodb status\G;（只能通过cmd或者shell登录mysql）

查看造成死锁的sql语句，分析索引情况，然后优化sql然后show processlist; show status like ‘%lock%’ show OPEN TABLES where In_use > 0; 这个语句记录当前锁表状态另外可以打开慢查询日志，linux下打开需在my.cnf的[mysqld]里面加上以下内容：

slow_query_log=TRUE(有些mysql版本是ON)

slow_query_log_file=/usr/local/mysql/slow_query_log.txt

long_query_time=3

Windows：

在my.ini配置文件的[mysqld]选项下增加：

slow_query_log=TRUE

slow_query_log_file=c:/slow_query_log.txt

long_query_time=3

添加完成之后记得一定要重启mysql服务才能生效记录输出。微笑最后在MySQL客户端中输入命令：

show variables like '%quer%'; 核查一哈是否Ok

使用 Spring Boot 发送邮件

2026-01-01T08:11:41+00:00

使用 Spring Boot 发送邮件。

依赖

maven 添加以下库：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

配置

spring:
  mail:
    host: # 比如 <smtp.office365.com>
    username: # 比如 <tblsyx@outlook.com>
    password: # 密码
    port: # 比如 <587>
    protocol: # 协议，比如 <smtp>
    default-encoding: utf-8
    test-connection: true
    properties:
      mail:
        smtp:
          connectiontimeout: 10000
          timeout: 10000
          auth: true
          starttls:
            enable: true
            required: true
          socketFactory:
            port: 587
            class: javax.net.ssl.SSLSocketFactory

代码

注入：

/**
 * 邮件发送线程池
 */
private final ExecutorService mailThreadPool;
private final JavaMailSender mailSender;
/**
 * 邮件列表
 */
private LinkedBlockingQueue<Email> mailSendQueue;

@Autowired
public EmailService(@Qualifier("mailSendingExecutorService") ExecutorService mailThreadPool,
                    JavaMailSender mailSender) {
    this.mailThreadPool = mailThreadPool;
    this.mailSender = mailSender;
}

主要实现：

try {
    if (isValidEmailAddres(email.getEmailAddr())) {
        log.info("Sending mail to {}", email.getEmailAddr());
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true,
                String.valueOf(StandardCharsets.UTF_8));
        messageHelper.setFrom("tblsyx@outlook.com");
        messageHelper.setTo(email.getEmailAddr());
        messageHelper.setSubject("Mail from bolitao.xyz");
        messageHelper.setText("<h3>Hello World!</h3>" + email.getContent(), true);
        mailSender.send(mimeMessage);
        log.info("Sent mail to {} success", email.getEmailAddr());
    } else {
        String errorContent = String.format("Wrong email address: %s", email.getEmailAddr());
        log.error(errorContent);
        throw new MessagingException(errorContent);
    }
} catch (MessagingException | InterruptedException e) {
    log.error("Failed to send email", e);
} catch (Exception e) {
    log.error("Failed to send email", e);
}

问题

Outlook 的问题

在测试中，出现以下异常：

2020-12-10 14:47:27.104 ERROR 17816 --- [    mail-pool-4] x.b.java_starter.service.EmailService    : Failed to send email

org.springframework.mail.MailSendException: Failed messages: com.sun.mail.smtp.SMTPSendFailedException: 432 4.3.2 STOREDRV.ClientSubmit; sender thread limit exceeded [Hostname=xxx.xxx.prod.outlook.com]

我使用的是微软的 Outlook 帐号，查了下，还真是微软的问题，有发送限制。Changes in message store and throttling for concurrent connections - Exchange | Microsoft Docs：

The service has various limits to prevent abuse and to ensure fair use. An additional limit is being added. Under the new limit, up to three concurrent connections are allowed to send email messages at the same time.

怎么办？上面的文档给出了三个解决办法。我觉得就第三点有用：换别家的，别用 Outlook toC 用作邮件发送服务。

XXL-job 简记

2026-01-01T08:11:41+00:00

[TOC]

任务调度

项目配置

spring boot 应用配置：

server.port=7888
nacos.config.server-addr=192.168.200.17:20002

配置中心添加以下配置：

# admin 地址
xxl.job.admin.addresses=http://192.168.200.17:20001/xxl-job
# 应用名
xxl.job.executor.appname=job-test
# 端口
xxl.job.executor.port=9999
# 日志保留天数
xxl.job.executor.logretentiondays=30

编码：配置 xxl-job

创建一个 configuration 类，其返回执行器实例：

@Configuration
public class XxlJobConfig {
    private static final Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @NacosValue(value = "${xxl.job.admin.addresses}", autoRefreshed = true)
    String adminAddresses;

    @NacosValue(value = "${xxl.job.executor.appname}", autoRefreshed = true)
    String appName;

    @NacosValue(value = "${xxl.job.executor.port}", autoRefreshed = true)
    int port;

    @NacosValue(value = "${xxl.job.executor.logretentiondays}", autoRefreshed = true)
    int daysCount;

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appName);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setLogRetentionDays(daysCount);
        return xxlJobSpringExecutor;
    }
}

main:

@SpringBootApplication
@NacosPropertySource(dataId = "job_test", groupId = "demo")
public class JobtestApplication {
    public static void main(String[] args) {
        SpringApplication.run(JobtestApplication.class, args);
    }
}

创建任务

java GLUE 模式

先运行 job-executor，日志输出如下表示执行器启动成功：

添加执行器：

添加完执行器后，需要验证执行器是否已注册，有两种方法：

在“执行器管理”界面，可以查看 online 机器：

执行器运行日志中，会输出注册成功的日志：

新增 glue 任务：

点击该任务的 GLUE_IDE 按钮，进入代码编辑器，可以看到默认代码功能为输出 XXL-JOB, Hello World.：

编辑完成后，在任务管理中启动这个定时任务：

之后可在调度日志面板查看任务执行日志：

bean 模式（`@XxlJob` 注解形式）

新增 JobTest 类，添加以下代码：

@Component
public class JobTest {
    private static final Logger logger = LoggerFactory.getLogger(JobTest.class);

    @XxlJob(value = "jobHandler01")
    public ReturnT<String> jobHandler01(String param) {
        XxlJobLogger.log("Hi xxl-job!");
        logger.info("job execute success.");
        return ReturnT.SUCCESS;
    }
}

在任务管理面板添加 jobHandler01 这个 bean 形式的任务：

重启 Java 应用，并在任务管理面板启动刚才新增的任务，job-executor 控制台输出如下：

可在管理面板的调度日志-执行日志中，查看 xxl-job 输出日志：

运行报表

在运行报表面板，可以查看报表：

Dubbo 简记

2026-01-01T08:11:41+00:00

[TOC]

Spring XML 方式

直连方式

provider

添加一个 provider service：

public interface ProviderService {
    String sayHello(String word);
}

实现该接口：

public class ProviderServiceImpl implements ProviderService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

提供 dubbo 配置 provider.xml：

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <dubbo:application name="provider" owner="bolitao"/>
    <dubbo:monitor protocol="registry"/>
    <!--暂不使用注册中心-->
    <dubbo:registry address="N/A"/>
    <dubbo:protocol name="dubbo" port="20880"/>
    <dubbo:service interface="xyz.bolitao.service.ProviderService" ref="providerService"/>
    <bean id="providerService" class="xyz.bolitao.service.ProviderServiceImpl"/>
</beans>

编写 main()：

public static void main(String[] args) throws IOException {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("provider.xml");
    context.start();
    System.in.read();
}

启动 provider，可以看到 dubbo 已开启服务：

文件树如下：

consumer

添加 provider 依赖，consumer 的其余依赖和 provider 一致：

<dependencies>
    <dependency>
        <groupId>xyz.bolitao</groupId>
        <artifactId>provider</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--其他依赖项-->
    ...
</dependencies>

添加 dubbo 配置 consumer.xml，注意调用地址 dubbo://172.16.44.186:20880/xyz.bolitao.service.ProviderService：

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <dubbo:application name="consumer" owner="bolitao"/>
    <dubbo:registry address="N/A"/>
    <dubbo:reference id="providerService" interface="xyz.bolitao.service.ProviderService" url="dubbo://172.16.44.186:20880/xyz.bolitao.service.ProviderService"/>
</beans>

添加 comsumer 的 main() 方法，通过 dubbo 调用 sayHello() 方法：

public static void main(String[] args) throws IOException {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
    context.start();
    ProviderService providerService = (ProviderService) context.getBean("providerService");
    String str = providerService.sayHello("dubbo");
    System.out.println(str);
    System.in.read();
}

运行 consumer 后，可以看到以下信息：

代码文件树如下：

Zookeeper 注册中心方式

provider 修改

修改 provider.xml：

<!--原始值：-->
<dubbo:registry address="N/A"/>

<!--修改为以下值：-->
<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181" check="false"/>

consumer 修改

与 provider 类似，将 dubbo:registry 的 address 值修改为 zk 地址：

<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181" check="false"/>

将 reference 的 URL 删去，consumer 将从 zk 获取服务地址：

<!--原来的 reference 配置：-->
<dubbo:reference id="providerService" interface="xyz.bolitao.service.ProviderService"
                     url="dubbo://172.16.44.186:20880/xyz.bolitao.service.ProviderService"/>

<!--新的 renfence 配置：-->
<dubb:reference interface="xyz.bolitao.service.ProviderService" id="providerService"/>

运行结果

运行 provider：

运行 consumer：

zk 中注册的服务：

Spring 注解配置方式（com.alibaba.dubbo）

provider

ProviderServiceAnnotation 类：

public interface ProviderServiceAnnotation {
    String sayHelloAnnotation(String name);
}

ProviderServiceImplAnnonation 类，使用 dubbo 提供的 @Service 注解进行声明：

@Service(timeout = 5000)
public class ProviderServiceImplAnnonation implements ProviderServiceAnnotation {
    @Override
    public String sayHelloAnnotation(String name) {
        return "Hello, " + name;
    }
}

DubboConfiguration 配置类：

@Configuration
@EnableDubbo(scanBasePackages = "xyz.bolitao.service.annotation")
public class DubboConfiguration {
    @Bean
    public ProviderConfig providerConfig() {
        ProviderConfig providerConfig = new ProviderConfig();
        providerConfig.setTimeout(1000);
        return providerConfig;
    }

    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-annotation-provider");
        return applicationConfig;
    }

    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setProtocol("zookeeper");
        registryConfig.setAddress("localhost");
        registryConfig.setPort(2181);
        return registryConfig;
    }

    @Bean
    public ProtocolConfig protocolConfig() {
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20880);
        return protocolConfig;
    }
}

运行如下：

代码文件树如下：

consumer

添加 ConsumerAnnotationService，用以替代 XML 形式配置中的 dubb:reference interface：

@Component("annotatedConsumer")
public class ConsumerAnnotationService {
    @Reference
    private ProviderServiceAnnotation providerServiceAnnotation;

    public String doSayHello(String content) {
        return providerServiceAnnotation.sayHelloAnnotation(content);
    }
}

添加一个配置类 DubboConsumerConfiguration：

@Configuration
@EnableDubbo(scanBasePackages = "xyz.bolitao.consumer.annotation")
@ComponentScan(value = "xyz.bolitao.consumer.annotation")
public class DubboConsumerConfiguration {
    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-annotation-consumer");
        Map<String, String> stringStringMap = new HashMap<>(5);
        stringStringMap.put("qos.enable", "true");
        stringStringMap.put("qos.accept.foreign.ip", "true");
        stringStringMap.put("qos.port", "22221");
        applicationConfig.setParameters(stringStringMap);
        return applicationConfig;
    }

    @Bean
    public ConsumerConfig consumerConfig() {
        ConsumerConfig consumerConfig = new ConsumerConfig();
        consumerConfig.setTimeout(3000);
        return consumerConfig;
    }

    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setProtocol("zookeeper");
        registryConfig.setAddress("localhost");
        registryConfig.setPort(2181);
        return registryConfig;
    }
}

编写 consumer main 方法：

public static void main(String[] args) {
    AnnotationConfigApplicationContext context =
        new AnnotationConfigApplicationContext(DubboConsumerConfiguration.class);
    context.start();
    ConsumerAnnotationService consumerAnnotationService = context.getBean(ConsumerAnnotationService.class);
    System.out.println(consumerAnnotationService.doSayHello("dubbo"));
}

运行结果如下：

目录树如下：

总结：使用 Spring 时，该方法还不如 xml 方式简洁。

Spring Boot 方式（dubbo-spring-boot-starter）

alibaba 的 spring boot starter 已经不维护，apache 继续维护的 starter GitHub 页为：apache/dubbo-spring-boot-project: Spring Boot Project for Apache Dubbo。这里使用 Apache 维护的 starter。

API

建立一个 API model，只写一个接口：

public interface TestService {
    public String doSth(String content);
}

代码目录树如下：

provider

新建一个 starter_provider 模块，添加依赖如下：

<dependency>
    <groupId>xyz.bolitao</groupId>
    <artifactId>api</artifactId><!--该包为上节添加的 api 模块-->
    <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.6.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.3</version>
</dependency>

修改 springboot 启动配置如下：

server.port=10010
dubbo.application.id=provider
dubbo.application.name=provider
dubbo.registry.address=zookeeper://192.168.200.1:2181
dubbo.provider.threads=10
dubbo.provider.threadpool=fixed
dubbo.provider.loadbalance=roundrobin
dubbo.server=true
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

之后实现 TestService 接口，注意 @Service 注解不由 spring 提供，而使用 org.apache.dubbo.config.annotation 包：

@Service(version = "1.0.0")
public class TestServiceImpl implements TestService {
    private static final Logger logger = LoggerFactory.getLogger(Application.class);

    @Override
    public String doSth(String content) {
        logger.info("provider 服务被调用");
        return "Hello, " + content;
    }
}

在 main 方法外，添加 @DubboComponentScan 注解，指定 dubbo 扫描的包位置：

@SpringBootApplication
@DubboComponentScan(basePackages = "xyz.bolitao.starter_provider.service.impl")
public class StarterProviderApplication {
    public static void main(String[] args) {
        ...

代码目录树如下：

consumer

新建 starter-consumer module，创建 module 时勾选 web starter 依赖，并添加刚才自己创建的 api 和 starter_provider 模块：

<dependency>
    <groupId>xyz.bolitao</groupId>
    <artifactId>api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
    <groupId>xyz.bolitao</groupId>
    <artifactId>starter_provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
...
<!--还需添加和 provider 一样的 dubbo、zk 相关依赖-->

修改 Spring Boot 应用配置：

server.port=10011
dubbo.application.id=consumer
dubbo.application.name=consumer
dubbo.registry.address=zookeeper://192.168.200.1:2181
dubbo.consumer.check=true

添加一个 REST controller，用于远程调用 provider 的方法：

@RestController
@RequestMapping("test")
public class TestController {
    @Reference(version = "1.0.0")
    private TestService testService;

    @GetMapping("{content}")
    public String test(@PathVariable String content) {
        return testService.doSth(content);
    }
}

代码文件树如下：

运行效果

依次运行 provider 和 consumer，访问 consumer 提供的 127.0.0.1:10011/test/{content} 页面：

provider 控制台有以下内容输出：

工作中 CentOS 的一些笔记 03

2026-01-01T08:11:41+00:00

工作中 CentOS 的一些笔记 03，其实大部分都是 Linux 通用。

[TOC]

Elasticsearch

安装

下载压缩版的 es 并解压运行：

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.8.0-linux-x86_64.tar.gz # 下载
tar -xzvf elasticsearch-7.8.0-linux-x86_64.tar.gz # 解压

# 编辑 .bashrc，添加以下 ES 环境变量：
export ES_PATH="/home/bolitao/apps/elasticsearch-7.8.0"
export PATH=$ES_PATH/bin:$PATH

es 启动过程可能会出现以下错误：

max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]
[2]: the default discovery settings are unsuitable for production use; at least one of [discovery.seed_hosts, discovery.seed_providers, cluster.initial_master_nodes] must be configured

进行以下设置：

vim config/elasticsearch.yml 

# 设置以下行
network.host: 0.0.0.0
# 取消注释以下行：
node.name: node-1
# 添加以下行：
cluster.initial_master_nodes: ["node-1"]

sudo vim /etc/sysctl.conf
# 添加以下行；
vm.max_map_count=655360

# 加载参数：
sudo sysctl -p

放行防火墙端口：

sudo firewall-cmd --zone=public --permanent --add-port=5601/tcp # kibana 端口
sudo firewall-cmd --zone=public --permanent --add-port=9200/tcp # es 通信端口
sudo firewall-cmd --reload

运行 es：

./elasticsearch-7.8.0-linux-x86_64./bin/elasticsearch

验证 ES 运行状态：

curl 192.168.188.130:9200


StatusCode        : 200
StatusDescription : OK
Content           : {
                      "name" : "node-1",
                      "cluster_name" : "elasticsearch",
                      "cluster_uuid" : "Qse9DW45TE2XhdsUfvk2fg",
                      "version" : {
                        "number" : "7.8.0",
                        "build_flavor" : "default",
                        "build_type" : "tar"...
RawContent        : HTTP/1.1 200 OK
...

Kibana 是 Elasticsearch 的数据可视化和管理工具，安装如下：

wget https://artifacts.elastic.co/downloads/kibana/kibana-7.8.0-linux-x86_64.tar.gz # 下载
tar -xzvf kibana-7.8.0-linux-x86_64.tar.gz # 解压


# 在 .bashrc 添加如下环境变量：
export KIBANA_PATH="/opt/kibana"
export PATH=$KIBANA_PATH/bin:$PATH

允许远程访问：

vim kibana-7.8.0-linux-x86_64/config/kibana.yml

# 设置以下行并重启 kibana
server.host: "0.0.0.0"

验证 Kibana 运行状态：

PostgreSQL

安装

根据 PostgreSQL 官方文档 PostgreSQL: Linux downloads (other)，二进制压缩包和 EDB 安装器方式都不再提供 10 以后的版本：

官方推荐使用对应发行版的包管理器进行安装，对于 RedHat 系发行版，按以下步骤安装 PostgreSQL 12：

sudo yum install https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm # 导入 pgsql 软件仓库
sudo yum install postgresql12-server # 安装 pgsql 12
sudo /usr/pgsql-12/bin/postgresql-12-setup initdb # 初始化 DB
# 以下是命令对应的输出：
Initializing database ... OK

sudo systemctl start postgresql-12 # 启动 pgsql
sudo systemctl status postgresql-12 # 查看 pgsql 运行状态
# 以下是命令对应的输出：
● postgresql-12.service - PostgreSQL 12 database server
   Loaded: loaded (/usr/lib/systemd/system/postgresql-12.service; disabled; vendor preset: disabled)
   Active: active (running) since 一 2020-07-13 09:20:55 CST; 7s ago
     Docs: https://www.postgresql.org/docs/12/static/
  Process: 2476 ExecStartPre=/usr/pgsql-12/bin/postgresql-12-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
 Main PID: 2482 (postmaster)
    Tasks: 8
   Memory: 18.0M
   CGroup: /system.slice/postgresql-12.service
           ...

配置 pgsql 密码：

sudo su - postgres
psql -c "alter user postgres with password '123'" # 设置 postgres 密码为 123

允许远程访问：

sudo vim /var/lib/pgsql/12/data/postgresql.conf
# 修改以下字段
listen_addresses = '*'

sudo vim /var/lib/pgsql/12/data/pg_hba.conf
# 文件末尾添加以下行：
host all all 0.0.0.0/0 md5
# 修改以下行，将 peer 改为 md5
local   all             all                                     md5

sudo systemctl restart postgresql-12 # 重启服务

配置防火墙，放行 pgsql 相关服务：

sudo firewall-cmd --add-service=postgresql12 --permanent --zone=public
sudo firewall-cmd --reload # 重载防火墙

在宿主机使用 psql 命令行访问虚拟机的 PostgreSQL：

PS C:\Users> psql -h 192.168.188.130 -W -U postgres -p 5432
口令：
psql (12.3)
输入 "help" 来获取帮助信息.

postgres=#

控制访问文件说明

ident：通过联系客户端上的ident服务器获取客户端的操作系统用户名，并检查它是否与请求的数据库用户名匹配。 Ident 身份验证只能用于 TCP / IP 连接，为本地连接指定时，将使用对等身份验证
peer：从操作系统获取客户端的操作系统用户名，并检查它是否与请求的数据库用户名匹配，仅适用于本地连接
md5：执行 SCRAM-SHA-256 或 MD5 身份验证以验证用户的密码。

Linux 额外学习

journalctl

从尾部滚动查看 systemd 日志：sudo journalctl -f。

查看某个由 systemd 管理的服务的日志：sudo journalctl --unit xxx。

比如查看 Tengine 的日志：

➜ sudo journalctl --unit nginx
-- Logs begin at 一 2020-07-13 08:21:13 CST, end at 一 2020-07-13 08:42:21 CST. --
7月 13 08:21:21 localhost.localdomain systemd[1]: Starting Tengine/nginx...
7月 13 08:21:21 localhost.localdomain nginx[1195]: nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
7月 13 08:21:21 localhost.localdomain nginx[1195]: nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
7月 13 08:21:21 localhost.localdomain systemd[1]: Started Tengine/nginx.

查看错误时常用的 sudo journalctl -xe 方法：-x 表示提供有用的帮助，-e 表示从尾部开始读。

PostgreSQL 补充

数据备份和恢复

PostgreSQL 官方提供的备份 cli 工具是 pg_dump，数据恢复工具是 pg_restore。

备份库：

pg_dump -U bolitao testdb > test.sql # 将 testdb 库的数据备份至 test.sql 文件

备份特定表（-t 参数）：

pg_dump -U bolitao -t user_tb testdb > user_tb.sql # 将 testdb 的 user_tb 表数据备份至 user_tb.sql 文件

恢复数据（使用 psql）：

psql -U postgres -d testdb2 -f test.sql # 将 test.sql 备份的库数据恢复到 testdb2 库
psql -U postgres -d testdb2 -f user_tb.sql # 将备份的表数据恢复到 testdb2 库

FastDFS

单机模式安装

安装编译和运行依赖：

sudo yum install git gcc gcc-c++ make automake autoconf libtool pcre pcre-devel zlib zlib-devel openssl-devel wget vim -y

安装 libfastcommon：

cd /usr/local/src
sudo git clone https://github.com/happyfish100/libfastcommon.git --depth 1
cd libfastcommon
sudo ./make.sh # 编译
sudo ./make.sh install # 安装

安装 FastDFS：

cd ..
sudo git clone https://github.com/happyfish100/fastdfs.git --depth 1
cd fastdfs
sudo ./make.sh && sudo ./make.sh install # 编译并安装
# 配置文件准备
sudo cp /etc/fdfs/tracker.conf.sample /etc/fdfs/tracker.conf
sudo cp /etc/fdfs/storage.conf.sample /etc/fdfs/storage.conf
sudo cp /etc/fdfs/client.conf.sample /etc/fdfs/client.conf # 客户端文件，测试用
sudo cp /usr/local/src/fastdfs/conf/http.conf /etc/fdfs/ # 供 nginx 访问使用
sudo cp /usr/local/src/fastdfs/conf/mime.types /etc/fdfs/ # 供 nginx 访问使用

为 nginx 编译 fastDFS插件：

# 下载插件
cd ~/source
git clone https://github.com/happyfish100/fastdfs-nginx-module.git --depth 1
sudo cp fastdfs-nginx-module/src/mod_fastdfs.conf /etc/fdfs

# 重新编译 Tengine
cd /home/bolitao/tengine-2.3.2

# 设置编译选项，新增 fastdfs 插件
./configure --user=app \
--group=app \
--with-jemalloc=/home/bolitao/jemalloc-5.2.1 \
--add-module=./modules/ngx_http_upstream_check_module \
--add-module=/home/bolitao/source/fastdfs-nginx-module/src

make

停止并重新安装 Tengine：

sudo systemctl stop nginx
sudo make install

# 查看 nginx 信息，检查是否有 FastDFS 插件
➜  tengine-2.3.2 sudo /usr/local/nginx/sbin/nginx -V
Tengine version: Tengine/2.3.2
...
configure arguments: --user=app --group=app --with-jemalloc=/home/bolitao/jemalloc-5.2.1 --add-module=./modules/ngx_http_upstream_check_module --add-module=/home/bolitao/source/fastdfs-nginx-module/src

修改 tracker 配置：

sudo vim /etc/fdfs/tracker.conf

# 修改以下内容
port=22122  # tracker 服务器端口
base_path=/home/dfs  # 存储日志和数据的根目录

修改 storage 配置：

sudo vim /etc/fdfs/storage.conf

# 修改以下内容
port=23000  # storage 服务端口
base_path=/home/dfs  # 数据和日志文件存储根目录
store_path0=/home/dfs  # 第一个存储目录
tracker_server=192.168.15.130:22122  # tracker 服务器 IP 和端口
http.server_port=8888  # http 访问文件的端口（和 nginx 中保持一致）

防火墙放行：

sudo firewall-cmd --zone=public --permanent --add-port=22122/tcp
sudo firewall-cmd --zone=public --permanent --add-port=23000/tcp
sudo firewall-cmd --zone=public --permanent --add-port=8888/tcp
sudo firewall-cmd --reload

启动 tracker 和 storage：

sudo /etc/init.d/fdfs_trackerd start
sudo /etc/init.d/fdfs_storaged start

测试客户端：

sudo vim /etc/fdfs/client.conf

# 修改以下内容
base_path=/home/dfs
tracker_server=192.168.15.130:22122    # tracker 服务器 IP 和端口

# 进行文件上传测试
➜ sudo fdfs_upload_file /etc/fdfs/client.conf /home/bolitao/apps/apache-tomcat-9.0.37/BUILDING.txt
group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt

上传文件后数据保存路径如下图所示：

配置 nginx 访问：

sudo vim /etc/fdfs/mod_fastdfs.conf

# 修改以下内容：
tracker_server=192.168.15.130:22122
url_have_group_name=true
store_path0=/home/dfs

# 配置 nginx：
sudo vim /usr/local/nginx/conf/nginx.conf

# 添加以下配置：
server {
    listen       8888;    ## 该端口和 storage.conf 中的 http.server_port 相同
    server_name  localhost;
    location ~/group[0-9]/ {
        ngx_fastdfs_module;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    root   html;
    }
}

sudo /usr/local/nginx/sbin/nginx -t # 测试 nginx 配置无误
sudo systemctl restart nginx.service # 重启 Tengine

测试：通过宿主机访问刚在上传的文件（地址为 http://192.168.188.130:8888/group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt ），发现如下图所示（如果是二进制文件则会直接弹出下载）：

集群安装和配置

修改三台机器的 tracker 配置：

sudo vim /etc/fdfs/tracker.conf

# 修改以下内容
port=22122  # tracker 服务器端口
base_path=/home/dfs  # 存储日志和数据的根目录

修改三台机器的 storage 配置：

sudo vim /etc/fdfs/storage.conf

# 修改以下配置
tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122
port=23000
base_path=/home/dfs
store_path0=/home/dfs
http.server_port=8888

重启 tracker 和 storage 服务，检查是否 storage 服务器是否登记到 tracker：

sudo /etc/init.d/fdfs_trackerd restart # 重启 tracker 服务
sudo /etc/init.d/fdfs_storaged restart # 重启 storage 服务

sudo /usr/bin/fdfs_monitor /etc/fdfs/storage.conf # 检查服务状态
# 以下是输出，省略部分非关键信息
...
tracker server is 192.168.15.132:22122

group count: 1

Group 1:
group name = group1
...
        Storage 1:
                id = 192.168.15.130
                ip_addr = 192.168.15.130  ACTIVE
                http domain =
                version = 6.06
                join time = 2020-07-14 10:08:26
                up time = 2020-07-14 15:57:34
...
        Storage 2:
                id = 192.168.15.131
                ip_addr = 192.168.15.131  ACTIVE
                http domain =
                version = 6.06
...
        Storage 3:
                id = 192.168.15.132
                ip_addr = 192.168.15.132  ACTIVE
                http domain =
                version = 6.06

可以看到三台存储服务器都处于激活状态，多运行几次 fdfs_monitor 命令会发现 tracker server 有所变换，即多个 tracker 的切换功能也是生效的。

测试 client，修改 client 配置文件：

sudo vim /etc/fdfs/client.conf

# 需要修改的内容如下：
base_path=/home/moe/dfs
tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122

测试 client 文件上传：

fdfs_upload_file /etc/fdfs/client.conf /home/bolitao/apps/screenfetch/screenfetch-dev
# 返回上传的文件位置和文件名：
group1/M00/00/00/wKgPgl8Nau-AcXEFAAPBDqCqwtI9997099

由于三台 storage 处于同一 group，组内文件互备，所以可以在三台存储服务器中发现上传的文件：

ls -l /home/dfs/data/00/00 # 列出文件
# 以下是命令输出：
-rw-r--r-- 1 root root 246030 7月  14 16:21 wKgPgl8Nau-AcXEFAAPBDqCqwtI9997099

配置 nginx 访问，修改服务器的 /etc/fdfs/mod_fastdfs.conf 文件：

tracker_server = 192.168.15.130:22122
tracker_server = 192.168.15.131:22122
tracker_server = 192.168.15.132:22122
url_have_group_name=true
store_path0=/home/dfs

在 nginx 中添加以下 server：

server {
    listen       8888;    ## 该端口为storage.conf中的http.server_port相同
    server_name  localhost;
    location ~/group[0-9]/ {
        ngx_fastdfs_module;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    root   html;
    }
}

备注：这里配置了三台服务器既作 tracker 服务器也作存储服务器。实际运用时更多情况是将 tracker 和 storage 划分，tracker 用作负载均衡和调度，storage 用来存储，如下图所示：

基本操作

tracker 服务管理：

sudo /etc/init.d/fdfs_trackerd start # 启动 tracker 服务
sudo /etc/init.d/fdfs_trackerd restart # 重启动 tracker 服务
sudo /etc/init.d/fdfs_trackerd stop # 停止 tracker 服务
sudo chkconfig fdfs_trackerd on # 自启动 tracker 服务

storage 服务管理：

sudo /etc/init.d/fdfs_storaged start # 启动 storage 服务
sudo /etc/init.d/fdfs_storaged restart # 重启 storage 服务
sudo /etc/init.d/fdfs_storaged stop # 停止 storage 服务
sudo chkconfig fdfs_storaged on # 自启动 storage 服务

检查集群（会输出所有服务器的信息）：

sudo /usr/bin/fdfs_monitor /etc/fdfs/storage.conf
# 以下是命令输出：
[sudo] bolitao 的密码：
[2020-07-14 10:24:49] DEBUG - base_path=/home/dfs, connect_timeout=5, network_timeout=60, tracker_server_count=1, anti_steal_token=0, anti_steal_secret_key length=0, use_connection_pool=1, g_connection_pool_max_idle_time=3600s, use_storage_id=0, storage server id count: 0

server_count=1, server_index=0

tracker server is 192.168.188.130:22122

group count: 1

Group 1:
group name = group1
disk total space = 48,096 MB
disk free space = 44,515 MB
trunk free space = 0 MB
storage server count = 1
active server count = 1
storage server port = 23000
storage HTTP port = 8888
store path count = 1
subdir count per path = 256
current write server index = 0
current trunk file id = 0
...

上传：使用 fdfs_upload_file 命令，命令跟的第一个参数表示客户端配置文件，第二个参数表示要上传的文件，比如：
```
sudo fdfs_upload_file /etc/fdfs/client.conf /home/bolitao/apps/apache-tomcat-9.0.37/BUILDING.txt
```
下载：使用 fdfs_download_file 命令进行下载，第一个参数是客户端配置文件，第二个参数是要下载的文件，比如：
```
fdfs_download_file /etc/fdfs/client.conf group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt
```

删除：使用 fdfs_delete_file 命令进行文件删除，第一个参数是配置文件，第二个参数是要删除的文件，比如：

fdfs_delete_file /etc/fdfs/client.conf group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt

# 再次下载该文件
fdfs_download_file /etc/fdfs/client.conf 
group1/M00/00/00/wKi8gl8NE5yAFQc7AABKJvC0Vqw094.txt
# 提示文件不存在
[2020-07-14 10:39:16] ERROR - file: tracker_proto.c, line: 50, server: 192.168.188.130:23000, response status 2 != 0
[2020-07-14 10:39:16] ERROR - file: ../client/storage_client.c, line: 598, fdfs_recv_header fail, result: 2
download file fail, error no: 2, error info: No such file or directory

设置多个组：

修改 /etc/fdfs/storage.conf 文件中：
- store_path_count 的值
- 新增 store_path，比如 store_path1、store_path2

修改 mod_fastdfs.conf 文件：

store_path_count 的值
store_pathx 的值

仿照 group 添加更多 group，比如：

[group1]
group_name=group1
storage_server_port=23000
store_path_count=3
store_path0=/home/dfs/data/group1/M00
store_path1=/home/dfs/data/group1/M01

[group2]
group_name=group2
storage_server_port=23000
store_path_count=3
store_path0=/home/dfs/data/group2/M00
store_path1=/home/dfs/data/group2/M01

修改 nginx 反向代理配置：

location ~/group[0-9]/M00 {
    root /home/dfs/data/group1
    ngx_fastdfs_module;
}

location ~/group[0-9]/M01 {
    root /home/dfs/data/group2
    ngx_fastdfs_module;
}

Kafka

安装（单机模式）

下载并解压：

wget https://mirror.bit.edu.cn/apache/kafka/2.5.0/kafka_2.12-2.5.0.tgz
tar -xzf kafka_2.12-2.5.0.tgz
cd kafka_2.12-2.5.0

修改 Kafka 配置，允许删除 topic：

vim config/server.properties

# 修改/在文件末添加如下行：
delete.topic.enable = true

为当前用户添加环境变量：

vim ~/.bashrc # 或者是 ~/.zshrc

# 添加以下内容：
export KAFKA_PATH="/home/bolitao/apps/kafka_2.12-2.5.0"
export PATH=$KAFKA_PATH/bin:$PATH

# 刷新
source ~/.bashrc

将 Kafka 注册为系统服务：

sudo vim /etc/systemd/system/kafka.service

# systemd 配置文件内容
[Unit]
Requires=zookeeper.service
After=zookeeper.service

[Service]
Type=simple
User=bolitao
ExecStart=/bin/sh -c '/home/bolitao/apps/kafka_2.12-2.5.0/bin/kafka-server-start.sh /home/bolitao/apps/kafka_2.12-2.5.0/config/server.properties > /home/bolitao/apps/kafka_2.12-2.5.0/logs/kafka.log 2>&1'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

启动 ZooKeeper：

sudo systemctl start zookeeper.service

启动 Kafka 服务：

sudo systemctl start kafka # 启动服务
sudo journalctl -u kafka # 查看 kafka 启动日志
less /home/bolitao/apps/kafka_2.12-2.5.0/logs/kafka.log # 查看 kafka 运行日志

集群安装和操作

为了便于操作，本节使用单机多实例方式进行集群操作。

设置多份配置文件

cp server.properties server-1.properties
cp server.properties server-2.properties

配置文件内容分别设置如下：

# server-1 的配置
broker.id=1
listeners=PLAINTEXT://:9093
log.dirs=/tmp/kafka-logs-1

# server-2 的配置
broker.id=2
listeners=PLAINTEXT://:9094
log.dirs=/tmp/kafka-logs-2

启动新的两个 Kafka 实例

kafka-server-start.sh ./server-1.properties
kafka-server-start.sh ./server-2.properties

加上上一步，共有 3 个 kafka 实例，之后创建一个 replication-factor 为 3 的 Topic，topic 名为 my-replicated-topic：

kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 3 --partitions 1 --topic my-replicated-topic
# 以下是命令输出：
Created topic my-replicated-topic.

查看 9092 端口的 my-replicated-topic 描述：
```
kafka-topics.sh --describe --bootstrap-server localhost:9092 --topic my-replicated-topic
# 以下是命令输出：
Topic: my-replicated-topic      PartitionCount: 1       ReplicationFactor: 3    Configs: segment.bytes=1073741824
        Topic: my-replicated-topic      Partition: 0    Leader: 1       Replicas: 1,0,2 Isr: 1,0,2
```
leader 负责给定分区的所有读写操作的节点，在上面的输出中可以看到 ldeade 为 1。

replicas 是复制的节点列表，主节点也会在这个列表里。

isr 全意 "in-sync" replicas，正常运行且同步状态已和 leader 一致的 replicas 将会出现在 isr 列表。partition leader 的重新选举操作会在 isr 节点中进行。

使用生产者发布一些信息：

kafka-console-producer.sh --bootstrap-server localhost:9092 --topic my-replicated-topic

>my test message 1
>my test message 2

使用消费者查看信息：

kafka-console-consumer.sh --bootstrap-server localhost:9092 --from-beginning --topic my-replicated-topic

my test message 1
my test message 2

测试集群容错性，杀死刚才作为 leader、id 为 1 的 kafka 进程：

ps aux | grep server-1.propertie
bolitao    3691  2.4 21.7 4747716 404952 pts/0  Sl+  14:50   0:37 /usr/lib/jvm/jdk1.8.0_251/bin/java...
...

kill -9 3691

之后再次查看 my-replicated-topic 的描述：

kafka-topics.sh --describe --bootstrap-server localhost:9092 --topic my-replicated-topic
# 以下是命令行输出：
Topic: my-replicated-topic      PartitionCount: 1       ReplicationFactor: 3    Configs: segment.bytes=1073741824
        Topic: my-replicated-topic      Partition: 0    Leader: 0       Replicas: 1,0,2 Isr: 0,2

可以看到 Leader 已被选举为 0，Isr 中 1 已掉线，目前跟上同步进度且仍存活的节点为 0 和 2

重新运行消费者，使用 --from-beginning 选项从头消费数据，可以看到即使之前 id 为 1 的主节点下线，消费者仍能够获取信息，没有造成数据丢失：
```
kafka-console-consumer.sh --bootstrap-server localhost:9092 --from-beginning --topic my-replicated-topic


my test message 1
my test message 2
```

其他基本操作

创建一个 topic：

kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TestTopic
# 输出如下：
Created topic TestTopic.

生产者发布一条 string 到 TestTopic：

echo "Hello, World" | kafka-console-producer.sh --broker-list localhost:9092 --topic TestTopic > /dev/null

消费者处理一条消息，使用 --from-beginning 选项可以让消费者获取之前 Topic 的消息：

kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic TestTopic --from-beginning

# 会有如下输出：
Hello, World

# 当使用 CTRL+C 停止该消费者时，会提示共处理了 TestTopoc 中的消息条数：
Processed a total of 1 messages

网络

netstat

--numeric , -n
    Show numerical addresses instead of trying to determine symbolic host, port or user names.
-l, --listening
    Show only listening sockets.  (These are omitted by default.)
-p, --program
    Show the PID and name of the program to which each socket belongs.
--udp, -u
--tcp, -t
-a, --all
	Show both listening and non-listening (for TCP this means established connections) sockets. With the --interfaces  option, show interfaces that are not up
-o, --timers
	Include information related to networking timers.

netstat -nlptp | grep port：

查看状态为 listening 的 TCP、UDP 连接。

netstat -nlptu | grep 3306
tcp6       0      0 :::3306                 :::*                    LISTEN      2910/mysqld

netstat -ap | grep appName：

查看某应用占用的端口。

netstat -ap | grep mysql
tcp   6247793      0 localhost.localdo:43546 172.18.20.105:mysql     ESTABLISHED 2910/mysqld
tcp6       0      0 [::]:mysql              [::]:*                  LISTEN      2910/mysqld
tcp6       0      0 localhost.localdo:mysql 172.18.20.105:6858      ESTABLISHED 2910/mysqld
tcp6       0      0 localhost.localdo:58079 172.18.20.105:mysql     ESTABLISHED 17100/java
unix  2      [ ACC ]     STREAM     LISTENING     20294    2910/mysqld          /tmp/mysql.sock

netstat -an | grep port：

查看某端口的使用情况。

netstat -an | grep 3306
tcp   6247793      0 172.18.20.106:43546     172.18.20.105:3306      ESTABLISHED
tcp6       0      0 :::3306                 :::*                    LISTEN
tcp6       0      0 172.18.20.106:3306      172.18.20.105:6858      ESTABLISHED
tcp6       0      0 172.18.20.106:58079     172.18.20.105:3306      ESTABLISHED

ss

-t, --tcp
	Display TCP sockets.
-u, --udp
	Display UDP sockets.
-a, --all
	Display both listening and non-listening (for TCP this means established connections) sockets.
-n, --numeric
    Do not try to resolve service names.
-l, --listening
    Display only listening sockets (these are omitted by default).
-p, --processes
    Show process using socket.

ss -atu
ss -nlptu
ss -ap
ss -np

lsof

Redis

Cluster

/app/soft/redis-5.0.5/bin/redis-cli -a password@redis --cluster create 172.18.20.116:6379 172.18.20.117:6379 172.18.20.118:6379 --cluster-replicas 0

工作中 CentOS 的一些笔记 02

2026-01-01T08:11:41+00:00

工作中 CentOS 的一些笔记 02，其实大部分都是 Linux 通用。

[toc]

Tengine

安装 Tengine

安装编译环境：

sudo yum -y install gcc gcc-c++ autoconf automake

安装 PCRE：

sudo yum install pcre pcre-static

通过包管理器安装 OpenSSL（yum 源默认 openssl 版本较老，要使用更新版本特性可以手动拉取源码编译安装）：

sudo yum install openssl openssl-static

拉取 jemalloc 源码：

wget 192.168.188.1:8000/jemalloc-5.2.1.tar.bz2 # 拉取代码
sudo yum -y install bzip2 # 安装 bzip2 支持库
tar -xvjf jemalloc-5.2.1.tar.bz2 # 解压

设置用户组和目录：

sudo groupadd -r app # 添加 app 组
sudo useradd -g app -r app # 添加 app 用户，其组为 app

下载 tengine 源码并解压：

wget https://tengine.taobao.org/download/tengine-2.3.2.tar.gz # 下载
tar xzf tengine-2.3.2.tar.gz # 解压

进行 makefile 文件的编译配置，指定用户为 app，组为 app，设置 jemalloc 源码路径，Tengine 可以静态编译和链接该库：

./configure --user=app \
--group=app \
--with-jemalloc=/home/bolitao/jemalloc-5.2.1

编译配置概述如下：

进行编译和安装：

make
sudo make install

查看安装是否成功：

➜  tengine-2.3.2 sudo /usr/local/nginx/sbin/nginx -V # 查看版本
Tengine version: Tengine/2.3.2
nginx version: nginx/1.17.3
built by gcc 4.8.5 20150623 (Red Hat 4.8.5-39) (GCC)
built with OpenSSL 1.0.2k-fips  26 Jan 2017
TLS SNI support enabled
configure arguments: --user=app --group=app --with-jemalloc=/home/bolitao/jemalloc-5.2.1
➜  tengine-2.3.2 sudo /usr/local/nginx/sbin/nginx -t # 测试配置是否正常
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

配置 Tengine

配置 systemd 服务：

sudo vim /usr/lib/systemd/system/nginx.service

nginx.service 内容如下：

[Unit]
Description=Tengine/nginx
Documentation=https://nginx.org/en/docs/
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStartPre=/usr/local/nginx/sbin/nginx -t
ExecStart=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

[Install]
WantedBy=multi-user.target

修改 tengine 配置文件，取消注释 user 行，修改 user 为 app：

sudo vim /usr/local/nginx/conf/nginx.conf

# nginx.conf 中 user 字段修改如下：
user  app;

修改 systemd 相关权限，配置开机自启动等功能：

sudo chmod 745 /usr/lib/systemd/system/nginx.service # 修改权限
sudo systemctl daemon-reload # 重载 systemd
sudo systemctl start nginx.service # 启动 Tengine 服务
sudo systemctl enable nginx.service # 允许开机自启动

使用 sudo systemctl status nginx.service 查看运行状态：

➜  tengine-2.3.2 sudo systemctl status nginx.service
● nginx.service - Tengine/nginx
   Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
   Active: active (running) since 四 2020-07-09 10:44:12 CST; 5min ago
     Docs: https://nginx.org/en/docs/
 Main PID: 30407 (nginx)
   CGroup: /system.slice/nginx.service
           ├─30407 nginx: master process /usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
           └─30409 nginx: worker process

7月 09 10:44:12 localhost.localdomain systemd[1]: Starting Tengine/nginx...
7月 09 10:44:12 localhost.localdomain nginx[30404]: nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
7月 09 10:44:12 localhost.localdomain nginx[30404]: nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
7月 09 10:44:12 localhost.localdomain systemd[1]: New main PID 28173 does not exist or is a zombie.
7月 09 10:44:12 localhost.localdomain systemd[1]: Started Tengine/nginx.

检查运行状态

使用 curl 访问 127.0.0.1 查看 Tengine 返回的 HTTP 头：

➜  tengine-2.3.2 curl -I 127.0.0.1
HTTP/1.1 200 OK
Server: Tengine/2.3.2
Date: Thu, 09 Jul 2020 02:51:18 GMT
Content-Type: text/html
Content-Length: 555
Last-Modified: Thu, 09 Jul 2020 02:22:10 GMT
Connection: keep-alive
ETag: "5f067f52-22b"
Accept-Ranges: bytes

从以上可看到 Tengine web 服务器运行正常。

防火墙放行 80 和 443 端口：

➜  tengine-2.3.2 sudo firewall-cmd --zone=public --add-port=443/tcp
success
➜  tengine-2.3.2 sudo firewall-cmd --zone=public --add-port=80/tcp
success

通过宿主机访问虚拟机 IP（192.168.188.128），Tengine 运行正常：

MySQL

安装 MySQL

通过二进制压缩包进行安装的笔记在 其他 - 通过二进制压缩包进行安装 部分。

下载 MySQL 官方 rpm 包，安装 rpm 包并更新 yum 源后，可以通过 yum 包管理器安装 MySQL server：

wget https://dev.mysql.com/get/mysql80-community-release-el7-3.noarch.rpm # 下载 rpm 包
sudo rpm -Uvh mysql80-community-release-el7-3.noarch.rpm
sudo yum update # 进行更新，会提示安装 mysql-community-libs 和 mysql-community-common，并导入 MySQL 官方 GPG key

查看 MySQL repo：

➜  ~ yum repolist all | grep mysql
mysql-cluster-7.5-community/x86_64  MySQL Cluster 7.5 Community     禁用
mysql-cluster-7.5-community-source  MySQL Cluster 7.5 Community - S 禁用
mysql-cluster-7.6-community/x86_64  MySQL Cluster 7.6 Community     禁用
mysql-cluster-7.6-community-source  MySQL Cluster 7.6 Community - S 禁用
mysql-cluster-8.0-community/x86_64  MySQL Cluster 8.0 Community     禁用
mysql-cluster-8.0-community-source  MySQL Cluster 8.0 Community - S 禁用
mysql-connectors-community/x86_64   MySQL Connectors Community      启用:    153
mysql-connectors-community-source   MySQL Connectors Community - So 禁用
mysql-tools-community/x86_64        MySQL Tools Community           启用:    110
mysql-tools-community-source        MySQL Tools Community - Source  禁用
mysql-tools-preview/x86_64          MySQL Tools Preview             禁用
mysql-tools-preview-source          MySQL Tools Preview - Source    禁用
mysql55-community/x86_64            MySQL 5.5 Community Server      禁用
mysql55-community-source            MySQL 5.5 Community Server - So 禁用
mysql56-community/x86_64            MySQL 5.6 Community Server      禁用
mysql56-community-source            MySQL 5.6 Community Server - So 禁用
mysql57-community/x86_64            MySQL 5.7 Community Server      禁用
mysql57-community-source            MySQL 5.7 Community Server - So 禁用
mysql80-community/x86_64            MySQL 8.0 Community Server      启用:    177
mysql80-community-source            MySQL 8.0 Community Server - So 禁用

可发现默认启用的是 8.0 版本，可以通过 yum-config-manager 更改版本：

sudo yum -y install yum-utils # 安装 yum 相关管理包
sudo yum-config-manager --disable mysql80-community # 禁用 MySQL 8.x 版本
sudo yum-config-manager --enable mysql57-community # 启用 MySQL 5.7

安装 MySQL：

sudo yum remove mysql-community-common mysql-community-libs # 卸载原来 MySQL 8 的相关依赖
sudo yum install mysql-community-common mysql-community-libs # 重新安装 MySQL 5 的相关依赖
sudo yum install mysql-community-server # 安装 MySQL

启动并查看 MySQL 状态：

➜  ~ sudo systemctl start mysqld.service # 启动 MySQL
➜  ~ sudo systemctl status mysqld.service # 查看 MySQL 运行状态
● mysqld.service - MySQL Server
   Loaded: loaded (/usr/lib/systemd/system/mysqld.service; enabled; vendor preset: disabled)
   Active: active (running) since 四 2020-07-09 11:39:12 CST; 1s ago
     Docs: man:mysqld(8)
           http://dev.mysql.com/doc/refman/en/using-systemd.html
  Process: 32346 ExecStart=/usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid $MYSQLD_OPTS (code=exited, status=0/SUCCESS)
  Process: 32297 ExecStartPre=/usr/bin/mysqld_pre_systemd (code=exited, status=0/SUCCESS)
 Main PID: 32349 (mysqld)
   CGroup: /system.slice/mysqld.service
           └─32349 /usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid

7月 09 11:39:09 localhost.localdomain systemd[1]: Starting MySQL Server...
7月 09 11:39:12 localhost.localdomain systemd[1]: Started MySQL Server.

配置 MySQL

查看 MySQL 安装时生成的暂用 root 密码：

➜  ~ sudo grep 'temporary password' /var/log/mysqld.log
2020-07-09T03:39:10.757404Z 1 [Note] A temporary password is generated for root@localhost: qX-SXV1guhsW

从上知 MySQL 安装过程中自动生成的密码为 qX-SXV1guhsW。使用 sudo mysql_secure_installation 命令重新配置 root 密码和远程访问：

➜  ~ sudo mysql_secure_installation

Securing the MySQL server deployment.

Enter password for user root:

The existing password for the user account root has expired. Please set a new password.

New password:

Re-enter new password:

Estimated strength of the password: 100
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : y
Success.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : n

 ... skipping.
By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : n

 ... skipping.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : y
Success.

All done!

检查运行状态

配置完成后可用 mysql cli 访问安装的 MySQL：

➜  ~ mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 24
Server version: 5.7.30 MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> \s
--------------
mysql  Ver 14.14 Distrib 5.7.30, for Linux (x86_64) using  EditLine wrapper

Connection id:          24
Current database:
Current user:           root@localhost
SSL:                    Not in use
Current pager:          less
Using outfile:          ''
Using delimiter:        ;
Server version:         5.7.30 MySQL Community Server (GPL)
Protocol version:       10
Connection:             Localhost via UNIX socket
Server characterset:    latin1
Db     characterset:    latin1
Client characterset:    utf8
Conn.  characterset:    utf8
UNIX socket:            /var/lib/mysql/mysql.sock
Uptime:                 9 min 4 sec

Threads: 1  Questions: 17  Slow queries: 0  Opens: 113  Flush tables: 1  Open tables: 106  Queries per second avg: 0.031
--------------

防火墙开放 MySQL 端口：

sudo firewall-cmd --zone=public --add-port=3306/tcp

宿主机使用 MySQL CLI 访问虚拟机 MySQL：

mysql -u root -p -P 3306 -h 192.168.188.130

Redis

Redis 安装的几个方法

通过 EPEL 源安装
拉取源码编译安装
使用 Docker 安装，Redis 提供了官方 Docker 镜像

编译安装 Redis

CentOS 7 中 GCC 版本为 4.x，无法编译 Redis 6，为避免污染系统环境，使用 scl 安装其他编译软件集：

sudo yum install centos-release-scl
sudo yum update
sudo yum install tcl devtoolset-9 # 安装版本为 9 的 scl 软件集，其中包含 gcc 9

进入 scl 软件集环境，并使用源码编译 Redis：

wget 192.168.188.1:8000/redis-6.0.5.tar.gz
tar -xzf redis-6.0.5.tar.gz
cd redis-6.0.5
scl enable devtoolset-9 bash
make
make test # 该步骤耗时较长，依赖 tcl 包

安装：

sudo make install # 将会安装至 /usr/local/bin 目录

将 Redis 注册为系统服务

复制 redis 模板配置文件：

sudo cp redis.conf /etc/redis

修改 Redis 配置文件：

sudo vim /etc/redis/redis.conf

# 修改以下字段：
daemonize yes
...
supervised systemd

编辑 redis systemd 配置：

sudo vim /etc/systemd/system/redis.service

配置内容如下：

[Unit]
Description=Redis data structure server
Documentation=https://redis.io/documentation
After=network.target syslog.target

[Service]
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
ExecStop=/usr/local/bin/redis-cli shutdown
Type=forking
TimeoutStartSec=10 # 服务允许的最大启动时长
TimeoutStopSec=20 # 服务自身停止的超时时长
Restart=always

[Install]
WantedBy=multi-user.target

确认运行状态

使用 systemd 确认运行状态：

sudo systemctl status redis.service

使用 redis-cli 确认运行状态：

➜  redis-6.0.5 redis-cli ping
PONG

ZooKeeper

安装

创建用户和组：

sudo groupadd zookeeper
sudo useradd -g zookeeper -d /opt/zookeeper -s /sbin/nologin zookeeper

下载、解压、移动二进制压缩包：

wget https://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.6.1/apache-zookeeper-3.6.1-bin.tar.gz
tar xzvf apache-zookeeper-3.6.1-bin.tar.gz
sudo mv apache-zookeeper-3.6.1-bin /opt
cd opt
sudo mv apache-zookeeper-3.6.1-bin zookeeper
cd zookeeper
sudo mkdir data # 数据目录
sudo mkdir logs # 日志文件目录
sudo vim /opt/zookeeper/conf/zoo.cfg # 编辑配置文件

zoo.cfg 内容如下：

tickTime=2000 # 时间单元
initLimit=10 
syncLimit=5
dataDir=/opt/zookeeper/data
dataLogDir=/opt/zookeeper/logs
clientPort=2181

启动

zookeeper sudo /opt/zookeeper/bin/zkServer.sh start

查看状态：

sudo /opt/zookeeper/bin/zkServer.sh status

可以看到 zk 正以单机模式运行，端口号为 2181。

将 ZooKeeper 注册为系统服务

新增 sk systemd 配置文件：

sudo vim /etc/systemd/system/zookeeper.service

配置文件内容如下：

[Unit]
Description=Zookeeper Service
After=syslog.target

[Service]
Type=simple
WorkingDirectory=/opt/zookeeper/
PIDFile=/opt/zookeeper/data/zookeeper_server.pid
SyslogIdentifier=zookeeper
ExecStart=/opt/zookeeper/bin/zkServer.sh start
ExecStop=/opt/zookeeper/bin/zkServer.sh stop
Restart=always
TimeoutSec=20
SuccessExitStatus=130 143
Restart=on-failure

[Install]
WantedBy=multi-user.target

使用 systemctl 命令进行管理：

sudo systemctl daemon-reload
sudo systemctl status zookeeper.service # 开启服务

查看运行状态：

sudo systemctl status zookeeper.service

其他

几种 MySQL 的安装及其对应的卸载方式

通过 MySQL 官方提供的 yum 源进行安装

wget https://dev.mysql.com/get/mysql80-community-release-el7-3.noarch.rpm # 下载 rpm 包
sudo rpm -Uvh mysql80-community-release-el7-3.noarch.rpm
sudo yum update
sudo yum install mysql-community-server

通过该方法安装的 MySQL 卸载方式：

sudo yum remove mysql # 卸载 MySQL-community-server
sudo rm -rf /var/lib/mysql # 删除 MySQL 数据目录

通过源码编译安装

该方法耗时较长。

相关文档：MySQL :: MySQL 5.7 Reference Manual :: 2.9 Installing MySQL from Source

通过二进制压缩包进行安装

// TODO

[TOC]

2020-07-10 学习日志（阶段2）

几种 MySQL 的安装及其对应的卸载方式（接昨日内容）

通过二进制压缩包进行安装

安装依赖、拉取二进制压缩包：

sudo yum install libaio # 安装 MySQL 基础 AIO 依赖
wget -P /mysql https://downloads.mysql.com/archives/get/p/23/file/mysql-5.7.29-linux-glibc2.12-x86_64.tar.gz # 下载二进制压缩包
sudo mkdir /usr/local/mysql
tar -xzvf mysql-5.7.29-linux-glibc2.12-x86_64.tar.gz # 解压缩
cd mysql-5.7.29-linux-glibc2.12-x86_64
sudo mv * /usr/local/mysql # 移动二进制文件至 /usr/local/mysql

更新环境变量：

# 在 .bashrc 或 .zshrc 文件内添加如下行，更新环境变量：
export PATH=$PATH:/usr/local/mysql/bin

添加用户和组：

# 添加用户和组
sudo groupadd mysql
sudo useradd -r -g mysql -s /bin/false mysql
#sudo useradd -g mysql -s /sbin/nologin mysql

创建 MySQL 相关必要目录：

# 创建 MySQL 相关目录
sudo mkdir -p /usr/local/mysql/datadir \
sudo mkdir -p /usr/local/mysql/log \
sudo mkdir -p /usr/local/mysql/etc \
sudo mkdir -p /usr/local/mysql/run \
sudo mkdir -p /usr/local/mysql/binlogs

# 修改相关目录 owner 为 mysql
sudo chown -R mysql.mysql /usr/local/mysql/datadir \
sudo chown -R mysql.mysql /usr/local/mysql/etc \
sudo chown -R mysql.mysql /usr/local/mysql/log \
sudo chown -R mysql.mysql /usr/local/mysql/run \
sudo chown -R mysql.mysql /usr/local/mysql/binlogs

创建 MySQL 配置文件：

sudo vim /usr/local/mysql/my.cnf

MySQL 配置内容如下：

[client]
port = 3306
socket = /usr/local/mysql/run/mysql.sock

[mysqld]
port = 3306
socket = /usr/local/mysql/run/mysql.sock
pid_file = /usr/local/mysql/run/mysql.pid
datadir = /usr/local/mysql/datadir
default_storage_engine = InnoDB
max_allowed_packet = 128M
max_connections = 2048
open_files_limit = 65535

skip-name-resolve
lower_case_table_names=1

character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect='SET NAMES utf8mb4'


innodb_buffer_pool_size = 128M
innodb_log_file_size = 128M
innodb_file_per_table = 1
innodb_flush_log_at_trx_commit = 0


key_buffer_size = 16M

log-error = /usr/local/mysql/log/mysql_error.log
log-bin = /usr/local/mysql/log/mysql_bin.log
slow_query_log = 1
slow_query_log_file = /usr/local/mysql/log/mysql_slow_query.log
long_query_time = 5


tmp_table_size = 16M
max_heap_table_size = 16M
query_cache_type = 0
query_cache_size = 0

server-id=1

初始化 MySQL，指定工作目录和数据存放目录：

sudo ./bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/usr/local/mysql/datadir

查看安装过程日志：

➜  mysql cat log/mysql_error.log
...
2020-07-10T00:46:47.484981Z 1 [Note] A temporary password is generated for root@localhost: o9./mrQpygcO

可以看到为 root@localhost 生成的暂用密码为 o9./mrQpygcO。

将 MySQL 注册为服务（使用 systemd）：

sudo vim /etc/systemd/system/mysqld.service

mysqld.service 配置文件内容如下：

[Unit]
Description=MySQL Server
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target

[Service]
User=mysql
Group=mysql

Type=forking
PIDFile=/usr/local/mysql/run/mysql.pid

# Disable service start and stop timeout logic of systemd for mysqld service.
TimeoutSec=0

# Execute pre and post scripts as root
PermissionsStartOnly=true

# Start main service
ExecStart=/usr/local/mysql/bin/mysqld --daemonize --pid-file=/usr/local/mysql/run/mysql.pid $MYSQLD_OPTS

# Sets open_files_limit
LimitNOFILE = 65535

Restart=on-failure
RestartPreventExitStatus=1
PrivateTmp=false

随后便能使用 systemd 管理 MySQL 服务：

sudo systemctl daemon-reload
sudo systemctl start mysqld.service
sudo systemctl status mysqld.service

使用 sudo systemctl status mysqld.service 命令查看 MySQL 运行状态：

sudo systemctl status mysqld.service

# 以下是输出内容
● mysqld.service - MySQL Server
   Loaded: loaded (/etc/systemd/system/mysqld.service; disabled; vendor preset: disabled)
   Active: active (running) since 五 2020-07-10 08:58:46 CST; 2s ago
     Docs: http://dev.mysql.com/doc/refman/en/using-systemd.html
  Process: 2193 ExecStart=/usr/local/mysql/bin/mysqld --daemonize --pid-file=/usr/local/mysql/run/mysql.pid $MYSQLD_OPTS (code=exited, status=0/SUCCESS)
 Main PID: 2195 (mysqld)
    Tasks: 27
   Memory: 180.9M
   CGroup: /system.slice/mysqld.service
           └─2195 /usr/local/mysql/bin/mysqld --daemonize --pid-file=/usr/local/mysql/run/mysql.pid

7月 10 08:58:45 localhost.localdomain systemd[1]: Starting MySQL Server...
7月 10 08:58:46 localhost.localdomain systemd[1]: Started MySQL Server.

使用 mysql_secure_installation 命令修改 root 密码、设置安全策略：

mysql_secure_installation
# 以下是部分命令输出
Securing the MySQL server deployment.

Enter password for user root:

The existing password for the user account root has expired. Please set a new password.

New password:

Re-enter new password:

VALIDATE PASSWORD PLUGIN can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD plugin?

Press y|Y for Yes, any other key for No: n
Using existing password for root.
Change the password for root ? ((Press y|Y for Yes, any other key for No) : y

New password:

Re-enter new password:
...

修改密码后，可使用 mysql -u root -p 命令本地连接数据库：

mysql -u root -p
# mysql cli 客户端
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 6
Server version: 5.7.29-log MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> \s
--------------
mysql  Ver 14.14 Distrib 5.7.29, for linux-glibc2.12 (x86_64) using  EditLine wrapper

Connection id:          6
Current database:
Current user:           root@localhost
SSL:                    Not in use
Current pager:          less
Using outfile:          ''
Using delimiter:        ;
Server version:         5.7.29-log MySQL Community Server (GPL)
Protocol version:       10
Connection:             Localhost via UNIX socket
Server characterset:    utf8mb4
Db     characterset:    utf8mb4
Client characterset:    utf8
Conn.  characterset:    utf8
UNIX socket:            /usr/local/mysql/run/mysql.sock
Uptime:                 4 min 22 sec

Threads: 1  Questions: 14  Slow queries: 0  Opens: 116  Flush tables: 1  Open tables: 109  Queries per second avg: 0.053
--------------

mysql>

防火墙放行 3306 端口的 TCP 连接：

sudo firewall-cmd --zone=public --add-port=3306/tcp

允许 root 用户远程访问：

mysql> use mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> select host,user from user;
+-----------+---------------+
| host      | user          |
+-----------+---------------+
| localhost | mysql.session |
| localhost | mysql.sys     |
| localhost | root          |
+-----------+---------------+
3 rows in set (0.00 sec)

mysql> update user set host='%' where user='root';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

由于 data 目录放在 /usr/local/mysql/datadir，在删除 MySQL 所在的 /usr/local/mysql 目录时，还会删除数据文件，因此注意在卸载前做好数据导出和备份。

通过二进制压缩包方式安装 MySQL 的卸载方法：

# 停止 MySQL 服务
sudo systemctl stop mysqld.service
# 删除 MySQL 安装文件夹，注意备份
sudo rm -rf /usr/local/mysql
# 删除 MySQL systemd 配置文件
sudo systemctl disable mysqld.service
sudo rm /etc/systemd/system/mysqld.service
sudo systemctl daemon-reload
sudo systemctl reset-failed

# 删除 .bashrc 中 MySQL 相关的环境变量，即以下行：
export PATH=$PATH:/usr/local/mysql/bin

最大文件操作数

单个进程打开文件的限制：ulimit -a 命令中 open files 的值：

系统所有进程打开文件的限制：cat /proc/sys/fs/file-max

暂时调整单个进程文件操作数

使用 ulimit -n xxx 进行调整。

硬限制：严格的设定，必定不能超过这个设定的数值。

软限制：警告的设定，可以超过这个设定值，但是若超过则有警告信息。

在普通用户下，无法调整超过 hard limit 的值，只能够调整 soft limit 的值，soft limit 无法超过 hard limit：

➜  tmp ulimit -n # 默认看到的是 soft limit
1024
➜  tmp ulimit -nS
1024
➜  tmp ulimit -nH # -H 参数可以查看 hard limit 数量
4096
➜  tmp ulimit -nH 2000 # 普通用户无法调整 hard limit
4096
➜  tmp ulimit -n 2000 # 普通用户可以调整 soft limit
➜  tmp ulimit -nS 2000
2000
➜  tmp ulimit -nS 9000 # soft limit 无法超过 hard limit
ulimit: value exceeds hard limit
2000

永久调整单个进程文件操作数

修改 /etc/security/limits.conf 文件，一般 soft limit 值可以稍低于 hard limit：

* soft nofile 50000 
* hard nofile 65535

* 表示对所有用户生效。

如果只想对某些用户生效，比如只对运行 nginx 的用户 nginx 生效，可以修改如下：

nginx soft nofile 50000
nginx hard nofile 65535

调整所有进程文件打开总数限制

该值必须永远大于单个进程文件操作数。

修改 /etc/sysctl.conf 文件，添加或修改 fs.file-max 字段值：

fs.file-max = 655350

检查修改是否生效

重启后查看单个进程文件限制和总文件限制：

➜  ~ ulimit -n # 默认显示 soft limit
50000
➜  ~ ulimit -nH # hard limit
65535
➜  ~ ulimit -nS # soft limit
50000
➜  ~ cat /proc/sys/fs/file-max # 总文件限制
655350

Tengine 补充

Tengine 配置负载均衡

在宿主机添加一个 tomcat，虚拟机访问地址为 192.168.188.1:8080，开启虚拟机上的 tomcat，虚拟机 tomcat 访问地址为 127.0.0.1:8080：

sudo systemctl start tomcat

修改 tomcat 默认主页，为顶部添加 虚拟机上的 tomcat 和 主机的 tomcat 标识：

进行 Tengine 相关配置：

sudo vim /usr/local/nginx/conf/nginx.conf

配置内容如下：

    upstream tomcats { # 使用权重进行轮询
        server 127.0.0.1:8080 weight=1;
        server 192.168.188.1:8080 weight=1;
    }
    server {
        listen 10010;
        server_name localhost;


        location / {
            proxy_pass http://tomcats;
        }
        access_log /home/bolitao/logs/tomcat_access.log; # 访问记录日志
    }

测试 nginx 配置无误：

➜ sudo ./sbin/nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

重启 nginx：

sudo systemctl restart nginx.service

放行相关端口：

sudo firewall-cmd --zone=public --permanent --add-port=10010/tcp # 放行 10010 端口
sudo systemctl restart firewalld.service # 重启防火墙

之后在宿主机可以使用 192.168.188.130:10010 访问由 Tengine 进行负载均衡的网页：

Tengine 后端节点检查

Tengine 2.3.2 默认不再自带 http_upstream_check_module 模块。

需要重新编译 Tengine，配置添加 --add-module=./modules/ngx_http_upstream_check_module 参数来添加健康检查模块：

./configure --user=app \
--group=app \
--with-jemalloc=/home/bolitao/jemalloc-5.2.1 \
--add-module=./modules/ngx_http_upstream_check_module

make # 重新编译
sudo make install # 重新安装

配置站点健康检查：

sudo vim /usr/local/nginx/conf/nginx.conf # 编辑 nginx 配置

在 tomcats upstream 中添加以下检查语句：

check interval=3000 rise=2 fall=5 timeout=1000 type=http; # 健康检查包发送间隔时间为 3秒；成功次数超过 2 次，认为服务器是 up 状态；失败次数超过 5 次，被认为是 down 状态；超时s时间为 1 秒；检查包类型为 http
check_http_send "HEAD / HTTP/1.0\r\n\r\n"; # 使用 HEAD 方法发送请求内容
check_http_expect_alive http_2xx http_3xx; # 指定 HTTP 回复的成功状态为 2xx 和 3xx

在 tomcats 对应的 server 中添加以下 location：

location /status {
    check_status; # 开启健康检查
    access_log   off; # 关闭日志记录
}

检查 nginx 配置是否正常，如果正常就重启 nginx 服务：

➜ sudo ./sbin/nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
➜ sudo systemctl restart nginx

访问网页的 /status 地址，结果如下：

手动停止一个服务器，健康检查结果发生改变：

Nginx 与 Tengine 的区别

Tengine 是基于 Nginx 的 fork，由淘宝网发起，针对大访问量情景做了优化，添加了许多高级功能和特性。Tengine 拥有 Nginx 1.17.3 的所有特性，兼容 Nginx 配置文件。

Tengine 增强了运维、监控相关功能，比如异步打印日志及回滚、本地DNS缓存、内存监控等；提供更多的负载均衡能力，可以适应更多场景，比如一致性hash模块、会话保持模块；还可以对后端的服务器进行主动健康检查，根据服务器状态自动上线下线，以及动态解析 upstream 中出现的域名。

Redis 补充

远程访问

将 Redis /etc/redis/redis.conf 配置文件中 bind 值修改为 0.0.0.0：

bind 0.0.0.0

确认 protected-mode 处于打开状态：

protected-mode yes

防火墙放行 redis 端口：

sudo firewall-cmd --zone=public --permanent --add-port=6379/tcp

重启 redis 服务：

sudo systemctl restart redis.service

通过宿主机访问虚拟机 redis：

redis-cli -h 192.168.188.130 -p 6379 ping
PONG

设置密码

修改配置文件，设置 requirepass 的值：

requirepass redis

重启 redis：

sudo systemctl restart redis.service

进行测试：

redis-cli -a redis -h 192.168.188.130 -p 6379 ping
PONG

持久化

Redis 官方文档对持久化介绍如下：

RDB 持久化方式每隔特定的间隔时间对数据进行一次快照备份
AOF 持久化方式记录服务器收到的每次写操作，当下次 redis 服务重启时，redis 会照着记录文件进行数据恢复。命令的日志格式与 Redis 协议本身相同，以追加的方式进行保存。当日志过大时，Redis 可以在后台进行重写
持久化是一项可选功能
在同一 Redis 实例中，可以同时启用 RDB 和 AOF 持久化方式。在同时使用这两种持久化方式的场景下，当 redis 重启时，会优先使用 AOF 文件恢复数据，因为 AOF 文件能尽可能保证数据完整性。

配置 Redis 持久化

redis 默认有以下持久化配置：

save 900 1 # 900 秒内如果有一条数据变动那么进行持久化
save 300 10 # 300 秒内有 10 条数据变动进行持久化
save 60 10000 # 60 秒内有 10000 条数据变动进行持久化

为方便观察，再添加一条规则：

save 30 1 # 30 秒内有一条数据变动就进行持久化

再启用 AOF 方式持久化：

appendonly yes
appendfilename "appendonly.aof"

设置 redis 持久化文件保存位置：

mkdir /home/bolitao/redisFile

# 以下是 redis 配置
dir /home/bolitao/redisFile

重启 redis 服务：

sudo systemctl restart redis.service

添加几条数据：

➜ redis-cli -a redis
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6379> set foo "bar"
OK
127.0.0.1:6379> set number 50
OK
127.0.0.1:6379> set foo "bar2"
OK
127.0.0.1:6379>

查看 AOF 文件：

查看 RDB 文件：

重启 redis：

sudo systemctl restart redis

在两种持久化方式都开启的情况下，优先从 AOF 进行数据恢复。重启后可以看到 redis 的数据已从持久化文件中恢复，没有丢失：

➜ redis-cli -a redis
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6379> keys *
1) "number"
2) "foo"
127.0.0.1:6379> get foo
"bar2"
127.0.0.1:6379>

总结

如果对数据安全性和完整性要求高，那么应该同时使用这两种持久化方法
如果在出现问题时可以忍受数分钟的数据丢失，那么可以只使用 RDB
Redis 官方不推荐单独使用 AOF，RDB 能够在 AOF 出现 bug 时提供次要恢复选择。并且 RDB 在备份、更快地重启方面有较好表现

Redis 相关操作和信息解读

基本命令

连接（包括远程和本地），-a 参数表示 auth，即认证密码，-h 表示地址，-p 表示端口：

redis-cli -a redis -h 192.168.188.130 -p 6379 # 连接本地 redis 则输入 127.0.0.1 或者不输即可

查看 redis 相关信息，在 cli 中输入 info 命令：

➜ redis-cli -a redis
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6379> info
# Server
redis_version:6.0.5
redis_git_sha1:00000000
redis_git_dirty:0
...

set key value：设置 key 值为 value
del key：删除 key
dump key：序列化 key
exists key：检查 key 是否存在
EXPIRE key：设置过期时间
KEYS pattern：查找符合给定模式的 key
move key dbx：将 key 移至 dbx 库
persist key：取消 key 的过期时间
ttl key：查询 key 的剩余生存时间
randomkey：随机获得一个 key
rename key newkey：将 key 的名字修改为 newkey
RENAMENX key newkey：只有 newkey 不存在时，把 key 名字改为 newkey
type key：key 的类型

Redis info 信息解读

在 redis-cli 中输入 info，可查询 Redis 相关信息。以下是几个比较重要的参数解读：

redis_version：redis 版本
redis_mode：redis 服务运行模式，有 standalone（单机）、sentinel（哨兵）、cluster（集群）三种模式
os：系统版本
arch_bits：系统位数
gcc_version：编译时所使用的 gcc 编译器版本
tcp_port：运行端口
config_file：所使用的配置文件目录
used_memory：使用内存，单位为 bytes
used_memory_human：易于阅读的使用内存量
rdb_last_save_time：最近一次 rdb 方式持久化的时间戳
rdb_last_bgsave_status：最近一次 rdb 持久化是否成功
aof_enabled：AOF 方式持久化是否成功
total_connections_received：新创建连接个数
total_commands_processed：共处理命令条数
used_cpu_sys：内核态所占用 CPU
used_cpu_user：用户态所占用 CPU
used_cpu_sys_children：后台进程和子进程占用的内核态 CPU
used_cpu_user_children：后台进程和子进程占用的用户态 CPU
cluster_enabled：是否开启集群

MySQL 二进制安装第二版

安装

安装依赖、拉取二进制压缩包：

yum install libaio # 安装 MySQL 基础 AIO 依赖
wget -P /opt/mysql/bin https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz # 下载二进制压缩包，地址可能变动

解压缩、创建链接：

tar -xzvf /opt/mysql/bin/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz -C /opt/mysql/bin
rm /opt/mysql/bin/mysql-5.7.31-linux-glibc2.12-x86_64.tar.gz # 删除程序压缩包
ln -s /opt/mysql/bin/mysql-5.7.31-linux-glibc2.12-x86_64 /usr/local/mysql # 慎用 ln -snf

修改环境变量：

vim /etc/profile

添加内容如下：

export PATH=$PATH:/usr/local/mysql/bin

刷新环境变量：

source /etc/profile

查看 MySQL 版本：

mysql -V
# 输出：
mysql  Ver 14.14 Distrib 5.7.31, for linux-glibc2.12 (x86_64) using  EditLine wrapper

初始化

添加用户和组：

# 添加用户和组
groupadd mysql
useradd -r -g mysql -s /bin/false mysql

创建相关文件夹、赋权：

mkdir /opt/mysql/mysqlFiles
mkdir /opt/mysql/mysqlFiles/data
mkdir /opt/mysql/mysqlFiles/log
chown -R mysql:mysql /opt/mysql

编辑 MySQL 配置文件：

vim /etc/my.cnf

输入内容如下：

[client]
port=3306
socket=/tmp/mysql.sock

[mysqld]
basedir=/usr/local/mysql
datadir=/opt/mysql/mysqlFiles/data
port=3306
socket=/tmp/mysql.sock
key_buffer_size=16M
max_allowed_packet=8M

初始化，记得记录初始化命令输出的日志：

/usr/local/mysql/bin/mysqld --defaults-file=/etc/my.cnf --initialize --user=mysql

启动脚本

拷贝 MySQL 的脚本：

cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld

使服务生效、允许开机启动，此步骤后可使用 service 或 systemctl 命令管理 MySQL 服务：

chkconfig --add mysqld && chkconfig mysqld on

启动 MySQL 服务：

systemctl start mysqld

检查 MySQL 状态：

systemctl status mysqld
# 以下是命令输出：
● mysqld.service - LSB: start and stop MySQL
   Loaded: loaded (/etc/rc.d/init.d/mysqld; bad; vendor preset: disabled)
   Active: active (running) since 四 2020-09-10 10:53:33 CST; 1s ago
     Docs: man:systemd-sysv-generator(8)
  Process: 13053 ExecStop=/etc/rc.d/init.d/mysqld stop (code=exited, status=0/SUCCESS)
  Process: 13079 ExecStart=/etc/rc.d/init.d/mysqld start (code=exited, status=0/SUCCESS)
   CGroup: /system.slice/mysqld.service
           ├─13090 /bin/sh /usr/local/mysql/bin/mysqld_safe --datadir=/opt/mysql/mysqlFiles/data --pid-file=/opt/mysql/mysqlFiles/data/loc...
           └─13258 /usr/local/mysql/bin/mysqld --basedir=/usr/local/mysql --datadir=/opt/mysql/mysqlFiles/data --plugin-dir=/usr/local/mys...

9月 10 10:53:32 localhost.localdomain systemd[1]: Starting LSB: start and stop MySQL...
9月 10 10:53:33 localhost.localdomain mysqld[13079]: Starting MySQL. SUCCESS!
9月 10 10:53:33 localhost.localdomain systemd[1]: Started LSB: start and stop MySQL.

使用 ps 命令查看 MySQL 进程：

ps -ef | grep mysql | grep -v grep
# 命令输出
root      13090      1  0 10:53 ?        00:00:00 /bin/sh /usr/local/mysql/bin/mysqld_safe --datadir=/opt/mysql/mysqlFiles/data --pid-file=/opt/mysql/mysqlFiles/data/localhost.localdomain.pid
mysql     13258  13090  0 10:53 ?        00:00:02 /usr/local/mysql/bin/mysqld --basedir=/usr/local/mysql --datadir=/opt/mysql/mysqlFiles/data --plugin-dir=/usr/local/mysql/lib/plugin --user=mysql --log-error=localhost.localdomain.err --pid-file=/opt/mysql/mysqlFiles/data/localhost.localdomain.pid --socket=/tmp/mysql.sock --port=3306

设置密码

初始化命令会输出一个暂用密码，比如本人密码是 9FohA-kl._p)：

2020-09-10T02:30:26.452271Z 1 [Note] A temporary password is generated for root@localhost: 9FohA-kl._p)

使用 mysql_secure_installation 修改密码、进行安全相关设置：

Securing the MySQL server deployment.

# 下面的步骤输入初始化时日志给出的暂用密码：
Enter password for user root:

The existing password for the user account root has expired. Please set a new password.
# 提示密码过期，设置一个新的 root 密码：
New password:
...
# 是否使用 VALIDATE PASSWORD 插件，用来验证密码强度的，我一般不用
VALIDATE PASSWORD PLUGIN can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD plugin?

Press y|Y for Yes, any other key for No:
...
# 是否删除匿名用户：
Remove anonymous users? (Press y|Y for Yes, any other key for No) :
...
# 是否禁用 root 用户的远程登陆：
Disallow root login remotely? (Press y|Y for Yes, any other key for No) :
...
# 是否删除测试库以及相关权限：
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : y
...
# 是否立刻刷新权限表，一般选是
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : y

设置完毕后即可使用新密码进行登录：

mysql -uroot -p

TODO

修改 server 的 encoding

参考：

MySQL :: MySQL Installation Guide :: 3 Installing MySQL on Unix/Linux Using Generic Binaries

MySQL :: MySQL 5.7 Reference Manual :: 4.2.2.2 Using Option Files

MySQL :: MySQL Installation Guide :: 9.1 Initializing the Data Directory

MySQL :: MySQL Installation Guide :: 9.3 Testing the Server

阶段 2 补充

MySQL 补充：常用操作和命令

mysql

连接命令

-u 指定用户名，-h 指定 ip，-P 指定端口号，-p 表示使用密码提示，-D 表示使用的数据库：

mysql -u root -p -h 192.168.188.130 -P 3306 -D mysql

查看 MySQL 信息

\s 命令：

mysql> \s
--------------
mysql  Ver 14.14 Distrib 5.7.29, for linux-glibc2.12 (x86_64) using  EditLine wrapper

Connection id:          7
Current database:
Current user:           root@localhost
SSL:                    Not in use
Current pager:          less
Using outfile:          ''
Using delimiter:        ;
Server version:         5.7.29-log MySQL Community Server (GPL)
Protocol version:       10
Connection:             Localhost via UNIX socket
Server characterset:    utf8mb4
Db     characterset:    utf8mb4
Client characterset:    utf8
Conn.  characterset:    utf8
UNIX socket:            /usr/local/mysql/run/mysql.sock
Uptime:                 6 min 55 sec

Threads: 1  Questions: 18  Slow queries: 0  Opens: 108  Flush tables: 1  Open tables: 101  Queries per second avg: 0.043
--------------

创建用户

CREATE USER 'bolitao'@'localhost' IDENTIFIED BY 'bolitao'; -- 创建只能在本地访问，用户名和密码为 bolitao 的用户
GRANT ALL PRIVILEGES ON *.* TO 'bolitao'@'localhost' WITH GRANT OPTION; -- 将所有权限赋予用户 bolitao（即和 root 账户相同的权限）

explain 命令

sql 语句运行详情（常用于 SQL 语句调优）：

mysql> explain select user, host from user where user = 'root';
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+--------------------------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra
   |
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+--------------------------+
|  1 | SIMPLE      | user  | NULL       | index | NULL          | PRIMARY | 276     | NULL |    3 |    33.33 | Using where; Using index |
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+--------------------------+
1 row in set, 1 warning (0.00 sec)

id：当 sql 语句中有子查询和关联查询时会显示多列，id 用于标志多列数据
select_type：表示简单查询还是复杂查询
- SIMPLE：简单查询
- PRIMARY：查询中包含子部分，最外层的 select 被标记为 PRIMARY
- UNION：UNION 中的第二个及其之后的 select 查询
- UNION RESULT：UNION 查询的结果
- SUBQUERY：子查询中的第一个 select
- UNCACHEABLE SUBQUERY：未被缓存的子查询
table：表名，当有子查询及 UNION 时，会有中间匿名表生成
partitions：分区表命中的分区情况
type：查询类型，
- ALL：全表扫描，最差情况
- index：扫描索引树
- range：有限制的索引扫描
- fef：是一种索引访问（索引查找），它返回所有匹配某个单个值的行
- eq_ref：索引查找，mysql最多只返回一条记录，在使用主键或者唯一索引查找时看得到
- const、system：当MySQL对查询某部分进行优化，并转换为一个常量时出现
- NULL：执行阶段不用访问表和索引
possible_keys：显示查询可以使用的索引
key：使用哪个索引来优化对表的访问
key_len：索引中使用的字节数
ref：显示table在key中选取的索引中查找值所用的列或者常量
rows：为了找到所需的行而要读取的行数
filtered：返回结果的行占需要读到的行(rows列的值)的百分比
Extra
- Using index：将使用覆盖索引，以避免访问表
- Using where：服务器将在存储引擎检索行后再进行过滤
- Using temporary：查询过程使用了中间表
- Using filesort：使用一个外部索引排序，而不是按索引的顺序读取表

mysqldump

导出数据库所有数据到 /tmp/all.sql：

➜ mysqldump -u root -p123 --all-databases >/tmp/all.sql
mysqldump: [Warning] Using a password on the command line interface can be insecure.

导出指定数据库：

# 以下命令导出 csuft_sd 和 sys 库
mysqldump -u root -p123 --databases csuft_sd sys > /tmp/spec_database_dump.sql

导出数据库特定的表：

# 导出 csuft_sd 库中的 role 和 user 表
mysqldump -u root -p123 --databases csuft_sd --tables role user > /tmp/tables.sql

导出某表中特定条件的数据：

# 导出 user 表中 real_name 为 bolitao 的数据
mysqldump -u root -p123 --databases csuft_sd --tables user --where='real_name="bolitao"' > /tmp/data.sql

仅导出表结构：

# 导出 role 和 user 的建表语句
mysqldump -u root -pZxc7601329! --databases csuft_sd --tables role user --no-data > /tmp/no_data_tables.sql

ZooKeeper 补充

集群

在三台虚拟机的 ZooKeeper 数据目录建立 myid 文件，文件内容分别写入 1、2、3：

sudo vim /opt/zookeeper/data/myid

三台服务器的 Zookeeper 配置文件分别添加以下配置：

sudo vim /opt/zookeeper/conf/zoo.cfg

# 以下是追加的配置文件内容：
server.1=192.168.188.130:2888:3888
server.2=192.168.188.131:2888:3888
server.3=192.168.188.132:2888:3888

在三台服务器分别开放防火墙端口：

sudo firewall-cmd --zone=public --permanent --add-port=2181/tcp
sudo firewall-cmd --zone=public --permanent --add-port=2888/tcp
sudo firewall-cmd --zone=public --permanent --add-port=3888/tcp
sudo firewall-cmd --reload

在三台服务器分别开启 Zookeeper 服务：

sudo systemctl start zookeeper

之后查看其运行状态：

sudo /opt/zookeeper/bin/zkServer.sh status

可以看到 3 号机为主，1、2 号机为从：

3 号机状态：

2 号机状态：

1 号机状态：

基本操作和了解

连接：

sudo zkCli.sh -server 192.168.188.132:2181

查看帮助：

[zk: localhost:2181(CONNECTED) 0] help # 随便输入不存在的命令
ZooKeeper -server host:port -client-configuration properties-file cmd args
        addWatch [-m mode] path # optional mode is one of [PERSISTENT, PERSISTENT_RECURSIVE] - default is PERSISTENT_RECURSIVE
        addauth scheme auth
        close
        config [-c] [-w] [-s]
        connect host:port
...

创建节点：

[zk: localhost:2181(CONNECTED) 6] create /mynode hello # 普通节点
Created /mynode

[zk: localhost:2181(CONNECTED) 8] create -s /mynode2 hello # 有序节点，可以创建多个，会自动按顺序命名
Created /mynode20000000001

[zk: localhost:2181(CONNECTED) 18] create -e /temp hello # 临时节点
Created /temp

列出节点：

[zk: localhost:2181(CONNECTED) 8] ls /mynode # 列出节点
[subnode]

[zk: localhost:2181(CONNECTED) 7] ls -s /mynode # 列出节点及其状态
[subnode]
cZxid = 0x200000006
ctime = Mon Jul 13 13:10:58 CST 2020
mZxid = 0x200000006
mtime = Mon Jul 13 13:10:58 CST 2020
pZxid = 0x200000007
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 5
numChildren = 1

获取节点：

[zk: localhost:2181(CONNECTED) 15] get /mynode
hello

[zk: localhost:2181(CONNECTED) 17] get -w /mynode # 获取 /mynode 并监听
hello
[zk: localhost:2181(CONNECTED) 18] set /mynode 1 # 修改 /mynode，发现 watch 发出消息

WATCHER::

WatchedEvent state:SyncConnected type:NodeDataChanged path:/mynode

状态检查：

[zk: localhost:2181(CONNECTED) 19] stat /mynode
cZxid = 0x200000006 # 创建 node 时的 zxid
ctime = Mon Jul 13 13:10:58 CST 2020 # 创建时间
mZxid = 0x20000001b # 修改 node 时的 zxid
mtime = Mon Jul 13 13:37:53 CST 2020 # 修改时间
pZxid = 0x200000007 # 最后一次修改子节点时的 zxid
cversion = 1 # 子节点的版本
dataVersion = 1 # 内容版本，修改一次该节点数字都会 +1（即使 set 了相同值也会 +1）
aclVersion = 0 # ALC 版本
ephemeralOwner = 0x0 # 如果是临时节点，会列出其所在 zk 服务器的 session id；如不是临时节点那么这个值为 0
dataLength = 1 # 数据长度
numChildren = 1 # 子节点个数

修改节点：

[zk: localhost:2181(CONNECTED) 24] set /mynode 123 # 将 /mynode 的值 修改为 123

删除节点：

deleteall /mynode # 删除节点及其子节点

delete /mynode # 删除节点，如存在子节点会报错：Node not empty: /xxx

强制同步：

[zk: localhost:2181(CONNECTED) 32] sync /mynode20000000001
Sync is OK

通过 Java 命令看进程和堆栈

jps

使用 JDK 附带的 jps 命令查看运行中的 Java 程序：

➜ jps -l # -l 表示显示完整的 package 名或者 jar 名
7904 sun.tools.jps.Jps
7482 org.apache.catalina.startup.Bootstrap

➜ jps -m # -m 表示查看传递给 main 的参数
7921 Jps -m
7482 Bootstrap start

➜  bin jps -v # -v 表示传输给 jvm 的详细参数
7939 Jps -Dapplication.home=/usr/lib/jvm/jdk1.8.0_251 -Xms8m
7482 Bootstrap -Djava.util.logging.config.file=/home/bolitao/apps/apache-tomcat-9.0.37/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -Dcatalina.base=/home/bolitao/apps/apache-tomcat-9.0.37 -Dcatalina.home=/home/bolitao/apps/apache-tomcat-9.0.37 -Djava.io.tmpdir=/home/bolitao/apps/apache-tomcat-9.0.37/temp

通常可以将这几个命令一起使用，表示查看使用该 JDK 运行的 Java 程序，并列出包名、传入 main 的参数和 jvm 详细参数：

➜ jps -mlv
7956 sun.tools.jps.Jps -mlv -Dapplication.home=/usr/lib/jvm/jdk1.8.0_251 -Xms8m
7482 org.apache.catalina.startup.Bootstrap start -Djava.util.logging.config.file=/home/bolitao/apps/apache-tomcat-9.0.37/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -Dcatalina.base=/home/bolitao/apps/apache-tomcat-9.0.37 -Dcatalina.home=/home/bolitao/apps/apache-tomcat-9.0.37 -Djava.io.tmpdir=/home/bolitao/apps/apache-tomcat-9.0.37/temp

查看垃圾收集情况

jstat -gcutil -h 5 7482 1000：查看 pid 为 7482 的 Java 程序垃圾收集信息，-h 5 表示每五次输出一次头部标题，1000 表示每秒输出一次相关信息。

# 比如查看 pid 为 4542 的 Java 程序的垃圾收集情况：
➜  ~ sudo jstat -gcutil -h 5 4542 1000
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
  0.00 100.00  67.60  65.42  94.47  92.92    207  374.753    43 1032.588 1407.341
  0.00 100.00  67.60  65.42  94.47  92.92    207  374.753    43 1032.588 1407.341
  0.00 100.00  67.60  65.42  94.47  92.92    207  374.753    43 1032.588 1407.341
  0.00 100.00  67.60  65.42  94.47  92.92    207  374.753    43 1032.588 1407.341

参数解读：

S0：Survivor space 0 区使用比率
S1：Survivor space 1 区使用比率
E：伊甸区使用比率
O：老年代使用比率
M：元数据区使用比率
CCS：类指针压缩空间使用率
YGC：新生代 GC 次数
YGCT：新生代 GC 总时长
FGC：full GC 次数
FGCT：full GC 时长
GCT：总垃圾回收时长

查看堆栈信息

使用 jstack 命令查看 Java 进程的线程快照，使用 -l 参数还会额外输出关于锁的附加信息（对于死锁的调试比较有用）。

➜ sudo jstack -l 4542
2020-07-13 14:53:03
Full thread dump OpenJDK 64-Bit Server VM (25.252-b09 mixed mode):

"Attach Listener" #51474 daemon prio=9 os_prio=0 tid=0x00007fa328024000 nid=0x3ab5 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"logback-8" #6303 daemon prio=5 os_prio=0 tid=0x00007fa334019800 nid=0x2910 waiting on condition [0x00007fa3160df000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000e25b1f90> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
...
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
        at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
        - None
...

其他 Linux 操作学习

查看网络情况

查看网卡信息 ifconfig：

➜  ~ ifconfig
ens33: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.188.130  netmask 255.255.255.0  broadcast 192.168.188.255
        ether 00:0c:29:32:3a:38  txqueuelen 1000  (Ethernet)
        RX packets 44757  bytes 14517781 (13.8 MiB) # 收到的数据包
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 26733  bytes 4783585 (4.5 MiB) # 发送的数据包
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

查看网络流量：iftop：

sudo yum install -y epel-release && sudo yum install -y iftop # 安装此软件包

运行效果：

查看某端口使用情况：

netstat -ntulp |grep xx # xx 为端口号

查看 IO 使用情况

使用 iotop 工具：

使用 df 命令查看空间情况：

➜  ~ sudo df
文件系统                   1K-块      已用      可用  已用% 挂载点
devtmpfs                  486004       0   486004    0% /dev
tmpfs                     497840       0   497840    0% /dev/shm
tmpfs                     497840    7856   489984    2% /run
tmpfs                     497840       0   497840    0% /sys/fs/cgroup
/dev/mapper/centos-root 52403200 6761420 45641780   13% /
/dev/sda1                1038336  163360   874976   16% /boot
/dev/mapper/centos-home 49250820 3250356 46000464    7% /home
tmpfs                      99572       0    99572    0% /run/user/1000

➜ sudo df / # 查看根目录情况
文件系统                   1K-块      已用      可用  已用% 挂载点
/dev/mapper/centos-root 52403200 6761420 45641780   13% /

查找指定文件

find 命令：

➜ find /opt/mysql -name 'my*' # 查找 /opt/mysql 目录下，名为 my 开头的文件
/opt/mysql
/opt/mysql/etc/my.cnf

whereis：用于搜索二进制程序：

➜ whereis mysql
mysql: /usr/local/mysql /usr/share/mysql /usr/local/mysql/bin/mysql

whitch：用于搜索 PATH 中找到的第一个结果：
```
➜ which java
/usr/lib/jvm/jdk1.8.0_251/bin/java
```

查看某个文件大小和权限

使用 ls -al xx 命令，比如：

➜ ls -al configure
-rwxrwxr-x 1 bolitao bolitao 2502 9月   5 2019 configure

以上结果可以知道该文件大小为 2502 字节，权限为 rwxrwxrx，即文件拥有者和同组有读、写、执行权限，其他用户有读和执行权限。

工作中 CentOS 的一些笔记 01

2026-01-01T08:11:41+00:00

工作中 CentOS 的一些笔记，其实大部分都是 Linux 通用。

[TOC]

安装与配置

CentOS 7

![image-20200707102445214](\阶段 1.assets\image-20200707102445214.png)

创建用户：

CentOS 6

进行 Basic Server 安装：

更新系统

sudo yum update

关闭 SELinux

使用 /usr/sbin/sestatus -v 查看 SELinux 启用状态：

![image-20200707110244291](\阶段 1.assets\image-20200707110244291.png)

从上图可知 SELinux 是开启状态，SELinux 可能会造成 SSH 自定义端口无法生效等问题，以下将其关闭：

sudo vi /etc/selinux/config

将以下字段修改为 disabled 并重启。

此外，暂时关闭 SELinux：

setenforce 0 # 设置 SELinux 成为 permissive 模式
setenforce 1 # 设置SELinux 成为 enforcing 模式

配置防火墙

设置防火墙，允许 2424 端口的 TCP 连接：

sudo firewall-cmd --permanent --zone=public --add-port=2424/tcp

开启 SSH 服务

编辑 SSH 服务配置文件：

sudo vi /etc/ssh/sshd_config

将端口行取消注释，设置 SSH 端口为 2424：

![image-20200707113624552](\阶段 1.assets\image-20200707113624552.png)

启动 SSH 服务：

sudo systemctl start sshd

设置 SSH 服务自动启动：

sudo systemctl enable sshd

通过 Windows SSH 客户端进行连接：

ssh bolitao@192.168.188.128 -p 2424

安装 VMware Tools

挂载虚拟光驱：

sudo mkdir /mnt/tmp # 创建暂存挂载目录
sudo mount -t iso9660 /dev/cdrom /mnt/tmp #以光盘格式将光驱挂载至 /mnt/tmp 目录

此外，挂载 ISO 镜像：
mount -o loop xxx xxx

将挂载内容拷贝至用户目录：

cd /mnt/tmp
mkdir ~/tmp
cp * ~/tmp

安装编译软件：

sudo yum install perl gcc make kernel-headers kernel-devel

安装 VMware Tools：

cd ~/tmp
tar xzvf VMwareTools-10.3.21-14772444.tar.gz # 解压缩
cd vmware-tools-distrib
sudo ./vmware-install.pl

![image-20200707112444415](\阶段 1.assets\image-20200707112444415.png)

取消挂载 tmp 目录：

sudo umount -v /mnt/tmp

JDK

安装 JDK

从主机下载准备的 Oracle JDK：

wget http://192.168.188.1:8000/jdk-8u251-linux-x64.tar.gz

解压缩 JDK：

tar xzf jdk-8u251-linux-x64.tar.gz

在 /usr/lib 下新建 jvm 文件夹，并把解压的 JDK 移至此处：

sudo mkdir /usr/local/jvm
sudo mv ~/jdk1.8.0_251 /usr/local/jvm

使用 update-alternatives 注册 java 和 javac 命令：

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk1.8.0_251/bin/java 300
sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk1.8.0_251/bin/javac 300 # 最后一个参数表示优先级，数字越大优先级越高

检查是否生效：

➜  jdk1.8.0_251 java -version
java version "1.8.0_251"
Java(TM) SE Runtime Environment (build 1.8.0_251-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)
➜  jdk1.8.0_251 javac -version
javac 1.8.0_251

配置多个 JDK

新增一个 JDK 11：

wget http://192.168.188.1:8000/jdk-11.0.7_linux-x64_bin.tar.gz # 下载
tar xzf jdk-11.0.7_linux-x64_bin.tar.gz # 解压
sudo mv jdk-11.0.7 /usr/lib/jvm # 移动至 /usr/lib/jvm 目录

通过 update-alternatives 注册新的 JDK 11：

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-11.0.7/bin/java 200
sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk-11.0.7/bin/javac 200

使用 update-alternatives 切换 JDK：

➜  ~ sudo update-alternatives --config java

共有 2 个提供“java”的程序。

  选项    命令
-----------------------------------------------
*+ 1           /usr/lib/jvm/jdk1.8.0_251/bin/java
   2           /usr/lib/jvm/jdk-11.0.7/bin/java

按 Enter 保留当前选项[+]，或者键入选项编号：2
➜  ~ sudo update-alternatives --config javac

共有 2 个提供“javac”的程序。

  选项    命令
-----------------------------------------------
*+ 1           /usr/lib/jvm/jdk1.8.0_251/bin/javac
   2           /usr/lib/jvm/jdk-11.0.7/bin/javac

按 Enter 保留当前选项[+]，或者键入选项编号：2

检查切换是否生效：

![image-20200707144206480](\阶段 1.assets\image-20200707144206480.png)

可以看到 JDK 版本已经由 1.8 切换为 11。

安装 JDK 的几个方法

通过 rpm 包进行安装
通过 yum 包管理器进行安装（该方法安装的 JDK 会自动配置环境变量，但 yum 只提供 openjdk）
通过压缩文件（.tar.gz、.zip）解压缩安装

切换 JDK 环境变量的几个方法

使用 update-alternatives 进行管理

”配置多个 JDK“有说明。
手动切换 .bashrc 中 JAVA_HOME 变量的值

使用 vim ~/.zshrc 或者 vim ~/.bashrc 命令修改 shell 配置文件：
```
export JAVA_HOME=/usr/local/java/jdk1.8.0_251
export PATH=$PATH:$JAVA_HOME/bin
```
刷新 shell，使刚才配置的环境变量生效：
```
source ~/.zshrc
```
检查环境变量无误：

![image-20200707141502676](\阶段 1.assets\image-20200707141502676.png)

Tomcat

安装 tomcat

下载并解压 Tomcat：

wget https://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat-9/v9.0.37/bin/apache-tomcat-9.0.37.tar.gz
tar xvf apache-tomcat-9.0.37.tar.gz

将 Tomcat 移动至 /opt/tomcat 目录：

sudo mkdir /opt/tomcat
sudo mv ~/apache-tomcat-9.0.37 /opt/tomcat

将 tomcat 注册为服务

使用 systemd 进行服务管理，创建 tomcat systemd 配置文件：

sudo vim /etc/systemd/system/tomcat.service

配置内容如下：

[Unit]
Description=Apache Tomcat
After=syslog.target network.target

[Service]
Type=forking

Environment=JAVA_HOME=/usr/lib/jvm/jdk1.8.0_251
Environment=CATALINA_PID=/opt/tomcat/apache-tomcat-9.0.37/temp/tomcat.pid
Environment=CATALINA_HOME=/opt/tomcat/apache-tomcat-9.0.37
Environment=CATALINA_BASE=/opt/tomcat/apache-tomcat-9.0.37
Environment='CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC'
Environment='JAVA_OPTS=-Djava.awt.headless=true -Djava.security.egd=file:/dev/./urandom'

ExecStart=/opt/tomcat/apache-tomcat-9.0.37/bin/startup.sh
ExecStop=/opt/tomcat/apache-tomcat-9.0.37/bin/shutdown.sh

[Install]
WantedBy=multi-user.target

重载 systemd：

sudo systemctl daemon-reload

启动 tomcat：

sudo systemctl start tomcat.service

使用 sudo systemctl status tomcat 命令查看 tomcat 作为 systemd 服务的运行状态：

➜  apache-tomcat-9.0.37 sudo systemctl status tomcat
● tomcat.service - Apache Tomcat
   Loaded: loaded (/etc/systemd/system/tomcat.service; disabled; vendor preset: disabled)
   Active: active (running) since 二 2020-07-07 15:20:28 CST; 1min 28s ago
  Process: 5983 ExecStart=/opt/tomcat/apache-tomcat-9.0.37/bin/startup.sh (code=exited, status=0/SUCCESS)
 Main PID: 5990 (java)
   CGroup: /system.slice/tomcat.service
           └─5990 /usr/lib/jvm/jdk1.8.0_251/bin/java -Djava.util.logging.config.file=/opt/tomcat/apache-tomcat-9.0.37/conf/logging...

7月 07 15:20:28 localhost.localdomain systemd[1]: Starting Apache Tomcat...
7月 07 15:20:28 localhost.localdomain startup.sh[5983]: Tomcat started.
7月 07 15:20:28 localhost.localdomain systemd[1]: Started Apache Tomcat.

可以看到 systemctl status 显示该服务在后台正常运行。访问 ip:port 发现可以正常访问：

其他

CentOS 6 与 7 的差别

初始化和服务管理：6 使用 Sysvinit，7 使用 systemd
日志：6 使用 syslog，7 更多使用 systemd-journalctl
包管理：6 的 yum 默认从官方源下载软件包，需手动更改 yum 源；7 更加智能，会自动选择速度最好的yum 镜像地址

防火墙

允许某个端口：

sudo firewall-cmd --permanent --add-port=aaaa/bbb

其中 aaaa 为放行的端口号，bbb 为 UDP 或者 TCP。

允许 HTTP 服务：

sudo firewall-cmd --permanent --add-service=http

允许 HTTPS 服务：

sudo firewall-cmd --permanent --add-service=https

查看其它可被防火墙允许访问/禁止访问的服务：

sudo firewall-cmd --get-services

防火墙的额外操作：

sudo systemctl stop firewalld # 停止防火墙
sudo systemctl disable firewalld # 禁止防火墙自动启动
sudo systemctl mask --now firewalld # 屏蔽防火墙服务，其他应用也不能启用防火墙
sudo firewall-cmd --zone=public --list-ports # 查看 zone 为 public 的开放的端口

SELinux

暂时关闭：

setenforce 0 # 设置 SELinux 成为 permissive 模式
setenforce 1 # 设置SELinux 成为 enforcing 模式

永久关闭：将 SELinux 配置文件 /etc/selinux/config 中的 SELINUX 字段修改为 disable。

挂载

挂载光驱：

mount -t iso9660 xxx xxx

挂载 ISO 文件：

mount -o loop xxx xxx

取消挂载：

umount -v /mnt/xxx

挂载光驱，配置本地yum源，实现yum源安装

新建文件夹 /mnt/tmp，将 /dev/cdrom 挂载至新建文件夹：

sudo mkdir /mnt/tmp
mount -t iso9660 /dev/cdrom /mnt/tmp

新建一个 yum 配置源：

sudo vim //etc/yum.repos.d/local.repo

配置内容如下：

[local]
name=local
baseurl=file:///mnt/tmp
enabled=1                    
gpgcheck=0

源配置完成后，清除 yum 缓存：

sudo yum clean all

之后便可使用 yum 常用命令：

sudo yum search xxx # 搜索软件包
sudo yum info xxx # 查看软件包信息
sudo yum list xxx # 列出软件包
sudo yum install xxx # 安装
sudo yum remove xxx # 删除

注册服务

CentOS 7 后，启动方式换成了 systemd，对应的命令为 systemctl。

将某个通过 SprnigBoot 打包的 Java jar/war 程序作为服务运行的 systemd 配置模板如下：

[Unit]
Description=服务描述
Documentation=官网、文档等
After=network-online.target
Wants=network-online.target

[Service]
User=root# 运行的用户名
Type=simple
ExecStart=/usr/bin/java -server -Xms256m -Xmx512m -jar jar包路径
ExecStop=/bin/kill -s QUIT $MAINPID
Restart=always
StandOutput=syslog

StandError=inherit

[Install]
WantedBy=multi-user.target

修改 systemd 配置后，需要刷新 systemd 才能生效：

sudo systemctl daemon-reload

启动某服务：

sudo systemctl start xxx.service

停止某服务：

sudo systemctl stop xxx.service

屏蔽某服务（其他应用也不能调起该服务）：

sudo systemctl mask --now xxx

开机自动启动：

sudo systemctl enable xxx.service

查看服务的运行状态：

sudo systemctl status xxx.service

查看某服务的运行日志：

journalctl -u xxx.service

删除某个由 systemd 管理的服务：

sudo systemctl stop 服务名
sudo systemctl disable 服务名
sudo rm /etc/systemd/system/服务名
sudo systemctl daemon-reload
sudo systemctl reset-failed

chkconfig

chkconfig 是 centos6 时代使用比较多的服务管理程序，现在用得较多的是 systemd。

使用 chkconfig 管理的服务，其配置文件保存在 /etc/init.d 目录下。

chkconfig --list：列出管理的服务：

➜  ~ sudo chkconfig --list

注：该输出结果只显示 SysV 服务，并不包含
原生 systemd 服务。SysV 配置数据
可能被原生 systemd 配置覆盖。

      要列出 systemd 服务，请执行 'systemctl list-unit-files'。
      查看在具体 target 启用的服务请执行
      'systemctl list-dependencies [target]'。

netconsole      0:关    1:关    2:关    3:关    4:关    5:关    6:关
network         0:关    1:关    2:开    3:开    4:开    5:开    6:关
vmware-tools    0:关    1:关    2:开    3:开    4:开    5:开    6:关

其他用法：

chkconfig --add xxx # 添加 xxx 服务
chkconfig --del xxx # 删除
chkconfig xxx on # 开机启动
chkconfig xxx off # 取消开机启动

常用的几个等级：

等级1：单用户模式/救援模式

等级2：无网络连接的多用户命令行模式

等级3：有网络连接的多用户命令行模式

等级5：带图形界面的多用户模式

其他

怎样查看指定进程或者查看指定端口

查看某进程：

ps aux | grep xxx # xxx 为进程名

查看某端口：

netstat -ntulp |grep xx # xx 为端口号

怎样进行当前服务器上的文件移动，以及服务器之间的文件移动

当前服务器移动文件：

mv

服务器之间的文件移动（scp）：

# 从本机拷贝文件到另一机器：
scp {{path/to/local_file}} {{remote_host}}:{{path/to/remote_file}}
# 从其他机器拷贝文件到本机：
scp {{remote_host}}:{{path/to/remote_file}} {{path/to/local_directory}}
# 递归拷贝目录：
scp -r
# 指定用户名：
scp localFile remote_username@remote_host:remote_directory

怎样挂载光驱，在离线环境安装插件，以及在服务器上查找某个已经安装的插件

新建文件夹 /mnt/tmp，将 /dev/cdrom 挂载至新建文件夹：

sudo mkdir /mnt/tmp
mount -t iso9660 /dev/cdrom /mnt/tmp

新建一个 yum 配置源：

sudo vim //etc/yum.repos.d/local.repo

配置内容如下：

[local]
name=local
baseurl=file:///mnt/tmp
enabled=1                    
gpgcheck=0

源配置完成后，清除 yum 缓存：

sudo yum clean all

之后便可使用 yum 常用命令：

sudo yum search xxx # 搜索软件包
sudo yum info xxx # 查看软件包信息
sudo yum list xxx # 列出软件包
sudo yum install xxx # 安装
sudo yum remove xxx # 删除

sudo yum list installed # 查看已安装的
sudo yum list updates # 查看可升级的

查找某个已经安装的软件包：

rpm -q xxx

服务的注册，删除和开机自启动配置修改 systemd 配置后，需要刷新 systemd 才能生效：

sudo systemctl daemon-reload

启动某服务：

sudo systemctl start xxx.service

停止某服务：

sudo systemctl stop xxx.service

屏蔽某服务（其他应用也不能调起该服务）：

sudo systemctl mask --now xxx

开机自动启动：

sudo systemctl enable xxx.service

查看服务的运行状态：

sudo systemctl status xxx.service

查看某服务的运行日志：

journalctl -u xxx.service

删除某个由 systemd 管理的服务：

sudo systemctl stop 服务名
sudo systemctl disable 服务名
sudo rm /etc/systemd/system/服务名
sudo systemctl daemon-reload
sudo systemctl reset-failed

查看服务器信息的一些命令，怎么看IP，看服务器版本号

看 IP：
```
ifconfig
ip addr
```
查看服务器信息：
```
lsb_release
uname -r
uname -a
screenfetch
```
运行权限和用户权限

运行权限：标识为 x 或者 1，比如：
- --x 表示某文件有运行权限，用数字表示为 1
- rwx 表示有读、写、运行权限，数字表示为 7（4+2+1）。
用户权限：分为普通用户和超级用户，普通用户可使用 sudo 命令暂时提升为管理员权限。

怎么查看某个进程的线程

ps -T -p <pid>

top -H
# 或者
top -H -p <pid>

光驱或镜像的挂载和卸载的命令

挂载光驱：
```
mount -t iso9660 xxx xxx
```
挂载 ISO 文件：
```
mount -o loop xxx xxx
```
取消挂载：
```
umount /mnt/xxx
```

MySQL 双主搭建及简单 CURD

2026-01-01T08:11:41+00:00

[toc]

在 Linux 系统上面搭建 MySQL 双主（liunx 系统采取 CentOS7 以上）
搭建 maven spring boot 工程，引入 Mybatis Plus，简单增删改查模块

MySQL 双主部署

确定服务器信息

首先输入 lsb_release -a 确定服务器系统信息：

A 机器（39.97.69.140）：

LSB Version:    :core-4.1-amd64:core-4.1-noarch
Distributor ID: CentOS
Description:    CentOS Linux release 7.3.1611 (Core)
Release:        7.3.1611
Codename:       Core

B 机器（49.235.232.61）：

LSB Version:    :core-4.1-amd64:core-4.1-noarch:cxx-4.1-amd64:cxx-4.1-noarch:desktop-4.1-amd64:desktop-4.1-noarch:languages-4.1-amd64:languages-4.1-noarch:printing-4.1-amd64:printing-4.1-noarch
Distributor ID: CentOS
Description:    CentOS Linux release 7.6.1810 (Core)
Release:        7.6.1810
Codename:       Core

A 机器系统为 CentOS 7.3 版本，B 机器系统为 CentOS 7.6。

安装和配置 MySQL

因为版权原因，CentOS yum 包管理器默认不包含 MySQL，只有 MariaDB：

# yum info mariadb
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
Available Packages
Name        : mariadb
Arch        : x86_64
Epoch       : 1
Version     : 5.5.65
Release     : 1.el7
Size        : 8.7 M
Repo        : base/7/x86_64
Summary     : A community developed branch of MySQL
......
......

由以上信息可以看到 MariaDB 版本为 5.5.65，是比较老的版本且可能和 MySQL 有差异。

为了便于使用 yum 进行依赖管理、升级和维护，决定使用 MySQL 官方推荐的方法安装 MySQL：使用官方维护的 yum 仓库安装 MySQL。

# 下载 MySQL rpm 包
wget https://dev.mysql.com/get/mysql80-community-release-el7-3.noarch.rpm
# 本地方式安装刚才下载的软件包
sudo yum localinstall mysql80-community-release-el7-3.noarch.rpm

使用 yum repolist all | grep mysql 命令查看软件仓库中 MySQL 的启用情况：

mysql-cluster-7.5-community/x86_64 MySQL Cluster 7.5 Community   disabled
mysql-cluster-7.5-community-source MySQL Cluster 7.5 Community - disabled
mysql-cluster-7.6-community/x86_64 MySQL Cluster 7.6 Community   disabled
mysql-cluster-7.6-community-source MySQL Cluster 7.6 Community - disabled
mysql-cluster-8.0-community/x86_64 MySQL Cluster 8.0 Community   disabled
mysql-cluster-8.0-community-source MySQL Cluster 8.0 Community - disabled
mysql-connectors-community/x86_64  MySQL Connectors Community    enabled:    153
mysql-connectors-community-source  MySQL Connectors Community -  disabled
mysql-tools-community/x86_64       MySQL Tools Community         enabled:    110
mysql-tools-community-source       MySQL Tools Community - Sourc disabled
mysql-tools-preview/x86_64         MySQL Tools Preview           disabled
mysql-tools-preview-source         MySQL Tools Preview - Source  disabled
mysql55-community/x86_64           MySQL 5.5 Community Server    disabled
mysql55-community-source           MySQL 5.5 Community Server -  disabled
mysql56-community/x86_64           MySQL 5.6 Community Server    disabled
mysql56-community-source           MySQL 5.6 Community Server -  disabled
mysql57-community/x86_64           MySQL 5.7 Community Server    disabled
mysql57-community-source           MySQL 5.7 Community Server -  disabled
mysql80-community/x86_64           MySQL 8.0 Community Server    enabled:    177
mysql80-community-source           MySQL 8.0 Community Server -  disabled

可看到 MySQL 8.0 分支是被启用状态，禁用 8.0 源，启用 5.6 源：

sudo yum-config-manager --disable mysql80-community
sudo yum-config-manager --enable mysql56-community

随后安装 MySQL：

sudo yum install -y mysql-community-server

使用 systemd 开启 MySQL 服务、启用开机自启动：

sudo systemctl start mysqld
sudo systemctl enable mysqld

使用 sudo，以 root 身份打开一个 MySQL 客户端连接：

sudo mysql -u root

新增一个名为 bolitao 的用户，密码也为 bolitao：

mysql> CREATE USER 'bolitao'@'localhost' IDENTIFIED BY 'bolitao';
Query OK, 0 rows affected (0.00 sec)

mysql> GRANT ALL PRIVILEGES ON *.* TO 'bolitao'@'localhost' WITH GRANT OPTION;
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

之后便可以 bolitao 身份登入 MySQL：

配置 MySQL 双主

备份原来的 MySQL 配置文件：

sudo mv /etc/my.cnf /etc/my.cnf.bak

修改机器 A 上的 MySQL 配置文件如下：

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.6/en/server-configuration-defaults.html
[client]
port = 3306
socket=/var/lib/mysql/mysql.sock

[mysqld]
#
# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M
#
# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin
#
# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock

basedir = /usr/local/mysql
port = 3306
pid-file=/var/run/mysqld/mysqld.pid
log-error=/var/log/mysqld.log

server-id = 1
auto_increment_offset = 1
auto_increment_increment = 2



# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

# Recommended in standard MySQL setup
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES

log-bin = mysql-bin
binlog-format=ROW
#binlog-row-p_w_picpath=minimal
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency=true
master-info-repository=TABLE
relay-log-info-repository=TABLE
sync-master-info=1
slave-parallel-workers=0
sync_binlog=0
binlog-checksum=CRC32
master-verify-checksum=1
slave-sql-verify-checksum=1
binlog-rows-query-log_events=1
expire_logs_days=5
max_binlog_size=1024M

replicate-ignore-db = mysql                                             #忽略不同步主从的数据库
replicate-ignore-db = information_schema
replicate-ignore-db = performance_schema
replicate-ignore-db = test

max_connections = 3000
max_connect_errors = 30

skip-character-set-client-handshake                                     #忽略应用程序想要设置的其他字符集
init-connect='SET NAMES utf8'                                           #连接时执行的SQL
character-set-server=utf8                                               #服务端默认字符集
wait_timeout=1800                                                       #请求的最大连接时间
interactive_timeout=1800                                                #和上一参数同时修改才会生效
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES                     #sql模式
max_allowed_packet = 10M
bulk_insert_buffer_size = 8M
query_cache_type = 1
query_cache_size = 128M
query_cache_limit = 4M
key_buffer_size = 256M
read_buffer_size = 16K

skip-name-resolve
slow_query_log=1
long_query_time = 6
slow_query_log_file=slow-query.log
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 16M


[mysql]
no-auto-rehash


[myisamchk]
key_buffer_size = 20M
sort_buffer_size = 20M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout

[mysqldump]
quick
max_allowed_packet = 16M


[mysqld_safe]
log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid

重启 MySQL 并查看其状态：

由以上信息可知 MySQL 重启成功、运行正常。

同理，修改 B 机器上的 MySQL 配置文件和 A 机器类似，只有主键自增策略不同：

server-id = 2
auto_increment_offset = 2
auto_increment_increment = 2

添加主从同步账户

在 A 机器上执行以下 SQL：

mysql> grant replication slave on *.* to 'bolitao'@'49.235.232.61' identified by 'bolitao';
Query OK, 0 rows affected (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

在 B 机器上执行以下 SQL：

mysql> grant replication slave on *.* to 'bolitao'@'39.97.69.140' identified by 'bolitao';
Query OK, 0 rows affected (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

查看主库的状态

A 主机上：

B 主机上：

配置同步信息

A 机器：

mysql> change master to master_host='49.235.232.61',master_port=3306,master_user='bolitao',master_password='bolitao',master_log_file='mysql-bin.000001',master_log_pos=551;
Query OK, 0 rows affected, 2 warnings (0.02 sec)

B 机器：

mysql> change master to master_host='39.97.69.140',master_port=3306,master_user='bolitao',master_password='bolitao',master_log_file='mysql-bin.000001',master_log_pos=552;
Query OK, 0 rows affected, 2 warnings (0.16 sec)

在 A 机和 B 机执行以下 SQL，开启基于 GTID 的复制：

mysql> stop slave;
Query OK, 0 rows affected (0.01 sec)

mysql> change master to MASTER_AUTO_POSITION=1;
Query OK, 0 rows affected (0.69 sec)

mysql> start slave;
Query OK, 0 rows affected (0.00 sec)

开启服务并查看状态：

mysql> start slave;
Query OK, 0 rows affected (0.00 sec)

mysql> show slave status\G
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 49.235.232.61
                  Master_User: bolitao
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000001
          Read_Master_Log_Pos: 551
               Relay_Log_File: mysqld-relay-bin.000002
                Relay_Log_Pos: 314
        Relay_Master_Log_File: mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB:
          Replicate_Ignore_DB: mysql,information_schema,performance_schema,test
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
  Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 551
              Relay_Log_Space: 519
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
            Last_IO_Error:
               Last_SQL_Errno: 0
           Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 2
                  Master_UUID: fba31258-aa80-11ea-8004-5254001c64d1
             Master_Info_File: mysql.slave_master_info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Slave has read all relay log; waiting for the slave I/O thread to update it
           Master_Retry_Count: 86400
                  Master_Bind:
      Last_IO_Error_Timestamp:
     Last_SQL_Error_Timestamp:
               Master_SSL_Crl:
           Master_SSL_Crlpath:
           Retrieved_Gtid_Set:
            Executed_Gtid_Set: 662f1b0e-aa52-11ea-bed4-00163e32c4be:1-2
                Auto_Position: 0
1 row in set (0.00 sec)

A、B 机执行 show slave status 时，可以发现以下值：

Slave_IO_Running: Yes
Slave_SQL_Running: Yes

表示双主架构 MySQL 运行正常。

简单测试

在 A 机上新建名为 testdb 的库，并进行一些数据插入：

mysql> create database testdb;
Query OK, 1 row affected (0.00 sec)

mysql> CREATE TABLE `test_table` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
);

> INSERT INTO `testdb`.`test_table` (`title`) VALUES ('test1');
> INSERT INTO `testdb`.`test_table` (`title`) VALUES ('test2');

随后在 B 机可以查询到同步的库和数据：

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| testdb             |
+--------------------+
4 rows in set (0.00 sec)


mysql> use testdb;
Database changed
mysql> select * from test_table;
+----+-------+
| id | title |
+----+-------+
|  1 | test1 |
|  3 | test2 |
+----+-------+
2 rows in set (0.00 sec)

可以看到数据已经被同步至 B 机，在 A 机插入记录的自增主键为 1, 3, 5...等，都为奇数。

在 B 机：1. 删除 testdb 库中的一些数据；2. 新建 testdb2 库；3. 在 testdb2 库新增一些数据：

> DELETE FROM `testdb`.`test_table` WHERE  `id`=1;

mysql> create database testdb2;
Query OK, 1 row affected (0.00 sec)

mysql> use testdb2;
Database changed
mysql> CREATE TABLE `test_table` (
    ->   `id` int(11) NOT NULL AUTO_INCREMENT,
    ->   `title` varchar(255) DEFAULT NULL,
    ->   PRIMARY KEY (`id`)
    -> );
Query OK, 0 rows affected (0.04 sec)

mysql> INSERT INTO `testdb`.`test_table` (`title`) VALUES ('test3');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO `testdb`.`test_table` (`title`) VALUES ('test4');
Query OK, 1 row affected (0.00 sec)

在 A 机可查询到同步的数据：

mysql> use testdb;
Database changed
mysql> select * from test_table;
+----+-------+
| id | title |
+----+-------+
|  3 | test2 |
+----+-------+
1 row in set (0.00 sec)

mysql> use testdb2;
Database changed
mysql> select * from test_table;
+----+-------+
| id | title |
+----+-------+
|  6 | test3 |
|  8 | test4 |
+----+-------+
2 rows in set (0.00 sec)

可以看到，A 机同步了 B 机的数据删除和新增记录。

基于 Mybatis Plus 的 CURD

创建项目

使用 IDEA 新建项目中的“Sprnig Initializr”功能新建 Spring 项目：

添加以下额外 Maven 模块：

<!-- web 支持 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--MySQL 支持-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--MyBatis Plus 支持-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version>
</dependency>

<!--swagger 支持-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

<!-- dynamic-datasource-spring-boot-starter-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.1.1</version>
</dependency>

<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

数据源和其他配置

设置默认数据源为 master 组，使用组名为主数据源时，采用负载均衡算法切换。

spring:
  datasource:
    dynamic:
      primary: master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        master_1:
          url: jdbc:mysql://39.97.69.140:3306/test123
          username: bolitao
          password: bolitao
          driver-class-name: com.mysql.cj.jdbc.Driver
        master_2:
          url: jdbc:mysql://49.235.232.61:3306/test123
          username: bolitao
          password: bolitao
          driver-class-name: com.mysql.cj.jdbc.Driver
          
logging:
  level:
    com.baomidou.mybatisplus.samples.quickstart: debug

双主 CURD 策略：

新增：都可以进行新增。

删除：写 A 机。

修改：为避免冲突，只写 A 机，修改的记录再同步至 B 机。

查询：都可进行查询。

配置测试数据库和基础 Java 类

新建一个 test123 库：

create database test123;

新增用户表：

CREATE TABLE user
(
	id int NOT NULL AUTO_INCREMENT,
	name VARCHAR(30) NULL DEFAULT NULL,
	age INT(11) NULL DEFAULT NULL,
	email VARCHAR(50) NULL DEFAULT NULL,
	PRIMARY KEY (id)
);

插入测试数据：

INSERT INTO user (id, name, age, email) VALUES
(NULL, 'Jone', 18, 'test1@baomidou.com'),
(NULL, 'Jack', 20, 'test2@baomidou.com'),
(NULL, 'Tom', 28, 'test3@baomidou.com'),
(NULL, 'Sandy', 21, 'test4@baomidou.com'),
(NULL, 'Billie', 24, 'test5@baomidou.com');

新建实体类 User：

@Data
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;

    public User(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

查询

编写一个查询接口，用于查询所有用户信息，Service 指定数据源为 master 组，会自动根据组进行负载均衡，实现如下：

@DS("master")
public List<User> getUsers() {
    List<User> users = userMapper.selectList(null);
    return users;
}

控制层实现如下：

@GetMapping("getAll")
public List<User> getAll() {
    return userService.getUsers();
}

访问 http://localhost:8080/getAll，返回的结果如下：

新增

新建一个新增数据的接口，指定数据源为 master 组，新增数据的方法如下，addUsers() 方法连续新增十条数据。：

@DS("master")
public void addUsers() {
    for (int i = 0; i < 10; i++) {
        userMapper.insert(new User("name" + i, i, "mail" + i));
    }
}

控制层代码如下：

@PostMapping("addUsers")
public void addUsers() {
    userService.addUsers();
}

使用 postman 发送一次请求后，发现 A 库新增 10 条记录，ID 为奇数的是自己新增的，ID 为偶数的是从 B 机器同步过来的：

查询 B 库，同样也新增了 10 条数据。

修改

指定使用 master_1（即 A 机）进行数据修改操作，service 层实现如下，将相应 ID 记录的 name 字段改为 updatedName：

@DS("master_1")
public void update(int id) {
    User user = userMapper.selectById(id);
    user.setName("updatedName");
    userMapper.updateById(user);
}

控制层实现如下：

@PostMapping("update")
public void update(@RequestParam(name = "id") int id) {
    userService.update(id);
}

使用 postman 发送如下请求：

查询 A 库，发现姓名已经更改：

查询 B 库，发现相应记录已被同步：

删除

通过 id 删除某条记录，删除操作限定在 A 机器上进行，所以 DS 注解设置数据源为 master_1，service 层实现代码如下：

@DS("master_1")
public void delete(int id) {
    userMapper.deleteById(id);
}

控制层代码如下：

@DeleteMapping("delete")
public void delete(@RequestParam(name = "id") int id) {
    userService.delete(id);
}

使用 postman 以 delete 方式请求 delete url，删除 id 为 62 的记录，如下图所示：

操作完毕后，查看 A 库，可以发现 id 为 62 的纪录已被删除：

B 库也同步了该条删除：

停掉 A 库

使用 systemctl stop mysqld 命令停止 A 库，以 get 方式访问 getAll URL，进行添加操作，仍可以读取数据：

参考

记一次 Jackson toString 和 asText() 相关问题

2026-01-01T08:11:41+00:00

Jackson 相关的憨憨问题。

TL;DR

这是个很弱智的问题，而且弱智的我被这个问题困扰了一天：

如果你使用 Jackson 解析 json，那么要小心引号。使用 JsonNode.get().asText() 而不是 JsonNode.get().toString()。

细节

前端传 json 大致如下：

{
  "title": "二手 NS",
  "description": "description",
  "originPrice": 2600,
  "salePrice": 1999,
  "deliveryPrice": 0,
  "userId": 30,
  "category": "手机数码"
}

实体类 Category 属性简要如下：

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
int id;
@Column(name = "name")
String name;

我的问题：后端要根据传来的 category 字段查询这个分类的信息，我的代码如下：

使用 jackson 解析 json：

JsonNode inputInfo = new ObjectMapper().readTree(inJson);
String categoryName = inputInfo.get("category").toString();
Category category = categoryService.getCategoryByName(categoryName);

CategoryService:

public Category getCategoryByName(String categoryName) {
        // xxxx
        return categoryDAO.findByName(categoryName);
}

dao 简单使用 JPA 查询查不到：

List<Category> findByName(String name);

手写 SQL 查询也查不到：

@Query(value = "select * from category_ c where c.name = ?1", nativeQuery = true)
Category findByName(String name);

然后我把 spring 配置改成显示 SQL 语句：

jpa:
  show-sql: true

运行时执行的 SQL 语句如下：

Hibernate: select category0_.id as id1_0_, category0_.name as name2_0_ from category_ category0_ where category0_.name=?

正常且符合逻辑的查询，把这串 SQL 手动执行了下，能正常查出结果：

select category0_.id as id1_0_, category0_.name as name2_0_ from category_ category0_ where category0_.name='手机数码'

那么...是不是 getCategoryByName() 方法传入的字符串出了问题？在这个方法里打印一下日志看看：

2020-04-14 12:16:54.279  WARN 10996 --- [nio-8383-exec-1] x.b.c.service.CategoryService            : "手机数码"

hmmm 这个分类名多了个双引号包裹，因为这个双引号造成了查不出结果...这就是 Jackson 使用相关的一些细节。

我原来从 json 取值的写法是：

String categoryName = inputInfo.get("category").toString();

那么这里的 categoryName 就是带双引号的，而想要预期效果，要使用 asText() 方法：

String categoryName = inputInfo.get("category").asText();

Typecho

2026-01-01T08:11:41+00:00

GitHub 和 GitHub pages 的访问越来越慢，前阵子国内还出现了中间人攻击，所以决定把博客搬到 VPS 上，不过毕竟是海外服务器，国内访问估计也够慢，希望能够苟住不被墙掉。

至于为什么选择 Typecho，可能只是单纯想折腾。如果 Typecho 不够好用，未来也可能换至 WordPress。

因为对 PHP 相关完全不熟，第一次不用别人的一键脚本、自己部署有点心累...不像 Java 直接 java -jar 就好，在这里做点 PHP 部署相关的记录，方便日后查阅。~~说到底我又在写二手知识了。~~

Typecho 稳定版虽说很久没更新，但主题和插件还是蛮多的。~~这次决定放飞自我整个二次元主题 xD。~~

~~Update: 好吧还是没整二次元主题，VOID 这个主题的衬线字体很对我胃口。~~

安装

安装 php5.6

sudo apt-get install python-software-properties
sudo add-apt-repository ppa:ondrej/php
sudo apt-get update
sudo apt install php5.6 php5.6-fpm php5.6-cgi php5.6-cli php5.6-pgsql php5.6-mysql php5.6-sqlite3 php5.6-xml php5.6-mbstring

安装 Nginx

sudo add-apt-repository ppa:nginx/stable
sudo apt-get update
sudo apt install nginx

安装 MySQL

sudo apt install mysql-server
sudo mysql_secure_installation

MySQL 用户相关的配置可以见我这篇博文：Ubuntu 安装的一些记录

安装 Typecho

mkdir ~/typecho
wget https://typecho.org/downloads/1.1-17.10.30-release.tar.gz
tar xvf 1.1-17.10.30-release.tar.gz
mv build app # typecho path: /home/username/typecho/app

这里就不执行 sudo chown -R www-data.www-data 了，我 nginx user 就是 bolitao 这个账户

配置

配置 Nginx

sudo nano /etc/nginx/sites-enabled/typecho

配置文件内容：

server {
    listen 10086;
    listen [::]:10086;

    server_name bolitao.xyz;

    root   /home/bolitao/typecho/app;
    index  index.html index.htm index.php;

    location ~ .*\.php(\/.*)*$ {
            include fastcgi.conf;
            fastcgi_pass unix:/run/php/php5.6-fpm.sock;
    }
}

测试 Nginx

➜  app sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

无误后重启 nginx：

sudo systemctl restart nginx

通过 IP:端口 访问 typecho 进行安装。安装过程中如果不能自动创数据库那么就手动创一个 typecho 数据库：

CREATE DATABASE typecho

站点配置步骤完成后可能会要在站点根目录手动创建 config.inc.php 文件，vim ~/typecho/config.inc.php 并添加前端给出的内容即可。

证书

certbot 一把梭。

问题解决

502 错误

查看 nginx error.log

2020/04/02 09:46:37 [crit] 15494#15494: *34 connect() to unix:/run/php/php5.6-fpm.sock failed (13: Permission denied)

发现是权限相关错误，修改 fpm 相关配置：

sudo vim /etc/php/5.6/fpm/pool.d/www.conf

listen.owner = 和 listen.group = 修改成自己的用户名和组

重启 fpm:

sudo systemctl restart php5.6-fpm.service

连接数据库时无数据库适配器可选

（我没来得及截图，借用一张 segmentfault 的图） https://image-static.segmentfault.com/989/349/9893498-574cf6032e3a8 php - Typecho 数据库适配器无法选择 - SegmentFault 思否

安装 php5.6-mysql：

sudo apt install php5.6-mysql

安装后会自动启用该拓展

Typecho 提示无法连接/无法创建数据库

手动创建一个叫 typecho 的数据库，mysql -u username -p：

CREATE DATABASE typecho

文章和后台 404

nginx 的站点配置：location ~ .*\.php$ 修改为 location ~ .*\.php(\/.*)*$
cgi.fix_pathinfo 设置为 enable：修改 php 配置：sudo vim /etc/php/5.6/fpm/php.ini，将 cgi.fix_pathinfo = 1 取消注释

500 错误

查看 nginx error 日志，发现错误：PHP Fatal error: Call to undefined function utf8_decode()，解决：安装 php-xml:

sudo apt install php5.6-xml

emoji 支持

在发表带有 emoji 表情的文章时，前端会提示错误：Database Query Error。后端错误：

"PHP message: Incorrect string value: '\xF0\x9F\x90\x8B A...' for column 'text' at row 1" while reading response header from upstream

原因是数据库或 PHP 程序 charset 是 utf-8，我们要换成 utf8mb4。解决办法如下：

修改数据库编码

ALTER DATABASE typecho CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;

修改表编码

USE typecho;
alter table typecho_comments convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_contents convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_fields convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_metas convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_options convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_relationships convert to character set utf8mb4 collate utf8mb4_unicode_ci;
alter table typecho_users convert to character set utf8mb4 collate utf8mb4_unicode_ci;

修改 PHP 程序连接参数

vim config.inc.php，修改 charset 为 utf8mb4:
```
'charset' => 'utf8mb4',
```

设置证书后无法加载 CSS 和 JavaScript

进入后台，把站点地址从 ip:port 修改为自己的域名。

升级 PHP 至 7.4

添加 PPA 然后 APT 安装相应模块即可。

升级后注意修改 Nginx 配置文件中 fastcgi_pass 的路径，以及 /etc/php/7.4/fpm/pool.d/www.conf 这个文件内的相关权限。

在升级 Typecho 后可能会无法访问数据库，这是因为高版本 MySQL 驱动换了，修改 config.inc.php 文件中 Typecho_Db 的第一个参数如下：

$db = new Typecho_Db('Pdo_Mysql', 'typecho_');

参考

使用 Hyper v 加速 Android 模拟器

2026-01-01T08:11:41+00:00

如果你是 AMD CPU 而且使用 WSL 2，那么几乎无缘使用市面一众 Android 模拟器，比如 Genymotion、各种主打游戏的 Android 模拟器（Mumu、雷电之类）。

Update: 2020年12月13日如果你是游戏玩家，那么可以使用 Mumu 模拟器的新引擎，MuMu 手游助手，与 Hyper-V 兼容。

好在另有出路：可以使用 Hyper-V + Visual Studio 跑 Android 模拟器。

安装

确保“启用或关闭 Windows 功能”中 Hyper-V、Windows 虚拟机监控程序平台 和 虚拟机平台功能是被安装的，如果没有那么将其勾选安装并重启。
打开 Visual Studio Installer，选中“使用 .NET 的移动开发”：

选择“修改”，之后等待下载和安装自动完成。

使用

打开 Visual Studio 2019，工具栏选择工具 - Android - Android SDK 管理器...。

勾选 Android SDK Tools 和 Android Emulator 并应用，确保 Android SDK Tools 版本最低为 26.1.1。
打开工具栏中工具 - Android - Android Device Manager，选择新建，设置虚拟机属性：可以按需求设置系统版本、是否需要 play 服务、分辨率、存储空间和内存大小等...属性设置完毕后选择创建，会下载 Android 镜像并自动安装。
打开虚拟机使用：

Troubleshooting

Microsoft 官方有给出十分详细的问题解决方案：Android Emulator 疑难解答 - Xamarin | Microsoft Docs。根据文档一步步排查基本能够解决问题。

我的状况：提示 WHPX 服务未启用：

检查 Hyper-V 和 Windows 虚拟机监控程序平台是否已经启用：

PS C:\WINDOWS\system32> Get-WindowsOptionalFeature -FeatureName Microsoft-Hyper-V-All -Online                                                                                                                                                   
FeatureName      : Microsoft-Hyper-V-All
DisplayName      : Hyper-V
Description      : 提供一些帮助创建和运行虚拟机及其资源的服务和管理工具。
RestartRequired  : Possible
State            : Enabled
CustomProperties :

PS C:\WINDOWS\system32> Get-WindowsOptionalFeature -FeatureName HypervisorPlatform -Online


FeatureName      : HypervisorPlatform
DisplayName      : Windows 虚拟机监控程序平台
Description      : 支持虚拟化软件在 Windows 虚拟机监控程序上运行
RestartRequired  : Possible
State            : Disabled
CustomProperties :

可以看到我的 HypervisorPlatform 是被禁用的状态，将其启用：

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All
Enable-WindowsOptionalFeature -Online -FeatureName HypervisorPlatform -All

重启后再次检查， HypervisorPlatform 已经启用了：

PS C:\WINDOWS\system32> Get-WindowsOptionalFeature -FeatureName HypervisorPlatform -Online


FeatureName      : HypervisorPlatform
DisplayName      : Windows 虚拟机监控程序平台
Description      : 支持虚拟化软件在 Windows 虚拟机监控程序上运行
RestartRequired  : Possible
State            : Enabled
CustomProperties :

总结

这玩意用起来卡卡的，完全比不上 Linux 下 KVM 加持的 Android 模拟器。不过也勉强凑合 Android 开发，拿来打游戏估计不行，也可能是本人移动处理器太菜了，桌面处理器体验说不定会好很多。

参考

WSL 2 体验 & 折腾

2026-01-01T08:11:41+00:00

我很久前就开始使用 WSL 2，遗憾好几次被 pre_release 通道各种鬼畜的 bug 劝退。而这次不同——还算能用的慢速预览通道总算迎来了 2004 更新，这个版本的更新包含 WSL 2。

安装

如果之前已装 WSL

在控制面板 - 程序和功能 - 启用或关闭 Windows 功能里开启“虚拟机平台”并重启。
到这个页面下载并安装 WSL 2 Linux Kernel：Updating the WSL 2 Linux kernel | Microsoft Docs。
将原来安装的发行版转为 WSL 2：
```
wsl --set-version Ubuntu 2
```

上述命令的 Ubuntu 换成自己发行版的名字，不确定的话可以通过 wsl -l -v 命令查看。

如果以前没装过 WSL

在 控制面板 - 程序和功能 - 启用或关闭 Windows 功能 里启用"适用于 Linux 的 Windows 子系统"和“虚拟机平台”并重启。

或者以管理员权限打开 PowerShell 执行以下命令后重启：
```
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
```
到这个页面安装 WSL 2 Linux Kernel：Updating the WSL 2 Linux kernel | Microsoft Docs。
设置默认 wsl 版本：
```
wsl --set-default-version 2
```
在 Microsoft Store 中找到想要的发行版进行安装，安装完后点击发行版图标打开，后续安装会自动进行，途中会提示新建一个 Linux 用户。

使用

换源

备份原来的配置文件：

sudo mv /etc/apt/sources.list /etc/apt/sources.list.bak

新建配置文件：

sudo vim /etc/apt/sources.list

我用的是清华镜像：

# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse

保存后更新：

sudo apt update; sudo apt upgrade

常用程序

WSL 1 时代有个对常用程序在 WSL 运行效果打分的项目：ethanhs/WSL-Programs，许多时候还得战战兢兢去这个页面看自己用的程序和 WSL 相性如何。

而 WSL 2 拥有完整的 Linux 内核，常见的程序应该都能运行，以下是一些我常用的程序的测试。

holo (Java + H2 数据库) 功能正常：

Jupyter 正常：

Python + MySQL 正常：NSFW 警告

注：由于 Systemctl 不可用，请使用 sudo service start mysql 来启动 MySQL。

Terminal

推荐唯一指定 Terminal——Windows Terminal，目前还处于测试，但已经足够好用。Win + Shift + 4 就可以直接打开终端了，可以在这里找到许多主题: iTerm2-Color-Schemes。

VSCode WSL 插件

现在 VSCode 插件已经兼容 WSL 2，直接在 VSCode 新建 WSL 窗口就能访问 WSL 的文件，用来写 Python 还是挺舒服的。

Shell

bash 和 ZSH 都正常运行，oh-my-zsh 也正常。

服务的互相访问

WSL 访问 Windows 服务

WSL 下可以输入 cat /etc/resolv.conf 命令查看 Windows 端 IP：

➜  ~ cat /etc/resolv.conf
# This file was automatically generated by WSL. To stop automatic generation of this file, add the following entry to /etc/wsl.conf:
# [network]
# generateResolvConf = false
nameserver 172.29.32.1

通过上面命令可知可以使用 172.29.32.1 这个 IP 访问 Windows 服务。比如我可以在 WSL 访问 Windows 的 IP:v2ray 端口 来进行代理，详见终端代理。

Update 1:

上面通过 cat /etc/resolv.conf 获取的 IP 是会随时改变的，不过我们可以通过一个固定网址来访问 Windows 端服务：

新建一个 shell 脚本，命名为 changeHosts.sh

# hosts edit
winIp=$(cat /etc/resolv.conf | grep -oP '((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}')
CUSTOM_ADDRESS="win.local"
addressInfo=$(cat /etc/hosts | grep -oP $CUSTOM_ADDRESS)
if [ -z "$addressInfo" ]; then
    # if [ $EUID != 0 ]; then
    #     sudo "$0" "$@"
    #     exit $?
    # fi
    echo "未找到自定义地址，将会进行添加..."
    echo "$winIp $CUSTOM_ADDRESS" >> /etc/hosts # 申请权限
    echo '完成'
else
    customAddressLineNumber=$(grep -n "win.local" /etc/hosts | cut -d : -f 1)
    originalIp=$(sed -n "$customAddressLineNumber"p /etc/hosts | grep -oP '((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}')
    # 如果 hosts 中 ip 和真实 ip 不相等，则进行更新
    if [ "$winIp" != "$originalIp" ]; then
        echo 'hosts 中 ip 和真实 ip 不一致，进行更新...'
        param=$customAddressLineNumber"d"
        sed -i "$param" /etc/hosts
        echo "$winIp $CUSTOM_ADDRESS" >> /etc/hosts
        echo '完成'
    fi
fi

你可以将以上代码的 CUSTOM_ADDRESS 设置成任何你想要的地址，比如我的就是 win.local。

如果不嫌每次手动运行该脚本才能更新 hosts 文件麻烦的话，就可以到此为止了。每当你重启，手动运行一遍 sudo ./changeHosts.sh 就能更新 hosts 了。

如果想要在每次重启后自动运行该脚本，请继续阅读。

使用 sudo crontab -e 命令创建一个定时任务，在每次重启时执行上面创建的脚本

在打开的编辑器里添加如下行，请将路径和脚本名设置成自己刚才创建的：
```
@reboot /path/changeHosts.sh
```
使用 chmod +x /path/changeHosts.sh 将脚本设置为可执行。
使用 sudo visudo 命令，将 cron 设置为不需要 sudo 就能执行

在最下面一行添加如下：
```
%sudo ALL=NOPASSWD: /etc/init.d/cron
```
将 wsl-autostart 这个项目 clone 到 Windows 某个目录（本人是 C:\source\wsl）
```
git clone https://github.com/troytse/wsl-autostart
```
在注册表 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run 下创建一个字符串值

数值名称随便，数值数据设置成 start.vbs 所在目录：
打开刚才 clone 目录下的 commands.txt 文件，修改文件内容如下：
```
/etc/init.d/cron
```

测试：在 Powershell 中输入 wsl --terminal 关闭 WSL。随后手动运行一次 start.vbs，再次启动 WSL 后可以发现能够使用 win.local 这个地址访问 Windows 的服务了：

重启造成 IP 的变动也不会对我们访问 win.local 产生影响。开机后 vbs 脚本会启动 cron，随后 cron 会执行修改 hosts 的 shell 脚本，永远将 Windows 的 IP 和 win.local 这个网址绑在一起。

Update 2:

是我脑子一时短路了，路由器设置中指定机器为固定 IP，之后在 WSL2 内通过成静态 IP 即可直接访问 Windows 网络服务。

以 Padavan 为例，在高级设置 - 内部网络 (LAN) - DHCP 服务器 - 手动指定 IP 的 DHCP 列表中可设置静态 IP：

Windows 访问 WSL 网络服务

Windows 端直接使用 localhost 访问 WSL 启动的服务：

文件的互相访问

Windows 的所有磁盘被挂载在 WSL 的 /mnt 目录下。
WSL 的文件在 \\wsl$ 这个地址中找到，可通过 explorer 进行访问。

Proxy

我这里直接使用了 Windows 端的 v2ray，v2rayN 记得打开“允许来自局域网的连接”选项。zsh 配置如下（记得把 V2RAY 的值设置成自己 Windows 的 IP 和端口，或直接在 WSL 跑一个 v2ray 也是可以的）：

#proxy
V2RAY='win.local:10809'
defp=$V2RAY

# No Proxy
function noproxy
{
    unset http_proxy HTTP_PROXY https_proxy HTTPS_PROXY all_proxy ALL_PROXY ftp_proxy FTP_PROXY dns_proxy DNS_PROXY JAVA_OPTS GRADLE_OPTS MAVEN_OPTS
    echo "clear proxy done"
}

function setproxy
{
	if [ $# -eq 0 ]
	then
		inArg=$defp
	else
		inArg=$1
	fi
	HOST=$(echo $inArg |cut -d: -f1)
	PORT=$(echo $inArg |cut -d: -f2)
	http_proxy=http://$HOST:$PORT
	HTTP_PROXY=$http_proxy
	all_proxy=$http_proxy
	ALL_PROXY=$http_proxy
	ftp_proxy=$http_proxy
	FTP_PROXY=$http_proxy
	dns_proxy=$http_proxy
	DNS_PROXY=$http_proxy
	https_proxy=$http_proxy
	HTTPS_PROXY=$https_proxy
	JAVA_OPTS="-Dhttp.proxyHost=$HOST -Dhttp.proxyPort=$PORT -Dhttps.proxyHost=$HOST -Dhttps.proxyPort=$PORT"
	GRADLE_OPTS="-Dgradle.user.home=$HOME/.gradle"
	MAVEN_OPTS=$JAVA_OPTS
	no_proxy="localhost,127.0.0.1,localaddress,.localdomain.com,.huaweicloud.com,.coding.net,.ruby-china.org"
	echo "current proxy is ${http_proxy}"
	export no_proxy http_proxy HTTP_PROXY https_proxy HTTPS_PROXY all_proxy ALL_PROXY ftp_proxy FTP_PROXY dns_proxy DNS_PROXY JAVA_OPTS GRADLE_OPTS MAVEN_OPTS
}

在需要使用代理时，终端输入 setproxy 即可。在想要取消时输入 noproxy。比如：

➜  ~ setproxy
current proxy is http://win.local:10809
➜  ~ curl ipinfo.io
{
  "ip": "xxx",
  "hostname": "xxx",
  "city": "Hong Kong",
  "region": "Central and Western",
  "country": "HK",
  "loc": "xxx",
  "org": "xxx",
  "timezone": "Asia/Hong_Kong",
  "readme": "https://ipinfo.io/missingauth"
}%
➜  ~ noproxy # 取消代理
clear proxy done

参考：在Mac终端下配置Proxy

Docker

运行正常，我试着跑了个容器化的 TinyTinyRSS，没什么问题，爽到。

Docker Windows 版还出了一个以 WSL 2 为后端的新特性，我对以前的 Docker for Windows 有阴影，所以不尝试使用了，蹲篇对两者进行比较的文章。

GPU

无法使用 GPU，想用 WSL 跑机器学习啥的没戏，不过 MS 也说他们正慢慢迭代 WSL，敬请期待。

Systemd

无法使用，启动/停止服务要用 service。

缺陷

内存占用

内存使用显著增加，就开了个 MySQL 占用高达 3G：

本人 16G 内存勉强能用，如果内存被 WSL 撑爆了可以尝试用 wsl --shutdown 结束所有相关服务。

预览版带来的问题

5E 对战平台不支持在预览版系统运行。

解决：老老实实等正式版推送 | ~~用另一台电脑打 5E~~

Hyper-V 带来的问题

腾讯家的网游和部分使用 ByttlEye 反作弊系统的游戏无法运行。
其他模拟器会出问题，比如 Android Studio 自带的模拟器、我玩少前用的雷电模拟器、VirtualBox等...

解决：要玩这些游戏/要用其他模拟器时临时关闭“虚拟机平台”功能（要重启，有点麻烦） | ~~用另一台电脑打游戏/用模拟器~~

对了，贴一个开启 Hyper-V 后使用 Android 模拟器的办法：使用 Hyper-V 加速 Android 模拟器 | Kara。

另外 VMware Workstation 似乎已经推出和 Hpyer-V 共存的版本，我没 license key 就不倒腾了。

总结

WSL 2 的 I/O 表现比以往好太多，Miniconda 安装和 apt upgrade 速度可能比以前快了一倍不止，我有启用 WD，不知道把 WD 换成其他防护软件 IO 表现会不会更好
完整的 Linux 内核很爽，Docker 终于好用了
Systemd 还是不能用，如果要管理服务可以用 service 命令

2004 更新之后新添的 WSL2 搭配 Scoop 和 Windows Terminal 还算好用，有点 macOS + iTerm2 + brew 那味，不过这也会带来娱乐性的损失——好些游戏都无法运行。

参考

2019总结

2026-01-01T08:11:41+00:00

2019 要过去了，到了该写年度总结的时候。这份总结原本计划在元旦假期那几天写，无奈今晚失眠，就这么想到哪写哪吧。

学习

想到“学习”这个词时脑袋是空的——我这一年对于在校理论的学习完全没有印象，刚才迫不得已打开教务处查成绩才想起某些课程的印象。

喜欢的/比较有帮助的课：计算机网络、Python

软件测试是自己想好好学但摸了的课，虽说最后获得的成绩还算过得去，但感觉少了许多系统的知识，类似“熟悉关系型数据库理论及其应用”和“会用 MySQL”这种差距。

七月份去了学校组织的位于广州的实习，为时半个月的实习没学到什么，个人全程没干劲，在那边写了些爬虫和数据处理的代码，说实话自学都比这强。当然不乏有趣的经历，比如每晚和同学的桌游、一起看恐怖烂片等。

毕设选了个 JSP 网站开发，现在任务书还没下，对要做的内容和技术要求/限制一头雾水，已经预感到蛋疼了...

至于课外，依旧是 Java 相关更广的学习，从 J2EE 过渡到 Spring Boot 和各种框架，深度需要加强。其他的：看了看前端，初步入门了 Vue 和 Python。

CS:APP 和《Java 编程思想》只是稍微看了看的程度，去年的目标今年没完成。

今年连续两次 CET6 都没去考，想扇自己两巴掌，明年还剩一次机会，希望能拿下。顶着个 CET4 毕业也没什么事，但总觉着没拿到 CET6 有点丢人。

工作

秋招摸了个尾巴上岸，一家长沙非互联网公司，Java 开发，工资够活的水平，明年二月入职实习。个人对这份工作满意度一般，但我决定在长沙工作就注定没得太多选择，未来考虑去一线修福报。

2020

所剩无几的学生时期：老老实实学习（英语）、写毕设、实习，争取安稳毕业
技术：Java 方面继续努力，顺便看看 Golang 和 Vue
工作：转正，存点钱

更多罗嗦的文字丢在这里：2019 年度总结（续），没找到说明没写完或者被我回头删掉了。

将强智教务系统课表导出为 Ics 文件

2026-01-01T08:11:41+00:00

将强智教务系统的学生课表导出为 ics 文件的一些思路和记录。GitHub：bolitao/CSUFT_classs_schedule。

function getAesString(data, key0, iv0) { //加密
    key0 = key0.replace(/(^\s+)|(\s+$)/g, "");
    var key = CryptoJS.enc.Utf8.parse(key0);
    var iv = CryptoJS.enc.Utf8.parse(iv0);
    var encrypted = CryptoJS.AES.encrypt(data, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
    });
    return encrypted.toString(); // 返回的是base64格式的密文
}

用到的几个变量的定义：

var $aes_chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
/****默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1****/
var aes_chars_len = $aes_chars.length;

randomString() 函数，从 $aes_chars 这个字符串随机挑 len 次（每次一个 char）组成字符串：

function randomString(len) {
    var retStr = '';
    for (i = 0; i < len; i++) {
        retStr += $aes_chars.charAt(Math.floor(Math.random() * aes_chars_len));
    }
    return retStr;
}

用 Python 实现加密：

import base64
from Crypto.Cipher import AES
import random

aes_chars = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678"


def random_str(length):
    ret = ""
    for i in range(length):
        ret += random.choice(aes_chars)
    return ret


def pad(password):  # 把密码补充成符合 AES-128 CBC 规范形式
    password = random_str(64) + password
    password_length = len(password)
    add_count = AES.block_size - password_length % AES.block_size
    if add_count == 0:
        add_count = AES.block_size
    _pad = chr(add_count)
    return password + _pad * add_count


def password_encrypt(aes_key, user_password):
    iv = random_str(16)
    user_password = pad(user_password).encode("utf8")
    aes_key = str(aes_key.strip())
    cipher = AES.new(aes_key.encode("utf8"), AES.MODE_CBC, iv.encode("utf8"))
    return base64.b64encode(cipher.encrypt(user_password))

知道了登录的 POST URL 和表单构成，就能模拟登陆了，以下是一种实现：

import requests
from bs4 import BeautifulSoup
import encrypt

login_page_url = "http://authserver.csuft.edu.cn/authserver/login?service=http%3A%2F%2Fjwgl.csuft.edu.cn%2F"
login_post_url = "http://authserver.csuft.edu.cn/authserver/login?service=http%3A%2F%2Fjwgl.csuft.edu.cn%2F"
table_page = "http://jwgl.csuft.edu.cn/jsxsd/xskb/xskb_list.do"


def login(username, password):
    _session = requests.session()
    response = _session.get(login_page_url)
    content = BeautifulSoup(response.text, "lxml")
    # 截取第二个 script 标签
    script = str(content.select('script')[1])
    script = script.replace(" ", "")
    script = script.replace("\n", "")
    salt = script.split("=")[3][1:1 + 16]  # TODO: 比较死板的取 pwdDefaultEncryptSalt 方法，待完善
    encrypted_password = encrypt.password_encrypt(salt, password)
    form_content = content.form.find_all("input")
    for input_tag in form_content:  # 表单中其他字段
        if input_tag.has_attr("name"):
            if input_tag["name"] == "lt":
                lt = input_tag["value"]
            elif input_tag["name"] == "dllt":
                dllt = input_tag["value"]
            elif input_tag["name"] == "execution":
                execution = input_tag["value"]
            elif input_tag["name"] == "_eventId":
                _eventID = input_tag["value"]
            elif input_tag["name"] == "rmShown":
                rm_shown = input_tag["value"]
    form_data = {
        "username": username,
        "password": encrypted_password,
        "lt": lt,
        "dllt": dllt,
        "execution": execution,
        "_eventId": _eventID,
        "rmShown": rm_shown
    }
    login_response = _session.post(login_post_url, data=form_data)
    return _session

课表解析

这部分有几点要注意：

有的格子里有分隔符：---------------------，即前半学期上某课，后半学期上另一门课
有的课程在期中考试周停课，所以会有 1-8,10-17(周) 这种周期
有形如 1-6,8,10-17 或被分割更多的课程周次，没想到比较简洁的解决办法，留到日后重构再解决

我的解析实现都是 dirty code，还有些没清理的测试代码，总之写完回过来看把自己恶心吐了：

CSUFT_classs_schedule/table_parse.py at csuft · bolitao/CSUFT_classs_schedule

将课表数据转为 ics 文件

这一部分比较好写，参考了裙主的博文：

import datetime

start_year = 2019
start_month = 9
start_day = 2
school_term_start = datetime.date(start_year, start_month, start_day)

start_time = ['08:00', '09:55', '14:00', '15:55', '19:00']
end_time = ['09:40', '11:35', '15:40', '17:35', '20:40']
week_name = ['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU']


def info_to_ics(class_info, username):
    VCALENDAR = '''BEGIN:VCALENDAR
VERSION:2.0
CALSCALE:GREGORIAN
METHOD:PUBLISH
X-WR-CALNAME:%(username)s 的课程表
X-WR-TIMEZONE:Asia/Shanghai
X-WR-CALDESC:%(username)s 的课程表
BEGIN:VTIMEZONE
TZID:Asia/Shanghai
X-LIC-LOCATION:Asia/Shanghai
BEGIN:STANDARD
TZOFFSETFROM:+0800
TZOFFSETTO:+0800
TZNAME:CST
DTSTART:19700101T000000
END:STANDARD
END:VTIMEZONE''' % {'username': username}
    file = open('课程表.ics', 'w', encoding="utf-8")
    file.write(VCALENDAR)
    for info in class_info:
        vevent = '\nBEGIN:VEVENT\n'
        # 课程开始日期
        class_start_date = school_term_start + datetime.timedelta(weeks=int(info['start']) - 1) + datetime.timedelta(
            days=int(info['day_of_week']) - 1)
        # 课程开始时间
        class_start_time = datetime.datetime.strptime(start_time[int(info['period']) - 1], '%H:%M').time()
        # 课程开始 datetime
        class_start_datetime = datetime.datetime.combine(class_start_date, class_start_time)
        # 课程结束时间
        class_end_time = datetime.datetime.strptime(end_time[int(info['period']) - 1], '%H:%M').time()
        # 课程结束 datetime
        class_end_datetime = datetime.datetime.combine(class_start_date, class_end_time)
        vevent += 'DTSTART;TZID=Asia/Shanghai:{class_start_datetime}\n'.format(
            class_start_datetime=class_start_datetime.strftime('%Y%m%dT%H%M%S'))
        vevent += 'DTEND;TZID=Asia/Shanghai:{class_end_datetime}\n'.format(
            class_end_datetime=class_end_datetime.strftime('%Y%m%dT%H%M%S'))
        # 循环 TODO: 单双周
        # count 循环次数 interval 间隔 byday 日程所在星期
        count = int(info['end']) - int(info['start']) + 1
        interval = 0
        byday = week_name[int(info['day_of_week']) - 1]
        vevent += 'RRULE:FREQ=WEEKLY;WKST=MO;COUNT={count};INTERVAL={interval};BYDAY={byday}\n'.format(
            count=count, interval=interval, byday=byday)
        # 地点
        vevent += ('LOCATION:' + info['place'] + '\n')
        # 名称
        vevent += ('SUMMARY:' + info['subject'] + '\n')
        vevent += 'END:VEVENT\n'
        file.write(vevent)
    file.write('END:VCALENDAR')
    file.close()
    print("OK: 课程表.ics")

TODO

解决周次为 1-6,8,10-17 或分割次数更多的奇葩
多次输错密码时对验证码的处理
使用 Java + Jsoup 重构，~~提供 web 页面~~，突然想起学校教务处不支持外网访问，挂服务器上也没啥用，虽然可以用树莓派 + frp 做代理但是不想麻烦
单双周（手头没有这种课表数据，暂不实现）

参考

AMD Ryzen 平台如何安装 MacOS

2026-01-01T08:11:41+00:00

一些安装记录。

Ryzen macOS 仅为玩票性质，工作和生产环境请谨慎使用，时刻做好资料备份，想要稳定请看这里。

需要的工具

Python: 官方 Python 或者 Anaconda 都可以，记得把 Python 加入 PATH
gibMacOS: Python 实现的 macOS 安装器，可以直接安装 macOS 镜像和 clover 到 U 盘
Etcher: 烧录工具，如果使用 gibMacOS 那么不需要用这个
DiskGenius: 主要用来修改 EFI 分区，也可以用命令行直接挂载
AMD Vanilla Clover: AMD 的内核补丁，这个是在 AMD 平台安装 macOS 的关键
一个 U 盘
一块用来装 macOS 的硬盘（SSD 最佳）

安装

nVidia 似乎不更新 10.13 以上版本显卡驱动了，建议使用 A 卡。以下是本人硬件概览：

使用 gibMacOS 下载并安装镜像

clone 或下载 gibMacOS 项目，打开 SSTap 或者路由器白名单（酸酸乳全局没用），以管理员权限运行 gibMacOS.bat。寻找 AMD Vanilla 项目支持的 macOS版本，截至今日（2019/11/19）该项目支持的版本是 19B88，所以我下载序号为 2 的镜像。

去打两局马造或者喝杯茶把，快慢取决于网速和梯子质量：

下好之后关闭当前窗口，管理员权限运行 MakeInstall.bat，选择 U 盘，我这里是 6G，G 代表格式化为 GPT 格式：

按 y 确认后会进行格式化：

之后把刚才下载的路径复制到 cmd 里（shift + 右键文件就有“复制为路径”选项）：

等待后最终会出现以下界面：

至此 gibMacOS 部分的工作算是完成了。

配置 Clover

上一步完成后文件管理器会多一个 CLOVER 的盘符，这就是 U 盘的 EFI 分区了。

备份好原来的 "EFI\CLOVER\config.plist" 文件，到 AMD Vanilla Clover 下载 Ryzen 平台的 config.plist，之后拷贝到 EFI\CLOVER\ 目录。

删除 EFI\CLOVER\drivers\UEFI 的 OsxAptioFix3Drv.efi 文件，把 EFI\CLOVER\drivers\off 的 AptioMemoryFix.efi 文件复制到 EFI\CLOVER\drivers\UEFI。

关于 kext，我的思路是先装满足 macOS 启动的必须 kext，在 macOS 能启起来后再安装功能性 kext（比如蓝牙和声卡），以下是我机器所需要的 kext：

必须：FakeSMC.kext（Clover 自带）、Lilu.kext、NullCPUPowerManagement.kext、Whatevergreen.kext、AppleIntelMCEReporter.kext

网络相关：AIDA64 显示我的网卡是 Realtek RTL8168/8111 PCI-E Gigabit Ethernet Adapter (PHY: Realtek RTL8111) PCI，所以选用 RealtekRTL8111.kext

蓝牙和音频驱动不是安装时必须的，所以在安装完 macOS 后再折腾。

安装 macOS

进入 BIOS 选择从 U 盘启动，之后的事有奶子的人都会，就不多介绍了。

安装后要干的事

至此一个干净的 macOS 就安装好了：

但是还要做一些必要修改来保证顺利使用。

禁用自动更新

建议禁用自动更新，配合 AMD Vanilla 项目定期手动更新。

勤备份

如果非要把 Ryzen 平台的 macOS 做日常使用请一定一定一定勤于备份，尤其是要经常备份各种应用程序配置和代码。至于备份方式各凭本事，NAS、云服务、TimeMachine 啥的都可以拿来用。

安装音频驱动

把 AppleALC.kext 丢到 Clover 的 kext 文件夹下，然后到 Supported codecs 这个页面查找声卡对应的 layout ID，用 Clover Configurator 打开 config.plist，修改注入 ID 并重启即可。

把 Clover 安装到硬盘

一个最简单粗暴的方法：新建一个 FAT32 格式的分区，然后把 U 盘 EFI 分区内容拷贝到这个分区，BIOS 里调整启动顺序就好，这样做的好处是不对其他原有 EFI 分区做改动，减少手贱误删引导的几率。

从某个没有 EFI 分区的磁盘压缩 300MB 空间：

将这个未分配空间格式化成 FAT32 格式：

把原来 U 盘 EFI 内容拷贝到这个新分区，在 BIOS 修改磁盘启动顺序即可。

参考

AMD OS X Vanilla Guide - AMD OS X Vanilla AMD-OSX/AMD_Vanilla: Native AMD macOS via Clover & OpenCore

Nginx 笔记

2026-01-01T08:11:41+00:00

nginx 部署的一些笔记，仅仅能够用起来的程度。

简单上手

nginx.conf 首行换成自己的用户名。

以下是一个简单的网站配置：

server {
    listen 80;
    server_name shop.bolitao.xyz;
    location / {
        proxy_pass    http://127.0.0.1:8282;
    }
}

重新加载 nginx 后即可使用 ip 访问 web app。

SSL

直接用 Let's Encrypt 来获取证书，因为超级简单而且方便。

到 Certbot ACME 选择自己的 web 服务器和系统版本，选择后会给出使用 Certbot 的条件：

主要看中间，需要有一个能够使用 80 端口访问的 website。

以我的配置 (nginx, Ubuntu 18.04) 为例安装 Certbot：

sudo apt-get update
sudo apt-get install software-properties-common
sudo add-apt-repository universe
sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
sudo apt-get install certbot python-certbot-nginx

运行 certbot，让其自动获取并安装证书：

sudo certbot --nginx

输入邮箱以接收证书的更新和安全相关信息：

Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): xxxxx@xxx.xxx

需要同意其协议，阅读后输入 A 并回车即可：

Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: A

是否订阅邮箱，这个随意：

Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: Y

Certbot 会询问需要在哪个站点启用 HTTPS：

Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: shop.bolitao.xyz
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel): 1

安装完后询问是否使用 http -> https 的重定向，看自己的需求选：

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2

以上完毕后会输出一些有用的信息：

可以到 https://www.ssllabs.com/ssltest/analyze.html?d=域名 测试 SSL
告知用户证书、配置之类文件存放的位置（及时备份）
告知证书过期时间及更新证书的方法（certbot 会自动更新证书）
如果喜欢可以考虑捐赠

Congratulations! You have successfully enabled https://xxxxxxxxxxxxx.xxxx

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=xxxx.xxx.xx


IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   xxxxxxxxxxxxxxxxxxxxxxxxxxxx
   Your key file has been saved at:
   xxxxxxxxxx
   Your cert will expire on 2020-02-16. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

手动配置

// TODO

参考

How to Configure NGINX - linode.com 快速入门 - Let's Encrypt - 免费的SSL/TLS证书 - letsencrypt.org Configuring HTTPS servers - nginx.org

在 Hexo 中使用本地资源

2026-01-01T08:11:41+00:00

项目列表在 hexo 官方文档有介绍过如何使用本地资源，如果你恰好装了一个叫 hexo-abbrlink 的插件，并且本地资源使用的是 Post Asset Folder 的方式的话，那么很有可能在预览和部署页面都看不到想要的资源。

说到底其实就是 hexo-abbrlink 这个插件的问题，本来使用 ![](post_title/xxx.png) 就可以访问到文件，但是 hexo generate 因为 abbrlink 的影响，生成的文件夹都变成了短链接的样子：

知道原因后，改起来就简单了，只需要把原本图片 markdown 的 post_title 改成对应的 abbrlink 就好，即图片引用方式应为 ![](abbrlink/xxx.png)，abbrlink 在每篇 post 的头部就能找到，如果没有这个属性，hexo s 开启一下本地服务就会自动生成了。

不过我个人其实更喜欢建立 source/_v_images 这样混乱的方式，因为我使用的笔记软件是 VNote，博客、笔记啥的都丢在上面，使用 OneDrive 备份。每次要发表博客了只需从 VNote 拷贝 markdown、添加描述信息，然后把 VNote 的图片全拷到博客的 source/images，用编辑器把要发表文章中的 _v_images 替换成 iamges 就好。

说到底还是我不信任在线图床，至今还记得微博图床限制外链时连夜修改笔记图片的惨案。

如何使用云服务器挂卡

2026-01-01T08:11:41+00:00

我很久没挂卡了，这两天看见曾哥在捣鼓 ASF 我也重新跑了下这玩意，发现总挂卡时间好像有点长，台式机常开费电，干脆丢服务器上吧。

使用 Windows 服务器

这个是最简单的办法，直接远程到服务器，像操作自己的 Windows 电脑一样操作服务器就好，你甚至可以直接拷贝自己机器上的 ASF 和配置文件到服务器上直接运行——只需输入两步验证码。

使用 Linux 服务器

我本来以为在 Linux 环境跑需要安装 .NET Core SDK，后来发现有直接可以使用的 release，省了安装 dotnet 的步骤。

我使用的 SSH 工具是 Xshell，传输工具是 Xftp，其他工具用法类似。

下载 ASF

2019 年 9 月 26 日的最新稳定版本是 4.0.4.2，直接使用 wget 下载：

wget -S https://github.com/JustArchiNET/ArchiSteamFarm/releases/download/4.0.4.2/ASF-linux-x64.zip
mkdir asf
sudo apt install unzip
unzip -d ./asf ASF-linux-x64.zip
rm ASF-linux-x64.zip

其他版本修改 4.0.4.2 数字即可。

修改配置文件

如果你在自己的机器上运行过 ASF 那么可以省略这一步。

这里我使用最小配置，有更多需求时可以参考 wiki 修改配置。

前往 ASF web config，我们至少有两个文件需要生成。首先是程序配置，点击 ASF，选择对应的 ASF 版本，填写必须字段并选取需要的特性，下载即可。以下是我的配置参考：

{
  "s_SteamOwnerID": "xxxxx",
  "IPC": true,
  "Headless": false,
  "IPCPassword": "password"
}

s_SteamOwnerID 是 64 位 SteamID，可以在 SteamDB 查询自己的 ID。
IPC 可提供网页后台，方便使用，关于 IPC 的更多信息可以查看其 wiki。
IPCPassword 是网页登录密码。
Headless 影响命令行是否接受输入，建议直接设置为 false。

然后是 bot 配置文件，输入 steam 账户密码和 bot 名即可，json 文件大致如下：

{
  "SteamLogin": "bolitao",
  "SteamPassword": "passwd",
  "Enabled": true
}

将配置文件传至服务器

这两个 json 文件准备好后用 Xftp 丢到 asf 目录下的 config 文件夹下就好叻。

配置 IPC

如果需要 IPC 请放行防火墙和安全组的 1242 端口。

在 config 文件夹下创建 IPC.config 文件：

vim IPC.config

官方模板：

{
    "Kestrel": {
        "Endpoints": {
            "example-http4": {
                "Url": "http://127.0.0.1:1242"
            },
            "example-http6": {
                "Url": "http://[::1]:1242"
            },
            "example-https4": {
                "Url": "https://127.0.0.1:1242",
                "Certificate": {
                    "Path": "/path/to/certificate.pfx",
                    "Password": "passwordToPfxFileAbove"
                }
            },
            "example-https6": {
                "Url": "https://[::1]:1242",
                "Certificate": {
                    "Path": "/path/to/certificate.pfx",
                    "Password": "passwordToPfxFileAbove"
                }
            }
        },
        "PathBase": "/"
    }
}

我偷点懒，直接配成允许本地访问，然后再用 Nginx 代理出去：

{
    "Kestrel": {
        "Endpoints": {
            "HTTP": {
                "Url": "http://127.0.0.1:1242"
            }
        }
    }
}

如果没有域名/不设置代理，可以把 Url 部分改为 http://*:1242，使用 ip:1242 进行访问

注：这样直接粗暴的方法可能会有潜在安全风险，请至少设置 IPCPassword。

Nginx

在 Nginx 配置目录添加一个 asf.conf 配置，然后在 nginx.conf 中 include ASF 的配置。

一个最简单的配置文件内容如下：

server {
  server_name asf.bolitao.xyz;

  client_max_body_size 128M;

  location / {
    proxy_pass http://127.0.0.1:1242;
    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;
  }
}

之后使用 certbot 自动配置 SSL：

sudo certbot --nginx

运行 ASF

安装一些必要依赖：

sudo apt install libcurl3 libicu60 libkrb5-3 liblttng-ust0 libssl1.0.0 zlib1g # Ubuntu 16.04

可执行权限：

cd asf; chmod +x ArchiSteamFarm

运行 ASF：

./ArchiSteamFarm

后台运行

上述方法在关闭 SSH 窗口后程序也会自动结束，使程序常驻运行方法很多，这里使用 screen：

sudo apt install screen
screen -S asf
~/apps/asf/ArchiSteamFarm

# 其他 screen 命令
screen -ls # 列出运行中的 screen，会给出 pid，可以使用 kill -9 pid 结束进程
screen -r abc # 返回到名为 abc 的 screen

这样子我们的 ASF 云挂卡就跑起来了：

而且不论身处何地只要有网，我们都可以登录 ip:port 或域名来查看 ASF 的运行状态、进行 ASF 相关的操作：

各种小问题的解决记录

2026-01-01T08:11:41+00:00

日常和开发时遇到各种稀奇古怪小问题的解决记录。

Windows 下 CLion Remote 模式乱码

中文环境下 CLion 控制台连英文 debug 信息都乱码，非常离谱。

修改语言和编码

remote Linux 的语言改成全英文、shell 编码改成 UTF-8
Windows 系统语言设置成英文，区域改成英语（美国）、打开全局 UTF-8（Control Panel -> Clock and Region -> Region 的两个选项卡都要改）
CLion 的 SSH 选项中把 Communication Encoding 改成 UFT-8，Settings -> Editor -> File Encodings 下相关的编码选项全部改成 UFT-8

修改 CLion VM options

Help -> Edit Custom VM Options 添加如下：

-Dconsole.encoding=UTF-8
-Dfile.encoding=UTF-8

修改后就能在 CLion 里看到无乱码的 Debug 信息了：

以上同样适用于 tomcat 控制台、IDEA 等乱码情况。

语言其实可以不用改，只用改 IDE 的 Encoding，另外修改系统 encoding 可能导致一些中文软件和 VS 出问题。我喜欢一刀切所以全改了（

卡巴斯基导致 SMB 等局域网服务不可用

打开卡巴斯基-设置-保护-防火墙-配置包规则，修改以下红框中的四项：

删除 Local Services (TCP) 和 Local Services (UDP) 中被阻止的 139，445 端口：

将 Any incoming ICMP 和 ICMPv6 Echo Request (in) 规则中的地址由任意地址改为子网地址-公用网络，即不拦截局域网地址和受信任网络：

IDEA 和 Maven

使用 IDEA 创建 Maven 项目时最好用 IDEA 自带的 Maven，否则可能造成 IDEA 相关的兼容性问题。

在国内懒得配代理的话可以使用阿里的 maven 镜像，不要直接修改捆绑的 maven 配置，不然 toolbox 更新一下又得重写配置。可以在其他目录建一个 xml 文件来覆盖默认设置，比如我的配置 mirror.xml：

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
     <mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>
    </mirror> 
  </mirrors>
</settings>

在创建项目时做如下调整即可：

Manjaro 无法启用 SMB 服务

可以参考这篇 wiki：Using Samba in your File Manager - Manjaro Linux

其实我嫌麻烦所以干脆开了个 SSH 服务，用 SFTP 代替 SMB，Android 上 Solid Explorer 能够正常访问，IOS 自带文件管理器没试过，ComicShare 能够正常访问。

sudo systemctl enable sshd.service
sudo systemctl start sshd.service

数据结构复习

2026-01-01T08:11:41+00:00

数据结构相关的一些复习笔记，本文很长善用目录跳转。

数组

Array 的属性：size 表示已存在的元素个数，capacity 是 Array 的容积。

contains

判断 Array 中是否含有某个元素的办法是进行遍历：

public boolean contains(E value) {
    for (E m : data) {
        if (value.equals(m)) {
            return true;
        }
    }
    return false;
}

查找元素

从前往后遍历，找到则返回元素索引，没找到则返回 -1：

public int find(E value) {
    for (int i = 0; i < data.length; i++) {
        if (value.equals(data[i])) {
            return i;
        }
    }
    return -1;
}

resize

有时在进行添加/删除时需要对 Array 进行扩容/缩容操作，此时可以准备一个 resize 方法，在 Array 需要被扩容或者缩容时调用该方法，这个方法的思路是进行遍历将旧 Array 的元素一个个赋值给新 Array 中的元素：

private void resize(int newCapacity) {
    E[] newData = (E[]) new Object[newCapacity];
    for (int i = 0; i < size; i++) {
        newData[i] = data[i];
    }
    data = newData;
}

向 Array 中插入元素

向 Array 中添加元素时要考虑 Array 已满的情况，如果已经满了则进行扩容，具体为扩大一倍。

插入元素的思路是将被插入位置及其之后的元素向后移一位，最后把要插入的元素赋值给 data[index]，同时注意维护 size 的值。

public void add(int index, E value) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("add() failed. Requirement: 0 <=index <= size.");
    }
    if (size == data.length) {
        resize(2 * data.length);
    }
    for (int i = size - 1; i >= index; i--) {
        data[i + 1] = data[i];
    }
    data[index] = value;
    size++;
}

给出索引移除 Array 中的元素

移除元素则很简单，把要移除的元素赋值给 temp，被移除元素之后的元素各向前移动一位，最后将 temp 返回即可。注意调整 size 的值。

移除元素后需要判断是否要缩容，通常判断缩容的条件是已存在元素个数等于容积的一半，但我们无法预测下次对 Array 的操作是 add 还是 remove，如果是 add 那么又需要进行一次扩容，这样会造成时间浪费。

所以更改判断条件：当元素个数是容积的 1 / 4 时才进行缩容操作，并且此时只缩容一半（而不是缩容到原来的 1/ 4）以应对下次可能的 add 操作。

与此同时还存在一个边界特殊情况：capacity 为 1 时不能再进行缩容，这也是需要判断的条件之一。

public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("remove() failed, index is illegal.");
    }
    E removedValue = data[index];
    for (int i = index + 1; i < size; i++) {
        data[i - 1] = data[i];
    }
    size--;
    // loitering objects != memory leak
    data[size] = null;
    if (size == data.length / 4 && data.length / 2 != 0) {
        resize(data.length / 2);
    }
    return removedValue;
}

给出元素值并将其在 Array 中移除

如果要删除某个特定值的元素，只要进行查找然后调用 remove 方法即可：

public void removeElement(E value) {
    int index = find(value);
    if (-1 != index) {
        remove(index);
    }
}

附完整代码

package array;

/**
 * 自定义的 Array 类
 *
 * @author 陶波利
 */
public class Array<E> {
    private E[] data;
    private int size;

    public Array() {
        this(10);
    }

    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    public Array(E[] arr) {
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
    }

    public int getSize() {
        return size;
    }

    public int getCapacity() {
        return data.length;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get() failed, index is illegal.");
        }
        return data[index];
    }

    public void set(int index, E value) {
        data[index] = value;
    }

    public boolean isContaianed(E value) {
        for (E m : data) {
            if (value.equals(m)) {
                return true;
            }
        }
        return false;
    }

    public int find(E value) {
        for (int i = 0; i < data.length; i++) {
            if (value.equals(data[i])) {
                return i;
            }
        }
        return -1;
    }

    public void add(int index, E value) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add() failed. Requirement: 0 <=index <= size.");
        }
        if (size == data.length) {
            resize(2 * data.length);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = value;
        size++;
    }

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    public void addFirst(E value) {
        add(0, value);
    }

    public void addLast(E value) {
        add(size, value);
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove() failed, index is illegal.");
        }
        E removedValue = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        // loitering objects != memory leak
        data[size] = null;
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return removedValue;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size - 1);
    }

    public void removeElement(E value) {
        int index = find(value);
        if (-1 != index) {
            remove(index);
        }
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array: size = %d, capacity = %d\n", size, data.length));
        builder.append("[");
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append("]");
        return builder.toString();
    }

    public E getLast() {
        return get(size - 1);
    }

    public E getFirst() {
        return get(0);
    }

    /**
     * 交换索引为 i j 的元素
     *
     * @param i index i
     * @param j index j
     */
    public void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size) {
            throw new IllegalArgumentException("Index is illegal");
        }
        E temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

栈

栈接口

首先对栈进行一下抽象，栈的特性是先入后出，栈的主要三个方法是 push（入栈），pop（出栈），peek（查看栈顶元素）：

package stack;

public interface Stack<E> {
    int getSize();

    boolean isEmpty();

    void push(E e);

    E pop();

    E peek();
}

使用数组实现栈

实现很简单，直接用以前写的 Array 就好。

package stack;

import array.Array;

/**
 * @author Boli Tao
 */
public class ArrayStack<E> implements Stack<E> {
    Array<E> array;

    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }

    public ArrayStack() {
        array = new Array<>();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }


    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Stack: ");
        stringBuilder.append("[");
        for (int i = 0; i < array.getSize(); i++) {
            stringBuilder.append(array.get(i));
            if (i != array.getSize() - 1) {
                stringBuilder.append(", ");
            }
        }
        stringBuilder.append("] top");
        return stringBuilder.toString();
    }
}

使用链表实现栈

由于对于链表头节点的增删查操作时间复杂度为 O(1)，所以使用链表实现的栈性能较数组栈性能更好。

package stack;

import LinkedList.LinkedList;

/**
 * @author Boli Tao
 */
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> list;

    public LinkedListStack() {
        list = new LinkedList<E>();
    }

    @Override
    public int getSize() {
        return list.getSize();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void push(E e) {
        list.addFirst(e);
    }

    @Override
    public E pop() {
        return list.removeFirst();
    }

    @Override
    public E peek() {
        return list.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Stack: top ");
        builder.append(list);
        return builder.toString();
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        for (int i = 0; i < 10; i++) {
            linkedListStack.push(i);
            System.out.println(linkedListStack);
        }
        linkedListStack.pop();
        System.out.println(linkedListStack);
        System.out.println(linkedListStack.peek());
    }
}

队列

队列接口

队列的特性是先入先出（参考排队），重要的三个方法是enqueue（入队），dequeue（出队），getFront（查看队首元素）。

package queue;

public interface Queue<E> {
    int getSize();

    boolean isEmpty();

    void enqueue(E e);

    E dequeue();

    E getFront();
}

数组实现的队列

package queue;

import array.Array;

public class ArrayQueue<E> implements Queue<E> {
    Array<E> array = new Array<>();

    public ArrayQueue() {
        array = new Array<>();
    }

    public ArrayQueue(int capacity) {
        array = new Array<>(capacity);
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }

    @Override
    public E dequeue() {
        return array.removeFirst();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Queue: front [");
        for (int i = 0; i < array.getSize(); i++) {
            builder.append(array.get(i));
            if (i != array.getSize() - 1) {
                builder.append(", ");
            }
        }
        builder.append("] tail");
        return builder.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        for (int i = 0; i < 10; i++) {
            arrayQueue.enqueue(i);
        }
        System.out.println(arrayQueue);
        arrayQueue.dequeue();
        System.out.println(arrayQueue);
        arrayQueue.enqueue(20);
        System.out.println(arrayQueue);
    }
}

循环队列

判空：front == tail

规定满的条件：(tail + 1) % capacity == front。

由于总是浪费一个空间，所以 getCapacity() 方法返回的是 data.length - 1

resize()

重新分配容积时和数组的 resize() 方法类似，但是由于队列是循环的所以需要额外应对 tail 在 front 前的情况，比如下图：

此时遍历赋值时不能单纯使用 temp[i] = data[(front + i)]，而要使用 temp[i] = data[(front + i) % data.length]。调整容积后的 LoopQueue 可以看作一个标准的数组队列，需要将 front 调整为 0，tail 值调整为 size（size - 1 + 1）。

private void resize(int newCapacity) {
    E[] temp = (E[]) new Object[newCapacity];
    // 第一种遍历的方式
    for (int i = 0; i < size; i++) {
        temp[i] = data[(front + i) % data.length];
    }
    data = temp;
    front = 0;
    tail = size;
}

入队

和数组类似，入队时需要判断队列是否满，如果满需要进行扩容。入队后注意维护 tail 和 size 的值，size 直接 ++ 就好，而为了应对 tail 在 front 前的情况不能直接 ++，需要对 capacity 取余：

@Override
public void enqueue(E e) {
    if ((tail + 1) % data.length == front) {
        resize(getCapacity() * 2);
    }
    data[tail] = e;
    tail = (tail + 1) % data.length;
    size++;
}

出队

某元素出队后 front 只需要 ++ 即可，同样为了应对 front 从队尾跑到队首的情况要对 capacity 取余，注意调整 size 大小。

出队后和 Array 类似，可以判断是否进行缩容，原理和 Array 一样，当元素个数为容积的 1/4 时才进行缩容，并且只缩容到原容积的 1/2（而不是 1/4）以应对未知的下次操作。

@Override
public E dequeue() {
    if (isEmpty()) {
        throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
    }
    E ret = data[front];
    data[front] = null;
    front = (front + 1) % data.length;
    size--;
    if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
        resize(getCapacity() / 2);
    }
    return ret;
}

循环队列的两种遍历方式

请查看循环队列实现源码的注释部分，其实本质一样，我个人更能理解第一种。

循环队列所有代码

package queue;

/**
 * @author Boli Tao
 */
public class LoopQueue<E> implements Queue<E> {
    private E[] data;
    private int tail, front, size;

    public LoopQueue(int capacity) {
        data = (E[]) new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue() {
        this(10);
    }

    public int getCapacity() {
        return this.data.length - 1;
    }

    public boolean isFull() {
        return (tail + 1) % data.length == front;
    }

    private void resize(int newCapacity) {
        E[] temp = (E[]) new Object[newCapacity];
        // 第一种遍历的方式
        for (int i = 0; i < size; i++) {
            temp[i] = data[(front + i) % data.length];
        }
        data = temp;
        front = 0;
        tail = size;
    }

    @Override
    public int getSize() {
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        return front == tail;
    }

    @Override
    public void enqueue(E e) {
        if ((tail + 1) % data.length == front) {
            resize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size--;
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
            resize(getCapacity() / 2);
        }
        return ret;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is empty.");
        }
        return data[front];
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Queue: size = %d, capacity = %d.\n", size, getCapacity()));
        builder.append("front [");
        // 第二种遍历的方式
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            builder.append(data[i]);
            if ((i + 1) % data.length != tail) {
                builder.append(", ");
            }
        }
        builder.append("] tail");
        return builder.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>(5);
        for (int i = 0; i < 10; i++) {
            loopQueue.enqueue(i);
            System.out.println(loopQueue);
        }
        System.out.println();
        for (int i = 0; i < 10; i++) {
            loopQueue.dequeue();
            System.out.println(loopQueue);
        }
    }
}

链表实现的队列

package queue;

/**
 * @author Boli Tao
 */
public class LinkedListQueue<E> implements Queue<E> {
    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    private Node head, tail;
    private int size;

    public LinkedListQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void enqueue(E e) {
        if (tail == null) {
            tail = new Node(e);
            head = tail;
        } else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is empty, cannot dequeue.");
        }
        Node dequeueNode = head;
        E returnValue = dequeueNode.e;
        dequeueNode = null;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        size--;
        return returnValue;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException();
        }
        return head.e;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Queue: front ");
        Node current = head;
        while (current != null) {
            stringBuilder.append(current + "->");
            current = current.next;
        }
        stringBuilder.append("NULL tail");
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        for (int i = 0; i < 10; i++) {
            linkedListQueue.enqueue(i);
            System.out.println(linkedListQueue);
        }
        for (int i = 0; i < 10; i++) {
            linkedListQueue.dequeue();
            System.out.println(linkedListQueue);
        }
    }
}

优先队列

最大堆具有优先队列特性，在入队时通过下沉对优先级进行排序，并且可以保证每次出队都是优先级最高的元素。以下是最大堆实现的优先队列，关于最大堆可以看本人堆相关的文章。

package queue;

import heap.MaxHeap;

/**
 * @author 陶波利
 */
public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {
    private MaxHeap<E> maxHeap;

    public PriorityQueue() {
        maxHeap = new MaxHeap();
    }

    @Override
    public int getSize() {
        return maxHeap.size();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }

    @Override
    public void enqueue(E e) {
        maxHeap.add(e);
    }

    @Override
    public E dequeue() {
        return maxHeap.extractMax();
    }

    @Override
    public E getFront() {
        return maxHeap.getMax();
    }
}

链表

链表中的节点

节点中的 next 引用就是链表的精华了。

private class Node {
    public E e;
    public Node next;

    public Node() {
        this(null, null);
    }

    public Node(E e, Node next) {
        this.e = e;
        this.next = next;
    }

    public Node(E e) {
        this(e, null);
    }

    @Override
    public String toString() {
        return e.toString();
    }
}

虚拟头节点

为了便于之后的理解和使用在链表中添加一个虚拟头节点，无参构造函数会实例化 Node(null, null) 赋值给 dummyNode：

public LinkedList() {
    dummyNode = new Node();
    size = 0;
}

向链表中添加元素

想要在索引处添加一个元素只需要以 dummyNode 为 prev，一路 next 到索引位置即可，随后的插入只要执行 prev.next = new Node(666, prev.next) 即可。

public void add(int index, E e) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("add() filed, illegal index.");
    }
    Node prev = dummyNode;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }
    prev.next = new Node(e, prev.next);
    size++;
}

获取链表中某索引位置的值 get()

public E get(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Illegal argument");
    }
    Node current = dummyNode.next;
    for (int i = 0; i < index; i++) {
        current = current.next;
    }
    return current.e;
}

修改索引位置节点的值

和 get() 类似，当 current 节点经过循环到达索引处时，直接修改 current.e 即可。

public void update(int index, E e) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Illegal argument");
    }
    Node node = dummyNode.next;
    for (int i = 0; i < index; i++) {
        node = node.next;
    }
    node.e = e;
}

判断链表中是否某值

直接遍历链表，找到符合的返回 true，否则返回 false：

public boolean contains(E e) {
    Node current = dummyNode.next;
    while (current != null) {
        if (current.e.equals(e)) {
            return true;
        }
        current = current.next;
    }
    return false;
}

删除给定索引位置的元素

与添加操作类似，在删除操作中被删除节点的前序节点对于链表的连接有重要作用，图示删除索引为 2 的元素：

只需要执行 prev.next = delNode.next 即可。

此后需要让 delNode 脱离链表，以便 Java 进行垃圾回收，否则 delNode 会成为游离对象，具体操作即 delNode.next = null，这是一个个人比较难理解的地方，如果不明白可以看看 Java 的引用那一部分。

还是那句老话，不要忘记维护 size（

public E delete(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Illegal argument");
    }
    Node prev = dummyNode;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }
    Node deletedNode = prev.next;
    E deletedData = deletedNode.e;
    prev.next = deletedNode.next;
    size--;
    // deletedNode = null;
    deletedNode.next = null;
    return deletedData;
}

删除链表中的某个特定值

遍历、找到前序节点、进行删除。

public void removeElement(E e) {
    Node prev = dummyNode;
    while (prev.next != null) {
        if (prev.next.e.equals(e)) {
            break;
        }
        prev = prev.next;
    }
    if (prev.next != null) {
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size--;
    }
}

时间复杂度分析

添加操作

addLast(e)：O(n)

addFirst(e): O(1)

add(index, e): O(n /2) = O(n)

删除操作

removeLast(e): O(n)

removeFirst(e): O(1)

remove(index, e): O(n/2) = O(n)

修改

set(index, e): O(n)

查找

get(index): O(n)

contains(e): O(n)

总结

增 O(n)
删 O(n)
改 O(n)
查 O(n)

用途

由于对链表头节点来说其增删时间复杂度为 O(1)，并且如果只对头节点进行查找其复杂度也为 O(1)，因此其非常适合作为栈的实现，详见栈那篇文章的链表相关内容。

附完整代码

package LinkedList;

/**
 * @author Boli Tao
 */
public class LinkedList<E> {
    private class Node {
        public E e;
        public Node next;

        public Node() {
            this(null, null);
        }

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    private Node dummyNode;
    private int size;

    public LinkedList() {
        dummyNode = new Node();
        size = 0;
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add() filed, illegal index.");
        }
        Node prev = dummyNode;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }

    public void addFirst(E e) {
        add(0, e);
    }

    public void addLast(E e) {
        add(size, e);
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal argument");
        }
        Node current = dummyNode.next;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.e;
    }

    public E getFirst() {
        return get(0);
    }

    public E getLast() {
        return get(size - 1);
    }

    public void update(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal argument");
        }
        Node node = dummyNode.next;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        node.e = e;
    }

    public boolean contains(E e) {
        Node current = dummyNode.next;
        while (current != null) {
            if (current.e.equals(e)) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    public E delete(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal argument");
        }
        Node prev = dummyNode;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node deletedNode = prev.next;
        E deletedData = deletedNode.e;
        prev.next = deletedNode.next;
        size--;
        // deletedNode = null;
        deletedNode.next = null;
        return deletedData;
    }

    public E removeFirst() {
        return delete(0);
    }

    public E removeLast() {
        return delete(size - 1);
    }

    public void removeElement(E e) {
        Node prev = dummyNode;
        while (prev.next != null) {
            if (prev.next.e.equals(e)) {
                break;
            }
            prev = prev.next;
        }
        if (prev.next != null) {
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        // current != null 而不是 current.next != null
        for (Node current = dummyNode.next; current != null; current = current.next) {
            stringBuilder.append(current + "->");
        }
        stringBuilder.append("NULL");
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
        linkedList.add(2, 666);
        System.out.println(linkedList);
        linkedList.add(0, 0);
        System.out.println(linkedList);
        linkedList.addFirst(0);
        System.out.println(linkedList);
        linkedList.addLast(0);
        System.out.println(linkedList);
        linkedList.removeFirst();
        System.out.println(linkedList);
        linkedList.removeLast();
        System.out.println(linkedList);
        linkedList.delete(3);
        System.out.println(linkedList);
    }
}

二分搜索树

重要性质

用不那么严谨且好理解的话来说，就是左孩子小于父节点右孩子大于父节点。

向二分搜索树中添加元素

如果比父节点小则向左深入，如果大则向右深入，对相等节点不做操作（即二分搜索树中不包含重复元素），直到深入的下一个节点为空为止，此时将空节点替换为待插入节点。

比如，向 BST 中插入元素 52：

递归代码：

private Node add(Node root, E e) {
    if (root == null) {
        size++;
        return new Node(e);
    }
    if (e.compareTo(root.e) < 0) {
        root.left = add(root.left, e);
    } else if (e.compareTo(root.e) > 0) {
        root.right = add(root.right, e);
    }
    return root;
}

判断树中是否含有某个值（可用于查找算法）

private boolean contains(Node root, E e) {
    if (root == null) {
        return false;
    }
    if (e.compareTo(root.e) == 0) {
        return true;
    } else if (e.compareTo(root.e) < 0) {
        return contains(root.left, e);
    } else {
        return contains(root.right, e);
    }
}

遍历

广度优先遍历（层序遍历）

层序遍历通常使用队列帮助实现：

public void levelOrder() {
    Queue<Node> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        Node current = queue.remove();
        System.out.println(current.e);
        if (current.left != null) {
            queue.add(current.left);
        }
        if (current.right != null) {
            queue.add(current.right);
        }
    }
}

深度优先遍历

前序遍历

先访问节点，再访问其左右孩子。

非递归的前序遍历通常借助栈来实现，注意左右孩子的入栈顺序：先入右孩子再入左孩子，这样出栈时才能保证顺序为“父-左-右”。

public void preOrderNR() {
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        Node current = stack.pop();
        System.out.println(current.e);
        if (current.right != null) {
            stack.push(current.right);
        }
        if (current.left != null) {
            stack.push(current.left);
        }
    }
}

递归：

private void preOrder(Node root) {
    if (root == null) {
        return;
    }
    System.out.println(root.e);
    preOrder(root.left);
    preOrder(root.right);
}

中序遍历

遍历顺序为左-中-右。

中序遍历的一个特性是其输出按大小排列。

示意图：

递归代码实现：

private void inOrder(Node root) {
    if (root == null) {
        return;
    }
    inOrder(root.left);
    System.out.println(root.e);
    inOrder(root.right);
}

后序遍历

递归代码：

private void postOrder(Node root) {
    if (root == null) {
        return;
    }
    postOrder(root.left);
    postOrder(root.right);
    System.out.println(root.e);
}

取得 BST 中的最小值

由二分搜索树的定义一直往左取就能得到最小值：

private Node minimum(Node node) {
    if (node.left == null) {
        return node;
    }
    return minimum(node.left);
}

取得 BST 中的最大值

private Node maximum(Node node) {
    if (node.right == null) {
        return node;
    }
    return maximum(node.right);
}

删除 BST 中的最小元素

private Node removeMin(Node node) {
    if (node.left == null) {
        Node rightNode = node.right;
        node.right = null;
        size--;
        return rightNode;
    }
    node.left = removeMin(node.left);
    return node;
}

删除 BST 中的最大元素

private Node removeMax(Node node) {
    if (node.right == null) {
        Node leftNode = node.left;
        node.left = null;
        size--;
        return leftNode;
    }
    node.right = removeMax(node.right);
    return node;
}

删除 BST 中某个给定值的元素

递归找到待删除节点
判断三种情形：
1. 如果待删除节点左子树为空：图中 58 为待删除元素，此时将 58 的右孩子直接返回。
2. 如果待删除结点右子树为空：直接返回左孩子即可。
3. 如果待删除结点左右子树都不为空：待删除节点为 D，此时需要找到 D 右子树的最小节点 S，将 S 替代 D。此外，寻找比 D 小的最大值来顶替 D 也是可行的（即 D 的左子树中的最大节点 53）。

/**
 * 删除以 node 为根的值为 e 的节点
 *
 * @param node 根节点
 * @param e    待删除节点的值
 * @return 删除之后的根节点
 */
private Node remove(Node node, E e) {
    if (node == null) {
        return null;
    }
    if (e.compareTo(node.e) < 0) {
        node.left = remove(node.left, e);
        return node;
    }
    if (e.compareTo(node.e) > 0) {
        node.right = remove(node.right, e);
        return node;
    } else { // e equals node.e
        // 待删除结点左子树为空的情况
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        // 待删除结点右子树为空的情况
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        /*
        待删除节点左右节点都不为空的情况：
        找到比待删除结点大的最小节点 a（即右子树的最小节点），用这个节点 a 顶替待删除结点
        注意 size 的变化情况
        另外：找待删除结点左子树的最大值作为顶替节点 a 也是可以的
        */
        Node successor = minimum(node.right);
        successor.right = removeMin(node.right);
        size++;
        successor.left = node.left;
        node.left = node.right = null;
        size--;
        return successor;
    }
}

BST 的性能

在二分搜索树性能取决于树的形状，在平衡状态下，性能为 O(logn)。在最坏情况下 BST 退化为链表，性能为 O(n)。

附 BST 完整代码

package BST;

import java.util.*;

/**
 * 二分搜索树，不包含重复元素
 *
 * @author Boli Tao
 */
public class BST<E extends Comparable<E>> {
    private class Node {
        E e;
        Node left, right;

        public E getE() {
            return e;
        }

        Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
        }


        public void setE(E e) {
            this.e = e;
        }

        public Node getLeft() {
            return left;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public Node getRight() {
            return right;
        }

        public void setRight(Node right) {
            this.right = right;
        }
    }

    private Node root;
    private int size;

    public BST() {
        root = null;
        size = 0;
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void add(E e) {
        root = add(root, e);
    }

    /**
     * 向二叉树中插入节点，忽略重复元素
     *
     * @param root 根节点（也包含子树的根节点）
     * @param e    需要插入的元素
     * @return 插入新节点后二叉树的根
     */
    private Node add(Node root, E e) {
        if (root == null) {
            size++;
            return new Node(e);
        }
        if (e.compareTo(root.e) < 0) {
            root.left = add(root.left, e);
        } else if (e.compareTo(root.e) > 0) {
            root.right = add(root.right, e);
        }
        return root;
    }

    public boolean contains(E e) {
        return contains(root, e);
    }

    /**
     * 判断以 root 为根的树是否含有值 e
     *
     * @param root 树的根
     * @param e    需要查询的值
     * @return 是否找到
     */
    private boolean contains(Node root, E e) {
        if (root == null) {
            return false;
        }
        if (e.compareTo(root.e) == 0) {
            return true;
        } else if (e.compareTo(root.e) < 0) {
            return contains(root.left, e);
        } else {
            return contains(root.right, e);
        }
    }

    /**
     * 非递归的前序遍历
     */
    public void preOrderNR() {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node current = stack.pop();
            System.out.println(current.e);
            if (current.right != null) {
                stack.push(current.right);
            }
            if (current.left != null) {
                stack.push(current.left);
            }
        }
    }

    /**
     * 二分搜索树的前序遍历
     */
    public void preOrder() {
        preOrder(root);
    }

    /**
     * 前序遍历以 root 为根的二分搜索树
     *
     * @param root 树根
     */
    private void preOrder(Node root) {
        if (root == null) {
            return;
        }
        System.out.println(root.e);
        preOrder(root.left);
        preOrder(root.right);
    }

    public void inOrder() {
        inOrder(root);
    }

    /**
     * 中序遍历以 root 为根的二叉搜索树
     * 重要特性：二分搜索树的中序遍历输出是按大小顺序排列的
     *
     * @param root 根节点
     */
    private void inOrder(Node root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.println(root.e);
        inOrder(root.right);
    }

    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.e);
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        generateBSTString(root, 0, result);
        return result.toString();
    }

    private void generateBSTString(Node root, int depth, StringBuilder stringBuilder) {
        if (root == null) {
            stringBuilder.append(generateDepthString(depth)).append("null\n");
            return;
        }
        stringBuilder.append(generateDepthString(depth)).append(root.e).append("\n");
        generateBSTString(root.left, depth + 1, stringBuilder);
        generateBSTString(root.right, depth + 1, stringBuilder);
    }

    private String generateDepthString(int depth) {
        StringBuilder builder = new StringBuilder();
//        for (int i = 0; i < depth; i++) {
//            builder.append("Depth: ").append(depth).append(", ");
//        }
        builder.append("Depth: ").append(depth).append(", ");
        return builder.toString();
    }

    /**
     * 层序遍历/ 广度优先遍历
     */
    public void levelOrder() {
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node current = queue.remove();
            System.out.println(current.e);
            if (current.left != null) {
                queue.add(current.left);
            }
            if (current.right != null) {
                queue.add(current.right);
            }
        }
    }

    public E getMin() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty.");
        }
        return minimum(root).e;
    }

    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    public E getMax() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty.");
        }
        return maximum(root).e;
    }

    private Node maximum(Node node) {
        if (node.right == null) {
            return node;
        }
        return maximum(node.right);
    }

    public E removeMin() {
        E ret = getMin();
        root = removeMin(root);
        return ret;
    }

    /**
     * 删除以 node 为根的最小节点
     *
     * @param node 根节点
     * @return 删除元素后新的二分搜索树的根
     */
    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    public E removeMax() {
        E ret = getMax();
        root = removeMax(root);
        return ret;
    }

    private Node removeMax(Node node) {
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }

    public void remove(E e) {
        root = remove(root, e);
    }

    /**
     * 删除以 node 为根的值为 e 的节点
     *
     * @param node 根节点
     * @param e    待删除节点的值
     * @return 删除之后的根节点
     */
    private Node remove(Node node, E e) {
        if (node == null) {
            return null;
        }
        if (e.compareTo(node.e) < 0) {
            node.left = remove(node.left, e);
            return node;
        }
        if (e.compareTo(node.e) > 0) {
            node.right = remove(node.right, e);
            return node;
        } else { // e equals node.e
            // 待删除结点左子树为空的情况
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            // 待删除结点右子树为空的情况
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            /*
            待删除节点左右节点都不为空的情况：
            找到比待删除结点大的最小节点 a（即右子树的最小节点），用这个节点 a 顶替待删除结点
            注意 size 的变化情况
            另外：找待删除结点左子树的最大值作为顶替节点 a 也是可以的
            */
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            size++;
            successor.left = node.left;
            node.left = node.right = null;
            size--;
            return successor;
        }
    }
}

集合和映射

集合

接口

package set;

/**
 * @author 陶波利
 */
public interface Set<E> {
    void add(E e);

    void remove(E e);

    boolean contains(E e);

    int getSize();

    boolean isEmpty();
}

基于二分搜索树实现的集合

package set;

import BST.BST;
import tool.FileOperation;

import java.util.ArrayList;

/**
 * 二分搜索树实现的集合
 *
 * @author 陶波利
 */
public class BinarySearchTreeSet<E extends Comparable<E>> implements Set<E> {
    private BST bst;

    public BinarySearchTreeSet() {
        bst = new BST();
    }

    @Override
    public void add(E e) {
        bst.add(e);
    }

    @Override
    public void remove(E e) {
        bst.remove(e);
    }

    @Override
    public boolean contains(E e) {
        return bst.contains(e);
    }

    @Override
    public int getSize() {
        return bst.getSize();
    }

    @Override
    public boolean isEmpty() {
        return bst.isEmpty();
    }
}

基于链表实现的集合

package set;

import LinkedList.LinkedList;

/**
 * 链表实现的集合
 *
 * @author 陶波利
 */
public class LinkedListSet<E> implements Set<E> {
    private LinkedList linkedList;

    public LinkedListSet() {
        linkedList = new LinkedList();
    }

    @Override
    public void add(E e) {
        if (!linkedList.contains(e)) {
            // 在链表头插入元素时间复杂度更小
            linkedList.addFirst(e);
        }
    }

    @Override
    public void remove(E e) {
        linkedList.removeElement(e);
    }

    @Override
    public boolean contains(E e) {
        return linkedList.contains(e);
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }
}

集合的复杂度分析

映射

链表实现的映射

package map;

/**
 * 链表实现的映射
 *
 * @author 陶波利
 */
public class LinkedListMap<K, V> implements Map<K, V> {
    private class Node {
        public K key;
        public V value;
        public Node next;

        public Node(K key, V value, Node next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public Node(K key) {
            this(key, null, null);
        }

        public Node() {
            this(null, null, null);
        }

        @Override
        public String toString() {
            return "Node{" +
                    "key=" + key +
                    ", value=" + value +
                    ", next=" + next +
                    '}';
        }
    }

    private Node dummyHead;
    private int size;

    public LinkedListMap() {
        dummyHead = new Node();
        size = 0;
    }

    private Node getNode(K key) {
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.key.equals(key)) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    /**
     * 添加元素
     * 如果 key 重复，则进行更新
     *
     * @param key   key
     * @param value value
     */
    @Override
    public void add(K key, V value) {
        Node node = getNode(key);
        if (node == null) {
            dummyHead.next = new Node(key, value, dummyHead.next);
            size++;
        } else {
            node.value = value;
        }
    }

    @Override
    public V remove(K key) {
        Node prev = dummyHead;
        while (prev.next != null) {
            if (prev.next.key.equals(key)) {
                break;
            }
            prev = prev.next;
        }
        if (prev.next != null) {
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
            return delNode.value;
        }
        return null;
    }

    @Override
    public boolean contains(K key) {
        return !(getNode(key) == null);
    }

    @Override
    public V get(K key) {
        Node node = getNode(key);
        return node == null ? null : node.value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(key);
        if (node == null) {
            new IllegalArgumentException(key + " doesn't exist.");
        } else {
            node.value = newValue;
        }
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }
}

BST 实现的映射

package map;

/**
 * 二分搜索树实现的映射
 *
 * @author 陶波利
 */
public class BinarySearchTreeMap<K extends Comparable<K>, V> implements Map<K, V> {
    private class Node {
        public K key;
        public V value;
        public Node left, right;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BinarySearchTreeMap() {
        root = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    private Node add(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = add(node.right, key, value);
        } else {
            // map 中已存在需插入的 key 情况：更新 value 的值
            node.value = value;
        }
        return node;
    }

    /**
     * 返回以 node 为根的二分搜索树中 key 所在的节点
     *
     * @param node 根节点
     * @param key  key
     * @return 根节点
     */
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else {
            return getNode(node.right, key);
        }
    }

    @Override
    public boolean contains(K key) {
        return !(getNode(root, key) == null);
    }

    @Override
    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException(key + " doesn't exist.");
        } else {
            node.value = newValue;
        }
    }

    @Override
    public V remove(K key) {
        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else {
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;
            return successor;
        }
    }
}

堆

堆的表示方式

二叉堆实质是一个完全二叉树，定义最大堆为父节点总是大于其子节点。

二叉堆可以使用数组存储，如图：

其父节点与子节点的关系：

parent(i) = (i -1) / 2
lChild(i) = i * 2  + 1
rChild(i) = i * 2 + 2

堆的父子节点关系

上一节有做说明和伪代码，这里直接贴 Java 代码：

private int parent(int index) {
    if (index == 0) {
        throw new IllegalArgumentException("index 0 doesn't have parent.");
    }
    return (index - 1) / 2;
}

private int leftChild(int index) {
    return index * 2 + 1;
}

private int rightChild(int index) {
    return index * 2 + 2;
}

上浮堆中元素

在向堆中添入元素后，为了满足堆的性质可能要将元素上浮。比如：

向堆中添加 52，为了满足堆的性质需要将 52 上浮到索引为 1 的位置。上浮操作是：拿 52 与其父节点进行比较，如果大于其父节点则进行交换，直到元素达到合适位置。

相应代码：

/**
 * 为满足最大堆性质而设计的元素上浮方法
 *
 * @param k 需要被上浮的元素索引
 */
private void siftUp(int k) {
    while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
        data.swap(k, parent(k));
        k = parent(k);
    }
}

向堆中添加元素

上一节已经实现过元素的上浮，所以添加操作顺理成章变得很简单，只需要把元素添加到数组末尾，然后调用上浮函数。

public void add(E e) {
    data.addLast(e);
    siftUp(data.getSize() - 1);
}

得到堆中最大值

直接 get(0) 即可。

下沉堆中元素

有时堆中可能出现某元素破坏堆性质，可能需要对该元素进行下沉操作，比如：

此时需要下沉 16 以维持堆的性质。下沉思路如下：

将元素与子节点比较，与子结点中比自己大且是最大的元素交换位置，比如上图中索引 0 和索引 1 要交换位置
交换位置后继续进行比较，直到自己比所有子节点大或者成为叶子

/**
 * 为满足最大堆性质而设计的元素下沉方法
 *
 * @param k 需要被下沉的元素索引
 */
private void siftDown(int k) {
    while (leftChild(k) < data.getSize()) {
        int j = leftChild(k);
        if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {
            j = rightChild(k);
        }
        // ↑此时 j 表示孩子节点中更大元素的索引
        if (data.get(k).compareTo(data.get(j)) > 0) {
            break;
        }
        data.swap(k, j);
        k = j;
    }
}

取出堆中最大元素(extractMax)

public E extractMax() {
    E ret = getMax();
    data.swap(0, data.getSize() - 1);
    data.removeLast();
    siftDown(0);
    return ret;
}

heapify、replace

heapify 使用构造函数实现：传入一个数组时，通过下沉将数组变成一个最大堆。

public MaxHeap(E[] arr) {
    data = new Array<>(arr);
    for (int i = parent(arr.length - 1); i >= 0; i--) {
        siftDown(i);
    }
}

在某些情况下需要将某元素替换掉堆顶元素，可以写一个 replace() 方法：

public E replace(E e) {
    E ret = getMax();
    data.set(0, e);
    siftDown(0);
    return ret;
}

堆的应用

优先队列，可以看本人队列相关的博客文章。

代码

package heap;

import array.Array;

import java.util.Random;

/**
 * @author 陶波利
 */
public class MaxHeap<E extends Comparable<E>> {
    private Array<E> data;

    public MaxHeap(int capacity) {
        data = new Array<>(capacity);
    }

    public MaxHeap() {
        data = new Array<>();
    }

    /**
     * 构造函数：将传入数组组成为最大堆
     *
     * @param arr 待化为最大堆的数组
     */
    public MaxHeap(E[] arr) {
        data = new Array<>(arr);
        for (int i = parent(arr.length - 1); i >= 0; i--) {
            siftDown(i);
        }
    }

    public int size() {
        return data.getSize();
    }

    public boolean isEmpty() {
        return data.isEmpty();
    }

    /**
     * @param index index
     * @return index 的父节点的索引
     */
    private int parent(int index) {
        if (index == 0) {
            throw new IllegalArgumentException("index 0 doesn't have parent.");
        }
        return (index - 1) / 2;
    }

    private int leftChild(int index) {
        return index * 2 + 1;
    }

    private int rightChild(int index) {
        return index * 2 + 2;
    }

    /**
     * 向堆中添加元素
     *
     * @param e 待添加的元素值
     */
    public void add(E e) {
        data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    /**
     * 为满足最大堆性质而设计的元素上浮方法
     *
     * @param k 需要被上浮的元素索引
     */
    private void siftUp(int k) {
        while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
            data.swap(k, parent(k));
            k = parent(k);
        }
    }

    /**
     * 取出堆中最大元素
     *
     * @return max value
     */
    public E extractMax() {
        E ret = getMax();
        data.swap(0, data.getSize() - 1);
        data.removeLast();
        siftDown(0);
        return ret;
    }

    public E getMax() {
        if (data.getSize() == 0) {
            throw new IllegalArgumentException("Size is 0, no element in heap.");
        }
        return data.get(0);
    }

    /**
     * 为满足最大堆性质而设计的元素下沉方法
     *
     * @param k 需要被下沉的元素索引
     */
    private void siftDown(int k) {
        while (leftChild(k) < data.getSize()) {
            int j = leftChild(k);
            if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {
                j = rightChild(k);
            }
            // ↑此时 j 表示孩子节点中更大元素的索引
            if (data.get(k).compareTo(data.get(j)) > 0) {
                break;
            }
            data.swap(k, j);
            k = j;
        }
    }

    public E replace(E e) {
        E ret = getMax();
        data.set(0, e);
        siftDown(0);
        return ret;
    }

    /**
     * 测试类
     *
     * @param args args
     */
    public static void main(String[] args) {
        int n = 1000000;
        MaxHeap<Integer> maxHeap = new MaxHeap<>();
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            maxHeap.add(random.nextInt(Integer.MAX_VALUE));
        }
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = maxHeap.extractMax();
        }
        for (int i = 1; i < n; i++) {
            if (arr[i - 1] < arr[i]) {
                throw new IllegalArgumentException("Error: 最大堆实现出现问题！");
            }
        }
        System.out.println("Completed!");
    }
}

红黑树

Wikipedia 对 Red–black tree 的性质描述如下：

In addition to the requirements imposed on a binary search tree the following must be satisfied by a red–black tree:

Each node is either red or black.

The root is black. This rule is sometimes omitted. Since the root can always be changed from red to black, but not necessarily vice versa, this rule has little effect on analysis.

All leaves (NIL) are black.

If a node is red, then both its children are black.

Every path from a given node to any of its descendant NIL nodes contains the same number of black nodes.

嗯...很复杂，光是听描述就要自闭，为了更方便理解红黑树可以先了解 2-3 树。

2-3 树

2-3 树的除了满足二分搜索树的基本性质外还有一个性质：节点可以存放一个或两个元素。

比如以下节点：

满足 leftChild < b < midChild < c < rightChild。

此外 2-3 树还是一颗绝对平衡树：从根节点到任意叶子节点所经过的节点数量一定相同。

这一性质由其 add 方式决定：2-3 树添加节点时永远不会添加到空的位置（有别于二分搜索树），而是和最后找到的叶子节点融合，如果节点数大于三，则进行分裂。

2-3 树转化为红黑树

对一个 2-3 树中的三节点，将其转化为二叉树，并且定义左侧/较小的值为子节点，规定所有红色节点为左倾，转化为红黑树中的节点则为：

e.g.

以上 2-3 树的红黑树形式为：

红黑树的定义

根是黑色

2-3 树等价的两种红黑树如下：

2 节点：

3 节点：

可见根节点总会是黑色。

所有叶子都是黑色（叶子是NIL节点）

可以看做一条定义，最后的空节点是黑色。比如空树这种特殊情况。

每个红色节点必须有两个黑色的子节点

红色节点的子节点在 2-3 树中为一个三节点的 lChild 或 mChild，lChild 和 mChild 只可能为二节点或三节点。

如果是二节点则直接对应红黑树中的黑色节点。

如果是三节点，其转化成红黑树的样式之后子树根节点仍为黑色（红黑树的性质）。

此外还有一相似性质：黑色节点的右孩子一定是黑色。

从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点

先看 2-3 树具有的相似性质：因为 2-3 树是绝对平衡的，所有叶子节点位于同一深度，所以显然由某一节点到其任一叶子经过的节点数相同。

而 2-3 树中每一个二节点在红黑树中对应一个黑色节点，每一个三节点对应红黑树中的一个黑色节点 + 红色节点。每经过 2-3 树的一个节点必经过其对应红黑树的一个黑色节点，所以从红黑树中某节点到其叶子所经过的黑色节点数相同。

红黑树的复杂度

2-3 树是一种绝对平衡的二叉树，而严格意义上红黑树不是，由红黑树性质五可知红黑树是”黑平衡”的二叉树。

在最差情况下，红黑树的最大高度为 2logn，即该红黑树对应的 2-3 树都是三节点。去掉常数，红黑树查找、修改、添加、删除的时间复杂度为 O(logn)。

编码实现红黑树

// TODO: 秋招结束后有空再更新

哈希表

哈希函数

整型

小范围整数直接使用
小范围负整数进行偏移 -100 ~ 100 → 0 ~ 200

大整数：模一个素数

e.g.

以下情况哈希冲突很严重：

模素数的结果分布更均匀：

对不同整型规模取模时素数的参考：good hash table primes

浮点型

字符串

转为整形处理

由整形组成：

$$123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0$$

可以推出：

$$code = c * 26^3 + o * 26^2 + d * 26^1 + e * 26^0$$

对于更复杂的字符串（区分大小写、包含符号等）可以使用更大的进制。

所以哈希函数可以设置如下：

$$hash(code) = (c * B^3 + o * B^2 + d * B^1 + e * B^0) \bmod P$$

即：

$$hash(code) = ((((c * B) + o) * B + d) * B + e) \bmod P$$

为防止计算机运行时整形溢出，可以变形为：

$$hash(code) = ((((c \bmod P) * B + o) \bmod P * B + d) \bmod P * B + e) \bmod P$$

其中 B 为进制数，P 为对整数取模用的素数，Java 代码：

int hash = 0;
for (int i = 0; i < str.length(); i++) {
    hash = (hash * B + str.charAt(i)) % P;
}

复合类型

与字符串类似。

e.g.

对于数据类型 Date，有 year, month, day 三个属性，可以设置其哈希函数为：

$$ hash(date) = (((date.year \bmod P) * B + date.month) \bmod P * B + date.day) \bmod P $$

Java 中的 `hashCode`

哈希冲突的处理

编码实现哈希表

复杂度分析

排序算法复习

2026-01-01T08:11:41+00:00

排序算法的一些复习笔记。

顺便分享一个视频，群魔乱舞到秩序与整洁的变化挺爽的（小心精神污染）：15 Sorting Algorithms in 6 Minutes - YouTube

冒泡排序

维基百科：

重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序对n个项目需要O(n^2)的比较次数，且可以原地排序。

演示：

代码：

package bubble;

import java.util.Random;

/**
 * @author Boli Tao
 */
public class BubbleSort {
    /**
     * 交换 arr 数组中索引为 index1 和 index2 的值
     *
     * @param arr    array
     * @param index1 index1
     * @param index2 index2
     */
    public static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    /**
     * bubble sort
     *
     * @param arr the array to be sorted
     */
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    public static void main(String[] args) {
        Random random = new Random();
        int[] array = new int[100000];
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(Integer.MAX_VALUE);
        }
        bubbleSort(array);
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i + 1] < array[i]) {
                throw new IllegalArgumentException("冒泡排序写错了");
            }
        }
        System.out.println("Test complete.");
    }
}

选择排序

冒泡排序比较的是相邻元素，而选择排序是比较整体，并且选择排序交换的是最小值和未经排序“头部”元素。其时间复杂度为 O(n^2)。

演示：

代码：

package selection;

/**
 * @author Boli Tao
 */
public class SelectionSort {
    /**
     * 交换 arr 数组中索引为 index1 和 index2 的值
     *
     * @param arr    array
     * @param index1 index1
     * @param index2 index2
     */
    private static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int min_idx = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[min_idx]) {
                    min_idx = j;
                }
            }
            swap(arr, i, min_idx);
        }
    }

    public static void main(String[] args) {
        int[] arr = {37, 18, 7, 5, 24, 46, 28, 35, 11, 13, 2};
        selectionSort(arr);
        System.out.print("Sorted array:\n[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) {
                System.out.print(" ,");
            }
        }
        System.out.print("]");
    }
}

插入排序

插入排序通过找到合适位置进行插入达到排序目的。时间复杂度为 O(n^2)。

演示：

代码：

package insertion;

/**
 * @author Boli Tao
 */
public class InsertionSort {
    static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            // 后移
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            // 插入
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {37, 18, 7, 5, 24, 46, 28, 35, 11, 13, 2};
        insertionSort(arr);
        StringBuilder builder = new StringBuilder();
        builder.append("Sorted array:\n[");
        for (int i = 0; i < arr.length; i++) {
            builder.append(arr[i]);
            if (i != arr.length - 1) {
                builder.append(" ,");
            }
        }
        builder.append("]");
        System.out.println(builder.toString());
    }
}

归并排序

空间复杂度 O(n)，时间复杂度 O(nlogn)。

演示：

package merge;

/**
 * @author 陶波利
 */
public class MergeSort {
    private static void merge(int[] arr, int l, int m, int r) {
        int leftArraySize = m - l + 1;
        // r - (m + 1) + 1
        int rightArraySize = r - m;

        // temp array
        int[] leftTempArray = new int[leftArraySize];
        int[] rightTempArray = new int[rightArraySize];

        // 把 arr 中的数据拷入两个 temp 数组
        for (int i = 0; i < leftArraySize; i++) {
            leftTempArray[i] = arr[l + i];
        }
        for (int i = 0; i < rightArraySize; i++) {
            rightTempArray[i] = arr[m + 1 + i];
        }

        // 两个 temp 数组的索引
        int i = 0, j = 0;
        // arr 数组的索引
        int k = l;

        // 将 temp 数组的数据按顺序填入 arr
        while (i < leftArraySize && j < rightArraySize) {
            if (leftTempArray[i] <= rightTempArray[j]) {
                arr[k] = leftTempArray[i];
                i++;
            } else {
                arr[k] = rightTempArray[j];
                j++;
            }
            k++;
        }

        while (i < leftArraySize) {
            arr[k] = leftTempArray[i];
            i++;
            k++;
        }

        while (j < rightArraySize) {
            arr[k] = rightTempArray[j];
            j++;
            k++;
        }
    }

    public static void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int m = (l + r) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }

    public static void main(String[] args) {
        int[] arr = {37, 18, 7, 5, 24, 46, 28, 35, 11, 13, 2};
        mergeSort(arr, 0, arr.length - 1);
        StringBuilder builder = new StringBuilder();
        builder.append("Sorted array:\n[");
        for (int i = 0; i < arr.length; i++) {
            builder.append(arr[i]);
            if (i != arr.length - 1) {
                builder.append(" ,");
            }
        }
        builder.append("]");
        System.out.println(builder.toString());
    }
}

快速排序

快速排序相比冒泡排序，不是比较相邻元素，而是比较和交换大数和小数，做到把小数浮到上面、大数沉到下面。

快速排序不稳定，平均时间复杂度为 O(nlogn)。

演示：

代码：

package quick;

import java.util.Random;

/**
 * @author 陶波利
 */
public class QuickSort {
    /**
     * 交换 arr 数组中索引为 index1 和 index2 的值
     *
     * @param arr    array
     * @param index1 index1
     * @param index2 index2
     */
    private static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[left];
        int pivotIndex = left;
        while (left < right) {
            // 从右侧开始寻找比基准数小的元素的索引
            while (left < right && arr[right] >= pivot) {
                right--;
            }
            //从左侧开始寻找比基准数大的元素的索引
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            // 把大数移到右边，小数移到左边
            swap(arr, left, right);
        }
        // 把 pivot 移到中间
        swap(arr, pivotIndex, left);
        return left;
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int pi = partition(arr, left, right);
        quickSort(arr, left, pi - 1);
        quickSort(arr, pi + 1, right);
    }

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    public static void main(String[] args) {
        Random random = new Random();
        int[] array = new int[1000000];
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(Integer.MAX_VALUE);
        }
        sort(array);
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i + 1] < array[i]) {
                throw new IllegalArgumentException("快排写错了");
            }
        }
    }
}

堆排序

平均时间复杂度为 O(nlogn)。

自己实现一个最大堆，所有的问题都迎刃而解。

代码：

package heap;

import array.Array;

import java.util.Random;

/**
 * @author 陶波利
 */
public class MaxHeap<E extends Comparable<E>> {
    private Array<E> data;

    public MaxHeap(int capacity) {
        data = new Array<>(capacity);
    }

    public MaxHeap() {
        data = new Array<>();
    }

    /**
     * 构造函数：将传入数组组成为最大堆
     *
     * @param arr 待化为最大堆的数组
     */
    public MaxHeap(E[] arr) {
        data = new Array<>(arr);
        for (int i = parent(arr.length - 1); i >= 0; i--) {
            siftDown(i);
        }
    }

    public int size() {
        return data.getSize();
    }

    public boolean isEmpty() {
        return data.isEmpty();
    }

    /**
     * @param index index
     * @return index 的父节点的索引
     */
    private int parent(int index) {
        if (index == 0) {
            throw new IllegalArgumentException("index 0 doesn't have parent.");
        }
        return (index - 1) / 2;
    }

    private int leftChild(int index) {
        return index * 2 + 1;
    }

    private int rightChild(int index) {
        return index * 2 + 2;
    }

    /**
     * 向堆中添加元素
     *
     * @param e 待添加的元素值
     */
    public void add(E e) {
        data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    /**
     * 为满足最大堆性质而设计的元素上浮方法
     *
     * @param k 需要被上浮的元素索引
     */
    private void siftUp(int k) {
        while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
            data.swap(k, parent(k));
            k = parent(k);
        }
    }

    /**
     * 取出堆中最大元素
     *
     * @return
     */
    public E extractMax() {
        E ret = getMax();
        data.swap(0, data.getSize() - 1);
        data.removeLast();
        siftDown(0);
        return ret;
    }

    public E getMax() {
        if (data.getSize() == 0) {
            throw new IllegalArgumentException("Size is 0, no element in heap.");
        }
        return data.get(0);
    }

    /**
     * 为满足最大堆性质而设计的元素下沉方法
     * TODO: 需要进一步理解
     *
     * @param k 需要被下沉的元素索引
     */
    private void siftDown(int k) {
        while (leftChild(k) < data.getSize()) {
            int j = leftChild(k);
            if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {
                j = rightChild(k);
            }
            // ↑此时 j 表示孩子节点中更大元素的索引
            if (data.get(k).compareTo(data.get(j)) > 0) {
                break;
            }
            data.swap(k, j);
            k = j;
        }
    }

    public E replace(E e) {
        E ret = getMax();
        data.set(0, e);
        siftDown(0);
        return ret;
    }

    /**
     * 测试类
     *
     * @param args args
     */
    public static void main(String[] args) {
        int n = 1000000;
        MaxHeap<Integer> maxHeap = new MaxHeap<>();
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            maxHeap.add(random.nextInt(Integer.MAX_VALUE));
        }
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = maxHeap.extractMax();
        }
        for (int i = 1; i < n; i++) {
            if (arr[i - 1] < arr[i]) {
                throw new IllegalArgumentException("Error: 最大堆实现出现问题！");
            }
        }
        System.out.println("Completed!");
    }
}

自定义的 Array 类如下：

package array;

/**
 * 自定义的 Array 类
 *
 * @author 陶波利
 */
public class Array<E> {
    private E[] data;
    private int size;

    public Array() {
        this(10);
    }

    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    public Array(E[] arr) {
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
    }

    public int getSize() {
        return size;
    }

    public int getCapacity() {
        return data.length;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get() failed, index is illegal.");
        }
        return data[index];
    }

    public void set(int index, E value) {
        data[index] = value;
    }

    public boolean isContaianed(E value) {
        for (E m : data) {
            if (value.equals(m)) {
                return true;
            }
        }
        return false;
    }

    public int find(E value) {
        for (int i = 0; i < data.length; i++) {
            if (value.equals(data[i])) {
                return i;
            }
        }
        return -1;
    }

    public void add(int index, E value) {
//        if (size >= data.length) {
//            throw new IllegalArgumentException("add() method failed, array is full.");
//        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add() failed. Requirement: 0 <=index <= size.");
        }
        if (size == data.length) {
            resize(2 * data.length);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = value;
        size++;
    }

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    public void addFirst(E value) {
        add(0, value);
    }

    public void addLast(E value) {
        add(size, value);
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove() failed, index is illegal.");
        }
        E removedValue = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        // loitering objects != memory leak
        data[size] = null;
        if (size == data.length / 4 && data.length / 2 != 0) {
            // TODO: / 4?
            resize(data.length / 2);
        }
        return removedValue;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size - 1);
    }

    public void removeElement(E value) {
        int index = find(value);
        if (-1 != index) {
            remove(index);
        }
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array: size = %d, capacity = %d\n", size, data.length));
        builder.append("[");
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append("]");
        return builder.toString();
    }

    public E getLast() {
        return get(size - 1);
    }

    public E getFirst() {
        return get(0);
    }

    /**
     * 交换索引为 i j 的元素
     *
     * @param i index i
     * @param j index j
     */
    public void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size) {
            throw new IllegalArgumentException("Index is illegal");
        }
        E temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

希尔排序

package shell;

import java.util.Random;

/**
 * @author 陶波利
 */
public class ShellSort {
    private static void shellInsert(int[] arr, int d) {
        for (int i = d; i < arr.length; i++) {
            int j = i - d;
            //记录要插入的数据
            int temp = arr[i];
            //从后向前，找到比其小的数的位置
            while (j >= 0 && arr[j] > temp) {
                //向后挪动
                arr[j + d] = arr[j];
                j -= d;
            }
            //存在比其小的数
            if (j != i - d) {
                arr[j + d] = temp;
            }
        }
    }

    public static void shellSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int d = arr.length / 2;
        while (d >= 1) {
            shellInsert(arr, d);
            d /= 2;
        }
    }

    public static void main(String[] args) {
        Random random = new Random();
        int[] array = new int[1000000];
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(Integer.MAX_VALUE);
        }
        shellSort(array);
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i + 1] < array[i]) {
                throw new IllegalArgumentException("希尔排序写错了");
            }
        }
        System.out.println("Test complete.");
    }
}

参考： Sorting Algorithms - GeeksforGeeks francistao/LearningNotes: Enjoy Learning. VisuAlgo - visualising data structures and algorithms through animation 排序算法 - 维基百科，自由的百科全书

Kara

2023

数据

数字生活

RescueTime

ManicTime

游戏

微软

索尼

任天堂

PC

音乐

Apple Music

网易云音乐

工作

GitLab

个人榜单

剁手

最好评

最差评

游戏

音乐

剧集

总结

来年

2023 年，如何简单方便地迁移系统

Windows

迁移

迁移后问题处理

Linux

迁移

迁移后问题处理（扩容）

删除 Swap

扩容

重新添加 swap

Ref.

使用 FFmpeg 将 ManicTime 的截图转成视频

自建 RSS 服务迁移至 Miniflux

起因

部署

域名

备份方案

TTRSS 星标数据处理

插件方式

通过 API 自行导出

体验

Ref.

2022：未来不会更好

效率

消费

iPhone 14

自建 NAS

12600KF

吉他

机械革命无界 16

臻享视界 165Hz 2K 显示器

红米 AX6S

Jetbrains IntelliJ IDEA

游戏

艾尔登法环

异度神剑 3

荒野大镖客：救赎 2

AI：梦境档案 涅槃计划

十三機兵防衛圏

TLOU2

死亡搁浅岛剪版

死亡循环

战神：诸神黄昏

神秘海域：盗贼传奇合辑

音乐

剧集

孤独摇滚！

Cyberpunk: Edgerunners

相合之物

异世界舅舅

我

AI 梦境档案 2 通关

从 0 到 1 的 NAS 记录

前任

第二台 NAS

AI：梦境档案涅槃计划