星屿浅奈 ✧ Saneko

忘记关闭自动扣费的教训

Fri, 03 Apr 2026 09:04:08 GMT

去年 5 月，我正在折腾一个 WPF 样式库，想给 TButton 组件加上好看的动画图标。找了一大圈开源素材都不太满意，最后碰巧发现了 Lordicon。

这网站的图标确实精致，但好东西基本都要 Pro 会员。为了项目效果，我咬咬牙买了一个月的 Pro。结果付完款，完全忘了去后台关掉自动续费。

大半年过去了，项目早就不弄了。直到今年 3 月底看账单，才发现有一笔来路不明的扣费。点开详情一看，天塌了。

就因为忘了点个取消按钮，白白扔了 1000 多块钱。

这笔钱虽然不多，但也够让人肉疼好一阵子了。写下这篇博客，主要是给自己长个记性，也顺便提醒一下大家：不管开通什么订阅，付完钱的第一件事就是去找“Cancel Subscription”或者“Auto-renewal”把它关掉！ 别太相信自己的记性。

Waline 评论配置自定义邮件通知

Fri, 06 Mar 2026 15:37:50 GMT

import { LinkPreview } from 'astro-pure/advanced' import { Aside } from 'astro-pure/user'

本文介绍如何为 Waline 配置评论邮件通知，涵盖 SMTP 设置、环境变量配置与自定义邮件模板。以 Vercel 部署为例，其他平台可对照 Waline 官方文档操作。

部署 Waline

按官方文档完成 Waline 部署即可：

获取 SMTP 授权码

Waline 通过 SMTP 发送邮件，需使用授权码而非邮箱登录密码。建议使用专门用于发信的邮箱。

以 163 邮箱为例：登录网页版 → 设置 → POP3/SMTP/IMAP → 开启 POP3/SMTP 与 IMAP/SMTP 服务 → 获取并保存授权码（后续填入 SMTP_PASS）。

配置环境变量

打开 Vercel Dashboard，进入你的 Waline 项目。
进入 Settings → Environment Variables。
点击 Add New，依次配置以下环境变量：

| 环境变量 | 说明 | 举例 | |----------|------|------| | SMTP_SERVICE | SMTP 服务提供商；邮箱支持列表 | 163 | | SMTP_HOST | SMTP 服务器地址，可在邮箱设置中查看。 | smtp.163.com | | SMTP_PORT | SMTP 端口。 | 465 | | SMTP_USER | SMTP 邮件发送服务的用户名，一般为登录邮箱。 | yourname@163.com | | SMTP_PASS | SMTP 密码；163 邮箱须填 SMTP 授权码（见上文），不能填登录密码。 | 上一步获取的授权码 | | SMTP_SECURE | 是否使用 SSL。 | true | | SITE_NAME | 网站名称，会在邮件中展示。 | Saneko | | SITE_URL | 网站地址。 | https://你的域名 | | AUTHOR_EMAIL | 博主邮箱，用于接收新评论通知（博主自己的评论不通知）。 | yourname@163.com | | SENDER_NAME | 自定义发件人名称。 | Saneko | | SENDER_EMAIL | 自定义发件地址，通常与 SMTP_USER 一致。 | yourname@163.com |

保存所有变量后，在项目中选择 Redeploy 重新部署，使环境变量生效。

自定义邮件模板

以下模板支持亮色/暗色自适应，可按需修改样式后填入对应环境变量。

新评论通知（发给博主）

在环境变量中添加 MAIL_TEMPLATE，值为下方 HTML（整段复制，保留为单段即可）。

<div style="margin: 0; padding: 40px 0; background-color: #fcfcfd; color: #09090b; font-family: Satoshi, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;">
    <style>
        /* Dark mode support */
        @media (prefers-color-scheme: dark) {
            .email-body { background-color: #0B0B10 !important; color: #f4f4f5 !important; }
            .card { background-color: #18181b !important; border-color: #27272a !important; }
            .text-muted { color: #a1a1aa !important; }
            .bg-muted { background-color: #27272a !important; }
            .text-primary { color: #8C766D !important; }
        }
    </style>
    
    <!-- Main Container -->
    <div class="email-body" style="max-width: 600px; margin: 0 auto; padding: 0 20px;">
        
        <!-- Card -->
        <div class="card" style="background-color: #ffffff; border: 1px solid #e4e4e7; border-radius: 16px; overflow: hidden; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
            
            <!-- Brand Header Inside Card -->
            <div style="text-align: center; padding: 32px 0 0 0;">
                <a href="{{site.url}}" style="text-decoration: none; color: #09090b; font-weight: 600; font-size: 20px; letter-spacing: -0.5px;">
                    <span style="color: #8C766D;">✦</span> {{site.name}}
                </a>
            </div>

            <!-- Header -->
            <div style="padding: 24px 24px 0 24px;">
                <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 8px;">
                    <h1 style="margin: 0; font-size: 18px; font-weight: 600; color: #09090b; display: flex; align-items: center; gap: 8px;">
                        <!-- MessageSquarePlus Icon -->
                        <img src="https://api.iconify.design/lucide:message-square-plus.svg?color=%238C766D" width="20" height="20" style="vertical-align: text-bottom;" alt="">
                        <span>新的评论</span>
                    </h1>
                    <span style="font-size: 12px; font-weight: 500; background-color: #f4f4f5; color: #71717a; padding: 4px 10px; border-radius: 9999px;">NEW</span>
                </div>
                <p class="text-muted" style="margin: 0; font-size: 14px; color: #71717a; line-height: 1.5;">
                    有人在 <strong>{{site.name}}</strong> 留下了新的足迹。
                </p>
            </div>

            <!-- Content -->
            <div style="padding: 24px;">
                
                <!-- Comment Block -->
                <div class="bg-muted" style="background-color: #f4f4f5; border-radius: 12px; padding: 20px; margin-bottom: 24px; border: 1px solid transparent;">
                    <div style="font-size: 15px; color: #09090b; line-height: 1.6;">
                        {{self.comment | safe}}
                    </div>
                </div>

                <!-- Meta Info -->
                <div style="display: flex; flex-direction: column; gap: 12px; font-size: 13px; color: #71717a; border-top: 1px dashed #e4e4e7; padding-top: 20px;">
                    <div style="display: flex; align-items: center; gap: 8px;">
                        <img src="https://api.iconify.design/lucide:user.svg?color=%23a1a1aa" width="16" height="16" alt="">
                        <span><strong>{{self.nick}}</strong> ({{self.mail}})</span>
                    </div>
                    <div style="display: flex; align-items: center; gap: 8px;">
                        <img src="https://api.iconify.design/lucide:link.svg?color=%23a1a1aa" width="16" height="16" alt="">
                        <a href="{{site.postUrl}}" style="color: #71717a; text-decoration: none; border-bottom: 1px solid #e4e4e7; padding-bottom: 1px;">{{site.postUrl}}</a>
                    </div>
                </div>

                <!-- Action Button -->
                <div style="margin-top: 32px;">
                    <a href="{{site.postUrl}}" style="display: inline-block; background-color: #09090b; color: #ffffff; text-decoration: none; padding: 10px 24px; border-radius: 9999px; font-size: 14px; font-weight: 500; transition: opacity 0.2s;">
                        查看并回复
                    </a>
                </div>

            </div>
            
            <!-- Footer in Card -->
            <div class="bg-muted" style="background-color: #fafafa; border-top: 1px solid #e4e4e7; padding: 24px; font-size: 12px; color: #a1a1aa; text-align: center;">
                <p style="margin: 0;">此邮件由系统发送，请不要回复此邮件</p>
            </div>

        </div>

    </div>
</div>

回复通知（发给被回复用户）

在环境变量中添加 MAIL_TEMPLATE_ADMIN，值为下方 HTML（当有人回复评论时，被回复者将收到此模板邮件）。

<div style="margin: 0; padding: 40px 0; background-color: #fcfcfd; color: #09090b; font-family: Satoshi, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;">
    <style>
        /* Dark mode support */
        @media (prefers-color-scheme: dark) {
            .email-body { background-color: #0B0B10 !important; color: #f4f4f5 !important; }
            .card { background-color: #18181b !important; border-color: #27272a !important; }
            .text-muted { color: #a1a1aa !important; }
            .bg-muted { background-color: #27272a !important; }
            .text-primary { color: #8C766D !important; }
        }
    </style>
    
    <!-- Main Container -->
    <div class="email-body" style="max-width: 600px; margin: 0 auto; padding: 0 20px;">
        
        <!-- Card -->
        <div class="card" style="background-color: #ffffff; border: 1px solid #e4e4e7; border-radius: 16px; overflow: hidden; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
            
            <!-- Brand Header Inside Card -->
            <div style="text-align: center; padding: 32px 0 0 0;">
                <a href="{{site.url}}" style="text-decoration: none; color: #09090b; font-weight: 600; font-size: 20px; letter-spacing: -0.5px;">
                    <span style="color: #8C766D;">✦</span> {{site.name}}
                </a>
            </div>

            <!-- Header -->
            <div style="padding: 24px 24px 0 24px;">
                <h1 style="margin: 0; font-size: 18px; font-weight: 600; color: #09090b; display: flex; align-items: center; gap: 8px;">
                    <!-- MessageCircle Icon -->
                    <img src="https://api.iconify.design/lucide:message-circle.svg?color=%238C766D" width="20" height="20" style="vertical-align: text-bottom;" alt="">
                    <span>收到回复</span>
                </h1>
                <p class="text-muted" style="margin: 8px 0 0 0; font-size: 14px; color: #71717a; line-height: 1.5;">
                    你好，你在 <strong>{{site.name}}</strong> 的留言收到了新的回复。
                </p>
            </div>

            <!-- Content -->
            <div style="padding: 24px;">
                
                <!-- Quote Block (User's Comment) -->
                <div class="bg-muted" style="background-color: #f4f4f5; border-radius: 12px; padding: 16px; margin-bottom: 24px; border: 1px solid transparent;">
                    <div class="text-muted" style="font-size: 12px; font-weight: 500; color: #71717a; margin-bottom: 8px; text-transform: uppercase; letter-spacing: 0.5px;">You</div>
                    <div style="font-size: 14px; color: #09090b; line-height: 1.6; font-style: italic;">
                        {{parent.comment | safe}}
                    </div>
                </div>

                <!-- Reply Block (Admin's Reply) -->
                <div style="position: relative; padding-left: 16px; border-left: 2px solid #8C766D;">
                    <div style="font-size: 12px; font-weight: 600; color: #8C766D; margin-bottom: 8px;">{{self.nick}}</div>
                    <div style="font-size: 15px; color: #09090b; line-height: 1.6;">
                        {{self.comment | safe}}
                    </div>
                </div>

                <!-- Action Button -->
                <div style="margin-top: 32px;">
                    <a href="{{site.postUrl}}" style="display: inline-block; background-color: #09090b; color: #ffffff; text-decoration: none; padding: 10px 20px; border-radius: 9999px; font-size: 14px; font-weight: 500; transition: opacity 0.2s;">
                        查看完整对话
                    </a>
                </div>

            </div>
            
            <!-- Footer in Card -->
            <div class="bg-muted" style="background-color: #fafafa; border-top: 1px solid #e4e4e7; padding: 24px; font-size: 12px; color: #a1a1aa; text-align: center;">
                <p style="margin: 0;">此邮件由系统发送，请不要回复此邮件</p>
            </div>

        </div>

    </div>
</div>

添加或修改上述环境变量后，需在 Vercel 中 Redeploy 一次方可生效。

效果预览

配置完成并重新部署后，新评论与回复将触发如下样式的邮件：

新评论通知（博主收到）：

回复通知（被回复者收到）：

minecraft服务器被入侵

Sun, 07 Dec 2025 00:00:00 GMT

import { WeChatChat } from 'astro-pure/user' import { Aside } from 'astro-pure/user'

事情的起因

11月2号那天，一个很久没联系的大学室友突然找我，说想和他女朋友一起玩 Minecraft，问我有没有服务器。我之前的服务器早就停了，不过手头还有台闲置的华为云服务器，正好可以拿来用。

那就搞呗！我就在华为云上重新搭了个原版生存服务器，用的 fabric，加了一些生电模组，像 tweakoo 这些。

当时只开了正版验证，想着应该问题不大，就没开白名单。

刚开始一切都很顺利，我们按部就班地建了刷铁机、村民交易所、熔炉组，还搞了沼泽刷怪塔和守卫者农场，玩得挺开心的。

被入侵了

结果到了11月23号晚上，出事了...

当时已经晚上11点多了，我正准备睡觉。看到这个消息人都傻了，赶紧先把服务器关了，免得被破坏得更严重。

第二天还要上班，我就让室友先上号看看情况。结果一看，存档被毁得不成样子，刷铁机、农场、仓库全都被拆了，东西也被拿光了。

处理结果

下班回家后，我第一件事就是把白名单开了。还好之前加了备份脚本，用 !!pb back 把存档恢复到被入侵前的状态，不然真的就白玩了。

这次也算是给我自己提了个醒：

DeepSeek-Commit-Tool

Sun, 07 Dec 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user' import { Card } from 'astro-pure/user' import { GithubCard } from 'astro-pure/advanced'

前言

在日常开发工作中，无论是 GitHub 还是公司内部的 Gerrit，我们都需要频繁提交代码。然而，每次填写 commit 信息时，总是难以用简洁明了的语言完整概括本次修改的内容。这导致提交信息要么过于简单，要么冗长且不够规范。

为了解决这个问题，我开发了一个基于 DeepSeek API 的工具，能够自动分析代码变更并生成规范的 commit 信息，大大提升了提交效率。

下载

API 配置

环境变量配置

为了便于全局使用，建议将 dsc.exe 配置到系统环境变量中。这样可以在任意目录下直接使用该工具。

获取 API Key

访问 DeepSeek API 管理页面
登录你的 DeepSeek 账户
点击「创建新的 API Key」
复制生成的 API Key（格式类似：sk-xxxxx）

配置 API Key

通过以下命令配置你的 API Key：

dsc.exe --api-key sk-xxxxx

配置完成后，工具会将 API Key 保存到本地配置文件中，后续使用无需重复配置。

使用

在 SourceTree 中集成

SourceTree 是一款流行的 Git 图形化客户端，下面介绍如何在该工具中集成 DeepSeek-Commit-Tool。

步骤一：配置自定义操作

打开 SourceTree
依次点击工具 → 选项 → 自定义操作 → 添加
按照以下配置填写：
- 菜单标题：DeepSeek Commit
- 运行的脚本：dsc.exe（或完整路径）
- 参数：run $REPO
点击「确定」保存配置

步骤二：使用工具生成 Commit 信息

在项目中添加需要提交的文件到暂存区
暂存区任意位置右键，选择自定义操作 → DeepSeek Commit
工具会自动分析代码变更，并生成规范的 commit 信息

命令行使用

如果你习惯使用命令行，也可以直接在终端中运行：

# 在 Git 仓库根目录下执行
dsc.exe run

工具会自动读取当前仓库的变更，生成 commit 信息并显示在终端中。

twikoo邮件通知模板

Sat, 13 Sep 2025 00:00:00 GMT

写在前面

样式主要参考了kzhik的通知样式，很好看!

MAIL_TEMPLATE

<div
    style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
    <div
        style="border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); overflow: hidden; background-color: #ffffff;">
        <!-- 头部区域 -->
        <div
            style="background-color: #f8db8f; padding: 20px; color: white; display: flex; align-items: center; justify-content: center; gap: 20px;">
            <div style="text-align: center;">
                <div
                    style="font-size: 28px; font-weight: bold; display: flex; align-items: center; justify-content: center; gap: 10px;">
                    <span style="font-size: 26px;">👋</span> Hi ${PARENT_NICK} </div>
                <div style="margin-top: 10px; font-size:16px;"> 您在 <a href="${SITE_URL}"
                        style="color: white; text-decoration: underline; font-weight: 500;">${SITE_NAME}</a> 中收到一条新回复！
                </div>
            </div> <!-- 右侧图片 --> <img src="https://cdn.blog.saneko.me/Web/web_250913_194213.png"
                style="display:block; max-width:100px;">
        </div> <!-- 内容区域 -->
        <div style="padding: 25px 20px;"> <!-- 原评论部分 -->
            <div style="margin-bottom: 20px;">
                <div style="font-weight: bold; margin-bottom: 10px; color: #333; font-size: 16px;">您发表的评论：</div>
                <div style="background-color: #f5f7fa; border-radius: 6px; padding: 15px; border: 1px solid #ebf0f5;">
                    <div style="color: #f8db8f; font-weight: 500; margin-bottom: 8px;">@${PARENT_NICK}:</div>
                    <div style="color: #333; line-height: 1.6;">
                        <div style="margin-bottom: 5px;">${PARENT_COMMENT}</div>
                    </div>
                </div>
            </div> <!-- 收到的回复部分 -->
            <div style="margin-bottom: 30px;">
                <div style="font-weight: bold; margin-bottom: 10px; color: #333; font-size: 16px;">您收到的回复</div>
                <div style="background-color: #f5f7fa; border-radius: 6px; padding: 15px; border: 1px solid #ebf0f5;">
                    <div style="color: #f8db8f; font-weight: 500; margin-bottom: 8px;">@${NICK}:</div>
                    <div style="color: #333; line-height: 1.6;">${COMMENT}</div>
                </div>
            </div> <!-- 回复按钮 -->
            <div style="margin-bottom: 30px;"> <a href="${POST_URL}"
                    style="display: inline-block; background-color: #f8db8f; color: white; padding: 10px 20px; text-decoration: none; border-radius: 4px; font-weight: 500;">回复</a>
            </div> <!-- 系统提示 -->
            <div
                style="color: #86909c; font-size: 12px; text-align: center; padding-top: 15px; border-top: 1px solid #ebf0f5;">
                此邮件由系统发送，请不要回复此邮件 </div>
        </div>
    </div>
</div>

样式参考:

MAIL_TEMPLATE_ADMIN

<div
    style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
    <div
        style="border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); overflow: hidden; background-color: #ffffff;">
        <!-- 头部区域 -->
        <div
            style="background-color: #f8db8f; padding: 20px; color: white; display: flex; align-items: center; justify-content: center; gap: 20px;">
            <div style="text-align: center;">
                <div
                    style="font-size: 28px; font-weight: bold; display: flex; align-items: center; justify-content: center; gap: 10px;">
                    <span style="font-size: 26px;">👋</span> Hi ATao </div>
                <div style="margin-top: 10px; font-size:16px;"> 您在 <a href="${SITE_URL}"
                        style="color: white; text-decoration: underline; font-weight: 500;">${SITE_NAME}</a> 中收到一条新的评论！
                </div>
            </div> <!-- 右侧图片 --> <img src="https://cdn.blog.saneko.me/Web/web_250913_213324.png"
                style="display:block; max-width:100px;">
        </div> <!-- 内容区域 -->
        <div style="padding: 25px 20px;"> <!-- 原评论部分 -->
            <div style="margin-bottom: 20px;">
                <div style="font-weight: bold; margin-bottom: 10px; color: #333; font-size: 16px;">评论内容：</div>
                <div style="background-color: #f5f7fa; border-radius: 6px; padding: 15px; border: 1px solid #ebf0f5;">
                    <div style="color: #f8db8f; font-weight: 500; margin-bottom: 8px;">@${NICK}:</div>
                    <div style="color: #333; line-height: 1.6;">
                        <div style="margin-bottom: 5px;">${COMMENT}</div>
                    </div>
                </div>
            </div> <!-- 回复按钮 -->
            <div style="margin-bottom: 30px;"> <a href="${POST_URL}"
                    style="display: inline-block; background-color: #f8db8f; color: white; padding: 10px 20px; text-decoration: none; border-radius: 4px; font-weight: 500;">回复</a>
            </div> <!-- 系统提示 -->
            <div
                style="color: #86909c; font-size: 12px; text-align: center; padding-top: 15px; border-top: 1px solid #ebf0f5;">
                此邮件由系统发送，请不要回复此邮件 </div>
        </div>
    </div>
</div>

样式参考:

其他

一开始配置了MAIL_TEMPLATE_ADMIN，但无论如何测试都无法收到邮件。由于我的Twikoo是通过Docker部署的，通过查看日志发现了原因：

9/12/2025, 2:05:18 PM Twikoo: 存在即时消息推送配置，默认不发送邮件给博主，您可以在管理面板修改此行为

原来是因为我配置了即时通知功能，导致Twikoo默认不发送邮件通知。取消该配置后，邮件通知功能就恢复正常了。

企业微信每日提醒机器人

Tue, 09 Sep 2025 00:00:00 GMT

需求背景

需要定时发送消息到企业微信群，实现每日提醒功能。

实现方法

在企业微信中的群聊，添加机器人

获取机器人的Webhook地址

打开并登录腾讯轻联
左侧导航栏中，点击新建流程
触发组件中选择定时启动, 执行流程中添加企业微信群机器人

设置定时启动的触发条件
设置机器人发送的消息内容
保存并上线流程

AI大模型常见术语

Tue, 26 Aug 2025 00:00:00 GMT

模型基础与结构

大语言模型（LLM, Large Language Model）

基于海量文本训练的大规模语言模型，能理解和生成类人文本（如 GPT、LLaMA、Qwen）

Transformer

LLM 的核心架构，基于自注意力机制，支持并行处理序列数据。

自注意力机制

Transformer 的核心，让模型计算文本中每个 Token 与其他 Token 的关联（如 “他” 指代前文的 “小明”）

模型深度

Transformer 的层数（如 GPT-3 有 96 层），深度越深，模型捕捉复杂规律的能力越强。

参数与规模

模型参数

模型训练中学习的权重和偏置（如 “7B 模型” 指 70 亿参数），参数量影响模型能力和资源需求。

参数量级

模型参数的规模等级（如 B = 十亿，13B 即 130 亿）。

上下文窗口

模型能处理的最大输入长度（以 Token 为单位），即 “上下文长度”。

Token

文本的基本处理单位（如中文单字、英文子词），模型输入输出均以 Token 为单位。

词汇表

模型可识别的所有 Token 集合（如 GPT-2 词汇表约 5 万 Token），未在表中的词会被拆分为子词。

训练与优化

预训练

模型在海量通用文本（如书籍、网页）上的初始训练，学习语言规律和世界知识。

预训练数据

用于预训练的文本集合（如 GPT-3 用了约 45TB 文本），数据质量和多样性影响模型能力。

微调

预训练模型在特定任务数据（如医疗问答）上的二次训练，适配具体场景。

指令微调

用 “指令 - 响应” 格式数据微调模型，让模型理解人类指令（如 “写一篇总结”）。

过拟合

模型过度拟合训练数据，在新数据上表现差（如生成内容局限于训练文本）。

泛化能力

模型对未见过的新文本的适应能力，是评估 LLM 的核心指标。

数据表示与转换

向量化

将文本、图像等非结构化数据转换为数值向量（Embedding）的过程。

嵌入向量

向量化的结果，是文本语义的数值表示。

向量数据库

专门存储和检索嵌入向量的数据库，通过高效的近似最近邻（ANN）算法，快速从海量向量中找到与查询向量最相似的结果，是 RAG 系统的 “知识库存储核心”。

模型压缩与优化

量化

降低模型参数精度（如 FP16→INT8→INT4），减少显存占用和计算量（如 7B 模型从 14GB 降至 3.5GB）。

AWQ

一种高效量化方法，通过激活感知权重量化，在低精度下保留模型性能，适合 LLM 部署。

GPTQ

另一种常用量化方法，通过优化量化误差，支持 4bit 量化，广泛用于社区模型。

模型蒸馏

一种模型压缩技术：用性能强的 “教师模型”（如 100B 大模型）指导 “学生模型”（如 7B 小模型）学习，通过模仿教师模型的输出分布（而非仅学习标签），让小模型在体积更小、速度更快的同时，保留接近大模型的能力。

知识蒸馏

将教师模型学到的 “暗知识”（如对不同答案的概率分布）迁移给学生模型，而非仅传递 “明知识”（如正确答案），使小模型更懂 “推理逻辑”。

剪枝

直接删除模型中冗余的参数或结构（如权重接近 0 的神经元、贡献度低的网络层），减少模型体积和计算量。与蒸馏不同，剪枝是 “减法”（删参数），蒸馏是 “模仿学习”。

数值精度与计算

FP32

32 位精度的浮点数，是传统深度学习的默认数据类型，精度最高但显存占用大（1 个 FP32 参数占 4 字节）。大模型训练初期可能用 FP32，但推理时极少使用（太耗资源）。

FP16

16 位精度的浮点数，显存占用仅为 FP32 的一半（1 个参数占 2 字节），计算速度更快，广泛用于模型推理和部分训练场景（如混合精度训练）。但精度较低，极端值可能溢出。

BF16

16 位精度的浮点数，由谷歌为 TPU 设计，指数位与 FP32 相同（保留大范围数值），尾数位更短（牺牲部分精度）。适合大模型训练（抗噪性强），与 FP16 相比，在极端值处理上更稳定，常见于 A100、H100 等高端 GPU。

INT8/INT4

整数精度数据类型，INT8 参数占 1 字节（为 FP32 的 1/4），INT4 仅占 0.5 字节（为 FP32 的 1/8），是量化技术的核心。通过降低精度大幅减少显存占用，适合低资源设备部署。

混合精度

训练 / 推理中同时使用多种精度，平衡精度与效率。

输入与输出处理

分词器

将文本拆分为 Token 的工具，是 LLM 处理文本的第一步。

Prompt（提示词）

用户输入的指令或问题（如 “解释什么是 LLM”），用于引导模型生成输出。

提示词工程

设计优化 Prompt 的方法（如添加示例、限定格式），提升模型输出质量。

少样本提示

在 Prompt 中加入少量示例（如 “例 1：... 例 2：... 请解决：...”），帮助模型理解任务。

零样本提示

不提供示例，直接用指令让模型处理任务（如 “翻译‘你好’为英文”）。

输出长度

模型生成文本的最大 Token 数，可通过参数限制。

温度参数

控制输出随机性的参数（0 = 确定性输出，1 = 高随机性），值越低输出越固定。

部署

vLLM

高效的 LLM 推理框架，通过 PagedAttention 技术优化显存使用，提升吞吐量。

Tensor Parallelism（张量并行）

将模型参数拆分到多个 GPU 上，解决单卡显存不足问题（如 13B 模型拆到 2 张卡）。

Pipeline Parallelism（流水线并行）

将模型层拆分到多个 GPU，按顺序处理数据，提升大模型训练 / 推理效率。

KV 缓存（KV Cache）

缓存推理过程中的 Key 和 Value 向量（自注意力计算结果），避免重复计算，加速生成。

应用与扩展

生成式 AI

能生成新内容的 AI，LLM 是其核心（如生成文章、代码、对话）。

文本生成

LLM 的核心能力，生成符合语境的文本（如写邮件、编故事）。

问答系统

LLM 根据问题生成答案（如 “地球半径是多少？”→输出具体数值）。

机器翻译

将一种语言转换为另一种（如 LLM 支持中英互译）。

摘要生成

将长文本压缩为简洁摘要（如把一篇论文缩为一段话）。

代码生成

LLM 根据指令生成代码（如 “写一个 Python 排序函数”）。

RAG（检索增强生成）

结合外部知识库检索与 LLM 生成，让输出引用真实信息（如企业知识库问答）。

多轮对话

LLM 记住对话历史，支持连续交互（如聊天机器人）。

工具调用

LLM 调用外部工具（如计算器、搜索引擎）完成任务（如 “查今天的天气”）。

多模态

LLM 结合图像、音频等数据（如 GPT-4V 能理解图片 + 文本）。

模型类型与特性

基座模型

仅经过预训练的模型，需微调后才能用于具体任务。

对话模型

经指令微调 + RLHF 优化的模型，适合直接对话。

开源模型

公开模型权重和代码，允许自由使用和修改（如 LLaMA2、Qwen）。

闭源模型

不公开权重，仅通过 API 提供服务（如 GPT-4、Claude）。

MoE（混合专家模型）

模型包含多个 “专家子网络”，输入由路由层分配给部分专家处理，平衡规模与效率（如 GLaM）。

长上下文模型

支持超长输入的 LLM（如 Qwen3 支持 128k Token，可处理整本书）。

评估与问题

困惑度（PPL）

评估模型对文本的预测能力，值越低表示模型越 “理解” 文本（如 PPL=10 优于 PPL=20）。

BLEU 分数

评估机器翻译质量的指标，衡量输出与参考译文的重叠度。

ROUGE 分数

评估文本摘要质量的指标，对比摘要与原文的相似度。

幻觉

LLM 生成错误或不存在的信息（如编造事实、引用假数据）。

对齐

让 LLM 输出符合人类价值观和需求（如避免有害内容、遵循伦理）。

偏见

LLM 因训练数据包含偏见（如性别、种族偏见），输出带有倾向性内容。

鲁棒性

LLM 对输入微小变化（如错别字）的稳定性，鲁棒性差易输出错误。

工具与生态

Hugging Face

开源 AI 社区，提供 LLM 模型、工具库（如 Transformers）和部署平台。

Transformers 库

Hugging Face 推出的工具库，简化 LLM 加载、训练和推理（支持多框架）。

LangChain

构建 LLM 应用的框架，支持 RAG、工具调用、多轮对话等复杂流程。

本地部署vllm

Tue, 26 Aug 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

介绍

vLLM 是一个专为大规模语言模型（LLM）推理和服务而设计的高性能库。

它的核心优势在于其创新的 PagedAttention 算法，该算法解决了传统服务方式中内存管理的瓶颈，从而带来了两大核心优势：

极高的吞吐量：在相同硬件条件下，vLLM 可以同时处理更多用户的请求，显著降低了服务成本。
高效的内存利用：极大地减少了模型运行所需的显存，使得在消费级GPU上运行大模型成为可能，或者可以在单卡上运行更大的模型。

简单来说，如果你需要将像 Deepseek、Qwen3 等这类大模型部署成可对外服务的 API，vLLM 通常是性能和易用性的最佳选择之一。

部署

使用 Docker 部署是最简单、最干净的方式，它能避免复杂的环境依赖问题。

前提条件

确保你的机器已安装 Docker 和 NVIDIA Docker Toolkit（如果你使用 NVIDIA GPU）。
拥有足够的 GPU 显存（例如，运行 7B 模型建议至少 16GB 显存）。

部署步骤

预先下载模型到宿主机

首先，在你的服务器或本地机器上，创建一个专门的目录来存放模型，然后使用 huggingface-hub 官方工具下载模型。huggingface

# 1. 安装模型下载工具
pip install huggingface-hub

# 2. 创建模型存储目录（建议选择一个空间大的磁盘）
mkdir -p /data/models

# 3. 下载你所需的模型（这里以 Qwen 为例）
huggingface-cli download Qwen/Qwen3-8B-AWQ --local-dir /data/models/Qwen3-8B-AWQ

# 或者也可以通过git进行拉取
# git clone https://huggingface.co/Qwen/Qwen3-8B-AWQ

编写 Docker Compose 配置文件

创建一個名为 docker-compose.yml 的文件，内容如下。这个配置几乎可以直接使用，你只需要修改 volumes 项中的模型路径即可。

version: '3.8'

services:
  vllm-openai:
    image: vllm/vllm-openai:latest
    container_name: Qwen3-8B-AWQ # 给你的容器起个名字
    ports:
      - '8000:8000' # 将宿主机的8000端口映射到容器内
    volumes:
      # 关键步骤：将宿主机上下载好的模型目录挂载到容器内
      - /data/models/Qwen3-8B:/app/model
    environment:
      - LC_ALL=C.UTF-8 # 设置容器内部语言环境，避免编码问题
      - HF_HUB_OFFLINE=1 # 强制使用离线模式，避免运行时检查网络
      - TRANSFORMERS_OFFLINE=1 # 强制Transformers库使用离线模式
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all # 使用所有可用的GPU
              capabilities: [gpu] # 声明需要NVIDIA GPU能力
    # 传递给vLLM服务的启动命令,参数分别为
    # --model 指定容器内的模型路径
    # --gpu-memory-utilizatio GPU内存使用率，根据需求调整
    # --dtype 选择数据类型
    # --tensor-parallel-size tensor并行数
    # --port 容器内服务监听端口
    # --api-key 密钥
    # --trust-remote-code 对于Qwen等模型，需要此参数
    command: >
      --model /app/model
      --gpu-memory-utilization 0.9
      --dtype auto
      --tensor-parallel-size 1
      --port 8000
      --api-key 123123
      --trust-remote-code

启动服务在包含 docker-compose.yml 文件的目录下，执行以下命令即可启动所有服务。

docker compose up -d # -d 参数代表在后台运行

验证服务服务启动后，使用 curl 命令测试接口是否正常工作。使用在 --api-key 参数中设置的密钥。

curl -H "Authorization: Bearer 123123" http://localhost:8000/v1/models

如果返回了包含模型信息的 JSON 数据，恭喜，部署成功！

{

  "object": "list",
  "data": [{
    "id": "/app/model",
    "object": "model",
    "created": 1756171599,
    "owned_by": "vllm",
    "root": "/app/model",
    "parent": null,
    "max_model_len": 40960,
    "permission": [{
      "id": "modelperm-e234d316935c4aae9fbe1b5cefe3e96c",
      "object": "model_permission",
      "created": 1756171599,
      "allow_create_engine": false,
      "allow_sampling": true,
      "allow_logprobs": true,
      "allow_search_indices": false,
      "allow_view": true,
      "allow_fine_tuning": false,
      "organization": "*",
      "group": null,
      "is_blocking": false,
    },],
  },],
}

一种轻APP的通知推送方案

Thu, 21 Aug 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

前提背景

在日常工作和生活中，我们经常需要将设备状态、程序日志、重要提醒等信息及时推送到手机或其他终端。

但传统的推送方案要么依赖第三方闭源服务（存在隐私和稳定性风险），要么需要安装专用 APP（增加用户操作成本）。

今天要介绍的PushDeer，正是一款以 “轻量、可控、易用” 为核心的通知推送工具，尤其适合需要自主掌控推送链路的用户。

PushDeer

PushDeer 是一款开源的无 APP 推送服务，同时支持轻 APP（如 APP Clip、快应用）、传统 APP（iOS/Android/Mac）以及自制硬件设备（如 ESP8266/ESP32），核心目标是让消息推送 “无需安装、简单调用、自主可控”。

其核心价值可以概括为三点：

易用性 无需安装 APP，通过轻应用或快应用即可接收消息；调用方式极简，只需一个 URL 即可发送文本，无需深入阅读文档。
可控性 支持自托管，避免依赖第三方服务下线风险；非商用场景免费，且不依赖微信等平台的消息接口，减少政策限制影响。
渐进性 基础功能（文本推送）零门槛，通过扩展参数可支持 Markdown、图片等富文本；后期可通过 APP 补充轻应用无法覆盖的功能。

自定义部署

如果需要完全掌控推送服务（避免依赖官方服务），可以通过以下步骤自托管 PushDeer。

环境准备
- 服务器：推荐 Linux 系统（需支持 Docker），具备公网 IP（方便外部调用）。
- 本地工具：安装git、docker和docker-compose。
下载代码克隆官方仓库到服务器

git clone https://github.com/easychen/pushdeer.git
cd pushdeer

启动服务执行以下命令启动 API 服务

docker-compose -f docker-compose.self-hosted.yml up --build -d

此时，访问http://公网ip:8800，可以正常显示下方二维码则表示部署成功

客户端配置

在苹果商店搜索「PushDeer·自架版」或扫描上方的二维码进行安装并启动

API服务地址输入http://公网ip:8800, 并用苹果id进行登录

登陆后，没有注册就先进行注册

注册完成后，点击Key就可以看到当前设备的密钥了

验证服务

使用python发送请求

import requests
from typing import Optional

def pushdeer_send(text: str, desp: Optional[str] = None, type_: str = "text", key: str = "[PUSHKEY]") -> str:
    """
    发送 PushDeer 消息
    Parameters
    ----------
    text : str
        主体文字
    desp : Optional[str]
        附加描述，若为 None 则不传递此字段
    type_ : str
        消息类型，默认 "text"
    key  : str
        PushKey， 设备密钥

    Returns
    -------
    str
        PushDeer API 返回的原始文本内容。
    """
    url = "http://公网ip:8800/message/push"

    payload = {
        "text": text,
        "type": type_,
        "pushkey": key
    }
    if desp is not None:
        payload["desp"] = desp

    response = requests.post(url, data=payload)

    response.raise_for_status()
    return response.text

pushdeer_send("Hello World",key="PDU1Tn3kcl...")

客户端接收到消息推送

Ollama突然无法识别GPU问题

Tue, 05 Aug 2025 00:00:00 GMT

问题描述

在 Docker 容器中运行 Ollama 时, GPU 最初可用，但运行一段时间后会突然失效，无法被 Ollama 识别到。

原因分析

Docker 默认使用 systemd 作为 cgroup 驱动（native.cgroupdriver=systemd），而 NVIDIA 容器运行时（nvidia-container-runtime）在某些情况下与 systemd 不兼容，导致:

GPU 设备权限丢失：/dev/nvidia* 设备节点在运行过程中被 systemd 动态调整，导致容器无法访问
GPU 无法识别：nvidia-container-runtime 无法正确挂载 GPU 设备

解决方案

修改 Docker 配置，使用 cgroupfs 编辑 /etc/docker/daemon.json（如果不存在则新建）：

{
  "exec-opts": ["native.cgroupdriver=cgroupfs"]
}

重启 Docker 生效

sudo systemctl restart docker

验证是否生效

docker info | grep "Cgroup Driver"

如果输出是 Cgroup Driver: cgroupfs，说明修改成功。

为什么这样修改有效

常用Git指令

Mon, 21 Jul 2025 00:00:00 GMT

一、Git基础配置

# 设置全局用户名和邮箱（每次提交都会记录这些信息）
git config --global user.name "你的名字"
git config --global user.email "你的邮箱@example.com"

# 查看所有配置信息
git config --list

这些配置通常只需要设置一次，它们会被保存在用户目录下的.gitconfig文件中

二、仓库操作基础

1. 创建与克隆仓库

# 在当前目录初始化一个新的Git仓库
git init

# 克隆远程仓库到本地
git clone <仓库URL>

# 克隆特定分支
git clone -b <分支名> <仓库URL>

2. 远程仓库管理

# 查看已配置的远程仓库
git remote -v

# 添加新的远程仓库
git remote add <远程名称> <仓库URL>

# 修改远程仓库地址
git remote set-url <远程名称> <新URL>

# 删除远程仓库
git remote remove <远程名称>

origin一般是在克隆(Clone)仓库时自动创建的默认远程仓库别名

三、日常开发工作流

1. 状态查看与文件操作

# 查看当前仓库状态（推荐频繁使用）
git status

# 查看工作区和暂存区的具体更改
git diff

# 查看已暂存文件的更改
git diff --cached

2. 提交更改

# 添加文件到暂存区
git add <文件名>       # 添加特定文件
git add .              # 添加所有更改的文件

# 提交更改并添加描述信息
git commit -m "有意义的提交信息"

# 修改最后一次提交（未推送前）
git commit --amend

常见 Git Commit 关键字及含义 | 关键字 | 用途示例 | 说明 | |-----------|-----------------------------|----------------------------------------------------------------------| | feat | feat: add user login | 新增功能（Feature），通常对应 semver 的 MINOR 版本更新。 | | fix | fix: button click bug | 修复 Bug，通常对应 semver 的 PATCH 版本更新。 | | docs | docs: update README | 文档更新（如 README、注释等）。 | | style | style: format code | 代码样式调整（如空格、缩进、分号等），不改变逻辑。 | | refactor| refactor: simplify logic | 代码重构（既非新增功能，也非修复 Bug）。 | | perf | perf: optimize rendering | 性能优化（Performance）。 | | test | test: add unit test | 测试相关（新增或修改测试代码）。 | | chore | chore: update deps | 杂项任务（如构建配置、依赖更新等）。 | | build | build: upgrade webpack | 构建系统或工具链变更（如 Webpack、Babel 等）。 | | ci | ci: fix GitHub Actions | CI/CD 配置变更（如 GitHub Actions、Jenkins）。 | | revert | revert: remove feature X | 回滚之前的提交。 | | merge | merge: branch A into main | 合并分支（通常由 Git 自动生成，手动提交时应避免使用）。 |

3. 分支管理

# 查看本地分支
git branch

# 查看所有分支（包括远程）
git branch -a

# 创建新分支
git branch <分支名>

# 切换分支
git checkout <分支名>

# 创建并切换到新分支（推荐方式）
git checkout -b <分支名>

# 删除分支
git branch -d <分支名>      # 安全删除（已合并的分支）
git branch -D <分支名>      # 强制删除（未合并的分支）

# 重命名分支
git branch -m <旧分支名> <新分支名>

四、同步与协作

1. 拉取与推送

# 拉取远程仓库的最新更改（只获取不合并）
git fetch origin

# 推送当前分支到远程的Gerrit代码审查系统
git push origin HEAD:refs/for/<分支名>

# 推送当前提交作为标签到远程仓库
git push origin HEAD:refs/tags/<标签名>

# 标准推送方式
git push

# 推送新分支到远程
git push -u origin <分支名>

# 强制推送（慎用，可能覆盖他人工作）
git push -f

强制推送会覆盖远程历史，只应在你完全确定的情况下使用，特别是在团队协作中要避免随意使用

2. 合并与变基

# 合并指定分支到当前分支
git merge <分支名>

# 变基当前分支到指定分支（使历史更线性）
git rebase <分支名>

合并(merge)会创建一个新的合并提交，保留完整的历史
变基(rebase)会重写提交历史，使分支看起来像是直接基于目标分支开发的

五、查看历史记录

# 查看完整的提交历史
git log

# 简洁版提交历史
git log --oneline

# 查看特定文件的修改历史
git blame <文件名>

六、标签管理

# 创建轻量级标签
git tag <标签名>

# 创建带注释的标签
git tag -a <标签名> -m "标签说明"

# 查看所有标签
git tag

# 推送标签到远程
git push origin --tags

# 删除本地标签
git tag -d <标签名>

# 删除远程标签
git push origin :refs/tags/<标签名>

七、常用小技巧

1. 强制重置到远程分支状态

git fetch origin
git reset --hard origin/<分支名>

WPF实现本地化及运行时切换语言

Wed, 18 Jun 2025 00:00:00 GMT

添加资源文件

找一个存放本地化资源文件的目录，例如/Resources/Languages目录下.

右键添加资源字典，这里简单命名为Strings.zh-CN.xaml.

添加需要翻译的字段

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:system="clr-namespace:System;assembly=mscorlib">
    <!--  导航页面  -->
    <system:String x:Key="Navigation_Home">主页</system:String>
</ResourceDictionary>

再新建另一种语言的资源字典，例如Strings.en-US.xaml.

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:system="clr-namespace:System;assembly=mscorlib">
    <!-- Navigation -->
    <system:String x:Key="Navigation_Home">Home</system:String>
</ResourceDictionary>

本地化管理

新建一个类LanguageService，用于管理本地化语言。

public static class LanguageService
{
    private static ResourceDictionary _currentDictionary;

    public static void ChangeLanguage(string languageCode)
    {
        // 构建资源路径 (根据实际程序集名调整)
        string path = $"pack://application:,,,/TWPFX_Gallery;component/Resources/Languages/Strings.{languageCode}.xaml";

        // 移除旧语言资源
        if (_currentDictionary != null)
        {
            Application.Current.Resources.MergedDictionaries.Remove(_currentDictionary);
        }

        // 加载新语言资源
        _currentDictionary = new ResourceDictionary { Source = new Uri(path) };
        Application.Current.Resources.MergedDictionaries.Add(_currentDictionary);
    }

    // 可选：自动检测系统语言
    public static void Initialize()
    {
        string sysLang = CultureInfo.CurrentCulture.Name;
        ChangeLanguage(sysLang == "zh-CN" ? "zh-CN" : "en-US");
    }
}

XAML中使用

使用DynamicResource才可以支持运行时动态更新

<ui:Button Content="{DynamicResource Navigation_Home}" />

C#中使用

button.Content = new DynamicResourceExtension("Navigation_Home").ProvideValue(null);

切换语言

LanguageService.ChangeLanguage("en-US");

Maxkb实现数据库备份与恢复

Fri, 06 Jun 2025 00:00:00 GMT

备份脚本

#!/bin/bash

# 定义变量
BACKUP_DIR="/opt/db_bak"        # 备份文件存储目录
DATE=$(date +%Y%m%d_%H%M%S)     # 创建时间戳
CURRENT_TIME=$(date +"%Y-%m-%d %H:%M:%S")  # 添加当前时间变量（用于日志）
DB_NAME="maxkb"                 # 数据库名
DB_USER="postgres"              # 数据库用户（根据配置修改）
DB_PASS="123123"                # 数据库密码（根据配置修改）
DB_HOST="localhost"             # 数据库主机地址
DB_PORT="5432"                  # 数据库端口

# 创建备份文件名
BACKUP_FILE="$BACKUP_DIR/$DB_NAME-$DATE.dump"

# 检查备份目录是否存在，如果不存在则创建
if [ ! -d "$BACKUP_DIR" ]; then
    mkdir -p "$BACKUP_DIR"
    echo "[${CURRENT_TIME}] 备份目录不存在，已创建目录：$BACKUP_DIR"
fi

# 执行备份
echo "[${CURRENT_TIME}] 开始备份数据库：$DB_NAME"

# 使用环境变量设置密码，避免在命令行中明文传递
PGPASSWORD="$DB_PASS" pg_dump -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -Fc > "$BACKUP_FILE"

# 检查备份是否成功
if [ $? -eq 0 ]; then
    echo "[${CURRENT_TIME}] 备份完成，文件路径：$BACKUP_FILE"
else
    echo "[${CURRENT_TIME}] 备份失败！"
    exit 1
fi

# 压缩备份文件
gzip "$BACKUP_FILE"
COMPRESSED_FILE="${BACKUP_FILE}.gz"
echo "[${CURRENT_TIME}] 备份文件已压缩：$COMPRESSED_FILE"
echo "------------------------"

添加执行权限

sudo chmod +x /opt/maxkb/backup_maxkb.sh

执行

sudo sh backup_maxkb.sh

此时默认将数据库导入到/opt/db_bak路径下，我们需要定时执行这个脚本。

设置定时任务

sudo crontab -e

在文件末尾添加

# 每周六凌晨2点进行备份
00 02 * * 6 /opt/backup_maxkb.sh >> /var/log/maxkb_backup.log 2>&1

恢复脚本

#!/bin/bash

# 定义变量
RESTORE_FILE="/opt/db_bak/maxkb-20250606_095233.dump.gz"  # 备份文件路径，支持 .gz 压缩格式
DB_NAME="maxkb"                                   # 要恢复的数据库名
DB_USER="postgres"                                # 数据库用户（根据实际情况修改）
DB_PASS="123123"                                  # 数据库密码（根据实际情况修改）
DB_HOST="localhost"                               # 数据库主机地址
DB_PORT="5432"                                    # 数据库端口
TEMP_DIR="/tmp/postgres_restore"                 # 临时解压目录

# 创建临时目录
mkdir -p "$TEMP_DIR"
echo "临时目录已创建：$TEMP_DIR"

# 检查备份文件是否存在
if [ ! -f "$RESTORE_FILE" ]; then
    echo "错误：恢复文件不存在：$RESTORE_FILE"
    exit 1
fi

# 提取文件名（不含路径）
FILENAME=$(basename "$RESTORE_FILE")

# 检查文件是否为 .gz 压缩格式
if [[ "$FILENAME" == *.gz ]]; then
    echo "检测到压缩文件，开始解压..."
    UNZIPPED_FILE="$TEMP_DIR/${FILENAME%.gz}"  # 移除 .gz 后缀

    # 解压文件
    gunzip -c "$RESTORE_FILE" > "$UNZIPPED_FILE"
    if [ $? -ne 0 ]; then
        echo "错误：解压文件失败！"
        exit 1
    fi
    echo "文件已解压至：$UNZIPPED_FILE"
else
    # 如果不是压缩文件，直接使用原文件
    UNZIPPED_FILE="$RESTORE_FILE"
fi

# 检查目标数据库是否已存在
echo "检查数据库 '$DB_NAME' 是否存在..."
if psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -lqt | cut -d \| -f 1 | grep -qw "$DB_NAME"; then
    echo "数据库 '$DB_NAME' 已存在，将清空数据库并继续恢复操作..."

    # 清空数据库（危险操作！）
    PGPASSWORD="$DB_PASS" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -c "
    BEGIN;
    -- 关闭所有连接（避免锁表）
    SELECT pg_terminate_backend(pid)
    FROM pg_stat_activity
    WHERE datname = '$DB_NAME' AND pid <> pg_backend_pid();

    -- 清空所有模式下的对象（注意：会删除所有数据！）
    DROP SCHEMA public CASCADE;
    CREATE SCHEMA public;
    GRANT ALL ON SCHEMA public TO public;
    GRANT ALL ON SCHEMA public TO $DB_USER;
    COMMIT;
    "

    if [ $? -ne 0 ]; then
        echo "错误：清空数据库失败！"
        exit 1
    fi
else
    echo "数据库 '$DB_NAME' 不存在，将创建新数据库..."
    # 创建新数据库
    PGPASSWORD="$DB_PASS" createdb -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" "$DB_NAME"
    if [ $? -ne 0 ]; then
        echo "错误：创建数据库失败！"
        exit 1
    fi
fi

# 执行恢复
echo "开始从 $RESTORE_FILE 恢复数据库 $DB_NAME..."

# 使用环境变量设置密码，避免在命令行中明文传递
PGPASSWORD="$DB_PASS" pg_restore -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -v "$UNZIPPED_FILE"

# 检查恢复是否成功
if [ $? -eq 0 ]; then
    echo "恢复完成！"
else
    echo "错误：恢复失败！"
    exit 1
fi

# 清理临时文件
echo "清理临时文件..."
rm -rf "$TEMP_DIR"
echo "恢复过程已完成！"

执行

sudo bash restore_maxkb.sh

{caption:恢复完成}

WPF布局控件

Thu, 15 May 2025 00:00:00 GMT

import { ProsCons } from 'astro-pure/user'

前提

在 WPF 开发中，布局控件是构建灵活、自适应界面的核心。合理选择布局控件能显著提升界面的美观度和用户体验。本文将详细介绍 WPF 中常见的布局控件，分析它们的特性差异，并结合实际场景给出选型建议。

控件总览

| 布局类型 | 核心控件 | 布局特点 | | ------------ | ------------- | --------------------------------------- | | 栈式布局 | StackPanel | 子元素按水平或垂直方向线性排列 | | 网格布局 | Grid | 基于行 / 列网格的二维布局，支持混合尺寸 | | 停靠布局 | DockPanel | 子元素停靠在容器边缘或填充剩余空间 | | 流式布局 | WrapPanel | 子元素自动换行排列，适应容器尺寸变化 | | 均分布局 | UniformGrid | 子元素等宽等高，自动分配空间 | | 绝对定位 | Canvas | 基于坐标（X/Y）的绝对定位布局 |

控件详解

StackPanel

排列方式：通过Orientation属性控制水平（Horizontal）或垂直（Vertical）排列。
尺寸逻辑：
- 主轴（排列方向）：子元素按MinWidth/MinHeight或内容大小占据空间。
- 次轴（垂直方向）：默认拉伸填充（可通过HorizontalAlignment/VerticalAlignment调整）。
适用场景：
- 简单的单行 / 单列布局（如工具栏、表单垂直排列）。
- 子元素数量较少且无需复杂排版的场景。

<StackPanel Orientation="Vertical" Margin="10">
    <Button Content="按钮1" Margin="5" />
    <Button Content="按钮2" Margin="5" />
</StackPanel>

Grid

二维网格：通过RowDefinitions和ColumnDefinitions定义行/列，支持星号（*）比例分配、固定尺寸（Auto）。
跨单元格布局：通过Grid.RowSpan和Grid.ColumnSpan实现元素跨行列显示。
适用场景：
- 复杂界面布局（如数据表格、多区域窗口）。
- 需要响应式设计（如不同分辨率下的自适应布局）。

<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" /> <!-- 标题行，自动适应内容 -->
        <RowDefinition Height="*" />    <!-- 内容行，填充剩余空间 -->
    </Grid.RowDefinitions>
    <TextBlock Grid.Row="0" Text="标题" Margin="10" />
    <TextBox Grid.Row="1" Margin="10" />
</Grid>

DockPanel

停靠逻辑：子元素通过Dock属性停靠在容器边缘，最后一个元素默认填充剩余空间。
适用场景：
- 应用程序主窗口布局（如顶部菜单、左侧导航栏、中间内容区）。
- 固定边缘元素与自适应内容结合的场景。

<DockPanel>
    <Menu DockPanel.Dock="Top" />          <!-- 顶部菜单 -->
    <TreeView DockPanel.Dock="Left" />      <!-- 左侧导航 -->
    <TextBox DockPanel.Dock="Fill" />       <!-- 填充剩余空间 -->
</DockPanel>

WrapPanel

自动换行：子元素按主轴方向排列，超出容器尺寸时自动换行。
适用场景：
- 动态数量的子元素（如标签云、图片画廊）。
- 需要根据窗口大小自动调整排列方式的场景。

<WrapPanel Orientation="Horizontal">
    <Button Content="短文本" />
    <Button Content="较长的文本需要换行" />
    <Button Content="另一个按钮" />
</WrapPanel>

UniformGrid

等宽等高：所有子元素自动占据相同大小的单元格，行列数由Rows或Columns属性决定（或自动计算）。
适用场景：
- 宫格布局（如应用图标列表、参数配置面板）。
- 子元素数量固定且需要均匀分布的场景。

<UniformGrid Rows="3" Columns="3" Margin="10">
    <Button Content="1" />
    <Button Content="2" />
    <!-- 省略其他按钮 -->
</UniformGrid>

Canvas

坐标定位：子元素通过Canvas.Left和Canvas.Top属性指定绝对位置，支持像素级精确控制。
适用场景：
- 图形绘制（如流程图、自定义控件设计）。
- 需要固定位置的元素（如浮层提示、动态定位图标）。

<Canvas>
    <Ellipse Canvas.Left="50" Canvas.Top="50" Width="30" Height="30" Fill="Red" />
    <TextBlock Canvas.Left="100" Canvas.Top="60" Text="坐标点" />
</Canvas>

建议总结

简单线性排列 → StackPanel
复杂二维布局 → Grid
边缘固定 + 中心自适应 → DockPanel
动态换行内容 → WrapPanel
均匀分布宫格 → UniformGrid
像素级精确控制 → Canvas

WPF创建简单用户控件

Wed, 14 May 2025 00:00:00 GMT

基本概念

用户控件(User Control)是一种可重用的UI组件，通过组合现有控件来创建自定义功能模块。它本质上是一个容器，可以包含其他控件并封装其交互逻辑。

主要特点

继承自UserControl类.
XAML+代码后置.
可重用的独立功能单元.
可自定义属性、方法和事件.

核心优势

开发效率提升
维护性增强
功能解耦

示例

假设需要封装一个FileSelectorBox控件，用来实现文件选择的功能。

控件组成：由一个TextBlock和一个Button组成。
依赖属性： FilePath(当前选择的文件路径)
自定义事件： OnFileChanged(当文件路径发生改变)

创建用户控件

右键项目，选择添加，选择用户控件

组合现有控件

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="Auto"/>
    </Grid.ColumnDefinitions>
    <TextBlock Grid.Column="0"/>
    <Button Grid.Column="1" Content="选择" Width="71"/>
</Grid>

添加依赖属性和自定义事件

public event EventHandler OnFileChanged;

public static readonly DependencyProperty FilePathProperty =
DependencyProperty.Register(
    "FilePath",     // 属性名称
    typeof(string),   // 属性类型
    typeof(FileSelectorBox), // 所属类型
    new PropertyMetadata(null, OnValuesChanged)); // 默认值，添加回调方法

public string FilePath
{
    get { return (string)GetValue(FilePathProperty); }
    set { SetValue(FilePathProperty, value); OnFileChanged?.Invoke(this, EventArgs.Empty); }
}

private static void OnValuesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    // 回调方法
    // 外部修改依赖属性的值时，将在这里回调...
}

当FilePath被修改时，需要修改TextBlock的内容

<TextBlock Grid.Column="0" Text="{Binding FilePath,
          RelativeSource={RelativeSource AncestorType=UserControl}}" />

按钮功能

当按钮点击时，需要弹出一个文件选择框来选择文件

<Button Grid.Column="1" Content="选择" Width="71" Click="Button_Click" />

private void Button_Click(object sender, RoutedEventArgs e)
{
    Button button = (Button)sender;
    switch(button.Content)
    {
        case "选择":
            OpenFileDialog openFileDialog = new()
            {
                Title = "选择文件",
                Filter = "All File|*.*"
            };
            openFileDialog.ShowDialog();
            FilePath = openFileDialog.FileName;
            break;
    }
}

控件使用

<Grid>
    <local:FileSelectorBox  FilePath="{Binding ExternalFilePath, Mode=TwoWay}" OnFileChanged="FileSelectorBox_OnFileChanged"/>
</Grid>

public partial class ToolMainWindow : UserControl, INotifyPropertyChanged
{
    private string _externalFilePath = string.Empty;  // 数据源，也可以是自定义的数据模型

    public string ExternalFilePath
    {
        get { return _externalFilePath; }
        set { _externalFilePath = value; OnPropertyChanged(nameof(ExternalFilePath)); }  // 通知属性值已更改
    }

    public ToolMainWindow()
    {
        InitializeComponent();
        DataContext = this;  // 设置数据上下文
    }

    public event PropertyChangedEventHandler? PropertyChanged;  // 实现接口

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private void FileSelectorBox_OnFileChanged(object sender, EventArgs e)
    {
        Growl.Info($"ExternalFilePath发生变化:{ExternalFilePath}");
    }
}

WPF错误的依赖属性仍然运行问题

Wed, 14 May 2025 00:00:00 GMT

前提

在 WPF 开发中，依赖属性（DependencyProperty）是一项核心技术，它让属性具有数据绑定、样式继承等强大功能。

但在实际编码过程中，开发者可能会遇到一些 “奇怪” 的现象：

即便代码写法不符合常规认知，程序依然能正常运行。

本文将通过一个实际案例，深入剖析这种异常现象背后的原理，帮助大家更好地理解 WPF 依赖属性系统。

问题代码复现

以下是一段定义FileSelectorBox用户控件依赖属性的代码：

public partial class FileSelectorBox : UserControl
{

    public static readonly DependencyProperty PropertyAProperty =
    DependencyProperty.Register(
        "PropertyA",     // 属性名称
        typeof(bool),   // 属性类型
        typeof(FileSelectorBox), // 所属类型
        new PropertyMetadata(false, OnValuesChanged)); // 默认值，添加回调方法

    public bool PropertyA
    {
        get { return (bool)GetValue(PropertyAProperty); }
        set { SetValue(PropertyAProperty, value);  }
    }

    public static readonly DependencyProperty PropertyBProperty =
    DependencyProperty.Register(
        "PropertyB",     // 属性名称
        typeof(bool),   // 属性类型
        typeof(FileSelectorBox), // 所属类型
        new PropertyMetadata(false, OnValuesChanged)); // 默认值，添加回调方法

    public bool PropertyB
    {
        get { return (bool)GetValue(PropertyAProperty); }
        set { SetValue(PropertyAProperty, value); }
    }

    // ....
}

乍一看，PropertyB属性的get和set方法中，调用GetValue和SetValue时使用的是PropertyAProperty，而不是正确的PropertyBProperty。

按照常理，这样的代码应该会导致属性值错乱。但实际运行时却没有立即暴露出问题，这是为什么呢？

现象背后的原理

依赖属性系统的底层机制

WPF 依赖属性系统的底层存储由DependencyObject类维护，通过DependencyProperty对象作为唯一标识（如PropertyAProperty和PropertyBProperty）来访问和存储属性值。系统在操作属性时，直接通过这些DependencyProperty键进行查找和修改，与 CLR 属性包装器的名称和实现细节并无直接关联。

XAML 解析的特性

当我们在 XAML 中设置属性，例如，XAML 解析器会直接调用SetValue(PropertyBProperty, true)，它绕过了 CLR 属性包装器，直接操作底层的依赖属性存储。因此，即使 CLR 属性包装器中的get和set方法存在错误引用，XAML 解析器依然能正确设置PropertyBProperty的值。

代码访问的矛盾

虽然 XAML 解析能正确设置属性值，但当在 C# 代码中直接访问PropertyB属性时，问题就会暴露出来。例如：

FileSelectorBox fileSelectorBox = new();
fileSelectorBox.PropertyB = true; // 实际修改的是PropertyAProperty的值
bool value = fileSelectorBox.PropertyB; // 实际获取的是PropertyAProperty的值

这种不一致的行为，会导致属性值的读写混乱，尤其在复杂的业务逻辑和数据绑定场景中，可能引发难以排查的 Bug。

总结

WPF 的依赖属性系统实际上有两层结构：

底层存储：由DependencyObject类内部维护的哈希表，通过DependencyProperty键访问（例如PropertyBProperty）
上层接口：为了让依赖属性能够像普通属性一样被 C# 代码使用，需要提供一个 CLR 属性包装器

xaml直接访问的依赖属性的底层存储，因此绕过了上层的CLR包装器。在开发过程中，我们必须确保 CLR 属性包装器正确地映射到对应的 DependencyProperty，以避免潜在的错误。

Maxkb加载gpt2失败

Fri, 25 Apr 2025 00:00:00 GMT

问题描述

在Maxkb使用AI高级编排时，使用AI对话会抛出Can’t load tokenizer for ‘gpt2’的异常

Can't load tokenizer for 'gpt2. if you were trying to load it from "htps://huggingface.co/models, make sure you don't have a
local directory with the same name. 0therwise, make sure 'gpt2 is the correct path to a directory containing all relevant files for
a GPT2TokenizerFast tokenizer.

{caption:错误日志}

解决方法

这是由于用于计算token的gpt2没有下载到本地导致的

可以通过huggingface进行下载

pip install -U huggingface_hub   # 安装huggingface库
huggingface-cli download --resume-download gpt2 --local-dir gpt2  # 下载gpt2

将下载完成后的模型放在/opt/maxkb/app/models/tokenizer/gpt2

修改Maxkb中查找gpt2的路径

# apps\common\config\tokenizer_manage_config.py
class TokenizerManage:
    tokenizer = None

    @staticmethod
    def get_tokenizer():
        from transformers import GPT2TokenizerFast
        if TokenizerManage.tokenizer is None:
            TokenizerManage.tokenizer = GPT2TokenizerFast.from_pretrained(
                '/opt/maxkb/app/models/tokenizer/gpt2',
                cache_dir="/opt/maxkb/model/tokenizer",
                local_files_only=True,
                resume_download=False,
                force_download=False)
        return TokenizerManage.tokenizer

ubuntu22.04源码部署maxkb

Mon, 17 Mar 2025 00:00:00 GMT

源码下载

从maxkb项目中拉取最新源码.

前端依赖

Nodejs

前端依赖下载需要使用较高版本的Nodejs，使用apt查看可下载的Node的版本信息

apt list -a nodejs

发现没有较新的22版本，运行下面的命令

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
# 安装完成后，检查 Node.js 和 npm 的版本
node -v
npm -v

下载源

安装好npm后，需要配置npm源，建议使用以下命令添加国内源

npm config set registry https://registry.npmmirror.com

安装依赖

使用以下命令安装前端所需依赖

cd ui   # 需要先切换至ui目录
npm install

后端依赖

python

python版本不能低于3.11,使用以下命令进行安装

sudo apt update  # 更新系统包列表
sudo apt install software-properties-common -y # 安装依赖项
sudo add-apt-repository ppa:deadsnakes/ppa # 添加 Deadsnakes PPA
sudo apt install python3.11  # 安装 Python 3.11

poetry

通过以下命令进行安装

pip install poetry==1.8.5

安装依赖

使用以下命令安装后端所需依赖(需要较长时间)

cd ..   # 需要先切换至项目根目录
poetry install

Postgresql(数据库)

安装Postgresql

sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
wget -qO- https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo tee /etc/apt/trusted.gpg.d/pgdg.asc &>/dev/null  # 启用它的官方包存储库
sudo apt update  # 获取包的最新版本
sudo apt install postgresql postgresql-client postgresql-server-dev-17 -y   # 安装服务端，客户端，开发套件
sudo systemctl status postgresql  # 验证 PostgreSQL 服务是否启动并运行

更新密码

使用下面命令进入psql, 并更新管理员用户密码

sudo -u postgres psql
ALTER USER postgres PASSWORD '123123';

输入\q退出

安装插件

执行以下指令，安装vector插件

cd /tmp
git clone --branch v0.8.0 https://github.com/pgvector/pgvector.git
cd pgvector
make
sudo make install

如果make命令报错，可能需要额外安装gcc和make工具:

apt install make gcc

创建数据库

使用psql -h localhost -U postgres输入密码并登录数据库，按行执行下面的sql

CREATE DATABASE "maxkb";
\c "maxkb";
CREATE EXTENSION "vector";

配置文件

将项目根目录下的config_example.yml配置文件拷贝至/opt/maxkb/conf目录下

sudo mkdir -p /opt/maxkb/conf
sudo cp config_example.yml /opt/maxkb/conf

修在/opt/maxkb/conf/config_example.yml内容如下（如果按照的是上面的步骤，则只需要修改 DB_USER: postgres和 DB_PASSWORD: 123123）

# 数据库链接信息
DB_NAME: maxkb
DB_HOST: localhost
DB_PORT: 5432
DB_USER: postgres
DB_PASSWORD: 123123
DB_ENGINE: django.db.backends.postgresql_psycopg2

DEBUG: false

TIME_ZONE: Asia/Shanghai

启动

启动后端

python3 main.py start

如果抛出异常，可能是有些库没有安装。执行以下指令，安装缺少的库

pip install -r requirements.txt

启动前端

需要在ui目录下启动

cd ui
npm run dev

通过浏览器打开http://localhost:3000/ui/, 可以看到Maxkb的登录页面(第一次启动可能需要较长时间)

用户名：admin
密码：MaxKB@123..

解除限制

需要修改以下文件

user_serializers.py

修改文件: apps/users/serializers/user_serializers.py
修改位置: 注释掉valid_license修饰器。分别大概在188、775行左右
修改后:

application_serializers.py

修改文件: apps/application/serializers/application_serializers.py
修改位置: 注释掉valid_license修饰器。分别大概在513、720行左右
修改后:

dataset_serializers.py

修改文件: apps/dataset/serializers/dataset_serializers.py
修改位置: 注释掉valid_license修饰器。大概在412行左右
修改后:

valid_serializers.py

修改文件: apps/setting/serializers/valid_serializers.py
修改位置: 将count数量调整为999999, 注释掉valid的判断过程，直接返回True
修改后:

Ollama

安装

执行以下命令，安装ollama

curl -fsSL https://ollama.com/install.sh | sh

添加模型

浏览器打开MaxKB主界面:http://localhost:3000/

依次点击系统设置,模型设置，添加模型

MCDR安装与使用

Wed, 12 Mar 2025 00:00:00 GMT

import { Video } from 'astro-pure/user'

介绍

MCDR（MCDaemon Reforged）是由Fallen_Breath主导维护的一个基于Python的工具，用于管理Minecraft服务器。

它通过插件系统提供丰富的功能扩展，如自动备份、玩家高亮等。

原理

MCDR通过Popen来启动Minecraft服务端作为子进程，进而控制服务端的输入与输出流。
MCDR通过解析服务端的输出，来抽象为不同的事件，并将它们分派给插件以进行响应。
借助Minecraft的命令系统，MCDR也可以通过标准输入流发送Minecraft命令以操作Minecraft服务端。

安装

打开服务器后端，直接通过pip进行安装

pip3 install mcdreforged

在服务端中，新建一个文件夹(例如mcdr_server)用来存放脚本，再通过init方法进行初始化

cd mcdr_server
mcdreforged init

此时会生成如下所示的文件夹结构

mcdr_server/
    ├─ config/
    ├─ logs/
    │   └─ MCDR.log
    ├─ plugins/
    ├─ server/
    ├─ config.yml
    └─ permission.yml

将我们整个服务端，放到server文件夹下

mcdr_server/
    ├─ config/
    ├─ logs/
    │   └─ MCDR.log
    ├─ plugins/
    ├─ server/
++  │   ├─ ...
++  │   ├─ minecraft_server.jar
++  │   └─ server.properties
    ├─ config.yml
    └─ permission.yml

配置

通过编辑config.yml文件来配置 MCDR

language: zh_cn # 输出信息的语言
working_directory: server # 服务端的工作目录
start_command: java -Dfile.encoding=UTF-8 -Dstdout.encoding=UTF-8 -Dstderr.encoding=UTF-8 -Xms3G -Xmx7G -jar fabric-server.jar nogui
handler: vanilla_handler # 用于 原版/Carpet/Fabric服务端 无需修改
# ...

启动

输入以下命令进行启动

mcdreforged

服务端

客户端

插件

Here

安装指令

!!MCDR plugin install here

命令

!!here：显示玩家坐标并使其发光

效果

Prime Backup

安装指令

!!MCDR plugin install prime_backup

配置config/prime_backup文件夹下的config.json, 将enabled设置为true.

其他配置参考官方文档

命令

!!pb help [指令]: 展示全部指令/给定指令的详细帮助

!!pb make [注释]: 创建一个备份。注释为可选注释

!!pb back [备份ID]: 回档至给定备份

!!pb list [...]: 列出备份，展示备份列表

!!pb show [备份ID]: 展示给定备份的详细信息

!!pb rename 备份ID 新注释: 修改给定备份的注释

!!pb delete 备份ID [备份ID]: 删除给定备份。可输入多个备份ID

!!pb confirm: 确认当前的任务操作

!!pb abort: 终止当前的任务操作

更多命令可通过!!pb help查看

效果

华为云部署minecraft服务端

Sun, 09 Mar 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

前期准备

1. 服务器

选用的是华为云的Flexus云服务器X实例

4核8G
5M带宽
SSD存储
操作系统Huawei Cloud EulerOS 2.0

2. 登录

通过FinalShell，登录服务器后台。

3. JDK

从oracle官网下载jdk21

将下载好后的压缩包，通过FinalShell上传到服务器并解压

tar -zxvf jdk-21_linux-x64_bin.tar.gz

下面开始配置环境变量

编辑/etc/profile文件以设置Java环境变量

sudo vim /etc/profile

在文件末尾添加以下内容

export JAVA_HOME=/root/jdk/jdk-21.0.6
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

激活配置

source /etc/profile

验证安装

java -version
# 输出一下内容，则表示安装成功
# java version "21.0.6" 2025-01-21 LTS
# Java(TM) SE Runtime Environment (build 21.0.6+8-LTS-188)
# Java HotSpot(TM) 64-Bit Server VM (build 21.0.6+8-LTS-188, mixed mode, sharing)

4. Fabric

访问fabric官网，下载服务器核心，并上传到服务器上

启动

1. 首次启动

执行以下指令，启动服务端

# 将fabric下载下来的文件重命名为fabric-server.jar，方便执行
# （-Xmx7G表示最大7GB内存，根据服务器配置调整）
java -Xmx7G -jar fabric-server.jar nogui

首次启动会失败，并会生成eula.txt文件，需要我们编辑同意协议。

sudo vim eula.txt

# 将eula=false修改为true
eula=true

2. 配置规则

通过修改server.properties来配置服务器规则

#Minecraft server properties
#Mon Mar 10 21:18:45 CST 2025

accepts-transfers=false
# 是否接受玩家转移（例如从一个服务器到另一个服务器）

allow-flight=false
# 是否允许玩家在生存模式下飞行。

allow-nether=true
# 是否启用下界维度

broadcast-console-to-ops=true
# 是否将控制台消息广播给操作员

broadcast-rcon-to-ops=true
# 是否将RCON命令输出广播给操作员

bug-report-link=
# 错误报告链接地址

difficulty=hard
# 游戏难度级别

enable-command-block=false
# 是否启用命令方块

enable-jmx-monitoring=false
# 是否启用JMX监控

enable-query=false
# 是否启用查询协议以获取服务器信息

enable-rcon=false
# 是否启用远程控制台功能

enable-status=true
# 是否启用状态请求响应

enforce-secure-profile=true
# 是否强制执行安全配置文件

enforce-whitelist=false
# 是否强制使用白名单

entity-broadcast-range-percentage=100
# 实体广播范围百分比

force-gamemode=false
# 是否强制所有玩家进入指定的游戏模式

function-permission-level=2
# 函数权限等级

gamemode=survival
# 默认游戏模式

generate-structures=true
# 是否生成结构物如村庄、要塞等

generator-settings={}
# 世界生成器设置

hardcore=false
# 是否启用硬核模式

hide-online-players=false
# 是否隐藏在线玩家列表

initial-disabled-packs=
# 初始禁用的功能包

initial-enabled-packs=vanilla
# 初始启用的功能包，默认是原版内容

level-name=world
# 保存的世界名称

level-seed=11311638121115121
# 世界的种子值

level-type=minecraft\:normal
# 世界的类型或地形风格

log-ips=true
# 是否记录IP地址
max-chained-neighbor-updates=1000000
# 最大连锁更新次数

max-players=20
# 服务器的最大玩家数量

max-tick-time=60000
# 每个tick的最大时间限制

max-world-size=29999984
# 世界大小上限

motd=A Minecraft Server
# 服务器的欢迎信息或描述

network-compression-threshold=256
# 网络压缩阈值

online-mode=true
# 是否启用在线模式验证

op-permission-level=4
# 管理员的操作权限等级

pause-when-empty-seconds=60
# 当没有玩家时暂停的时间

player-idle-timeout=0
# 玩家空闲超时时间（分钟），0表示不超时

prevent-proxy-connections=false
# 是否阻止代理连接

pvp=true
# 是否开启玩家之间的战斗

query.port=25565
# 查询端口

rate-limit=0
# 速率限制，0表示无限制

rcon.password=
# RCON密码

rcon.port=25575
# RCON端口

region-file-compression=deflate
# 区域文件压缩方式

require-resource-pack=false
# 是否要求资源包

resource-pack=
# 资源包URL

resource-pack-id=
# 资源包ID

resource-pack-prompt=
# 资源包提示信息

resource-pack-sha1=
# 资源包SHA-1哈希值

server-ip=
# 服务器绑定的IP地址

server-port=25565
# 服务器监听的端口号

simulation-distance=10
# 模拟距离

spawn-monsters=true
# 是否生成怪物

spawn-protection=16
# 出生点保护半径

sync-chunk-writes=true
# 是否同步写入区块数据

text-filtering-config=
# 是否同步写入区块数据

text-filtering-version=0
# 文本过滤版本

use-native-transport=true
# 是否使用本地传输优化

view-distance=10
# 视距范围

white-list=false
# 是否启用白名单

3. 一键运行

新建一个start.sh，写入启动指令

java -Xmx7G -jar fabric-server.jar nogui

后续只要执行sh start.sh

但是此时如果关掉后台，服务器就停掉了。只需通过nohup挂在后台即可。

nohup sh start.sh &

4. 安全组

Activate Typora

Sun, 09 Mar 2025 00:00:00 GMT

Activation steps

Under Typora’s installation directory, open the folder Typora\resources\page-dist\static\js.

Open the JS file whose name starts with LicenseIndex, e.g. LicenseIndex.180dd4c7.bffb5802.chunk.js.

// # Change e.hasActivated="true"==e.hasActivated to
e.hasActivated = true;

Save the file as administrator, then restart Typora.

Activated

The app will show as activated.

minecraft模组：02创建工具

Fri, 07 Mar 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

前言

通过fabric编写模组，创建一套自定义工具铜镐、 铜锄、 铜锹、 铜斧、 铜剑。

工具材质

在 Minecraft 开发中，ToolMaterials 类是一个非常重要的类，它主要用于定义工具的材质属性。

首先，创建一个铜质的工具材料，统一管理耐久度,挖掘速度,攻击力,附魔能力等。

/**
 * 自定义的铜质工具材料类，实现了 ToolMaterial 接口，用于定义铜质工具的各项属性。
 */
public class CopperToolMaterial implements ToolMaterial {

    public static final CopperToolMaterial INSTANCE = new CopperToolMaterial();

    private final Supplier<Ingredient> repairIngredient = () ->
            Ingredient.ofItems(Items.COPPER_INGOT);

    // 耐久度  木制59/石制131/铁制250/金制32/钻石1561/下界合金2031
    @Override
    public int getDurability() { return 200; }

    // 挖掘速度乘数 木制2.0/石制4.0/铁制6.0/金制12.0/钻石8.0/下界合金9.0
    @Override
    public float getMiningSpeedMultiplier() {
        return 5.0f;
    }

    // 攻击伤害 木制0.0/石制1.0/铁制2.0/金制0.0/钻石4.0/下界合金4.0
    @Override
    public float getAttackDamage() {
        return 1.5f;
    }

    @Override
    public TagKey<Block> getInverseTag() {
        return BlockTags.INCORRECT_FOR_STONE_TOOL;
    }

    // 附魔能力 木制15/石制5/铁制14/金制22/钻石10/下界合金15
    @Override
    public int getEnchantability() {
        return 10;
    }

    @Override
    public Ingredient getRepairIngredient() {
        return repairIngredient.get();
    }

    // 静态方法，用于注册物品到游戏的物品注册表中
    public static Item register(Item item, String id) {
        // 创建物品的标识符
        Identifier itemID = Identifier.of("mymod", id);
        // 将物品注册到游戏的物品注册表中，并返回注册后的物品实例
        return Registry.register(Registries.ITEM, itemID, item);
    }
}

注册物品

通过register方法进行注册。分别将铜镐、铜锄、铜锹、铜斧和铜剑的攻击伤害和攻击速度修改为[3.5, 1, 4, 9, 5.5]与[1.2, 2, 1, 0.8, 1.6]

public class CopperPickaxe {
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的铜镐物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item copperPickaxe = CopperToolMaterial.register(
            new PickaxeItem(CopperToolMaterial.INSTANCE,
                    new Item.Settings().attributeModifiers(PickaxeItem.createAttributeModifiers(CopperToolMaterial.INSTANCE, 1, -2.8f))),
            "copper_pickaxe"
    );

    // 初始化
    public static void initialize() {
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.TOOLS)
                .register((itemGroup) -> itemGroup.add(copperPickaxe));
        LOGGER.info("[DEBUG] 铜镐注册完成");
    }
}

// 铜锄
public class CopperHoe {
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的铜锄物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item CopperHoe = CopperToolMaterial.register(
            new HoeItem(CopperToolMaterial.INSTANCE,
                    new Item.Settings().attributeModifiers(HoeItem.createAttributeModifiers(CopperToolMaterial.INSTANCE, -1.5f, -2))),
            "copper_hoe"
    );

    // 初始化
    public static void initialize() {
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.TOOLS)
                .register((itemGroup) -> itemGroup.add(CopperHoe));

        LOGGER.info("[DEBUG] 铜锄注册完成");
    }
}

// 铜锹
public class CopperShovel {
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的铜锹物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item CopperShovel = CopperToolMaterial.register(
            new ShovelItem(CopperToolMaterial.INSTANCE,
                    new Item.Settings().attributeModifiers(ShovelItem.createAttributeModifiers(CopperToolMaterial.INSTANCE, 1.5f, -3))),
            "copper_shovel"
    );

    // 初始化
    public static void initialize() {
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.TOOLS)
                .register((itemGroup) -> itemGroup.add(CopperShovel));

        LOGGER.info("[DEBUG] 铜锹注册完成");
    }
}

// 铜斧
public class CopperAxe {
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的铜斧物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item CopperAxe = CopperToolMaterial.register(
            new AxeItem(CopperToolMaterial.INSTANCE,
                    new Item.Settings().attributeModifiers(AxeItem.createAttributeModifiers(CopperToolMaterial.INSTANCE, 6.5f, -3.2f))),
            "copper_axe"
    );

    // 初始化
    public static void initialize() {
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.TOOLS)
                .register((itemGroup) -> itemGroup.add(CopperAxe));

        LOGGER.info("[DEBUG] 铜斧注册完成");
    }
}

// 铜剑
public class CopperSword {
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的铜剑物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item copperSword = CopperToolMaterial.register(
            new SwordItem(CopperToolMaterial.INSTANCE,
                    new Item.Settings().attributeModifiers(SwordItem.createAttributeModifiers(CopperToolMaterial.INSTANCE, 3, -2.4f))),
            "copper_sword"
    );

    // 初始化
    public static void initialize() {
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.COMBAT)
                .register((itemGroup) -> itemGroup.add(copperSword));
        LOGGER.info("[DEBUG] 铜剑注册完成");
    }
}

添加翻译

en_us

打开main\resources\assets\mymod\lang\en_us.json文件，不存在则新建，添加英语翻译

{
  "item.mymod.copper_pickaxe": "Copper Pickaxe",
  "item.mymod.copper_axe": "Copper Axe",
  "item.mymod.copper_hoe": "Copper Hoe",
  "item.mymod.copper_shovel": "Copper Shovel",
  "item.mymod.copper_sword": "Copper Sword",
}

zh_ch

打开main\resources\assets\mymod\lang\zh_ch.json文件，不存在则新建，添加中文翻译

{
  "item.mymod.copper_pickaxe": "铜镐",
  "item.mymod.copper_axe": "铜斧",
  "item.mymod.copper_hoe": "铜锄",
  "item.mymod.copper_shovel": "铜锹",
  "item.mymod.copper_sword": "铜剑",
}

添加纹理模型

在main\resources\assets\mymod\models\item文件夹下，新建copper_axe.json,copper_hoe.json,copper_pickaxe.json, copper_shovel.json,copper_sword.json等文件，写入对应模型文件。

// copper_axe.json
{
  "parent": "item/handheld",
  "textures": {
    "layer0": "mymod:item/copper_axe",
  },
}

// copper_hoe.json
{
  "parent": "item/handheld",
  "textures": {
    "layer0": "mymod:item/copper_hoe",
  },
}

// copper_pickaxe.json
{
  "parent": "item/handheld",
  "textures": {
    "layer0": "mymod:item/copper_pickaxe",
  },
}

// copper_shovel.json
{
  "parent": "item/handheld",
  "textures": {
    "layer0": "mymod:item/copper_shovel",
  },
}

// copper_sword.json
{
  "parent": "item/handheld",
  "textures": {
    "layer0": "mymod:item/copper_sword",
  },
}

需要注意的是，此时parent填入的是item/handheld模型，表示物品将使用默认的手持物品显示方式。

在main\resources\assets\mymod\textures\item文件夹下,放入对应纹理文件。

合成

以上的代码已经可以在游戏里正常工作了，但是想要在生存模式中使用，就需要设计对应的合成方式。

在main\resources\data\mymod\recipe文件夹下，分别新建对应工具的json文件，写入合成方式。

铜镐

// copper_pickaxe.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    "ccc",
    " / ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_pickaxe",
    "count": 1,
  },
}

铜铲

// copper_shovel.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    " c ",
    " / ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_shovel",
    "count": 1,
  },
}

铜锄

// copper_hoe.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    "cc ",
    " / ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_hoe",
    "count": 1,
  },
}

// copper_hoe2.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    " cc",
    " / ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_hoe",
    "count": 1,
  },
}

铜剑

// copper_sword.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    " c ",
    " c ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_sword",
    "count": 1,
  },
}

铜斧

// copper_axe.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    "cc ",
    "c/ ",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_axe",
    "count": 1,
  },
}

// copper_axe2.json 第二种合成方式
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    " cc",
    " /c",
    " / ",
  ],
  "key": {
    "c": {
      "item": "minecraft:copper_ingot",
    },
    "/": {
      "item": "minecraft:stick",
    },
  },
  "result": {
    "id": "mymod:copper_axe",
    "count": 1,
  },
}

附魔

当这些自定义工具，放置到附魔台上时，发现无法进行附魔。查阅了一些资料发现，需要对这些工具打上附魔的tag标签。同样在main\resources\data\minecraft\tags\item\enchantable文件夹下(文件夹不存在则新建),分别创建mining.json和sword.json文件。

// mining.json
{
  "replace": false,
  "values": [
    "mymod:copper_axe",
    "mymod:copper_hoe",
    "mymod:copper_pickaxe",
    "mymod:copper_shovel",
  ],
}

// sword.json
{
  "replace": false,
  "values": [
    "mymod:copper_sword",
  ],
}

此时，放到附魔台上就可以正常附魔了。

实现效果

minecraft模组：01创建物品

Sun, 02 Mar 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

示例

通过fabric编写模组，创建一个自定义物品腐烂的苹果

合成：腐肉+苹果
效果：食用后，80%的概率中毒

新建项目

选择Minecraft生成器, 选择对应的minecraft版本，frabic版本及模组名称等

创建物品类

在main中创建一个类RottenApple来实现自定义物品

public class RottenApple{
    // 创建一个日志记录器
    public static final Logger LOGGER = LoggerFactory.getLogger("MyMod");

    // 定义一个静态的食物组件，用于表示腐烂的食物属性
    public static final FoodComponent ROTTEN_FOOD_COMPONENT = new FoodComponent.Builder()
            .alwaysEdible()
            // 添加中毒状态效果，持续 6 秒（120 游戏刻），等级为 0，触发概率为 80%
            .statusEffect(new StatusEffectInstance(StatusEffects.POISON, 6 * 20, 0), 0.8f)
            .build();

    // 用于在物品上添加自定义的提示信息
    static class CustomToolTip extends Item {
        static String tips;
        public CustomToolTip(Settings settings, String tip) {
            super(settings);
            tips = tip;
        }

        @Override
        public void appendTooltip(ItemStack stack, TooltipContext context, List<Text> tooltip, TooltipType type) {
            tooltip.add(Text.translatable(tips).styled(s -> s.withColor(0x6D4C41)));
        }
    }

    // 定义一个静态的腐烂苹果物品实例, 并通过 register 方法将该物品注册到游戏中
    public static final Item RottenApple = register(
            new CustomToolTip(new Item.Settings().food(ROTTEN_FOOD_COMPONENT), "腐烂的"),
            "rotten_apple"
    );

    // 静态方法，用于注册物品到游戏的物品注册表中
    public static Item register(Item item, String id) {
        // 创建物品的标识符
        Identifier itemID = Identifier.of("mymod", id);
        // 将物品注册到游戏的物品注册表中，并返回注册后的物品实例
        return Registry.register(Registries.ITEM, itemID, item);
    }

    // 初始化
    public static void initialize() {
        // 将物品添加到 FOOD_AND_DRINK 物品组中
        ItemGroupEvents.modifyEntriesEvent(ItemGroups.FOOD_AND_DRINK)
                .register((itemGroup) -> itemGroup.add(RottenApple));

        // 将腐烂苹果物品添加到堆肥机会注册表中，有 30% 的概率增加堆肥器的等级
        CompostingChanceRegistry.INSTANCE.add(RottenApple, 0.3f);

        LOGGER.info("[DEBUG] 物品注册完成");
    }

}

在Mymod中进行模组初始化

public class Mymod implements ModInitializer {

    @Override
    public void onInitialize() {
        RottenApple.initialize();
    }
}

在gradle中，选择fabric,运行runClient，进入游戏。新建游戏后，在物品栏中可以看到我们新建的物品。

但是此时，物品名称和纹理都还没有添加

添加翻译

在main\resources\assets\mymod\lang文件夹中，新建一个en_us.json (如果文件夹不存在则新建)

写入翻译和名称

{
  "item.mymod.rotten_apple": "RottenApple",
}

添加纹理和模型

模型

在main\resources\assets\mymod\models\item文件夹中，新建一个rotten_apple.json(如果文件夹不存在则新建)

写入模型数据

{
  "parent": "item/generated",
  "textures": {
    "layer0": "mymod:item/rotten_apple",
  },
}

parent 模型要继承的父模型。大多物品继承的模型是 item/generate, 也有其他的，比如 item/handheld，用于拿在玩家手中的物品，例如工具。
textures 为模型定义纹理的地方。 layer0 是模型使用的纹理。

纹理

将纹理文件放在main\resources\assets\mymod\textures\item文件夹中，并命名为rotten_apple.png(如果文件夹不存在则新建)

需要注意的是:

必须是png格式的文件
像素需要是16×16或32×32

合成配方

通过腐肉 + 苹果 进行无序合成

在main\resources\data\mymod\recipe文件夹中，新建一个rotten_apple.json(如果文件夹不存在则新建)

写入合成配方(无序合成)

{
  "type": "minecraft:crafting_shapeless",
  "ingredients": [
    {
      "item": "minecraft:rotten_flesh",
    },
    {
      "item": "minecraft:apple",
    },
  ],
  "result": {
    "id": "mymod:rotten_apple",
    "count": 1,
  },
}

实现效果

minecraft铁傀儡生成机制

Thu, 27 Feb 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

生成条件

在Java版里，不管村民是惊慌还是交谈，都能生成铁傀儡。

村民尝试生成铁傀儡时，系统最多试十次，在以村民为中心，水平 ±8 格、垂直 ±6 格（17×13×17 格范围）内生成。

每次尝试，系统会在该范围随机选个 1×1、高 13 格的柱状区域，从顶向下找合适位置生成铁傀儡，找不到就失败。若多个位置 X、Z 坐标一样，铁傀儡只在最高处生成，低处即便合适也不行。

铁傀儡的合适位置需符合以下条件：

该处需为空气或液体
该处下方的方块必须是固体方块或细雪
该处下方不能是下列方块：
- 冰
- 浮冰
- 玻璃（含染色与遮光变种）
- 玻璃板（含染色变种）
- 树叶
- 仙人掌
- TNT
- 蜘蛛网
- 信标
- 荧石
- 海晶灯
- 潮涌核心

选定合适位置后，若该位置下方为可生成方块，且生成的铁傀儡不会和任何其他实体和方块的碰撞箱碰撞，则铁傀儡会被生成在此处；否则，此次尝试失败。

恐慌

村民在遇到敌对生物时，会进入惊慌状态。村民对敌对生物的感知距离如下:

private static final ImmutableMap<EntityType<?>, Float> SQUARED_DISTANCES_FOR_DANGER = ImmutableMap.<EntityType<?>, Float>builder()
    .put(EntityType.DROWNED, 8.0F)  // 溺尸：8格
    .put(EntityType.EVOKER, 12.0F)  // 唤魔者：12格
    .put(EntityType.HUSK, 8.0F)  // 尸壳：8格
    .put(EntityType.ILLUSIONER, 12.0F)  // 幻术师：12格
    .put(EntityType.PILLAGER, 15.0F)  // 掠夺者：15格
    .put(EntityType.RAVAGER, 12.0F)  // 劫掠兽：12格
    .put(EntityType.VEX, 8.0F)  // 恼鬼：8格
    .put(EntityType.VINDICATOR, 10.0F)  // 卫道士：10格
    .put(EntityType.ZOGLIN, 10.0F)  // 僵尸疣猪兽：10格
    .put(EntityType.ZOMBIE, 8.0F)  // 僵尸：8格
    .put(EntityType.ZOMBIE_VILLAGER, 8.0F)  // 僵尸村民：8格
    .build();

在惊慌状态的村民会每100游戏刻（5秒）尝试生成一次铁傀儡，若周围有2个有意愿生成铁傀儡的村民（一共3个村民），就会判定成功进行生成。

protected void keepRunning(ServerWorld serverWorld, VillagerEntity villagerEntity, long l) {
    if (l % 100L == 0L) {
        villagerEntity.summonGolem(serverWorld, l, 3);
    }
}

交谈

如果村民不处于惊慌状态，村民会每1200游戏刻（60秒）传播一次言论，若周围有4个村民同样有生成铁傀儡的意愿（一共5个村民），就会判定成功进行生成步骤。

public void talkWithVillager(ServerWorld world, VillagerEntity villager, long time) {
    if ((time < this.gossipStartTime || time >= this.gossipStartTime + 1200L) && (time < villager.gossipStartTime || time >= villager.gossipStartTime + 1200L)) {
        // 分享来自另一个村民的言论
        this.gossip.shareGossipFrom(villager.gossip, this.random, 10);
        this.gossipStartTime = time;
        villager.gossipStartTime = time;
        // 尝试在给定的世界中生成一个铁傀儡
        this.summonGolem(world, time, 5);
    }
}

生成

public boolean canSummonGolem(long time) {
    // 如果最近没有睡觉且记忆中没有记录最近检测到铁傀儡，则可以召唤
    return !this.hasRecentlySlept(this.getWorld().getTime()) ? false : !this.brain.hasMemoryModule(MemoryModuleType.GOLEM_DETECTED_RECENTLY);
}

public void summonGolem(ServerWorld world, long time, int requiredCount) {
    if (this.canSummonGolem(time)) {
        Box box = this.getBoundingBox().expand(10.0, 10.0, 10.0);
        // 在指定区域内查找所有村民实体
        List<VillagerEntity> list = world.getNonSpectatingEntities(VillagerEntity.class, box);
        List<VillagerEntity> list2 = list.stream().filter(villager -> villager.canSummonGolem(time)).limit(5L).toList();
        // 尝试召唤铁傀儡
        if (list2.size() >= requiredCount) {
            if (!LargeEntitySpawnHelper.trySpawnAt(
                    EntityType.IRON_GOLEM, SpawnReason.MOB_SUMMONED, world, this.getBlockPos(), 10, 8, 6, LargeEntitySpawnHelper.Requirements.IRON_GOLEM, false
                )
                .isEmpty()) {
                // 遍历所有村民并记录他们看到铁傀儡的时间
                list.forEach(GolemLastSeenSensor::rememberIronGolem);
            }
        }
    }
}

冷却

当铁傀儡生成之后，以该村民为中心周围10格内的所有村民会进入600游戏刻（30秒）的冷却时间。

// 让实体记住它最近看到了铁傀儡的方法
public static void rememberIronGolem(LivingEntity entity) {
    // 设置“Golem Detected Recently”的记忆为true，并设置过期时间为599毫秒
    entity.getBrain().remember(MemoryModuleType.GOLEM_DETECTED_RECENTLY, true, 599L);
}

minecraft刷怪机制

Tue, 25 Feb 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

生物类别

minecraft中生物被划分为8种类别，分别为怪物（Monster）、动物（Creature）、环境生物（Ambient）、美西螈（Axolotls）、地下水生生物（Underground Water Creature）、水生生物（Water Creature）、水下环境生物（Water Ambient）和其他（Misc）。

| 类别 | 上限乘数 | 友好生物 | 自动清除 | 清除半径 | | ------------ | -------- | -------- | -------- | -------- | | 怪物 | 70 | 否 | 是 | 128 | | 动物 | 10 | 是 | 否 | 128 | | 环境生物 | 15 | 是 | 是 | 128 | | 美西螈 | 5 | 是 | 是 | 128 | | 地下水生生物 | 5 | 是 | 是 | 128 | | 水生生物 | 5 | 是 | 是 | 128 | | 水下环境生物 | 20 | 是 | 是 | 64 | | 其他 | -1 | 是 | 否 | 128 |

public enum SpawnGroup implements StringIdentifiable {
	MONSTER("monster", 70, false, false, 128),
	CREATURE("creature", 10, true, true, 128),
	AMBIENT("ambient", 15, true, false, 128),
	AXOLOTLS("axolotls", 5, true, false, 128),
	UNDERGROUND_WATER_CREATURE("underground_water_creature", 5, true, false, 128),
	WATER_CREATURE("water_creature", 5, true, false, 128),
	WATER_AMBIENT("water_ambient", 20, true, false, 64),
	MISC("misc", -1, true, true, 128);
    //...
}

生成上限

为了阻止生物无限生成，每个生物类别都有它们的生成上限数量。生成上限数量不仅与类别本身有关，也与玩家有关。

以每个玩家所在区块为中心的17×17区块都被认为是可生成区块，而每个生物类别的生成上限m是可生成区块数量c、生物类别上限乘数a之积除以289得到的，即m=ac/289。

当仅有一位玩家时生成上限m就等于上线乘数a，即m=a
当存在n名玩家时假如所有玩家所在的可生成区块互不干扰，则生成上限为最大值na，假如所有玩家在同一个区块，则生成上限与一名玩家相同为a。因此该情况下，生成上限m在[a, na]范围之间。

生成条件

光照条件：天空光小于等于7，方块光等于0。
空间要求：下方必须是非透明方块。僵尸/骷髅需要至少2格高，蜘蛛需要至少3格宽的空间。
玩家距离：距离玩家半径24~128的球形区域。
生成上限：超过生成上限时，将生成失败。
碰撞箱检测：生成时需满足碰撞箱无遮挡。

核心步骤

1. 生物群系筛选

根据生物群系配置获取可生成的生物列表，并基于群系生成概率决定是否进入生成循环。

SpawnSettings spawnSettings = biomeEntry.value().getSpawnSettings();
Pool<SpawnSettings.SpawnEntry> pool = spawnSettings.getSpawnEntries(SpawnGroup.CREATURE);
if (!pool.isEmpty()) {
    int i = chunkPos.getStartX();
    int j = chunkPos.getStartZ();

    while (random.nextFloat() < spawnSettings.getCreatureSpawnProbability()) {
    // ...
    }
    // ...
}

2. 初始点

X/Z轴在区块内随机选择初始点，Y轴从非透明方块的最高点+1到世界底部的随机值

private static BlockPos getRandomPosInChunkSection(World world, WorldChunk chunk) {
    ChunkPos chunkPos = chunk.getPos();
    int i = chunkPos.getStartX() + world.random.nextInt(16);
    int j = chunkPos.getStartZ() + world.random.nextInt(16);
    int k = chunk.sampleHeightmap(Heightmap.Type.WORLD_SURFACE, i, j) + 1;
    int l = MathHelper.nextBetween(world.random, world.getBottomY(), k);
    return new BlockPos(i, l, j);
}

3. 生成尝试

每个初始点触发3次生成游走尝试

 // 外层循环：3次生成游走尝试
for (int k = 0; k < 3; k++) {
    int l = pos.getX(); // 初始X坐标
    int m = pos.getZ(); // 初始Z坐标
    SpawnSettings.SpawnEntry spawnEntry = null; // 当前生成的生物配置
    EntityData entityData = null; // 生物初始化数据
    // 计算本次游走的生成尝试次数（1-4次）
    int o = MathHelper.ceil(world.random.nextFloat() * 4.0F);
    int p = 0; // 本次游走已生成的生物数

    // 内层循环：单次游走中的生成尝试
    for (int q = 0; q < o; q++) {
        // 随机偏移坐标（X/Z各±0-5格）
        l += world.random.nextInt(6) - world.random.nextInt(6);
        m += world.random.nextInt(6) - world.random.nextInt(6);
        mutable.set(l, i, m); // 设置候选坐标

        // 计算精确坐标（用于距离检查）
        double d = (double)l + 0.5;
        double e = (double)m + 0.5;
        // 查找最近玩家（用于距离判定）
        PlayerEntity playerEntity = world.getClosestPlayer(d, (double)i, e, -1.0, false);

        if (playerEntity != null) {
            // 计算与玩家的平方距离（优化计算）
            double f = playerEntity.squaredDistanceTo(d, (double)i, e);

            // 检查候选位置是否合法
            if (isAcceptableSpawnPosition(world, chunk, mutable, f)) {
                // 首次生成时选择生物类型
                if (spawnEntry == null) {
                    // 根据群系/结构选择可生成的生物条目
                    Optional<SpawnSettings.SpawnEntry> optional = pickRandomSpawnEntry(
                        world, structureAccessor, chunkGenerator, group, world.random, mutable
                    );
                    if (optional.isEmpty()) break; // 无可用生物则终止本次游走

                    spawnEntry = optional.get();
                    // 动态调整生成次数（基于生物群大小）
                    o = spawnEntry.minGroupSize + world.random.nextInt(
                        1 + spawnEntry.maxGroupSize - spawnEntry.minGroupSize
                    );
                }

                // 最终生成条件验证
                if (canSpawn(world, group, structureAccessor, chunkGenerator, spawnEntry, mutable, f)
                    && checker.test(spawnEntry.type, mutable, chunk)) { // 自定义条件检查

                    // 创建生物实体
                    MobEntity mobEntity = createMob(world, spawnEntry.type);
                    if (mobEntity == null) return; // 创建失败终止方法

                    // 设置生物位置和角度
                    mobEntity.refreshPositionAndAngles(d, (double)i, e,
                        world.random.nextFloat() * 360.0F, 0.0F);

                    // 验证生物生成合法性
                    if (isValidSpawn(world, mobEntity, f)) {
                        // 初始化生物（生成装备/设置属性）
                        entityData = mobEntity.initialize(world,
                            world.getLocalDifficulty(mobEntity.getBlockPos()),
                            SpawnReason.NATURAL,
                            entityData
                        );

                        // 更新计数器
                        j++;
                        p++;

                        // 将生物加入世界
                        world.spawnEntityAndPassengers(mobEntity);
                        runner.run(mobEntity, chunk); // 执行生成后回调

                        // 检查区块生物上限
                        if (j >= mobEntity.getLimitPerChunk()) {
                            return; // 达到上限立即终止
                        }

                        // 检查单次尝试生成数限制（如末影人最多生成1只）
                        if (mobEntity.spawnsTooManyForEachTry(p)) {
                            break;
                        }
                    }
                }
            }
        }
    } // 结束内层循环
} // 结束外层循环

生成验证

满足以下条件，将导致生成失败

玩家距离过近或过远
光照条件不符合
空间不足
生物群系或结构不匹配
密度上限已满
碰撞箱被遮挡
生物类型不可生成

LC值对刷怪的影响

LC(Loaded Chunk)，即玩家所在区块的最大渲染区段高度，一般是16的倍数减1。在核心步骤中的第2步，选择随机初始点时，会随机在最高的非透明方块所在位置+1与世界底部之间取一个值，作为刷怪初始点的高度。

当 LC 值低时，意味着最高遮光方块的纵坐标较低，刷怪初始点可选择的高度范围小，就有更大的概率选到合适的刷怪高度，从而提高刷怪成功率。
若 LC 值高，比如刷怪平台建在 y=100 处，那么 y 轴坐标可能是 0-101 之间的任何一个数，选到刚好能刷怪高度的概率就低，刷怪效率自然下降。

minecraft药水酿造

Sun, 23 Feb 2025 00:00:00 GMT

药水

minecraft药水分为基础药水（无效果，如粗制药水）、正面效果药水（如力量、夜视）、负面效果药水（如虚弱、剧毒）和混合效果药水（如隐身）。部分药水还可通过添加火药或龙息制成喷溅型或滞留型，实现群体效果。

酿造设备

酿造台：用于添加材料到玻璃瓶里。
炼药锅：用于储存水，可以装满3个玻璃瓶。
烈焰粉：酿造台的燃料。
玻璃瓶：所有药水的容器。
水瓶：所有药水的基础。将一个玻璃瓶从水源或是炼药锅里装水获得。

酿造流程

制作水瓶（玻璃瓶装水）。
加入地狱疣酿造粗制药水（大多数药水的基础）。
添加特定材料（如糖→速度药水、金萝卜→夜视药水）。
可选：用萤石增强效果或红石延长持续时间。

机制

叠加

同种药水效果不可叠加，以最高等级或剩余时间覆盖。
部分效果（如抗火、缓降）可与其他增益共存。

投掷

喷溅型药水垂直向上扔出可保留完整效果时间，若随意投掷可能缩短效果。

亡灵生物

亡灵生物（如僵尸）受治疗药水伤害，但被伤害药水治疗。剧毒和再生药水对其无效。

minecraft村民交易

Fri, 21 Feb 2025 00:00:00 GMT

交易基础

minecraft村民共有13种职业（如农民、图书管理员、盔甲匠等），每种职业对应特定工作站点（如讲台对应图书管理员）。失业村民会绑定未被占用的工作站点转职，但傻子村民（穿绿袍）无法交易。

交易机制

工作站点: 村民共有13种职业，每种对应特定工作站点方块（如讲台→图书管理员，高炉→盔甲匠）。失业村民会绑定附近未被占用的工作站转职，但傻子村民（绿袍）无法交易
交易层级: 交易分新手、学徒、老手、专家、大师共5个等级，需完成当前层级交易才能解锁下一层级选项
补货规则: 交易次数耗尽后，村民需接触工作站和床补货，每天最多补货2次
价格波动: 频繁交易同一物品会暂时涨价，补货后价格重置。治愈被僵尸感染的村民或获得村庄英雄效果时可极大降低交易价格

交易内容

盔甲商[高炉]

屠夫[烟熏炉]

制图师[制图台]

牧师[酿造台]

农民[堆肥桶]

渔夫[木桶]

制箭师[制箭台]

皮匠[炼药锅]

图书管理员[讲台]

石匠[切石机]

牧羊人[织布机]

工具匠[锻造台]

武器匠[砂轮]

失业

没有穿着职业着装，只有对应生物群系的衣服的村民为失业村民，它们无法进行交易。

傻子

傻子是穿着绿色袍子的村民。自然生成的傻子不会提供任何交易。与失业村民不同的是，傻子不能获得以及改变职业。

生成minecraft源码

Thu, 20 Feb 2025 00:00:00 GMT

说明

Minecraft的官方源码始终未公开，其Java版客户端通过混淆技术对类名、方法名进行随机化处理（如a()、b()等无意义命名）。而通过Fabric生成的源码本质是：

反编译产物：基于Mojang发布的JAR包，使用CFR反编译器生成
社区映射：通过Yarn项目（社区维护的映射表）将混淆名称转为语义化命名（如method_1234→calculateBlockDamage）
受限结构：仅包含游戏运行时核心逻辑（如net.minecraft.block包），不包含渲染引擎等闭源模块

注意事项

生成的源码不可二次分发（违反Mojang EULA第2节）
生成的源码与Minecraft版本严格绑定（如1.20.1生成的类无法直接用于1.21开发）
禁止直接修改生成的源码（修改无效，需通过Mixin或API注入）

环境准备

安装JDK 17+{hugeicons:java}
安装IntelliJ IDEA{devicon:intellij}
安装插件Minecraft Development（自动配置Fabric）

生成步骤

下载fabric模组模板
修改Gradle配置

# settings.gradle 添加镜像源
repositories {
    maven { url 'https://maven.aliyun.com/nexus/content/groups/public' }
    maven { url 'https://repository.hanbings.io/proxy' }
}

执行生成命令

# 控制台运行
./gradlew genSources

验证生成结果

在IDEA中的外部库中可以查看到net.minecraft:minecraft-<版本>@merged-named 展开net.minecraft包查看反编译后的Yarn映射源码

本地部署deepseek-r1

Tue, 18 Feb 2025 00:00:00 GMT

import { Card } from 'astro-pure/user' import { Aside } from 'astro-pure/user'

模型参数

deepseek-r1模型不同参数的特点，适用场景及硬件配置如下，根据自己实际情况选择对应版本。

| DeepSeek 模型版本 | 参数量 | 特点 | 适用场景 | 推荐硬件配置 | | -------------------- | ------ | -------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | | DeepSeek - R1 - 1.5B | 1.5B | 轻量级，参数量与规模小 | 短文本生成、基础问答等轻量级任务 | 4 核处理器、8G 内存，无需显卡 | | DeepSeek - R1 - 7B | 7B | 性能与硬件需求较平衡 | 文案撰写、表格处理、统计分析等中等复杂度任务 | 8 核处理器、16G 内存，Ryzen 7 或更高 CPU，RTX 3060（12GB）或更高显卡 | | DeepSeek - R1 - 8B | 8B | 性能略优于 7B 模型 | 代码生成、逻辑推理等高精度轻量级任务 | 8 核处理器、16G 内存，Ryzen 7 或更高 CPU，RTX 3060（12GB）或 4060 显卡 | | DeepSeek - R1 - 14B | 14B | 高性能，擅长复杂任务 | 长文本生成、数据分析等复杂任务 | i9 - 13900K 或更高 CPU、32G 内存，RTX 4090（24GB）或 A5000 显卡 | | DeepSeek - R1 - 32B | 32B | 专业级，性能强大 | 语言建模、大规模训练、金融预测等超大规模任务 | Xeon 8 核（80GB）或更高配置 | | DeepSeek - R1 - 70B | 70B | 顶级性能，适合大规模与高复杂计算 | 多模态任务预处理等高精度专业领域任务，适用于预算充足的企业或研究机构 | Xeon 8 核、128GB 内存或更高，8 张 A100/H100（80GB）或更高 | | DeepSeek - R1 - 671B | 671B | 超大规模，性能卓越、推理快 | 气候建模、基因组分析等国家级 / 超大规模 AI 研究及通用人工智能探索 | 64 核、512GB 或更高，8 张 A100/H100 |

<Card as='a' href='https://zhuanlan.zhihu.com/p/22524204610' heading='百亿云互联' subheading='DeepSeek-R1模型1.5B/7B/14B/70B/671B区别及硬件配置要求' date='August 2021'

本人部署的是8b版本，可以做到流畅推理。

部署

安装ollama

进入ollama官网，点击download后，选择对应电脑系统进行下载安装

下载模型

回到ollama官网，在搜索栏中搜索deepseek-r1

选择对应参数模型，复制指令。

这里选择8b的模型，以管理员身份打开终端，运行复制的指令。

ollama run deepseek-r1:8b

等待模型下载安装完成。后续在终端中执行刚才的指令，就可以调用该模型来推理了。

可视化

安装chatbox

进入Chatbox官网，点击下载后，选择对应电脑系统进行下载安装

模型设置

打开安装好后的chatbox，点击设置，将模型提供方选择为OLLAMA API，模型中会自动加载在ollama中下载部署好的模型。

使用

WPF依赖属性的注册与绑定

Tue, 11 Feb 2025 00:00:00 GMT

说明

依赖属性是 WPF 中的一种特殊属性，它扩展了传统的 .NET 属性，提供了更多功能，如数据绑定、动画、样式和资源支持。依赖属性的值不存储在对象本身，而是由 WPF 属性系统管理，这使得它们能够支持继承、默认值和值优先级等特性。

和普通属性区别

| | 普通属性 | 依赖属性 | | ------------ | ---------------------------------------- | ------------------------------------------------- | | 存储方式 | 值直接存储在类的字段中 | 值由 WPF 属性系统管理，存储在全局的依赖属性系统中 | | 功能支持 | 功能有限，不支持数据绑定、动画等高级特性 | 支持数据绑定、动画、样式、资源等高级功能 | | 值优先级 | 只有一个值来源 | 支持多个值来源，并根据优先级决定最终值 |

注册

依赖属性通过 DependencyProperty.Register 方法注册。以下是一个简单的例子：

public class LineChart : Control
{
    public static readonly DependencyProperty ValuesProperty =
        DependencyProperty.Register(
            "Values",     // 属性名称
            typeof(ObservableCollection<double>),   // 属性类型
            typeof(LineChart), // 所属类型
            new PropertyMetadata(null, OnValuesChanged)); // 默认值，添加回调方法

    public ObservableCollection<double> Values
    {
        get { return (ObservableCollection<double>)GetValue(ValuesProperty); }
        set { SetValue(ValuesProperty, value); }
    }

    private static void OnValuesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
       // 回调方法
       var chart = (LineChart)d;
        var newValues = (ObservableCollection<double>)e.NewValue;
        // 更新 Series 的 Values
        if (chart.Series is LineSeries<double> series)
        {
            series.Values = newValues;
        }
    }
}

绑定

<livecharts:LineChart Values="{Binding Values}"/>

在这个例子中LineChart控件的Values 绑定到 DataContext 中的 Values。

总结

依赖属性是 WPF 中用于支持高级功能的特殊属性。
通过 DependencyProperty.Register 方法注册依赖属性。
依赖属性支持数据绑定、动画、样式等高级功能。
依赖属性的值由 WPF 属性系统管理，支持多个值来源和优先级。

通过依赖属性，WPF 提供了强大的 UI 开发能力，使得开发者能够更灵活地构建复杂的用户界面。

CSharp资源释放管理

Sat, 08 Feb 2025 00:00:00 GMT

背景

在 .NET 中，IDisposable接口是一个非常重要的接口，它主要用于管理非托管资源的释放。非托管资源是指那些不受 .NET 垃圾回收器（GC）管理的资源，例如文件句柄、数据库连接、网络套接字等。

当你使用完这些资源后，需要及时释放它们以避免资源泄漏。IDisposable接口提供了一种标准的方式来实现资源的释放逻辑。

举例

实现接口

/// <summary>
/// YOLOv8 目标检测预测器，提供基于ONNX模型的物体检测功能
/// </summary>
public class YoloV8Predictor: IDisposable
{
    private readonly Yolo yolo;   // yolo预测器

    public YoloV8Predictor()
    {
        // 初始化预测器
    }

    public void Detect()
    {
        // ... 目标检测
    }
    private bool disposedValue;
    // 受保护的虚方法，用于释放资源
    protected virtual void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                // 释放托管资源
                yolo.Dispose();
            }
            // 释放非托管资源
            disposedValue = true;
        }
    }
	// 实现 IDisposable 接口的 Dispose 方法
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
     // 终结器，用于在对象被垃圾回收时释放资源
    ~YoloV8Predictor()
    {
        Dispose(false);
    }
}

Dispose 方法调用了受保护的虚方法 Dispose(bool disposing)，根据 disposedValue 参数的值来决定是否释放托管资源。
提供了一个终结器 ~YoloV8Predictor()，用于在对象被垃圾回收时释放非托管资源。

调用

using YoloV8Predictor yolov8 = new();  // 使用 using 语句确保资源被正确释放
yolov8.Detect();

总结

IDisposable 接口为管理非托管资源提供了一种标准的方式，通过实现该接口并在 Dispose 方法中编写释放资源的代码，可以确保资源在不再使用时被及时释放，避免资源泄漏。同时，使用 using 语句可以简化资源的管理，确保资源在作用域结束时自动释放。

CSharp使用uiautomator

Fri, 07 Feb 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user' import { GithubCard } from 'astro-pure/advanced'

开发背景

uiautomator是Android平台上用于UI自动化测试的框架，可模拟用户对设备屏幕的各种操作，如点击、输入、滑动等。

Python中有相对成熟的解决方案，普遍应用于自动化测试中。项目地址：

然而，近期在C#项目的开发进程中，我始终未能找到合适的解决方案。基于此状况，我计划借鉴该项目，着手打造一个C#版本的项目。

原理研究

首先先了解一下，该项目实现UIAutomator的原理。

简单来说，其实现原理是：在手机内开启一个rpc服务，然后PC端借助adb forward（adb转发）将该服务在手机中的端口转发至本地。随后，PC端向此服务发送诸如点击、输入之类的请求，手机中的该服务便会执行相应操作来完成这些请求。

尝试一下

通过以下指令，将U2.jar导入到设备中并启动一个端口固定为9008的服务端

adb push u2.jar /data/local/tmp
adb shell "CLASSPATH=/data/local/tmp/u2.jar app_process / com.wetest.uia2.Main"

通过adb的端口转发功能，随机一个端口与9008形成映射

adb forward tcp:1234 tcp:9008

此时python给本地的1234端口发送信息, 设备中的服务端也能同时接收到。

但是，还需要了解发送的是什么信息。通过修改python的uiautomator2源码(如下图所示),打印相关信息。

执行下面的代码

import uiautomator2 as u2
d = u2.connect()
d.press("home")

打印出

method: GET
url: http://127.0.0.1:1234/ping
data: None
return: b'pong'
=================
method: POST
url: http://127.0.0.1:1234/jsonrpc/0
data: {'jsonrpc': '2.0', 'id': 1, 'method': 'pressKey', 'params': ('home',)}
return: b'{"jsonrpc":"2.0","id":1,"result":true}\n'
=================

可以推测Get请求只是用来获取服务端的状态，具体的执行是需要发送Post请求的。关键则在于post请求中的data数据。

因此，只要C#也发送相同的请求，理论上也可以实现同样的效果。

代码实现

/// <summary> 用于启动u2.jar服务并在后台挂载 </summary>
public class MockAdbProcess
{
    private static readonly object _lock = new object();
    private Process _process;
    private string _serial;

    public string Serial
    {
        get { return _serial; }
        set { _serial = value; }
    }

    public MockAdbProcess(string serial)
    {
        Serial = serial;
        StartUiautomatorServer();
        AppDomain.CurrentDomain.ProcessExit += OnProcessExit;
    }

    private void StartUiautomatorServer()
    {
        StopUiautomatorServer();
        string cmd = $"adb -s {Serial} shell \"CLASSPATH=/data/local/tmp/u2.jar app_process / com.wetest.uia2.Main\"";
        ProcessStartInfo startInfo = new()
        {
            FileName = "cmd.exe",
            Arguments = $"/c {cmd}",
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true,
            WindowStyle = ProcessWindowStyle.Hidden
        };

        Log.Info($"launch uiautomator with cmd: {cmd}");
        _process = new Process { StartInfo = startInfo };
        _process.Start();

        // 读取错误信息
        _process.ErrorDataReceived += (sender, e) =>
        {
            if(e.Data==null)
            if(e.Data != null && e.Data.Contains("UiAutomation not connected"))
            {
                Log.Error("UiAutomation not connected.");
            }
        };
        _process.BeginErrorReadLine();
    }

    public void StopUiautomatorServer()
    {
        string input = NProcess.RunReturnString($"adb -s {Serial} shell ps -A -ef|findstr com.wetest.uia2.Main");
        // 定义正则表达式模式来匹配PID
        string pattern = @"shell\s+(\d+)";
        // 创建Regex对象
        Regex regex = new(pattern);
        // 查找所有匹配的PID
        MatchCollection matches = regex.Matches(input);
        // 输出所有匹配的PID
        foreach (Match match in matches)
        {
            string pid = match.Groups[1].Value;
            NProcess.RunReturnString($"adb -s {Serial} shell kill -9 {pid}");
            Log.Debug($"kill uiautomatorServer pid: {pid}");
        }
    }

    public void Kill()
    {
        StopUiautomatorServer();
        if (_process != null && !_process.HasExited)
        {
            try
            {
                _process.Kill();
                _process.WaitForExit();
                Log.Info("Process has been killed and exited.");
            }
            catch (Exception ex)
            {
                Log.Error($"Failed to kill the process: {ex.Message}");
            }
        }
    }

    private void OnProcessExit(object sender, EventArgs e)
    {
        Kill();
    }

    public void Dispose()
    {
        Kill();
    }
}

public class U2Device
{
    private MockAdbProcess _process;
    private string _serial = string.Empty;
    private ADB _adb;
    private static readonly SemaphoreSlim _semaphore = new(1, 1);  // 创建一个 SemaphoreSlim，最大并发数为 1
    private string urlBase = "http://127.0.0.1";

    public string Serial
    {
        get { return _serial; }
        set { _serial = value; }
    }

    /// <summary>
    /// 构造方法。
    /// </summary>
    /// <param name="serial">设备的序列号。如果未指定，则使用第一个连接的设备。</param>
    public U2Device(string serial = "")
    {
        if (string.IsNullOrEmpty(serial))
        {
            List<string> devices = ADB.Devices();
            if (devices.Count > 0)
            {
                Serial = devices[0]; // 如果有设备连接，则使用第一个设备
            }
            else
            {
                throw new InvalidOperationException("no devices/emulators found");
            }
        }
        else
        {
            Serial = serial;
        }
        _adb = new ADB(Serial);
        string port = _adb.GetForwardPort();
        urlBase = $"http://127.0.0.1:{port}";
    }

    /// <summary>
    /// 安装U2工具的JAR文件。如果指定了重新安装，则先删除现有的JAR文件，然后检查并推送新的JAR文件到指定目录。
    /// </summary>
    /// <param name="reinstall">是否重新安装U2工具的JAR文件，默认为false。</param>
    public void SetupJar(bool reinstall=false)
    {
        if (reinstall)
        {
            _adb.FileRemove("/data/local/tmp/u2.jar");
        }
        if (!_adb.FileExists("/data/local/tmp/u2.jar"))
        {
            _adb.Push("Assets/u2/u2.jar", "/data/local/tmp");
        }
    }

    /// <summary>
    /// 检查U2设备是否在线（响应"pong"）。
    /// </summary>
    /// <returns>如果设备在线并响应"pong"，则返回true；否则返回false。</returns>
    public bool Live()
    {
        string r = Requests.Get($"{urlBase}/ping").Result;
        return Equals(r, "pong");
    }

    /// <summary>
    /// 等待U2服务在线，直到超时。
    /// </summary>
    /// <param name="timeout">等待的超时时间（秒），默认为30秒。</param>
    /// <returns>如果在超时时间内U2服务在线，则返回true；否则返回false。</returns>
    public bool Wait(int timeout=30)
    {
        DateTime startTime = DateTime.Now;
        while (DateTime.Now - startTime < TimeSpan.FromSeconds(timeout))
        {
            if (Live())
                return true;
        }
        return false;
    }

    /// <summary>
    /// 启动设备的U2服务，并等待服务在线。
    /// </summary>
    public void LaunchUiautomator()
    {
        _process = new(Serial);
        string port = _adb.GetForwardPort();
        urlBase = $"http://127.0.0.1:{port}";
        Wait();
    }

    /// <summary>
    /// 启动设备的U2服务。如果服务已经在运行，则直接返回；否则，安装U2并启动服务。
    /// </summary>
    public void StartUiautomator()
    {
        // 检查u2服务是否正在运行
        if (Live())
        {
            return;
        }
        // 安装u2
        if (!_adb.FileExists("/data/local/tmp/u2.jar"))
        {
            SetupJar();
        }
        // 启动u2服务
        LaunchUiautomator();
    }

    /// <summary>
    /// 停止设备的U2服务。
    /// </summary>
    public void StopUiautomator()
    {
        _process?.Kill();
    }

    /// <summary>
    /// 在设备上执行Shell命令。
    /// </summary>
    /// <param name="cmd">要在设备上执行的Shell命令。</param>
    /// <returns>返回命令执行的结果字符串。</returns>
    public string Shell(string cmd)
    {
        return _adb.Shell(cmd);
    }

    /// <summary>
    /// 在设备上模拟按键操作。
    /// </summary>
    /// <param name="keyCode">要模拟的按键。</param>
    public void Press(KeyCode keyCode)
    {
        // 字典映射 KeyCode 到按键字符串
        var keyMapping = new Dictionary<KeyCode, string>
        {
            { KeyCode.Home, "home" },
            { KeyCode.Back, "back" },
            { KeyCode.Left, "left" },
            { KeyCode.Right, "right" },
            { KeyCode.Up, "up" },
            { KeyCode.Down, "down" },
            { KeyCode.Center, "center" },
            { KeyCode.Menu, "menu" },
            { KeyCode.Search, "search" },
            { KeyCode.Enter, "enter" },
            { KeyCode.Delete, "delete" },
            { KeyCode.Recent, "recent" },
            { KeyCode.VolumeUp, "volume_up" },
            { KeyCode.VolumeDown, "volume_down" },
            { KeyCode.VolumeMute, "volume_mute" },
            { KeyCode.Camera, "camera" },
            { KeyCode.Power, "power" }
        };
        // 检查是否存在于映射中
        if (keyMapping.TryGetValue(keyCode, out string keyString))
        {
            JsonRpcCall("pressKey", [keyString]);
        }
        else
        {
            // 错误处理：当传入的 KeyCode 不在映射中时
            throw new ArgumentOutOfRangeException(nameof(keyCode), "Invalid KeyCode value");
        }
    }

    /// <summary>
    /// 在设备上模拟长按按键操作。
    /// </summary>
    /// <param name="keyCode">要模拟长按的按键。</param>
    public void LongPress(KeyCode keyCode)
    {
        // 使用字典映射 KeyCode 到对应的 keyevent 数值
        var keyEventMapping = new Dictionary<KeyCode, int>
        {
            { KeyCode.Home, 3 },
            { KeyCode.Back, 4 },
            { KeyCode.Left, 21 },
            { KeyCode.Right, 22 },
            { KeyCode.Up, 19 },
            { KeyCode.Down, 20 },
            { KeyCode.Center, 23 },
            { KeyCode.Menu, 82 },
            { KeyCode.Search, 84 },
            { KeyCode.Enter, 66 },
            { KeyCode.Delete, 67 },
            { KeyCode.Notification, 83 },
            { KeyCode.VolumeUp, 24 },
            { KeyCode.VolumeDown, 25 },
            { KeyCode.VolumeMute, 91 },
            { KeyCode.Power, 26 }
        };

        // 如果映射中不存在该按键，抛出异常
        if (!keyEventMapping.TryGetValue(keyCode, out int code))
        {
            throw new ArgumentOutOfRangeException(nameof(keyCode), "Invalid KeyCode value");
        }

        // 执行 shell 命令
        Shell($"input keyevent --longpress {code}");
    }

    /// <summary>
    /// 在设备上模拟点击操作。
    /// </summary>
    /// <param name="x">点击位置的X坐标。</param>
    /// <param name="y">点击位置的Y坐标。</param>
    public void Click(double x, double y)
    {
        JsonRpcCall("click", [x, y]);
    }

    /// <summary>
    /// 在设备上模拟长按操作。
    /// </summary>
    /// <param name="x">长按位置的X坐标。</param>
    /// <param name="y">长按位置的Y坐标。</param>
    /// <param name="duration">长按的持续时间（秒），默认为0.5秒。</param>
    public void LongClick(double x, double y, double duration = 0.5)
    {
        JsonRpcCall("click", [x, y, duration*1000]);
    }

    /// <summary>
    /// 在设备上模拟滑动操作。
    /// </summary>
    /// <param name="x1">起始点的X坐标。</param>
    /// <param name="y1">起始点的Y坐标。</param>
    /// <param name="x2">终点X坐标。</param>
    /// <param name="y2">终点Y坐标。</param>
    /// <param name="duration">滑动操作的持续时间，默认为0。</param>
    /// <param name="steps">滑动操作的步数，默认为55。</param>
    public void Swipe(double x1, double y1, double x2, double y2, double duration=0, int steps=55)
    {
        if (duration != 0 && steps != 0)
            duration = 0;  // duration与steps不能同时设置.
        if (duration != 0)
        {
            steps = (int)(duration * 200);
        }
        _adb.Rel2Abs(x1, y1, out double abs_x1, out double abs_y1);
        _adb.Rel2Abs(x2, y2, out double abs_x2, out double abs_y2);
        JsonRpcCall("swipe", [abs_x1, abs_y1, abs_x2, abs_y2, steps]);
    }

    /// <summary>
    /// 在设备上模拟拖拽操作。
    /// </summary>
    /// <param name="x1">起始点的X坐标。</param>
    /// <param name="y1">起始点的Y坐标。</param>
    /// <param name="x2">终点X坐标。</param>
    /// <param name="y2">终点Y坐标。</param>
    /// <param name="duration">滑动操作的持续时间，默认为0.5。</param>
    public void Drag(double x1, double y1, double x2, double y2, double duration = 0.5)
    {
        _adb.Rel2Abs(x1, y1, out double abs_x1, out double abs_y1);
        _adb.Rel2Abs(x2, y2, out double abs_x2, out double abs_y2);
        JsonRpcCall("drag", [abs_x1, abs_y1, abs_x2, abs_y2, duration*200]);
    }

    /// <summary> 唤醒屏幕 </summary>
    public void ScreenOn()
    {
        JsonRpcCall("wakeUp", []);
    }

    /// <summary> 熄灭屏幕 </summary>
    public void ScreenOff()
    {
        JsonRpcCall("sleep", []);
    }

    /// <summary>
    /// 获取屏幕旋转方向
    /// </summary>
    /// <return>屏幕旋转方向的枚举值 </return>
    public Orientation GetOrientation()
    {
        // 获取设备信息
        string r = JsonRpcCall("deviceInfo", []);
        // 使用正则表达式提取 displayRotation 值
        string pattern = @"""displayRotation"":(\d)";
        Regex regex = new(pattern);
        Match match = regex.Match(r);
        // 如果匹配成功，解析 orientation，否则返回默认值
        if (match.Success)
        {
            string orientation = match.Groups[1].Value;
            // 映射数字到对应的枚举值
            return orientation switch
            {
                "0" => Orientation.Natural,
                "1" => Orientation.Left,
                "2" => Orientation.Upsidedown,
                "3" => Orientation.Right,
                _ => Orientation.Natural, // 如果值不符合预期，则返回默认值
            };
        }
        // 如果没有匹配到，则返回默认值
        return Orientation.Natural;
    }

    /// <summary>
    /// 设置屏幕旋转方向
    /// </summary>
    /// <param name="orientation">屏幕旋转方向的枚举值。</param>
    public void SetOrientation(Orientation orientation)
    {
        var keyMapping = new Dictionary<Orientation, string>
        {
            { Orientation.Natural, "natural" },
            { Orientation.Left, "left" },
            { Orientation.Upsidedown, "upsidedown" },
            { Orientation.Right, "right" },
        };

        // 检查是否存在于映射中
        if (keyMapping.TryGetValue(orientation, out string keyString))
        {
            // 调用 JsonRpcCall
            JsonRpcCall("setOrientation", [keyString]);
        }
        else
        {
            // 错误处理：当传入的 KeyCode 不在映射中时
            throw new ArgumentOutOfRangeException(nameof(orientation), "Invalid KeyCode value");
        }
    }

    /// <summary> 打开通知栏 </summary>
    public void OpenNotification()
    {
        JsonRpcCall("openNotification", []);
    }

    /// <summary> 打开快速设置</summary>
    public void OpenQuickSettings()
    {
        JsonRpcCall("openQuickSettings", []);
    }

    /// <summary> 清空文本 </summary>
    public void ClearInputText()
    {
        JsonRpcCall("clearInputText", []);
        JsonRpcCall("clearInputText", []); // 执行两次  概率性无法清空
    }

    /// <summary>
    /// 输入文本
    /// </summary>
    /// <param name="text">文本内容。</param>
    /// <param name="clear">是否清空原文本，默认false。</param>
    public void InputText(string text, bool clear=false)
    {
        if (clear)
        {
            ClearInputText();
            Sleep(500);
        }
        Shell($"input text {text}");
    }

    /// <summary>
    /// 获取属性值
    /// </summary>
    /// <param name="prop">需要获取的属性。</param>
    public string Getprop(string prop)
    {
        return Shell($"getprop {prop}");
    }

    /// <summary>
    /// 等待控件出现
    /// </summary>
    /// <param name="selector"> 选择器 </param>
    /// <param name="timeout"> 等待超时时间，默认20000ms </param>
    public void WaitForExists(Selector selector, int timeout= 20000)
    {
        JsonRpcCall("waitForExists", [selector.Contents, timeout]);
    }

    /// <summary>
    /// 判断控件是否存在
    /// </summary>
    /// <param name="selector"> 选择器 </param>
    /// <return> 控件是否存在 </return>
    public bool Exists(Selector selector)
    {
        string r = JsonRpcCall("exist", [selector.Contents]);
        return r.Contains("true");
    }

    /// <summary>
    /// 获取控件信息
    /// </summary>
    /// <param name="selector"> 选择器 </param>
    /// <return> 控件信息 </return>
    public Dictionary<string, object> ObjInfo(Selector selector)
    {
        string r = JsonRpcCall("objInfo", [selector.Contents]);
        var jsonObject = JObject.Parse(r);
        // 提取 "result" 部分
        var result = jsonObject["result"];
        // 将 "result" 部分转换为字典
        var resultDictionary = result.ToObject<Dictionary<string, object>>();
        // 处理 bounds，拆分成各个子字段并添加到字典中
        if (resultDictionary.ContainsKey("bounds"))
        {
            // 拆分 "bounds" 中的字段并添加到字典
            if (resultDictionary["bounds"] is JObject bounds)
            {
                resultDictionary["boundsBottom"] = bounds["bottom"];
                resultDictionary["boundsLeft"] = bounds["left"];
                resultDictionary["boundsRight"] = bounds["right"];
                resultDictionary["boundsTop"] = bounds["top"];
                resultDictionary.Remove("bounds");
            }
        }
        if (resultDictionary.ContainsKey("visibleBounds"))
        {
            if (resultDictionary["visibleBounds"] is JObject visibleBounds)
            {
                resultDictionary["visibleBoundsBottom"] = visibleBounds["bottom"];
                resultDictionary["visibleBoundsLeft"] = visibleBounds["left"];
                resultDictionary["visibleBoundsRight"] = visibleBounds["right"];
                resultDictionary["visibleBoundsTop"] = visibleBounds["top"];
                resultDictionary.Remove("visibleBounds");
            }
        }
        return resultDictionary;
    }

    /// <summary>
    /// 点击控件
    /// </summary>
    /// <param name="selector"> 选择器 </param>
    /// <param name="delay"> 执行结束后等待时间，默认2秒 </param>
    public void ClickUi(Selector selector, int delay=2000)
    {
        WaitForExists(selector);
        Dictionary<string, object> objInfo = ObjInfo(selector);
        double center_x = (Convert.ToInt32(objInfo["boundsLeft"]) + Convert.ToInt32(objInfo["boundsRight"])) / 2;
        double center_y = (Convert.ToInt32(objInfo["boundsTop"]) + Convert.ToInt32(objInfo["boundsBottom"])) / 2;
        Click(center_x, center_y);
        Sleep(delay);
    }

    /// <summary>
    /// 查找控件
    /// </summary>
    /// <param name="selector"> 选择器 </param>
    /// <param name="isClick"> 是否点击 </param>
    /// <param name="delay"> 执行结束后等待时间，默认2秒 </param>
    /// <returns> 是否存在 </returns>
    public bool FindUi(Selector selector, bool isClick = false, int delay = 2000)
    {
        bool isExist = Exists(selector);
        if (isExist && isClick)
        {
            ClickUi(selector, delay);
        }
        return isExist;
    }

    public static void Sleep(int sleepTime)
    {
        Thread.Sleep(sleepTime);
    }

    public static Selector By(string text = "", string textContains = "", string textMatches = "", string textStartsWith = "", string className = "",
        string classNameMatches = "", string description = "", string descriptionContains = "", string descriptionMatches = "", string descriptionStartsWith = "",
        string checkable = "", string Checked = "", string clickable = "", string longClickable = "", string scrollable = "", string enabled = "", string focusable = "",
        string focused = "", string selected = "", string packageName = "", string packageNameMatches = "", string resourceId = "", string resourceIdMatches = "",
        string index = "")
    {
        Selector selector = new();
        int mask = 0;
        if (!string.IsNullOrEmpty(text))
        {
            selector.Contents.Add("text", text);
            mask |= 1 << 0;  // 0x01
        }
        if (!string.IsNullOrEmpty(textContains))
        {
            selector.Contents.Add("textContains", textContains);
            mask |= 1 << 1;  // 0x02
        }
        if (!string.IsNullOrEmpty(textMatches))
        {
            selector.Contents.Add("textMatches", textMatches);
            mask |= 1 << 2;  // 0x04
        }
        if (!string.IsNullOrEmpty(textStartsWith))
        {
            selector.Contents.Add("textStartsWith", textStartsWith);
            mask |= 1 << 3;  // 0x08
        }
        if (!string.IsNullOrEmpty(className))
        {
            selector.Contents.Add("className", className);
            mask |= 1 << 4;  // 0x10
        }
        if (!string.IsNullOrEmpty(classNameMatches))
        {
            selector.Contents.Add("classNameMatches", classNameMatches);
            mask |= 1 << 5;  // 0x20
        }
        if (!string.IsNullOrEmpty(description))
        {
            selector.Contents.Add("description", description);
            mask |= 1 << 6;  // 0x40
        }
        if (!string.IsNullOrEmpty(descriptionContains))
        {
            selector.Contents.Add("descriptionContains", descriptionContains);
            mask |= 1 << 7;  // 0x80
        }
        if (!string.IsNullOrEmpty(descriptionMatches))
        {
            selector.Contents.Add("descriptionMatches", descriptionMatches);
            mask |= 1 << 8;  // 0x0100
        }
        if (!string.IsNullOrEmpty(descriptionStartsWith))
        {
            selector.Contents.Add("descriptionStartsWith", descriptionStartsWith);
            mask |= 1 << 9;  // 0x0200
        }
        if (!string.IsNullOrEmpty(checkable))
        {
            selector.Contents.Add("checkable", checkable);
            mask |= 1 << 10;  // 0x0400
        }
        if (!string.IsNullOrEmpty(Checked))
        {
            selector.Contents.Add("checked", Checked);
            mask |= 1 << 11;  // 0x0800
        }
        if (!string.IsNullOrEmpty(clickable))
        {
            selector.Contents.Add("clickable", clickable);
            mask |= 1 << 12;  // 0x1000
        }
        if (!string.IsNullOrEmpty(longClickable))
        {
            selector.Contents.Add("longClickable", longClickable);
            mask |= 1 << 13;  // 0x2000
        }
        if (!string.IsNullOrEmpty(scrollable))
        {
            selector.Contents.Add("scrollable", scrollable);
            mask |= 1 << 14;  // 0x4000
        }
        if (!string.IsNullOrEmpty(enabled))
        {
            selector.Contents.Add("enabled", enabled);
            mask |= 1 << 15;  // 0x8000
        }
        if (!string.IsNullOrEmpty(focusable))
        {
            selector.Contents.Add("focusable", focusable);
            mask |= 1 << 16;  // 0x010000
        }
        if (!string.IsNullOrEmpty(focused))
        {
            selector.Contents.Add("focused", focused);
            mask |= 1 << 17;  // 0x020000
        }

        if (!string.IsNullOrEmpty(selected))
        {
            selector.Contents.Add("selected", selected);
            mask |= 1 << 18;  // 0x040000
        }
        if (!string.IsNullOrEmpty(packageName))
        {
            selector.Contents.Add("packageName", packageName);
            mask |= 1 << 19;  // 0x080000
        }
        if (!string.IsNullOrEmpty(packageNameMatches))
        {
            selector.Contents.Add("packageNameMatches", packageNameMatches);
            mask |= 1 << 20;  // 0x100000
        }
        if (!string.IsNullOrEmpty(resourceId))
        {
            selector.Contents.Add("resourceId", resourceId);
            mask |= 1 << 21;  // 0x200000
        }
        if (!string.IsNullOrEmpty(resourceIdMatches))
        {
            selector.Contents.Add("resourceIdMatches", resourceIdMatches);
            mask |= 1 << 22;  // 0x400000
        }
        if (!string.IsNullOrEmpty(index))
        {
            selector.Contents.Add("index", index);
            mask |= 1 << 23;  // 0x800000
        }
        selector.Contents.Add("mask", mask);
        selector.Mask = mask;

        return selector;
    }

    public string JsonRpcCall(string method, object[] param, int timeout = 60)
    {
        // 等待获取信号量，保证只有一个线程可以进入下面的异步调用
        _semaphore.WaitAsync();
        string r = String.Empty;
        try
        {
            if (!Live())
            {
                Log.Debug($"uiautomator2 no ok");
                StopUiautomator();
                StartUiautomator();
            }
            r = _JsonRpcCall(method, param, timeout);
            //Log.Info(r);

            if (r.Contains("An error occurred while sending the request") || r.Contains("无法连接"))
            {
                Log.Debug($"uiautomator2 no ok");
                StopUiautomator();
                StartUiautomator();
                _JsonRpcCall(method, param, timeout);
            }
            else if (r.Contains("UiObjectNotFound"))
            {
                Log.Error(r);
                throw new UiObjectNotFoundError(r);
            } else if (r.Contains("IllegalStateException"))
            {
                Log.Error(r);
                throw new IllegalStateException(r);
            }
        }
        catch (Exception ex)
        {
            Log.Error($"JsonRpcCall error: {ex.Message}");
            throw;
        }
        finally
        {
            // 确保释放信号量，允许其他线程继续执行
            _semaphore.Release();
        }
        return r;
    }

    public string _JsonRpcCall(string method, object[] param, int timeout = 60)
    {
        // 使用字典创建 JSON-RPC 2.0 请求数据
        var content = new Dictionary<string, object>
        {
            { "jsonrpc", "2.0" },
            { "id", 1 },
            { "method", method },
            { "params", param }  // params 使用对象数组
        };
        //Log.Debug($"method: {method}, params: {FormatParameters(param)}, timeout: {timeout}");
        return Requests.Post($"{urlBase}/jsonrpc/0", JsonConvert.SerializeObject(content), timeout);
    }

    private string FormatParameters(object[] param)
    {
        if (param == null || param.Length == 0)
        {
            return "empty";
        }
        return string.Join(", ", param.Select(p => FormatObject(p)));
    }

    private string FormatObject(object obj)
    {
        if (obj == null)
        {
            return "null";
        }
        // 如果是字典类型，递归格式化字典内容
        if (obj is Dictionary<string, object> dict)
        {
            return "{" + string.Join(", ", dict.Select(kv => $"{kv.Key}: {FormatObject(kv.Value)}")) + "}";
        }
        // 如果是列表类型（例如 List<object>），递归格式化列表元素
        if (obj is IEnumerable<object> enumerable)
        {
            return "[" + string.Join(", ", enumerable.Select(e => FormatObject(e))) + "]";
        }
        // 如果是DateTime类型，返回自定义格式的日期
        if (obj is DateTime)
        {
            return ((DateTime)obj).ToString("yyyy-MM-dd HH:mm:ss");
        }
        // 默认返回对象的 ToString() 值
        return obj.ToString();
    }
}

截取指定区域图像

Tue, 28 Jan 2025 00:00:00 GMT

开发背景

一般来说，我们可以通过adb shell screencap指令来截取android设备中的图像，但是获取到的是完整的图像。当我们需要进行图像识别的操作时，需要获取指定区域的图像来进行对比。

功能实现

C#实现

部分代码如下

/// <summary>
/// 对指定设备进行屏幕截图并裁剪指定区域，然后将裁剪后的图像保存到指定路径。
/// </summary>
/// <param name="x">裁剪区域左上角的x坐标。</param>
/// <param name="y">裁剪区域左上角的y坐标。</param>
/// <param name="width">裁剪区域的宽度。</param>
/// <param name="height">裁剪区域的高度。</param>
/// <param name="savePath">裁剪后图像的保存路径，默认值为"screencap.png"。</param>
public void ScreenCapAndCrop(int x, int y, int width, int height, string savePath = "screencap.png")
{
    Stream stream = NProcess.RunReturnStream($"adb -s {_serial} shell screencap -p");
    List<byte> data = ReadStreamAndConvertCRLF(stream);
    if (data.Count == 0)
    {
        Log.Error($"{_serial} screencap failed!");
        return;
    }
    // 将字节列表转换为字节数组
    byte[] imageData = [.. data];

    // 使用字节数组创建一个图像对象
    using MemoryStream ms = new(imageData);
    using Bitmap bitmap = new(ms);
    // 创建裁剪区域
    Rectangle cropRect = new(x, y, width, height);

    // 裁剪图像
    using Bitmap croppedImage = bitmap.Clone(cropRect, bitmap.PixelFormat);
    // 保存裁剪后的图像
    croppedImage.Save(savePath, ImageFormat.Png);
}

/// <summary>
/// 从给定的流中读取数据，并处理回车符（CR）和换行符（LF），将CRLF转换为LF
/// </summary>
/// <param name="stream">要从中读取数据的流</param>
/// <returns>处理后的字节列表，其中CRLF被转换为LF</returns>
private static List<byte> ReadStreamAndConvertCRLF(Stream stream)
{
    ArgumentNullException.ThrowIfNull(stream);

    List<byte> data = [];
    byte[] buffer = new byte[1024];
    int read;
    bool isCR = false;
    do
    {
        byte[] buf = new byte[1024];
        read = stream.Read(buf, 0, buf.Length);

        for (int i = 0; i < read; i++) //convert CRLF to LF
        {
            if (isCR && buf[i] == 0x0A)
            {
                isCR = false;
                data.RemoveAt(data.Count - 1);
                data.Add(buf[i]);
                continue;
            }
            isCR = buf[i] == 0x0D;
            data.Add(buf[i]);
        }
    }
    while (read > 0);
    return data;
}

_serial为设备号，通过adb devices获取，具体代码就不列举了。

python实现

import subprocess
from PIL import Image
import io

def get_screenshot_and_crop(x, y, width, height, output_path="screencap.png"):
    process = subprocess.Popen(
        ['adb', 'shell', 'screencap', '-p'],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE
    )
    stdout, stderr = process.communicate()

    # 处理 Windows 系统中的换行符问题
    if b'\r\n' in stdout:
        stdout = stdout.replace(b'\r\n', b'\n')

    # 将二进制数据转换为图像并裁剪
    image = Image.open(io.BytesIO(stdout))
    cropped_image = image.crop((x, y, x + width, y + height))
    # 保存裁剪后的图像
    cropped_image.save(output_path)

博客封面图制作

Thu, 23 Jan 2025 00:00:00 GMT

前提

之前我的博客页面都是直接用AI生成的，风格各异，有些甚至看起来很奇怪，整体效果也不是很理想。后来，我看到了张洪Heo的博客封面图，非常吸引人，颜色搭配和设计都很有美感。但是，他的方法对我来说操作起来有一定的难度，不太容易上手。

于是，我在知乎上搜索了如何制作文章封面图，找到了一些实用的方法。根据我自己的实际情况，对这些方法进行了适当的调整，尝试制作封面图。虽然我已经尽力去改进了，但效果还是比不上张洪Heo的作品那么完美。

制作工具

MasterGo
- https://mastergo.com/
boardmix（之前用来画思维导图，开了1年会员，发现用来做图也很方便）
- boardmix博思白板官网, AIGC在线生成, 多人协同思维导图, 流程图工具
图标资源
- Windows 11 Color风格的标志符号和图标，格式有PNG、SVG

制作图标(可选)

boardmix中，使用圆角矩形画出图标背景。

不展示边框
宽度256
高度256
圆角45

添加对应的图标素材，大小调整为210-240左右

选中区域，右键导出为png。

制作封面

MasterGo中新建文件，容器选择社媒，公众号封面 2.35:1(900 x 383), 设置图标近似的背景色

添加文字，文字中间通过空格空出合适的位置

阿里妈妈数黑体
字体大小130
居中对齐
自动高度

添加刚才制作的图标，调整合适的大小，并添加阴影

导出为png即可

anzhiyu主题about页面鼠标动效不生效问题

Thu, 16 Jan 2025 00:00:00 GMT

问题背景

在配置安知鱼主题的关于页面时，发现helloAbout的动效突然不起作用了。如下图所示

原因分析

打开调试控制台，发现在about页面存在报错。

通过排查发现，在selfInfo中的selfInfoContentYear我填的不是纯数字导致的。

修改前

selfInfo:
  selfInfoTips1: 生日
  selfInfoContentYear: 3 月 5 日
  selfInfoTips2: 星座
  selfInfoContent2: 双鱼座
  selfInfoTips3: 职业
  selfInfoContent3: 自动化工程师

修改后

selfInfo:
  selfInfoTips1: 出生
  selfInfoContentYear: 1999
  selfInfoTips2: 星座
  selfInfoContent2: 双鱼座
  selfInfoTips3: 职业
  selfInfoContent3: 自动化工程师

恢复正常

gitignore添加文件不起作用

Wed, 15 Jan 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

问题描述

通过git进行版本管理时，可以通过.gitignore文件来配置哪些文件或目录应该被忽略，不纳入版本控制系统的管理范围。但是有时在.gitignore文件中添加对应目录或文件后，在Sourcetree的未暂存文件中仍能看到。

可能原因

可能在之前已经将该目录或文件添加到了 Git 的暂存区或已经进行了版本控制，所以 .gitignore 的规则对这些文件暂时不起作用。

解决方法

通过以下命令清除已经添加到暂存区的目录或文件。

git rm -r --cached EEITest/app/build

配置用户环境变量

Tue, 14 Jan 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user' import { Tabs, TabItem } from 'astro-pure/user';

开发背景

在 Windows 系统应用开发与部署中，环境变量 PATH 对查找可执行文件和库文件很重要。手动添加新路径到 PATH 繁琐易错，在多用户环境下还会影响系统稳定性。

因此，开发了一个自动化函数用于向用户级 PATH 添加新路径。因修改需管理员权限，该函数会检查权限，同时避免重复添加，以提高效率和系统可维护性、可扩展性，方便软件安装更新等操作。

功能实现

基于QThread的多线程任务管理

Tue, 14 Jan 2025 00:00:00 GMT

在开发一个 PyQt 应用程序时，我们经常需要执行一些耗时的操作，例如文件读写、网络请求、复杂的数据处理或长时间的计算。如果这些操作在主线程中执行，会导致用户界面（UI）冻结，用户无法与应用程序进行交互，影响用户体验。为了解决这个问题，我们需要将这些耗时操作放在单独的线程中执行。

然而，直接使用多线程会带来一些复杂性，例如线程的创建、管理、信号和槽机制的使用，以及在多线程环境下处理异常和结果的传递等。为了简化这些操作，因此开发了 Task 和 TaskManager 类。

功能实现

from PyQt5.QtCore import QThread, pyqtSignal

class Task(QThread):
    """
    Task class to run a task in a separate thread.
    """
    success_signal = pyqtSignal(object)
    fail_signal = pyqtSignal(Exception)
    finished_signal = pyqtSignal()

    def __init__(self, func, *args):
        super().__init__()
        self.func = func
        self.args = args

    def run(self):
        try:
            r = self.func(*self.args)
            self.success_signal.emit(r)
        except Exception as e:
            self.fail_signal.emit(e)
        self.finished_signal.emit()

    def onSuccess(self, func):
        self.success_signal.connect(func)
        return self

    def onFail(self, func):
        self.fail_signal.connect(func)
        return self

    def onFinished(self, func):
        self.finished_signal.connect(func)
        return self

class TaskManager:
    """
    TaskManager class to manage multiple tasks.
    """
    _instance = None
    _tasks = {}

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    @classmethod
    def create_task(cls, func, *args, **kwargs):
        if "label" in kwargs:
            label = kwargs["label"]
        else:
            label = "null"
        task = Task(func, *args)
        if label not in cls._tasks:
            cls._tasks[label] = [task]
        else:
            cls._tasks[label].append(task)
        return task

    @classmethod
    def run_task(cls, task: Task):
        task.start()
        task.onFinished(lambda: cls.remove_task(task))
        return task

    @classmethod
    def run_tasks(cls, tasks: list):
        for task in tasks:
            if isinstance(task, Task):
                cls.run_task(task)

    @classmethod
    def remove_task(cls, task: Task):
        for key, value in cls._tasks.items():
            if task in value:
                value.remove(task)
                if len(value) == 0:
                    cls._tasks.pop(key)
                break

    @classmethod
    def is_idle(cls, label: str = "null"):
        return label not in cls._tasks

    @classmethod
    def is_all_idle(cls):
        return len(cls._tasks) == 0

方法解释

线程执行：Task 类继承自 QThread，用于将函数封装在独立线程中执行。通过 start() 方法在后台运行耗时操作，避免阻塞主线程。
信号机制：使用 PyQt 的 pyqtSignal 机制，Task 类定义了三个信号：
- success_signal：任务成功完成时触发
- fail_signal：任务执行异常时触发
- finished_signal：任务完成时触发（无论成功或失败）
回调函数连接：通过 onSuccess、onFail 和 onFinished 方法连接回调函数，实现任务成功时更新 UI、失败时显示错误、完成时执行清理等操作。
任务生命周期管理：
- create_task：创建任务并添加到 _tasks 字典
- run_task：启动单个任务，完成后自动移除
- run_tasks：同时运行多个任务
- remove_task：移除已完成的任务，避免内存泄漏
- is_idle / is_all_idle：检查任务是否处于空闲状态

使用示例

def getDeviceInfo():
    # 一些耗时操作...
    return "模拟设备数据"

task = TaskManager.create_task(getDeviceInfo).onSuccess(lambda deviceInfo: print(deviceInfo)).onFail(lambda e: print(e)).onFinished(lambda: print("任务结束"))
TaskManager.run_task(task)

链式调用shell指令

Tue, 14 Jan 2025 00:00:00 GMT

开发背景

在自动化测试和脚本化任务中，常需按步骤执行 adb shell 命令及处理结果。例如自动化测试时，先通过 shell 命令安装应用，再检查安装结果，之后进行其他操作。

功能实现

class ADBShell:
    def __init__(self, device: str):
        self.shell = None  # shell 进程对象
        self.device = device
        self.stdout_adb = ""
        self.stderr_adb = ""
        self.start_shell()

    def start_shell(self):
        self.stdout_adb = ""
        self.stderr_adb = ""
        self.shell = subprocess.Popen(["adb", "-s", self.device, "shell"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

    def write(self, command: str):
        if self.shell.stdin.closed:  # 如果输入流已关闭，则重新启动 ADB shell 进程
            self.start_shell()
        if command[-1]!= '\n':
            command += '\n'
        self.shell.stdin.write(command.encode())
        self.shell.stdin.flush()
        return self

    def read(self):
        if self.shell.stdin:
            self.shell.stdin.flush()
            self.shell.stdin.close()
        stdout, stderr = self.shell.communicate()
        return stdout.decode(), stderr.decode()

    def write_adb(self, adb_command: str):
        full_command = ["adb", "-s", self.device] + adb_command.split()
        process = subprocess.Popen(full_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = process.communicate()
        self.stdout_adb += stdout.decode()
        self.stderr_adb += stderr.decode()
        return self

    def read_adb(self):
        return self.stdout_adb, self.stderr_adb

    def flush(self):
        self.shell.stdin.flush()
        return self

    def close(self):
        if self.shell.stdin:
            self.shell.stdin.close()
        return self

    def sleep(self, sleep_time):
        time.sleep(sleep_time)
        return self

使用示例

通过adb将APK安装到手机中，并获取手机中APK的信息。获取完成后，将数据导出

adbShell = ADBShell("T442A02XNKH0189")
_ = (adbShell.   # 链式执行删除结果，安装APK，启动APK等操作
        write("cd /sdcard/Android/data/com.tt.appinfo/files/").
        write("rm result.txt").
        write_adb("install app-debug.apk").
        write("am start -n com.tt.appinfo/.MainActivity").
        read())
start = time.time()
while((time.time() - start) < 30):    # 等待执行结束
    stdout, stderr = adbShell.write(f"cd /sdcard/Android/data/com.tt.appinfo/files/").write("cat result.txt").read()
    if "1" in stdout:
        break
    time.sleep(1)
else:
    print("timeout")
adbShell.write_adb("pull /sdcard/Android/data/com.tt.appinfo/files/appInfo.db")   # 导出结果
print("finished")

Android配置uiautomator

Mon, 13 Jan 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

添加依赖

在build.gradle中添加uiautomator依赖

androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'

编写用例

需要在androidTest中编写用例，而不是在main中。新建一个test类，下面是一个打开设置的一个测试。

package com.tt.demo;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.uiautomator.By;
import androidx.test.uiautomator.UiDevice;
import androidx.test.uiautomator.UiObject2;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(AndroidJUnit4.class)
public class test {
    static UiDevice device;
    @Test
    public void openSettings() throws InterruptedException {
        device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
        UiObject2 settings = device.findObject(By.text("Settings"));
        if(settings!=null){
            settings.click();
            Thread.sleep(2000);
        }
    }
}

安装APK

需要安装2个apk，一个是由main中编译出来的apk(傀儡应用)，另一个则是由androidTest编译出来的apk。可以直接通过右侧的Gradle中的install直接安装。

运行测试

打开命令提示符，输入以下指令即可开始进行测试

adb shell am instrument -w -e class com.tt.demo.test#openSettings com.tt.demo.test/androidx.test.runner.AndroidJUnitRunner

instrument参数

填充联系人、通话记录、短信的方法

Mon, 13 Jan 2025 00:00:00 GMT

import { Tabs, TabItem } from 'astro-pure/user';

前提

在Android自动化测试中，通过自动化测试脚本填充联系人、通话记录、短信等数据，可以模拟出更接近真实用户的使用场景。这种模拟有助于发现那些在日常使用中才会出现的问题，从而提高测试的全面性和准确性。

实现方法

联系人

<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.WRITE_CONTACTS"/>

ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)  // 插入联系人的姓名数据
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)   // 引用前面插入的原始联系人 ID
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) // 指定数据类型为姓名
        .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, names) // 设置联系人姓名
        .build());

ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)   // 插入联系人的电话号码数据
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)  // 引用前面插入的原始联系人 ID
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)   // 指定数据类型为电话号码
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, num)  // 设置电话号码
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)  // 设置电话号码类型为移动电话
        .build());

try {
    getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);   // 执行批量插入操作
    return true;
} catch (Exception e) {
    Log.e(TAG, "insertContacts error: " + e);
    return false;
}

}

  </TabItem>
<TabItem label="删除">
```java
private void deleteAllContacts() {
    Uri uri = ContactsContract.Contacts.CONTENT_URI;
    String[] projection = new String[]{ContactsContract.Contacts._ID};  // 只查询联系人的 ID
    String selection = null;  // 定义查询条件，这里为空表示查询所有联系人
    String[] selectionArgs = null;
    String sortOrder = ContactsContract.Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC";  // 按显示名称升序排序

    // 查询所有联系人的 ID
    Cursor cursor = getContentResolver().query(uri, projection, selection, selectionArgs, sortOrder);
    if (cursor != null) {
        try {
            while (cursor.moveToNext()) {
                // 获取联系人的 ID 并尝试删除
                @SuppressLint("Range") long contactId = cursor.getLong(cursor.getColumnIndex(ContactsContract.Contacts._ID));
                if (deleteContact(contactId)) {
                    Log.d(TAG, String.format("delete contact %s succ\n", contactId));
                } else {
                    Log.e(TAG, String.format("delete contact %s fail\n", contactId));
                }
            }
        } finally {
            cursor.close();
        }
    }
}

private boolean deleteContact(long contactId) {
    try {
        Uri deleteUri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, contactId);  // 构建删除 URI
        int rowsDeleted = getContentResolver().delete(deleteUri, null, null);  // 执行删除操作
        if (rowsDeleted > 0) {
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "deleteContactError: " + e);
    }
    return false;
}

</TabItem>

通话记录

<uses-permission android:name="android.permission.READ_CALL_LOG"/>
<uses-permission android:name="android.permission.WRITE_CALL_LOG"/>

短信

AndroidManifest.xml中添加

<uses-permission android:name="android.permission.SEND_SMS" />
<uses-permission android:name="android.permission.RECEIVE_SMS"/>
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
    tools:ignore="QueryAllPackagesPermission" />

<application
    android:allowBackup="true"
    android:dataExtractionRules="@xml/data_extraction_rules"
    android:fullBackupContent="@xml/backup_rules"
    android:icon="@mipmap/app"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/app_round"
    android:supportsRtl="true"
    android:theme="@style/Theme.AutoFill"
    >
    <receiver
        android:name=".SmsReceiver"
        android:permission="android.permission.BROADCAST_SMS"
        android:exported="true"
        tools:ignore="WrongManifestParent">
        <intent-filter>
            <action android:name="android.provider.Telephony.SMS_DELIVER" />
        </intent-filter>
    </receiver>
    <receiver
        android:name=".MmsReceiver"
        android:permission="android.permission.BROADCAST_WAP_PUSH"
        android:exported="true"
        tools:ignore="WrongManifestParent">
        <intent-filter>
            <action android:name="android.provider.Telephony.WAP_PUSH_DELIVER" />
            <data android:mimeType="application/vnd.wap.mms-message" />
        </intent-filter>
    </receiver>
    <service
        android:name=".HeadlessSmsSendService"
        android:exported="true"
        android:permission="android.permission.SEND_RESPOND_VIA_MESSAGE"
        tools:ignore="WrongManifestParent">
        <intent-filter>
            <action android:name="android.intent.action.RESPOND_VIA_MESSAGE" />
            <category android:name="android.intent.category.DEFAULT" />

            <data android:scheme="sms" />
            <data android:scheme="smsto" />
            <data android:scheme="mms" />
            <data android:scheme="mmsto" />
        </intent-filter>
    </service>
    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.SEND" />
            <action android:name="android.intent.action.SENDTO" />

            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.BROWSABLE" />

            <data android:scheme="sms" />
            <data android:scheme="smsto" />
            <data android:scheme="mms" />
            <data android:scheme="mmsto" />
        </intent-filter>
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

分别创建空的HeadlessSmsSendService，MmsReceiver，SmsActivity，SmsReceiver，SmsService

public class HeadlessSmsSendService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}
public class MmsReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
    }
}
public class SmsActivity extends Activity {
}
public class SmsReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
    }
}
public class SmsReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
    }
}

最后，需要将APK设置为默认短信应用(需要手动授予)

// 获取当前设备上默认的短信应用的包名
private String getDefaultSms()
{
    String packageName = "null";
    Intent intent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:"));
    PackageManager packageManager = getApplicationContext().getPackageManager();
    ResolveInfo resolveInfo = packageManager.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
    if (resolveInfo != null) {
        packageName = resolveInfo.activityInfo.packageName;
    }
    return packageName;
}

// 设置当前应用为默认短信应用
private void setDefaultSms(int requestCode) {
    String defaultSmsPkg = Telephony.Sms.getDefaultSmsPackage(getApplicationContext());
    Log.d(TAG, "default SMS: " + defaultSmsPkg);
    if (!defaultSmsPkg.equals(getPackageName())) {
        RoleManager roleManager = (RoleManager) getSystemService(Context.ROLE_SERVICE);
        if (roleManager != null && roleManager.isRoleAvailable(RoleManager.ROLE_SMS)) {
            Intent roleRequestIntent = roleManager.createRequestRoleIntent(RoleManager.ROLE_SMS);
            if (roleRequestIntent != null) {
                startActivityForResult(roleRequestIntent, requestCode);  // 启动请求设置默认短信的活动
            }
        }
    }
}

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    // 通过判断requestCode的值来确定是哪个操作触发的结果回调
    // 默认短信应用设置结果可以在这里判断
}

while (c.moveToNext()) {
    long id = c.getLong(c.getColumnIndexOrThrow("_id"));
    getContentResolver().delete(Uri.parse("content://sms/" + id), null, null);
}
c.close();

}

</TabItem>
</Tabs>

获取APK相关信息

Mon, 13 Jan 2025 00:00:00 GMT

前提

Android中APK部分信息通过adb无法直接获取，但是可以通过Android中的ApplicationInfo{eos-icons:api}接口进行获取。

获取内容

packageName：应用的包名，唯一标识每个APP
appName：应用的名称，用户在界面上看到的名字
isSystemApp：是否为系统应用，区分预装和用户安装
launcherActivity：应用的启动Activity类名
processName：应用运行的进程名称
compileSdkVersion：编译时所用的SDK版本
targetSdkVersion：目标适配的SDK版本
icon：应用的图标数据

功能实现

权限

<uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
    tools:ignore="QueryAllPackagesPermission" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
    android:maxSdkVersion="32" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
    android:maxSdkVersion="32"
    tools:ignore="ScopedStorage" />

MainActivity(入口)

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private static final int REQUEST_PERMISSIONS = 1122;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        EdgeToEdge.enable(this);
        setContentView(R.layout.activity_main);

        // 获取应用程序的名称和图标
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_PERMISSIONS);
        }
        Thread backgroundThread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 权限已经被授予，可以保存应用信息
                try {
                    AppInfoManager.saveInstalledAppsInfo(MainActivity.this);
                } catch (ClassNotFoundException | NoSuchMethodException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        backgroundThread.start();
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_PERMISSIONS) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 权限被授予，可以保存应用信息
            } else {
                // 权限被拒绝，提示用户权限未被授予
                Log.d(TAG, "权限被拒绝");
            }
        }
    }
}

AppInfoManager（核心部分）

public class AppInfoManager {
    public static String TAG = "APPInfoManager";

    public static void saveInstalledAppsInfo(Context context) throws ClassNotFoundException, NoSuchMethodException {
        PackageManager packageManager = context.getPackageManager();
        List<ApplicationInfo> apps = packageManager.getInstalledApplications(0);

        DatabaseHelper dbHelper = new DatabaseHelper(context);
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        for (ApplicationInfo app : apps) {
            // 获取包名
            String packageName = app.packageName;
            Log.d(TAG, app.packageName);
            String name = (String) app.loadLabel(packageManager);  // 应用的用户可见名称
            // 检查应用名是否已经存在于数据库中
            if (dbHelper.appNameExists(name)) {
                Log.d(TAG, String.format("%s exists", name));
                continue;
            }
            // 获取应用的各种标志
            int flags = app.flags;
            // 是否是系统应用
            boolean isSystemApp = (flags & ApplicationInfo.FLAG_SYSTEM) != 0;
            int compileSdkVersion = app.compileSdkVersion;
            int targetSdkVersion = app.targetSdkVersion;
            // 进程名称
            String processName = app.processName;

            // 获取启动活动名
            String launcherActivity = "";
            Intent intent = packageManager.getLaunchIntentForPackage(packageName);
            if (intent != null) {
                // 从Intent中获取启动Activity的组件信息
                ComponentName componentName = intent.getComponent();
                launcherActivity = componentName.getClassName(); // 启动Activity的类名
            }
            Drawable icon = app.loadIcon(packageManager);
            // 获取应用图标
            Bitmap bitmap = getBitmapFromDrawable(icon);
            // 将图标转换为可以存储到数据库中的字节数据
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
            byte[] iconBytes = baos.toByteArray();

            // 将数据保存到数据库
            ContentValues values = new ContentValues();
            values.put("packageName", packageName);
            values.put("appName", name);
            values.put("isSystemApp", isSystemApp);
            values.put("launcherActivity", launcherActivity);
            values.put("processName", processName);
            values.put("compileSdkVersion", compileSdkVersion);
            values.put("targetSdkVersion", targetSdkVersion);
            values.put("icon", iconBytes);
            db.insert("apps", null, values);
            Log.d(TAG, String.format("%s saved", name));
        }

        db.close();
        writeFinishedFlag(context);
    }

    private static Bitmap getBitmapFromDrawable(Drawable drawable) {
        if (drawable instanceof BitmapDrawable) {
            return ((BitmapDrawable) drawable).getBitmap();
        } else if (drawable instanceof AdaptiveIconDrawable) {
            Drawable backgroundDr = ((AdaptiveIconDrawable) drawable).getBackground();
            Drawable foregroundDr = ((AdaptiveIconDrawable) drawable).getForeground();
            // 添加非空检查
            if (backgroundDr != null && foregroundDr != null) {
                Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
                Canvas canvas = new Canvas(bitmap);
                backgroundDr.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
                foregroundDr.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
                backgroundDr.draw(canvas);
                foregroundDr.draw(canvas);
                return bitmap;
            } else{
                // 创建一个完全透明的 ARGB_8888 格式的 Bitmap
                return Bitmap.createBitmap(64, 64, Bitmap.Config.ARGB_8888);
            }
        } else {
            // Fallback for other types of drawables (e.g., ColorDrawable, VectorDrawable)
            Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
            Canvas canvas = new Canvas(bitmap);
            drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
            drawable.draw(canvas);
            return bitmap;
        }
    }

    private static void writeFinishedFlag(Context context) {
        File file = new File(Objects.requireNonNull(context.getExternalFilesDir(null)).getAbsolutePath(), "result.txt");
        try (FileWriter writer = new FileWriter(file)) {
            writer.write("1");
        } catch (IOException e) {
            Log.d(TAG, "writeFinishedFlag: ", e);
        }
    }
}

DatabaseHelper（数据保存）

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "appInfo.db";
    private static final String TABLE_NAME = "apps";
    private static final int DATABASE_VERSION = 1;

    private static final String CREATE_TABLE_APPS =
            "CREATE TABLE " + TABLE_NAME +
                    "(_id INTEGER PRIMARY KEY AUTOINCREMENT, " +
                    "packageName TEXT, " +
                    "appName TEXT," +
                    "isSystemApp INTEGER," +
                    "launcherActivity TEXT," +
                    "processName TEXT," +
                    "compileSdkVersion INTEGER," +
                    "targetSdkVersion INTEGER," +
                    "icon BLOB);";

    public DatabaseHelper(Context context) {
        super(context, context.getExternalFilesDir(null).getAbsolutePath() +
                "/" + DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_TABLE_APPS);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // Handle database version upgrades if necessary
    }

    public boolean appNameExists(String appName) {
        SQLiteDatabase db = getReadableDatabase();
        String query = "SELECT * FROM " + TABLE_NAME + " WHERE appName = ?";
        Cursor cursor = db.rawQuery(query, new String[]{appName});
        boolean exists = cursor.moveToFirst();
        cursor.close();
        return exists;
    }

}

使用方法

安装APK

adb install -g app-debug.apk # 通过-g参数授予全部权限"

启动APK

adb shell am start -n com.tt.appinfo/.MainActivity

等待获取完成

adb shell cat /sdcard/Android/data/com.tt.appinfo/files/result.txt # 结果为1时，获取完成

导出数据

adb pull /sdcard/Android/data/com.tt.appinfo/files/appInfo.db

解析数据

可通过SQLite在线查看{hugeicons:sql}临时查看数据 :::

python解析示例

if __name__ == "__main__":
    conn = sqlite3.connect('appInfo.db')
    cursor = conn.cursor()
    cursor.execute("SELECT _id, packageName, appName, isSystemApp, launcherActivity, processName, compileSdkVersion, targetSdkVersion, icon FROM apps")
    rows = cursor.fetchall()
    appInfos = {}
    for row in rows:
        packageName = row[1]
        appName = row[2]
        isSystemApp = row[3]
        launcherActivity = row[4]
        processName = row[5]
        compileSdkVersion = row[6]
        targetSdkVersion = row[7]
        icon = row[8]
        if packageName in appInfos.keys():
            continue
        appInfos[packageName] = {
            "appName": appName,
            "isSystemApp": isSystemApp,
            "launcherActivity": launcherActivity,
            "processName": processName,
            "compileSdkVersion": compileSdkVersion,
            "targetSdkVersion": targetSdkVersion,
            "icon": icon,
        }

    if not os.path.exists("Icons"):
        os.mkdir("Icons")

    for package in appInfos.keys():
        appName = appInfos[package]["appName"]
        isSystemApp = appInfos[package]["isSystemApp"]
        launcherActivity = appInfos[package]["launcherActivity"]
        processName = appInfos[package]["processName"]
        compileSdkVersion = appInfos[package]["compileSdkVersion"]
        targetSdkVersion = appInfos[package]["targetSdkVersion"]

        print(f"[{package}]appName: {appName}")
        print(f"[{package}]isSystemApp: {isSystemApp}")
        print(f"[{package}]launcherActivity: {launcherActivity}")
        print(f"[{package}]processName: {processName}")
        print(f"[{package}]compileSdkVersion: {compileSdkVersion}")
        print(f"[{package}]targetSdkVersion: {targetSdkVersion}")

        iconData = appInfos[package]['icon']
        with open(f'Icons/{package}.png', 'wb') as f:
            f.write(iconData)
        print(f"{package} saved")

C#解析示例

private void LoadAppInfo()
{
    string connectionString = "Data Source=appInfo.db;";
    using var conn = new SqliteConnection(connectionString);
    conn.Open();
    string sql = "SELECT _id, packageName, appName, isSystemApp, launcherActivity, processName, compileSdkVersion, targetSdkVersion, icon FROM apps";
    using var cmd = new SqliteCommand(sql, conn);
    using (var reader = cmd.ExecuteReader())
    {
        var appInfos = new Dictionary<string, Dictionary<string, object>>();

        while (reader.Read())
        {
            string packageName = reader.GetString(reader.GetOrdinal("packageName"));
            string appName = reader.GetString(reader.GetOrdinal("appName"));
            bool isSystemApp = reader.GetBoolean(reader.GetOrdinal("isSystemApp"));
            string launcherActivity = reader.GetString(reader.GetOrdinal("launcherActivity"));
            string processName = reader.GetString(reader.GetOrdinal("processName"));
            int compileSdkVersion = reader.GetInt32(reader.GetOrdinal("compileSdkVersion"));
            int targetSdkVersion = reader.GetInt32(reader.GetOrdinal("targetSdkVersion"));
            byte[]? iconData = reader.IsDBNull(reader.GetOrdinal("icon")) ? null : (byte[])reader.GetValue(reader.GetOrdinal("icon"));

            if (appInfos.ContainsKey(packageName))
            {
                continue;
            }

            appInfos[packageName] = new Dictionary<string, object>
                    {
                        {"appName", appName},
                        {"isSystemApp", isSystemApp},
                        {"launcherActivity", launcherActivity},
                        {"processName", processName},
                        {"compileSdkVersion", compileSdkVersion},
                        {"targetSdkVersion", targetSdkVersion},
                        {"iconData", iconData}
                    };

            Log.Info($"[{packageName}]appName: {appName}");
            Log.Info($"[{packageName}]isSystemApp: {isSystemApp}");
            Log.Info($"[{packageName}]launcherActivity: {launcherActivity}");
            Log.Info($"[{packageName}]processName: {processName}");
            Log.Info($"[{packageName}]compileSdkVersion: {compileSdkVersion}");
            Log.Info($"[{packageName}]targetSdkVersion: {targetSdkVersion}");

            string iconsDir = "Icons";
            if (!Directory.Exists(iconsDir))
            {
                Directory.CreateDirectory(iconsDir);
            }

            string iconPath = Path.Combine(iconsDir, $"{packageName}.png");
            if (iconData != null)
            {
                File.WriteAllBytes(iconPath, iconData);
            }
            Log.Info($"{packageName} saved");
        }
    }
}

WPF实现数据绑定

Thu, 09 Jan 2025 00:00:00 GMT

import { Tabs, TabItem } from 'astro-pure/user';

前提

在 WPF 中，数据绑定是一种强大的机制，用于将 UI 元素（如TextBox、Button等）与数据对象进行关联。

INotifyPropertyChanged接口允许数据对象在其属性值发生改变时通知 UI，从而使 UI 能够自动更新以反映最新的数据状态。

优势

自动更新 UI：当数据变化时，UI 自动刷新（无需手动调用 setText 或 update）
减少样板代码:避免手动同步数据和控件状态
支持 MVVM 模式：在 WPF 中，数据绑定是 MVVM（Model-View-ViewModel）的核心
数据验证 & 格式化：自动处理输入验证、数据转换（如日期格式化）

ToolMainWindow中实现

public int Count
{
    get { return _count; }
    set { _count = value; OnPropertyChanged(nameof(Count)); }  // 通知属性值已更改
}

public ToolMainWindow()
{
    InitializeComponent();
    DataContext = this;  // 设置数据上下文
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    Count++;
}

public event PropertyChangedEventHandler? PropertyChanged;  // 实现接口

protected virtual void OnPropertyChanged(string propertyName)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

}

  </TabItem>
  <TabItem label="ToolMainWindow.xaml">
```xml
<UserControl x:Class="demo.ToolMainWindow"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:local="clr-namespace:demo"
             mc:Ignorable="d"
             d:DataContext="{d:DesignInstance local:ToolMainWindow,
                                IsDesignTimeCreatable=False}"
             d:DesignHeight="450" d:DesignWidth="800">
    <StackPanel>
        <Button Content="click it!" Click="Button_Click"/>
        <TextBlock Text="{Binding Count, Mode=OneWay}"/>
    </StackPanel>
</UserControl>

实现INotifyPropertyChanged接口
数据上下文设置
数据源设置

ToolMainWindowViewModel中实现

适用于需要多个数据模型，方便管理

public int Count
{
    get { return _count; }
    set { _count = value; OnPropertyChanged(nameof(Count)); }  // 通知属性值已更改
}

public event PropertyChangedEventHandler? PropertyChanged;  // 实现接口

protected virtual void OnPropertyChanged(string propertyName)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

}

  </TabItem>
  <TabItem label="ToolMainWindow.xaml.cs">
```c#
public partial class ToolMainWindow : UserControl, INotifyPropertyChanged
{
    public ToolMainWindowViewModel ViewModel { get; set; }

    public ToolMainWindow()
    {
        ViewModel = new ToolMainWindowViewModel();
        InitializeComponent();
        DataContext = ViewModel;  // 设置数据上下文
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        ViewModel.Count++;
    }
}

安装adb环境

Mon, 06 Jan 2025 00:00:00 GMT

介绍

adb（Android Debug Bridge）是Android开发工具包（SDK）中的一个命令行工具，用于在计算机和Android设备之间进行通信和交互。它允许开发人员安装、调试和管理Android应用程序，以及在设备和计算机之间传输文件。

安装步骤

1. 安装SDK

从android官方网站（SDK 平台工具版本说明 | Android Studio | Android Developers）中下载Android SDK，可以仅下载SDK中的Platform-Tools，Platform-Tools包含了adb与fastboot。

2. 设置环境变量

为了使系统中的任意位置都能使用adb，需要对环境变量进行设置。

右键点击此电脑或计算机，选择属性，进入高级系统设置，点击环境变量。在系统变量栏中，找到Path并双击。

点击新建，添加Platform-Tools路径，如下图。

保存。

打开命令提示符(cmd)，输入adb version，如果返回类似下面的结果，则表示配置成功。

C:\Users\qiata>adb version
Android Debug Bridge version 1.0.41
Version 35.0.2-12147458
Installed as C:\platform-tools\adb.exe
Running on Windows 10.0.22631

CSharp执行终端指令

Mon, 06 Jan 2025 00:00:00 GMT

开发背景

执行终端指令，并返回结果

功能实现

public class NProcess
{

    /// <summary>
    /// 执行cmd命令
    /// </summary>
    /// <param name="command">cmd命令</param>
    /// <param name="useUTF8">是否使用utf-8编码</param>
    /// <returns>包含命令执行结果的Process对象</returns>
    public static Process Run(string command, bool useUTF8=true)
    {
        ProcessStartInfo startInfo = new()
        {
            FileName = "cmd.exe",
            Arguments = $"/c {command}",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true, // 不显示cmd窗口
        };
        if (useUTF8)
        {
            startInfo.StandardOutputEncoding = Encoding.UTF8;
        }
        using Process process = new() { StartInfo = startInfo };
        process.Start();
        return process;
    }

    /// <summary>
    /// 运行指定的命令行命令，并返回命令的输出结果。
    /// </summary>
    /// <param name="command">要运行的命令行命令。</param>
    /// <param name="useUTF8">是否使用utf-8编码。</param>
    /// <returns>返回命令的输出结果。</returns>
    public static string RunReturnString(string command, bool useUTF8=true)
    {
        ProcessStartInfo startInfo = new()
        {
            FileName = "cmd.exe",
            Arguments = $"/c {command}",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true, // 不显示cmd窗口
        };
        if (useUTF8)
            startInfo.StandardOutputEncoding = Encoding.UTF8;
        using Process process = new() { StartInfo = startInfo };
        process.Start();
        // 同步读取输出
        string result = process.StandardOutput.ReadToEnd();
        // 等待进程退出
        process.WaitForExit();
        // 返回结果
        return result;
    }

    /// <summary>
    /// 运行指定的命令行命令，并返回命令的输出流。
    /// </summary>
    /// <param name="command">要运行的命令行命令。</param>
    /// <returns>返回命令的输出流。</returns>
    public static Stream RunReturnStream(string command)
    {
        ProcessStartInfo startInfo = new()
        {
            FileName = "cmd.exe",
            Arguments = $"/c {command}",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true, // 不显示cmd窗口
        };
        using Process process = new() { StartInfo = startInfo };
        process.Start();
        var stream = process.StandardOutput.BaseStream;
        return stream;
    }

}

高级启动中缺少禁用驱动强制签名的解决方法

Fri, 03 Jan 2025 00:00:00 GMT

问题背景

系统高级启动选项中，有时找不到禁用驱动强制签名的选项。

问题原因

一般来说，是由于恢复环境WINER.wim的丢失造成的。该镜像存在于C盘根目录的Recovery文件夹，该文件夹被删除或精简。

解决方法

首先Win + X 打开终端管理员
输入 reagentc /info 并回车，查看WINER.wim文件是否真的丢失

如图所示Windows RE位置为空，说明文件丢失。

在系统盘根目录新建名为Recovery的文件夹，然后再在Recovery文件夹内新建名为WindowsRE的文件夹。完整路径即为C:\Recovery\WindowsRE。
从微软原版Windows ISO镜像中获取WinRE.wim映像，直接提取镜像中install.wim文件。或者也可以从没有丢失WINRE.wim镜像的电脑中拷贝一份。放在C:\Recovery\WindowsRE目录下。
再次WIN+X 打开终端（管理员），输入reagentc /setreimage /path C:\Recovery\WindowsRE 回车，之后再输入reagentc /enable 回车

reagentc /setreimage /path C:\Recovery\WindowsRE
reagentc /enable

操作完成后，就修复了windows的恢复环境。再进入高级启动选项中，就可以看到"禁用驱动强制签名"等选项。

51单片机接收AT指令功能实现

Fri, 03 Jan 2025 00:00:00 GMT

开发背景

51单片机需要接收电脑端发送的指令，来控制继电器的通断，从而控制连接电脑端的USB数据线的通断。

指令配置如下

AT+USB=1  // 连接usb
AT+USB=0  // 断开usb

功能实现

具体代码如下

#include <reg52.h>
#include <string.h>

#define uchar unsigned char
#define uint unsigned int

uint dataCount;       // 数据计数器
uint receiveStatus;   // 接收状态：-1未开始，0错误，1开始
uchar receiveStr[10]; // 接收字符串缓冲区
// 函数声明
uint checkReceiveStatus();
void send_str_com(unsigned char *sendStr);

// 初始化串口及相关寄存器
void init()
{
    TMOD = 0x20; // 定时器1工作方式2（8位自动重装）
    PCON = 0x80; // 使能波特率倍增
    TH1 = 0xFD;  // 设置波特率为9600（根据晶振频率调整）
    TL1 = 0xFD;
    TR1 = 1; // 启动定时器1
    REN = 1; // 使能串口接收
    SM0 = 0; // 串口工作方式1（8位UART）
    SM1 = 1;
    EA = 1; // 使能全局中断
    ES = 1; // 使能串口中断
}

void main()
{
    init(); // 初始化串口
    send_str_com("init ok!");
    receiveStatus = -1; // 重置接收状态
    while (1)
    {
        if (checkReceiveStatus() == 1)
        {                             // 如果接收到完整数据
            send_str_com(receiveStr); // 回显接收到的数据

            // 根据接收到的指令执行相应操作
            if (0 == strncmp(receiveStr, "AT+USB=1", 8))
            {
                send_str_com("connect usb");
                P1 = 0xff;
            }
            else if (0 == strncmp(receiveStr, "AT+USB=0", 8))
            {
                send_str_com("break usb");
                P1 = 0x00;
            }
            else
            {
                receiveStatus = -1;        // 重置接收状态
                memset(receiveStr, 0, 10); // 清空接收缓冲区
            }
        }
    }
}

// 串口中断服务程序
void ser() interrupt 4 using 3
{
    if (RI)
    {           // 如果接收到数据
        RI = 0; // 清除接收中断标志
        if (receiveStatus == -1)
        { // 接收第一个数据
            if (SBUF != 'A')
            { // 如果不是AT指令开头报错
                receiveStatus = 0;
                dataCount = 0;
            }
            else
            {
                receiveStatus = 1; // 开始接收
                dataCount = 0;
                memset(receiveStr, 0, sizeof(receiveStr[10])); // 数据清空
                receiveStr[dataCount] = SBUF;                  // 存储第一个字符
                dataCount++;
            }
        }
        else if (receiveStatus == 1)
        { // 正在接收
            if (dataCount > 10)
            {
                receiveStatus = 0;
                dataCount = 0;
            }
            else
            {
                receiveStr[dataCount] = SBUF;
                dataCount++;
            }
        }
    }
}

uint checkReceiveStatus()
{ // 检查接收状态
    if (receiveStatus == 0)
    {
        send_str_com("RECEIVE ERROR");
        receiveStatus = -1;
        return 0;
    }
    if ((dataCount > 1) && (receiveStatus == 1))
    { // 如果接收到完整的一行数据
        if ((receiveStr[dataCount - 2] == 0X0D) && (receiveStr[dataCount - 1] == 0X0A))
        {
            receiveStatus = -1; // 重置接收状态
            return 1;           // 表示接收到完整数据
        }
    }
    return 0;
}

void send_str_com(unsigned char *sendStr) // 发送字符串
{
    uchar i;
    for (i = 0; sendStr[i] != '\0'; i++)
    {
        SBUF = sendStr[i];
        while (TI == 0)
            ;
        TI = 0;
    }
}