Muxui

[开源]AI Summary - WordPress智能摘要生成插件

Fri, 19 Sep 2025 00:00:00 GMT

AI Summary是一款专为WordPress设计的智能摘要生成插件，它集成了五大主流AI服务：百度文心一言、OpenAI ChatGPT、Google Gemini、字节豆包和阿里通义千问。无论您是个人博客作者还是企业网站运营者，这款插件都能帮您轻松提升内容质量和搜索引擎优化效果。

🚀 核心功能特性#

多AI服务支持

🌟 ChatGPT - OpenAI官方API，支持自定义API地址和模型名称
✨ Google Gemini - 谷歌最新AI模型，支持自定义API地址和模型名称
🔥 文心一言 - 百度千帆大模型平台，支持最新API Key认证
🔥 字节豆包 - 火山方舟平台，支持自定义API地址和模型名称
⚡ 通义千问 - 阿里云百炼平台，支持多种模型规格

智能内容生成

📝 AI摘要生成 - 自动提取文章核心内容，生成吸引人的摘要
🔍 SEO自动优化 - 智能生成SEO描述和关键词
🎯 内容精准提取 - 500字关键内容提取，降低API成本

完美主题集成

🎨 B2主题完美适配 - 自动填充B2主题SEO字段
🔄 双向数据同步 - AI字段与主题字段实时同步
📱 响应式设计 - 支持所有WordPress编辑器

💡 使用方法#

编辑页面生成

在文章编辑页面右侧找到 “AI Summary设置” 元框：

生成摘要: 点击”生成摘要”按钮，AI自动分析文章内容
生成SEO: 点击”生成SEO”按钮，自动生成描述和关键词
自动保存: 生成成功后自动保存，无需手动操作
一键同步: 自动填充到B2主题SEO字段

批量管理

在 AI Summary → 文章管理 页面：

✅ 批量生成摘要: 选择多篇文章，一键生成摘要
✅ 批量生成SEO: 智能跳过已生成的内容
✅ 状态监控: 清晰显示每篇文章的生成状态
✅ 进度反馈: 详细的操作进度和结果提示

🎨 前端展示效果#

插件在文章页面自动添加精美的AI摘要展示区域：

🎭 打字机动画效果 - 吸引用户注意力
🎯 “看其他文章”按钮 - 增加页面停留时间
📱 响应式设计 - 完美适配移动端
🎨 可自定义样式 - 与网站主题完美融合

🎨 后端展示效果#

⚡ 性能优化特性#

智能内容提取

🔹 关键内容识别: 自动提取标题、首段、关键段落
🔹 500字限制: 大幅降低API调用成本
🔹 提取算法: 智能识别文章核心信息

数据缓存机制

🔹 生成结果缓存: 避免重复生成相同内容
🔹 本地数据存储: WordPress原生meta机制
🔹 增量更新: 只有内容变化时才重新生成

🛠️ 技术实现细节#

架构设计

// 统一AI调用接口
class AI {
static function getSummary($content) {
// 智能摘要生成
}

static function getSeo(content) { // SEO信息生成 } } // 多AI服务适配 switch (provider) {
case ‘wenxin’: return WenXin::chat();
case ‘chatgpt’: return ChatGPT::chat();
case ‘gemini’: return Gemini::chat();
case ‘doubao’: return Doubao::chat();
case ‘tongyi’: return Tongyi::chat();
}

📊 功能对比表#

功能特性	AI Summary	其他插件
多AI服务支持	✅ 5个主流服务	❌ 单一服务
B2主题集成	✅ 完美适配	❌ 需手动配置
智能内容提取	✅ 500字优化	❌ 全文发送
实时双向同步	✅ 自动同步	❌ 单向导出
批量处理	✅ 智能跳过	❌ 重复生成
用户体验	✅ 一键操作	❌ 复杂配置

🎯 适用场景#

个人博客

📝 技术分享博客 - 自动生成技术要点摘要
📚 知识分享站点 - 提炼核心知识点
🎨 创作类网站 - 吸引读者阅读兴趣

企业网站

🏢 公司新闻站 - 快速生成新闻摘要
📈 产品介绍页 - 突出产品核心卖点
🎓 在线教育 - 课程内容精华提取

内容平台

📖 资讯聚合站 - 批量生成文章摘要
🌐 多语言网站 - 统一内容生成标准
📱 移动优先站 - 简洁摘要提升体验

🔧 高级配置技巧#

自定义API配置

ChatGPT配置:

🔹 API地址 (可选): 支持第三方代理和镜像站
🔹 自定义模型: 支持最新模型如gpt-4o、gpt-4o-mini等
🔹 优先级: 自定义模型名称优先于下拉选择

Gemini配置:

🔹 API地址 (可选): 支持代理服务和第三方兼容接口
🔹 自定义模型: 支持最新模型如gemini-1.5-flash等
🔹 优先级: 自定义模型名称优先于下拉选择

API成本优化

选择合适模型:
- 日常使用: ernie-3.5-8k / gpt-3.5-turbo
- 高质量需求: ernie-4.0-8k / gpt-4
内容长度控制:
- 摘要字数: 100-200字 (平衡质量与成本)
- SEO描述: 120-150字符 (搜索引擎友好)
批量处理策略:
- 选择性生成: 只为重要文章生成
- 定期更新: 根据流量数据优化

📈 SEO优化效果#

使用AI Summary插件后，您的网站将获得：

搜索引擎优化

🎯 精准关键词: AI智能识别文章核心关键词
📝 吸引人描述: 生成符合搜索引擎要求的描述
🔍 提升点击率: 优质摘要吸引更多用户点击

用户体验提升

⚡ 快速了解: 用户可快速了解文章内容
📱 移动友好: 简洁摘要适合移动端阅读
🎨 视觉效果: 打字机动画增强用户体验

🆚 版本更新记录#

v1.0.0 (2025-06-28)

🎉 首次发布: 完整功能实现
✅ 多AI支持: 文心一言、ChatGPT、Gemini
🔧 B2主题集成: 完美适配B2主题
🚀 智能优化: 内容提取和成本控制

v1.1.0 (2025-06-30)

🎉 新增模型: 豆包、通义千问
🚀 优化代码: 优化代码逻辑及界面优化

v1.1.2 (2025-07-02)

🚀 功能增强: ChatGPT和Gemini配置升级
🔧 ChatGPT新增: 自定义模型名称配置
🌐 Gemini新增: 自定义API地址和模型名称配置
⚡ 优先级逻辑: 自定义模型优先于下拉选择
🎯 兼容性: 完全向后兼容，不影响现有配置

未来规划

📊 数据分析: 生成效果统计和优化建议
🎨 主题扩展: 支持更多WordPress主题

🎁 送一些Gemini的key#

1
AIzaSyA7Br2V-gqJ-SdIpKU4jHZX4bDsbQLtWFY,
2
AIzaSyCuQA8YMmF3nQACiNUvpH7eUBiJc2UG65w,
3
AIzaSyAWfB2vi0x-yM2pnOPxeu1HXe4MC0ObJUU,
4
AIzaSyDnjFUaqySz3ju_8kEUuyJ8JE6AIc47Lkw,
5
AIzaSyDzfJuNKrKpzai82YgqRg6ksLcpIhvGS7A,
6
AIzaSyAmML4tOnwjo202n60Ue_kU2mY2SWor3oA,
7
AIzaSyCcHl0Ge0qgbJD6KAqNw7ulxuCkFF-rg6Q,
8
AIzaSyDzOr21jeAoJMHlj-bihsOvg5uB4HOBM40,
9
AIzaSyDjZ0SnKsXje34Mn09HCTPDO0Cb7FaTflc,
10
AIzaSyC5kBkGmo2GClIHLbDhELQowpwadXwf9iY,
11
AIzaSyCglOiXDxSp7MnNNLKBmwIphGD4efphAjc,
12
AIzaSyAPK7Z43CjDFkGjU4aP-OBnzIipyL-KVws,
13
AIzaSyAXPQswBkbAHHhOhGK_UWQpxAjdhYbTis4,
14
AIzaSyCbbndNEN44tBrDnv7rOsMXWCiILx7-jbY,
15
AIzaSyBafWhRUWKkPg5k6M_O57Mz74V7IP5PWVs,
16
AIzaSyDRvXuYRBaZ-AlBw8GNDJKSyTHQmp3rQUU,
17
AIzaSyAvoAgK8wIqjediRfXCY0MmMbShN_VYlJI,
18
AIzaSyDMqE0spVwOOdBkXmgKdXIY1JqMk8LiQWI,
19
AIzaSyAiQEeAeozmBi5HTk6XkG2fomYdUFQxDxg,
20
AIzaSyBfFOs3ffu4oF4K5HkU6h6CY99XQnlFM3o,

展开收起

🌕想说的话#

本插件的开发灵感来源于 Core AI Power。当初偶然间发现这款插件，原本只是想尝试一下，结果发现无法正常使用——主要有两个原因：一是我的博客所用的主题不同，二是该插件仅支持 文心一言 1.0 版本，而目前官网已经不再开放 1.0 的申请接口。

因此，我决定自己动手开发了一个兼容 文心一言 2.0 接口 的插件，并对 B2 主题 进行了适配测试，运行效果良好。其他主题暂未测试，如遇兼容性问题，建议可以尝试使用原版的 Core AI Power 插件。

另外需要说明的是，本插件默认带有一个跳转至我博客的引流链接。如果你不希望显示此链接，可以在你的主题样式中添加以下 CSS 代码进行隐藏：

1
.ai-summary-brand {  display: none;}

如果你的博客部署在海外服务器（外网环境），我推荐优先使用 Gemini 模型。上文中提到的 API Key，你可以直接拿来用，开箱即用。

其实最初我就是打算接入 Gemini 的。为此测试了很久，每次都连不上，搞得我一度崩溃 —— 明明本地测试一切正常。最终才发现，问题根源在于我用的是 国内的阿里云服务器。我淦……😩

开源地址#

🎁https://github.com/uurani/ai-summary

MyBatisCodeHelper-Pro破解[V3.4.4]

Fri, 04 Jul 2025 00:00:00 GMT

提前申明：这篇文章只用于作者个人记录，任何人不得转载、分享。不转发不扩散，如因此造成的任何损失或其他影响，本人概不承担。MyBatisCodeHelper-Pro 是一款很不错的 IDEA 插件，有能力的还是购买正版授权。如官方侵权或产生其他影响请联系我立即删除。

下载 MyBatisCodeHelper-Pro#

在 idea 插件市场下载所需版本。目前分两个版本，一个是idea2023.2+版本使用，一个是idea2019.1 — 2023.1.7版本使用。更新时间：2025年07月04日

下载目前最新版：MyBatisCodeHelper-Pro。解压，找到 jar 包：instrumented-MyBatisCodeHelper-Pro241-3.4.4+2321

下载 cfr#

一个 Java 反编译器，官网：https://www.benf.org/other/cfr

下载好后，将 cfr-0.152.jar 和 instrumented-MyBatisCodeHelper-Pro241-3.4.4+2321.jar 放在同一目录下，执行命令：

Terminal window

1
java -jar cfr-0.152.jar instrumented-MyBatisCodeHelper-Pro241-3.4.4+2321.jar --renamedupmembers true --hideutf false >> a.txt

等待数秒钟命令执行完毕，分析 a.txt 文件：

最终定位到：搜索 @SerializedName(value="validTo")

1
public class f {
2
    // 付费密钥
3
    @SerializedName(value="paidKey")
4
    private String var_java_lang_String_a;
5
    // 校验是否通过
6
    @SerializedName(value="valid")
7
    private Boolean var_java_lang_Boolean_a;
8
    // 机器码
9
    @SerializedName(value="userMac")
10
    private String b;
11
    // 激活截止日期
12
    @SerializedName(value="validTo")
13
    private Long var_java_lang_Long_a;
14
}

我加了注释，然后我们使用 Java 字节码技术修改这个类的各个属性 get 方法，使之直接返回正确的值即可。

通过上述方法随便输入激活码激活时，正常都是成功的，但有的可能会发现激活是吧，报错：base64解密异常，分析报错信息

最终定位到：打开 a.txt，搜索 private static Gson

找到如下所在的包及类：

1
public class e {
2
    private static Gson a = new Gson();
3

4
    public static f a(String string) {
5
        String string2;
6
        byte[] byArray = null;
7
        try {
8
            byArray = d.b(d.java_security_interfaces_RSAPublicKey_a(new String(Base64.getDecoder().decode("TUlHZk1BMEdDU3FHU0liM0RRRUJBUVVBQTRHTkFEQ0JpUUtCZ1FDZzUyUjExV0h1MysvNUV2WnhkS0l2a3ovekpnS2VNUUhNLytMVkxSZS9zWUpFQlUxbUUrODc3MmJJckk4UThscldqSHc5cmVjQ1RWVVhXUnhWYXBndk1HYTZ3KzU4STZwYXdSaFhwZDBrRkhUY2xxeUZGWFpoS3ZiQUtoblphRGNuZkJtSkhObTQwR0JFTGpCTmx5MXpha2FIblFmUzF0QlhaSGQwOUV0c2VRSURBUUFC"), Charsets.UTF_8)), Base64.getDecoder().decode(string));
9
        }
10
        catch (b b2) {
11
            byArray = d.b(new c(), Base64.getDecoder().decode(string));
12
        }
13
        f f2 = null;
14
        try {
15
            string2 = new String(byArray, "UTF-8");
16
        }
17
        catch (UnsupportedEncodingException unsupportedEncodingException) {
18
            throw new RuntimeException(unsupportedEncodingException);
19
        }
20
        try {
21
            f2 = (f)a.fromJson(string2, f.class);
22
        }
23
        catch (Exception exception) {
24
            throw new RuntimeException("gson catch exception, the json string is" + string2, exception);
25
        }
26
        return f2;
27
    }
28
}

展开收起

看他里面逻辑无非就是 base64 解析，然后 gson 转换。直接修改这个类即可。

使用 Javassist 修改类文件#

添加 maven 依赖：

1
<dependency>
2
    <groupId>org.javassist</groupId>
3
    <artifactId>javassist</artifactId>
4
    <version>3.25.0-GA</version>
5
</dependency>

如上分析，主要修改的就是 com.ccnode.codegenerator.af.f.e 的 e 方法。

1
       CtClass ctClass = classPool.get("com.ccnode.codegenerator.af.f.e");
2
        CtMethod parseLicenseMethod = ctClass.getDeclaredMethod("a", new CtClass[] { classPool.get("java.lang.String") });
3
        StringBuffer bodyBuff = new StringBuffer();
4
        bodyBuff.append("{")
5
                .append(" com.google.gson.Gson gson = new com.google.gson.Gson();")
6
                .append(" com.ccnode.codegenerator.af.d.f e = (com.ccnode.codegenerator.af.d.f)gson.fromJson($1,com.ccnode.codegenerator.af.d.f.class);")
7
                .append(" return e;")
8
                .append("}");
9
        parseLicenseMethod.setBody(bodyBuff.toString());

之前直接这么修改就完成了，但是后面作者加了验证，所以每一行我们都要去修改

1
 try {
2
                ApplicationManager.getApplication().invokeLater(new Runnable(){
3

4
                    @Override
5
                    public void run() {
6
                        Messages.showErrorDialog((String)"你正在使用破解版的MybatisCodeHelperPro插件，将会生成错误的代码和造成电脑卡慢请到 https://brucege.com/pay/view 购买正版", (String)"MybatisCodeHelperPro插件非正版");
7
                        com.ccnode.codegenerator.j.a.com_ccnode_codegenerator_myconfigurable_Profile_a().setValid(false);
8
                        ApplicationImpl applicationImpl = (ApplicationImpl)ApplicationManager.getApplication();
9
                        applicationImpl.exit(true, true);
10
                    }
11
                });
12
            }
13
            catch (Exception exception) {
14
                // empty catch block
15
            }

展开收起

我现在主要做的就是在进行验证的时候，我们直接return掉，代码如下：

1
  // 修改第一个方法
2
        CtClass ctClass = classPool.get("com.ccnode.codegenerator.af.f.e");
3
        CtMethod parseLicenseMethod = ctClass.getDeclaredMethod("a", new CtClass[] { classPool.get("java.lang.String") });
4
        StringBuffer bodyBuff = new StringBuffer();
5
        bodyBuff.append("{")
6
                .append(" com.google.gson.Gson gson = new com.google.gson.Gson();")
7
                .append(" com.ccnode.codegenerator.af.d.f e = (com.ccnode.codegenerator.af.d.f)gson.fromJson($1,com.ccnode.codegenerator.af.d.f.class);")
8
                .append(" return e;")
9
                .append("}");
10
        parseLicenseMethod.setBody(bodyBuff.toString());
11

12
        //修改第二个方法
13
        CtClass ctClass2 = classPool.get("com.ccnode.codegenerator.n.e");
14
        CtMethod methodToModify2 = ctClass2.getDeclaredMethod("a");
15
        methodToModify2.setBody("{ return; }");
16

17
        //修改第三个方法
18
        CtClass ctClass3 = classPool.get("com.ccnode.codegenerator.w.a");
19
        CtMethod methodToModify3 = ctClass3.getDeclaredMethod("a");
20
        methodToModify3.setBody("{ return; }");
21

22
        //修改第四个方法
23
        CtClass ctClass4 = classPool.get("com.ccnode.codegenerator.G.e.d");
24
        CtMethod methodToModify4 = ctClass4.getDeclaredMethod("a", new CtClass[]{});
25
        methodToModify4.setBody("{ return; }");
26

27
        //修改第五个方法
28
        CtClass ctClass5 = classPool.get("com.ccnode.codegenerator.ad.ab");
29
        CtMethod methodToModify5 = ctClass5.getDeclaredMethod("a");
30
        methodToModify5.setBody("{ return; }");
31

32
        //修改第六个方法
33
        CtClass ctClass6 = classPool.get("com.ccnode.codegenerator.ad.a.b");
34
        CtMethod methodToModify6 = ctClass6.getDeclaredMethod("a");
35
        methodToModify6.setBody("{ return; }");
36

37
        //修改第七个方法
38
        CtClass ctClass7 = classPool.get("com.ccnode.codegenerator.ae.a");
39
        CtMethod methodToModify7 = ctClass7.getDeclaredMethod("a", new CtClass[] {});
40
        methodToModify7.setBody("{ return; }");

展开收起

运行完成后，会将修改的 class 文件生成到指定目录下。

替换 jar 包的对应 class 文件#

使用压缩工具 Bandzip 或 7zip 替换都有问题。推荐使用360压缩，这里值得注意的是要和 jar 里的的路径对应起来。

查看结果#

然后将更新后的这个 jar 包，替换原始 jar 包，重启 idea，按如下格式输入离线激活码激活，大功告成。

1
{
2
  "paidKey": "muxui",
3
  "valid": true,
4
  "userMac": "离线激活时显示的唯一码",
5
  "validTo": 4859711999000
6
}

参考文章：#

https://www.52pojie.cn/thread-1759478-1-1.html

从 WordPress 到 Astro迁移实战全记录

Thu, 23 Jul 2026 00:00:00 GMT

这篇文章记录了把 Muxui 从 WordPress（B2 Pro） 迁到 Astro + Firefly 的完整过程。不是「理论科普」，而是一次可复现的实操：文章怎么导、图片怎么改、导航怎么拆、友链怎么迁、踩了哪些坑。

如果你也在考虑离开 WordPress，或者正在把内容搬到 Astro / Fuwari / Firefly 一类静态主题，可以直接对照本文的步骤做。

为什么离开 WordPress#

WordPress 很强，但对我这种以内容为主、不需要商城和复杂会员体系的个人站来说，日常成本越来越明显：

性能与安全：PHP + 数据库 + 插件栈，更新、备份、防篡改都要花精力
主题耦合深：B2 Pro 功能丰富，但短代码、付费隐藏、圈子等和主题绑死，换主题等于重做
静态化红利：Astro 构建后是纯静态（或边缘静态），CDN 分发简单，运维接近零

最终选择 Firefly——基于 Astro 的个人博客主题，Markdown / MDX 写作，配置全在 TypeScript 文件里，改起来清晰。

目标架构一览#

项目	迁移前	迁移后
运行时	WordPress + PHP + MySQL	Astro 静态构建
主题	B2 Pro	Firefly（fork 自用）
内容	后台编辑器 / Gutenberg	`src/content/posts/*.md`
图片	`muxui.com/wp-content/uploads/...`	`muxui.com/uploads/...`
域名	muxui.com	仍为 muxui.com

仓库结构大致是：

1
Firefly/
2
├── muxui.WordPress.2026-07-23.xml   # WXR 导出（本地用，不必提交）
3
├── scripts/
4
│   ├── migrate-wordpress.mjs        # 一次性迁移脚本
5
│   └── lib/
6
│       ├── wxr-parse.mjs            # 解析 WXR
7
│       └── html-to-md.mjs           # HTML → Markdown + 图床改写
8
├── src/config/                      # 站点 / 导航 / 友链等配置
9
└── src/content/posts/               # 迁过来的文章

migrate-wordpress.mjs展开收起

1
import fs from "node:fs";
2
import path from "node:path";
3
import { parseWxr } from "./lib/wxr-parse.mjs";
4
import { htmlToMarkdown, rewriteImageUrls } from "./lib/html-to-md.mjs";
5

6
const ROOT = process.cwd();
7
const XML = path.join(ROOT, "muxui.WordPress.2026-07-23.xml");
8
const POSTS_DIR = path.join(ROOT, "src/content/posts");
9
const SITE_CONFIG = path.join(ROOT, "src/config/siteConfig.ts");
10

11
function decodeSlug(raw) {
12
  if (!raw) return "";
13
  try {
14
    return decodeURIComponent(raw);
15
  } catch {
16
    return raw;
17
  }
18
}
19

20
function safeSlug(title, id) {
21
  const base = title
22
    .toLowerCase()
23
    .replace(/[^\p{L}\p{N}]+/gu, "-")
24
    .replace(/^-+|-+$/g, "")
25
    .slice(0, 80);
26
  return base || `post-${id}`;
27
}
28

29
function pickCategory(cats) {
30
  const specific = cats.filter((c) => c !== "文章");
31
  return specific[0] || cats[0] || "";
32
}
33

34
function yamlEscape(s) {
35
  return String(s).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
36
}
37

38
function toIsoDate(wpDate) {
39
  return wpDate.slice(0, 10);
40
}
41

42
function excerptFrom(md, excerpt) {
43
  if (excerpt?.trim()) return excerpt.trim().slice(0, 160);
44
  const plain = md
45
    .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
46
    .replace(/\[[^\]]*\]\([^)]*\)/g, "$1")
47
    .replace(/[#>*`\[\]()\-_!]/g, " ")
48
    .replace(/https?:\/\/\S+/g, "")
49
    .replace(/\s+/g, " ")
50
    .trim();
51
  return plain.slice(0, 120);
52
}
53

54
function clearPostsDir(dir) {
55
  if (!fs.existsSync(dir)) {
56
    fs.mkdirSync(dir, { recursive: true });
57
    return;
58
  }
59
  for (const name of fs.readdirSync(dir)) {
60
    fs.rmSync(path.join(dir, name), { recursive: true, force: true });
61
  }
62
}
63

64
function buildFrontmatter(post, image, body, slug) {
65
  const tags = post.tags.map((t) => `"${yamlEscape(t)}"`).join(", ");
66
  const desc = excerptFrom(body, post.excerpt);
67
  return `---
68
title: "${yamlEscape(post.title)}"
69
published: ${toIsoDate(post.date)}
70
updated: ${toIsoDate(post.modified)}
71
description: "${yamlEscape(desc)}"
72
image: "${yamlEscape(image)}"
73
tags: [${tags}]
74
category: "${yamlEscape(pickCategory(post.cats))}"
75
draft: false
76
comment: true
77
slug: "${yamlEscape(slug)}"
78
---
79

80
`;
81
}
82

83
function patchSiteConfig(filePath) {
84
  let src = fs.readFileSync(filePath, "utf8");
85
  src = src.replace(/title: "Firefly"/, 'title: "Muxui"');
86
  src = src.replace(/subtitle: "Demo site"/, 'subtitle: "记录美好生活！"');
87
  src = src.replace(
88
    /site_url: "https:\/\/firefly\.cuteleaf\.cn"/,
89
    'site_url: "https://muxui.com"',
90
  );
91
  src = src.replace(
92
    /description:\s*\n\s*"[\s\S]*?",/,
93
    'description:\n\t\t"记录美好生活！",',
94
  );
95
  src = src.replace(
96
    /keywords: \[[\s\S]*?\],/,
97
    `keywords: [
98
\t\t"Muxui",
99
\t\t"博客",
100
\t\t"技术博客",
101
\t\t"muxui.com",
102
\t],`,
103
  );
104
  src = src.replace(/(navbar: \{[\s\S]*?title: )"Firefly"/, '$1"Muxui"');
105
  fs.writeFileSync(filePath, src);
106
}
107

108
function main() {
109
  if (!fs.existsSync(XML)) {
110
    console.error("Missing WXR:", XML);
111
    process.exit(1);
112
  }
113

114
  const { posts, attachmentsById } = parseWxr(XML);
115
  console.log(`Parsed ${posts.length} published posts`);
116

117
  clearPostsDir(POSTS_DIR);
118

119
  const used = new Set();
120
  for (const post of posts) {
121
    const body = htmlToMarkdown(post.content);
122
    let image = "";
123
    if (post.thumbnailId && attachmentsById.has(post.thumbnailId)) {
124
      image = rewriteImageUrls(attachmentsById.get(post.thumbnailId));
125
    }
126
    let slug = decodeSlug(post.slug) || safeSlug(post.title, post.id);
127
    // Windows-safe filenames: avoid reserved chars
128
    slug = slug.replace(/[<>:"/\\|?*]/g, "-").replace(/\.+$/g, "");
129
    if (used.has(slug)) slug = `${slug}-${post.id}`;
130
    used.add(slug);
131
    const fm = buildFrontmatter(post, image, body, slug);
132
    const out = path.join(POSTS_DIR, `${slug}.md`);
133
    fs.writeFileSync(out, fm + body + "\n", "utf8");
134
    console.log("Wrote", path.relative(ROOT, out));
135
  }
136

137
  patchSiteConfig(SITE_CONFIG);
138
  console.log("Patched", path.relative(ROOT, SITE_CONFIG));
139
  console.log("Done.");
140
}
141

142
main();

展开收起

wxr-parse.mjs展开收起

1
import fs from "node:fs";
2
import { XMLParser } from "fast-xml-parser";
3

4
const parser = new XMLParser({
5
  ignoreAttributes: false,
6
  attributeNamePrefix: "@_",
7
  cdataPropName: "__cdata",
8
  isArray: (name) =>
9
    ["item", "category", "wp:postmeta", "wp:comment"].includes(name),
10
});
11

12
function textOf(node) {
13
  if (node == null) return "";
14
  if (typeof node === "string" || typeof node === "number") return String(node);
15
  if (typeof node === "object" && "__cdata" in node)
16
    return String(node.__cdata ?? "");
17
  return String(node);
18
}
19

20
function metaMap(postmeta) {
21
  const map = {};
22
  for (const m of postmeta || []) {
23
    map[textOf(m["wp:meta_key"])] = textOf(m["wp:meta_value"]);
24
  }
25
  return map;
26
}
27

28
function categoriesOf(item) {
29
  const cats = [];
30
  const tags = [];
31
  for (const c of item.category || []) {
32
    const name = textOf(c);
33
    const domain = c["@_domain"];
34
    if (domain === "post_tag") tags.push(name);
35
    else if (domain === "category") cats.push(name);
36
  }
37
  return { cats, tags };
38
}
39

40
export function parseWxr(xmlPath) {
41
  const xml = fs.readFileSync(xmlPath, "utf8");
42
  const doc = parser.parse(xml);
43
  const channel = doc.rss.channel;
44
  const attachmentsById = new Map();
45
  const posts = [];
46

47
  for (const item of channel.item || []) {
48
    const type = textOf(item["wp:post_type"]);
49
    const id = textOf(item["wp:post_id"]);
50
    if (type === "attachment") {
51
      const url = textOf(item["wp:attachment_url"]) || textOf(item.guid) || "";
52
      attachmentsById.set(id, url);
53
      continue;
54
    }
55
    if (type !== "post") continue;
56
    if (textOf(item["wp:status"]) !== "publish") continue;
57

58
    const { cats, tags } = categoriesOf(item);
59
    const meta = metaMap(item["wp:postmeta"]);
60
    posts.push({
61
      id,
62
      title: textOf(item.title),
63
      slug: textOf(item["wp:post_name"]),
64
      date: textOf(item["wp:post_date"]),
65
      modified: textOf(item["wp:post_modified"]),
66
      excerpt: textOf(item["excerpt:encoded"]),
67
      content: textOf(item["content:encoded"]),
68
      cats,
69
      tags,
70
      thumbnailId: meta._thumbnail_id || "",
71
    });
72
  }
73

74
  return {
75
    site: {
76
      title: textOf(channel.title),
77
      link: textOf(channel.link),
78
      description: textOf(channel.description),
79
    },
80
    attachmentsById,
81
    posts,
82
  };
83
}

展开收起

html-to-md.mjs展开收起

1
import TurndownService from "turndown";
2

3
const TARGET_PREFIX = "https://muxui.com/uploads/";
4

5
export function rewriteImageUrls(text) {
6
  return text
7
    .replace(/https?:\/\/img\.roven\.cc\/images\//g, TARGET_PREFIX)
8
    .replace(/https?:\/\/muxui\.com\/wp-content\/uploads\//g, TARGET_PREFIX)
9
    .replace(/(["'(=\s]|^)\/wp-content\/uploads\//g, `$1${TARGET_PREFIX}`);
10
}
11

12
function stripShortcodes(html) {
13
  return html
14
    .replace(/\[\/?b2[^\]]*\]/gi, "")
15
    .replace(/\[hide[^\]]*\]([\s\S]*?)\[\/hide\]/gi, "$1")
16
    .replace(/\[.*?\]/g, (m) => {
17
      const href = m.match(/https?:\/\/[^\s\]]+/);
18
      return href ? `<p><a href="${href[0]}">${href[0]}</a></p>` : "";
19
    });
20
}
21

22
export function htmlToMarkdown(html) {
23
  const cleaned = stripShortcodes(rewriteImageUrls(html));
24
  const td = new TurndownService({
25
    headingStyle: "atx",
26
    codeBlockStyle: "fenced",
27
    bulletListMarker: "-",
28
  });
29
  td.keep(["iframe", "video", "table"]);
30
  return td.turndown(cleaned).trim();
31
}

展开收起

第一步：从 WordPress 导出内容#

后台路径：工具 → 导出 → 全部内容，得到 WXR（WordPress eXtended RSS）XML。

我这份导出里大致有：

已发布文章 23 篇（另有 1 篇草稿跳过）
附件约 181 个（主要用于封面 ID → URL 映射）
以及页面、友链、圈子、快讯等 B2 扩展类型

第一期只迁 已发布文章 + 站点基础信息；友链、页脚备案、导航定制是迁完内容后再单独处理的。

建议：导出后先把 XML 放到仓库根目录本地用，不要轻易提交到公开仓库（体积大，也可能含邮件等隐私字段）。

第二步：写一个可复跑的迁移脚本#

手工复制 23 篇不现实，所以用 Node 脚本一次性完成：

用 fast-xml-parser 解析 WXR
建立 attachment_id → URL 索引（封面 _thumbnail_id）
过滤 post_type=post 且 status=publish
Gutenberg HTML → Markdown（turndown）
改写图片域名
写出 Firefly frontmatter + .md 文件
更新 siteConfig.ts，删掉主题自带 Demo 文

核心映射关系：

WordPress	Firefly
title	`title`
post_name（URL 解码）	文件名 / `slug`
post_date	`published`
post_modified	`updated`
category	`category`（优先具体分类，弱化泛化的「文章」）
post_tag	`tags`
excerpt / 正文截取	`description`
`_thumbnail_id` → attachment	`image`（绝对 URL）
content	Markdown 正文

图片统一规则：

1
https://muxui.com/wp-content/uploads/{path}
2
  → https://muxui.com/uploads/{path}

相对路径 /wp-content/uploads/... 同样改写；外站自带的 /wp-content/uploads/（例如引用别人站点的图）不要动，否则会出现：

1
https://www.example.comhttps://muxui.com/uploads/...

这种拼接错乱——我第一次写正则时就踩过。

运行方式：

Terminal window

1
pnpm add -D turndown fast-xml-parser
2
node scripts/migrate-wordpress.mjs
3
pnpm check

第三步：处理 B2 / Gutenberg 的「脏内容」#

纯 Markdown 博客迁出去通常很干净；B2 + Gutenberg 会带上：

区块注释：
短代码：隐藏内容、下载框、卡片等
偶发残缺 HTML、外链图片

策略是 可读优先，不追求像素级还原：

Turndown 处理常见标题、列表、链接、代码块、表格
[hide]...[/hide] 之类尽量展开正文
无法可靠还原的短代码，降级成链接或直接丢掉，保证构建不炸

迁完后务必抽查：

图多的文章（封面 + 正文图是否都是 muxui.com/uploads）
代码长文（Markdown 代码围栏是否完整）
带外链配图的文章（外站 URL 是否被误伤）

第四步：站点身份与页脚#

siteConfig.ts 里至少改这些：

title / navbar.title → Muxui
subtitle / description → 「记录美好生活！」
site_url → https://muxui.com

页脚版权与备案：

1
Copyright © 2026 Muxui ・ 蜀ICP备2024080231号-1

备案号放在 FooterConfig.html，并链到工信部查询页 https://beian.miit.gov.cn/。侧栏显示名同步改成 Muxui。

第五步：导航按「文章 / 软件」分组#

WordPress 时代分类较杂。迁到 Firefly 后，导航做成：

主要 · 文章 · 软件 · 工具 · 友链 · 留言 · 关于我

其中：

文章下拉：归档 / 分类 / 标签 —— 只覆盖
文章、Java、Python、PHP、Vue、jQuery
软件下拉：归档 / 分类 / 标签 —— 只覆盖
软件、Windows、Mac、IOS
工具：外链 https://muxui.com/tools，新窗口打开

实现上用配置文件声明分组，例如：

1
export const CONTENT_GROUPS = {
2
  article: {
3
    id: "article",
4
    name: "文章",
5
    categories: ["文章", "Java", "Python", "PHP", "Vue", "jQuery"],
6
  },
7
  software: {
8
    id: "software",
9
    name: "软件",
10
    categories: ["软件", "Windows", "Mac", "IOS"],
11
  },
12
};

归档：/archive/?category=A&category=B&...（Firefly 的 ArchivePanel 支持多 category OR 筛选）
分类页：/categories/article/、/categories/software/
标签页：/tags/article/、/tags/software/（标签点击时带上同组 category，避免串到另一边）

相册、追番、番组、打赏、音乐等与个人站无关的入口全部关掉，避免空页面。

第六步：友链迁移与入驻说明#

WordPress 里 post_type=links 很多，真正「友情链接」分类只有几条；AI / 网络工具那些不算友链，不要混进 Firefly 的 friendsConfig。

最终保留例如：

朱某的生活印记
小栋博客
handsome

并在 src/content/spec/friends.mdx 写清：

本站信息

名称：Muxui
介绍：记录个人生活点滴与技术笔记……
地址：https://muxui.com
Logo：https://muxui.com/favicon.ico

入驻说明要点

必须完成国内 ICP 备案
欢迎个人博客、WordPress 类同类站互换
首页链接需双方同等待遇
提交后请联系博主；未通过会在留言板回应
内容须合法合规
定期检查死链；对方取消互链则删除且不另行通知
请先在贵站加好本站，再按模板申请

迁移清单（可直接照抄）#

WordPress 导出 WXR，本地备份数据库与 uploads
Fork / Clone Firefly，建自己的分支
图床已托管旧路径（或准备批量同步 uploads → 图床）
写迁移脚本：解析 → 转 MD → 改图床 → 写 frontmatter
删除 Demo 文，更新 siteConfig / profileConfig
pnpm check / pnpm build 通过
抽查图多文、代码文、外链图
导航、友链、页脚备案、无用页面开关
DNS / CDN 切到静态托管（Vercel / Cloudflare Pages 等）
旧链接 301（若 URL 结构变化）

踩坑摘要#

图片正则过宽
不要匹配所有站点的 /wp-content/uploads/，只改自己的域名和站内相对路径。
单分类限制
Firefly 一篇文章一个 category。WordPress 多分类时要定优先级（例如去掉泛化「文章」后取第一个具体分类），否则导航分组会对不齐。
中文 slug
post_name 可能是百分号编码，写入文件前要 decodeURIComponent；Windows 文件名还要避开非法字符。
短代码不可完美还原
付费隐藏、下载框等接受降级，比硬解析到构建失败更划算。
主题功能默认全开
Firefly Demo 带追番、相册、音乐等，个人站要主动关，不然导航和侧栏很「热闹」。

结果与后续#

迁移完成后：

23 篇正文以 Markdown 落在 Git 里，可版本管理、可 PR 审稿
图片走自有图床，站点本体静态分发
导航按「文章 / 软件」内容域拆分，比 WordPress 默认分类页更符合阅读习惯
友链与入驻规则与旧站对齐

后续还可以做：

旧 permalink → 新 /posts/{slug}/ 的 301 表
关于页、评论系统（Twikoo / Waline 等）对接
把迁移脚本再封装成「指定 WXR 路径即可复跑」的小工具

结语#

WordPress 适合「什么都想装一点」的阶段；当站点目标收敛成 写文章、存笔记、换友链 时，Astro 静态站往往更省心。

这次 Muxui 的路径可以概括成一句话：

WXR 导出 → 脚本转 Markdown → 图床改写 → Firefly 配置本地化。

脚本和配置都在自己的 Git 仓库里，下次换机器或重建环境，只要拉代码、装依赖、构建即可。

如果你也在迁站，欢迎在留言板交流你的导出格式和坑点——尤其是不同主题的短代码，大家踩的都不太一样。

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

YOLO训练麻将(Mahjong)识别,导出ONNX

Mon, 20 Apr 2026 00:00:00 GMT

本文基于 Roboflow Universe 数据集（例如
http://(https://universe.roboflow.com/jon-chan-gnsoa/mahjong-baq4s”
）与仓库内脚本，在 Windows 上完成训练，并导出 ONNX 供后端推理。下文配图均为本机实测截图，便于对照。快速体验
小程序

1. 环境要求#

- Windows 10 / 11

- Python 3.10 或 3.11

- NVIDIA 显卡：建议已安装 CUDA 驱动；训练阶段 GPU 会持续高占用

命令行自检：

1
nvidia-smi
2
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'no gpu')"

训练中若希望直观确认显卡是否在干活，可打开 **任务管理器 → 性能 → GPU**。下图为本机训练时 **RTX 3070** 的占用：**利用率接近满载、专用显存占用约数 GB**，说明计算确实在显卡上跑（温度因机型与散热而异，只要在合理区间即可）。

2. 安装依赖#

在 Mahjong_YOLO 根目录：

1
python -m venv .venv
2
.\.venv\Scripts\activate
3
python -m pip install --upgrade pip
4
pip install -r requirements.txt

3. 数据与类别#

目录约定（Roboflow 导出常见结构）：

1
dataset/
2
  train/images/    train/labels/
3
  valid/images/    valid/labels/
4
  test/images/     test/labels/
5
  data.yaml

- 类别数与名称以 `dataset/data.yaml` 为准（示例工程为 42 类，`nc: 42`）。

- 标签为 YOLO 检测格式，每行：`class_id x_center y_center width height`（均为 0～1 归一化坐标）。

4. 训练前：标签体检#

在根目录、已激活 `.venv`：

1
python scripts/check_labels.py --data dataset/data.yaml --num-classes 42 --show-bad-samples 15

若误用 分割标注 当检测，可能出现大量 `invalid_lines`，可先：

1
python scripts/convert_seg_labels_to_det.py --dataset-root dataset
2
python scripts/check_labels.py --data dataset/data.yaml --num-classes 42 --show-bad-samples 15

5. 第一轮训练：YOLOv8n 跑通#

1
python scripts/train.py --data dataset/data.yaml --model yolov8n.pt --imgsz 960 --epochs 80 --batch 8 --workers 2 --device 0 --name mahjong_42cls_n

显存紧张时可改为更小输入、更小 batch，例如：

1
python scripts/train.py --data dataset/data.yaml --model yolov8n.pt --imgsz 640 --epochs 80 --batch 4 --workers 0 --device 0 --name mahjong_42cls_n_safe

终端里应能看到：验证集路径、`save_dir`、优化器、TensorBoard 提示、当前 epoch 进度条、GPU 显存占用、各项 loss 等。下图示例为 第 1 轮训练进行中（路径中的 `mahjong_42cls_n` 即本次 `—name`，具体以你机器打印为准）。

6. 训练输出目录（务必核对）#

默认输出在：

1
runs/detect/<run_name>/

`<run_name>` 对应你传入的 `—name`。若同名目录已存在，Ultralytics 往往会自动顺延为 `mahjong_42cls_n2`、`mahjong_42cls_n3` 等，请以终端里的 `save_dir` 或 `runs/detect` 下实际文件夹为准。

常用文件：

路径	说明
`runs/detect/<run_name>/weights/best.pt`	验证集上表现最佳的权重，导出 ONNX 首选
`runs/detect/<run_name>/results.csv`	每 epoch 指标，便于脚本汇总或自行画图

训练结束后可看摘要：

1
python scripts/show_train_summary.py --results-csv runs/detect/<run_name>/results.csv

训练中另开终端可选：

1
python scripts/watch_train.py --results-csv runs/detect/<run_name>/results.csv --interval 5 --idle-timeout 180

7. TensorBoard：曲线与计算图#

安装并开启 TensorBoard 日志（若尚未配置）：

1
pip install tensorboard
2
yolo settings tensorboard=True
3
tensorboard --logdir runs\detect\<run_name> --port 6006

浏览器访问：`http://localhost:6006\`。左侧 Runs 中选择对应目录（例如界面中的 `detect/mahjong_42cls_n`）。

GRAPHS 页可查看模型数据流概览（input → DetectionModel → output），用于确认当前跑的是检测结构、日志是否挂在本次 run 上：

SCALARS 页重点看 lr（学习率调度是否如预期）、metrics（mAP50、mAP50-95、precision、recall）。训练初期曲线通常整体向上；若长期横盘或发散，再回头查数据与超参。

同一 run 在训练后期，指标会趋于稳定。下图示例中可见 mAP50、mAP50-95、precision、recall 等读数（具体数值随数据与随机种子变化，以你本地 `results.csv` 为准）。

8. 第二轮（可选）：换更大模型提精度#

第一轮流程与指标正常后，可再跑例如 YOLOv8s、加长 epoch：

1
python scripts/train.py --data dataset/data.yaml --model yolov8s.pt --imgsz 960 --epochs 150 --batch 8 --workers 2 --device 0 --name mahjong_42cls_s

同样注意 输出目录名是否带 `2` 后缀。

9. 导出 ONNX#

将 `—weights` 换成你选定的那次训练的 `best.pt`，`—imgsz` 与训练一致，便于与后端输入尺寸（如 `MAHJONG_OCR_IMGSZ`）对齐：

1
python scripts/export_onnx.py --weights runs/detect/mahjong_42cls_s/weights/best.pt --imgsz 960 --opset 12 --dynamic

产物示例：`artifacts/best.onnx`。类别文件复制给后端使用：

1
copy tools\label_classes.txt artifacts\classes.txt

## 10. ONNX 快速验证#

1
python scripts/predict_onnx_check.py --onnx artifacts/best.onnx --source dataset/test/images --imgsz 960 --conf 0.35 --iou 0.55 --device 0

可视化一般在 `artifacts/onnx_check/pred/`。若几乎全空或误检爆炸，先调 `conf`/`iou`，再核对预处理与类别顺序是否与训练一致。

开源地址#

🎁https://github.com/uurani/Mahjong_YOLO

自建 Headscale + DERP 全流程实战记录

Thu, 25 Dec 2025 00:00:00 GMT

记录一次完整、可上线、可长期运行的 Headscale + 自建 DERP 搭建过程。
本文不是“能跑就行”的教程，而是生产可用、已多客户端验证的配置方案。

简介#

Tailscale（Headscale）就是组建一个大的局域网，可以将你手里头的所有设备都拉到这个局域网内，进而使用局域网IP进行互联。
此外，Tailscale（Headscale）还有一个作用就是内网穿透，局域网内的设备之间的访问会通过穿透进行打洞（成功概率挺高），进而实现公网的点对点互联。而且就算打洞失败，也可以利用中转服务器进行互联。
应用场景举例：家里没有公网IP，但是可以通过Tailscale组网和穿透的方式实现在任意网络下对家里设备的访问。

整体架构说明#

使用 Headscale 作为 Tailscale 控制平面
自建 DERP Server，不依赖官方 DERP
使用 宝塔 / Nginx 统一终止 TLS
开启 DERP 防白嫖（verify-clients）
多客户端 tailscale netcheck 验证通过

最终架构如下：#

1
Tailscale Client
2
   ↓
3
Headscale（控制平面）
4
   ↓ 下发 DERP Map
5
https://derp.muxui.com/derp.json
6
   ↓
7
DERP Server（derper，HTTP 本地端口）
8
   ↓
9
宝塔 / Nginx（HTTPS 443）

DERP Server 搭建#

安装最新版GO#

更新软件包，安装依赖

1
apt update && apt upgrade
2
apt install -y wget git openssl curl

下载最新版GO

1
wget https://go.dev/dl/go1.25.5.linux-amd64.tar.gz
2
rm -rf /usr/local/go && tar -C /usr/local -xzf go1.25.5.linux-amd64.tar.gz

目前最新版为1.25.5，后续若有更新则可以去 https://go.dev/dl/ 查看最新版并替换下载即可，记得后面的版本号都要改

配置环境变量

1
export PATH=$PATH:/usr/local/go/bin
2
go version

1
echo "export PATH=$PATH:/usr/local/go/bin" >> /etc/profile
2
source /etc/profile

1
go env -w GO111MODULE=on
2
go env -w GOPROXY=https://goproxy.cn,direct

安装最新版Derper#

安装

1
go install tailscale.com/cmd/derper@latest

拷贝二进制文件

1
mkdir /etc/derp/
2
cp ~/go/bin/derper /etc/derp/

查看是否拷贝成功

1
ls /etc/derp

derper 域名部署（宝塔反代模式,国内服务器域名需要备案）#

⚠️ 关键原则：DERP 不自己处理 TLS

TLS 由宝塔 / Nginx 负责
derper 只监听本地 HTTP

正确启动参数（手动验证用）：#

1
/etc/derp/derper \
2
  -a :13445 \
3
  --hostname derp.muxui.com \
4
  --certmode=off \
5
  --stun \
6
  --stun-port 3478 \
7
  --verify-clients

看到以下日志即为成功：

1
STUN server listening on [::]:3478
2
derper: serving on :13445

systemd 服务（最终版）#

1
[Unit]
2
Description=Tailscale DERP Server
3
After=network-online.target
4
Wants=network-online.target
5

6
[Service]
7
Type=simple
8
User=root
9
ExecStart=/etc/derp/derper \
10
  -a :13445 \
11
  --hostname derp.muxui.com \
12
  --certmode=off \
13
  --stun \
14
  --stun-port 3478 \
15
  --verify-clients
16
Restart=always
17
RestartSec=5
18
LimitNOFILE=1048576
19

20
[Install]
21
WantedBy=multi-user.target

展开收起

启用并启动：

1
systemctl daemon-reload
2
systemctl enable derp --now
3
systemctl status derp

Derper IP部署(123.123.123.123改成自己服务器的IP)#

1
DERP_IP="123.123.123.123"

1
openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes -keyout ${DERP_IP}.key -out ${DERP_IP}.crt -subj "/CN=${DERP_IP}" -addext "subjectAltName=IP:${DERP_IP}"

这时候/root文件夹下会有两个证书文件：/root/123.123.123.123.crt和/root/123.123.123.123.key，拷贝到/etc/derp/:

1
mv /root/123.123.123.123.crt /etc/derp
2
mv /root/123.123.123.123.key /etc/derp

启动Derper服务器#

写入后台

新建文件derp.service

1
touch /etc/systemd/system/derp.service

写入以下内容

1
[Unit]
2
Description=TS Derper
3
After=network.target
4
Wants=network.target
5
[Service]
6
User=root
7
Restart=always
8
ExecStart=/etc/derp/derper -hostname 123.123.123.123 -a :13445 -http-port 13446 -certmode manual -certdir /etc/derp
9
RestartPreventExitStatus=1
10
[Install]
11
WantedBy=multi-user.target

启动

1
systemctl enable derp
2
systemctl restart derp
3
systemctl status derp

验证Derper是否搭建成功#

浏览器打开https://123.123.123.123:13445，忽略不安全，看看是不是显示下面的内容：

DERP
This is a Tailscale DERP server.
It provides STUN, interactive connectivity establishment, and relaying of end-to-end encrypted traffic for Tailscale clients.
Documentation:
About DERP
Protocol & Go docs
How to run a DERP server

DERP 防白嫖（verify-clients）#

为什么必须开启？#

不开启 --verify-clients：

任何人只要知道你的 DERP 地址
都可以把你当 TCP 中继刷流量

verify-clients 的工作方式#

DERP 通过 本机的 tailscaled
向 Headscale 校验客户端身份
只允许本 Tailnet 成员使用

搭建Headscale和Headscale-ui#

安装最新版Headscale#

下载

1
wget --output-document=headscale.deb \
2
  https://github.com/juanfont/headscale/releases/download/v0.27.1/headscale_0.27.1_linux_amd64.deb

目前最新版为0.27.1，后续若有更新则可以去 https://github.com/juanfont/headscale/releases 查看最新版并替换下载即可，记得后面的版本号都要改

安装

1
mv headscale_0.27.1_linux_amd64.deb headscale.deb
2
dpkg --install headscale.deb

修改配置文件（/etc/headscale/config.yaml）

仅列出需要修改的地方

1
server_url: https://headscale.muxui.com

1
listen_addr: 0.0.0.0:8080

1
metrics_listen_addr: ""

1
prefixes:
2
  v4: 100.64.0.0/10
3
#  v6: fd7a:115c:a1e0::/48

1
  # List of externally available DERP maps encoded in JSON
2
  urls:
3
    - https://derp.muxui.com/derp.json

1
  base_domain: tailnet.muxui.com

1
  # List of DNS servers to expose to clients.（建议改成国内适合自己的DNS）
2
  nameservers:
3
    global:
4
      - 114.114.114.114

启动

1
systemctl enable headscale
2
systemctl restart headscale
3
systemctl status headscale

3.3 安装最新版Headscale-ui#

下载

1
wget https://github.com/gurucomputing/headscale-ui/releases/download/2025.08.23/headscale-ui.zip

目前最新版为2025.08.23，后续若有更新则可以去 https://github.com/gurucomputing/headscale-ui 查看最新版并替换下载即可，记得后面的版本号都要改

安装

1
apt-get install unzip
2
unzip -d /var/www headscale-ui.zip

配置Derper服务器#

配置/etc/headscale/derp.json文件

新建

1
touch /etc/headscale/derp.json

写入以下内容

ip部署

1
{
2
  "Regions": {
3
    "901": {
4
      "RegionID":   901,
5
      "RegionCode": "Myself",
6
      "RegionName": "Myself Derper",
7
      "Nodes": [
8
          {
9
          "Name":             "901a",
10
          "RegionID":         901,
11
          "DERPPort":         13445,
12
          "IPv4":   "123.123.123.123",
13
          "InsecureForTests": true
14
        }
15
      ]
16
    }
17
  }
18
}

展开收起

使用域名（推荐做法）#

1
{
2
  "Regions": {
3
    "901": {
4
      "RegionID": 901,
5
      "RegionCode": "MUXUI",
6
      "RegionName": "Muxui DERP",
7
      "Nodes": [
8
        {
9
          "Name": "901a",
10
          "RegionID": 901,
11
          "HostName": "derp.muxui.com",
12
          "DERPPort": 443,
13
          "InsecureForTests": true
14
        }
15
      ]
16
    }
17
  }
18
}

展开收起

Nginx / 宝塔暴露 derp.json#

1
location /d/derp.json {
2
    alias /etc/headscale/derp.json;
3
    default_type application/json;
4
}

验证：

1
https://derp.muxui.com/derp.json

能直接返回 JSON。

如果不是宝塔,就下载安装并配置Nginx

下载

1
apt install -y nginx

打开/etc/nginx/sites-available/default并添加以下内容：

1
map $http_upgrade $connection_upgrade {
2
    default      upgrade;
3
    ''           close;
4
}
5
server {
6
    listen 80;
7
    listen [::]:80;
8
    listen 443      ssl http2;
9
    listen [::]:443 ssl http2;
10
    server_name headscale.example.com;
11
    ssl_certificate /root/cert.crt;
12
    ssl_certificate_key /root/private.key;
13
    ssl_protocols TLSv1.2 TLSv1.3;
14
    location / {
15
        proxy_pass http://127.0.0.1:8080;
16
        proxy_http_version 1.1;
17
        proxy_set_header Upgrade $http_upgrade;
18
        proxy_set_header Connection $connection_upgrade;
19
        proxy_set_header Host $server_name;
20
        proxy_redirect http:// https://;
21
        proxy_buffering off;
22
        proxy_set_header X-Real-IP $remote_addr;
23
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
24
        proxy_set_header X-Forwarded-Proto $scheme;
25
        add_header Strict-Transport-Security "max-age=15552000; includeSubDomains" always;
26
    }
27
    location /web {
28
    index  index.html;
29
          alias  /var/www/web;
30
  }
31
}
32
server {
33
  listen 80;
34
  listen [::]:80;
35

36
  server_name 127.0.0.1;
37

38
  root /var/www;
39
  index index.html index.htm index.nginx-debian.html;
40
  location /d {
41
    alias   /var/www;
42
    autoindex on;
43
  }
44
  location / {
45
    try_files $uri $uri/ =404;
46
  }
47
}

展开收起

启动

1
systemctl enable nginx
2
systemctl restart nginx
3
systemctl status nginx

验证安装#

重启Derper，Headscale和Nginx服务

1
systemctl restart derp
2
systemctl status derp

1
systemctl restart headscale
2
systemctl status headscale

1
systemctl restart nginx
2
systemctl status nginx

打开网站

https://headscale.example.com/web

如无意外应该是三个服务的状态应该是全绿的，网页也能正常打开，有报错的话建议按教程自查或在帖子底下留言

配置Headscale-ui#

生成API Key

1
headscale apikeys create --expiration 9999d

并将其写入到https://headscale.muxui.com/web/settings.html的Headscale API Key里面，点击Save API Key提交，见到右侧有小对勾即可

新建用户Default

打开https://headscale.`muxui`.com/web/users.html，点击New User，输入Default并提交

最终验证（最关键）#

Windows 客户端 netcheck#

1
tailscale netcheck

结果示例：

1
Nearest DERP: Muxui DERP
2
DERP latency:
3
  - MUXUI: 6.9ms

下载最新客户端#

https://tailscale.com/download

启动指令解析#

—login-server: 指定使用的Headscale服务器地址，即https://headscale.example.com
—advertise-routes: 向Headscale服务器报告当前客户端处于哪个内网网段下, 便于Headscale服务器让同内网设备直接内网直连(可选的)或者将其他设备指定流量路由到当前内网(可选)，多条路由英文逗号隔开
—accept-routes: 是否接受Headscale服务器下发的用于路由到其他客户端内网的路由规则(可选)
—accept-dns: 是否使用Headscale服务器下发的 DNS 相关配置(可选, 推荐关闭)
—force-reauth：强制重新认证
—advertise-exit-node：作为出口节点

不同客户端的启动方法#

Windows

以管理员身份启动PowerShell，输入以下代码：

1
tailscale login --login-server https://headscale.example.com

用非国区Apple ID下载，配置V P N文件

点击右上角头像，点击Log In...，点击右上角三个点,点击Use a custom coordination server，输入https://headscale.example.com,点击Login in

Linux

安装

1
curl -fsSL https://tailscale.com/install.sh | sh

运行

1
tailscale up --reset --advertise-routes=192.168.x.0/24 --accept-routes=true --login-server=https://headscale.example.com

到Headscale-ui中允许设备加入局域网#

上面在客户端执行了tailscale up之后，在客户都会显示一个带Device Key的代码，格式类似于：

1
headscale nodes register --user USERNAME --key mkey:ed8f19e22f51c9c231c8bc8ccbxxxxxxxxxxxxxxf86c8211e4ad32b6c6e

拷贝mkey:ed8f19e22f51c9c231c8bc8ccbxxxxxxxxxxxxxxf86c8211e4ad32b6c6e，去 https://headscale.example.com/web/devices.html中导入Device Key

参考教程#

基于 Cloudflare Workers + Telegram Bot + D1 的双向匿名聊天系统完整实现

Sun, 16 Nov 2025 00:00:00 GMT

在本篇文章中，我将分享一个基于 Cloudflare Workers + Telegram Bot + D1 数据库 的完全无服务器（Serverless）聊天系统。该机器人支持用户匿名与管理员双向通信，具备首访验证、自动诈骗检测、屏蔽管理、消息映射等功能，是一个非常适合作为客服、匿名反馈、小型 IM 系统的解决方案。

⭐ 系统亮点#

🚀 100% Serverless 无需服务器
🔐 首访用户自动加减法验证（防骚扰）
🔁 双向匿名对话（用户看不到管理员 ID）
🛡 管理员可屏蔽 / 解封任何用户
🧠 自动诈骗账号检测（基于 D1 fraud 表）
💾 D1 数据库存储用户状态与消息映射
📌 管理员收到用户消息时自动生成“用户资料卡”
🔔 可控频率的通知提醒机制

🧩 系统架构#

1
[Telegram User]
2
      ↓ 发送消息
3
[Cloudflare Workers /endpoint]
4
      ↓
5
[验证系统（加减法 1～10）]
6
      ↓ 通过后
7
[反诈检测(fraud)]
8
      ↓
9
[自动转发消息 → 管理员]
10

11
管理员 ←→ 用户 （双向聊天）

📦 使用技术#

技术	用途
Cloudflare Workers	核心逻辑执行环境
Telegram Bot API	双向聊天接口
Cloudflare D1	用户资料、屏蔽状态、验证码、消息映射存储
Webhooks	实时接收 Telegram 更新事件

🗄 数据库结构（D1）#

为保证机器人功能完整，需要创建以下表：

1
CREATE TABLE blocks (
2
  user_id TEXT PRIMARY KEY,
3
  is_blocked INTEGER
4
);
5

6
CREATE TABLE msg_map (
7
  admin_msg_id TEXT PRIMARY KEY,
8
  user_id TEXT
9
);
10

11
CREATE TABLE lastmsg (
12
  user_id TEXT PRIMARY KEY,
13
  ts INTEGER
14
);
15

16
CREATE TABLE fraud (
17
  user_id TEXT PRIMARY KEY
18
);
19

20
CREATE TABLE verify (
21
  user_id TEXT PRIMARY KEY,
22
  question TEXT,
23
  answer INTEGER,
24
  passed INTEGER
25
);
26

27
CREATE TABLE user_first (
28
  user_id TEXT PRIMARY KEY
29
);

展开收起

🔢 首次验证系统（加减法 1～10）#

为了防止广告机器人、骚扰用户，系统会对第一次聊天的用户进行简单的数学验证：

✨ 验证示例#

1
为了防止骚扰，请先完成验证：
2

3
7 + 3 = ?
4

5
请直接回复数字答案。

答对后自动进入聊天流程；答错则重新生成题目。

🎯 核心功能说明#

1️⃣ 匿名聊天（Forward/Copy）#

用户发送消息 → 机器人自动转发给管理员
管理员「回复这条转发消息」→ 机器人将回复复制给用户

整个过程：

用户不会看到管理员的 UID
管理员同样看不到用户昵称（除资料卡）

实现完整“匿名双向通信”。

2️⃣ 用户资料卡（首次出现）#

管理员第一次收到用户消息时，自动生成用户信息卡：

管理员点按钮后 → 自动屏蔽

3️⃣ 屏蔽 / 解除屏蔽#

管理员可直接通过命令控制：

指令	说明
`/block`	屏蔽此用户
`/unblock`	解除屏蔽
`/checkblock`	查看用户是否被屏蔽

4️⃣ 诈骗检测（D1 fraud 表）#

只需点击按钮

或者

回复的是输入/block 也可以拉黑用户

5️⃣ 可控间隔的通知提醒系统#

为了避免管理员被刷屏，可设置提醒间隔（默认 1 小时）：

作用：

用户第一次联系 → 提醒
用户长时间没聊天，再次联系 → 再提醒一次
保证管理员不会被Spam

🛠 Worker 代码结构说明#

代码整体分为：

Webhook 接收器
Telegram API 封装
核心消息处理
加减法验证模块
管理员控制命令
D1 数据访问模块
首次资料卡发送模块（可扩展）

该架构清晰、可维护性高、支持未来扩展。

📚 使用教程#

1. 创建 Telegram Bot#

在 @BotFather 创建一个机器人，并获得：

Bot Token

2. 部署到 Cloudflare Workers#

1
// ================== 常量区 ==================
2

3
const START_MESSAGE = `
4
🤖 你好，欢迎使用 @guaguawa_bot 双向聊天机器人！
5
请通过此机器人发送您的消息与我联系，我会立即为您传达。
6
`;
7

8
const START_MESSAGE_ADMIN = `
9
🤖 <b>关于本机器人</b>
10

11
本机器人用于 <b>双向匿名聊天</b>，旨在提高用户的沟通体验，并防止骚扰。
12

13
📌 <b>功能介绍：</b>
14
- 匿名聊天：用户可以自由交流，管理员可管理消息流转。
15
- 防骚扰功能：管理员可使用 /block 指令屏蔽不良用户。
16
- 诈骗检测：自动检测是否属于诈骗用户，并提醒管理员。
17

18
📜 <b>可用命令：</b>
19
- /start 获取欢迎信息
20
- /block 屏蔽用户（管理员）
21
- /unblock 解除屏蔽（管理员）
22
- /checkblock 查询用户状态（管理员）
23

24
🔹 机器人由 <b>匿名聊天管理系统</b> 提供支持。
25
`;
26

27

28
// ================== Worker 入口（ESM 格式） ==================
29

30
export default {
31
  async fetch(request, env, ctx) {
32
    const url = new URL(request.url);
33

34
    if (url.pathname === "/endpoint") {
35
      return handleWebhook(request, env, ctx);
36
    }
37
    if (url.pathname === "/registerWebhook") {
38
      return registerWebhook(request, env);
39
    }
40
    if (url.pathname === "/unRegisterWebhook") {
41
      return unRegisterWebhook(request, env);
42
    }
43

44
    return new Response("OK");
45
  }
46
};
47

48

49
// ===================== Telegram API 封装 ========================
50

51
function apiUrl(methodName, params = null, env) {
52
  let query = params ? "?" + new URLSearchParams(params).toString() : "";
53
  return `https://api.telegram.org/bot${env.ENV_BOT_TOKEN}/${methodName}${query}`;
54
}
55

56
function requestTelegram(method, body, env, params = null) {
57
  return fetch(apiUrl(method, params, env), body).then(r => r.json());
58
}
59

60
const makeReq = (body) => ({
61
  method: "POST",
62
  headers: { "content-type": "application/json" },
63
  body: JSON.stringify(body)
64
});
65

66
const sendMessage = (msg, env) =>
67
  requestTelegram("sendMessage", makeReq(msg), env);
68

69
const forwardMessage = (msg, env) =>
70
  requestTelegram("forwardMessage", makeReq(msg), env);
71

72
const copyMessage = (msg, env) =>
73
  requestTelegram("copyMessage", makeReq(msg), env);
74

75

76
// ===================== Webhook ========================
77

78
async function handleWebhook(request, env, ctx) {
79
  if (request.headers.get("X-Telegram-Bot-Api-Secret-Token") !== env.ENV_BOT_SECRET) {
80
    return new Response("Unauthorized", { status: 403 });
81
  }
82

83
  const update = await request.json();
84
  ctx.waitUntil(onUpdate(update, env));
85
  return new Response("OK");
86
}
87

88

89
// ===================== Update Routing ========================
90

91
async function onUpdate(update, env) {
92
  if (update.message) {
93
    await onMessage(update.message, env);
94
  }
95
  if (update.callback_query) {
96
    await onCallback(update.callback_query, env);
97
  }
98
}
99

100

101
// ===================== D1 数据库封装 ========================
102

103
// 拉黑
104
async function getBlock(env, userId) {
105
  const row = await env.TG_BOT_DB.prepare("SELECT is_blocked FROM blocks WHERE user_id=?").bind(userId).first();
106
  return row ? row.is_blocked === 1 : false;
107
}
108

109
async function setBlock(env, userId, val) {
110
  await env.TG_BOT_DB.prepare("INSERT OR REPLACE INTO blocks (user_id, is_blocked) VALUES (?, ?)").bind(userId, val ? 1 : 0).run();
111
}
112

113
// 消息映射
114
async function getMsgMap(env, adminMsgId) {
115
  const row = await env.TG_BOT_DB.prepare("SELECT user_id FROM msg_map WHERE admin_msg_id=?").bind(adminMsgId).first();
116
  return row ? row.user_id : null;
117
}
118

119
async function setMsgMap(env, adminMsgId, userId) {
120
  await env.TG_BOT_DB.prepare("INSERT OR REPLACE INTO msg_map (admin_msg_id, user_id) VALUES (?, ?)").bind(adminMsgId, userId).run();
121
}
122

123
// 通知节流
124
async function getLastMsg(env, userId) {
125
  const row = await env.TG_BOT_DB.prepare("SELECT ts FROM lastmsg WHERE user_id=?").bind(userId).first();
126
  return row ? row.ts : null;
127
}
128

129
async function setLastMsg(env, userId, ts) {
130
  await env.TG_BOT_DB.prepare("INSERT OR REPLACE INTO lastmsg (user_id, ts) VALUES (?, ?)").bind(userId, ts).run();
131
}
132

133
// 诈骗
134
async function isFraud(env, userId) {
135
  const row = await env.TG_BOT_DB.prepare("SELECT user_id FROM fraud WHERE user_id=?").bind(userId).first();
136
  return !!row;
137
}
138

139

140
// ===================== 首次加减验证 ========================
141

142
function genVerifyQuestion() {
143
  let a = Math.floor(Math.random() * 10) + 1;
144
  let b = Math.floor(Math.random() * 10) + 1;
145

146
  if (Math.random() < 0.5) {
147
    return { question: `${a} + ${b} = ?`, answer: a + b };
148
  } else {
149
    if (a < b) [a, b] = [b, a];
150
    return { question: `${a} - ${b} = ?`, answer: a - b };
151
  }
152
}
153

154
async function getVerify(env, userId) {
155
  return await env.TG_BOT_DB.prepare("SELECT * FROM verify WHERE user_id=?").bind(userId).first();
156
}
157

158
async function setVerify(env, userId, question, answer) {
159
  await env.TG_BOT_DB.prepare("INSERT OR REPLACE INTO verify (user_id, question, answer, passed) VALUES (?, ?, ?, 0)").bind(userId, question, answer).run();
160
}
161

162
async function passVerify(env, userId) {
163
  await env.TG_BOT_DB.prepare("UPDATE verify SET passed=1 WHERE user_id=?").bind(userId).run();
164
}
165

166

167
// ===================== 消息主处理 ========================
168

169
async function onMessage(message, env) {
170
  const chatId = message.chat.id.toString();
171
  const ADMIN_UID = env.ENV_ADMIN_UID;
172

173
  // /start
174
  if (message.text === "/start") {
175
    return sendMessage({ chat_id: chatId, text: chatId === ADMIN_UID ? START_MESSAGE_ADMIN : START_MESSAGE, parse_mode: "HTML" }, env);
176
  }
177

178
  // -------- 管理员 --------
179
  if (chatId === ADMIN_UID) {
180
    return handleAdminMessage(message, env);
181
  }
182

183
  // -------- 用户 --------
184
  return handleGuestMessage(message, env);
185
}
186

187

188
// ===================== 管理员逻辑 ========================
189

190
async function handleAdminMessage(message, env) {
191
  const ADMIN_UID = env.ENV_ADMIN_UID;
192

193
  if (!message.reply_to_message?.message_id) {
194
    return sendMessage({ chat_id: ADMIN_UID, text: START_MESSAGE_ADMIN, parse_mode: "HTML" }, env);
195
  }
196

197
  const guestId = await getMsgMap(env, message.reply_to_message.message_id.toString());
198

199
  if (!guestId) {
200
    return sendMessage({ chat_id: ADMIN_UID, text: "无法找到用户映射" }, env);
201
  }
202

203
  // 管理员命令
204
  if (message.text === "/block") return handleBlock(message, env);
205
  if (message.text === "/unblock") return handleUnblock(message, env);
206
  if (message.text === "/checkblock") return handleCheckBlock(message, env);
207

208
  // 正常回复
209
  return copyMessage({
210
    chat_id: guestId,
211
    from_chat_id: ADMIN_UID,
212
    message_id: message.message_id
213
  }, env);
214
}
215

216

217
// ===================== 用户逻辑（含验证 + 资料卡） ========================
218

219
async function handleGuestMessage(message, env) {
220
  const chatId = message.chat.id.toString();
221
  const ADMIN_UID = env.ENV_ADMIN_UID;
222

223
  // --- 1. 验证 ---
224
  const verify = await getVerify(env, chatId);
225

226
  if (!verify) {
227
    const q = genVerifyQuestion();
228
    await setVerify(env, chatId, q.question, q.answer);
229

230
    return sendMessage({
231
      chat_id: chatId,
232
      text: `为了防止骚扰，请先完成验证：\n\n<b>${q.question}</b>`,
233
      parse_mode: "HTML"
234
    }, env);
235
  }
236

237
  if (verify.passed !== 1) {
238
    const ans = parseInt(message.text);
239

240
    if (ans === verify.answer) {
241
      await passVerify(env, chatId);
242

243
      return sendMessage({
244
        chat_id: chatId,
245
        text: "验证通过！你现在可以给管理员发送消息了 🎉"
246
      }, env);
247
    }
248

249
    const q = genVerifyQuestion();
250
    await setVerify(env, chatId, q.question, q.answer);
251

252
    return sendMessage({
253
      chat_id: chatId,
254
      text: `❌ 错误，请重新验证：\n\n<b>${q.question}</b>`,
255
      parse_mode: "HTML"
256
    }, env);
257
  }
258

259
  // --- 2. 是否被屏蔽 ---
260
  if (await getBlock(env, chatId)) {
261
    return sendMessage({ chat_id: chatId, text: "🚫 你被拉黑了" }, env);
262
  }
263

264
  // --- 3. 首次与管理员建立联系 → 发送资料卡 ---
265
  const firstRow = await env.TG_BOT_DB.prepare("SELECT user_id FROM user_first WHERE user_id=?").bind(chatId).first();
266

267
  if (!firstRow) {
268
    await env.TG_BOT_DB.prepare("INSERT INTO user_first (user_id) VALUES (?)").bind(chatId).run();
269

270
    const fullname = (message.from.first_name || "") + (message.from.last_name ? " " + message.from.last_name : "");
271
    const username = message.from.username ? "@" + message.from.username : "无";
272

273
    const now = new Date();
274
    const timeDisplay = now.toLocaleString("zh-CN", { hour12: false });
275

276
    const userCard = `
277
<b>用户资料卡</b>
278
---
279
• 昵称名称: <b>${fullname}</b>
280
• 用户名: <b>${username}</b>
281
• ID: <code>${chatId}</code>
282
• 首次连接时间: <code>${timeDisplay}</code>
283
`;
284

285
    const blockKeyboard = {
286
      inline_keyboard: [
287
        [{ text: "🚫 屏蔽此人 (Block)", callback_data: `block:${chatId}` }]
288
      ]
289
    };
290

291
    await sendMessage({
292
      chat_id: ADMIN_UID,
293
      text: userCard,
294
      parse_mode: "HTML",
295
      reply_markup: blockKeyboard
296
    }, env);
297
  }
298

299
  // --- 4. 转发消息 ---
300
  const fw = await forwardMessage({
301
    chat_id: ADMIN_UID,
302
    from_chat_id: chatId,
303
    message_id: message.message_id
304
  }, env);
305

306
  if (fw.ok) {
307
    await setMsgMap(env, fw.result.message_id.toString(), chatId);
308
  }
309
}
310

311

312
// ===================== 回调按钮（屏蔽） ========================
313

314
async function onCallback(query, env) {
315
  const ADMIN_UID = env.ENV_ADMIN_UID;
316

317
  if (query.from.id.toString() !== ADMIN_UID) {
318
    return;
319
  }
320

321
  const data = query.data;
322

323
  if (data.startsWith("block:")) {
324
    const userId = data.split(":")[1];
325

326
    await setBlock(env, userId, true);
327

328
    await requestTelegram(
329
      "answerCallbackQuery",
330
      makeReq({ callback_query_id: query.id, text: "已拉黑该用户" }),
331
      env
332
    );
333

334
    await requestTelegram(
335
      "editMessageReplyMarkup",
336
      makeReq({
337
        chat_id: query.message.chat.id,
338
        message_id: query.message.message_id,
339
        reply_markup: {
340
          inline_keyboard: [[{ text: "✔ 已拉黑", callback_data: "noop" }]]
341
        }
342
      }),
343
      env
344
    );
345
  }
346
}
347

348

349
// ===================== 管理员命令 ========================
350

351
async function handleBlock(message, env) {
352
  const guest = await getMsgMap(env, message.reply_to_message.message_id.toString());
353

354
  await setBlock(env, guest, true);
355
  return sendMessage({ chat_id: env.ENV_ADMIN_UID, text: `UID:${guest} 已屏蔽` }, env);
356
}
357

358
async function handleUnblock(message, env) {
359
  const guest = await getMsgMap(env, message.reply_to_message.message_id.toString());
360

361
  await setBlock(env, guest, false);
362
  return sendMessage({ chat_id: env.ENV_ADMIN_UID, text: `UID:${guest} 已解除屏蔽` }, env);
363
}
364

365
async function handleCheckBlock(message, env) {
366
  const guest = await getMsgMap(env, message.reply_to_message.message_id.toString());
367
  const blocked = await getBlock(env, guest);
368

369
  return sendMessage({
370
    chat_id: env.ENV_ADMIN_UID,
371
    text: `UID:${guest} → ${blocked ? "已屏蔽" : "未屏蔽"}`
372
  }, env);
373
}
374

375

376
// ===================== Webhook 控制 ========================
377

378
async function registerWebhook(request, env) {
379
  const url = new URL(request.url);
380
  const webhookUrl = `${url.protocol}//${url.hostname}/endpoint`;
381

382
  const res = await fetch(apiUrl("setWebhook", { url: webhookUrl, secret_token: env.ENV_BOT_SECRET }, env)).then(r => r.json());
383
  return new Response(res.ok ? "OK" : JSON.stringify(res));
384
}
385

386
async function unRegisterWebhook(request, env) {
387
  const res = await fetch(apiUrl("setWebhook", { url: "" }, env)).then(r => r.json());
388
  return new Response(res.ok ? "OK" : JSON.stringify(res));
389
}

展开收起

然后把上面的代码全部复制到里面去.

3. 绑定 D1 数据库#

D1的key为_BOT_DB

4. 设置环境变量#

变量	说明
`ENV_BOT_TOKEN`	Telegram Bot Token
`ENV_ADMIN_UID`	管理员 UID
`ENV_BOT_SECRET`	Webhook secret（可随意生成）

从@BotFather获取token，并且可以发送/setjoingroups来禁止此Bot被添加到群组
从uuidgenerator获取一个随机uuid作为secret
从@username_to_id_bot获取你的用户id
配置worker的变量
- 增加一个ENV_BOT_TOKEN变量，数值为从步骤1中获得的token
- 增加一个ENV_BOT_SECRET变量，数值为从步骤2中获得的secret
- 增加一个ENV_ADMIN_UID变量，数值为从步骤3中获得的用户id

5. 注册 Webhook#

访问：

1
https://你的worker域名/registerWebhook

6. 测试#

测试Bot: @guaguawa_bot

Mac中磁盘没有正常推出的解决方案

Thu, 23 Oct 2025 00:00:00 GMT

由于mac电脑关机或者没有实现正常推出硬盘导致的磁盘没有正常推出。

解决办法：

1）打开终端，输入如下命令查看一下硬盘的信息，确定一下自己的磁盘是否可以显示：

diskutil list

在终端的最后一行显示了我硬盘的名字，因此/dev/disk2所在目录就是我的移动硬盘。

2）杀死对应进程

sudo fsck_hfs -fy /dev/disk2

3）挂载移动硬盘数据卷

sudo diskutil mount /dev/disk2

4）去磁盘工具可以看到外置里面自己的硬盘了，但是显示是灰色，我们等待一段时间就可以看到我们硬盘了

KMS系统激活工具

Tue, 19 Aug 2025 00:00:00 GMT

几乎完美的系统激活工具，功能丰富而强大

功能：#

1、基本的各种激活，从Windows XP到Windows 11 24H2（含Server）.
2、激活Microsoft Office 2010到2024，包括365和UWP版.
3、可配合搭建本地内网激活专用服务器.
4、更改任意Windows版本（如从家庭版切换为专业版）

系统激活方式有：#

1、数字许可证永久激活
2、KMS38离线激活
3、OEM激活（如惠普联想整机）
4、上古电话激活

更新日志：#

**v63.2.0 更新说明：
**1.增加对Windows评估版的支持（重置90天）。
2.修复智能激活误启动KMS服务器的bug。

文件: HEU_KMS_Activator_v63.2.0.exe
MD5: 8F331BCBF428291F36EA59467A4E080B
SHA1: 5DB1793734E2A7577614BCE7E07067AA9CD08F65
SHA256: 85D199B41482B4D0C341F817ADE60EDF789CCEDDC2845F4B1938C597D5F54300

**v63.1.0 更新说明：
**1.修复智能激活选项中单独勾选Office KMS选项执行失败的bug。

文件: HEU_KMS_Activator_v63.1.0.exe
MD5: 8C52CBADE34FEA1FB1B53135B97F4CB8
SHA1: 7E86EF8E396E6D4CBC961045B02EF0C1C70240D2
SHA256: FE4B65E02DA1A6BC38383C13D1010A94941C3E13668B6120D936D72941473D4A

**v63.0.0 更新说明：
**1.优化了激活后提示信息过长的问题。
2.修复了OHook创建符号链接因为权限导致失败的问题。
3.修复了某些情况下软件闪退问题。
4.新增TForge StaticCID激活方式(需联网)，基于开源项目https://github.com/massgravel/Microsoft-Activation-Scripts。
5.新增静默参数/wzc /ozc /wsc /osc 使用说明使用/?查看。
6.新增在线获取CID的功能，基于开源项目https://github.com/dadorner-msft/activationws。

文件: HEU_KMS_Activator_v63.0.0.exe
MD5: D6C8EC6CF38176865BFA1F1CF4FB467D
SHA1: 3A5AF309E88C23CB4396E316A20BF654CAB07E37
SHA256: 954A91CC3D0CB045D8E44A4DAC7C349CA330CBD84F57853785F9754BBF4772F4

**v62.0.0 更新说明：
**1.OHook新增对OSPP的支持（支持Window XP及以上系统的所有Office版本）（OSPP方法基于开源程序MAS3.2）
2.调整经典界面布局。
3.修复了检测Office永久激活状态错误的bug。
4.修复了一些已知问题。

文件: HEU_KMS_Activator_v62.0.0.exe
MD5: 3F6573A37D373123D2014A09E4FDB509
SHA1: 9F28201A03A5CA363936720C780D466292E78934
SHA256: 930A816F6B78A667981B282E46DB7D0CDCE1AF7D8E20C3910DAF997031F32987

分享一个微信小程序原型生成的Prompt

Mon, 21 Jul 2025 00:00:00 GMT

最近在用 ClaudeCode 尝试开发一个微信小程序，分享一下目前生成产品原型 UI 的 Prompt，佬们可以尝试一下，如果有什么反馈和优化的意见可以讨论一下。

微信小程序高保真 UI 原型构建#

请帮我构建微信小程序高保真原型：$ARGUMENTS

按照以下三个阶段进行：产品探讨→设计确定→原型制作。

第一阶段：产品概念探讨（3-4 轮深度对话）#

探讨以下维度：

核心价值：解决什么核心痛点
目标用户：用户画像和使用场景
必备功能：3-5 个核心功能模块及优先级
用户路径：完整使用流程
竞品分析：
- 搜索分析相关竞品
- 总结优缺点
- 确定差异化策略

输出：

产品定位说明（200 字以内）
核心功能列表（按优先级）
竞品分析总结

第二阶段：设计风格确定#

基于产品定位，提供 2-3 个设计风格方案供我选择：

设计方案示例格式：

方案名称：如 “清新简约风”
适用理由：为什么适合您的产品
视觉特征：用通俗语言描述视觉感受
色彩建议：主色、辅助色的建议和使用场景
导航方案：如何处理顶部区域与胶囊按钮的关系
参考案例：类似风格的知名产品

输出：确定的设计方向和关键色彩

文档输出#

生成设计指导文档：

文件：.claude/mvp/design-guide.md

内容：

基于前两阶段讨论结果
简洁清晰，作为设计唯一参考
包含所有关键设计决策

更新原则：

任何调整先更新文档
文档始终是最新设计依据

第三阶段：高保真原型制作#

重要：严格遵循 design-guide.md 规范。

技术规范#

框架：HTML + Tailwind CSS
设备尺寸：393×852px（iPhone 16 Pro）
内容区域：393×808px

固定页面模板#

每个功能页面都必须基于以下模板，不要修改状态栏和胶囊按钮部分：

1
<!DOCTYPE html>
2
<html>
3
<head>
4
    <meta charset="UTF-8">
5
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
6
    <title>微信小程序模板</title>
7
    <script src="https://cdn.tailwindcss.com"></script>
8
    <style>
9
        /* 确保容器尺寸固定 */
10
        .wechat-container {
11
            width: 393px;
12
            height: 852px;
13
            position: relative;
14
            overflow: hidden;
15
        }
16

17
        /* 胶囊按钮样式 */
18
        .capsule-button {
19
            background: rgba(0, 0, 0, 0.1);
20
            backdrop-filter: blur(20px);
21
            border: 1px solid rgba(255, 255, 255, 0.2);
22
        }
23

24
        /* 分割线样式 */
25
        .capsule-divider {
26
            background: rgba(255, 255, 255, 0.3);
27
        }
28

29
        /* 内容区域样式 */
30
        .content-area {
31
            height: 808px;
32
            overflow-y: auto;
33
            background: white;
34
        }
35
    </style>
36
</head>
37
<body class="bg-gray-100 flex items-center justify-center min-h-screen">
38
    <div class="wechat-container mx-auto bg-white relative">
39
        <!-- 状态栏 -->
40
        <div class="h-11 bg-white flex items-center justify-between px-4 text-black relative z-10">
41
            <!-- 左侧时间 -->
42
            <div class="text-sm font-medium">1:41</div>
43

44
            <!-- 右侧状态图标 -->
45
            <div class="flex items-center gap-1">
46
                <!-- 5G网络图标 -->
47
                <div class="text-xs font-medium">5G</div>
48
                <!-- 信号强度图标 -->
49
                <div class="flex items-end gap-0.5 ml-1">
50
                    <div class="w-1 h-1 bg-black rounded-full"></div>
51
                    <div class="w-1 h-1.5 bg-black rounded-full"></div>
52
                    <div class="w-1 h-2 bg-black rounded-full"></div>
53
                    <div class="w-1 h-2.5 bg-black rounded-full"></div>
54
                </div>
55
                <!-- 电池图标 -->
56
                <div class="ml-1 flex items-center">
57
                    <div class="w-6 h-3 border border-black rounded-sm relative">
58
                        <div class="absolute inset-0.5 bg-black rounded-sm" style="width: 74%;"></div>
59
                    </div>
60
                    <div class="w-0.5 h-1.5 bg-black rounded-r-sm ml-0.5"></div>
61
                    <span class="text-xs ml-1">37</span>
62
                </div>
63
            </div>
64
        </div>
65

66
        <!-- 内容区域 -->
67
        <div class="relative content-area">
68
            <!-- 微信胶囊按钮 -->
69
            <div class="absolute right-3 top-1 flex capsule-button rounded-full h-7 w-18 z-20">
70
                <!-- 三个点按钮 -->
71
                <div class="w-9 h-7 flex items-center justify-center">
72
                    <div class="flex gap-0.5">
73
                        <div class="w-1 h-1 bg-black rounded-full"></div>
74
                        <div class="w-1 h-1 bg-black rounded-full"></div>
75
                        <div class="w-1 h-1 bg-black rounded-full"></div>
76
                    </div>
77
                </div>
78
                <!-- 分割线 -->
79
                <div class="w-px h-4 capsule-divider self-center"></div>
80
                <!-- 关闭按钮 -->
81
                <div class="w-9 h-7 flex items-center justify-center">
82
                    <div class="w-3.5 h-3.5 border border-black rounded-full"></div>
83
                </div>
84
            </div>
85

86
            <!--
87
            页面内容区域 - 在这里添加具体的页面内容
88
            使用纯 HTML + TailwindCSS 实现
89
            注意：内容区域高度为 808px，支持滚动
90
            -->
91
        </div>
92
    </div>
93
</body>
94
</html>

展开收起

胶囊按钮适配#

微信胶囊按钮不可移除，设计时：

空间处理：预留安全距离避免遮挡
视觉平衡：选择合适的适配策略
导航设计：考虑与胶囊按钮的协调
交互布局：重要操作避开右上角

内容要求#

图片素材：使用 Unsplash/Pexels 真实图片
文案内容：真实中文文案
数据展示：3-5 条示例数据

文件输出#

1. 生成多个独立 HTML 文件：

1
home.html       // 首页
2
[feature1].html // 核心功能页（根据实际功能命名）
3
[feature2].html // 核心功能页
4
profile.html    // 个人中心（如需要）

2. 生成 index.html 汇总展示页：

创建一个 index.html 文件，用于集中展示所有原型页面，便于整体预览和评审。

index.html 模板：

1
<!DOCTYPE html>
2
<html lang="zh-CN">
3
<head>
4
    <meta charset="UTF-8">
5
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
6
    <title>[产品名称] - 高保真原型预览</title>
7
    <script src="https://cdn.tailwindcss.com"></script>
8
    <style>
9
        iframe {
10
            border: 1px solid #e5e7eb;
11
            border-radius: 12px;
12
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
13
        }
14
        .page-container {
15
            transition: transform 0.2s;
16
        }
17
        .page-container:hover {
18
            transform: scale(1.02);
19
        }
20
    </style>
21
</head>
22
<body class="bg-gray-50 p-8">
23
    <div class="max-w-7xl mx-auto">
24
        <div class="text-center mb-8">
25
            <h1 class="text-3xl font-bold text-gray-900 mb-2">[产品名称]</h1>
26
            <p class="text-gray-600">微信小程序高保真原型预览</p>
27
            <div class="mt-4 text-sm text-gray-500">
28
                <p>设备尺寸：393×852px (iPhone 16 Pro)</p>
29
                <p>设计风格：[选定的设计风格]</p>
30
            </div>
31
        </div>
32

33
        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8">
34
            <!-- 根据实际生成的页面添加iframe容器 -->
35
            <!-- 每个页面按照以下格式 -->
36
            <div class="bg-white rounded-lg p-4 page-container">
37
                <h3 class="text-lg font-semibold mb-4 text-center">[页面名称]</h3>
38
                <iframe src="[filename].html" width="393" height="852" class="mx-auto"></iframe>
39
            </div>
40
        </div>
41

42
        <!-- 设计说明 -->
43
        <div class="mt-12 bg-white rounded-lg p-6">
44
            <h2 class="text-xl font-bold mb-4">设计说明</h2>
45
            <div class="space-y-2 text-gray-600">
46
                <p><strong>产品定位：</strong>[从design-guide.md提取]</p>
47
                <p><strong>核心功能：</strong>[从design-guide.md提取]</p>
48
                <p><strong>设计特色：</strong>[从design-guide.md提取]</p>
49
            </div>
50
        </div>
51
    </div>
52
</body>
53
</html>

展开收起

index.html 要求：

使用响应式网格布局，自动适应不同屏幕尺寸
每个 iframe 展示一个页面，保持 393×852px 原始尺寸
页面标题清晰标注每个页面的功能
底部包含设计说明，提取 design-guide.md 的关键信息
鼠标悬停时有轻微放大效果，提升交互体验

注意事项：

index.html 应该最后生成，确保包含所有已创建的页面
iframe 的 src 路径应与实际文件名完全匹配
页面排序按功能重要性：首页 → 核心功能页 → 辅助页面
确保所有 HTML 文件在同一目录下，便于 iframe 引用

输出要求#

首先生成 / 更新 design-guide.md
基于文档依次生成 5-8 个核心页面 HTML 文件
最后生成 index.html 汇总展示页
确保 index.html 中包含所有已生成的页面

输出顺序：

design-guide.md → 各功能页面 HTML → index.html

白嫖 .com .net .jp .shop .xyz 等顶级域名

Sat, 19 Jul 2025 00:00:00 GMT

1.购买地址
日本IP 点开活动地址之后搜索你想要的域名注意全程日本IP
身份生成：https://www.meiguodizhi.com/jp-address

2.付款选择その他・決めていない
输入你的卡信息卡需要支持3ds

3.看到您的申请已被接受。来这里 https://navi.onamae.com/domain/setting/ns?btn_id=newnavi_top__newnavi_domainlist_dns 登录你的账户，账号是右上角的数字。在邮箱里也可以看到

4.登陆后有你注册的域名就可以设置的名称服务器。托管cf即可。

教程补充
在這裡可以取消自動續約： https://navi.onamae.com/domain/setting/autorenew
在這裡可以刪除綁定的信用卡： https://navi.onamae.com/payment/detail/domain

Mysql 知识整理

Wed, 16 Jul 2025 00:00:00 GMT

数据库三大范式#

第一范式：每个列都不可以再拆分。

第二范式：在第一范式的基础上，非主键列完全依赖于主键，而不能是依赖于主键的一部分。

第三范式：在第二范式的基础上，非主键列只依赖于主键，不依赖于其他非主键。

SQL语言共分为四大类#

数据查询语言（DQL）：用于从数据库中查询数据。常用的 DQL 命令是 select，它允许用户指定要从数据库中检索哪些数据。通过 select 语句，你可以选择特定的列、过滤数据、排序结果等。
数据定义语言（DDL）：用于定义和管理数据库中的结构。DDL 命令用于创建、修改和删除数据库、表、索引、视图等对象。常见的 DDL 命令包括 create、alter 和 drop。
数据操纵语言（DML）：用于操作数据库中的数据。DML 命令允许你插入、更新和删除数据。常用的 DML 命令包括 insert、update 和 delete。
数据控制语言（DCL）：用于控制数据库用户的权限和访问级别。DCL 命令允许管理员授权或撤销用户对数据库对象的访问权限。常见的 DCL 命令包括 grant 和 revoke。

类别	英文缩写	中文含义	作用关键词	常见语句
DDL	Data Definition	数据定义	定义结构	`CREATEALTERDROP`
DML	Data Manipulation	数据操作	增删改数据	`INSERTUPDATEDELETE`
DQL	Data Query	数据查询	查找数据	`SELECT`
DCL	Data Control	权限控制	分配/撤销权限	`GRANTREVOKE`

索引#

1
MySQL 索引
2
 ├── 功能角度（逻辑类型）
3
 │   ├── 主键索引（Primary Key）
4
 │   ├── 唯一索引（Unique Index）
5
 │   ├── 普通索引（Normal Index）
6
 │   ├── 联合索引（Composite Index）
7
 │   ├── 全文索引（Fulltext Index）
8
 │   └── 空间索引（Spatial Index）
9
 │
10
 └── 存储结构角度（物理结构）
11
     ├── 聚簇索引（Clustered Index）= 主键索引
12
     ├── 二级索引（Secondary Index）= 辅助索引

创建索引的原则#

原则总结	是否推荐建索引？
查询条件字段	✅
区分度高的字段	✅
联合索引按顺序使用	✅
尽量实现覆盖查询	✅
控制索引数量（别太多）	⚠️ 慎重
频繁更新字段	❌ 尽量避免
长文本字段避免建索引	❌ 避免
函数、运算字段索引失效	❌ 避免
重复率高字段不推荐索引	❌ 避免
外键字段明确加索引	✅

MySQL为什么使用B+树作为索引的数据结构#

B+Tree vs B Tree:

存储相同数据量级别的情况下，B+Tree树高比 B Tree低,磁盘IO次数更少。
B+Tree叶子节点用双向链表串起来,适合范围查询，BTree无法做到这点

B+Tree vs二叉树:

随着数据量的增加，二叉树的树高会越来越高，磁盘IO次数也会更多,B+Tree在千万级别的数据量下，高度依然维持在34层左右，也就是说一次数据查询操作只需要做34次的磁盘O操作就能查询到目标数据。

B+Tree vs Hash:

虽然Hash的等值查询效率很高，但是无法做范围查询

索引失效有哪些？#

场景/错误写法	原因	是否失效
`WHERE UPPER(name) = 'XX'`	函数操作	✅
`WHERE age != 30`	使用不等于	✅
`WHERE name LIKE '%三'`	通配符在前	✅
`WHERE name = '张三' OR age = 20`	OR 条件中部分无索引	✅
`WHERE age = 20` 联合索引跳过最左字段	最左前缀原则不符合	✅
`WHERE phone = 1234567890`（字段是字符串）	类型不一致，触发隐式转换	✅
小表查索引	优化器判断索引没必要	✅（可能）

什么时候需要 / 不需要创建索引？#

是否建索引？	场景 / 条件
✅ 需要	频繁 `WHERE` 查询、`JOIN`、`排序`、`分组`、`唯一字段`
✅ 需要	大表中的范围查询字段、外键字段、联合索引中最左字段
❌ 不需要	数据重复度高、字段频繁更新、字段很少被查询
❌ 不需要	极小的表、临时表、字段本身参与计算或函数

读多写少 → 建索引优先（查询系统）
写多读少 → 谨慎建索引（日志、消息系统）
建索引之后要配合 **EXPLAIN** 分析是否命中

有什么优化索引的方法？#

前缀索引优化；
覆盖索引优化；
主键索引最好是自增的；
防止索引失效

项目	前缀索引	联合索引	覆盖索引
是不是一种索引类型	✅ 是	✅ 是	❌ 否，是一种查询优化结果
是否在建索引时定义	✅ 是	✅ 是	❌ 否，由查询命中索引字段决定
适用字段	仅限字符串类型（CHAR/VARCHAR等）	任意字段类型	查询中字段全部包含在索引中即可
关键作用	节省空间，适合长字段	多字段组合索引，支持多条件查询	避免回表，提升查询效率
是否可以唯一	✅ 可以（但容易冲突）	✅ 可以（可建联合唯一索引）	❌ 不属于索引类型
是否回表	✅ 可能（字段不完整）	✅ 可能（视查询字段而定）	❌ 不需要

EXPLAIN 常见字段汇总（重点关注这几个）#

`type`（连接类型）🌟最重要的性能指标之一#

type	含义	效率
`system`	表仅有一行（系统表）	极高
`const`	一次命中，结果恒定	✅ 极高
`eq_ref`	主键/唯一索引的等值查询	✅ 非常好
`ref`	非唯一索引的等值查询	✅ 好
`range`	范围查询，如 `BETWEEN`、`LIKE 'xx%'`	✅ 不错
`index`	全索引扫描（不回表）	⚠️ 中等
`ALL`	全表扫描	❌ 慢

`key`（使用的索引名称）#

显示 MySQL 实际使用的索引名称。

如果是 NULL → 没有使用索引 ❌
如果是索引名 → 说明命中索引 ✅

`rows`（扫描的行数）#

表示 MySQL 预估要读取的行数（越少越好）：

小于 100：查询很快
上万以上：说明可能需要优化

✅ 注意：这里是估算值，并非真实执行统计。

`Extra`（额外信息，能看出是否回表）#

Extra 内容	含义说明
`Using index`	✅ 覆盖索引，无需回表，性能最佳
`Using index condition`	✅ 使用了索引条件下推（ICP）
`Using where`	有使用 WHERE 条件（不是坏事）
`Using temporary`	❌ 用了临时表（常见于复杂排序或分组）
`Using filesort`	❌ 用了文件排序，可能意味着索引未用于 `ORDER BY`

事务#

事务(ACID)有哪些特性？#

特性	说明（通俗理解）
A 原子性	要么都做，要么一个都不做（不可拆分）
C 一致性	数据操作前后都保持规则/约束一致
I 隔离性	多个事务之间互不干扰
D 持久性	提交成功后数据永不丢失

事务必须要遵守 4 个特性，分别如下：

原子性（Atomicity）：一个事务中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节，而且事务在执行过程中发生错误，会被回滚到事务开始前的状态。
一致性（Consistency）：是指事务操作前和操作后，数据满足完整性约束，数据库保持一致性状态。比如，用户 A 和用户 B 在银行分别有 800 元和 600 元，总共 1400 元，用户 A 给用户 B 不论如何转账，最后的结果是1400 元。
隔离性（Isolation）：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致，因为多个事务同时使用相同的数据时，不会相互干扰，每个事务都有一个完整的数据空间，对其他并发事务是隔离的。
持久性（Durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

InnoDB 引擎通过什么技术来保证事务的这四个特性的呢？#

持久性是通过 redo log （重做日志）来保证的；
原子性是通过 undo log（回滚日志）来保证的；
隔离性是通过 MVCC（多版本并发控制）或锁机制来保证的；
一致性则是通过持久性+原子性+隔离性来保证；

什么是脏读？幻读？不可重复读？#

异常类型	描述
脏读	读到了别的事务未提交的数据
不可重复读	同一事务两次读到的结果不同（被别人修改了）
幻读	同一事务两次查询，新增或删除了行数

脏读(Drity Read)：一个事务读取另一个事务未提交的数据
不可重复读(Non-repeatable read)：一个事务对同一数据进行读取，前后数据内容不一致
幻读(Phantom Read)：一个事务内进行了多次读取，数据总量不一致。

事务的隔离级别有哪些？#

隔离级别	脏读	不可重复读	幻读
未提交读（READ-UNCOMMITTED）	√	√	√
已提交读（READ-COMMITTED）	×	√	√
可重复读（REPEATABLE-READ）	×	×	√
可串行（SERIALIZABLE）	×	×	×

读未提交（read uncommitted），指一个事务还没提交时，它做的变更就能被其他事务看到；
读提交（read committed），指一个事务提交之后，它做的变更才能被其他事务看到；
可重复读（repeatable read），指一个事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，MySQL InnoDB 引擎的默认隔离级别；
串行化（serializable ）；会对记录加上读写锁，在多个事务对这条记录进行读写操作时，如果发生了读写冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行；

按隔离水平高低排序如下：

MVCC#

它的实现原理主要是版本链，undo日志，Read View来实现的。即多版本并发控制，主要是为了提高数据库的并发性能。

版本链#

除了我们数据库每行的数据，还有几个隐藏字段，分别是事务ID（trx_id），一个是回滚指针(roll_pointer)。

trx_id ：每次一个事务对某条聚簇索引记录改动时，都会把自己的事务id重新写到 trx_id 隐藏列。

roll_pointer ：每次对某条聚簇索引记录进行改动时，都会把旧版本记录写入到 undo日志中，roll_pointer这个隐藏列是一个地址指针，通过它可以找到该聚簇索引记录历史修改信息。

undo日志#

Undo log 主要用于记录数据被修改之前的日志，在表信息修改之前先会把数据拷贝到undo log里。当事务进行回滚时可以通过undo log 里的日志进行数据还原。

undo log主要分为两种：

insert undo log：顾名思义，此代表执行insert语句时产生的undo log, 它只在事务回滚时需要，因为这种log只是对本事务可见，其他事务不可见，所以当事务提交后，这种类型的undo log就会被系统直接删除回收（也就是该undo log占用的undo页面链表被释放）。

update undo log（主要）：事务在进行update或者delete时产生的undo log; 不仅在事务回滚时需要，在快照读时也需要（也就是MVCC），所以不能在事务提交后马上删除，只在提交后放入undo log的链表，等待purge线程进行最后的删除。

Read View读视图#

什么是Read View？#

Read View 是当前事务在执行“快照读”时生成的一份“可见数据版本清单”，用于判断当前能“看见哪些事务提交的数据”。

通俗地说：

Read View 就像是当前事务“拍下的一张快照”，它决定了你在事务中看到的“历史数据版本”。

元素	说明
`m_ids`	当前系统中活跃事务的 ID 列表（未提交）
`min_trx_id`	活跃事务中最小的事务 ID，用于加速判断
`max_trx_id`	当前系统中尚未分配的下一个事务 ID（即分配到的最大事务 ID + 1）
`creator_trx_id`	当前事务自己的 ID，用于标识“自己是否能看到自己”

creator_trx_id ：指创建该 Read View 的事务的事务 id。

m_ids ：指创建该 Read View 时数据库中所有活跃事务的事务 id 列表，这是一个列表，活跃事务则代表是已启动但未提交的事务。

min_trx_id ：指创建 Read View 时数据库中活跃事务中最小的事务 id，也就是 m_ids 中的最小值。

max_trx_id ：这里并不是m_ids中的最大值，而是创建 Read View 时当前数据中应该给下一个事务的id值，也就是全局事务中最大的事务id值+ 1。

在可重复读隔离级别下，Read View是在事务开始（begin）之后且执行第一条sql时创建，创建Read View的同时也就生成了一个新的事务id（直到commit结束），事务会依赖该 Read View保证查询结果保持不变直到该事务结束。

Read View 的判断规则（事务可见性判断）#

条件	是否可见	原因说明
`trx_id < min_trx_id`	✅ 可见	已经提交了，早于其他活跃事务
`trx_id = creator_trx_id`	✅ 可见	自己修改的当然能看到
`trx_id > max_trx_id`	❌ 不可见	是后面新开的事务，还未开始 → 不可见
`trx_id ∈ [min_trx_id, max_trx_id) 且 trx_id ∈ m_ids`	❌ 不可见	活跃事务依然活跃着（还没提交事务）
`trx_id ∈ [min_trx_id, max_trx_id) 且 trx_id ∉ m_ids`	✅ 可见	事务虽启动时已存在，但已提交，可见

一个事务去访问记录的时候，除了自己的更新记录总是可见之外，还有这几种情况：

如果记录的 trx_id 值小于 Read View 中的 min_trx_id 值，表示这个版本的记录是在创建 Read View 前已经提交的事务生成的，所以该版本的记录对当前事务可见。
如果记录的 trx_id 值等于当前事务id,就是自己的事务自己处理,所以总是可见
如果记录的 trx_id 值大于 Read View 中的 max_trx_id 值，表示这个版本的记录是在创建 Read View 后才启动的事务生成的，所以该版本的记录对当前事务不可见。
如果记录的 trx_id 值在 Read View 的 min_trx_id 和 max_trx_id 之间，需要判断 trx_id 是否在m_ids列表中：
如果记录的 trx_id 在 m_ids 列表中，表示生成该版本记录的活跃事务依然活跃着（还没提交事务），所以该版本的记录对当前事务不可见。
如果记录的 trx_id 不在 m_ids列表中，表示生成该版本记录的活跃事务已经被提交，所以该版本的记录对当前事务可见。

可重复读(RR)隔离级别是启动事务时生成一个 Read View，然后整个事务期间都在用这个 Read View

读提交(RC)隔离级别是在每次读取数据时，都会生成一个新的 Read View。

Read View 何时生成？#

读方式	是否创建 Read View	是否加锁	说明
`SELECT * FROM table`	✅ 是	❌ 否	快照读，用 Read View 构建数据版本
`SELECT ... FOR UPDATE`	❌ 否	✅ 是	当前读，直接加锁
`UPDATE` / `DELETE`	❌ 否	✅ 是	当前读

锁#

MySQL有那些锁?#

1
MySQL 锁
2
├── 全局锁（Global Lock）
3
│   └── FTWRL（Flush Tables with Read Lock）
4
│       ├─ 锁住整个实例，所有库所有表 → 只读维护操作
5
│       └─ 常用于备份/主从复制初始化
6
│
7
├── 表级锁（Table Lock）
8
│   ├── 表锁（Table Lock）              -- `LOCK TABLES`
9
│   ├── 元数据锁（Meta Lock）           -- 执行 DDL 时自动加（如 `ALTER TABLE`）
10
│   ├── 意向锁（Intention Lock）        -- 行锁前提 → 意向共享(IS) / 意向排它(IX)
11
│   └── AUTO-INC 锁（自增锁）           -- 旧版使用表级锁，8.0 后为轻量级互斥锁
12
│
13
└── 行级锁（Row Lock） ← InnoDB 专属
14
    ├── Record Lock（记录锁）
15
    │   └─ 锁住某一具体数据行，精确控制并发
16
    ├── Gap Lock（间隙锁）
17
    │   └─ 锁住“记录之间的空隙”，防止插入 → 用于防止幻读
18
    └── Next-Key Lock（临键锁）
19
        └─ Record Lock + Gap Lock，锁住行 + 间隙，最常见（默认加锁方式）

展开收起

全局锁（Global Lock）#

▶ 类型：FTWRL（Flush Tables With Read Lock）

📌 特点：

会锁住整个 MySQL 实例：所有数据库、所有表
所有对数据的读写都将被阻塞（DML + DDL）
常用于逻辑备份（mysqldump），保证备份期间数据一致

✅ 示例：

1
FLUSH TABLES WITH READ LOCK;
2
-- 所有库所有表只读，其他事务无法写入

🔓 解锁：

1
UNLOCK TABLES;

表级锁（Table Lock）#

1. 表锁（Table Lock）#

📌 特点：

显式锁定整张表，读或写时阻塞其他用户
常用于 MyISAM 引擎（无行锁）

✅ 示例：

1
//表级别的共享锁，也就是读锁；
2
//允许当前会话读取被锁定的表，但阻止其他会话对这些表进行写操作。
3
lock tables t_student read;
4

5
//表级别的独占锁，也就是写锁；
6
//允许当前会话对表进行读写操作，但阻止其他会话对这些表进行任何操作（读或写）。
7
lock tables t_stuent write;

需要注意的是，表锁除了会限制别的线程的读写外，也会限制本线程接下来的读写操作。比如我在当前线程执行了select * from t_student; 我就不能执行update及其他语句,也不能执行其他表查询.

2. 元数据锁（Meta Data Lock, MDL）#

📌 特点：

自动加锁，用于防止 DDL / DML 冲突
执行 SELECT 时也会加共享 MDL 锁，防止别人同时改表结构

✅ 示例：

1
-- 会话 A
2
SELECT * FROM user;
3

4
-- 会话 B
5
ALTER TABLE user ADD COLUMN email VARCHAR(100);
6
-- ❌ 阻塞！直到 A 释放锁

3. 意向锁（Intention Lock）#

📌 特点：

InnoDB 自动加的表级锁，不需要显式处理
用于表示“即将”对某一行加锁
有两种：
IS：意向共享锁（用于 SELECT … LOCK IN SHARE MODE）
IX：意向排它锁（用于 SELECT … FOR UPDATE、UPDATE 等）

✅ 示例：

1
-- 先在表上加上意向共享锁，然后对读取的记录加共享锁
2
select ... lock in share mode;
3

4
-- 你执行 FOR UPDATE 时，InnoDB 自动加 IX 意向锁
5
SELECT * FROM user WHERE id=1 FOR UPDATE;

执行插入、更新、删除操作，需要先对表加上「意向独占锁」，然后对该记录加独占锁。而普通的 select 是不会加行级锁的，普通的 select 语句是利用 MVCC 实现一致性读，是无锁的。

4. AUTO-INC 锁（自增锁）#

📌 特点：

控制自增列的生成
MySQL 5.x 是表级锁，多个事务串行插入
MySQL 8.0 优化为轻量级互斥锁，并发更高效

✅ 示例：

1
INSERT INTO order (user_id, product_id) VALUES (1, 100);
2
-- 自动生成主键 id，需要加 AUTO-INC 锁来顺序保证

行级锁（Row Lock）（InnoDB 专属）#

1. Record Lock（记录锁）#

📌 特点：

精确锁住某一行
用于排它性访问（FOR UPDATE、UPDATE）

✅ 示例：

1
SELECT * FROM user WHERE id = 1 FOR UPDATE;
2
-- 精确加锁，仅锁住 id=1 那一行

2. Gap Lock（间隙锁）#

📌 特点：

锁住“某两个记录之间的间隙”，阻止插入操作
解决幻读问题（比如防止插入张三）

✅ 示例：

1
SELECT * FROM user WHERE age > 30 FOR UPDATE;
2
-- age=40 存在，那么 (30, 40) 的间隙被锁住，不能插入 age=35 的行

3. Next-Key Lock（临键锁）#

📌 特点：

InnoDB 默认使用的锁类型
等于 Record Lock + Gap Lock
能锁住已有行及其前间隙，全面防止幻读

✅ 示例：

1
UPDATE user SET age=age+1 WHERE age BETWEEN 30 AND 40;
2
-- 会锁住 30 到 40 范围内的所有记录 + 相关间隙（Next-Key Lock）

总结表格（核心对照）#

类别	锁类型	场景	阻塞其他事务	是否防幻读
全局锁	FTWRL	备份、主从	✅ 是	✅ 是
表级锁	表锁	`LOCK TABLES`	✅ 是	❌ 否
表级锁	元数据锁	`ALTER TABLE`, `SELECT`	✅ 是	❌ 否
表级锁	意向锁	自动加，用于协同行锁	❌ 否	❌ 否
表级锁	AUTO-INC 锁	插入自增主键时	部分情况会	❌ 否
行级锁	Record Lock	精确主键查询 + `FOR UPDATE`	✅ 是	❌ 否
行级锁	Gap Lock	范围查询	✅ 是	✅ 是
行级锁	Next-Key Lock	范围更新/查询 + 防幻读	✅ 是	✅ 是

按锁的粒度划分：#

锁粒度	说明	引擎
表级锁	锁定整张表，开销小、并发差	MyISAM、InnoDB（如 `LOCK TABLES`）
行级锁	锁定一行记录，开销大、并发高	✅ InnoDB
页级锁	锁定一页（多个记录），介于表和行之间	BDB（较少使用）

按锁的类型划分：#

锁类型	说明	示例语句
共享锁（S锁）	允许多个事务并发读取，但不能写入	`SELECT ... LOCK IN SHARE MODE`
排它锁（X锁）	只允许一个事务读写，其他事务被阻塞	`SELECT ... FOR UPDATE`、`UPDATE`
意向锁	事务声明自己将对某行加锁的意图	自动加，用户不可见

按加锁方式划分：#

加锁方式	说明	示例
显式加锁	手动加锁	`LOCK TABLE`, `FOR UPDATE`
隐式加锁	InnoDB 自动加锁	执行 `UPDATE` / `DELETE` 时自动

各类锁的使用/触发举例#

SQL 操作	加锁方式	涉及锁类型
`LOCK TABLE users READ`	显式表锁	表级锁
`SELECT * FROM users`	快照读（无锁）	使用 MVCC
`SELECT * FROM users FOR UPDATE`	当前读（加锁）	行锁 / Gap Lock / Next-Key Lock
`UPDATE users SET name='a' WHERE id=1`	当前读（加锁）	行锁 / Next-Key Lock
`ALTER TABLE`	系统自动加锁	元数据锁
`INSERT INTO auto_table VALUES (...)`	自动	自增锁（AUTO-INC 锁）

特别注意的“锁误区”：#

易混点	正确解释
“SELECT 会不会加锁？”	普通 `SELECT` 是快照读 → 不加锁（MVCC）
“意向锁是你手动加的吗？”	❌ 不是，InnoDB 自动加，用于辅助判断是否能加行锁
“Gap Lock 也会锁住已有记录吗？”	❌ 不会，Gap Lock 只锁间隙，不锁记录本身
“Next-Key Lock 是什么意思？”	记录锁 + 间隙锁一起加，防止幻读的默认策略
“AUTO-INC 锁会阻塞插入吗？”	✅ 会，在老版本中（表级锁），8.0 起是轻量级

隔离级别与锁的关系#

在未提交度级别下，读取数据不需要加共享锁，这样就不会跟被修改的数据上的排他锁冲突

在已提交度级别下，读操作需要加共享锁，但是在语句执行完以后释放共享锁；

在可重复度级别下，读操作需要加共享锁，但是在事务提交之前并不释放共享锁，也就是必须等待事务执行完毕以后才释放共享锁。

可串行化是限制性最强的隔离级别，因为该级别锁定整个范围的键，并一直持有锁，直到事务完成。

什么是死锁？怎么解决？#

死锁是指两个或多个事务在同一资源上相互占用，并请求锁定对方的资源，从而导致恶性循环的现象。

常见的解决死锁的方法

如果不同程序会并发存取多个表，尽量约定以相同的顺序访问表，可以大大降低死锁机会。
在同一个事务中，尽可能做到一次锁定所需要的所有资源，减少死锁产生概率；
对于非常容易产生死锁的业务部分，可以尝试使用升级锁定颗粒度，通过表级锁定来减少死锁产生的概率；

如果业务处理不好可以用分布式事务锁或者使用乐观锁

日志#

undo log、redo log、binlog 有什么用？#

undo log（回滚日志）：是 Innodb 存储引擎层生成的日志，实现了事务中的原子性，主要用于事务回滚和 MVCC。

redo log（重做日志）：是 Innodb 存储引擎层生成的日志，实现了事务中的持久性，主要用于掉电等故障恢复；

binlog （归档日志）：是 Server 层生成的日志，主要用于数据备份和主从复制；

为什么需要 undo log？#

实现事务回滚，保障事务的原子性。事务处理过程中，如果出现了错误或者用户执行了 ROLLBACK 语句，MySQL 可以利用 undo log 中的历史数据将数据恢复到事务开始之前的状态。
实现 MVCC（多版本并发控制）关键因素之一。MVCC 是通过 ReadView + undo log 实现的。undo log 为每条记录保存多份历史数据，MySQL 在执行快照读（普通 select 语句）的时候，会根据事务的 Read View 里的信息，顺着 undo log 的版本链找到满足其可见性的记录。

主从复制是怎么实现？#

MySQL 的主从复制依赖于 binlog ，也就是记录 MySQL 上的所有变化并以二进制形式保存在磁盘上。复制的过程就是将 binlog 中的数据从主库传输到从库上。

这个过程一般是异步的，也就是主库上执行事务操作的线程不会等待复制 binlog 的线程同步完成。

MySQL 集群的主从复制过程梳理成 3 个阶段：

写入 Binlog：主库写 binlog 日志，提交事务，并更新本地存储数据。
同步 Binlog：把 binlog 复制到所有从库上，每个从库把 binlog 写到暂存日志中。
回放 Binlog：回放 binlog，并更新存储引擎中的数据。

为什么需要 Buffer Pool？#

当读取数据时，如果数据存在于 Buffer Pool 中，客户端就会直接读取 Buffer Pool 中的数据，否则再去磁盘中读取。
当修改数据时，如果数据存在于 Buffer Pool 中，那直接修改 Buffer Pool 中数据所在的页，然后将其页设置为脏页（该页的内存数据和磁盘上的数据已经不一致），为了减少磁盘I/O，不会立即将脏页写入磁盘，后续由后台线程选择一个合适的时机将脏页写入到磁盘。

Innodb引擎SQL执行的BufferPool缓存机制#

为什么需要 redo log ？#

redo log 是物理日志，记录了某个数据页做了什么修改，每当执行一个事务就会产生这样的一条或者多条物理日志。

在事务提交时，只要先将 redo log 持久化到磁盘即可，可以不需要等到将缓存在 Buffer Pool 里的脏页数据持久化到磁盘。

当系统崩溃时，虽然脏页数据没有持久化，但是 redo log 已经持久化，接着 MySQL 重启后，可以根据 redo log 的内容，将所有数据恢复到最新的状态。

redo log 和 undo log 区别在哪？#

这两种日志是属于 InnoDB 存储引擎的日志，它们的区别在于：

redo log 记录了此次事务「完成后」的数据状态，记录的是更新之后的值；
undo log 记录了此次事务「开始前」的数据状态，记录的是更新之前的值；

redo log 什么时候刷盘？#

主要有下面几个时机：

MySQL 正常关闭时；
当 redo log buffer 中记录的写入量大于 redo log buffer 内存空间的一半时，会触发落盘；
InnoDB 的后台线程每隔 1 秒，将 redo log buffer 持久化到磁盘。

为什么需要 binlog ？#

MySQL 在完成一条更新操作后，Server 层还会生成一条 binlog，等之后事务提交的时候，会将该事物执行过程中产生的所有 binlog 统一写入 binlog 文件。

binlog 文件是记录了所有数据库表结构变更和表数据修改的日志，不会记录查询类的操作，比如 SELECT 和 SHOW 操作。

binlog有几种录入格式？分别有什么区别？#

有三种格式，statement，row和mixed。

statement模式下，每一条会修改数据的sql都会记录在binlog中。不需要记录每一行的变化，减少了binlog日志量，节约了IO，提高性能。由于sql的执行是有上下文的，因此在保存的时候需要保存相关的信息，同时还有一些使用了函数之类的语句无法被记录复制。
row级别下，不记录sql语句上下文相关信息，仅保存哪条记录被修改。记录单元为每一行的改动，基本是可以全部记下来但是由于很多操作，会导致大量行的改动(比如alter table)，因此这种模式的文件保存的信息太多，日志量太大。
mixed，一种折中的方案，普通操作使用statement记录，当无法使用statement的时候使用row。

FinalShell专业版激活

Fri, 11 Jul 2025 00:00:00 GMT

源码#

1
from Crypto.Hash import keccak
2
from Crypto.Hash import MD5
3
def md5(msg):
4
    hash_obj = MD5.new(msg)
5
    return hash_obj.hexdigest()
6
def keccak384(msg):
7
    hash_obj = keccak.new(data=msg, digest_bits=384)
8
    return hash_obj.hexdigest()
9
if __name__ == '__main__':
10
    code = input('输入机器码: ')
11
    print('版本号 < 3.9.6 (旧版)')
12
    print('高级版:', md5(f'61305{code}8552'.encode())[8:24])
13
    print('专业版:', md5(f'2356{code}13593'.encode())[8:24])
14
    print('版本号 >= 3.9.6 (新版)')
15
    print('高级版:', keccak384(f'{code}hSf(78cvVlS5E'.encode())[12:28])
16
    print('专业版:', keccak384(f'{code}FF3Go(*Xvbb5s2'.encode())[12:28])
17
    print('版本号 (4.5)')
18
    print('高级版:', keccak384(f'{code}wcegS3gzA$'.encode())[12:28])
19
    print('专业版:', keccak384(f'{code}b(xxkHn%z);x'.encode())[12:28])
20
    print('版本号 (4.6)')
21
    print('高级版:', keccak384(f'{code}csSf5*xlkgYSX,y'.encode())[12:28])
22
    print('专业版:', keccak384(f'{code}Scfg*ZkvJZc,s,Y'.encode())[12:28])

展开收起

在线激活

在线激活#

输入机器码: 计算

// 引入哈希库 function md5(str) { const encoder = new TextEncoder(); const data = encoder.encode(str); return CryptoJS.MD5(CryptoJS.enc.Utf8.parse(str)).toString(); } function keccak384(str) { const encoder = new TextEncoder(); const data = encoder.encode(str); return CryptoJS.SHA3(str, { outputLength: 384 }).toString(); } document.getElementById(‘calculateButton’).addEventListener(‘click’, function () { const code = document.getElementById(‘machineCode’).value; const resultDiv = document.getElementById(‘result’); resultDiv.innerHTML = ”; resultDiv.innerHTML += ‘

版本号 < 3.9.6 (旧版)

’; resultDiv.innerHTML += `

高级版: {md5(\`61305{code}8552`).slice(8, 24)}

`; resultDiv.innerHTML += `

专业版: {md5(\`2356{code}13593`).slice(8, 24)}

`; resultDiv.innerHTML += ‘

版本号 >= 3.9.6 (新版)

’; resultDiv.innerHTML += `

高级版: {keccak384(\`{code}hSf(78cvVlS5E)`).slice(12, 28)}

`; resultDiv.innerHTML += `

专业版: {keccak384(\`{code}FF3Go(*Xvbb5s2)`).slice(12, 28)}

`; resultDiv.innerHTML += ‘

版本号 (4.5)

’; resultDiv.innerHTML += `

高级版: {keccak384(\`{code}wcegS3gzA\`).slice(12, 28)}\`; resultDiv.innerHTML += \`专业版: {keccak384(`codeb(xxkHn{code}b(xxkHn%z);x\`).slice(12, 28)}\`; resultDiv.innerHTML += '版本号 (4.6)'; resultDiv.innerHTML += \`高级版: codeb(xxkHn{keccak384(`{code}csSf5\*xlkgYSX,y\`).slice(12, 28)}\`; resultDiv.innerHTML += \`专业版: {keccak384(`${code}Scfg*ZkvJZc,s,Y`).slice(12, 28)}

`; });

Typora 1.10.8 学习版直装包

Tue, 01 Jul 2025 00:00:00 GMT

Typora 是一款轻量级、所见即所得（WYSIWYG）的 Markdown 编辑器。与传统 Markdown 编辑器不同，Typora 实时渲染 Markdown 语法，无需左右分屏，编辑与预览完全合一，极大提升了写作专注度与效率。

官网地址：https://typora.io

🌟 核心特性#

✅ 所见即所得#

不再需要左右两栏的“编辑+预览”界面
所见即所得，边写边看效果

✅ 完整支持 Markdown 语法#

标题、段落、加粗、斜体
有序/无序列表、任务列表
图片、链接、引用块
代码块（支持语法高亮）
表格、脚注、数学公式（LaTeX）

✅ 强大的导出能力#

支持导出为：PDF、HTML、Word (.docx)、OpenOffice (.odt)、EPUB 等
支持自定义样式（CSS），自由控制排版美感

✅ 插件与扩展性#

集成图床上传（如：PicGo）
自动保存与恢复
目录大纲导航
支持 Vim 模式

✅ 多平台支持#

macOS / Windows / Linux 均有原生客户端
可跨平台同步使用（搭配 Git、云盘等）

✍️ 基本使用方法#

🧱 常见 Markdown 语法示例#

功能	Markdown 语法	显示效果
标题	`## 二级标题`	二级标题
加粗	`加粗文字`	加粗文字
斜体	`斜体文字`	斜体文字
引用	`> 这是引用内容`	> 这是引用内容
无序列表	`- 项目1`	- 项目1
有序列表	`1. 项目1`	1. 项目1
插入图片	`!(url)`	插入图片
插入链接	`(链接)`	超链接
表格	`	列1
代码块	```java\n代码\n```	代码块（高亮）

🧩 WordPress + Typora 写作流程#

在 Typora 中撰写完整 Markdown 文档
使用图片链接或上传至图床（Typora 支持自定义图床）
导出为 HTML 或直接复制 Markdown
在 WordPress 中粘贴（建议配合插件如 “Markdown Block”）
调整排版样式并发布

👉 推荐使用插件：

WP Githuber MD：支持 Markdown 直接在 WordPress 编辑器中渲染
Markdown Block：支持区块编辑器中的 Markdown 格式粘贴

💡 高级技巧推荐#

使用 侧边栏大纲 快速跳转标题结构
自定义主题 CSS（Typora → 偏好设置 → 外观 → 打开主题文件夹）
启用 自动保存，防止数据丢失
与 Git 配合进行版本控制与协作写作
搭配语雀、Obsidian、Notion 做笔记整合

📦 安装方法#

Windows 学习版：#

学习版直装包，一路安装即可，点击“试用”即可永久学习。
好用就完事儿咯，多的咱也不介绍😎
个人是替代Windows自带笔记本使用的。
当然，写代码还是请另找高明，你别告诉我你用记事本写代码。
有能力建议入正

🎯 适合人群#

用户类型	适用原因
博客写作者	轻松排版、导出方便、专注写作
技术开发者	支持代码块、高亮与 LaTeX
内容编辑 / 运营	快速组织内容结构、导出发布
学术研究人员	数学公式支持好，适合写笔记

只需 1 美元薅 ChatGPT Team 教程，5 个 ChatGPT Team

Mon, 30 Jun 2025 00:00:00 GMT

成品展示#

教你如何只需要 1 美元就可以体验和使用 ChatGPT Team 计划，升级和订阅 ChatGPT Team 计划跟 ChatGPT Plus 计划没有什么区别。

但是 ChatGPT Team 计划的模型次数会比 ChatGPT Plus 高一倍左右，如 GPT-4o 模型。

而且 ChatGPT Team 计划，之前需要 30 美元 / 月，现在 OpenAI 开启了一个活动，可以首页 1 美元就可以开通。

具体的如何开通升级 ChatGPT Team 计划，请看下面的保姆级教程。

开始教程#

如果你直接到 ChatGPT 的升级套餐那边进入的话，它会是 25 美元 / 月，会出现下面这种情况，是因为你操作方式不对，我教你如何直达。

没有从促销活动进入的话，就会出现下图这种情况

从促销活动进入的就是，1 美元 / 月。你只需要在 ChatGPT 上面的 url 上，加上这个参数就可以生效。

只需要增加这个参数：?promo_campaign=team1dollar#team-pricing

完整的 url：https://chatgpt.com/?promo_campaign=team1dollar#team-pricing

出现 1 美元 / 月的折扣之后，接下来我们就可以点击获取 Team 的操作，你可以看到下图，直接减免 149 美金的折扣，只需要支付 1 美金，就可以获得 5 个 ChatGPT Team 的位置。

之后，你可以分享给你朋友加入，你的朋友就不需要支付额外的费用。

进入结算页面，你只需要绑定一下国际的 Master 卡或者 visa 卡就行，国内卡不能用的情况下，就可以用虚拟卡。

我之前注册的了一张虚拟卡，专门薅羊毛的，避免忘记取消计划被扣费的情况的。

我之前冲了个最低的 5 美金，用到现在。

绑定之后，支付成功后，记得去取消掉 ChatGPT Team 计划。避免下个月的自动续费，下个月就是恢复原价 30 美金 / 月 / 位置。

那就是 150 美金了！一定要记得先去取消！！！！

ChatGPT 取消计划#

但是，你会发现找不到订阅管理的入口，我查了一下官方，和对比了 ChatGPT Pro 和 ChatGPT Plus 账号之后。

因为，官方也说了，目前只支持 Pro 和 Plus 管理订阅。 而 Team 需要在管理工作空间上的结算进行管理结算。

操作步骤：#

Click on your profile icon → Settings （点击你的头像 → 设置）
Select Subscription （选择订阅）
Select Manage → Cancel Subscription （选择管理 → 取消订阅）

重要提示：#

只有现有的 Plus 和 Pro 计划用户才会看到 “订阅” 选项。
你的取消将在你的下一个账单日期之后生效，允许你在那之前继续使用服务。
为了避免在下个计费周期被收费，请在下次计费日期前至少 24 小时取消。
订阅费用不可退款。

Team 取消步骤#

如果需要取消 ChatGPT Team 计划的，右上角头像 -> 管理工作空间 -> 结算 -> 管理套餐 -> 取消订阅。

支付问题#

有很多佬友碰到了一些支付的问题，这里是可以使用 PayPal、兔卡、野卡都可以。无法支付的情况下，可以先确认一下是否是网络问题。

建议使用美区网络，我是自己部署的美区家宽，所以几乎能一次性过。

检测网络可以在 ping0.cc。

关于 ChatGPT 最新的弹性计划#

下面是最新的企业版本的弹性计划的积分消耗情况，ChatGPT 灵活的定价方案表，目前只适用于企业计划：

Model（模型）	Unit （单位）	Credits （积分）
GPT-4o	1 消息	无限
GPT-4.1 mini	1 消息	无限
GPT-4.1	1 消息	2 积分
GPT-4.5	1 消息	20 积分
GPT-4 Voice	1 分钟	5 积分
o3	1 条消息	10 积分
o4-mini	1 消息	5 积分
o4-mini-high	1 消息	5
o1-Pro	1 消息	50 积分
Deep Research	1 个任务	50 积分
ImageGen	1 消息	5 个积分

如果需要对某个模型，比如深度研究 Deep Research 这类功能高强度使用的话，就可以尝试开通企业计划，不过，这个比较复杂，需要联系对应的 OpenAI 的销售。

image

文章来源#

https://linux.do/t/topic/702526

Java线程池

Mon, 23 Jun 2025 00:00:00 GMT

总体设计#

ThreadPoolExecutor实现的顶层接口是Executor，顶层接口Executor提供了一种思想：将任务提交和任务执行进行解耦。用户无需关注如何创建线程，如何调度线程来执行任务，用户只需提供Runnable对象，将任务的运行逻辑提交到执行器(Executor)中，由Executor框架完成线程的调配和任务的执行部分。ExecutorService接口增加了一些能力：（1）扩充执行任务的能力，补充可以为一个或一批异步任务生成Future的方法；（2）提供了管控线程池的方法，比如停止线程池的运行。AbstractExecutorService则是上层的抽象类，将执行任务的流程串联了起来，保证下层的实现只需关注一个执行任务的方法即可。最下层的实现类ThreadPoolExecutor实现最复杂的运行部分，ThreadPoolExecutor将会一方面维护自身的生命周期，另一方面同时管理线程和任务，使两者良好的结合从而执行并行任务。

线程池的核心类：`ThreadPoolExecutor`#

Java 提供的线程池主要通过 java.util.concurrent.ThreadPoolExecutor 实现。

1
public ThreadPoolExecutor(    int corePoolSize,        // 核心线程数（常驻）    int maximumPoolSize,     // 最大线程数    long keepAliveTime,      // 非核心线程的存活时间    TimeUnit unit,           // 上面参数的单位    BlockingQueue<Runnable> workQueue,  // 任务队列    ThreadFactory threadFactory,        // 线程工厂（创建线程的方式）    RejectedExecutionHandler handler    // 拒绝策略)

线程池参数详解#

参数	说明
corePoolSize	核心线程数，线程池中始终保留的线程数量。
maximumPoolSize	最大线程数。线程池能创建的最大线程数（包括核心线程）。
keepAliveTime	非核心线程的空闲存活时间。超过这个时间会被销毁。
unit	存活时间单位，如 TimeUnit.SECONDS。
workQueue	任务缓存队列（如 ArrayBlockingQueue、LinkedBlockingQueue）。
threadFactory	自定义线程创建方式，可设置线程名、守护线程等。
handler	拒绝策略，线程池已满时的处理方式。

任务执行流程#

若线程数 < corePoolSize → 创建新线程执行任务
若线程数 ≥ corePoolSize → 放入队列
若队列满且线程数 < maximumPoolSize → 创建新线程执行任务
若线程数 ≥ maximumPoolSize 且队列也满 → 触发拒绝策略

常见线程池拒绝策略（`RejectedExecutionHandler`）#

策略	含义
AbortPolicy	默认策略，抛出 RejectedExecutionException 异常。
CallerRunsPolicy	谁提交谁执行（任务回退给主线程）。
DiscardPolicy	直接丢弃任务，不抛异常。
DiscardOldestPolicy	丢弃队列最旧的任务，尝试执行当前任务。

常用线程池队列（`BlockingQueue`）#

队列类型	特点
ArrayBlockingQueue	有界，数组实现，必须设置容量，适合固定大小任务量
LinkedBlockingQueue	可设容量（默认无限），链表实现，适合任务突发
SynchronousQueue	不缓存任务，直接传递给线程，适合高并发、立即处理任务

如何创建线程池？

推荐：使用 ThreadPoolExecutor，避免 Executors 工厂方法（不推荐）

1
ExecutorService threadPool = new ThreadPoolExecutor(    2, 5,    10, TimeUnit.SECONDS,    new LinkedBlockingQueue<>(100),    Executors.defaultThreadFactory(),    new ThreadPoolExecutor.AbortPolicy());

不推荐的 Executors（会导致OOM）：

1
Executors.newFixedThreadPool(10); // 队列无界Executors.newCachedThreadPool();  // 线程无限Executors.newSingleThreadExecutor(); // 只有一个线程

线程池使用示例#

1
public class ThreadPoolDemo {    public static void main(String args) {        ExecutorService pool = new ThreadPoolExecutor(            2, 4,            10, TimeUnit.SECONDS,            new ArrayBlockingQueue<>(5),            Executors.defaultThreadFactory(),            new ThreadPoolExecutor.CallerRunsPolicy()        );        for (int i = 0; i < 10; i++) {            final int taskId = i;            pool.execute(() -> {                System.out.println("任务 " + taskId + " 执行线程: " + Thread.currentThread().getName());            });        }        pool.shutdown(); // 关闭线程池    }}

阿里巴巴线程池规范（强烈建议背熟）#

使用 ThreadPoolExecutor 自定义线程池，禁止使用 Executors 提供的默认线程池，原因是：

FixedThreadPool 和 SingleThreadPool 使用的是无界队列，可能导致 OOM；
CachedThreadPool 使用的是无界线程数量，也可能 OOM；
推荐设置合理 队列大小 和 最大线程数；

Executors#

Executors 是 Java 提供的线程池工厂工具类，位于 java.util.concurrent.Executors 包中，它提供了一些快速创建线程池、定时任务线程池、单线程执行器的方法，使用简单，但也有一些坑（如无界队列、OOM 等问题）。

Executors 常用方法总览

方法名	描述	推荐程度
newFixedThreadPool(int nThreads)	固定线程数线程池	❌ 不推荐（使用无界队列）
newCachedThreadPool()	缓存线程池，线程数不限制	❌ 不推荐（线程数无界）
newSingleThreadExecutor()	单线程线程池	❌ 不推荐（无界队列）
newScheduledThreadPool(int corePoolSize)	支持定时/周期执行的线程池	✅ 合理使用
newSingleThreadScheduledExecutor()	单线程定时线程池	✅ 可用于简单定时任务
newWorkStealingPool() （Java 8+）	ForkJoinPool 支持的多任务窃取线程池	✅ 特定并行任务
callable(Runnable task, V result)	把 Runnable 转为 Callable	✅ 工具方法
unconfigurableExecutorService(...)	包装不可配置的线程池	✅ 安全场景用
privilegedThreadFactory()	获取当前线程上下文权限的 ThreadFactory	✅ 高安全场景
defaultThreadFactory()	默认线程工厂（可用于手动 ThreadPoolExecutor）	✅ 常用

重点方法说明

1. newFixedThreadPool(int nThreads)

1
ExecutorService pool = Executors.newFixedThreadPool(5);

特点：线程数固定，超出部分任务排队执行
使用：适合任务量固定、不会突发堆积的场景
⚠️ 问题：使用的是无界队列，易造成内存堆积 ➜ ❌不推荐

2. newCachedThreadPool()

1
ExecutorService pool = Executors.newCachedThreadPool();

特点：线程数量无限制（Integer.MAX_VALUE）
使用：适合大量、短周期的轻量任务
⚠️ 问题：线程无限增长，易 OOM ➜ ❌不推荐

3. newSingleThreadExecutor()

1
ExecutorService pool = Executors.newSingleThreadExecutor();

特点：只有一个线程，串行执行任务
使用：任务必须顺序执行场景
⚠️ 问题：队列无界，线程挂了会自动创建新线程，可能隐藏问题 ➜ ❌不推荐用于生产高并发

4. newScheduledThreadPool(int corePoolSize)

1
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);

特点：支持定时、周期性任务，基于 ScheduledThreadPoolExecutor
使用：定时任务（如日志归档、缓存刷新）
✅ 推荐使用，但建议配合 ThreadFactory + 拒绝策略显式构造更安全

5. newWorkStealingPool()

1
ExecutorService pool = Executors.newWorkStealingPool(); // Java 8+

✅ 高性能，但不适合高并发请求处理，且无法精细控制线程池参数

特点：基于 ForkJoinPool，自动按 CPU 核心数创建工作线程

使用：适合并行分治任务（如大数据分片处理）

推荐做法（线程池最佳实践）

阿里巴巴 Java 开发手册强烈建议不要使用 Executors，而是手动构造：

1
ThreadPoolExecutor pool = new ThreadPoolExecutor(    10, 20,    60L, TimeUnit.SECONDS,    new ArrayBlockingQueue<>(200),    Executors.defaultThreadFactory(), // 可替换为自定义命名工厂    new ThreadPoolExecutor.CallerRunsPolicy());

拓展方法

方法	说明
Executors.callable(Runnable task)	把 Runnable 包装成 Callable（返回 null）
Executors.defaultThreadFactory()	返回默认线程工厂，线程名如：pool-1-thread-1
Executors.privilegedThreadFactory()	创建带当前 AccessControlContext 的线程
Executors.unconfigurableExecutorService()	包装线程池，不允许调用配置方法（如 shutdownNow）

总结：Executors 方法使用建议

方法	是否推荐	说明
newFixedThreadPool	❌	无界队列风险
newCachedThreadPool	❌	无界线程数风险
newSingleThreadExecutor	❌	无界队列、线程替换隐藏问题
newScheduledThreadPool	✅	合理控制线程数
newWorkStealingPool	✅	高吞吐并行计算
自定义 ThreadPoolExecutor	✅强烈推荐	可精细控制每个参数，安全、灵活

ScheduledThreadPoolExecutor#

**ScheduledThreadPoolExecutor** 是 Java 中专门用于执行定时任务和周期任务的线程池，它比 Timer 更强大、更安全，是企业级定时任务的首选方案。

ScheduledThreadPoolExecutor 是什么？

ScheduledThreadPoolExecutor 是一个线程池，支持以下几种定时任务调度：

调度类型	描述
延迟执行	延迟固定时间后执行一次任务
周期执行（固定速率）	每隔固定时间开始执行（忽略任务执行时长）
周期执行（固定延迟）	每次任务执行完后，延迟固定时间再开始下一次

它是 Executors.newScheduledThreadPool(int corePoolSize) 的底层实现类，继承自 ThreadPoolExecutor。

创建线程池的方式

1
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

等价于：

1
ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(    2,    Executors.defaultThreadFactory(),    new ThreadPoolExecutor.AbortPolicy());

常用方法介绍

1. schedule(Runnable command, long delay, TimeUnit unit)

延迟固定时间后执行一次

1
scheduler.schedule(() -> {    System.out.println("延迟 3 秒后执行一次任务");}, 3, TimeUnit.SECONDS);

2. scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

周期执行（固定速率）：每隔 period 时间触发一次任务，不管任务执行多久

1
scheduler.scheduleAtFixedRate(() -> {    System.out.println("每 5 秒执行一次，固定速率");}, 1, 5, TimeUnit.SECONDS);

✅ 适合：定时轮询任务（比如定时监控、健康检查）

⚠️ 注意：如果任务执行超过周期，会出现任务并发执行重叠

3. scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

周期执行（固定延迟）：每次任务执行完之后，等 delay 时间再执行下一次

1
scheduler.scheduleWithFixedDelay(() -> {    System.out.println("每次执行完后再等 5 秒执行");}, 1, 5, TimeUnit.SECONDS);

✅ 适合：任务耗时不固定、希望每次之间有固定“间隔”

含义和区别：

方法	重复？	延迟/周期点	执行时机	并发执行
schedule(Runnable, delay)	否（一次性）	延迟 delay 后执行一次	不管任务执行多长时间，到达延迟点就执行一次	不会重复，也不存在并发问题
scheduleAtFixedRate(Runnable, initialDelay, period)	是（固定速率）	以调度开始时间为基准，每隔 period 安排一次	上一次开始时间 + period 到点就触发	不会并发执行（内部串行），但如果执行慢于 period，会“立即”补跑
scheduleWithFixedDelay(Runnable, initialDelay, delay)	是（固定延迟）	以上一次结束时间为基准，结束后再延迟 delay	上一次完成时间 + delay 到点才触发	同样不并发执行

与 Timer 的区别（为什么用 ScheduledThreadPoolExecutor）

比较点	`Timer`	`ScheduledThreadPoolExecutor`
错误隔离	❌ 一个任务出异常会终止所有任务	✅ 一个任务异常不影响其他任务
并发支持	❌ 单线程	✅ 多线程
精度	一般	更精确
线程管理	❌ 不支持	✅ 支持线程回收、拒绝策略等

✅ 所以：推荐使用 ScheduledThreadPoolExecutor 替代 Timer

推荐封装方式（更安全、更灵活）

1
ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(    4,    new BasicThreadFactory.Builder()        .namingPattern("scheduled-task-%d")        .daemon(true)        .build(),    new ThreadPoolExecutor.AbortPolicy());

BasicThreadFactory 是来自 commons-lang3 的工具类，可设置线程名、是否守护线程
可结合监控系统收集执行时间、失败次数等

注意事项

问题	建议
任务执行时间过长	建议使用 scheduleWithFixedDelay 避免任务重叠
出现异常未捕获	用 try-catch 包裹任务逻辑，避免线程退出
执行慢造成堆积	可使用 ScheduledExecutorService.shutdownNow() 停止并清理
定时任务过多	拆分多个线程池，按业务划分执行优先级

实战示例：每晚 2 点定时执行

1
public class DailyTask {    public static void main(String args) {        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);        Runnable task = () -> {            System.out.println("执行每日任务：" + LocalDateTime.now());        };        long initialDelay = computeInitialDelay(); // 计算当前时间到 2 点的间隔        long period = 24 * 60 * 60; // 每 24 小时执行一次        scheduler.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.SECONDS);    }    private static long computeInitialDelay() {        LocalDateTime now = LocalDateTime.now();        LocalDateTime nextRun = now.withHour(2).withMinute(0).withSecond(0);        if (now.compareTo(nextRun) > 0) {            nextRun = nextRun.plusDays(1);        }        return Duration.between(now, nextRun).getSeconds();    }}

Java线程知识

Thu, 19 Jun 2025 00:00:00 GMT

线程基础#

Java线程是什么？

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

进程（Process）：程序运行的实例，每个进程有独立的内存空间。
线程：进程内部的执行单元，可以多个线程共享同一个进程的内存资源。

Java线程指的是Java程序中用Thread类或实现Runnable接口创建的轻量级执行单元。一个Java应用至少有一个线程（main线程）。

为什么要用线程？

并发执行：让程序可以同时做多件事，比如下载、界面响应、计算等互不阻塞。
资源共享：同一个进程内的多个线程可以共享数据，减少资源消耗，通信高效。
提高性能：多核CPU上利用多线程能让程序跑得更快（合理使用的话）。

创建线程的方式#

继承 Thread 类

1
class MyThread extends Thread {
2
    public void run() {
3
        System.out.println("MyThread is running");
4
    }
5
}
6
new MyThread().start();

实现 Runnable 接口

1
class MyRunnable implements Runnable {
2
    public void run() {
3
        System.out.println("MyRunnable is running");
4
    }
5
}
6
new Thread(new MyRunnable()).start();

实现 Callable 接口 + Future

1
Callable<Integer> task = () -> {
2
    return 123;
3
};
4
FutureTask<Integer> future = new FutureTask<>(task);
5
new Thread(future).start();
6
Integer result = future.get(); // 等待执行完

区别：

Thread直接继承，不适合多继承。
Runnable/Callable推荐（面向接口，更灵活）。

线程的生命周期#

Java 线程状态分为几个阶段：

状态	说明
NEW	新建，刚创建，还没启动（new Thread时）
RUNNABLE	可运行，包括正在运行和就绪等待CPU
BLOCKED	阻塞，等待锁
WAITING	等待，等待其他线程唤醒（如wait()/join()）
TIMED_WAITING	超时等待（如sleep(n)、wait(n)、join(n)）
TERMINATED	终止，线程执行完毕

状态切换典型例子

start()：NEW -> RUNNABLE
等待 CPU 分配：RUNNABLE -> RUNNING
sleep()/wait()/join()：RUNNING -> TIMED_WAITING/WAITING
获取不到锁：BLOCKED
notify()/notifyAll()：WAITING -> RUNNABLE
执行完 run()：RUNNING -> TERMINATED

常用线程操作方法#

start() ：启动线程
run() ：线程要执行的代码
sleep(ms) ：让当前线程休眠指定时间（不释放锁）
join() ：等待另一个线程执行完毕
interrupt() ：中断线程（设置中断标志，具体还要自己响应）
isAlive() ：判断线程是否还在运行

例子：多线程打印

让两个线程交替打印数字：

1
public class PrintDemo {
2
    public static void main(String[] args) {
3
        Runnable task = () -> {
4
            for (int i = 0; i < 5; i++) {
5
                System.out.println(Thread.currentThread().getName() + ": " + i);
6
            }
7
        };
8
        Thread t1 = new Thread(task, "A");
9
        Thread t2 = new Thread(task, "B");
10
        t1.start();
11
        t2.start();
12

13
}

输出样例：

1
A: 0
2
B: 0
3
A: 1
4
B: 1
5
...

面试题举例#

1. Thread 和 Runnable 的区别？哪种更推荐？

答：

Thread 是类，Runnable 是接口。
Thread 本身也实现了 Runnable。
如果继承 Thread，不能再继承其他类（Java 单继承）。
实现 Runnable 更灵活，便于资源共享、可配合线程池等。
推荐使用 Runnable。

解析：

面试官想考你“类和接口的区别”、Java 的单继承特性和面向接口编程思想。

2. 直接调用 run() 和 start() 有什么区别？

答：

start() 会新建一个线程，让线程异步并发执行 run()。
run() 只是一个普通方法调用，会在当前线程（通常是 main 线程）里顺序执行，不会新建线程。

代码举例：

1
Thread t = new Thread(() -> System.out.println(Thread.currentThread().getName()));t.run();   // maint.start(); // Thread-0

解析：

主要考你是否理解线程启动的机制，很多初学者会混淆这两者。

3. Java 线程的生命周期有哪些状态？各状态之间如何转换？

答：

状态有：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。
NEW —(start)—> RUNNABLE —(获取CPU)—> RUNNING
RUNNING —(wait/sleep/join/lock)—> WAITING/BLOCKED/TIMED_WAITING
WAITING —(notify/join结束)—> RUNNABLE
RUNNING —(run结束)—> TERMINATED

解析：

考察你是否了解多线程的本质和线程调度机制。

4. 为什么建议用 Runnable 而不是 Thread？

答：

Runnable是接口，可实现多继承，Thread是类只可单继承。
Runnable代码和线程对象分离，便于解耦、代码复用。
Runnable更适合资源共享。
线程池只能提交 Runnable/Callable，不接受 Thread。

解析：

考察你面向接口编程思想和并发框架适配能力。

5. 线程在什么情况下会进入 BLOCKED/WAITING/TIMED_WAITING 状态？

答：

BLOCKED：等待获取 synchronized 锁时进入（比如两个线程抢一个锁）。
WAITING：调用 Object.wait()、Thread.join()、LockSupport.park() 等，线程无限等待。
TIMED_WAITING：调用 Thread.sleep(time)、wait(time)、join(time)、parkNanos() 等，超时等待。

解析：

你要清楚每种等待的应用场景和 API。

6. 线程池为什么只能提交 Runnable/Callable，不能直接提交 Thread？

答：

线程池的任务提交方法参数是 Runnable 或 Callable，底层线程池会把它包装到自己的工作线程（Worker）去执行，而不是直接管理 Thread 对象。
Thread 是线程实例，不适合作为任务的“逻辑单元”，Runnable/Callable 更轻便、复用性高。

解析：

体现面向接口编程、线程池架构设计思想。

7. 常见代码题：下面这段代码输出什么？

1
public class Demo {    public static void main(String args) {        Thread t = new Thread(() -> System.out.println(Thread.currentThread().getName()));        t.run();        t.start();    }}

答：

1
mainThread-0

解析：

t.run() 只是普通方法调用，输出 main
t.start() 启动新线程，输出 Thread-0

8. 说出你知道的线程的常用方法，并简要说明作用

答：

start()：启动线程
run()：线程体方法
sleep(ms)：让当前线程休眠指定毫秒数
join()：让当前线程等待目标线程执行完毕
interrupt()：中断线程（设置中断标志位）
isAlive()：判断线程是否存活

解析：

体现你实际开发经验和 API 熟悉度。

9. 线程安全问题是怎么产生的？举例说明

答：

多个线程同时访问同一共享资源（如变量、集合）且有写操作时，线程切换可能导致数据不一致，即线程安全问题。

代码举例：

1
class Counter {    public int count = 0;    public void incr() { count++; }}

两个线程同时执行 incr()，结果可能小于2，说明数据被覆盖了。

10. 线程用完后为什么不能复用？如何提高线程复用效率？

答：

Thread 对象只能启动一次（start()），否则会抛出 IllegalThreadStateException。
为提高效率，推荐使用线程池（如 Executors），线程池中的线程可以复用，避免频繁创建销毁。

在哪些场景会用到线程？#

1. 提高程序性能、充分利用多核CPU

场景举例：

批量数据处理
比如：对 100 万条数据做运算，把数据分成 10 份，开 10 个线程，每个线程处理一份，最后合并结果，大大加快速度。
大文件处理
文件分块多线程上传或下载。

2. 避免阻塞主线程，提高用户体验

场景举例：

GUI 应用/移动端开发
比如：Swing/Android 开发中，如果网络请求、文件读写都在主线程，界面会卡死。必须放到子线程里处理，主线程负责界面响应。
Web服务中的异步任务
用户下单后订单信息入库是主流程，但发短信、邮件等操作可以用新线程或线程池异步处理，提升接口响应速度。

3. 处理需要并发访问的场景

场景举例：

高并发 Web 服务器
Tomcat、Jetty等Web服务器为每个请求分配线程（或线程池中的线程），可以同时处理成百上千的请求。
聊天室/游戏服务器
每个用户一个线程，实时通信。

4. 定时、周期性任务

场景举例：

定时任务调度
通过 ScheduledExecutorService，每隔一段时间自动执行某项任务（如每5分钟同步数据）。
日志异步落盘
日志框架往往会用线程异步写磁盘，避免主业务阻塞。

5. 多线程爬虫/数据采集

场景举例：

多线程爬虫
爬取多个网站页面，每个页面一个线程，同时采集，提高抓取效率。
多线程文件上传/下载
分块并发上传大文件，比如网盘、断点续传。

6. 并行计算/任务分片

场景举例：

矩阵运算/科学计算
大规模计算任务分解为多个线程，并行处理。
视频转码
视频按片段切分，每段用一个线程转码，最后拼接结果。

7. 线程池场景（资源有限、任务繁多）

场景举例：

消息队列消费者
多线程从消息队列（如RabbitMQ、Kafka）取消息，提升吞吐量。
Web爬虫任务池
多线程不断处理任务队列中的爬虫任务。

8. 其他场景

异步事件驱动编程（比如Netty，虽然底层不完全用传统线程，但线程池是基础）
并发缓存刷新
文件系统监听与同步

线程同步（synchronized、Lock）#

一、为什么需要线程同步？#

线程安全问题：多个线程同时访问/修改同一个资源（如变量、集合），可能导致数据混乱（脏读、丢数据等）。
举例：

1
class Counter {
2
    int count = 0;
3
    void incr() { count++; }
4
}
5
// 多线程执行incr()，count结果可能不是你预期的

结论：要保证共享数据的正确性，需要线程同步，让同一时刻只能有一个线程修改资源。

二、synchronized 同步机制#

1. 基本语法

修饰实例方法：锁住当前实例对象

1
public synchronized void incr() { count++; }

修饰静态方法：锁住类对象（Class对象）

1
public static synchronized void incr() { ... }

修饰代码块：指定锁对象

1
public void incr() {
2
    synchronized(this) { count++; }
3
    // 或 synchronized(某个对象) { ... }
4
}

2. 作用范围

实例方法：锁住当前对象（this），同一个对象同一时刻只有一个线程进入该方法。
静态方法：锁住Class对象（全类唯一）。
代码块：可以灵活指定锁粒度（如锁某个共享变量、类对象等）。

3. synchronized 的原理

每个对象有一个“内置锁”（Monitor），synchronized 本质就是拿这个锁。
获取不到锁的线程会阻塞，直到获得锁。

4. synchronized 代码演示

1
class SafeCounter {
2
    private int count = 0;
3

4
    public synchronized void incr() {
5
        count++;
6
    }
7

8
    public int getCount() {
9
        return count;
10
    }
11
}
12

13
public class Demo {
14
    public static void main(String[] args) throws InterruptedException {
15
        SafeCounter counter = new SafeCounter();
16
        Thread t1 = new Thread(() -> { for (int i=0; i<10000; i++) counter.incr(); });
17
        Thread t2 = new Thread(() -> { for (int i=0; i<10000; i++) counter.incr(); });
18
        t1.start(); t2.start();
19
        t1.join(); t2.join();
20
        System.out.println(counter.getCount()); // 20000
21
    }
22
}

展开收起

没有同步，结果可能小于 20000；加了 synchronized，一定是 20000。

三、Lock 接口及其实现#

1. Lock 概述

Lock 是 java.util.concurrent.locks 包下的接口，比 synchronized 更灵活。
常用实现：ReentrantLock（可重入锁）

2. 基本用法

1
import java.util.concurrent.locks.Lock;
2
import java.util.concurrent.locks.ReentrantLock;
3

4
class SafeCounter2 {
5
    private int count = 0;
6
    private final Lock lock = new ReentrantLock();
7

8
    public void incr() {
9
        lock.lock();         // 加锁
10
        try {
11
            count++;
12
        } finally {
13
            lock.unlock();   // 解锁，必须写在finally防止死锁
14
        }
15
    }
16

17
    public int getCount() {
18
        return count;
19
    }
20
}

展开收起

3. Lock 的优势

能响应中断（lockInterruptibly()）
可以尝试获取锁（tryLock()）
支持公平/非公平锁
支持条件变量（Condition，可实现更灵活的线程通信）

四、synchronized VS Lock#

方面	synchronized	Lock (如ReentrantLock)
JDK版本	关键字，JVM层实现	类库，JDK 1.5后
解锁方式	自动（方法/代码块执行完自动释放）	手动（需要unlock，容易死锁）
是否可重入	是	是
是否可中断	否	是（lockInterruptibly）
是否公平锁	否	可选（构造时指定公平性）
条件变量	无	有（Condition）
性能	JDK1.6以后，差别很小	灵活场景更多

总结：

简单用法优先synchronized（易读，易维护）。
复杂并发控制、可中断、公平锁、条件队列等用Lock。

五、常见线程同步场景举例#

1. 银行账户转账（防止两个人同时转账导致余额出错）

1
class Account {    private int balance = 1000;    public synchronized void withdraw(int money) {        if (balance >= money) balance -= money;    }}

2. 多线程安全队列

用 Lock 实现队列的线程安全入队出队
JDK 自带 ConcurrentLinkedQueue 等并发容器（底层就是 CAS/锁）

六、常见面试/笔试陷阱#

忘记用 unlock()，导致死锁

1
lock.lock();
2
// 代码异常没有finally unlock，锁永远不释放

锁对象不同导致同步失败

1
synchronized(new Object()) { ... } // 每次都是新对象，没有同步效果

误以为 static synchronized 锁住所有实例，其实只锁类对象

七、最佳实践建议#

多线程只锁真正需要同步的最小代码块，避免扩大锁粒度，防止性能下降。
如果锁住的是静态资源，一定要锁 Class 对象（如synchronized(ClassName.class)）。
用 Lock 的时候一定要 unlock() 写在 finally 里。
面试时会被问：如何避免死锁？怎么用Lock写出更灵活的同步控制？

八、死锁问题复现#

1. 什么是死锁？

死锁（Deadlock）：多个线程因互相持有对方需要的锁资源，导致都永远等待下去，程序卡住。
直观理解：
- 线程A拿着资源1，要等资源2；线程B拿着资源2，要等资源1；谁都不肯放手，谁都等不到。

2. 死锁经典代码复现

1
public class DeadLockDemo {
2
    private static final Object lockA = new Object();
3
    private static final Object lockB = new Object();
4

5
    public static void main(String[] args) {
6
        Thread t1 = new Thread(() -> {
7
            synchronized (lockA) {
8
                System.out.println("Thread1 got lockA");
9
                try { Thread.sleep(100); } catch (InterruptedException e) {}
10
                synchronized (lockB) {
11
                    System.out.println("Thread1 got lockB");
12
                }
13
            }
14
        });
15

16
        Thread t2 = new Thread(() -> {
17
            synchronized (lockB) {
18
                System.out.println("Thread2 got lockB");
19
                try { Thread.sleep(100); } catch (InterruptedException e) {}
20
                synchronized (lockA) {
21
                    System.out.println("Thread2 got lockA");
22
                }
23
            }
24
        });
25

26
        t1.start();
27
        t2.start();
28
    }
29
}

展开收起

运行结果：

1
Thread1 got lockA
2
Thread2 got lockB
3
// 程序一直卡住，不再输出

原因：

t1 获得 lockA，t2 获得 lockB，之后双方都在等待对方释放锁，永远卡住。

如何避免死锁？

1. 尽量保证获取多个锁时顺序一致

方案：统一规定加锁顺序，比如永远先拿lockA再拿lockB。
改造代码：

1
// 两个线程都先拿lockA再拿lockB，不会死锁
2
Runnable task = () -> {
3
    synchronized (lockA) {
4
        try { Thread.sleep(100); } catch (InterruptedException e) {}
5
        synchronized (lockB) {
6
            System.out.println(Thread.currentThread().getName() + " got both locks");
7
        }
8
    }
9
};
10
// t1和t2都用同一个顺序

2. 尽量减少锁的持有时间、减少同步范围

锁只包裹最小、最关键的代码块，避免不必要的锁嵌套。

3. 避免嵌套锁（能不多层加锁就不多层）

有些场景通过业务设计避免多重锁定。

4. 使用 tryLock 尝试获取锁，失败立即释放已持有的锁

利用 Lock 的 tryLock 特性，可以让线程在拿不到全部锁时“主动放弃”，避免死锁。

用Lock写更灵活的同步控制

1. ReentrantLock 支持 tryLock（核心功能！）

基本思想：尝试同时获取所有锁，失败则释放已获得的锁并稍后重试，防止死锁。

例子：避免死锁的 tryLock 实现

1
import java.util.concurrent.locks.Lock;
2
import java.util.concurrent.locks.ReentrantLock;
3

4
public class TryLockAvoidDeadlock {
5
    private static final Lock lockA = new ReentrantLock();
6
    private static final Lock lockB = new ReentrantLock();
7

8
    public static void main(String[] args) {
9
        Runnable task1 = () -> {
10
            while (true) {
11
                if (lockA.tryLock()) {
12
                    try {
13
                        Thread.sleep(100); // 模拟业务
14
                        if (lockB.tryLock()) {
15
                            try {
16
                                System.out.println("Task1 got both locks!");
17
                                break; // 成功获得所有锁，跳出
18
                            } finally {
19
                                lockB.unlock();
20
                            }
21
                        }
22
                    } catch (InterruptedException e) {}
23
                    finally {
24
                        lockA.unlock();
25
                    }
26
                }
27
                // 失败时稍微等下再试
28
                try { Thread.sleep(10); } catch (InterruptedException e) {}
29
            }
30
        };
31

32
        Runnable task2 = () -> {
33
            while (true) {
34
                if (lockB.tryLock()) {
35
                    try {
36
                        Thread.sleep(100);
37
                        if (lockA.tryLock()) {
38
                            try {
39
                                System.out.println("Task2 got both locks!");
40
                                break;
41
                            } finally {
42
                                lockA.unlock();
43
                            }
44
                        }
45
                    } catch (InterruptedException e) {}
46
                    finally {
47
                        lockB.unlock();
48
                    }
49
                }
50
                try { Thread.sleep(10); } catch (InterruptedException e) {}
51
            }
52
        };
53

54
        new Thread(task1).start();
55
        new Thread(task2).start();
56
    }
57
}

展开收起

说明：

tryLock 如果拿不到锁不会阻塞，直接返回false，这样线程能主动释放已持有的锁和重试，避免僵死等待。

问：如果两个线程中,程序挂了,会当如何？#

这个“如果两个线程中，程序挂了，会当如何”——这个问题我拆分一下理解：

如果你的意思是线程死锁卡住了，两个线程都在等对方，不会继续往下走，但整个Java进程（JVM）不会自动退出，进程会一直挂着（CPU/内存不会释放），直到你手动kill进程或用工具分析。
如果你的意思是线程执行代码抛出了异常（比如空指针、数组越界），这时候分几种情况，下面详细说说：

1. 线程发生死锁（Deadlock）

两个线程都在等待对方释放锁，谁也不让步，不会抛出异常，只是这两个线程永远卡住。
只要主线程没退出（比如main方法还在等），整个Java程序会一直处于“卡死”状态，你只能用 jstack/jconsole 查看线程堆栈，或者重启程序。

2. 线程内部抛出异常

2.1 主线程抛出异常

主线程（main）如果抛出未捕获异常，主线程会退出，但进程不会马上终止，因为还有其他子线程可能还在跑。

2.2 子线程抛出异常

子线程如果抛出异常（没catch），该线程会退出，但不会影响其他线程。
不会导致整个Java程序（JVM进程）挂掉或退出，其他线程继续跑。
如果这个子线程很重要（比如线程池里的worker），那它挂了后，相关任务会失败，但程序总体还活着。

例子：

1
public class Demo {
2
    public static void main(String[] args) {
3
        Thread t = new Thread(() -> {
4
            System.out.println("子线程开始");
5
            int x = 1/0; // 这里异常
6
            System.out.println("子线程结束");
7
        });
8
        t.start();
9
        System.out.println("main线程结束");
10
    }
11
}

输出类似：

1
子线程开始
2
main线程结束
3
Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
4
    at ...

线程 Thread-0 挂了，main线程没受影响，JVM进程还会活着直到所有线程都退出。

3. 线程组/线程池中线程异常

在线程池中，如果任务抛出异常，只影响当前任务，线程池会自动回收、继续接收新任务。
但如果线程异常没人捕获且主线程已经退出，且没有非守护线程存活，JVM会自动退出。

4. 怎样防止线程因异常挂掉影响业务？

用 try-catch 包裹线程体，日志输出异常，确保即使出错也能优雅处理：

1
Runnable task = () -> {
2
    try {
3
        // 业务代码
4
    } catch (Exception e) {
5
        e.printStackTrace();
6
    }
7
};

对于线程池，可以用ThreadPoolExecutor的afterExecute回调，统一日志处理。

5. 死锁挂住如何处理？

定位死锁：jstack/jconsole 工具可以看到“waiting to lock…”的线程栈，能发现死锁。
手动干预：一般只能重启服务或优化代码。
预防：如上面说的 tryLock、锁顺序统一等。

6. 其他特殊情况

如果你的主线程是守护线程（daemon thread），所有非守护线程退出后，JVM 会自动退出。
但只要有非守护线程（比如死锁、死循环）活着，JVM就不会自动退出。

小结

单个线程挂了不会影响整个程序，除非它是最后一个非守护线程。
死锁会让程序卡住不动，但不会自动报错退出。
要健壮，多用 try-catch 保证线程异常能被日志记录，不影响主流程。
生产环境最好有线程存活/心跳监控，死锁检测和自动报警。

理解JMM和可见性问题#

一、什么是 JMM（Java 内存模型）？#

JMM是Java语言中规定的多线程并发时，变量如何在内存中存储、读取和传递的一套规范。
目的是：屏蔽不同硬件和操作系统的内存访问差异，让Java程序员写出的多线程代码能在所有平台下表现一致。

二、为什么需要 JMM？#

多核CPU下的高速缓存导致“可见性”问题
- 每个CPU都有自己的缓存，各个线程可以同时运行在不同CPU上。
- 线程A在自己的CPU缓存里修改了变量，线程B在另一个CPU的缓存里还没看到这个最新值。
指令重排序
- 为了提升性能，JVM和CPU都可以对代码执行顺序做优化。
- 可能导致代码实际运行顺序和我们写出来的顺序不同，从而出错。

三、JMM的三大核心问题#

原子性：操作不可被线程切割（一次完成）。比如++不是原子操作。
可见性：一个线程修改了变量，其他线程能否立即看到这个变化？
有序性：程序执行顺序是否和代码顺序一致？

四、可见性问题的现象和举例#

1. 代码示例：可见性问题

1
public class VisibilityDemo {
2
    private static boolean flag = false;
3

4
    public static void main(String[] args) throws Exception {
5
        new Thread(() -> {
6
            while (!flag) {
7
                // do nothing
8
            }
9
            System.out.println("线程检测到flag变为true");
10
        }).start();
11

12
        Thread.sleep(1000);
13
        flag = true;
14
        System.out.println("main线程已修改flag=true");
15
    }
16
}

展开收起

你可能期望输出：

1
main线程已修改flag=true
2
线程检测到flag变为true

但实际运行时输出：

1
main线程已修改flag=true

而子线程里的System.out.println("线程检测到flag变为true");永远不会执行！

这是为什么？

2.1 JMM的内存模型决定了这种情况

Java 的每个线程都有自己的工作内存（可以理解为“线程私有变量的副本”）。
当子线程开始时，会把 flag 的值从主内存拷贝到自己的工作内存。
子线程在 while 循环里，一直判断自己的“副本flag”，如果主线程把主内存的 flag 改为 true，但子线程不会自动刷新自己的flag副本。
所以子线程一直看到的都是原来的false，while循环永远不退出。

2.2 不是每次都出现！

有时候你加一条输出（比如在while里打印），或者改成debug模式，JVM的“优化”行为会变，副本会被刷新，表现出正确结果。这就是**“偶现/不稳定”问题**，更难排查。

结论：这不是Java“Bug”，而是JMM特意的规定

Java这样设计，是为了多线程下的性能（缓存机制、减少主内存的读写压力）。
只有当你用synchronized/volatile等方式，才强制各线程刷新变量。

五、JMM对可见性问题的规定#

JMM规定了主内存（Main Memory）和每个线程的工作内存（Working Memory）。
变量必须先拷贝到线程工作内存，再从工作内存写回主内存。
线程间通信，必须通过主内存。
线程自己工作区变量改了，不保证立刻刷回主内存。

六、解决可见性问题的常用方法#

1. 使用 volatile 关键字

作用：保证变量对所有线程立即可见，每次读写都强制从主内存读/写。
缺点：只能保证可见性和有序性，不保证原子性。

1
private static volatile boolean flag = false;

2. 使用 synchronized 关键字

进入/退出同步块时，JMM会保证变量的刷新（解锁前会把本地工作内存的变量写回主内存，加锁后清空本地缓存重新读取主内存）。
因此，synchronized 既保证了可见性，又能保证原子性。

3. 使用 Lock（如ReentrantLock）

lock() 和 unlock() 同步也会带来可见性保证。

七、指令重排序与 volatile 的“内存屏障”作用#

volatile 原理其实就是加了“内存屏障”，禁止 JVM/CPU 优化时乱序执行，保证前后的代码顺序对其他线程可见。
synchronized 也有相似效果（加锁/解锁时会有内存屏障）。

1
// 仅保证可见性
2
private static volatile boolean flag = false;
3

4
// 既保证可见性又保证原子性
5
public synchronized void setFlag(boolean value) { flag = value; }

volatile能保证什么？不能保证什么？

volatile能保证：

可见性：一个线程修改变量，其他线程立刻可见。
有序性：禁止指令重排（保证前后的操作不会被JVM/CPU优化错乱顺序）。

volatile不能保证：

原子性：一个操作“不可再分”，volatile不保证复合操作的原子性。

举例（不保证原子性）：

1
private static volatile int count = 0;
2
public static void main(String[] args) {
3
    new Thread(() -> { for(int i=0;i<10000;i++) count++; }).start();
4
    new Thread(() -> { for(int i=0;i<10000;i++) count++; }).start();
5
    // 结果可能小于20000，说明++不是原子操作
6
}

synchronized和volatile的区别？#

对比点	volatile	synchronized
关键字类型	修饰变量	修饰方法/代码块
可见性	保证	保证
原子性	不保证	保证
有序性	保证（禁止重排）	保证（进入/退出内存屏障）
性能	性能高，适合状态标志	性能低，涉及线程调度
适用场景	状态标志、单例双检锁等	复杂逻辑同步、复合操作

原子性、可见性、有序性各举一个代码例子

原子性举例：

1
private static int count = 0;
2
public static void main(String[] args) throws Exception {
3
    Thread t1 = new Thread(() -> { for(int i=0;i<10000;i++) count++; });
4
    Thread t2 = new Thread(() -> { for(int i=0;i<10000;i++) count++; });
5
    t1.start(); t2.start(); t1.join(); t2.join();
6
    System.out.println(count); // 结果可能小于20000，++不是原子操作
7
}

可见性举例：

1
private static boolean running = true;
2
Thread t = new Thread(() -> {
3
    while (running) {} // 没有volatile或synchronized修饰，主线程改了，子线程看不到
4
});
5
t.start();
6
Thread.sleep(1000);
7
running = false; // 子线程可能永远跳不出循环

有序性举例（指令重排序）：

1
int a = 0, b = 0, x = 0, y = 0;
2
Thread t1 = new Thread(() -> { a = 1; x = b; });
3
Thread t2 = new Thread(() -> { b = 1; y = a; });
4
// 理论上x、y都为1，但由于指令重排，有可能x=0或y=0

Mihomo (原Clash) 自用配置

Tue, 20 May 2025 00:00:00 GMT

DNS防泄漏查询#

查询地址:

其实吧,我感觉DNS泄露这东西,咋个说呢,感觉并没啥大用!仁者见仁吧

DNS解析流程#

节点配置#

1
### 全局配置
2
mixed-port: 7890 # HTTP(S) + SOCKS 混合代理端口，Clash 主代理入口
3
allow-lan: true # 允许局域网设备连接本机代理
4
mode: rule # 代理模式，使用规则分流
5
bind-address: "*" # 绑定所有网卡地址，使局域网内其他设备可访问
6
ipv6: false # 禁用 IPv6，防止 DNS 泄露及访问异常
7
log-level: debug # 日志等级，调试时推荐设置为 debug
8
profile:
9
  store-selected: true # 记住上次选择的节点或策略
10
  store-fake-ip: true # 记住 fake-ip 映射关系，提升命中率
11
unified-delay: true # 启用统一延迟计算
12
tcp-concurrent: true # TCP 并发连接，提升连接速度
13
global-client-fingerprint: chrome # 全局默认浏览器指纹，用于模拟真实浏览器行为
14

15
### DNS 配置
16
dns:
17
  enable: true # 启用内置 DNS 服务器
18
  prefer-h3: true # 优先使用 HTTP/3（QUIC）协议解析 DNS 请求
19
  ipv6: false # 不解析 AAAA 记录，避免走 IPv6
20
  enhanced-mode: fake-ip # 使用 fake-ip 模式，防止 DNS 泄露
21
  fake-ip-range: 198.18.0.1/16 # 用于 fake-ip 映射的 IP 段（保留地址段）
22
  fake-ip-filter: # fake-ip 排除列表，这些域名将使用真实 IP 解析，防止功能异常
23
    # 本地主机/设备
24
    - +.lan
25
    - +.local
26
    # Windows网络出现小地球图标
27
    - +.msftconnecttest.com
28
    - +.msftncsi.com
29
    # QQ快速登录检测失败
30
    - localhost.ptlogin2.qq.com
31
    - localhost.sec.qq.com
32
    # 追加以下条目
33
    - +.in-addr.arpa
34
    - +.ip6.arpa
35
    - time.*.com
36
    - time.*.gov
37
    - pool.ntp.org
38
    # 微信快速登录检测失败
39
    - localhost.work.weixin.qq.com
40
  respect-rules: true # DNS 查询也按 Clash 规则处理
41
  nameserver: # 直连使用的 DNS 服务器（DoH）
42
    - https://223.5.5.5/dns-query # 阿里公共 DNS
43
    - https://doh.pub/dns-query # 腾讯公共 DNS
44
  proxy-server-nameserver: # 被规则判断为走代理的域名使用此处 DNS
45
    - https://cloudflare-dns.com/dns-query # CloudflareDNS
46
    - https://77.88.8.8/dns-query # YandexDNS
47
    - https://8.8.4.4/dns-query#ecs=1.1.1.1/24&ecs-override=true  #GoogleDNS
48
    - https://208.67.222.222/dns-query#ecs=1.1.1.1/24&ecs-override=true  #OpenDNS
49
    - https://9.9.9.9/dns-query  #Quad9DNS
50

51
## 这里替换你的自建节点
52
proxies:
53
  - { name: "🇯🇵日本claw"}
54
  - { name: "🇺🇸美国dmit"}
55

56

57
### 出站策略锚点（用于复用）
58
pr: &pr { type: select, proxies: [ 节点选择, 自动选择, 🇯🇵日本claw, 🇺🇸美国dmit, 全局直连 ] }
59

60
### 代理组定义
61
proxy-groups:
62
  - { name: 节点选择, type: select, proxies: [ 自动选择, 🇯🇵日本claw, 🇺🇸美国dmit ] ,icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/adjust.svg }
63
  - { name: 自动选择, type: url-test, include-all: true, tolerance: 20, interval: 300, filter: "^((?!(全局直连)).)*$" ,icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/speed.svg }
64
  - { name: Google, <<: *pr ,icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/google.svg }
65
  - { name: Stream, <<: *pr , icon: https://cdn.jsdelivr.net/gh/uurani/uurani@refs/heads/master/image/stream.svg }
66
  - { name: ChatGPT, <<: *pr , icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/chatgpt.svg }
67
  - { name: Microsoft, <<: *pr , icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/microsoft.svg }
68
  - { name: Telegram, <<: *pr ,icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/telegram.svg }
69
  - { name: Apple, <<: *pr , icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/apple.svg }
70
  - { name: 漏网之鱼, <<: *pr , icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/fish.svg }
71
  - { name: 全局直连, type: select, proxies: [ DIRECT ], icon: https://fastly.jsdelivr.net/gh/clash-verge-rev/clash-verge-rev.github.io@main/docs/assets/icons/link.svg }
72

73
# 规则配置
74
RuleSet_classical: &RuleSet_classical { type: http, behavior: classical, interval: 86400, format: text}
75
RuleSet_domain: &RuleSet_domain { type: http, behavior: domain, interval: 86400, format: text}
76
RuleSet_ipcidr: &RuleSet_ipcidr { type: http, behavior: ipcidr, interval: 86400, format: text}
77

78
# 订阅规则
79
rule-providers:
80
  reject_non_ip_no_drop:
81
    <<: *RuleSet_classical
82
    url: 'https://ruleset.skk.moe/Clash/non_ip/reject-no-drop.txt'
83
    path: './rule_set/sukkaw_ruleset/reject_non_ip_no_drop.txt'
84

85
  reject_non_ip_drop:
86
    <<: *RuleSet_classical
87
    url: https://ruleset.skk.moe/Clash/non_ip/reject-drop.txt
88
    path: ./rule_set/sukkaw_ruleset/reject_non_ip_drop.txt
89

90
  reject_non_ip:
91
    <<: *RuleSet_classical
92
    url: https://ruleset.skk.moe/Clash/non_ip/reject.txt
93
    path: ./rule_set/sukkaw_ruleset/reject_non_ip.txt
94

95
  reject_domainset:
96
    <<: *RuleSet_domain
97
    url: https://ruleset.skk.moe/Clash/domainset/reject.txt
98
    path: ./rule_set/sukkaw_ruleset/reject_domainset.txt
99

100
  reject_ip:
101
    <<: *RuleSet_classical
102
    url: https://ruleset.skk.moe/Clash/ip/reject.txt
103
    path: ./rule_set/sukkaw_ruleset/reject_ip.txt
104

105
  cdn_domainset:
106
    <<: *RuleSet_domain
107
    url: https://ruleset.skk.moe/Clash/domainset/cdn.txt
108
    path: ./rule_set/sukkaw_ruleset/cdn_domainset.txt
109

110
  cdn_non_ip:
111
    <<: *RuleSet_domain
112
    url: https://ruleset.skk.moe/Clash/non_ip/cdn.txt
113
    path: ./rule_set/sukkaw_ruleset/cdn_non_ip.txt
114

115
  # 所有流媒体（包括上述所有流媒体）
116
  stream_non_ip:
117
    <<: *RuleSet_classical
118
    url: https://ruleset.skk.moe/Clash/non_ip/stream.txt
119
    path: ./rule_set/sukkaw_ruleset/stream_non_ip.txt
120

121
  stream_ip:
122
    <<: *RuleSet_classical
123
    url: https://ruleset.skk.moe/Clash/ip/stream.txt
124
    path: ./rule_set/sukkaw_ruleset/stream_ip.txt
125

126
  ai_non_ip:
127
    <<: *RuleSet_classical
128
    url: https://ruleset.skk.moe/Clash/non_ip/ai.txt
129
    path: ./rule_set/sukkaw_ruleset/ai_non_ip.txt
130

131
  telegram_non_ip:
132
    <<: *RuleSet_classical
133
    url: https://ruleset.skk.moe/Clash/non_ip/telegram.txt
134
    path: ./rule_set/sukkaw_ruleset/telegram_non_ip.txt
135

136
  telegram_ip:
137
    <<: *RuleSet_classical
138
    url: https://ruleset.skk.moe/Clash/ip/telegram.txt
139
    path: ./rule_set/sukkaw_ruleset/telegram_ip.txt
140

141
  apple_cdn:
142
    <<: *RuleSet_domain
143
    url: https://ruleset.skk.moe/Clash/domainset/apple_cdn.txt
144
    path: ./rule_set/sukkaw_ruleset/apple_cdn.txt
145

146
  apple_services:
147
    <<: *RuleSet_classical
148
    url: https://ruleset.skk.moe/Clash/non_ip/apple_services.txt
149
    path: ./rule_set/sukkaw_ruleset/apple_services.txt
150

151
  apple_cn_non_ip:
152
    <<: *RuleSet_classical
153
    url: https://ruleset.skk.moe/Clash/non_ip/apple_cn.txt
154
    path: ./rule_set/sukkaw_ruleset/apple_cn_non_ip.txt
155

156
  microsoft_cdn_non_ip:
157
    <<: *RuleSet_classical
158
    url: https://ruleset.skk.moe/Clash/non_ip/microsoft_cdn.txt
159
    path: ./rule_set/sukkaw_ruleset/microsoft_cdn_non_ip.txt
160

161
  microsoft_non_ip:
162
    <<: *RuleSet_classical
163
    url: https://ruleset.skk.moe/Clash/non_ip/microsoft.txt
164
    path: ./rule_set/sukkaw_ruleset/microsoft_non_ip.txt
165

166
  # 软件更新、操作系统等大文件下载
167
  download_domainset:
168
    <<: *RuleSet_domain
169
    url: https://ruleset.skk.moe/Clash/domainset/download.txt
170
    path: ./rule_set/sukkaw_ruleset/download_domainset.txt
171

172
  download_non_ip:
173
    <<: *RuleSet_domain
174
    url: https://ruleset.skk.moe/Clash/non_ip/download.txt
175
    path: ./rule_set/sukkaw_ruleset/download_non_ip.txt
176

177
  # 内网域名和局域网 IP
178
  lan_non_ip:
179
    <<: *RuleSet_classical
180
    url: https://ruleset.skk.moe/Clash/non_ip/lan.txt
181
    path: ./rule_set/sukkaw_ruleset/lan_non_ip.txt
182

183
  lan_ip:
184
    <<: *RuleSet_classical
185
    url: https://ruleset.skk.moe/Clash/ip/lan.txt
186
    path: ./rule_set/sukkaw_ruleset/lan_ip.txt
187

188
  domestic_non_ip:
189
    <<: *RuleSet_classical
190
    url: https://ruleset.skk.moe/Clash/non_ip/domestic.txt
191
    path: ./rule_set/sukkaw_ruleset/domestic_non_ip.txt
192

193
  direct_non_ip:
194
    <<: *RuleSet_classical
195
    url: https://ruleset.skk.moe/Clash/non_ip/direct.txt
196
    path: ./rule_set/sukkaw_ruleset/direct_non_ip.txt
197

198
  global_non_ip:
199
    <<: *RuleSet_classical
200
    url: https://ruleset.skk.moe/Clash/non_ip/global.txt
201
    path: ./rule_set/sukkaw_ruleset/global_non_ip.txt
202

203
  domestic_ip:
204
    <<: *RuleSet_classical
205
    url: https://ruleset.skk.moe/Clash/ip/domestic.txt
206
    path: ./rule_set/sukkaw_ruleset/domestic_ip.txt
207

208
  china_ip:
209
    <<: *RuleSet_ipcidr
210
    url: https://ruleset.skk.moe/Clash/ip/china_ip.txt
211
    path: ./rule_set/sukkaw_ruleset/china_ip.txt
212

213
# 分流规则
214
rules:
215
  ### 自定义类规则
216
  - DOMAIN-SUFFIX,infini.money,🇯🇵日本claw
217
  - DOMAIN-SUFFIX,piggo.me,DIRECT
218
  ### 非 IP 类规则
219
  - RULE-SET,reject_non_ip,REJECT
220
  - RULE-SET,reject_domainset,REJECT
221
  - RULE-SET,reject_non_ip_drop,REJECT-DROP
222
  - RULE-SET,reject_non_ip_no_drop,REJECT
223
  - RULE-SET,cdn_domainset,节点选择
224
  - RULE-SET,cdn_non_ip,节点选择
225
  - RULE-SET,stream_non_ip,Stream
226
  - RULE-SET,telegram_non_ip,Telegram
227
  - RULE-SET,download_domainset,节点选择
228
  - RULE-SET,download_non_ip,节点选择
229
  - RULE-SET,apple_cdn,Apple
230
  - RULE-SET,apple_cn_non_ip,Apple
231
  - RULE-SET,apple_services,Apple
232
  - RULE-SET,microsoft_cdn_non_ip,Microsoft
233
  - RULE-SET,microsoft_non_ip,Microsoft
234
  - RULE-SET,ai_non_ip,ChatGPT
235
  - RULE-SET,global_non_ip,节点选择
236
  - RULE-SET,domestic_non_ip,全局直连
237
  - RULE-SET,direct_non_ip,全局直连
238
  - RULE-SET,lan_non_ip,全局直连
239

240
  ### IP 类规则
241
  - RULE-SET,reject_ip,REJECT
242
  - RULE-SET,telegram_ip,Telegram
243
  - RULE-SET,stream_ip,Stream
244
  - RULE-SET,lan_ip,全局直连
245
  - RULE-SET,domestic_ip,全局直连
246
  - RULE-SET,china_ip,全局直连
247
  - GEOIP,CN,全局直连
248
  - MATCH,漏网之鱼

展开收起

软件下载(Win/Mac/Linux通用)#

https://github.com/mihomo-party-org/mihomo-party/releases

https://github.com/clash-verge-rev/clash-verge-rev/releases

Windows 更新阻止程序 v1.8

Tue, 13 May 2025 00:00:00 GMT

与以前版本的 Windows 相比，Windows 11 和 10 对操作系统更新行为的 UI 控制较少，没有使用控制面板或设置关闭 Windows 更新的选项Windows 11 和 Windows 10 中的应用程序会自动检查更新并安装任何找到的更新，无论您是否喜欢。这项新功能实际上对大多数用户来说非常方便。如果您想控制更新过程，可以禁用 Windows 更新服务。这需要您打开服务管理器，找到该服务并更改其启动参数和状态。之后，每当您希望操作系统检查更新时，您都必须再次启用该服务（这看起来并不那么容易）。

Windows 更新阻止程序主要

Windows Update Blocker 是一款免费软件，只需单击按钮即可帮助您彻底禁用或启用 Windows 系统上的自动更新。此实用程序是便携式的，这意味着您无需再经历安装过程，并且卸载后硬盘上不会留下任何残留物。如果您将程序文件放置到外部数据设备中，就可以随身携带 Windows Update Blocker，并在您接触的任何计算机上使用它，只要您的计算机配置正确，并且不想冒险让更新搞乱系统。此实用程序就是为这样的人准备的。

工作原理

下载后，将 Windows Update Blocker 解压到所需位置，然后运行它

windows 更新阻止程序被阻止

服务状态图标将显示您的 Windows 更新服务状态，如果您想阻止自动 Windows 更新，请选择“禁用服务”并单击“立即应用”按钮，保护服务设置可以防止不受控制的更改（推荐）。

如何阻止其他服务并保护设置

Windows 更新阻止程序新版本允许用户将任何其他服务添加到 Wub.ini 文件中以阻止它，首先请编辑 Wub.ini 文件并在“dosvc=2,4”行下添加所需的服务名称，例如，如果您想阻止“Windows 更新医疗服务”，请打开服务并找到它

Windows 服务

然后单击它并复制服务名称

Windows 更新医疗服务

在 dosvc=2,4 行下写入或粘贴服务名称

wub.ini 文件

最后打开 Windows 更新阻止程序，然后点击“立即应用”按钮。如果您想在一段时间后删除最近添加的服务，请按照以下步骤操作：

1. 打开 Windows Update Blocker，选择“启用服务”选项，然后点击“立即应用”按钮。

2. 从 Wub.ini 文件中删除所需的服务行。

3. 现在，您可以选择“禁用服务”和“保护服务设置”选项。

服务列表选项

在“菜单”按钮下有一个“服务列表选项”选项，点击后会弹出“服务列表选项”窗口。通过此图形用户界面，您可以轻松控制已添加到 Wub.ini 部分的服务。您最多可以向 Wub.ini 添加 25 个服务。Wausrv 服务仅供参考，因此您无法对其进行编辑。

Wub 服务列表选项

注意：如果 Windows 更新服务无法启动，或者即使您已启用 Windows 更新，仍然出现问题，请重启系统并重试。关闭Windows 更新后，某些 Windows 进程或程序可能会尝试打开并修复 Windows 更新，**从而导致 Windows 更新损坏。**如果重启系统后更新仍未打开，请使用Microsoft提供的 Windows 更新疑难解答

Windows Update Blocker 支持命令行选项来自动执行 Windows Update Blocker 任务：

Windows 更新阻止程序 Cmd 参数

注意： Wub 软件不会阻止 Microsoft Defender 更新。

支持的操作系统： Windows 11、Windows 10、Windows 8.1、Windows 8、Windows 7、Windows Vista、Windows XP（32\64 位）。

**支持的语言：**英语、土耳其语、德语、希伯来语、斯洛文尼亚语、法语、俄语、葡萄牙语、意大利语、波兰语、西班牙语、捷克语、乌克兰语、希腊语、匈牙利语、简体中文、繁体中文、葡萄牙语（巴西）、泰语、阿拉伯语、韩语、越南语、日语、印尼语、波斯语、瑞典语、泰语、格鲁吉亚语、丹麦语（丹麦语）、阿尔巴尼亚语、阿塞拜疆语、保加利亚语、塞尔维亚语、乌兹别克语、塔吉克语、阿布哈兹语、罗马尼亚语、斯洛伐克语、僧伽罗语、马其顿语、克罗地亚语、立陶宛语、土库曼语、荷兰语（荷兰）、荷兰语（迪迪埃）

文件：Wub_x64.exe │ Virustotal
MD5：9d6778f7f274f7ecd4e7e875a7268b64
SHA1：452fa439f1cc0b9fcc37cf4b8cfff96e8cc348aa

文件：Wub.exe │ Virustotal
MD5：82aff8883099cf75462057c4e47e88ac
SHA1：68e2939f59b3869e9bd3ecc4aca3947649631bf8

原文链接: https://www.sordum.org

[自用]win永久激活,非工具

Mon, 12 May 2025 00:00:00 GMT

近日，微软终于发布公告，正式宣布关闭 Windows 免费升级通道，并对服务器进行了限制，阻止此前常用的激活工具发起请求。这意味着，那些依赖“旧方法”进行激活的用户将不再能够绕过验证。

massgrave.dev 推出新激活方案⚙️🆕#

虽然官方路径被封堵，但来自 massgrave.dev 团队的开发者们迅速研究出了一种全新的激活方法，并且经过多位用户实测（包括笔者在虚拟机中的 Windows 11 专业工作站版），激活成功！

该方法无需繁琐操作，只需下载并运行一个脚本，即可获得永久的数字许可证激活。不仅适用于 Windows，连 Office 也能轻松搞定。

使用方法 📝🔧#

右键点击「开始菜单」 → 选择「PowerShell」或「终端」（不是 CMD）
复制并粘贴下方命令，按下 Enter：
`irm https://massgrave.dev/get | iex`
若提示需要管理员权限，请点击「允许」。
屏幕会出现激活选项，按数字键操作即可：
- 1：激活 Windows
- 2 → 1：激活 Office

功能一览 📦✨#

✅ HWID（数字许可证）激活法 – 永久激活 Windows 系统
✅ Ohook 激活法 – 永久激活 Office 软件
✅ KMS38 激活法 – 激活 Windows/Server 至 2038 年
✅ Online KMS 激活法 – 有效期 180 天，支持自动续订
✅ 高级激活故障排查工具
✅ 支持预激活的 OEMOEMOEM 文件夹
✅ Windows 版本切换工具
✅ 激活状态检查工具
✅ 支持合一文件和单文件版本
✅ 完全开源，基于 Batch 脚本
✅ 更少的杀毒软件报毒率

🔗 使用文档与脚本主页：massgrave.dev

【已封车】白嫖Adobe,Jetbrains,chatGPT,Office 365

Wed, 30 Apr 2025 00:00:00 GMT

这篇文章将教你如何快速注册 SJSU（San Jose State University）学生邮箱，并通过这个邮箱获取一系列超值的教育优惠服务，包括 JetBrains、Office 365、Adobe、ChatGPT EDU PLUS 等。动动手指，你就能享受到高达上千元的正版软件服务！

先看成果#

第一步,注册SJSU学生邮箱#

首先去注册地址里填写个人信息,去网站随便找个信息填上就行.身份生成

然后等待一天,回收一个一个邮件

第二步,收到后激活你想要的产品#

大多数收到邮件后,去登录然后会提示无法登录,是因为要去重置一下密码,然后5分钟解锁账户

先去 https://sjsuone.sjsu.edu/sjsuone/resetpassword/ 重置密码,然后5分钟后在登录!

再次期间去下载校园网VPN(这个很重要,因为你去验证的时候都是需要校园网络的)

请先下载cisco-secure-client.zip后进行操作下一步

然后再软件中添加:

1
vpn.sjsu.edu

看到这些信息,证明你离成功接近一半了

第三步,去申请服务#

Adobe 学生邮箱可以直接登录，并没有什么东西，需要申请，一天就通过申请了

Jetbrains 直接去用教育邮箱注册,秒下号

Office 365，学生邮箱登录即可，基本全部都有，OneDrive 是 1T，还可以使用 Microsoft 365 Copilot

ChatGpt EDU PLUS 学生免费两个月

参考文章#

https://linux.do/t/topic/592434

用 Python 写个双色球青龙通知脚本，再也不用下那些流氓 App

Wed, 30 Apr 2025 00:00:00 GMT

在生活中我们常常遇到这种情况：只想简单看看双色球开奖号码，却被强制要求下载各种 App 📲。
这些 App 不是广告满天飞 💥，就是界面臃肿卡顿 🐢，甚至还可能偷偷获取隐私信息 😒。

于是我决定：自己动手，用 Python 写一个脚本，自动获取开奖号码并通过青龙面板发送通知 📬！
干净、快速、自由，想看就看，拒绝被绑架。

🎯 开发目标#

✅ 自动获取每日双色球开奖信息
✅ 通过青龙定时任务推送通知（支持 Bark / 钉钉 / Telegram 等）
✅ 无需手动操作，全自动运行

⚙️ 技术选型#

📝 Python 3：脚本首选语言，灵活高效
📡 requests：拉取开奖信息
🧹 json & re：处理数据内容
🧭 青龙面板：定时执行 & 多渠道通知

🔗 开奖数据来源#

为了确保数据准确可靠，我选用了中彩网或其他公开接口作为数据源 🧮。

示例接口返回内容如下：

1
{
2
    "issue": "2025047",
3
    "openTime": "2025-04-29",
4
    "frontWinningNum": "01 14 21 22 23 31",
5
    "backWinningNum": "12",
6
    "seqFrontWinningNum": "14 22 31 23 01 21",
7
    "seqBackWinningNum": "12",
8
    "saleMoney": "364051920",
9
    "r9SaleMoney": "",
10
    "prizePoolMoney": "2211042881",
11
    "week": "星期二",
12
    "winnerDetails": [
13
        {
14
            "awardEtc": "1",
15
            "baseBetWinner": {
16
                "remark": "一等奖",
17
                "awardNum": "4",
18
                "awardMoney": "10000000",
19
                "totalMoney": ""
20
            },
21
            "addToBetWinner": "",
22
            "addToBetWinner2": "",
23
            "addToBetWinner3": ""
24
        },
25
        {
26
            "awardEtc": "2",
27
            "baseBetWinner": {
28
                "remark": "二等奖",
29
                "awardNum": "174",
30
                "awardMoney": "152770",
31
                "totalMoney": ""
32
            },
33
            "addToBetWinner": "",
34
            "addToBetWinner2": "",
35
            "addToBetWinner3": ""
36
        },
37
        {
38
            "awardEtc": "3",
39
            "baseBetWinner": {
40
                "remark": "三等奖",
41
                "awardNum": "929",
42
                "awardMoney": "3000",
43
                "totalMoney": ""
44
            },
45
            "addToBetWinner": "",
46
            "addToBetWinner2": "",
47
            "addToBetWinner3": ""
48
        },
49
        {
50
            "awardEtc": "4",
51
            "baseBetWinner": {
52
                "remark": "四等奖",
53
                "awardNum": "47377",
54
                "awardMoney": "200",
55
                "totalMoney": ""
56
            },
57
            "addToBetWinner": "",
58
            "addToBetWinner2": "",
59
            "addToBetWinner3": ""
60
        },
61
        {
62
            "awardEtc": "5",
63
            "baseBetWinner": {
64
                "remark": "五等奖",
65
                "awardNum": "1005016",
66
                "awardMoney": "10",
67
                "totalMoney": ""
68
            },
69
            "addToBetWinner": "",
70
            "addToBetWinner2": "",
71
            "addToBetWinner3": ""
72
        },
73
        {
74
            "awardEtc": "6",
75
            "baseBetWinner": {
76
                "remark": "六等奖",
77
                "awardNum": "9948912",
78
                "awardMoney": "5",
79
                "totalMoney": ""
80
            },
81
            "addToBetWinner": "",
82
            "addToBetWinner2": "",
83
            "addToBetWinner3": ""
84
        }
85
    ]
86
}

展开收起

💻 代码示例#

1
import requests
2
import time
3
import random
4
import json
5
import re
6
import notify
7

8
# 生成动态参数以避免缓存
9
current_timestamp = int(time.time() * 1000)
10
tt_value = random.random()
11
callback_timestamp = current_timestamp - 1
12

13
url = (
14
    "https://jc.zhcw.com/port/client_json.php?"
15
    f"callback=jQuery1122029918790071673307_{callback_timestamp}&"
16
    "transactionType=10001001&"
17
    "lotteryId=1&"
18
    "issueCount=30&"
19
    "startIssue=&"
20
    "endIssue=&"
21
    "startDate=&"
22
    "endDate=&"
23
    "type=0&"
24
    "pageNum=1&"
25
    "pageSize=1&"
26
    f"tt={tt_value}&"
27
    f"_={current_timestamp}"
28
)
29

30
headers = {
31
    "Accept": "*/*",
32
    "Accept-Language": "zh-CN,zh-TW;q=0.9,zh;q=0.8,en;q=0.7",
33
    "Cache-Control": "no-cache",
34
    "Connection": "keep-alive",
35
    "Cookie": "PHPSESSID=bi2vu7nn8gdqvg79ggal0bmvq0",
36
    "Pragma": "no-cache",
37
    "Referer": "https://www.zhcw.com/",
38
    "Sec-Fetch-Dest": "script",
39
    "Sec-Fetch-Mode": "no-cors",
40
    "Sec-Fetch-Site": "same-site",
41
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
42
    "sec-ch-ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
43
    "sec-ch-ua-mobile": "?0",
44
    "sec-ch-ua-platform": '"Windows"',
45
}
46

47
response = requests.get(url, headers=headers)
48
response_text = response.text
49
# 清理字符串以获取有效的JSON对象
50
start_index = response_text.find('(') + 1
51
end_index = response_text.rfind(')')
52

53
json_str = response_text[start_index:end_index]
54

55
# 解析JSON字符串
56
parsed_data = json.loads(json_str)
57

58
# 提取"data"中的信息
59
data_info = parsed_data.get('data', [])
60

61
# 遍历每个数据项（在这个例子中只有一个）
62
for data in data_info:
63
    # 数据解析（建议添加类型校验）
64
    red_numbers = data.get('frontWinningNum', '').split()  # 前区红球
65
    blue_number = data.get('backWinningNum', '')           # 后区蓝球
66
    open_time = data.get('openTime', '未知时间')
67
    week = data.get('week', '未知星期')
68
    issue = data.get('issue', '未知期号')
69

70
    # 动态生成红球HTML
71
    red_balls = '\n'.join([
72
        f'<div style="width:40px;height:40px;background:#e74c3c;border-radius:50%;color:white;'
73
        f'display:flex;align-items:center;justify-content:center;font-weight:bold;">{num}</div>'
74
        for num in red_numbers
75
    ])
76

77
    # 构建HTML模板
78
    message = f'''
79
    <div style="background:#f8f9fa;padding:20px;border-radius:12px;font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;">
80
        <h2 style="color:#2d3436;margin:0 0;border-bottom:2px solid #e74c3c;display:flex;">
81
            <span style="font-size:1.2em;margin-right:8px;">🎉</span>双色球开奖公告
82
        </h2>
83

84
        <div style="color:#636e72;display: flex">
85
            <span style="color:#e74c3c;">📅 {open_time} {week}</span>
86
            <span style="margin:0 8px">|</span>
87
            <span>第{issue}期</span>
88
        </div>
89

90
        <div style="display:flex;flex-wrap:wrap;gap:8px;">
91
            <!-- 红球 -->
92
            {red_balls}
93

94
            <!-- 蓝球 -->
95
            <div style="width:40px;height:40px;background:#3498db;border-radius:50%;color:white;
96
                 display:flex;align-items:center;justify-content:center;font-weight:bold;">{blue_number}</div>
97
        </div>
98

99
        <div style="color:#636e72;display: flex">
100
            <span>⏰ 开奖时间：20:30（每周二、四、日）</span>
101
            <span style="margin:0 8px">|</span>
102
            <span>📞 客服电话：95086</span>
103
        </div>
104
    </div>
105
    '''
106

107
    notify.send("双色球", message)

展开收起

🕒 青龙定时任务配置#

把脚本放进青龙的脚本目录，然后设置每天晚上开奖时间后自动执行 🧠。

🗓 定时任务规则：

0 22 * * 2,4,0

📱 效果展示#

每天开奖后，手机立即收到通知👇：

支付宝面对面对接个人赞赏页

Tue, 25 Feb 2025 00:00:00 GMT

📌 项目背景#

在个人博客/自媒体场景中，接收读者小额赞赏是常见的互动方式。基于支付宝的「面对面支付」接口，我开发了一个轻量级赞赏页，支持金额选择、动态二维码生成、捐赠记录展示等功能。核心代码基于PHP+MySQL实现，无需依赖复杂框架，适合个人快速部署

🚀 核心功能拆解#

动态支付二维码生成

1
// 调用第三方API生成二维码（示例）
2
<img src="https://api.qrtool.cn/?text=<?php echo urlencode($qrCode); ?>">

通过alipays://协议深度链接唤起支付宝APP
移动端自动识别设备类型，显示「点击跳转支付宝」按钮

捐赠记录实时展示

1
// 数据库查询最新66条记录
2
$sql = "SELECT * FROM donations ORDER BY created_at DESC LIMIT 66";
3
while($row = $result->fetch_assoc()) {
4
    echo '<li>网友'.$row.'赠送：'.$row.'</li>';
5
}

采用瀑布流式滚动设计
统计总金额和捐赠人次（SQL聚合查询）

支付状态轮询机制

1
// 每5秒轮询支付状态
2
setInterval(function() {
3
    $.ajax({ url: "/pay/query.php?action=serve", data: { gid: "<?php echo $orderId; ?>" } });
4
}, 5000);
5

6
// 60秒自动刷新防重复支付
7
setTimeout(() => window.location.reload(), 60000);

参考支付宝官方推荐的轮询策略
前端使用Layer.js实现支付成功弹窗提示

🔧 技术亮点#

设备自适应设计
通过isMobile()函数检测设备类型，动态切换H5/PC布局：

1
function isMobile() {
2
    $ua = $_SERVER ?? '';
3
    return (strpos($ua, 'Mobile') !== false) || (strpos($ua, 'MicroMessenger') !== false);
4
}

防重复支付设计

生成带时间戳的订单号createNewOrderNo()
数据库记录支付请求参数和状态

安全增强措施

使用htmlspecialchars()过滤用户输入
限制二维码有效期为60秒
关键参数加密传输（示例未展示具体实现）

📊 数据统计展示#

通过底部统计模块直观展示捐赠影响力：

1
$sql_stats = "SELECT COUNT(*) as total_count, SUM(amount) as total_amount FROM donations";
2
echo "共有[{$stats['total_count']}]位暖心人捐赠，总计[{$stats['total_amount']}]元";

数字动态更新，增强用户参与感
采用「恰饭」「零食」等趣味化文案

💡 开发心得#

支付宝接口选择
个人开发者推荐使用「当面付」或「电脑网站支付」接口，前者无需营业执照即可申请
性能优化点

使用CDN加载Bootstrap/jQuery（减少服务器压力）
捐赠记录分页加载（当前示例限制66条）

扩展可能性

接入微信支付实现双渠道收款
添加打赏留言功能（需注意内容审核）
数据可视化图表展示

源码结构参考：
donate ├── config/
│ └── db.php # 数据库配置文件
│
├── pay/
│ ├── pay.php # 支付宝支付核心处理类
│ ├── pay_template.php # 支付页面模板
│ ├── query.php # 支付状态查询处理
│ └── public/ # 支付页面静态资源
│ ├── style.css
│ └── jquery.min.js
│
├── style/
│ ├── css/
│ │ └── style.css # 主页样式文件
│ └── js/
│ ├── jquery-3.2.1.min.js
│ ├── layer/ # layer弹窗组件
│ │ └── layer.js
│ └── style.js # 主页JS逻辑
│
├── sql/
│ ├── donation.sql # 捐赠记录表结构
│ └── orders.sql # 订单表结构
│
├── favicon.ico # 网站图标
└── index.php

✒️ 修改配置#

修改pay/pay.php中的支付宝参数

1
define('ALIPAY_APPID', '你的支付宝APPID');
2
define('ALIPAY_PRIVATE_KEY', "-----BEGIN RSA PRIVATE KEY-----\n" .
3
    "你的支付宝应用私钥" .
4
    "\n-----END RSA PRIVATE KEY-----");
5

6
define('ALIPAY_PUBLIC_KEY', "-----BEGIN PUBLIC KEY-----\n" .
7
    "你的支付宝公钥" .
8
    "\n-----END PUBLIC KEY-----");

修改pay/pay.php中63行的默认值，创建订单的时候，f12查询元素然后复制链接即可

1
  return 'https://qr.alipay.com/你的默认收款标号';

🌐 效果预览#

演示图

通过这个项目，不仅实现了支付功能的技术验证，更深刻体会到「细节决定体验」—— 从自动换菜名的趣味交互，到支付成功的暖心提示，每一个微小设计都在传递温度

源码获取：

https://github.com/uurani/donate.git”>https://github.com/uurani/donate.git”>https://github.com/uurani/donate.git

演示地址：

https://donate.muxui.com/“>https://donate.muxui.com/“>https://donate.muxui.com/

PVE设置

Sat, 22 Feb 2025 00:00:00 GMT

基础设置#

1. 合并硬盘分区#

1.1 删除local-lvm#

1
lvremove pve/data

1.2 扩容local#

1
lvextend -l +100%FREE -r pve/root

1.3 然后数据中心进行图形界面的local-lvm删除和local编辑。#

2. 确认网络是否正常#

ping www.baidu.com 如果ping不通，修改网关和dns。

3. 更换软件源#

1
https://mirrors.tuna.tsinghua.edu.cn/help/debian

1
nano /etc/apt/sources.list

添加网页上的内容，保存退出。

建议全部修改成清华源：

1
deb https://mirrors.tuna.tsinghua.edu.cn/debian-security bookworm-security main contrib non-free non-free-firmware

4. 修改pve源#

4.1 添加清华源#

1
https://mirrors.tuna.tsinghua.edu.cn/help/proxmox

1
nano /etc/apt/sources.list.d/pve-no-subscription.list

加入内容

1
deb https://mirrors.tuna.tsinghua.edu.cn/proxmox/debian/pve bookworm pve-no-subscription

4.2 去掉企业源#

1
nano /etc/apt/sources.list.d/pve-enterprise.list

前面加入#

4.3 去掉ceph源（有需要的可以之后自行修改）#

1
nano /etc/apt/sources.list.d/ceph.list

前面加入#

PVE更新—存储库里面添加pve-no-subscription

5. 去掉登录弹窗：#

1
sed -i.backup -z "s/res === null || res === undefined || \!res || res\n\t\t\t.data.status.toLowerCase() \!== 'active'/false/g" /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js && systemctl restart pveproxy.service

6. 更新软件源，升级软件#

1
apt update
2

3
apt upgrade -y

7. 开启IPV6（可选）#

1
nano /etc/sysctl.conf

添加如下内容：

1
net.ipv6.conf.all.accept_ra=2
2

3
net.ipv6.conf.default.accept_ra=2
4

5
net.ipv6.conf.vmbr0.accept_ra=2
6

7
net.ipv6.conf.all.autoconf=1
8

9
net.ipv6.conf.default.autoconf=1
10

11
net.ipv6.conf.vmbr0.autoconf=1

重启系统：reboot

硬盘直通

1. 查看硬盘信息#

1
ls -l /dev/disk/by-id/

2. 设置硬盘直通#

1
qm set 100 -sata1 /dev/disk/by-id/ata-WDC_WD5000AAKX-753CA1_WD-WMAYU7283459
2

3
qm set 100 -sata2 /dev/disk/by-id/ata-WDC_WD5000AAKX-00ERMA0_WD-WCC2E6DHKRCX
4

5
qm set 100 -sata3 /dev/disk/by-id/ata-WDC_WD5000AAKX-08U6AA0_WD-WCC2E2LDAVCN

3. 解除硬盘直通#

1
qm set 100 -sata1 none
2

3
qm set 100 -sata2 none
4

5
qm set 100 -sata3 none

Adobe Photoshop 2023

Thu, 20 Feb 2025 00:00:00 GMT

介绍#

Adobe Photoshop（PS）是Adobe公司推出的一款顶尖图像编辑与设计软件，它集成了最先进的内容识别填充技术和Adobe Sensei AI技术，使用户能够精确选择填充像素，轻松进行图像的旋转、缩放和镜像处理。作为Adobe系列中最受欢迎的图像处理工具，Photoshop拥有强大的图像选择、修饰、逼真绘画以及广泛的工作流程和性能增强功能，几乎是每个创意项目的核心。Photoshop不仅能够帮助用户将想象力转化为现实，还彻底革新了日常摄影，提供了专业的摄影工具组合，支持剪切、移除物体、合成照片等编辑操作，让色彩和效果的处理游刃有余。它为设计师提供了强大的设计工具，无论是海报、包装、横幅还是网站设计，都能从Photoshop开始。此外，Photoshop提供了强大的画笔工具，包括超过1000款由知名插画家Kyle T. Webster设计的笔刷，让插画创作更加灵动。它还具备快速填充和自然真实的模糊效果，通过对象选择工具和强化的变形功能，以及改进的属性面板和新预设，为用户提供了更多的创造性控制和便利。

截图#

Adobe Photoshop

功能#

修图、替换、合成等等#

让肖像更生动，面部表情更具表现力。只需一次鼠标点击，就可以替换背景中的天空。删除物体、修图、改变颜色。借助强大的编辑工具和新的智能功能，可以创建出惊人的效果，将图形工作转化为真正的艺术。

图形设计的全能工具#

海报、包装、横幅、网站——图形设计从Photoshop开始。将照片、图表和文本组合成全新的图像。只需一次鼠标点击就可以选择物体。通过播放颜色和效果来改善任何项目。

千款惊艳画笔#

使用各种专用画笔进行绘画，或者创建自己的画笔——世界上最大的Photoshop画笔库始终在您手边。

追随灵感#

混合照片、图形、效果和神经滤镜，将任何照片转化为艺术作品。借助一键选择、自动遮罩和几乎无限的图层，您可以快速创建出相机无法实现的效果。

生成式AI开创新时代#

借助有史以来最惊人的Photoshop版本，大步迈向未来。利用Adobe Firefly的强大力量，使用生成填充和生成扩展功能，在图像中添加、删除或扩展内容。欢迎试用，亲眼见证。

为您的业务注入创意#

陶瓷艺术家Chinzalée Sonami在网上和全国各地的商店销售她的彩色陶器。她可以在Adobe Photoshop中更换背景，以更新其宣传海报和广告的外观。

打造精美品牌#

Meg Lewis设计虚拟背景和图形，在社交媒体上展示其风格并扩展业务。Adobe Photoshop为她提供了无尽的方式来混合图像并创作独特的作品。

打造完美肖像#

人们的照片可以吸引客户。通过Adobe Photoshop，您可以自动调整主体的特征和姿势，无需重新拍摄或搜索新的库存图片。

您制作精美Instagram图像的必备工具#

Photoshop可以轻松移除瑕疵，使纽约的Nice Day Chinese Takeout餐厅能快速制作令人垂涎三尺的社交帖文和图形。

制作签名作品并快速分享#

设计师兼插画家Aries Moross使用Photoshop笔刷进行绘图和上色，将字母转变为艺术表现形式。借助此应用程序的协作工具，他们可以与客户顺畅地共享作品以供审查和批准。

浏览新增功能的作用#

Adobe Photoshop一直在推出新功能，让任何人都能以更快速、更聪明的方式使用。欢迎查看一些最新更新。另外，您还可以使用Photoshop网页版在线编辑图像。

一瞬间将最狂野的梦想转化为令人惊叹的图像#

生成填充是令人惊叹的生成式AI工具，可以提升您的创造力并加快工作流程。只需要使用简单的文字提示，就可以执行复杂的编辑操作，并获得高品质的成果。您可以采用不具破坏性的方式添加、扩展和删除图像内容，保持一切在您的掌控之下。

快速扩展图像#

使用生成扩展，只需几个步骤就可以扩展图像。只需使用“裁剪”工具点击并拖动到图像的边界之外，就可以使用与现有图像融合的新生成内容顺畅地填充扩展的画布。增加外观比例以及将人像照片变成风景照，并重新处理图像，使其符合网站、社交媒体等的尺寸。

只需几个步骤，就可以改变图像的外观#

使用30多款新的调整预设集，大幅改变图像的外观。让鼠标停留以预览、点击以应用您最喜欢的项目，然后随心所欲地调整结果，创作出完全独特的作品。

使用后续步骤建议进行编辑#

快显工作栏是一个浮动菜单，可以根据您正在执行的操作显示相关功能，并加速遮色片和生成式AI工作流程。直接点击菜单中的建议，就可以简化您的流程。

使大型物体消失#

使用“移除工具”在大面积的形状上刷过或圈选，就可以自动填入与其周围环境相符的内容，同时保留复杂背景中的物体细节和深度，从而创造无缝的编辑内容。