涛声依旧

AI反代好工具-Agent2Api推荐

2026-11-13T03:42:19.000Z

# 起因：额度都锁在客户端里

现在手里能用的 AI 额度，一多半是跟着客户端走的：某个 IDE 送的、某个 CLI 登录后才有的、某个网页版账号每天签到的。这些额度要么只能在它自家的客户端里点，要么协议各说各话 ——OpenAI 的 Chat Completions、Responses，Anthropic 的 Messages，还有一堆只有自家才认的私有接口。

想把这些额度接进 Cherry Studio、Open WebUI、LobeChat，或者接进自己的脚本里跑点自动化，就得有个东西站在中间，把客户端的登录态接过来，翻译成标准的 OpenAI 兼容接口。这就是所谓「AI 反代」。

试过几个之后，这段时间一直在用的是 Agent2API（ aimod-cc/agent2api ），记录一下。

# 项目基本情况

仓库：https://github.com/aimod-cc/agent2api
定位：本地 AI 路由网关 + Agent 客户端接管
协议：AGPL-3.0
形态：桌面端（Windows /macOS/ Linux）、无头服务器（Windows Server / Linux）、Docker（amd64 /arm64）
默认端口：3065，同一个端口既是管理面板也是 OpenAI 兼容网关

一句话概括它的思路：复用各家客户端的登录态，用一个 base_url 调 50 多家模型额度，统一 OpenAI / Anthropic / 生图接口，多账号选路、签到、余额和请求报表全在一个面板里。

# 功能介绍

1. 统一模型接口

同时提供 OpenAI 的 Chat Completions、Responses、Images 和 Anthropic 的 Messages 接口，模型目录统一管理。也就是说 Cherry Studio 这种只认 OpenAI 的客户端，和 Claude Code 这种只认 Anthropic 的，可以共用同一个网关、同一个 key。生图和参考图编辑也在里面（小浣熊、Loomy、Antigravity、ModelScope、WorkBuddy、豆包工作台这些来源）。

2. AI 路由

模型映射、账号优先级、负载均衡、会话粘性和故障切换放在一处配。实际用起来最舒服的是「会话粘性」—— 同一轮对话固定走同一个账号，缓存命中率会好看很多。

3. Agent 客户端接管

这个是我觉得最省事的部分。它不只是给你一个 URL，还能管理本地客户端的多套连接配置：一键导入现有设置、预览将要写入的内容、在「走网关」和「走官方」之间切换。改完即时生效，不用手工去翻各个客户端的 json 配置文件。

4. Provider 插件化

50 多家 provider 不是全塞在主程序里，而是按插件独立安装、独立更新。主程序升级不会把 provider 的实现冲掉；自定义 provider 则不需要装插件。

5. 出口代理

可以给每个账号单独选代理池出口。多账号场景下这点很关键 —— 同一个 IP 上挂一堆账号，风控基本躲不过。作者还和 ProxyLane 有合作，用优惠码 AGENT2API25 首购 25% off（这个按需，不是必须）。

6. 网关安全

网关 key 支持作用域划分；面板登录可以开人机验证；没配 key 的时候模型请求默认直接拒绝，不会出现部署完就裸奔的情况。

7. 请求报表

请求量、成功率、token 消耗、缓存命中率，还有账号和 provider 的排行、用量环形图、365 天活跃热力图。趋势页是双轴的：24 小时缓存命中率折线 + token 消耗面积图。排查「到底是谁在烧额度」比翻日志快多了。

8. 后台维护

模型目录定时刷新、凭证维护、更新检查，外加每日自动签到 —— 按 provider 各自的时间窗跑（Qoder 10:01，ZCode 19:01，其它按设定时间），之后还有一轮补签，只补没签到的账号。

9. 手机端

浏览器打开 http://<网关IP>:3065/m 就是移动端面板，可以「添加到主屏幕」当 PWA 用；也有独立的 apk /ipa（iOS 那个未签名，要自己签）。

# 适合什么场景

把 IDE / CLI 送的额度接进 Cherry Studio、Open WebUI、LobeChat、new-api 之类的地方统一用
多账号轮着用，顺手看余额、签到、用量统计
给自己的脚本、机器人、内部小工具提供一个稳定的统一入口

反过来，如果只是想把几个正规的 API key 聚合成一个入口做分发，那 one-api /new-api 更合适，不需要 Agent2API 这套「接管客户端」的机制。

# 如何下载

Release 页面：https://github.com/aimod-cc/agent2api/releases

按用途挑一个就行：

# 桌面端
Agent2API_<版本>_x64-setup.exe        # Windows
Agent2API_<版本>_universal.dmg        # macOS
Agent2API_<版本>_amd64.deb / .AppImage # Linux

# 服务器（无界面，注册成系统服务，开机自启）
agent2api-server-windows-amd64.zip
agent2api-server-linux-<arch>.tar.gz

# Docker
aimodcc/agent2api:latest              # amd64 / arm64

桌面端的用法：添加自定义 provider 和账号 → 建一个网关 key → 到 Agent 页面应用连接配置，或者直接把客户端指向 http://127.0.0.1:3065/v1 并填上 key。

服务器版的安装：

	# Linux
	tar -xzf agent2api-server-linux-amd64.tar.gz && cd agent2api-server-linux-amd64 && sudo bash install.sh

	# Windows Server（管理员 PowerShell）
	Expand-Archive agent2api-server-windows-amd64.zip -DestinationPath C:\agent2api-pkg
	cd C:\agent2api-pkg; .\install-service.ps1

# Docker 安装

方式一：一条命令跑起来

docker run -d --name agent2api --restart unless-stopped -p 3065:3065 -v ./data:/data aimodcc/agent2api:latest

注意 ./data 建议换成绝对路径，比如 -v /opt/agent2api/data:/data ，不然换个目录执行 compose/run 就找不到原来的数据了。ARM 的机器（群晖、树莓派、ARM 云主机）直接拉就行，镜像本身就是多架构的。

方式二：docker compose（推荐）

	services:
	agent2api:
	image: aimodcc/agent2api:latest
	container_name: agent2api
	restart: unless-stopped
	ports:
	- "3065:3065" # 网关（/v1/*）与面板
	environment:
	# 可选项：不填就走面板首次登录注册
	AGENT2API_ADMIN_USER: admin
	AGENT2API_ADMIN_PASSWORD: 换成你自己的密码
	# 登录页人机验证，默认开；1 开 0 关
	AGENT2API_CAPTCHA_ENABLED: 1
	# 面板「设置 → 软件更新」一键更新，默认开
	AGENT2API_SELF_UPDATE: 1
	volumes:
	# 全部状态（SQLite 库、配置、日志）都在这一个卷里
	- ./data:/data
	# 小内存机器（512M~1G 的 VPS / NAS）建议加个上限，超限重启一次而不是拖垮宿主机
	# mem_limit: 1g

	docker compose up -d
	docker compose logs -f agent2api

方式三：面板和网关分端口（想把面板留在内网）

设了 AGENT2API_PANEL_PORT 之后，管理面（界面 + /api/* ）单独监听那个端口，主端口只剩 /v1/* 网关。这时候只把网关暴露到公网，面板绑回环：

	environment:
	AGENT2API_PANEL_PORT: 3066
	ports:
	- "3065:3065" # 网关，公网可暴露
	- "127.0.0.1:3066:3066" # 面板，只绑本机，走 SSH 隧道或内网访问

验证部署

	# 连通性检查
	curl http://127.0.0.1:3065/health

返回正常就打开面板 http://<主机IP>:3065/ ，首次打开会提示注册管理员账号（如果 compose 里预置了账号密码，启动时会自动转成 bcrypt 哈希入库，直接登录即可）。

首次配置流程

面板里添加 provider，选版本后网页登录授权（登录态就存在本地库里了）
到「网关 Key」页创建一个 key，按需要划作用域
客户端填 base_url = http://<主机IP>:3065/v1 ，key 用上一步建的
模型名在「模型管理」页的目录里选，填对应的映射名

验证一下能不能通：

	curl http://127.0.0.1:3065/v1/chat/completions \
	-H "Authorization: Bearer sk-你建的key" \
	-H "Content-Type: application/json" \
	-d '{"model":"<模型管理里选一个>","messages":[{"role":"user","content":"你好"}]}'

升级与备份

	# 标准升级：拉新镜像重建容器
	docker compose pull && docker compose up -d

	# 备份 = 打包 data 卷
	tar -czf agent2api-$(date +%F).tar.gz -C /opt/agent2api data

面板里的「软件更新」替换的是容器内的文件，compose 里的镜像 tag 没变，所以下次 up -d 重建容器会退回旧版本。要么就用 docker compose pull 升级，要么就别开自更新。

# 几个实际踩到的点

端口冲突：3065 不算冷门，装之前先 ss -lntp | grep 3065 看一眼。
账号要配出口：不配代理直接跑，多账号很容易触发风控。账号页里一个账号一个出口，别图省事共用。
别公网裸奔：面板默认就在 3065 上，公网暴露的话至少开人机验证、给 key 划作用域；能绑内网就绑内网。
./data 里是敏感数据：SQLite 库里存着加密后的账号凭证，导出和备份文件可能是明文级别的东西，别往 Git、网盘、群聊里丢。
出问题先看日志： docker compose logs -f agent2api 基本能定位到是鉴权、供应商还是网络的问题。
模型名对不上：客户端里报 model not found，多半是模型目录里的名字和映射没对上，回「模型管理」页看一眼实际可用列表。

# 使用须知

项目是 AGPL-3.0，商用、修改、分发都允许，但对外提供网络服务时要按要求提供对应源码。
凭证虽然在库里加密，但导出、备份、key 文件仍可能含敏感信息。
复用客户端登录态这件事，各家服务条款的态度并不一致，仅建议个人研究自用，别拿去对外卖 token 做中转站，封号风险自担。
项目本身 as-is 提供，不担保可用性、稳定性和安全性。

# 小结

Agent2API 属于那种「装上就一直在后台待着」的工具：平时想不起来它，但每次要换客户端、要加账号、要看这个月谁烧了多少额度，都会去面板点两下。对于手里额度散落在十几个客户端里的人，省下来的配置时间比它占的那点内存值多了。

如果只是想聚合几个正规 API key，one-api /new-api 更轻；如果要接管客户端登录态、还要多账号调度和报表，那这个目前是我用过最顺手的。

自建私服

2025-10-04T14:55:00.000Z

# 前言

国庆闲的无聊，自建了两个私服。有感兴趣的朋友可以一起玩玩！不充值不氪金不变态，纯休闲娱乐！

# 客户端下载

客户端

# 魔兽世界注册

注册账号

极空间部署DeepSeek（API调用）

2025-02-16T14:32:00.000Z

# 前言

最近 DeepSeek 比较火爆，到处都在夸。大部分人都想搭建自己的私有服务器，但我查了查资料还是放弃了想法，毕竟需要投入一笔不小的费用！🙂，最后又经不住诱惑就搞一个调用 api 的吧。经过研究，最终决定使用 justsong/one-api 加 vinlic/deepseek-free-api 加 yidadaa/chatgpt-next-web 的方案。justsong/one-api 用于统一管理、调用 AI 服务（当然也可以调用自己搭建的 DeepSeek🙂），vinlic/deepseek-free-api 用于调用 DeepSeek 官方接口，yidadaa/chatgpt-next-web 提供 web 界面用户和 ai 进行对话。大致了解清楚后就开始吧！

# 前期准备

需要自己先申请一个 DeepSeek 账号，并获取 token。获取方法是登陆后随便说一句话，然后按 F12 到应用程序 - 存储 - 本地存储中找到 userToken 的 value 值。

# 安装 deepseek-free-api

1、端口

2、环境

增加参数 DEEP_SEEK_CHAT_AUTHORIZATION 值：userToken 的 value 值

# 安装 one-api

1、文件夹与路径
2、端口
3、配置

登陆 web 页面（极空间 ip+one-api 的本地端口，默认用户名密码 root/123456），先添加渠道，再添加令牌。渠道用于调用指定的 api，我这里调用的是 deepseek-free-api（密钥为 userToken 的 value 值）。令牌用于给 chatgpt-next-web 使用，记录、控制权限等。

# 安装 chatgpt-next-web

1、端口
2、环境

参数 OPENAI_API_KEY 的值填 one-api 令牌页面复制的值。再增加一个 BASE_URL 参数，值为 one-api 的地址（极空间 ip+one-api 的本地端口）

3、对话

恭喜你，至此已经搭建完成。通过极空间 ip+chatgpt-next-web 的本地端口就可以开始和 DeepSeek 对话了。

# nginx proxy manager 配置

chatgpt-next-web 反代时需要在高级里加入以下代码，否则会报错。

	location / {
	proxy_pass http://极空间ip:chatgpt-next-web的本地端口;
	proxy_set_header Host $host;
	proxy_set_header X-Forwarded-Host $http_host;
	proxy_set_header X-Forwarded-Proto $scheme;
	}

最终成果

dante+stunnel+clash 科学上网

2024-09-29T08:25:00.000Z

# 前言

上次介绍了使用 squid+stunnel 的方案进行科学上网。但是那个方案只适合在浏览器上使用，并不能让其它 app 也可以科学上网。此次介绍使用 dante+stunnel+clash 的方式来代理其它 app 科学上网。

# 准备

一台可以访问外网的服务器，如香港的云主机并安装 Ubuntu 系统。

# dante 部分

1、安装

apt-get install -y dante-server

2、配置

修改 dante 配置
1、修改 /etc/danted.conf 文件，在末尾加入下面的配置
2、如果不需要用户密码认证，则把 socksmethod 改为 none
3、可以为认证单独添加一个用户
sudo useradd -r -s /bin/false proxy
sudo passwd proxy
4、重启服务
systemctl restart danted
5、查看状态
systemctl status danted

	logoutput: syslog
	internal: 0.0.0.0 port = 1080
	external: eth0

	socksmethod: username
	clientmethod: none

	user.privileged: root
	user.notprivileged: nobody

	client pass {
	from: 0.0.0.0/0 to: 0.0.0.0/0
	}

	socks pass {
	from: 0.0.0.0/0 to: 0.0.0.0/0
	}

# stunnel 服务端部分

1、安装（和 danted 装在一起）

apt-get install -y stunnel

2、生成 TLS/SSL 证书

openssl req -new -x509 -days 3650 -nodes -out stunnel.pem -keyout stunnel.pem

3、将证书 stunnel.pem 放到 /etc/stunnel/ 目录下
4、修改 stunnel 配置 (/etc/stunnle/stunnle.conf)

	; 设置stunnel的pid文件路径
	pid = /etc/stunnel/stunnel.pid
	; 设置stunnel工作的用户（组）
	setuid = root
	setgid = root

	; 开启日志等级：emerg (0), alert (1), crit (2), err (3), warning (4), notice (5), info (6), or debug (7)
	debug = 7
	; 日志文件路径
	output = /etc/stunnel/stunnel.log

	; 证书文件
	cert = /etc/stunnel/stunnel.pem
	; 私钥文件
	key = /etc/stunnel/stunnel.pem

	; 自定义服务名danted
	[danted]
	; 服务监听的端口，client要连接这个端口与server通信
	accept = 1081
	; 服务要连接的端口，连接到danted的1080端口，将数据发给danted
	connect = 1080

5、重启服务
systemctl restart stunnel4
6、查看状态
systemctl status stunnel4

# stunnel 客户端部分

可以安装在要代理的机器上，在需要代理的情况下再开启（代理地址填 127.0.0.1 加客户端监听端口）。也可以安装在国内的服务器上一直保持连接（代理信息填国内服务器 ip 加客户端监听端口）。本示例客户端为 ubuntu 系统

1、安装（和 danted 装在一起）

apt-get install -y stunnel

2、修改配置（/etc/stunnel/stunnel.conf）

	[danted]
	; 监听端口，用户的代理设置就是 stunnel-client-ip:1080
	accept = 1080
	; 要连接到的stunnel server的ip与端口
	connect = stunnel服务端ip:1081
	client = yes
	; 需要验证对方发过来的证书
	;verify = 2
	; 用来进行证书验证的文件
	;CAfile = /etc/stunnel/stunnel-server.pem

# Clash 部分

1、下载
Clash 客户端
2、配置

新建订阅

编辑文件并写入以下配置

	# Profile Template for clash verge

	proxies:
	- name: "PROXY"
	type: socks5 # 节点类型
	server: "" # SOCKS5 服务器地址
	port: 1080 # 服务器端口
	username: "proxy" # 可选，用户名
	password: "" # 可选，密码

	rule-providers:
	reject:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/reject.txt"
	path: ./ruleset/reject.yaml
	interval: 86400

	icloud:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/icloud.txt"
	path: ./ruleset/icloud.yaml
	interval: 86400

	apple:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/apple.txt"
	path: ./ruleset/apple.yaml
	interval: 86400

	google:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/google.txt"
	path: ./ruleset/google.yaml
	interval: 86400

	proxy:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/proxy.txt"
	path: ./ruleset/proxy.yaml
	interval: 86400

	direct:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/direct.txt"
	path: ./ruleset/direct.yaml
	interval: 86400

	private:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/private.txt"
	path: ./ruleset/private.yaml
	interval: 86400

	gfw:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/gfw.txt"
	path: ./ruleset/gfw.yaml
	interval: 86400

	tld-not-cn:
	type: http
	behavior: domain
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/tld-not-cn.txt"
	path: ./ruleset/tld-not-cn.yaml
	interval: 86400

	telegramcidr:
	type: http
	behavior: ipcidr
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/telegramcidr.txt"
	path: ./ruleset/telegramcidr.yaml
	interval: 86400

	cncidr:
	type: http
	behavior: ipcidr
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/cncidr.txt"
	path: ./ruleset/cncidr.yaml
	interval: 86400

	lancidr:
	type: http
	behavior: ipcidr
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/lancidr.txt"
	path: ./ruleset/lancidr.yaml
	interval: 86400

	applications:
	type: http
	behavior: classical
	url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/applications.txt"
	path: ./ruleset/applications.yaml
	interval: 86400

	rules:
	- RULE-SET,applications,DIRECT
	- DOMAIN,clash.razord.top,DIRECT
	- DOMAIN,yacd.haishan.me,DIRECT
	- RULE-SET,private,DIRECT
	- RULE-SET,reject,REJECT
	- RULE-SET,icloud,DIRECT
	- RULE-SET,apple,DIRECT
	- RULE-SET,google,PROXY
	- RULE-SET,proxy,PROXY
	- RULE-SET,direct,DIRECT
	- RULE-SET,lancidr,DIRECT
	- RULE-SET,cncidr,DIRECT
	- RULE-SET,telegramcidr,PROXY
	- GEOIP,LAN,DIRECT
	- GEOIP,CN,DIRECT
	- MATCH,PROXY

开启代理和自启动

至次运行 clash 的电脑就可以愉快的科学上网了，并且还可以代理同局域网的其它电脑科学上网。

利用jackson对返回数据做字典转换

2024-08-21T02:00:00.000Z

# 简介

在项目中经常有一些类型字段用数字或者字母保存，但是前端展示时，则需要转换为用户能够理解的文字。于是公司内有人写了一个公用的注解，利用 java 的反射机制，修改字段的值或者添加属性来实现字典转换。由于 java 是静态类型语言，类在编译时固定，所以无法动态添加属性。于是他的解决方法是先把对象转为 map 再添加属性，或者在定义对象时先预定义字典的属于名称。我在使用中发现如果转换为 map（也可能是拦截处理的时机不对）则会丢失字段上的其它注解，如 swagger 文档定义、时间格式化等等。预设字典属性名称毕竟又增加了一道工序，操作起来也比较繁琐。于是我就想到了在返回阶段利用 jackson 的序列化步骤来对属性进行字典转换。json 对象类似 map 都是键值对，不用担心增减属性的问题。序列化时其它注解也已经处理完成，不会造成影响。

# 实现细节

# 需要的 jar

	<!-- 版本根据需求调整 -->
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-core</artifactId>
	<version>2.15.2</version>
	</dependency>
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.15.2</version>
	</dependency>
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-annotations</artifactId>
	<version>2.15.2</version>
	</dependency>

# 定义注解

	public enum DicHandleStrategy {
	replace,
	add;

	private DicHandleStrategy() {
	}
	}

	import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
	import com.fasterxml.jackson.databind.annotation.JsonSerialize;

	import java.lang.annotation.ElementType;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.annotation.Target;

	@Target({ElementType.FIELD, ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	@JacksonAnnotationsInside
	@JsonSerialize(using = JsonDicHandle.class)
	public @interface JsonDicField {

	/**
	* 业务表名
	* @return
	*/
	String tableName() default "";

	/**
	* 业务字段名
	* @return
	*/
	String fieldName() default "";

	/**
	* 默认增加一个对应属性名加_dic 的新属性（如 type_dic）* newFieldName 为空的情况下
	* @return
	*/
	DicHandleStrategy strategy() default DicHandleStrategy.add;

	/**
	* 字典属性名称（如不指定，并且 strategy 为 add 的情况下则字典名称默认为原属性加_dic）
	* @return
	*/
	String newFieldName() default "";

	}

# 注解处理

	import org.springframework.beans.BeansException;
	import org.springframework.beans.factory.NoSuchBeanDefinitionException;
	import org.springframework.context.ApplicationContext;
	import org.springframework.context.ApplicationContextAware;

	import java.util.Timer;
	import java.util.TimerTask;

	public class SpringContextUtil implements ApplicationContextAware {
	private static ApplicationContext applicationContext;

	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
	SpringContextUtil.applicationContext = applicationContext;
	}

	public static ApplicationContext getApplicationContext() {
	return applicationContext;
	}

	public static Object getBean(String name) throws BeansException {
	return applicationContext.getBean(name);
	}

	public static Object getBean(String name, Class<?> requiredType) throws BeansException {
	return applicationContext.getBean(name, requiredType);
	}

	public static Object getBean(Class<?> requiredType) throws BeansException {
	return applicationContext.getBean(requiredType);
	}

	public static boolean containsBean(String name) {
	return applicationContext.containsBean(name);
	}

	public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
	return applicationContext.isSingleton(name);
	}

	public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
	return applicationContext.getType(name);
	}

	public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
	return applicationContext.getAliases(name);
	}
	}


	import com.fasterxml.jackson.core.JsonGenerator;
	import com.fasterxml.jackson.databind.BeanProperty;
	import com.fasterxml.jackson.databind.JsonMappingException;
	import com.fasterxml.jackson.databind.JsonSerializer;
	import com.fasterxml.jackson.databind.SerializerProvider;
	import com.fasterxml.jackson.databind.ser.ContextualSerializer;
	import com.ys.szygl.util.SpringContextUtil;
	import org.apache.commons.collections.CollectionUtils;
	import org.apache.commons.collections.MapUtils;
	import org.apache.commons.lang3.StringUtils;

	import java.io.IOException;
	import java.util.*;
	import java.util.stream.Collectors;

	public class JsonDicHandle extends JsonSerializer<Object> implements ContextualSerializer {

	final String DIC_FIELD_SUFFIX = "_dic";

	String tableName = "";

	String fieldName = "";

	DicHandleStrategy strategy = DicHandleStrategy.add;

	String newFieldName = "";

	String propertyName = "";

	static final IDicService iDicService = (IDicService)SpringContextUtil.getBean(IDicService.class);

	public JsonDicHandle() {
	}

	public JsonDicHandle(String tableName, String fieldName, DicHandleStrategy strategy, String newFieldName, String propertyName) {
	this.tableName = tableName;
	this.fieldName = fieldName;
	this.strategy = strategy;
	this.newFieldName = newFieldName;
	this.propertyName = propertyName;
	}

	@Override
	public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
	if (StringUtils.isBlank(this.newFieldName) && StringUtils.isNotBlank(this.propertyName)) {
	this.newFieldName = this.propertyName + DIC_FIELD_SUFFIX;
	}
	String dicValue = null;
	if (Objects.nonNull(value)) {
	dicValue = this.getDicValue(this.tableName, this.fieldName, String.valueOf(value));
	if (DicHandleStrategy.replace.name().equals(this.strategy.name())) {
	gen.writeObject(dicValue);
	} else {
	gen.writeObject(value);
	}
	} else {
	gen.writeObject(value);
	}
	if (DicHandleStrategy.add.name().equals(this.strategy.name()) && StringUtils.isNotBlank(this.newFieldName)) {
	gen.writeStringField(this.newFieldName, dicValue);
	}
	}

	@Override
	public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
	JsonDicField annotation = property.getAnnotation(JsonDicField.class);
	if (Objects.nonNull(annotation)) {
	return new JsonDicHandle(annotation.tableName(), annotation.fieldName(), annotation.strategy(),
	annotation.newFieldName(), property.getName());
	}
	return new JsonDicHandle();
	}

	/**
	* 把值转为字典值
	* @param value
	* @return
	*/
	private String getDicValue(String tableName, String fieldName, String value) {
	String dicValue = null;
	if (Objects.nonNull(iDicService)) {
	Map<String, String> dicMap = this.iDicService.getDicMapFromCatch(tableName, fieldName);
	if (MapUtils.isNotEmpty(dicMap)) {
	List<String> dicValues = Arrays.stream(value.split(",")).map(s -> {
	return Optional.ofNullable(dicMap.get(s)).map(String::valueOf).orElse("");
	}).collect(Collectors.toList());
	if (CollectionUtils.isNotEmpty(dicValues)) {
	dicValue = String.join(",", dicValues);
	}
	}
	}
	return dicValue;
	}

	}

# 其它

IDicService 是自己的字典缓存服务，利用 tableName 和 fieldName 来定位属性的对应字典名称。请根据自己的业务逻辑进行修改。

idea 主题代码颜色代码区背景行号背景注释颜色修改

2024-06-25T08:03:00.000Z

# 简介

最近写代码眼睛总是看的不舒服，想着换一个主题，但是换了主题，代码的颜色显示和之前又不一样了，接下来就是修改主题，但是代码颜色仍然保持 Darcula 主题的颜色。

# 修改主题

我这里用的是 One Dark theme 可以直接去下载这个插件

# 修改代码颜色与背景

代码颜色
这里只修改代码颜色的话，idea 整体背景将不统一，看着非常难受，因此不仅要修改代码颜色，还要修改与当前主题相同的背景颜色。

这里直接修改为 Darcula ，那么整体的代码颜色风格都会变成 Darcula，但是代码区域的背景颜色也会变成 Darcula ，使得 idea 背景一体性破坏。
代码区背景

这里如果你用的跟我一样的 One Dark theme ，那么你就可以修改颜色为 21252B 这样代码区颜色就会和主题相一致，但是到这里你会发现，行号区域的颜色又不一样了。

# 修改行号背景

这里按照相同的方法修改，即可达到整体的一致性。

# 修改注释颜色

这里就是个人习惯了，我习惯注释都是绿色的，清晰明了。

这里提供一个参考 629755 ，我个人比较喜欢这个颜色。

# 鼠标悬停代码提示框背景修改

# 代码快捷提示框背景颜色修改

对XML格式的Word模板格式化处理

2024-05-22T07:43:00.000Z

# 简介

生成复杂的 word 文档需要使用 xml 格式的 word 模板，但是另存为 xml 文件的 word 文件格式比较杂乱。现提供一个格式化 xml 的工具类，代码如下：

	package xxx.util;

	import cn.hutool.core.io.FileUtil;
	import cn.hutool.core.io.file.FileAppender;
	import cn.hutool.core.io.file.FileReader;

	import java.util.List;

	public class WordConvertXmlHandle {

	public static void main(String[] args) {
	// 文件读取 - FileReader
	// 默认 UTF-8 编码，可以在构造中传入第二个参数作为编码
	FileReader fileReader = new FileReader("D:\\mb.xml");
	// 从文件中读取每一行数据
	List<String> strings = fileReader.readLines();
	// 文件追加 - FileAppender
	//destFile – 目标文件
	//capacity – 当行数积累多少条时刷入到文件
	//isNewLineMode – 追加内容是否为新行
	FileAppender appender = new FileAppender(FileUtil.newFile("D:\\mb.ftl"), 16, true);
	// 遍历得到每一行数据
	for (String string : strings) {
	// 判断每一行数据中不包含 '$' 的数据先添加进新文件
	if (!string.contains("$")) {
	appender.append(string);
	continue;
	}
	// 如果一行数据中包含 '$' 变量符将替换为 '#$'
	string = string.replaceAll("\\$", "#\\$");
	// 然后以 '#' 切割成每一行（数组）, 这样一来 '$' 都将在每一行的开头
	String[] ss = string.split("#");
	// 同一行的数据写到同一行，文件追加自动换行了 (最后的完整数据)
	StringBuilder sb = new StringBuilder();
	// 遍历每一行（数组 ss）
	for (int i = 0; i < ss.length; i++) {
	// 暂存数据
	String s1 = ss[i];
	// 将不是以 '$' 开头的行数据放进 StringBuilder
	if (!s1.startsWith("$")) {
	sb.append(s1);
	continue;
	}
	// 被分离的数据一般都是 '${' 这样被分开
	// 匹配以 '$' 开头的变量找到 '}' 得到索引位置
	int i1 = s1.lastIndexOf("}");
	// 先切割得到这个完整体
	String substr = s1.substring(0, i1 + 1);
	// 把变量追加到 StringBuilder
	sb.append(substr.replaceAll("<[^>]+>", ""));
	// 再将标签数据追加到 StringBuilder 包裹变量
	sb.append(s1.substring(i1 + 1));
	}
	appender.append(sb.toString());
	}
	appender.flush();
	appender.toString();
	}
	}

MySQL表分区

2024-05-10T09:09:00.000Z

# 简介

当单表数据量过大时，就需要考虑对表进行分表或者分区了。分表和分区都是用来解决数据库中大量数据存储和查询效率的问题，但它们的实现方式和解决的问题有所不同。

分表（Sharding）：

分表是将一个大表按照某种规则拆分成多个较小的表，每个小表称为一个分表，这些分表可以分布在不同的数据库实例中。
分表通常基于某种规则进行拆分，例如按照用户 ID、地理位置等进行拆分。
分表的主要目的是解决单个表过大的问题，提高查询效率和并发能力。

分区（Partitioning）：

分区是将一个表按照某种规则拆分成多个逻辑上的部分，每个部分称为一个分区，但这些分区仍然属于同一个表。
分区通常基于某种规则进行拆分，例如按照时间、范围、哈希值等进行拆分。
分区的主要目的是提高数据的管理和查询效率，通过将数据分散到不同的分区中，可以提高查询性能和管理灵活性。

区别：

实现方式：分表是将一个表拆分成多个子表，每个子表都是一个独立的表；而分区是将一个表按照某种规则拆分成多个逻辑上的部分，这些部分仍然属于同一个表。
解决的问题：分表主要解决单个表过大的问题，提高查询效率和并发能力；而分区主要提高数据的管理和查询效率，通过将数据分散到不同的分区中，可以提高查询性能和管理灵活性。
适用场景：分表适用于单表数据量巨大的情况，例如大型电商平台的订单表；而分区适用于需要根据某种规则对数据进行划分管理的情况，例如按照时间对日志表进行分区。

# 实现细节

本文章介绍的是如何对单表进行分区。

# 给表添加分区

	ALTER TABLE 表名（字段）
	PARTITION BY RANGE COLUMNS (时间字段名) (
	-- 分区条件（时间小于 2022-02-01 的数据放入 p202201 分区中）
	PARTITION p202201 VALUES LESS THAN ('2022-02-01'),
	PARTITION p202202 VALUES LESS THAN ('2022-03-01'),
	PARTITION p202203 VALUES LESS THAN ('2022-04-01'),
	-- 继续定义更多的分区...
	);

# 按指定表名创建当前年月的分区

	CREATE PROCEDURE create_monthly_partition(IN tableName VARCHAR(255))
	BEGIN
	DECLARE currentYear INT;
	DECLARE currentMonth INT;
	DECLARE nextYear INT;
	DECLARE nextMonth INT;
	DECLARE partitionName VARCHAR(255);
	SET currentYear = YEAR(CURRENT_DATE);
	SET currentMonth = MONTH(CURRENT_DATE);
	-- 计算下一个月的年份和月份
	IF currentMonth = 12 THEN
	SET nextYear = currentYear + 1;
	SET nextMonth = 1;
	ELSE
	SET nextYear = currentYear;
	SET nextMonth = currentMonth + 1;
	END IF;
	SET partitionName = CONCAT('p', currentYear, LPAD(currentMonth, 2, 0));
	SET @sql = CONCAT('ALTER TABLE ', tableName,
	' ADD PARTITION (PARTITION ', partitionName,
	' VALUES LESS THAN (\'', nextYear, '-', LPAD(nextMonth, 2, 0), '-01\'', '))');
	PREPARE stmt FROM @sql;
	EXECUTE stmt;
	DEALLOCATE PREPARE stmt;
	END

# 调用创建新分区

CALL create_monthly_partition('表名');

# 删除指定分区

ALTER TABLE 表名 drop PARTITION 分区名;

# 每月执行一次调用指定表添加新分区

	CREATE EVENT create_monthly_partition_event
	ON SCHEDULE EVERY 1 MONTH
	STARTS '2024-01-01 00:00:00.000'
	ON COMPLETION NOT PRESERVE
	ENABLE
	DO begin
	DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
	BEGIN
	-- 捕获异常，记录错误信息，然后继续执行
	SET @error_message = CONCAT('Error occurred while processing table: ', @tableName);
	-- 可以将错误信息插入到日志表，或者使用 SELECT 输出错误信息
	SELECT @error_message;
	END;
	-- 定义需要分区的表名列表
	SET @tables = '表名1,表名2';
	-- 遍历表名列表并为每个表创建分区
	WHILE CHAR_LENGTH(@tables) > 0 DO
	SET @tableName = SUBSTRING_INDEX(@tables, ',', 1);
	SET @tables = SUBSTRING(@tables, CHAR_LENGTH(@tableName) + 2);
	CALL create_monthly_partition(@tableName);
	END WHILE;
	end

Java后端禁止接口瞬时重复调用

2024-04-30T03:44:00.000Z

# 简介

由于前端会莫名其妙的对同一接口请求多次，从而占用后端资源造成浪费。所以采用了后端拦截相关重复请求的方案。此方案会将请求用户 id 加接口 url 加参数作为 key，请求时间作为 value，使用 ConcurrentHashMap 进行缓存。如果下次相同的请求和上次请求的时间在指定的范围内则认为此请求属于重复请求。

# 实现细节

# 自定义可重复读 Request

request 的 body 只能读取一次，所以对其进行封装。

	package xxx.support;

	import com.alibaba.fastjson.JSON;
	import lombok.extern.slf4j.Slf4j;

	import javax.servlet.ReadListener;
	import javax.servlet.ServletInputStream;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletRequestWrapper;
	import java.io.*;
	import java.nio.charset.StandardCharsets;
	import java.util.Enumeration;
	import java.util.Map;
	import java.util.Objects;
	import java.util.TreeMap;

	@Slf4j
	public class RepeatableReadHttpServletRequestWrapper extends HttpServletRequestWrapper {

	private final byte[] requestBody;

	public RepeatableReadHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
	super(request);
	this.requestBody = readRequestBody(request);
	}

	private byte[] readRequestBody(HttpServletRequest request) throws IOException {
	try (InputStream inputStream = request.getInputStream();
	ByteArrayOutputStream result = new ByteArrayOutputStream()) {

	byte[] buffer = new byte[1024];
	int length;
	while ((length = inputStream.read(buffer)) != -1) {
	result.write(buffer, 0, length);
	}

	return result.toByteArray();
	}
	}

	@Override
	public ServletInputStream getInputStream() throws IOException {
	// 直接使用 ByteArrayInputStream，它提供可重复读取的输入流
	return new ServletInputStream() {
	private final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(requestBody);

	@Override
	public int read() throws IOException {
	return byteArrayInputStream.read();
	}

	@Override
	public boolean isFinished() {
	return byteArrayInputStream.available() == 0;
	}

	@Override
	public boolean isReady() {
	return true;
	}

	@Override
	public void setReadListener(ReadListener readListener) {
	// 不需要实现，可以留空
	}
	};
	}

	@Override
	public BufferedReader getReader() throws IOException {
	// 使用 InputStreamReader 包装 ByteArrayInputStream，提供可重复读取的字符流
	return new BufferedReader(new InputStreamReader(new ByteArrayInputStream(requestBody)));
	}

	/**
	* 获取 json 格式的参数
	* @return
	*/
	public String getParamsToJSONString() {
	String jsonStr = "";
	if ("POST".equals(this.getMethod().toUpperCase()) && this.isJsonRequest()) {
	try {
	jsonStr = this.readJsonData();
	} catch (Exception e) {
	log.error(e.getMessage());
	}
	} else {
	Enumeration<String> parameterNames = this.getParameterNames();
	if (Objects.nonNull(parameterNames) && parameterNames.hasMoreElements()) {
	// 将参数排序后转为 json
	Map<String, String> paramsMap = new TreeMap<>();
	while (parameterNames.hasMoreElements()) {
	String paramName = parameterNames.nextElement();
	paramsMap.put(paramName, this.getParameter(paramName));
	}
	jsonStr = JSON.toJSONString(paramsMap);
	}
	}
	return jsonStr;
	}

	/**
	* 判断是否 json 请求
	* @return
	*/
	private boolean isJsonRequest() {
	String contentType = this.getContentType();
	return contentType != null && contentType.toLowerCase().contains("application/json");
	}

	/**
	* 获取 json 格式的参数
	* @return
	* @throws IOException
	*/
	private String readJsonData() throws IOException {
	return new String(this.readRequestBody(this), StandardCharsets.UTF_8);
	}

	}

# 重复请求过滤器

	package xxx.filter;

	import cn.hutool.core.collection.CollectionUtil;
	import xxx.RepeatableReadHttpServletRequestWrapper;
	import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
	import org.springframework.security.web.util.matcher.RequestMatcher;
	import org.springframework.web.filter.OncePerRequestFilter;

	import javax.servlet.FilterChain;
	import javax.servlet.ServletException;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import java.io.IOException;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.concurrent.ConcurrentHashMap;

	public class DuplicateRequestFilter extends OncePerRequestFilter {
	// 是否启用
	private Boolean duplicateRequestFilter;
	// 间隔时间（毫秒）
	private Long intervalTime;
	// 清除缓存时间（毫秒）
	private Long clearCachetime;
	// 放行 url
	private List<RequestMatcher> permitAll;

	public DuplicateRequestFilter(Boolean duplicateRequestFilter, List<RequestMatcher> permitAll, Long intervalTime,
	Long clearCachetime) {
	this.duplicateRequestFilter = duplicateRequestFilter;
	this.permitAll = permitAll;
	this.intervalTime = intervalTime;
	this.clearCachetime = clearCachetime;
	}

	// 存储参数和请求时间
	private Map<String, Long> requestCache = new ConcurrentHashMap<>();

	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
	throws ServletException, IOException {
	boolean doFilter = true;
	// 使用 ContentCachingRequestWrapper 包装原始请求
	RepeatableReadHttpServletRequestWrapper wrappedRequest = null;
	if (this.duplicateRequestFilter) {
	// 判断请求路径是否需要放行
	boolean permit = false;
	if (CollectionUtil.isNotEmpty(this.permitAll)) {
	for (RequestMatcher matcher: this.permitAll) {
	if (matcher.matches(request)) {
	permit = true;
	break;
	}
	}
	}
	if (!permit) {
	if (request instanceof RepeatableReadHttpServletRequestWrapper) {
	wrappedRequest = (RepeatableReadHttpServletRequestWrapper) request;
	} else {
	wrappedRequest = new RepeatableReadHttpServletRequestWrapper(request);
	}
	doFilter = this.isValid(wrappedRequest);
	}
	}
	if (doFilter) {
	// 继续处理请求
	filterChain.doFilter(Objects.nonNull(wrappedRequest) ? wrappedRequest : request, response);
	} else {
	response.setContentType("application/json");
	response.setStatus(WebEndpointResponse.STATUS_TOO_MANY_REQUESTS);
	// response.setStatus(HttpServletResponse.SC_OK);
	// ObjectMapper mapper = new ObjectMapper();
	// mapper.writeValue (response.getOutputStream (), R.error (WebEndpointResponse.STATUS_TOO_MANY_REQUESTS, "重复的请求"));
	}
	}

	/**
	* 验证请求的有效性（判断是否重复请求）
	* @param request
	* @return
	*/
	private boolean isValid(RepeatableReadHttpServletRequestWrapper request) {
	boolean valid = true;
	// 缓存的 key
	String key = TokenUtil.getUidByToken() + "_" + request.getServletPath() + "_" + request.getParamsToJSONString();
	// 获取之前的请求时间
	Long previousRequestTime = requestCache.get(key);
	if (previousRequestTime != null) {
	// 如果距离上次请求时间很短（例如 1 秒），则拒绝当前请求
	if (System.currentTimeMillis() - previousRequestTime < this.intervalTime) {
	valid = false;
	}
	}
	this.clearOldRequests();
	// 缓存当前请求时间
	requestCache.put(key, System.currentTimeMillis());
	return valid;
	}

	// 用于清除缓存中的旧请求数据，防止缓存无限增长
	private void clearOldRequests() {
	requestCache.entrySet().removeIf(entry -> System.currentTimeMillis() - entry.getValue() > this.clearCachetime);
	}

	}

# 配置 OAuth2 资源

	package xxx.config;


	import xxx.AuthExceptionEntryPoint;
	import xxx.CustomAccessDeniedHandler;
	import xxx.DuplicateRequestFilter;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.beans.factory.annotation.Qualifier;
	import org.springframework.beans.factory.annotation.Value;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.security.config.annotation.web.builders.HttpSecurity;
	import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
	import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
	import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
	import org.springframework.security.oauth2.provider.token.TokenStore;
	import org.springframework.security.web.authentication.preauth.AbstractPreAuthenticatedProcessingFilter;
	import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

	import javax.servlet.Filter;
	import java.util.Arrays;
	import java.util.stream.Collectors;

	@Configuration
	@EnableResourceServer
	public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

	Logger log = LoggerFactory.getLogger(ResourceServerConfig.class);

	@Autowired
	private TokenStore tokenStore;

	/**
	* 是否开放所有接口
	*/
	@Value("${http.security.permitAll:false}")
	private Boolean isPermitAll;

	/**
	* 是否启用重复请求过滤
	*/
	@Value("${request.duplicateFilter.enabled:true}")
	private Boolean duplicateRequestFilter;

	/**
	* 间隔时间 (毫秒)
	*/
	@Value("${request.duplicateFilter.interval_time:1000}")
	private Long intervalTime;

	/**
	* 清除缓存时间 (毫秒)
	*/
	@Value("${request.duplicateFilter.clear_cache_time:30000}")
	private Long clearCachetime;

	/**
	* 不需要验证权限的接口
	*/
	private String[] permitAll = new String[] {
	"/auth/getVCode", "/auth/login"
	};


	/**
	* 通行规则
	* @param http
	* @throws Exception
	*/
	@Override
	public void configure(HttpSecurity http) throws Exception {
	HttpSecurity httpSecurity = http.csrf().disable();
	if (isPermitAll) {
	httpSecurity.authorizeRequests().antMatchers("/**").permitAll();
	} else {
	httpSecurity.authorizeRequests()
	.antMatchers(permitAll).permitAll()
	.antMatchers("/**").authenticated();
	}
	if (this.duplicateRequestFilter) {
	httpSecurity.addFilterAfter(duplicateRequestFilter(), AbstractPreAuthenticatedProcessingFilter.class);
	}
	// 让 X-frame-options 失效，去除 iframe 限制
	http.headers().frameOptions().disable();
	}

	@Override
	public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
	resources.tokenStore(tokenStore).authenticationEntryPoint(new AuthExceptionEntryPoint())
	.accessDeniedHandler(new CustomAccessDeniedHandler());

	}

	@Bean
	public Filter duplicateRequestFilter() {
	return new DuplicateRequestFilter(this.duplicateRequestFilter, Arrays.asList(this.permitAll)
	.stream().map(AntPathRequestMatcher::new).collect(Collectors.toList()), this.intervalTime,
	this.clearCachetime);
	}

	}

Docker容器管理平台-Portainer安装

2024-03-03T07:52:00.000Z

# 简介

Portainer 是一款开源的容器管理平台，它提供了易于使用的 Web UI 界面，用于管理和监控容器及容器集群。该软件支持多种容器技术和配置，包括但不限于 Docker、Kubernetes 和 Swarm。

# 部署

	#原版
	docker run -d --restart=always --name="portainer" -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v D:\docker\portainer\data:/data portainer/portainer-ce

	#汉化版
	docker run -d --restart=always --name="portainer" -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v D:\docker\portainer\data:/data 6053537/portainer-ce

# 登录

http://localhost:9000/#!/home

IntellIJ只编译打包指定的模块

2024-01-19T08:06:00.000Z

# 新增 Maven 配置

IntellIJ -》右侧小锤子旁下拉按钮选择 Edit Configurations -》+ 号按钮 -》Maven

# 填写 Maven 命令

Working directory 选择根目录，命令是基于选中的目录为执行目录，Run 填写以下命令

	clean package -pl emergency-dzdz/dzdz-yzt -am -Dmaven.test.skip=true -f pom.xml
	或者
	clean install -pl emergency-dzdz/dzdz-yzt -am -Dmaven.test.skip=true -f pom.xml

	clean: 这个命令会删除目标目录（target），确保每次构建是干净的。
	install: 这个命令会将项目打包，并安装到本地的 Maven 仓库中。
	-pl emergency-dzdz/dzdz-yzt: -pl 参数指定要构建的项目模块。dzdz-yzt 是模块的名称。这个参数告诉 Maven 只构建 dzdz-yzt 及其依赖的模块。注意模块路径，此处是构建emergency-dzdz下的dzdz-yzt模块。
	-am: -am 参数与 -pl 一起使用，表示还要构建 dzdz-yzt 模块所依赖的所有模块。
	package: 这个命令会将项目打包为 JAR 文件或 WAR 文件，取决于项目类型。
	-f pom.xml: 这个参数指定要使用的 pom.xml 文件。默认情况下，Maven 会在当前目录下查找 pom.xml 文件，但可以通过此参数指定一个不同的位置。
	-DskipTests=true：跳过测试的执行，但会编译测试代码。
	-Dmaven.test.skip=true：跳过测试的编译和执行。

解决Nginx访问自签ssl证书报不安全告警

2024-01-03T10:01:00.000Z

# 生成根证书私钥和根证书

	openssl req -x509 -nodes -days 36500 -newkey rsa:2048 -subj "/C=国家/ST=省/L=市/O=机构" -keyout CA-private.key -out CA-certificate.crt -reqexts v3_req -extensions v3_ca

	#示例
	openssl req -x509 -nodes -days 36500 -newkey rsa:2048 -subj "/C=CN/ST=EZ/L=EZ/O=EZ" -keyout CA-private.key -out CA-certificate.crt -reqexts v3_req -extensions v3_ca

# 生成自签名证书私钥

openssl genrsa -out private.key 2048

# 根据自签名证书私钥生成自签名证书申请文件

openssl req -new -key private.key -subj "/C=CN/ST=EZ/L=EZ/O=EZ/CN=192.168.2.117" -sha256 -out private.csr

# 定义自签名证书扩展文件 (解决 chrome 安全告警)，新建 private.ext 文件并写入以下内容（IP 为 nginx 服务器 ip，同 nginx.conf 中的 server_name）

	[ req ]
	default_bits = 1024
	distinguished_name = req_distinguished_name
	req_extensions = san
	extensions = san
	[ req_distinguished_name ]
	countryName = CN
	stateOrProvinceName = Definesys
	localityName = Definesys
	organizationName = Definesys
	[SAN]
	authorityKeyIdentifier=keyid,issuer
	basicConstraints=CA:FALSE
	keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
	subjectAltName = IP:192.168.2.117

# 生成自签名证书（有效期 100 年）

openssl x509 -req -days 36500 -in private.csr -CA CA-certificate.crt -CAkey CA-private.key -CAcreateserial -sha256 -out private.crt -extfile private.ext -extensions SAN

# nginx 的 ssl 证书配置

	ssl_certificate_key /usr/local/nginx/ssl/private.key;
	ssl_certificate /usr/local/nginx/ssl/private.crt;

# 证书安装

需要安装 CA-certificate.crt 到受信任的根证书颁发机构下，即可从浏览器正常访问且不会报不安全警告。

	#ssl 测试
	openssl s_client -connect localhost:8080
	#检查证书格式
	openssl x509 -in private.crt -text -noout
	openssl rsa -in private.key -check
	#检查证书是否过期（确保 "notBefore" 小于当前日期，"notAfter" 大于当前日期）
	openssl x509 -in private.crt -noout -dates
	#查看证书链
	openssl x509 -in private.crt -noout -issuer -subject

Centos7编译升级nginx

2024-01-03T09:40:00.000Z

# 配置

./configure
# 安装目录
--prefix=/usr/local/nginx
#nginx 运行时的非特权用户
--user=nginx
#nginx 运行时的非特权用户组
--group=nginx
#nginx 运行时 pid 的目录
--pid-path=/var/run/nginx/nginx.pid
# 锁定文件目录，防止误操作，或其他使用
--lock-path=/var/lock/nginx.lock
#nginx 错误日志目录
--error-log-path=/var/log/nginx/error.log
#nginx 运行日志目录
--http-log-path=/var/log/nginx/access.log
# 开启 gz 模块，压缩静态页面
--with-http_gzip_static_module
--with-http_gunzip_module
# 开启 ssl 模块
--with-http_ssl_module
# 开启 http2 模块
--with-http_v2_module
#openssl 目录
--with-openssl=/home/openssl-3.2.0
#nginx 的客户端状态
--with-http_stub_status_module
--with-http_realip_module
# 设定客户端请求的临时目录
--http-client-body-temp-path=/usr/local/nginx/client
# 设定 http 代理临时目录
--http-proxy-temp-path=/usr/local/nginx/proxy
# 设定 fastcgi 临时目录
--http-fastcgi-temp-path=/usr/local/nginx/fastcgi
# 设定 uwsgi 临时目录
--http-uwsgi-temp-path=/usr/local/nginx/uwsgi
# 设定 scgi 临时目录
--http-scgi-temp-path=/usr/local/nginx/scgi

./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module --with-http_v2_module  --with-openssl=/home/openssl-3.2.0

# 编译

make（不要make install）

# 备份

cp /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.old

# 更新

	#关闭 nginx
	nginx -s stop
	#更新 nginx
	cp /root/nginx-1.24.0/objs/nginx /usr/local/nginx/sbin/
	#启动 nginx
	nginx

Docker desktop部署nacos

2023-12-24T13:37:00.000Z

# 创建数据库

create database nacos

# 下载初始化脚本

脚本文件

# 以普通模式启动获取数据

docker run -d --restart=always --name="nacos" -e MODE=standalone -p 8848:8848 -p 9848:9848 nacos/nacos-server:latest

# 进入容器内修改文件权限

	chmod 777 /home/nacos/conf
	chmod 777 /home/nacos/data
	chmod 777 /home/nacos/logs

# 拷贝文件到本地

	docker cp nacos:/home/nacos/conf D:\docker\nacos\data\
	docker cp nacos:/home/nacos/data D:\docker\nacos\data\
	docker cp nacos:/home/nacos/logs D:\docker\nacos\data\

# 创建正式容器

docker run -d --name nacos --restart=always --network my-net -p 8848:8848 -p 9848:9848 -p 9849:9849 -e MODE=standalone --privileged=true -e SPRING_DATASOURCE_PLATFORM=mysql -e MYSQL_SERVICE_HOST=mysql地址 -e MYSQL_SERVICE_PORT=mysql端口 -e MYSQL_SERVICE_USER=mysql用户名 -e MYSQL_SERVICE_PASSWORD=mysql密码 -e MYSQL_SERVICE_DB_NAME=nacos -e TIME_ZONE='Asia/Shanghai' -v D:\docker\nacos\data\logs:/home/nacos/logs -v D:\docker\nacos\data\data:/home/nacos/data -v D:\docker\nacos\data\conf:/home/nacos/conf nacos/nacos-server:latest

fastjson序列化去除空字符串属性

2023-12-02T13:47:00.000Z

今天在把对象转为 json 时需要去除 key 或者 value 为 null 或空字符串的属性，特此记录一下后续好复用。

	public static String toJSONString(Object object) {
	SerializerFeature[] serializerFeatures = new SerializerFeature[] {
	// 格式化时间
	SerializerFeature.WriteDateUseDateFormat
	};
	return JSON.toJSONString(object, new ValueFilter() {
	@Override
	public Object process(Object object, String name, Object value) {
	// 如果名称或者值为 null 或空字符串，则不序列化该属性
	if (name == null \|\| (name instanceof String && ((String) name).isEmpty()) \|\|
	value == null \|\| (value instanceof String && ((String) value).isEmpty())) {
	return null;
	}
	return value;
	}
	}, serializerFeatures);
	}

Linux下快速部署SpringBoot项目的脚本

2023-11-03T13:35:00.000Z

# Windows 部署脚本

只需要把 jar 和 yml 跟脚本放在同一目录下即可快速启动。

拷贝以下代码放入 txt 文本，然后改为 start.sh

	#!/bin/bash

	export CLOUD_HOME=`pwd`

	# 获取当前目录中的第一个 JAR 文件的名称
	jar_file=$(find . -maxdepth 1 -type f -name "*.jar" \| head -n 1)

	if [ -n "$jar_file" ]; then
	jar_file=${jar_file#./}
	#echo "JAR 文件的名称是: $jar_file"
	jar_file_name=$(basename "$jar_file" .jar)
	else
	echo "当前目录没有JAR文件."
	exit
	fi

	# 获取当前目录中的第一个 yml 文件的名称
	yml_file=$(find . -maxdepth 1 -type f -name "*.yml" \| head -n 1)

	if [ -n "$yml_file" ]; then
	yml_file=${yml_file#./}
	#echo "YML 文件的名称是: $yml_file"
	else
	echo "当前目录中没有YML文件."
	fi

	pids=$(ps -ef \| grep java \| grep $jar_file_name \| grep -v grep \| awk '{print $2}')

	for pid in $pids; do
	echo "$jar_file_name is running, pid="$pid
	exit 0
	done

	echo "$jar_file_name is pedding..."

	sleep 3

	JAVA_OPTS="-Djava.security.egd=file:/dev/./urandom -Dfile.encoding=UTF8"
	JAVA_OPTS="$JAVA_OPTS -Dsun.jnu.encoding=UTF8 -Xms512m -Xmx1024m"
	JAVA_OPTS="$JAVA_OPTS -Dpid.path=$CLOUD_HOME/temp -Dspring.config.additional-location=$CLOUD_HOME/$yml_file"
	JAVA_OPTS="$JAVA_OPTS -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5007"

	nohup java $JAVA_OPTS -jar $CLOUD_HOME/$jar_file >/dev/null 2> $CLOUD_HOME/$jar_file_name.run &
	#nohup java $JAVA_OPTS -jar $CLOUD_HOME/$jar_file > $CLOUD_HOME/$jar_file_name.run 2>&1 &

	echo "$jar_file_name started."

拷贝以下代码放入 txt 文本，然后改为 stop.sh

	#!/bin/bash

	export CLOUD_HOME=`pwd`

	# 获取当前目录中的第一个 JAR 文件的名称
	jar_file=$(find . -maxdepth 1 -type f -name "*.jar" \| head -n 1)

	if [ -n "$jar_file" ]; then
	jar_file=${jar_file#./}
	#echo "JAR 文件的名称是: $jar_file"
	jar_file_name=$(basename "$jar_file" .jar)
	else
	echo "当前目录没有JAR文件."
	exit
	fi

	# 获取当前目录中的第一个 yml 文件的名称
	yml_file=$(find . -maxdepth 1 -type f -name "*.yml" \| head -n 1)

	if [ -n "$yml_file" ]; then
	yml_file=${yml_file#./}
	#echo "YML 文件的名称是: $yml_file"
	else
	echo "当前目录中没有YML文件."
	fi

	pids=$(ps -ef \| grep java \| grep $jar_file_name \| grep -v grep \| awk '{print $2}')

	for pid in $pids; do
	kill -9 $pid
	done

	echo "$jar_file_name is stopping..."

	sleep 5

	echo "$jar_file_name stopped."

给我的老笔记本清理灰尘

2023-10-29T12:41:00.000Z

今天闲着无事就把我的老笔记本拆了，清理了一下灰尘。笔记本已经 10 多年了，中间加过内存，换过固态硬盘。清理一下还能发挥它的余热！

Windows下快速部署SpringBoot项目的批处理

2023-10-28T11:56:00.000Z

# Windows 部署脚本

只需要把 jar 和 yml 跟批处理放在同一目录下即可点击快速启动。启动后再次点击会关闭上次启动的窗口并重新启动。

拷贝以下代码放入 txt 文本，然后改为 start.bat

	@ECHO OFF
	setlocal enabledelayedexpansion

	REM 关闭上次进程
	SET "pidFile=pid.txt"
	if exist "%pidFile%" (
	for /f "usebackq" %%a in ("pid.txt") do (
	set PID=%%a
	)
	if not "!PID!"=="" (
	taskkill /F /T /PID !pid!
	del pid.txt
	)
	)

	REM 存储当前进程
	for /f %%i in ('wmic process where "name='cmd.exe' and CommandLine like '%%<scriptname>.bat%%'" get ParentProcessId ^\| findstr /r "[0-9]"') do set pid=%%i
	echo %PID% > pid.txt

	REM 设置title
	for /f "tokens=2" %%i in ('chcp') do set codepage=%%i
	chcp 65001 > nul
	title 我的SpringBoot项目
	chcp %codepage% > nul

	cd %~dp0

	REM 获取jar
	set "jarFile="
	for %%i in (*.jar) do (
	if not defined jarFile (
	set "jarFile=%%i"
	)
	)

	if not defined jarFile (
	echo not find jar
	pause
	exit
	)

	SET JAVA_OPTS=-Djava.security.egd=file:/dev/./urandom -Dfile.encoding=UTF-8
	set JAVA_OPTS=%JAVA_OPTS% -Dsun.jnu.encoding=UTF8 -Xms512m -Xmx1024m
	set JAVA_OPTS=%JAVA_OPTS% -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5007
	set JAVA_OPTS=%JAVA_OPTS% -Dpid.path=./temp

	REM 获取yml
	set "ymlFile="
	for %%i in (*.yml) do (
	if not defined ymlFile (
	set "ymlFile=%%i"
	)
	)

	if defined ymlFile (
	set JAVA_OPTS=%JAVA_OPTS% -Dspring.config.additional-location=!ymlFile!
	) else (
	echo not find yml
	)

	REM 启动服务
	java %JAVA_OPTS% -jar !jarFile!
	pause

拷贝以下代码放入 txt 文本，然后改为 stop.bat

	@ECHO OFF
	setlocal enabledelayedexpansion

	REM 关闭上次进程
	SET "pidFile=pid.txt"
	if exist "%pidFile%" (
	for /f "usebackq" %%a in ("pid.txt") do (
	set PID=%%a
	)
	if not "!PID!"=="" (
	taskkill /F /T /PID !pid!
	del pid.txt
	)
	)

	exit

Centos挂载新硬盘

2023-10-28T11:26:00.000Z

# 查看磁盘信息

fdisk -l 查看当前磁盘的分区情况

可从图中获取以下信息：
/dev/vdb 数据盘容量为 60GB，包含 MBR 分区 /dev/vdb1，容量为 50GB。
/dev/vdc 数据盘容量为 60GB，包含 GPT 分区 /dev/vdc1，容量为 50GB。

df -TH 分区的文件系统类型

可从图中获取以下信息：
/dev/vdb1 文件系统类型为 ext4，已挂载至 /mnt/disk1。
/dev/vdc1 文件系统类型为 xfs，已挂载至 /mnt/disk2。

fdisk /dev/vdb 查看新磁盘情况

lsbl 查看分区情况

# 挂载新硬盘

mkfs.ext4 /dev/vdb 格式化磁盘

	cd /mnt
	mkdir data 新建挂载点
	mount /dev/vdb /mnt/data 挂载

df -h 查看挂载情况

查看 UUID 有三种方式：

blkid

lsblk -f

ll /dev/disk/by-uuid/

	设置自动挂载：
	echo "UUID=c8ac09ca-fd4d-4511-bd2c-4fdf96f08168 /data ext4 defaults 0 0" >> /etc/fstab
	自动挂载/etc/fstab里面的东西
	mount -a

# 临时卸载

umount /dev/vdb 重启机器之后又恢复到挂载状态

# 永久卸载

vim /etc/fstab 把添加的磁盘信息删除即可。

squid+stunnel 科学上网

2023-09-09T08:48:00.000Z

# 前言

科学上网的方法有多种，有很多第三方提供的免费方案，这些方案优缺点暂时不予讨论。实际工作生活中还是会有需要自己搭建的情况，这次介绍的是使用 squid+stunnel 方案进行搭建。

# 准备

一台可以访问外网的服务器，如香港的云主机并安装 Ubuntu 系统。

# squid 部分

1、安装

apt-get install -y squid

2、配置

生成用户文件

	apt-get install apache2-utils
	htpasswd -c /etc/squid/squid_user.txt 用户名

修改 squid 配置
1、直接修改 /etc/squid/squid.conf 文件
2、修改 /etc/squid/conf.d/debian.conf 文件
两种方式都一样，在底部加入以下代码

	#dns 服务器地址
	dns_nameservers 8.8.8.8 8.8.4.4
	dns_v4_first on
	# 监听端口
	http_port 3128
	# 定义 squid 密码文件与 ncsa_auth 文件位置
	auth_param basic program /usr/lib/squid/basic_ncsa_auth /etc/squid/squid_user.txt
	# 认证进程的数量
	auth_param basic children 15
	# 认证对话框显示提示信息
	auth_param basic realm Squid proxy-caching web server
	# 认证有效期
	auth_param basic credentialsttl 24 hours
	# 是否区分用户名大小，off 为不区分
	auth_param basic casesensitive off
	# 对定义的 squid_user 文件内的用户开启认证访问
	acl 用户名 proxy_auth REQUIRED
	# 允许 squid_user 文件内用户进行代理
	http_access allow 用户名
	# 顺序匹配，最后添加拒绝所有未允许的规则。不添加会发现，未匹配到的规则会被放行
	http_access deny all
	# 缓存设置
	cache_dir ufs /var/spool/squid 100 16 256 read-only
	cache_mem 0 MB
	coredump_dir /var/spool/squid
	# 配置高匿，不允许设置任何多余头信息，保持原请求 header。
	header_access Via deny all
	header_access X-Forwarded-For deny all
	header_access Server deny all
	header_access X-Cache deny all
	header_access X-Cache-Lookup deny all
	forwarded_for off
	via off

	# logs 相关配置
	emulate_httpd_log on
	logformat squid %{X-Forwarded-For}>h %ui %un [%tl] "%rm %ru HTTP/%rv" %Hs %<st "%{Referer}>h" "%{User-Agent}>h" %Ss:%Sh
	access_log /var/log/squid/access.log squid
	cache_log /var/log/squid/cache.log
	cache_store_log /var/log/squid/store.log
	logfile_rotate 20

	######## 新版 ########
	#Hide client ip
	forwarded_for delete

	#Turn off via header
	via off

	#Deny request for original source of a request
	follow_x_forwarded_for deny all

	#See below
	request_header_access X-Forwarded-For deny all
	######## 新版 ########

至次已经可以通过填写安装 squid 的服务器 ip 加端口 3128 加用户名密码进行代理访问了（通过访问 https://www.ip.cn/ 查看 ip 就会发现自己的出口 ip 已经变成了 squid 服务器的 ip 了）。但是要想科学上网还必须对代理的数据进行加密，否则访问外网还是会被我国的长城防火墙阻挡，所以还需要安装 stunnel 来实现此目的。

# stunnel 服务端部分

1、安装（和 squid 装在一起）

apt-get install -y stunnel

2、生成 TLS/SSL 证书

openssl req -new -x509 -days 3650 -nodes -out stunnel.pem -keyout stunnel.pem

3、将证书 stunnel.pem 放到 /etc/stunnel/ 目录下
4、修改 stunnel 配置 (/etc/stunnle/stunnle.conf)

	; 设置stunnel的pid文件路径
	pid = /etc/stunnel/stunnel.pid
	; 设置stunnel工作的用户（组）
	setuid = root
	setgid = root

	; 开启日志等级：emerg (0), alert (1), crit (2), err (3), warning (4), notice (5), info (6), or debug (7)
	debug = 7
	; 日志文件路径
	output = /etc/stunnel/stunnel.log

	; 证书文件
	cert = /etc/stunnel/stunnel.pem
	; 私钥文件
	key = /etc/stunnel/stunnel.pem

	; 自定义服务名squid-proxy
	[squid-proxy]
	; 服务监听的端口，client要连接这个端口与server通信
	accept = 1234（自定义）
	; 服务要连接的端口，连接到squid的3128端口，将数据发给squid
	connect = 3128

# stunnel 客户端部分

可以安装在要代理的机器上，在需要代理的情况下再开启（代理地址填 127.0.0.1 加客户端监听端口）。也可以安装在国内的服务器上一直保持连接（代理信息填国内服务器 ip 加客户端监听端口）。本示例客户端为 windows 系统

1、下载地址

https://www.stunnel.org/downloads.html

2、修改配置（C:\Program Files (x86)\stunnel\config\stunnel.conf）

	[squid-proxy]
	client = yes
	; 监听3128端口，那么用户浏览器的代理设置就是 stunnel-client-ip:3128
	accept = 3128
	; 要连接到的stunnel server的ip与端口
	connect = stunnel服务端ip:1234（服务端自定义端口）

	; 需要验证对方发过来的证书
	verify = 2
	; 用来进行证书验证的文件（stunnel服务端生成的证书复制到以下目录并改名为stunnel-server.pem）
	CAfile = C:\Program Files (x86)\stunnel\config\stunnel-server.pem

至次配置好代理 ip 为 stunnel 客户端 ip 加端口 3128 就可以正式科学上网了。如果只想对需要科学的 url 进行代理，可以通过安装 Proxy SwitchyOmega 插件实现（规则地址可通过 https://github.com/gfwlist/gfwlist 获取）。

涛声依旧

AI反代好工具-Agent2Api推荐

# 起因：额度都锁在客户端里

# 项目基本情况

# 功能介绍

# 适合什么场景

# 如何下载

# Docker 安装

# 几个实际踩到的点

# 使用须知

# 小结

自建私服

# 前言

# 客户端下载

# 魔兽世界注册

极空间部署DeepSeek（API调用）

# 前言

# 前期准备

# 安装 deepseek-free-api

# 安装 one-api

# 安装 chatgpt-next-web

# nginx proxy manager 配置

dante+stunnel+clash 科学上网

# 前言

# 准备

# dante 部分

# stunnel 服务端部分

# stunnel 客户端部分

# Clash 部分

利用jackson对返回数据做字典转换

# 简介

# 实现细节

# 需要的 jar

# 定义注解

# 注解处理

# 其它

idea 主题 代码颜色 代码区背景 行号背景 注释颜色修改

# 简介

# 修改主题

# 修改代码颜色与背景

# 修改行号背景

# 修改注释颜色

# 鼠标悬停代码提示框背景修改

# 代码快捷提示框背景颜色修改

对XML格式的Word模板格式化处理

# 简介

MySQL表分区

# 简介

# 实现细节

# 给表添加分区

# 按指定表名创建当前年月的分区

# 调用创建新分区

# 删除指定分区

# 每月执行一次调用指定表添加新分区

Java后端禁止接口瞬时重复调用

# 简介

# 实现细节

# 自定义可重复读 Request

# 重复请求过滤器

# 配置 OAuth2 资源

Docker容器管理平台-Portainer安装

# 简介

# 部署

# 登录

IntellIJ只编译打包指定的模块

# 新增 Maven 配置

# 填写 Maven 命令

解决Nginx访问自签ssl证书报不安全告警

# 生成根证书私钥和根证书

# 生成自签名证书私钥

# 根据自签名证书私钥生成自签名证书申请文件

# 定义自签名证书扩展文件 (解决 chrome 安全告警)，新建 private.ext 文件并写入以下内容（IP 为 nginx 服务器 ip，同 nginx.conf 中的 server_name）

# 生成自签名证书（有效期 100 年）

# nginx 的 ssl 证书配置

# 证书安装

Centos7编译升级nginx

# 配置

# 编译

# 备份

# 更新

idea 主题代码颜色代码区背景行号背景注释颜色修改