Timeline

前言：狂热之下，所有人都该冷静想想退路

过去两年，软件行业经历了一场罕见的集体狂热。Vibe Coding 成了流行词：一句话生成一个应用，一个周末上线一个产品，「不需要懂代码」的叙事铺天盖地。大模型公司估值一路水涨船高，算力订单排到几年之后，投资圈的逻辑从「这个项目能赚钱吗」变成了「这个故事够不够大」。

与此同时，另一群人的担忧也在发酵：AI 泡沫是不是在重演 2000 年的互联网狂剧？靠 Prompt 堆出来的系统，两年后谁来维护？当「能跑就行」成为团队默认的交付标准，技术债以从未有过的速度累积，会以什么方式清算？

本文不打算做预言家。2027 年泡沫会不会正式破裂，没人能给出确定答案。但把「如果破裂」当作一场思想实验推演一遍，是非常值得的——因为它的价值不在于预测是否应验，而在于：无论泡沫破不破、什么时候破，推演中暴露的问题今天就已经真实存在，推演中给出的答案今天就已经开始有效。

本文回答一个问题：通知渠道从"邮件/短信/Webhook"老三样扩到 39 种（钉钉、飞书、Slack、Telegram、Bark、极光、Twilio、PagerDuty……），代码量为什么没有翻 13 倍——配置面是怎么设计的？

GoWind Admin 的通知渠道扩展（1.4.0）把接入渠道数从 3 种推到 39 种，但真正值得拆的不是"接了多少平台"，而是这条扩展曲线背后的三个设计决策：投递能力下沉为独立库（管"怎么发"）、schema 驱动的注册表（新渠道 = 一份声明 + 一份 builder）、配置存储从多列切到整包 JSON（39 种渠道共用一个 settings 列）。加上敏感字段的"加密落库 / 回显脱敏 / 留空不修改"三段闭环，这一套组合是可以直接搬走的通知渠道扩展方案。

本文回答一个问题：让大模型把自然语言翻译成 SQL 直接在公司数据库上执行，怎么才能不把生产库拖垮、不把别人的数据泄露出去？

GoWind CMS 的智能问数（NL2SQL）功能允许用户输入"最近 30 天哪个分类的文章评论最多"，系统让模型生成 SQL、在库上执行、再把结果喂回模型生成自然语言结论。这件事的工程本质不是"让模型写对 SQL"——是假设模型一定会写错、会幻觉、会被提示注入的前提下，如何在执行路径上保证它只能造成无害的错误。

本文回答一个问题："把这篇文章一键发到 10 个平台、明早 9 点准时发、失败自动重试、发布后还能回拉互动数据"——这句话拆成工程问题，一共有几层？

GoWind CMS 的社交分发功能连接 10 个平台（Bluesky / Mastodon / DEV.to / Telegram / WordPress / 微信公众号 / Nostr / 微博 / LinkedIn / 博客园），支持内容一键分发、定时发布、改期重排、失败重试、互动统计回拉，并把这些能力以 MCP 工具的形式暴露给 AI 代理。这篇文章拆它的五层：平台适配器、凭据生命周期、发布状态机、定时自愈、统计回拉——每一层都有可以直接迁移的工程决策。

本文回答一个问题：两个人同时编辑同一篇富文本，从浏览器到 Go 服务端再到数据库，中间要处理哪些协议、锁、持久化与竞态？

GoWind CMS 的帖子/页面编辑页支持多人同编：在线光标、无冲突合并、断线恢复、离线内容回流。后端没有用任何现成的协同 SaaS，而是在 Go 侧搭了一套 Yjs 兼容的 WebSocket 服务（COLLAB_ADDR，默认 :6602），与 TipTap 的 Collaboration 扩展直连。这个功能的实现从 v1 到 v2.5 演进了三版（编辑锁 → 持久化自愈 → 服务端权威种子化），每一版解决一类问题，踩过的坑都留在了代码注释里——这篇按演进顺序拆。

本文回答一个问题："审批完的采购单自动生成应付、收货自动回写库存、低库存自动起草补货单"——同一句"数据全打通"，为什么有的链路用硬事务、有的用软失败、有的用事务后 defer？

GoWind ERP（采购/库存/财务三大模块）的 README 把"单据驱动单据"当核心卖点，而代码里真正值得学的是它对一致性等级的分层：不同链路按"失败的代价"选了三种不同的机制——硬同事务、软失败人工补、单体 SAGA 缝。这篇文章把这三种机制各拆到底，再补一刀贯穿全库的并发武器：SQL 条件更新。

本文回答一个问题：把一张卡片从"进行中"拖到"已完成"的第三行，要让所有在线用户的屏幕一致地变化——排序、并发、同步这三件事分别怎么解？

GoWind Kanban（风行看板）的实时协作没有用 CRDT、没有用协同算法库，是"服务端权威排序 + 乐观锁 + 尽力而为广播 + 差量兜底"的四层务实组合。这篇拆这四层，外加一条 WebSocket 准入的安全演进线。

本文回答一个问题：记账 App 的"账户余额"到底是算出来的还是存出来的？选了"存出来的"，删除、修改、确认这些操作要付出什么代价？

GoWind Ledger（风行记账，单式记账：支出/收入/转账/调整四类流水）的核心设计是冗余余额列——账户表上存 balance，流水增删改时手工维护它。这篇拆它的余额维护机制（confirm 确认流、RefundBalance 补偿、copy-then-delete 更新），也如实拆它的三条裂缝——一条没能回滚的调整流水、两段没进事务的余额操作。设计取舍与已知缺陷放在一起讲，比只讲光鲜面有用得多。

本文回答一个问题：不引入 Camunda/Flowable，自己写一个支持条件分支、并行会签、子流程、回退环的审批引擎，核心复杂度到底在哪几处？

GoWind OA（协同办公：审批流转、请假报销、考勤）内置了一个自研的轻量级工作流引擎——约 3000 行核心 Go 代码（不含生成物），7 张表，28 个图模型单测 + service 层集成测试，配一篇 358 行的设计文档。它不追求 BPMN 兼容，只追求"把审批这件事的边界情况全部想清楚"。这篇按引擎的六个机制拆：图契约、编译期校验、运行期推进、会签或签、寻人与委托、业务挂钩——每一段都有真实的取舍可讲。

本文回答一个问题：当你点下「分发到 20 台机器」，从浏览器到目标机磁盘落定，中间经过了哪些服务、哪些协议、哪些状态机与哪些防呆设计？

GoWind Ops 是一个多节点运维平台，Go 后端（Kratos 微服务 + Ent + PostgreSQL/Redis/MinIO）+ React 19 管理台。它不做大而全的 K8s 替代品，聚焦四件事：管机器、跑项目、发脚本、构建分发，组织权限、审计日志、数据字典作为系统底座内置。

本文回答一个问题：core 服务水平扩到多副本之后，定时任务、指令回执、构建触发、告警外呼，靠什么保证不重复执行——而又不引入 Redlock、etcd concurrency、ZooKeeper 分布式锁里的任何一种？

GoWind Ops 的 core 是唯一连库的领域服务，天然想水平扩：多副本分摊 MQTT 信令、多副本跑定时调度。但多副本立刻带来一组经典问题——同一分钟的双 cron 触发、同一指令的重复回执、同一配置的并发构建。常见的答案是上一把分布式锁，GoWind Ops 的选择是把协调拆散进它已经在用的三个层：MQTT broker 的投递语义、数据库条件更新、Redis 原子操作。全仓找不到 redsync / etcd concurrency / 抢占式锁服务里的任何一种"锁服务"。

本文回答一个问题：用户下单后 30 分钟没付款，系统要收回什么、按什么顺序收、怎么防重防并发？"超时关单"这个电商标配功能，值得写 450 行吗？

GoWind Shop 的未支付订单 30 分钟自动过期（ExpireOrderByTimeout，约 150 行核心逻辑），是全仓库把"事务边界设计"体现得最完整的一条链路：释放库存、状态推进、孤儿支付清理、优惠券返还四件事在一个数据库事务里完成，外层有延迟任务的投递去重与幂等闸门。拆它之前先看它的对照面——下单事务，因为超时收回的每一样东西，都是下单时锁定的。

本文回答一个问题：一次上下滑、一次发布、一次审核驳回，在 GoWind ShortPlay 里分别走过了哪些代码、哪些状态与哪些取舍？

GoWind ShortPlay 是一个短视频社区的完整实现：上下滑沉浸式 Feed、拍摄发布、互动社区、后台审核闭环。后端 Go 1.26 + Kratos v2.9 + Ent v0.14 + PostgreSQL/Redis/MinIO，前端 React 19 管理台 + Flutter 跨平台 App，与 go-wind-cms 同构——同一套基座，换一个业务域长出一个新产品。

本文回答一个问题：一条 SQL 都没手写的情况下，租户 A 的用户为什么绝不可能查到租户 B 的视频——连"漏一次"的机会都没有？

多租户隔离最常见的死法是应用层 WHERE：每个仓储方法都记得写 tenant_id = ?，直到某天一个新同事写的接口忘了——于是租户 B 拉到了租户 A 的数据，没有任何报错。GoWind ShortPlay 不信任任何人的记性：它把隔离下沉到 ORM 层（Ent 的 privacy 机制），查询根本到不了 SQL 就被拦下补条件或直接拒绝。全仓 51 张业务表的 schema 里没有一行手写的租户过滤代码，隔离却无处不在。

本文回答一个问题：一个"上下滑短视频"App，把抖音的手感做对，Flutter 端到底要处理哪些细节？

上下滑短视频 App 的代码量错觉很强：看起来就是"一个 PageView + 一个播放器"，但 GoWind ShortPlay 的 Flutter 端（BLoC + media_kit，一套代码 iOS/Android/Windows 同源）真正下功夫的全是看不见的地方——页面切换时播放器状态的精确交接、单击秒响应与双击点赞并存的判定、游客刷得动但互动要登录的静默降级。这篇拆 Flutter 端三个最值得学的板块：播放器生命周期、手势状态机、401 游客降级。

本文回答一个问题：没有算法团队、没有特征平台、没有模型服务，一个短视频 Feed 的"推荐"要怎么做才不是自欺欺人？

GoWind ShortPlay 的 Feed 有一套完整的推荐链路：Flutter 播放器实时上报观看行为 → core 防刷入库 → 三路召回 + 热度加权排序 → 已看去重 → 召回理由随内容回传。全程一个模型都没有，但闭环的每一环都是真的——埋的是真数据、算的是真信号、去重是真去重。

本文回答一个问题：一套围绕 Doris UNIQUE KEY 模型建起来的行为分析系统（upsert 去重、随时可查的聚合结果），要支持 ClickHouse 二选一部署，需要翻译的到底是什么——建几张表就够了吗？

GoWind UBA 的 OLAP 层原本只跑 Doris。为了适配"已有 ClickHouse 集群、不想再养一套 Doris"的部署环境，项目做了第二个引擎实现：backend/sql/clickhouse/ 的全套 DDL、internal/data/clickhouse/ 的 13 个同名仓储文件、uba-ingest ch-etl 回算工具。CHANGELOG 里那句"ClickHouse 引擎的读数正确性（事件去重 / FINAL 读 / 派生表按天回算）已与 Doris 对齐"，背后是四幕真实的语义翻译——每一段 DDL 注释都是一次数据丢失模式的防御记录。

"Go 还是 Rust"吵了十年，大多停留在语言层面互喷，产不出架构决策。工程上更有价值的问法是三段论：**两者的成本模型差在哪？边界应该画在哪？用什么方式接起来？**本文按这三段展开：先把 Go 的 GC 税与 Rust 的优势边界算成账（含"怎么量自己系统里的这笔税"），再给出"变化频率 × 延迟敏感度"的切分准则，然后把四种集成模式（进程边界 / sidecar / FFI / WASM）按集成成本排序逐一拆解——每种都给到代价清单与适用判据，最后落到一个真实样本：用 Rust 实现的中后台平台（RushWind Admin）与 Go 业务服务如何共享同一份 proto 契约协同。反例与不适用场景一并摆出来，量化表述尽量给可核对的量级与出处。

大多数后端项目的 API 层是"人肉维护的目录"：路由注册、参数解析、错误码映射、文档注释——四份东西描述同一个事实，靠人保证一致，于是永远不完全一致。RushWind Admin 把这层做成了编译产物：Protobuf 是唯一契约，构建期确定性生成路由、错误映射、服务接口与绑定计划——203 条路由、441 条错误状态映射、198 个服务接口方法，零手写；前端 TypeScript 客户端同源于契约，三套前端字节相同。本文拆解这条生成流水线的设计与治理，以及三个真实踩到的暗礁——每一个都值得写成生成器作者的检查清单。

中后台大概是世界上被写得最多、也最不被认真对待的软件品类：几乎每家公司都要再写一遍用户、角色、租户、审计，写完还要为它们的安全性、性能与多前端适配反复买单。更麻烦的是，这块代码谁都不敢动——它不产生差异化价值，却出不起事故。RushWind Admin（中文名：锐风）把这套底座用 Rust 完整做了一遍：112 个 proto 契约文件、构建期生成 203 条路由、六类审计日志、存储层多租户隔离、TOTP 多因素认证、异步任务队列、SSE 实时推送、脚本级插件系统，外加 React / Vue Element / Vue Vben 三套前端共享同一份生成客户端。本文是它的自我介绍；至于"Go 写业务、Rust 扛平台"的混合架构论证，另有一篇硬核文专门展开。

管理系统的账号是人用的。但当监控平台要拉数据、CI 流水线要触发任务、第三方系统要对接时，团队最常见的做法是把管理员账号密码写进对方的配置文件——这是一次凭据泄漏事故的预约：密码改一轮就得通知所有对接方、那个人还有正常登录和会话、泄漏了都不知道从哪漏的。风行（GoWind Admin）提供 AK/SK 机器凭证体系：给"系统对系统"的调用发独立身份，人机分治、各自设防。

一、模型：机器是机器，人是人

AK/SK（Access Key / Secret Key）与云厂商开放 API 的凭证同构，任何对接过 AWS/阿里云 API 的开发者零学习成本：

当"接个大模型"成为每个管理系统的标配需求，多数团队的选择是在业务代码里散落一堆 SDK 调用：密钥写死在配置文件、用量没人记账、租户之间无隔离、换一家模型供应商就要发版。风行（GoWind Admin）把 AI 当作平台的一等公民模块来做：提供商是数据不是配置、对话走流式推送、用量进配额体系、知识库 RAG 开箱即用，甚至自然语言问数也带四重安全护栏。本文带你完整过一遍这套 AI 能力的设计与实践。

一、能力全景：五个子域，一张图看懂

接到等保测评或客户安全问卷的那天，很多管理系统的团队才发现：登录有没有记录？操作可不可追溯？数据被谁改过能查到吗？口令策略符合要求吗？——这些能力补起来往往要动中间件、改 ORM、加表，动静不小。风行（GoWind Admin）把六类审计日志、身份鉴别三件套、留存归档做成了平台内置能力，开箱即得。本文盘点这套审计与合规体系。

一、六类审计日志：两层采集，各司其职

登录是管理系统被攻击最多的面：撞库、爆破、凭证枚举、会话劫持。很多项目的登录只有"验密码、发 token"两步，其余全靠运气。风行（GoWind Admin）把认证做成了纵深防御的完整链路：限流、验证码、登录策略、防枚举、MFA、令牌轮换、会话吊销层层设卡。本文拆解这条链路的设计与取舍。

一、登录链路：十一道闸门按序把关

一次 POST /admin/v1/login 背后的完整链路（按执行顺序）：

 1 限流预检      IP + 用户名双维度 Redis 计数，锁定中直接 400（被封锁 IP 连用户表都不查）
 2 图形验证码    Header 携带，Redis verify-and-delete（单次有效）
 3 租户解析      tenant_code 空=平台登录；非 ON 租户统一文案拒绝
 4 登录策略·全局段  IP / 时间窗 / 设备黑名单（白名单反向约束）
 5 标识符反查    输入含 @ 走邮箱、纯数字走手机号，反查真实用户名
 6 凭证校验      AES 解密入参 → bcrypt 比对；用户不存在也跑一次假 bcrypt（恒定时间防枚举）
 7 纵深校验      凭证行租户必须等于用户行租户
 8 登录策略·用户段  定向到具体用户的策略条目
 9 授权丰富      角色链 → 权限码 → 管理员旗标 → 数据范围/字段黑名单进令牌
10 MFA 闸门      绑有 TOTP 则不发令牌，签发一次性挑战走二次验证
11 签发          access + refresh 双令牌（jti 关联，Redis 令牌对缓存）

"这个列表能导出 Excel 吗？""能不能批量导入？"——做管理系统交付的两个必问题。很多开源脚手架的答案是"请自行实现"，于是一个导出按钮在几十个列表页被复制粘贴几十遍，格式五花八门。风行（GoWind Admin）把导入导出做成了统一的封装 + 全面的铺面：管理页批量挂上导入导出能力，体验一致、代码零重复。

一、导出：一个按钮组件铺满全站

列表页工具栏的「导出」按钮来自统一的 TableExportButton 封装：当前搜索条件、当前列结构一键导出为 .xlsx，文件即点即得。这个封装已经铺满了三端的主要列表页：

SaaS 化的第一道坎就是数据隔离：租户 A 的运营人员绝不能看到租户 B 的一行数据——这不是"前端藏好按钮"能解决的事，而是要从 HTTP 入口一路压实到 SQL 的 WHERE 子句。多数自研方案的做法是在每个查询里手写 tenant_id 条件，写漏一处就是一次数据泄露事故。风行（GoWind Admin）把租户隔离做成了编译进数据访问层的默认行为：查询自动注入租户谓词、跨租户变更必扑空、伪造租户 ID 直接被覆盖，配合 HTTP 层的 Api 表闸门形成纵深防御。本文拆解这套隔离体系的三道防线与覆盖边界。

大多数管理系统的"通知"长成这样：站内信是一张表、邮件发送散落在某个 service 里、Webhook 是临时加的一段 curl——三个互不相认的半成品。想回答"这条通知发了没有、为什么失败"时，只能翻日志。风行（GoWind Admin）把通知做成了一个完整的域：业务代码一个入口发通知，路由规则决定走哪个渠道，投递台账记录每一次的成败与原因。本文拆解这套统一投递体系。

一、痛点对话：两个互不相认的半个域

风行在设计通知域之前，面对的正是多数项目的现状：

• 站内信成熟，但只能站内投递；
• 通知渠道（SMTP 邮箱配置）能发站外，但没有调度层——谁在什么时候该发什么，没人管。

把一套管理系统卖给多家客户（SaaS 化），光有租户隔离还不够——你得回答这三个商业问题：**免费版能用哪些功能？套餐到期了怎么办？用量怎么计量？**多数项目在接第一单时才想起这些，然后用手写 SQL 改库、人工停账号的方式勉强运转。风行（GoWind Admin）把套餐体系做成了平台原生的三层结构：套餐目录、模块白名单、配额计量，配合三档到期处置策略全自动执行。本文拆解这套 SaaS 化运营能力。

一、三层模型：目录、白名单、配额

配置面    sys_plans（套餐目录：版本 / 到期策略 / 描述）
          sys_plan_modules（套餐 → 功能模块白名单）
          sys_plan_quotas（套餐 → 配额）
                      │ 管理页维护（租户管理 → 套餐管理 / 配额管理）
                      ▼
绑定面    sys_tenants.plan（套餐外键）+ expired_at（到期时间）
                      ▼
执行面    模块白名单 → HTTP 租户闸门（fail-closed）
          到期处置   → 三档策略全自动执行

"新用户注册后自动发一封欢迎语""租户创建后写一条审计流水""每天凌晨清理一次过期文件"——这些小逻辑每个项目都有，但为它们走一遍「改代码 → 编译 → 发版」的流程，性价比低到令人发指。风行（GoWind Admin）内建了一套脚本级插件系统：用 JavaScript/Lua 写扩展逻辑，在管理页在线编辑、试运行、一键启用，不发版、不重启、即时生效。本文讲这套系统的扩展点、安全模型与管理页工作流。

一、先对号入座：什么需求该用脚本

风行把"行为扩展"分成三档，脚本系统卡在中间那一档：

管理系统的"实时"需求比想象中多：站内信到达要立即亮起铃铛、协同操作要互相感知、AI 对话要逐字流式输出。轮询能做但难看，WebSocket 重但得自己管心跳与重连。风行（GoWind Admin）选择了 Server-Sent Events——HTTP 之上的单向服务端推送，并把它做成了独立网关 + 统一事件通道的平台基础设施。本文拆解这套推送架构。

一、拓扑：推送是一个独立端口

SSE 服务独立监听 :7789，与 REST 的 :7788 分离：

多人网络游戏的第一性问题只有一个：若干台分布在不同网络环境里的客户端，如何各自跑出"同一场对局"。业界几十年的实践收敛出两条主路线——

• 帧同步（lockstep）：只同步玩家的操作指令，每个客户端各自把整场战斗模拟出来；
• 状态同步（state synchronization）：服务器算出结果，把结果状态广播给各客户端。

两条路线没有绝对优劣，只有与具体玩法、团队结构和运营目标的匹配度差异。本文梳理两种模型的原理、工程要点、衍生形态与选型逻辑。至于传输层（KCP / WebRTC / WebSocket）怎么选，那是与同步模型正交的另一个问题，展开在《实时游戏网络协议深度对比：KCP vs WebRTC vs WebSocket》，本文不涉及。

这篇在讲什么

大多数微服务架构的文章停在"我们用了 BFF 模式"这种结论性描述,不讲 BFF 具体怎么装配、一个请求实际穿过了哪些代码、依赖图是怎么织起来的。这篇文章反过来:用一条真实的 POST /admin/v1/mall/brands 请求,把它从 HTTP 入站到 Ent 落库的每一个环节用代码钉死,再把支撑这条链路的 Wire 依赖注入和运行时配置逐行拆解。

文中所有代码和配置都来自一个真实仓库 go-wind-shop(GitHub: https://github.com/tx7do/go-wind-shop, Gitee: https://gitee.com/tx7do/go-wind-shop),标注了文件路径可核对。读完你会清楚三件事:这条链路怎么走、它由哪些配置决定、依赖图怎么从代码生成。

一个常见误解

很多团队对"国际化"的理解停留在前端字符串翻译——zh.json/en.json 切换一下 t('hello') 就完事。但对电商而言,真正的难点不在 UI 文案,而在商品内容的多语言化。

一件商品的中文名、英文名、商品描述、类目路径——这些是入库的业务数据,不是 UI 文案。你不能把它们塞进 zh.json,因为:

• 不同语言的商品描述要分别审核、分别上下架。
• 同一件商品的"主数据"(SKU、价格、库存、类目归属)是语言无关的,只有"展示文案"按语言分叉。
• 后台编辑时,运营要在同一界面同时维护所有语言版本,而不是切来切去。
• 店铺前台要能按 URL 里的 locale 一次性取到对应语言版本,而不是取全量再前端过滤。

为什么再聊"契约驱动"

"契约驱动(contract-driven)"这个词被用滥了。大多数项目里它的实际含义是:后端写完接口,用 Swagger 注解生成一份文档,前端照着文档手写 fetch。文档和实现谁是事实源?没人说得清。接口改了文档没改,文档改了实现没改,前后端各自演进直到某天线上 404。

这篇文章不讲概念,讲一个可运行的工程闭环:以 .proto 为唯一事实源,一次 buf generate 同时产出六路产物——后端 gRPC 桩、后端 HTTP 桩、错误码 helper、请求校验器、PII 脱敏器、OpenAPI 文档,以及给前端的 TypeScript 客户端。文中所有配置和代码都来自一个真实仓库 go-wind-shop(GitHub: https://github.com/tx7do/go-wind-shop, Gitee: https://gitee.com/tx7do/go-wind-shop),你可以逐行核对。

为什么写这篇

安全这件事,讲概念的多(纵深防御、最小权限、fail-closed),讲工程落地的少。一篇好的安全文章应该能回答:这些概念具体落在哪几行代码里、它们怎么串成一条链、出过什么洞、怎么修的。

这篇文章拆解一个真实仓库 go-wind-shop(GitHub: https://github.com/tx7do/go-wind-shop, Gitee: https://gitee.com/tx7do/go-wind-shop)的安全实现。它不讲"应该做什么",讲"实际做了什么、实际踩过什么坑、实际怎么修的"。文中会引用四个真实的 git commit,每个都是一个被修的安全洞——从漏洞存在、到发现、到修复代码,完整还原。

本文回答一个问题：当一个用户行为从浏览器发出，到最终在 Vue 看板上变成一条留存曲线，中间经过了哪些服务、哪些代码、哪些取舍？

一、先看全貌：四个角色的接力

GoWind UBA 不是单体，也不是"微服务为了微服务"。它把用户行为分析的链路切成职责清晰的三段服务，外加一个采集 SDK：

SDK 上报 ──HTTP──▶ Collector ──Publish──▶ Kafka ──▶ Core ──▶ OLAP
                                                       │
                  Vue 看板 ◀──HTTP/SSE── Admin ◀──gRPC──┘

本文回答一个问题：一个 SaaS 级 UBA 平台，怎么保证租户 A 绝对看不到租户 B 的数据？ 答案藏在两层完全不同的机制里——而它们的边界差异，恰恰是最值得讲的部分。

一、两套机制，一个真相

先说结论：GoWind UBA 的多租户隔离不是一套统一机制，而是两套独立的、设计哲学迥异的机制：

本文回答一个问题：25 个分析模型（漏斗 / 留存 / LTV / 归因 / 路径……）在 ClickHouse 和 Doris 上，到底是用什么 SQL 写出来的？双引擎又是怎么做到"一份业务模型，两份实现"的？

一、为什么是双引擎？

先说结论：GoWind UBA 支持 ClickHouse 和 Apache Doris 二选一，部署时按需选其一，运行时通过一个开关切换。这是一个很有意思的工程选择——为什么不让用户自己写 SQL，而要维护两份？

本文回答一个问题：一个埋点事件，从用户在浏览器里点了一下，到最终被 Kafka 接住，中间的 SDK 和 Collector 做了多少你看不见的工程？ 答案是：比你想象的多得多。

一、为什么"采集"这件事很难

很多人以为埋点 SDK 就是 fetch('/report', { body: event })。这在 demo 里成立，在生产里不成立。真实的采集层要回答这些问题：

• 页面随时可能关闭——用户点完就关 tab，残留事件怎么办？
• 网络随时可能抖动——一次失败就丢数据？还是重试？重试几次？退避多久？
• 服务端可能限流——429 要重试，但 401（鉴权失败）不该重试，怎么区分？
• 批量还是单条——单条上报开销大，批量要攒多久、攒多少？
• 客户端环境千差万别——浏览器的 sendBeacon、Unity WebGL 不能用 HttpClient、小程序没有 localStorage……
• 凭证放哪——放 Header 还是 body？前者标准但不支持 sendBeacon。

一、项目原始架构与初期设计取舍

1.1 初始架构：go-wind-cms 原生三层设计

项目初期，我们直接引入 go-wind-cms 作为技术底座。其原生的目录结构完美契合了我们定下的硬性分层规范：

backend/app/
├── admin/service/   # Admin-BFF：管理后台聚合层
├── app/service/     # App-BFF：前台应用聚合层
└── core/service/    # Core大包：核心业务服务

本文基于 kratos-transport 项目的实际架构，深入分析三种主流实时通信协议在游戏场景下的性能差异与选型策略。

1. 三种协议的协议栈全景

1.1 KCP

KCP 是一个基于 UDP 的可靠传输协议，由 skywind3000 开发。其核心思想是用带宽换延迟——通过更激进的重传策略和拥塞控制，在弱网环境下获得远低于 TCP 的延迟。

本文面向希望基于此项目进行二次开发的 Flutter 工程师，从技术栈选型、核心架构设计、关键模块实现到二开实践路径，提供一份完整的技术地图。

一、技术栈总览

本项目是一个 Flutter 全平台 CMS 内容展示前端，一套 Dart 代码同时编译为 iOS、Android、Web、macOS、Windows 等多端应用：

在 Go 开发社区中，长期存在一个普遍认知误区：以 Kratos 为代表的微服务框架配置流程繁琐、工程模板冗余、上手门槛较高，仅适合大型分布式项目，用于中小单体业务属于大材小用。同时 Protobuf IDL、Wire 依赖注入等配套技术的学习成本，也让大量初学者、外包开发者望而却步。原生 Kratos 本身具备单体运行能力，但官方默认模板面向分布式场景设计，存在组件冗余、初始化流程繁杂、单体适配不友好等问题，直接用于单体项目改造成本较高。而 GoWind Admin 通过自研 Kratos-Bootstrap 封装层，重构原生框架的启动机制、组件组装逻辑、分层规范与工程工具体系，借鉴 Java Spring Boot 配置驱动的极简设计思想，实现了微服务框架的轻量化、标准化单体落地。本文将基于 GoWind Admin 原生架构，从架构革新、工具链工程化赋能、数据源拓展能力、渐进式架构演进四个维度，拆解其低门槛、高规范、可拓展的核心技术优势。

本文面向希望基于此项目进行二次开发的前端工程师，从技术栈选型、核心架构设计、关键模块实现到二开实践路径，提供一份完整的技术地图。

一、技术栈总览

本项目是一个 Taro 多端 CMS 内容展示前端，一套代码同时编译为 H5、微信/支付宝/抖音小程序等多端应用：

本文面向希望基于此项目进行二次开发的前端工程师，从技术栈选型、核心架构设计、关键模块实现到二开实践路径，提供一份完整的技术地图。

一、技术栈总览

本项目是一个静态导出型 CMS 内容展示前端，采用以下核心技术栈：

本文面向希望基于此项目进行二次开发的前端工程师，系统性地讲解项目的技术选型、架构设计与模块划分，并提供扩展开发的实操指引。

一、项目概览

本项目是一个面向内容管理的现代前端应用，使用 Nuxt 4（Vue 3）构建，支持 SSR/SSG 双模式部署，提供文章、分类、标签、评论等完整的内容管理功能，并内置多语言（中英文）和暗色模式支持。

核心特性一览

前言

做Go微服务开发，大部分开发者每天都在做无用功：新建项目、搭建目录、手写实体类、反复写DAO、Service、Proto文件，还有枯燥的CRUD基础代码。不仅浪费时间，团队每个人编码风格不一样，还会导致项目结构混乱、维护成本飙升。

go-wind-toolkit 完美解决CRUD重复开发的痛点！一站式搞定项目创建、数据库导入、业务分包、全自动代码生成，直接产出可直接运行的 gRPC + BFF 完整后端项目。这篇图文手把手带你从零上手，一篇吃透后端全部生成功能。

一、整体流程速览

后端代码生成全程只需要4步，单体、微服务项目全部通用，新手也能轻松上手：

前言

开发中后台管理系统，最耗费精力的不是业务开发，而是重复机械的CRUD工作：编写数据列表、封装接口、写搜索条件、制作新增编辑弹窗、配置路由菜单。

很多代码生成工具需要人工反复微调字段、配置页面功能，依然繁琐。而 go-wind-toolkit 前端生成器主打全自动模式，依托 OpenAPI 元数据自动解析生成页面，几乎零人工介入。

工具内置三套主流开发模板：Vue3 ElementPlus、Vue3 Vben Admin、React AntDesign。全程无需精细化手动配置，导入文件即可一键产出完整可用的后台CRUD项目。

前言

大模型技术高速迭代，正在深层次重塑软件开发的作业模式。当前编码类大模型已成熟支持单文件编写、批量CRUD生成、业务逻辑拼装等能力，部分低复杂度业务模块，甚至可全程交由AI独立完成开发与交付。

行业内随之滋生出一种极具迷惑性的论调：AI普及编码之后，开发框架与脚手架的价值将会彻底消亡。未来开发者仅依靠Prompt即可完成全流程开发，标准化工程基建终将沦为时代冗余产物。

站在生产级微服务、企业级中后台项目的落地视角来看，该观点存在根本性认知误区，其混淆了碎片化代码生成与系统化工程交付两个完全不同的概念。直白来说：会写代码不等于能搭建生产级系统，这也是当下绝大多数开发者对AI编码最大的认知盲区。

搭建后台管理系统、业务中台时，几乎所有开发团队都会遇到同一个问题：究竟是直接接入成熟的第三方IAM（身份与访问管理）系统，还是结合业务场景自建认证授权体系？

尤其对于基于 Go 语言开发的中小型后台（例如 go-wind-admin 这类通用管理框架），这道选择题没有绝对标准答案，核心取决于系统规模、业务场景、维护成本、长期演进规划。本文结合实战经验，拆解两种方案的优劣、适用场景、落地风险，同时提供从单体到微服务的平滑演进方案，帮助团队做出最合适的技术决策。

一、认清两种方案的本质区别

一、前言

在企业级中后台系统、SaaS平台以及内部运维平台的开发过程中，架构选型直接决定项目的扩展性、维护成本与迭代效率。传统MVC单体架构长期存在视图与业务高度耦合、前端技术栈绑定僵化、无法适配多终端业务等痛点；而原生Headless架构虽解决了解耦问题，但仅提供基础API能力，团队仍需从零完成前端工程搭建、权限封装、页面开发，大幅抬高项目落地门槛。

基于此，行业内逐渐衍生出一种新型开发方案：纯Headless API服务 + 多套可选前端模板。该方案既坚守无头架构前后端解耦的核心特性，又通过预制主流技术栈前端模板，补齐纯无头架构落地效率低的短板。本文将详细拆解这套以Go语言为底层底座的企业级开发方案，从架构原理、技术构成、核心优势到实操教程，全方位解析该方案的应用价值。

前言：为什么越来越多人厌倦传统Admin脚手架？

在 Golang + Vue 中后台开发领域，成熟一体化脚手架早已成为企业项目开发的首选方案。标准化脚手架能够完成项目初始化、权限封装、基础页面搭建等重复性工作，大幅提升项目落地速度。但在实际业务迭代过程中，不少开发者都会遇到同一个普遍性痛点：部分脚手架过度封装底层组件，固化编码范式，变相约束开发者的编码自由度。

这类脚手架为了统一团队编码规范、降低入门门槛，对页面布局、请求逻辑、弹窗交互、表格渲染等底层能力做深层次封装。该方案对简单标准化CRUD页面十分友好，但适配复杂企业级业务时，弊端会逐步凸显：

前言

权限模块是企业级中后台系统的基础设施，也是前端工程化进阶必备知识点。当前市面上绝大多数权限教程普遍存在两个痛点：仅讲解表层API调用，缺少顶层架构思维；Vue、React两套实现方案割裂，无法复用。

从工程化角度来讲，权限本质与UI框架无关。无论Vue3还是React，权限的数据模型、鉴权逻辑、执行链路完全一致。

本文立足于企业级项目标准，拆解通用权限架构，同时提供Vue3 + React双框架生产级落地代码，统一路由/菜单/页面/按钮四级权限，适配前端静态、后端动态两种模式，帮助开发者搭建标准化、可复用的权限体系。

前言

在中后台Admin系统开发过程中，API层开发是所有业务功能的基石，用户列表、权限配置、字典管理、审计日志、文件上传等几乎所有后台业务，都离不开前后端接口的数据交互。

在传统的开发模式中，团队往往存在诸多痛点：接口调用方式混乱、数据缓存无统一方案、组件与非组件环境调用逻辑割裂、重复编写请求与TS类型、Vue与React技术栈开发规范不统一、新增业务模块无固定标准。不仅拉高新人上手成本，还极易产生冗余代码、隐性BUG，严重影响迭代效率。

为解决以上问题，我们基于Axios（底层请求）+ **TanStack Query（原React Query/Vue Query，异步状态管理）、TypeScript强类型约束，结合gRPC后端接口体系，设计了一套三层分层API架构**。该架构完美适配Vue、React双技术栈，统一中后台项目API开发规范，分离网络请求、缓存管理、业务逻辑、UI渲染的职责，实现类型全覆盖、调用方式标准化、业务开发轻量化，下文将完整介绍这套框架的设计理念、分层逻辑、使用方式与开发规范。

在企业中后台开发场景中，长期存在两大痛点：臃肿单体项目难以横向拓展，纯微服务架构对中小型团队过重；同时团队技术栈不统一，Vue、React 技术偏好并存，提升项目统一搭建成本。为解决以上问题，我基于 Go 语言打造双模后端基座，并配套三套差异化前端模板，封装出开箱即用的全栈脚手架 GoWind Admin（风行）。

本文从架构设计、技术选型、底层原理、工程化脚本、落地体验等维度，完整分享整套脚手架的全站开发实践。

一、整体架构设计

1.1 设计理念：一套代码，两种部署模式

后端基于 Kratos 微服务规范开发，创新性实现单体/微服务双模适配：既支持集群化微服务部署，满足大型业务拓展需求；也可直接编译为独立二进制文件，以单体模式运行。小团队可直接单体部署快速上线，后续业务增长无需重构，即可平滑拆分微服务。

很多技术团队的微服务改造都陷入两难：单体架构臃肿难维护，但全量拆微服务风险高、工期长、上线易崩。绝大多数从单体转型的开发者，都害怕“为了架构升级而重构”，导致业务停摆、Bug激增、迭代停滞。

行业内普遍存在一个误区：微服务 = 彻底拆分、全量重构、多服务乱堆砌。而 GoWind 风行 CMS 给出了一套低风险、无感演进的落地答案：不推翻单体、不一次性大重构，通过 Core 核心下沉 + 双 BFF 分层剥离，实现单体架构平滑、无感升级为企业级微服务内容中台。

本文结合 GoWind 真实架构实践，讲透单体项目如何零感知、低风险演进微服务，拆解 Core + Admin BFF + App BFF 分层架构的核心价值、底层通信原理、代码规范与落地优势，彻底解决单体转微服务的转型焦虑。

前言

在基于 Go 语言的 Kratos 微服务架构开发中，定时任务是后台数据清理、报表统计、消息推送、心跳检测、超时管控等业务场景的基础能力。

kratos-transport 生态内置了两款定位互补、风格统一的定时器中间件：

• hptimer：毫秒级高精度定时器

• cron：标准秒级周期定时器

二者均遵循 Kratos transport.Server 标准规范，无缝适配框架生命周期，同时覆盖毫秒级高频调度与秒级常规周期任务两大场景。本文完整解析设计原理、特性差异、代码实践、性能表现与业务选型。

前言

在多人在线游戏开发场景中，网络质量是决定玩家体验的核心命脉。无论是 FPS、MOBA 类帧同步重度游戏，还是棋牌、休闲对战类轻量实时游戏，都对网络通信有着低延迟、抗丢包、高实时、高可靠的严苛要求。

传统 TCP 协议基于拥塞优先的设计理念，重传机制保守、延迟累积严重，在 4G/5G 波动、Wi-Fi 干扰等弱网环境下极易出现卡顿、瞬移、技能延迟等问题；而原生 UDP 虽延迟极低，但完全不保障数据可靠性，无法承载游戏指令、帧同步数据、玩家状态等核心业务数据。

KCP 协议作为基于 UDP 实现的可靠快速传输协议，完美平衡了低延迟与数据可靠性，是目前游戏实时通信的行业最优方案之一。而 kratos-transport KCP 中间件 基于标准 KCP 协议深度封装，完整适配 Kratos 微服务生态，提供开箱即用的服务端、客户端、会话管理能力，大幅降低 Go 语言游戏服务器的网络层开发成本。

前言

在 H5 联机游戏、网页实时对战、浏览器语音开黑、在线互动课堂等实时业务场景中，传统 TCP/UDP 服务端中转架构存在天然短板：链路转发延迟高、服务器带宽压力大、弱网适应性差、规模化扩容成本高昂，难以满足低延迟、高互动的业务诉求。

WebRTC 是 W3C 与 IETF 标准化的浏览器原生实时通信方案，基于 UDP 协议构建，具备毫秒级低延迟、完整 NAT 穿透、端对端 P2P 直连能力，同时支持音视频媒体流 + 二进制数据通道双通路并行传输，是当前网页端实时交互场景的最优落地方案。

kratos-transport/webrtc 是适配 Kratos 微服务生态的生产级 WebRTC 传输中间件。它对原生 WebRTC 繁杂的信令协商、SDP 交换、ICE 穿透、会话生命周期管理、异常重连等底层逻辑做了高度工程化封装，完全契合 Kratos 标准生命周期规范，支持优雅启停、自动会话回收、事件驱动回调、媒体流传输与自定义二进制协议，大幅降低 Go 语言 WebRTC 服务的开发与落地成本。

前言：Kratos微服务开发的长期痛点

在 Go-Kratos 微服务的日常开发中，开发者始终被重复编码、多端同步困难、团队规范混乱三大核心问题困扰，极大拖累了项目迭代效率与工程质量。

传统 Kratos 开发链路十分繁琐：开发者先设计数据库表结构、编写 SQL DDL，再手动编写 ORM 模型、Data 层仓储代码、Service 层基础代码，逐一定义 Protobuf 接口契约，最后还要同步适配前端接口与类型。整条链路高度依赖人工维护，环节多、链路长、极易出错。

长期人工迭代，会衍生一系列顽固的工程化问题：

在 MySQL 数据库运维、数据恢复、迁移场景中，仅存 ibd 文件、丢失表结构 / 备份 是最棘手的问题之一。InnoDB 的独立表空间文件 .ibd 存储了表的全部数据和结构，但无法直接读取使用。

基于开源工具 ibd2sql，我们可以离线解析 ibd 文件，直接导出完整的 CREATE TABLE（DDL）和 INSERT（DML）语句。本文整合** Windows PowerShell 批量脚本** + Linux Shell 自动转换 + 导入脚本，实现一键批量处理，彻底解决 ibd 恢复难题。

在内容管理系统（CMS）向微服务、云原生升级的浪潮中，技术框架的选型直接决定架构的稳定性、扩展性与开发效率。作为基于 Go 语言打造的企业级 Headless CMS，go-wind-cms 摒弃了传统单体架构的局限，采用微服务架构设计，而其核心技术底座，选择了由 B 站开源、社区共建的 Kratos 微服务框架。

很多开发者会疑惑：Go 语言生态中不乏 Go-Zero、Go-Micro 等优秀微服务框架，go-wind-cms 为何独选 Kratos？答案并非单一维度的技术偏好，而是 Kratos 的设计理念、核心特性与 go-wind-cms 的业务场景、产品定位高度契合——从标准化治理到可观测性，从生态协同到业务适配，Kratos 为 go-wind-cms 提供了“开箱即用、可扩展、易维护”的微服务解决方案，完美解决了 CMS 微服务化过程中的核心痛点。

在数字化时代，用户行为数据早已成为企业突破增长瓶颈、优化产品体验、防范业务风险的核心资产。无论是互联网产品的迭代优化、营销活动的精准落地，还是企业内部的安全管控，都离不开对用户行为的深度洞察。然而，传统用户行为分析流程中，埋点繁琐、数据割裂、分析滞后、决策脱节等痛点，往往让企业陷入“数据多而无用”的困境——花费大量精力采集数据，最终却无法将数据转化为可落地的业务决策。

Go Wind UBA（User Behavior Analytics，用户行为分析）的出现，正是为了破解这一行业痛点。作为基于Go语言研发的一站式用户行为全链路分析工具，它以“埋点轻量化、数据一体化、分析智能化、决策场景化”为核心，打通从数据采集（埋点）、数据处理、智能分析到决策落地的全流程，让企业无需搭建复杂的技术架构，就能快速挖掘用户行为背后的价值，实现“数据驱动业务”的核心目标。

在前端技术飞速迭代的当下，用户触点早已从单一的 Web 端，延伸至小程序、APP、平板、智能设备等多元场景。传统的 “前后端一体” 架构（如 PHP/Java 渲染模板）在面对多端适配时，暴露出耦合严重、开发效率低、体验不统一等核心痛点。

而 Headless（无头）架构 作为一种以 API 为核心、内容与展示完全解耦的架构模式，正成为企业级应用、内容平台与数字化系统的主流解决方案。结合 风行 GoWind 等基于 Go 语言的 Headless CMS / 后端架构，其能实现一套 API 同时支撑 Web、小程序、APP、React/Vue、Taro 等全端开发，在效率、灵活性、扩展性上形成降维打击。

一、前言

在内容管理系统（CMS）领域，PHP（如 WordPress、织梦、帝国 CMS）与 Java（如 Jeecms、SiteServer）长期占据主流市场，前者以低成本、易上手著称，后者以企业级稳定性立足。但随着 Go 语言在高并发、云原生、微服务场景的爆发式普及，基于 Go 开发的轻量高性能 CMS 开始成为中小站点、企业官网、资讯平台、跨境独立站的新选择，其中风行 GoWind 作为国产优质 Go 原生 CMS 代表，凭借 Go 语言底层优势和轻量化设计，在性能、部署、运维、成本等维度对传统 PHP/Java CMS 形成了差异化竞争力。

Apache Superset 是一款功能强大的开源数据挖掘与可视化平台，支持多种数据源连接、自定义仪表盘和细粒度权限控制，广泛应用于数据运维与分析场景。由于 Superset 官方 Docker 镜像未默认集成 MySQL 驱动，在实际运维中，需手动安装驱动才能实现与 MySQL 数据库的正常连接。本文将详细介绍两种 Docker 部署方式（Docker run 和 Docker Compose）下，MySQL 驱动的完整安装流程，同时兼顾 Apache Doris 驱动安装（适配多数据源需求），并提供数据库配置方法和常见注意事项。

一、前置说明

可能是因为MySQL是使用的GPL协议，所以Superset官方镜像中未包含MySQL驱动，需要手动安装。

做企业官网、资讯平台、多端内容分发，你是否也被传统 CMS 的“笨重”折磨？部署时要配置一堆环境，启动慢到让人耐心耗尽，多端适配还要重复开发，稍微调整一下页面就要动后端代码，内存占用居高不下，运维起来更是费心费力。

在“轻量高效、多端融合”成为主流需求的今天，传统 CMS（如 PHP 系的 WordPress、织梦，Java 系的 Jeecms）的单体架构早已跟不上节奏。而 Headless 架构（无头架构） 的风行 GoWind，凭借 Go 语言原生优势与 Headless 核心设计，彻底打破传统 CMS 的桎梏，用“轻量不简陋、强大不复杂”的体验，成为中小企业、开发者的首选 CMS 解决方案。

前言

在量化交易场景中，实时行情接入、多维度 K 线聚合、技术指标计算、策略回测与绩效监控是核心能力诉求。Apache Doris 4.x 凭借高性能 OLAP 引擎、实时物化视图、标准 SQL 兼容、Kafka 实时接入等特性，成为量化投研与实盘交易的理想存储计算引擎。

本文基于 Doris 4.x 构建一站式量化交易数据平台，覆盖分钟级行情存储、实时聚合、技术指标、策略选股、AI 辅助决策、回测复盘全流程，可直接用于生产环境部署。

一、整体架构设计

本方案采用分层量化数仓架构，兼顾实时性、查询性能与投研易用性：

天气变化大总觉得特别容易感冒，尤其在冷冷的冬天医背将茶喝下肚全身就暖活了起来，不过并不是所有时候都可以喝姜茶，喝错时间还可能让喉咙越喝越痛。所以说到底该吃什么才能提高免疫力，减少感冒呢？

1. 维生素C

维生素C能够增强免疫系统，因为是水溶性维生素，需要不断透过饮食补充。可以吃：菠菜、芭乐、奇异果、木瓜、彩椒。

2. 姜辣素

姜中的姜辣素能够减缓发炎、促进血液循环、加速新陈代谢。不过要注意如果已经在感冒中，喉咙红肿疼痛，此时就不要再吃姜来刺激喉咙。(也就是重感冒不要喝姜茶！)

3. 花青素

花青素能够加强泌尿系统、减少发炎症状。可以吃：蓝莓、葡萄、黑梅、蔓越莓、茄子。

FastAPI 是 Python 开发人员最新、最流行的 API 框架之一。我们的工程师一次又一次需要将一个或多个第三方库与我们的 API 结合使用，以附加额外的功能和特性来丰富我们的项目。

在今天的这篇文章中，我想与您分享一些对于常规 FastAPI 从业者非常有用的资源。我已经在自己的项目中使用了其中的大部分，并且还包括我计划在不久的将来使用的一些。

那么让我们深入看看吧！

FastAPI-pagination

该库允许您从 API 路由发送简单的分页响应。这在main.py中的几行代码中使用非常方便，而不是自己编写整个分页逻辑。

迄今为止（2023年5月22日），我看过了太多的天灾人祸，太多的死亡：

• 1998年，夏季，大水灾；
• 2008年，1月10日，大雪灾；
• 2008年，5月12日，汶川大地震；
• 2014年，3月8日，马航MH370空难；
• 2014年，4月16日，韩国世越号沉默事故；
• 2015年，6月1日，东方之星号客轮翻沉实践；
• 2022年，3月21日，东方航空5735空难；
• 2022年，10月29日，韩国梨泰院踩踏事故；
• 2023年，2月11日，土耳其和叙利亚大地震；

参考资料

• 后台权限管理设计思路：三种模型分析
• 关于系统后台的用户权限设计与思考

关于这两个方法，我去网上找了一大堆资料，都没有讲清楚是怎么一回事。还是读了ASIO的源代码这才理解。

要提到这两个方法，不得不提一下Windows的两个API：SendMessage和PostMessage。

io_context::post跟PostMessage的行为差不多，投递完消息立即返回，Handler的执行跟它没有半毛钱的关系。

io_context::dispatch可以认为是SendMessage的超集，SendMessage是阻塞的，必须要在消息处理完成之后才返回，当io_context::dispatch在io_context的工作线程中被调用的时候，io_context::dispatch的行为和SendMessage是一致的，必须要在Handler调用完成之后才返回。但是，如果不是io_context的工作线程中调用，则执行了io_context::post一样的行为：将Handler投递到io_context的事件队列中去。

ASIO（Boost.Asio 或独立的 Asio）作为高性能异步 IO 库，提供了灵活且高效的定时器组件，适用于网络编程、异步任务调度、定时触发等场景。本文将系统梳理 ASIO 定时器的核心类型、底层实现、核心 API、实战示例及常见问题，帮助开发者快速掌握其使用方法。

一、ASIO 定时器核心类型解析

ASIO 提供 4 种常用定时器，均基于底层模板类实现，核心差异在于 时钟类型（决定精度、是否受系统时间影响）和 适用场景。先纠正一个常见误区：high_resolution_timer 并非 system_timer，二者是 basic_waitable_timer 的不同时钟特例化，属于并列关系。

本文将向您展示如何在 Linux 操作系统中使用 RClone 和 cron 来自动进行文件备份。

现在是星期五下午 6 点，我需要将一些工作和学校文件备份到 Google 云端硬盘。是的，我使用 git 进行编码项目，但这种工作最好保存在 Google Drive 中。所以我想知道是否有一种更快、简单、自动化的方法来备份到 Google Drive，有趣的是，我发现了 RClone。

在本文中您将了解到：

• 什么是 RClone？
• 什么是 cron？
• RClone 和 cron 的基本用法
• 如何在每周五下午 6:30 自动备份文件
• Cron日志记录
• 如何卸载 RClone

我将从本系列的第一部分开始构建一个简单的简短应用程序实现，该实现可以从 API 获取最新的技术新闻。在开始之前，我将简要介绍一些关键术语及其含义。

什么是反应式编程？

响应式编程基本上是 使用异步可观察流进行编程。在 Dart 中，流提供异步数据序列。

RxDart 是基于 Dart 的反应式编程实现。如果您来自 Android 开发领域，RxJava + RxAndroid、Coroutines 可能非常适合您。Dart 编程语言中已经实现了类似的概念。RxDart 是 Dart 语言的 ReactiveX 支持的反应式函数式编程库。Dart 已经有一个很好的用于处理 Streams 的包，但 RxDart 用新功能对其进行了扩展。

Make

• 官方网站：https://www.gnu.org/software/make/
• 开源代码库：https://github.com/gitGNU/gnu_make
• 开发语言：C

Cache Aside Pattern

Cache Aside Pattern是最经典的缓存 + 数据库读写的模式。

1. 读的时候，先读缓存，缓存没有的话，那么就读数据库，然后取出数据后放入缓存，同时返回响应
2. 更新的时候，先更新缓存，然后再更新数据库（缓存和数据库双写）

最大的缺点就是需要应用程序侧来编排读写流程。

读取的步骤

1. 先从缓存中读取数据；
2. 如果缓存数据不存在，那么从数据库中读取数据；
3. 写入缓存。

两轮驱动（Two-Wheel Drive，2WD）

两轮驱动，即是由发动机通过变速箱等直接驱动前轮或者后轮，使汽车前进。

• 前轮驱动（Front-Wheel Drive） - 发动机驱动前面一对车轮
• 后轮驱动（Rear-Wheel Drive） - 发动机驱动后面一对车轮

四轮驱动（4-Wheel Drive，4WD）

四轮驱动，是指汽车前后轮都有动力，可按行驶路面状态不同而将发动机输出扭矩按不同比例分布在前后所有的轮子上，以提高汽车的行驶能力。一般用4X4或4WD来表示。

Change Data Capture介绍

变更数据捕获 (CDC) 是一种用于跟踪对数据库中的数据所做的更改的技术，使您能够跟踪数据的演变。在 PostgreSQL 中，CDC 是使用逻辑复制（Logical Replication）功能实现的，它可以选择性地复制对特定表或列所做的更改。

Golang 是一种编程语言，近年来因其速度和简单性而受到欢迎。它也非常适合处理数据库，因为它内置了对 SQL 数据库的支持以及许多用于处理这些数据库的强大库。

在 PostgreSQL 中使用 Golang 和 CDC 是一个强大的组合，因为它允许您轻松地实时捕获和处理对数据库所做的更改。以下是开始在 PostgreSQL 中使用 Golang 和 CDC 需要遵循的基本步骤：

通过命令df -h查看磁盘空间占用，发现Docker的overlay对磁盘的占用极高。

通过docker system prune -a命令清除掉Docker的无用镜像、缓存、挂载数据，也并没有太多的改善。

通过du -h --max-depth=1或者du -sh *命令查看大文件的占用情况。

参考资料

• Docker容器占用磁盘内存过大的问题排查
• Docker 容器磁盘占用100%(/var/lib/docker/overlay2空间占用很大)

该快捷方式在键盘图中称为“相关符号”。

MAC

Ctrl + Cmd + Up

Windows、Linux

Ctrl + Alt + Home

• Waydroid只能单开一个Android实例，所以要批量部署，可能需要部署多个宿主Ubuntu；
• Redroid基于Docker部署，一个宿主可以部署多个。

虚拟手机开源方案

• ReDroid (Remote anDroid) Docker + AnBox
• Waydroid LXC + AnBox
• Android-x86
• BlissOS

安装依赖

sudo apt-get install libgtest-dev

渲染方式

• Rectangle/Orthogonal：正交，正常矩形瓦片
• Isometric：等距瓦片，45度
• Hexagon：六边形

参考资料

• Cocos2D-X Tile Map Tutorial: Part 1
• Cocos2D-X Tile Map Tutorial: Part 2
• Introduction to Tiled Map Editor: A Platform-Agnostic Tool for Level Maps
• 笔记：TileMap坐标转换
• 韩版《传奇2》源码分析与 Unity 重制（四）服务端地图对象管理

小程序真机无法显示ttf字体

根据论坛里面说的是，主要的原因是因为字体的font-family名字里面带有空格。

需要使用字体修改工具High-Logic FontCreator来修改font-family名，修改之后，确实生效了。

1. 打开FontCreator，将ttf文件拖到FontCreator打开。
2. 菜单项选择：Font -> Properties，打开Font Properties弹窗。
3. 在弹窗里面看到有几个子标签页，其中Identification标签页里面的 Font Family即为字体的英文名，自行修改成自己需要的值。
4. 在Custom标签页里面，可以看到列表里面的第一列是语言ID，第二列是Name ID，简体中文系统上，找到行 Chinese-People's Republic of China Font Family，
5. 繁体中文或者其他语言的系统下，应该是修改对应的行，没有的也可以Add添加新的行，这个我没有测试，猜测是这样。
6. 修改完毕后点击OK保存。
7. 菜单项选择：File -> Export Font As... -> Export as Desktop Font(ttf/otf)，弹出Export as Desktop Font(ttf/otf)窗口。
8. 在弹出窗口中将Outline Format项，通过下拉选择TrueType，不建议选CFF（测试时这个选项可能Identification标签页里面字体名不生效）。
9. 底部三个按钮点击Export即可。最终保存文件窗口自己选择文件格式。

一、完整注释表格

Python

使用tronpy软件包

from tronpy.keys import PrivateKey

# 指定私钥（请替换为你实际的私钥）
private_key_hex = "your_private_key_hex_string"

# 将十六进制私钥转换为PrivateKey对象
private_key = PrivateKey(bytes.fromhex(private_key_hex))

# 从私钥派生公钥
public_key = private_key.public_key

# 从公钥生成TRC地址
address = public_key.to_base58check_address()

print("私钥 (十六进制):", private_key_hex)
print("公钥 (十六进制):", public_key.hex())
print("TRC地址:", address)
print('\n')

首先，我的应用场景是这样的，我是一个C++为宿主的程序，内嵌了Python，我C++里边有引用C++版的protobuf动态链接库。Python里边也有用到Python版的Protobuf。两者都用了同一版本的protobuf: 3.13.0。

因为我是插件式的系统，我单独测试Python脚本系统插件的时候，一切都是完美的。然后，我将插件集成到主程序里边去，就完犊子了。只要我在Python中import到protobuf的协议，主程序就会以SIGSEGV信号崩掉。

最终堆栈挂在了_message.cpython-35m-x86_64-linux-gnu.so的google::protobuf::DescriptorPool::FindFileByName()这里：

C++ 创建于 1985 年，是一种流行的编程语言，已经使用了 30 多年。这种面向对象的编程语言设计有多种功能设施，包括编译功能。它最初是为系统编程而构建的，但如今它已成为软件开发行业许多项目的绝佳选择。它可用于创建高性能应用程序，例如桌面应用程序、游戏和服务器。

C++ 作为 C 语言的扩展而构建，采用类进行设计，使其代码可重用。C++ 编程语言支持多种操作系统和集成开发环境 (IDE)。作为想要构建令人印象深刻的软件应用程序的初学者，您可能正在寻找 C++ 的最佳 IDE 来轻松构建和启动您的产品。使用本指南为初学者找到最好的 C++ IDE。

什么是 IDE？

在 C++ 编程中，类型转换是连接不同数据类型的重要手段。C++ 同时支持兼容 C 语言的旧风格强制转型，以及针对特定场景设计的四种新风格强制转型，后者在可读性、安全性和规范性上更具优势。本文将详细解析各类转换的语法、用途及核心差异。

一、旧风格（C-style）强制转型

C 风格强制转型包含两种语法形式，本质功能完全一致，仅括号位置不同：

• 格式 1：(T) expression（将表达式转换为 T 类型）
• 格式 2：T(expression)（函数式语法，效果同上）

CQRS 代表：命令查询职责分离(Command Query Responsibility Segregation)。它提倡分离“命令(Command)”和“查询(Query)”的“职责(Responsibility)”。在本文中，我将尝试回答以下问题：

• 什么是 CQRS？
• 为什么 Kafka Streams 是实现 CQRS 很自然的选择？
• 如何使用 Kafka Streams 实现 CQRS 模式？

案例研究：在线订购系统

让我们从一个经典示例开始：零售在线订购系统。它有两个主要用例：

如果你知道Bazel，你就会知道它有多棒：它快速可靠。当您在使用多种服务的项目中工作时，甚至可能使用不同的语言，拥有一个快速可靠的构建系统，更重要的是，生成确定性构建是关键。

但是，您可能不知道使用它bazel来构建容器镜像是多么容易。您将从使用bazel应用到您的镜像构建过程中获得所有好处。另外，您不必处理丑陋的Dockerfiles。

什么是cron表达式？

cron表达式是一个具有时间含义的字符串，一般用于定义定时任务的执行时间。

cron表达式的格式

cron使用6-7位制的格式：

{秒数} {分钟} {小时} {日期} {月份} {星期} {年份（可为空）}

参考资料

• 甚麼是客戶保留率？ 如何計算客戶保留率？
• APP用户留存率计算公式和预估方法
• 用户留存|教你统计日留存、周留存、月留存率更准确的方法
• 出色的应用留存率是如何炼成的？
• 关于游戏的留存
• 小游戏玩家留存策略
• 6 个重要的移动游戏留存指标及计算方法
• App的留存率多少才合格？行业App留存参考
• 微信小游戏大盘留存数据：益智、模拟品类次留高于40%
• 留存：4 大策略提升 2 类留存官方
• 如何提升网赚游戏的用户留存率，我们总结出了可复用的分析方法

• ElasticSearch
• Fluentd
• Kibana

Docker Run

docker network create app-tier --driver bridge

两个可执行程序：

• hbbs - RustDesk ID注册服务器，是管各个客户端 ID 的，每个客户端都有一个唯一的 ID 。
• hbbr - RustDesk中继服务器，是负责检测、中转各个客户端连接和数据传输。

端口占用情况：

• TCP(21115, 21116, 21117, 21118, 21119)
• UDP(21116)

进程占用端口情况：

• hbbs - 21115(tcp), 21116(tcp/udp), 21118(tcp)
• hbbr - 21117(tcp), 21119(tcp)

• Bash的换行符为 \

• CMD的换行符为 ^

• Powershell的换行符为 `

参数简析：

• -p 宿主机端口:容器端口

需要设置Host：

# Added by Docker Desktop
192.168.1.6 host.docker.internal
192.168.1.6 gateway.docker.internal
# To allow the same kube context to work on the host and the container:
192.168.1.6 kubernetes.docker.internal
# End of section

Jitsi项目组成

• Jitsi Meet，与WebRTC兼容的JavaScript应用程序，使用Jitsi Videobridge提供高质量、可扩展的视频会议。基于React和React Native构建
• Jitsi Videobridge（JVB） - 与WebRTC兼容的服务器，用于在会议参与者之间路由视频流。
• Jitsi Conference Focus (jicofo) - 用于Jitsi会议的服务器端焦点组件，用于管理媒体会话，并充当每个参与者和视频桥之间的负载平衡器。
• Jitsi Gateway to SIP (jigasi) - 允许常规SIP客户端加入Jitsi会议的服务器端应用程序
• Jitsi Broadcasting Infrastructure (jibri) - 用于录制和/或流式传输Jitsi会议的一组工具，通过启动虚拟帧缓冲区中呈现的Chrome实例，并使用ffmpeg捕获和编码输出来工作

什么是Traefik?

Traefik 是一款开源的反向代理与负载均衡工具，它监听后端的变化并自动更新服务配置。Traefik 最大的优点是能够与常见的微服务系统直接整合，可以实现自动化动态配置。目前支持 Docker、Swarm,Marathon、Mesos、Kubernetes、Consul、Etcd、Zookeeper、BoltDB 和 Rest API 等后端模型。

什么是微服务网关?

微服务网关是整个微服务API请求的入口，可以实现过滤Api接口。并且可以实现用户的验证登录、解决跨域、日志拦截、权限控制、限流、熔断、负载均衡、黑名单与白名单机制等。

概要

我将介绍如何构建运行在 Docker 上的 Swagger 环境。

成果

Swagger Editor

网页的左侧是编辑器，右侧是Swagger UI，可以实时查看notation和查看定义文档。 如果将稍后描述的示例复制并粘贴到左侧，结果将显示在右侧，所以请尝试一下。

Swagger UI

Docker的容器当中一般是没有安装任何编辑器的,vi和vim神马的都没有.如果想要在容器中使用编辑器,需要自己去安装.
但是,在 Docker 中执行：apt-get update报错:

E: List directory /var/lib/apt/lists/partial is missing. - Acquire (13: Permission denied)

Docker的国内代理都失效了，不抱怨，只讲如何解决问题。

简单来说，就是把本地的镜像导出来，然后打成压缩包，再拷贝到服务器上去，然后再导入。

导出镜像

docker save bitnami/minio:latest -o minio.tar

今天Windows11升级重启了,我启动RabbitMQ,然后提示端口被占用,而无法启动Docker. 提示信息如下:

listen tcp 0.0.0.0:1883: bind: An attempt was made to access a socket in a way forbidden by its access permissions.

准备

查看PostgreSQL的版本号（有些插件带大版本号）：

SELECT version();

Docker 采用保守的方法来清理未使用的对象，例如镜像(Image)、容器(Container)、数据卷(volume)和网络(Network)。也就是说，除非您明确告诉 Docker 这样做，否则每个对象都永远不会被删除。结果导致了 Docker 最终使用了大量的磁盘空间。对于每种类型的对象，Docker 都提供了一个 prune（删除）命令。此外，您可以一次清理多个对象类型。本主题介绍如何使用每个命令。

镜像(Image)修剪

docker image prune该命令可以清理未使用的镜像。默认情况下，该命令仅删除挂起的镜像。挂起的镜像是没有标签且不被其他容器引用的镜像。要删除挂起的镜像，只需要键入：docker image prune

创建Dockerfile

注册Docker Hub账号

在日常运维当中，Docker会产生一些运行时的临时文件，我们需要定时的清理掉他们，不然将会对磁盘造成极大的压力。

探查命令

查看整个Docker系统的磁盘占用情况：

docker system df

所谓的汉字注音，就是给汉字上方加注拼音。

在Office里面，这个功能叫做 “拼音指南”（Phonetic Guide）。

拼音指南一次只能够处理最多30个字，一篇文章不可能只有30个字，上百个字是很正常的，人工处理就会很累。所以，需要做到自动化，做到自动化有两种方式可以做到：

Flutter 的 widget系统 允许 父widget 和 子widget 之间无缝通信。了解如何双向调用方法可以显著增强应用的架构和性能。在本文中，我们将探讨如何从 父widget 调用 子widget 的方法，反之亦然。

从父部件调用子部件的方法

在 Flutter 中，可以使用属于子State类型的全局键GlobalKey来从父级调用子Widget中定义的方法。

例如：假设我们有一个名为ChildWidget的子窗口小部件

class ChildWidget extends StatefulWidget {
  const ChildWidget({super.key});

  @override
  State<ChildWidget> createState() => ChildWidgetState();
}

class ChildWidgetState extends State<ChildWidget> {
  int value = 0;

  @override
  Widget build(BuildContext context) {
    return Card(
      elevation: 10,
      child: Container(
        height: 200,
        decoration: BoxDecoration(
          borderRadius: BorderRadius.circular(10),
          color: Colors.green,
        ),
        child: Column(
          children: [
            const Text(
              "Child Widget",
              style: DemoTextStyle.headline1,
            ),
            ElevatedButton(onPressed: () {}, child: const Text("Call Parent")),
            Center(
              child: Text(
                'Child value:  $value',
                style: DemoTextStyle.copyWith(
                    fontSize: 18, fontWeight: FontWeight.normal),
              ),
            ),
          ],
        ),
      ),
    );
  }

  void changeValue() {
    setState(() {
      value++;
    });
  }

  void changeValueDynamic(int val) {
    setState(() {
      value = val;
    });
  }
}

Ent是Facebook开源的一个GO语言的ORM框架。它提供了一系列的工具，可以做到：

1. SQL生成schema；
2. schema生成protobuf的message；
3. schema生成gPRC的service。

创建go项目

go mod init entimport-example

我们在开发程序的过程中，会遇到一个常见的需求——删除表中的数据。

但是有时候，业务需求要求不能永久删除数据库中的数据。比如一些敏感信息，我们需要留着以方便做历史追踪。 这个时候，我们便会用到软删除。

Entgo本身是不直接支持的，但是，要实现也并不是很难的事情。

什么是软删除？

软删除（Soft Delete） 是相对于 硬删除（Hard Delete） 来说的，它又可以叫做 逻辑删除 或者 标记删除。

TypeScript版

// 列数 -> 列字母
function ColumnNumberToName(num: number): string {
  if (num < 1 || num > 16384) {
    return ''
  }

  if (num > 26) {
    const digit1 = String.fromCharCode((num - 1) / 26 + 64)
    const digit2 = String.fromCharCode(((num - 1) % 26) + 65)
    return digit1 + digit2
  } else {
    return String.fromCharCode(num + 64)
  }
}

// 列字母 -> 列数
function ColumnNameToNumber(name: string): number {
  let num = 0
  if (name.length == 1) {
    num = Number(name[0].charCodeAt(0)) - 64
  } else if (name.length == 2) {
    num = (Number(name[0].charCodeAt(0)) - 64) * 26 + Number(name[1].charCodeAt(0)) - 64
  }
  return num
}

console.log(ColumnNumberToName(1))
console.log(ColumnNumberToName(26))
console.log(ColumnNumberToName(27))


console.log(ColumnNameToNumber('A'))
console.log(ColumnNameToNumber('Z'))
console.log(ColumnNameToNumber('AA'))

Dart 3 在 Flutter 中引入了 密封类(Sealed Class)。如果您来自于类似 Kotlin 这样的现代编程语言，您可能已经知道它们有多么强大。如果没有，在本文结束时您将了解到关于密封类的全部内容。

密封类(Sealed Class)是一项强大的功能，使开发人员能够创建受限制的类层次结构。与常规类不同，密封类只能在同一文件中扩展，这使得它们成为表示有限相关类集的绝佳选择。

了解密封类

之前，都是找的Andriod的文件，但是，这很麻烦，因为需要Root，不然无法访问。找到文件，拷贝也是一件很麻烦的事情。

现在，电脑版的微信也是可以使用小程序的，所以，从电脑上去寻找小程序的资源就变得切实可行。

小程序所在的位置

首先，它有两个路径：

C:\Users\{Windows用户名}\Documents\WeChat Files\Applet\{小程序ID}

人脸识别十大关键技术

1. 人脸检测(Face Detection)

“人脸检测”的作用就是要检测出图像中人脸所在位置。人脸检测算法的原理简单来说是一个“扫描”加“判定”的过程。即首先在整个图像范围内扫描，再逐个判定候选区域是否是人脸的过程。因此人脸检测算法的计算速度会跟图像尺寸大小以及图像内容相关。在实际算法时，我们可以通过设置“输入图像尺寸”、或“最小脸尺寸限制”、“人脸数量上限”的方式来加速算法。

2. 人脸配准(Face Alignment)

“人脸配准”所实现的目的是定位出人脸上五官关键点坐标。当前效果的较好的一些人脸配准技术基本通过深度学习框架实现。这些方法都是基于人脸检测的坐标框，按某种事先设定规则将人脸区域抠取出来，缩放到固定尺寸，然后进行关键点位置的计算。另外，相对于人脸检测，或者是后面将提到的人脸特征提取的过程，人脸配准算法的计算耗时都要少很多。

默认安装的是Android系统，我们不需要，我们需要一个Ubuntu Desktop。

安装工具

• 安装RK USB驱动 DriverAssistant
• 安装运行 RKDevTool
• 下载固件：Ubuntu、Debian、Buildroot……

开发板进入到Loader模式

1. 先断开电源；
2. USB线一端插入到OTG口，另外一端插入到电脑；
3. 按住RECOVERY 键（需要注意，为了防止误触，它的按钮被隐藏在侧面，手指头探下，将黑色的按钮往白色的按钮基座抠）；
4. 接通电源；
5. RECOVERY 键持续摁住大约2秒。

升级到Android Studio Ladybug | 2024.2.1后，我在 Flutter 项目中遇到了一些问题。幸运的是，我通过修改一些配置文件找到了一个简单的解决方案。如果您面临类似的挑战，请按照以下步骤让您的项目重回正轨。

修改settings.gradle：

id "com.android.application" version "8.3.2" apply false

Сocoapods trunk URL couldn’t be downloaded

逐行运行此命令

gem uninstall cocoapods 
arch -x86_64 brew install cocoapods 
arch -x86_64 brew reinstall cocoapods 
cd ios 
pod cache clean --all 
pod install （如果m1 macOS 运行这个“arch -x86_64 pod install”）
pod update

是否使用 GetX？

看到有许多人在讨论 GetX 如何如何，通常很多人是刚进入 Flutter 的初学者，一眼望去，有许多状态管理可以选择，感觉无从下手，所以提出自己的询问，我觉得这些人做得很好，他们在决定投入之前，会先尝试一下询问社群。

在这里，我先给出个我的意见：

不建议你使用，尤其在专业以及大型的产品上更不应该使用，而且它也无法帮助你的职业发展。

数字格式化

可以使用intl实现该功能。

首先安装库：

flutter pub add intl

安装鸿蒙开发环境

首先，需要下载安装两个东西：DevEco Studio和command-line-tools，在这个网址去下载。

DevEco Studio是Jetbrains定制的IDE，使用起来和Android Studio也差不太多。

安装好之后，然后通过内置的SDK管理器去下载SDK，进入SDK管理器的路径是：File -> Settings -> OpenHarony SDK。找一个合适的版本下载。默认本地安装路径：C:\Users\{用户名}\AppData\Local\OpenHarmony\Sdk。

国内镜像列表

记得之前在写Kotlin的时候，对于Kotlin所提供的Sealed Class的功能感到惊喜，我还给Sealed Class封上了enum 2.0的称号，它拥有Class的特性，可以将状态封装起来，使用when语法的时候，还可以详尽列出所有的子项，而在Flutter当中，其实也有sealed class可以用，在Dart 3.0中，也已经将sealed class加入到了Dart的武器库。

enum

假如，我们现在要实现一个 收音机 功能，我们可以使用enum声明其状态，代码如下：

位图字体(Bitmap Font)

最简单的文本渲染方式是：点阵字体 (Dot-matrix-fonts) 也叫位图字体 (Bitmap-fonts)。

位图字体通过将所需的独特字形光栅化为单个纹理（称为 纹理图集(Texture atlas)），使用的时候再找到对应的字符的 UV，再绘制文本。

期货合约（Futures Contract）

期货合约（英语：futures contract），简称期货（英语：futures），是一种跨越时间的交易方式，金融衍生工具的一种。买卖双方透过签订合约，同意按指定的时间、价格与其他交易条件，交收指定数量的现货。通常期货集中在期货交易所，以标准化合约进行买卖，但亦有部分期货合约可透过柜台交易进行买卖，称为场外交易合约。交易的资产通常是商品或金融工具。双方同意购买和出售资产的预定价格被称为远期价格。未来的指定时间 - 即交付和付款发生时 - 称为交货日期。因为它是标的资产的函数，期货合约是衍生工具。

期货的基本制度

什么是地理围栏(Geo-fencing)?

地理围栏（Geo-fencing）是LBS的一种新应用，就是用一个虚拟的栅栏围出一个虚拟地理边界。当手机进入、离开某个特定地理区域，或在该区域内活动时，手机可以接收自动通知和警告。有了地理围栏技术，位置社交网站就可以帮助用户在进入某一地区时自动登记。

地理坐标系

我们通常用经纬度来表示一个地理位置，但是由于一些原因，我们从不同渠道得到的经纬度信息可能并不是在同一个坐标系下。

• 高德地图、腾讯地图以及谷歌中国区地图使用的是GCJ-02坐标系
• 百度地图使用的是BD-09坐标系
• 底层接口(HTML5 Geolocation或ios、安卓API)通过GPS设备获取的坐标使用的是WGS-84坐标系

Redis

Redis 3.2.0版本开始，提供了GEO系列命令，可以用搜索、索引地理位置信息。

索引地理位置信息

GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"

设置HTTP代理

git config --global http.proxy http://127.0.0.1:1080

添加子模块

git submodule add <url> <path>

算法列表

• [X] 顺序查找（Sequential Search）
• [X] 二叉树查找（Binary Search）
• [X] 三叉树查找（Ternary Search）
• [X] 插值查找（Interpolation Search）
• [X] 斐波那契查找（Fibonacci Search）
• [X] 指数查找（Exponential Search）
• [X] 树表查找（Tree table lookup）
• [X] 分块查找（Blocking Search）
• [ ] 哈希查找（Hash Search）

算法列表

• [X] 冒泡排序（Bubble Sort）
• [X] 鸡尾酒排序（Cocktail Sort）
• [X] 选择排序（Selection Sort）
• [X] 插入排序（Insertion Sort）
• [X] 归并排序（Merge Sort）
• [X] 原地归并排序（In-place Merge Sort）
• [X] 堆排序（Heap Sort）
• [X] 快速排序（Quick Sort）
• [X] 希尔排序（Shell Sort）
• [X] 计数排序（Counting Sort）
• [X] 基数排序（Radix Sort）
• [X] 桶排序（Bucket Sort）
• [X] 二叉排序树排序（Binary Tree Sort）
• [X] 鸽巢排序（Pigeonhole Sort）
• [X] 侏儒排序（Gnome Sort）
• [ ] 块排序（Block Sort）

在游戏后端架构设计中，单协程（单线程）事件调度器（Event Loop） 是实现 “绝对消息顺序” 与 “无锁状态管理” 的核心方案。

相较于多线程模型所面临的锁竞争、竞态条件、数据一致性等复杂问题，单协程调度器通过 完全串行化执行 所有核心逻辑，从根本上规避了并发安全风险——这一特性对于对状态准确性要求极高的游戏场景（如玩家血量、金币、技能释放结果、战斗胜负判定）具有决定性意义。

然而，串行执行也带来了严苛的约束：任何一个事件的处理延迟，都会直接放大为全服玩家的体验损耗。因此，单协程调度器的核心设计目标，是在保证逻辑有序性的前提下，极致控制响应时间，守住系统稳定性红线。

一、前言

Go 是 Google 设计的类 C 静态类型语言，兼顾底层性能与开发效率。它并非传统意义上的面向对象（OOP）语言 —— 没有 class 关键字，也不支持传统的 “继承” 语法，但通过 接口的隐式实现 和 结构体组合（嵌入），Go 能灵活实现 OOP 的核心特性（多态、代码复用），且设计更简洁、无继承带来的耦合问题。 与 C++ 相比，Go 的设计哲学是 “组合优于继承”：用接口实现多态，用结构体嵌入实现代码复用，既避免了继承的复杂语法，又解决了多重继承的歧义问题。本文将通过类比 C++ 的接口 / 继承逻辑，详解 Go 如何实现类似效果。

对于刚接触 Go 微服务开发的初学者来说，直接上手 “框架 + ORM” 的组合常显复杂。而 kratos-ent-example 项目已为我们搭建好了 Go-Kratos 与 Ent 的基础集成框架，本文将基于该项目，聚焦如何快速接入 go-curd 工具简化 CRUD（增删改查）操作，全程以 step-by-step 的方式讲解，新手也能轻松跟随实操。

先明确核心工具关系：kratos-ent-example是 “基础骨架”（已整合 Kratos 与 Ent），go-curd是 “效率工具”（封装重复 CRUD 逻辑），我们的核心目标是 “在现有骨架上装工具，让数据操作更简单”。

对于刚接触Go微服务开发的初学者来说，直接上手“框架+ORM”的组合常显复杂。而kratos-gorm-example项目已为我们搭建好了Go-Kratos与GORM的基础集成框架，本文将基于该项目，聚焦如何快速接入go-curd工具简化CRUD（增删改查）操作，全程以step-by-step的方式讲解，新手也能轻松跟随实操。

先明确核心工具关系：kratos-gorm-example是“基础骨架”（已整合Kratos与GORM），go-curd是“效率工具”（封装重复CRUD逻辑），我们的核心目标是“在现有骨架上装工具，让数据操作更简单”。

打开模块支持

go env -w GO111MODULE=on

参考资料

• Golang WebRTC. How to use Pion 🌐Remote Controller
• Getting Web Development Right: WebRTC Tutorial — Golang and React.
• From zero to fully functional video conference app using Go and webRTC

开门见山，Kratos内置的RPC是gRPC，而gRPC是基于Protobuf作为 接口规范的描述语言（IDL，Interface Description Language）。

后端的权限控制主要分为两种：

• API权限控制；
• 数据权限控制。

在本文，我们不讨论数据权限的控制，主要讲API的权限控制。

在GO的世界里面，我们能够使用到的解决方案有：

• Casbin
• Open Policy Agent(OPA)
• Zanzibar

kratos-bootstrap 是 GoWind Admin 底层核心的应用引导框架，承担着类似 Java 生态中 Spring Boot 的角色 —— 通过标准化初始化流程、统一配置管理、简化组件集成，为开发者屏蔽基础设施搭建的复杂性。借助它，开发者无需重复编写微服务启动、配置加载、中间件注册等样板代码，可直接聚焦业务逻辑开发。本文将详细讲解如何在 GoWind Admin 中通过 kratos-bootstrap 完成应用初始化、配置管理、组件集成等关键操作，并对比 Spring 等主流框架的设计理念，帮助开发者快速上手。

一、kratos-bootstrap 在 GoWind Admin 中的角色：类比 Spring Boot 的「基础设施引擎」

GoWind Admin（风行）作为开箱即用的企业级前后端一体中后台框架，致力于解决中后台系统开发中的通用问题，而权限管理作为中后台系统的核心安全能力，是框架设计的重中之重。Casbin 作为一款功能强大、灵活易用的开源访问控制框架，能够完美适配 GoWind Admin 的权限管理需求。本文将详细讲解 Casbin 的核心原理、配置规则，并完整呈现其在 GoWind Admin 中的集成流程与最佳实践。

一、Casbin 简介：企业级权限管理的优选方案

Casbin（https://github.com/casbin/casbin）是一款专注于访问控制的开源库，核心目标是帮助复杂系统解决权限管理的灵活性与安全性难题，也是国内开源项目中的优秀代表。其最大优势在于采用元模型设计思想，不局限于固定的权限模型，而是支持 ACL（访问控制列表）、RBAC（基于角色访问控制）、ABAC（基于属性访问控制）、RESTful 等多种经典访问控制模型，同时允许开发者根据业务需求自定义权限规则，具备极强的扩展性。 凭借卓越的设计与稳定性，Casbin 已获得全球众多企业的认可：Intel、IBM、腾讯云、VMware、RedHat、T-Mobile 等企业将其用于开源项目，Cisco、Verizon 等企业在闭源系统中采用。项目由北京大学罗杨博士于 2017 年 4 月发起，罗杨博士长期深耕云计算访问控制领域，发表数十篇相关学术论文，并在 ICWS、IEEE CLOUD、ICICS 等顶级学术会议宣讲研究成果，Casbin 正是其学术研究与工程实践结合的核心产物。

ClickHouse 是一款由俄罗斯搜索引擎公司 Yandex 开发的开源列式存储数据库，专为海量数据实时分析设计。它以极致的查询性能和高吞吐写入能力著称，尤其擅长处理PB 级别的结构化数据，并能在毫秒到秒级内完成复杂的聚合分析（如多维度统计、漏斗计算、用户行为分析等），是大数据分析、数据仓库、实时报表等场景的核心工具。

ClickHouse 的核心概念

我们为go-wind-admin这个项目打造了一个代码生成工具集。

• cfgexp 用于将服务本地配置导入到远程配置系统，支持：Etd、Consul、Nacos……
• sql2orm 用于把数据库的表结构导入，并且生成为ORM代码，支持：ENT、GORM……
• sql2proto 用于把数据的表结构导入，并且生成gRPC、REST的Protobuf代码。
• sql2kratos 用于把数据的表结构导入，并且生成一整套的Kratos服务代码。

Docker 部署具备环境一致性、可移植性强、部署高效等优势，是企业级应用落地的优选方案。风行·GoWind Admin 后端已将所有Docker部署相关操作封装至 Makefile 中，实现极简部署体验。本文将详细介绍两种核心部署方式、服务增减时的配置调整方法，助力开发者快速完成后端服务的容器化部署。

一、部署前提

• 本地环境已安装 Docker（建议版本 20.10+）及 Docker Compose（建议版本 2.10+），可通过 docker -v``、docker compose version 命令验证安装。
• 已获取 GoWind Admin 项目源码，进入后端项目根目录（即 backend 目录），所有部署命令均在此目录执行（特殊说明除外）。
• 确保部署环境网络通畅，可正常拉取 Docker Hub 公共镜像（如 postgres、redis 等依赖组件）。

开发环境的稳定与规范是高效开发的基础。风行·GoWind Admin 作为前后端一体的企业级中后台框架，需搭建适配的前端、后端开发环境以保障开发流程顺畅。本文将详细拆解前端、后端开发环境的搭建步骤，涵盖工具安装、插件配置、网络代理设置等核心内容，适配 Windows/macOS 主流系统，助力开发者快速完成环境初始化。

一、前端开发环境搭建

前端基于 Vue + TypeScript 技术栈，需安装代码管理、开发IDE、运行环境及依赖管理工具，同时配置 Protobuf 相关插件以支持接口定义解析。

1. 必备开发工具清单

以下工具为前端开发核心依赖，确保代码拉取、项目编译、依赖管理等流程正常运行：

ElasticSearch（简称 ES）是 Elastic 技术栈的核心组件，一款开源分布式全文搜索引擎，基于 Lucene 引擎构建，兼具实时数据存储、检索与分析能力。其分布式架构天然支持水平扩展，能轻松应对海量数据场景，凭借高吞吐、低延迟、高可用的特性，广泛应用于中后台系统的日志分析、全文检索、业务监控、数据可视化等核心模块。

GoWind Admin（风行）作为企业级前后端一体中后台框架，已对 ElasticSearch SDK 进行封装，提供标准化配置、依赖注入、通用 CRUD 封装等能力，开发者可快速集成 ES 实现数据检索与分析需求。本指南将从核心概念、环境部署、框架集成、实战示例四个维度，完整讲解 ES 与 GoWind Admin 的集成过程。

在企业级中后台系统中，前端权限控制是保障数据安全、规范用户操作边界的核心能力。风行·GoWind Admin 前端权限控制核心聚焦于功能权限管控，根据控制粒度的不同，分为「页面级权限」和「按钮级权限」两大模块，覆盖从“页面访问”到“操作执行”的全链路权限管控需求。本文将详细拆解两种权限的实现原理、启用方式、核心代码及最佳实践，助力开发者快速落地权限管控方案。

一、页面级权限：管控页面访问边界

页面级权限的核心目标是控制用户能否访问特定页面，主要通过「菜单隐藏」和「路由拦截」两种手段实现——未授权用户既无法在侧边栏看到目标菜单，也无法通过直接输入URL跳过菜单访问页面，进而实现对用户访问“财务报表”“人事管理”等核心页面的精准管控。

在企业级中后台系统开发中，开发者常常面临两大痛点：一是微服务架构搭建繁琐，从项目初始化到多服务协同需要大量手动配置；二是前后端协同成本高，接口定义、数据模型同步往往耗时费力。而 GoWind Admin（简称「风行」）的出现，正是为了解决这些问题 —— 它基于 gow CLI 工具，提供了一套开箱即用的企业级前后端一体中后台框架，让开发者能以极低成本快速搭建微服务体系。

什么是 GoWind Admin？

GoWind Admin 是一套聚焦企业级中后台场景的微服务开发框架，基于 Go 语言生态（依托 go-kratos 微服务框架）打造，整合了前后端开发所需的核心工具链。其核心优势在于「一键生成」与「高度可配置」：通过 gow 命令行工具，开发者可以快速初始化项目、创建微服务、生成接口与数据层代码，无需从零搭建架构，极大缩短开发周期。

本文将指导开发者在 GoWind Admin 企业级前后端一体中后台框架中，从零开始构建一个完整的 gRPC 服务。我们所指的 “服务” 即 gRPC 中的 service，通常包含特定数据集的 CRUD（增删改查）操作，遵循框架规范实现高可维护性与可扩展性。

前置准备

在开始前，请确保已完成以下环境准备：

开发环境

• Go 1.19+（推荐 1.21+，支持最新语言特性）
• Git（版本控制）
• Protobuf 编译器（protoc，用于编译 proto 文件）

本文将指导开发者在 GoWind Admin 企业级前后端一体中后台框架中，从零开始构建一个完整的 gRPC 服务。我们所指的 “服务” 即 gRPC 中的 service，通常包含特定数据集的 CRUD（增删改查）操作，遵循框架规范实现高可维护性与可扩展性。

前置准备

在开始前，请确保已完成以下环境准备：

开发环境

• Go 1.19+（推荐 1.21+，支持最新语言特性）
• Git（版本控制）
• Protobuf 编译器（protoc，用于编译 proto 文件）

企业级 Admin 系统的技术选型，既要兼顾高性能与稳定性，也要平衡开发效率与可扩展性。go-wind-admin 作为开箱即用的全栈 Admin 解决方案，最终选定 Golang 生态（后端） + Vue3 生态（前端） 的技术组合，并非偶然 —— 而是精准匹配企业级管理系统核心需求的必然选择。本文将深度拆解这套技术栈的选型逻辑，以及它如何为项目赋能。

一、后端技术栈：Golang 生态的 “精准狙击”

InfluxDB 是一款采用 Go 语言开发的开源分布式时序数据库，专为时间序列数据的高效存储、查询与分析设计，由 InfluxData 公司主导开发。其核心优势在于高频写入性能、时序数据索引优化及原生聚合分析能力，广泛应用于 IoT 设备监控、系统性能指标采集、日志时序分析、金融行情跟踪等场景。在企业级中后台系统中，InfluxDB 可快速对接 GoWind Admin 框架，为实时监控面板、历史数据追溯、趋势预测分析等功能提供稳定的数据存储支撑。

一、InfluxDB 核心概念深度解析

InfluxDB 的数据模型与传统关系型数据库存在显著差异，理解以下核心概念是实现高效集成的基础。可通过与 MySQL 概念的类比快速建立认知：

在企业级后台管理系统中，站内信是核心沟通组件之一，承担着系统通知、用户互动、业务提醒等关键场景需求。基于 Go 语言微服务框架 Kratos 构建的 Go Wind Admin，将站内信模块封装为「开箱即用」的标准化组件，无需从零开发即可快速集成，大幅降低开发成本。

风行（GoWind Admin）是一款开箱即用的企业级Golang全栈中后台管理框架，品牌slogan：让中后台开发如风般自由。

系统后端基于GO微服务框架go-kratos，前端基于Vue微服务框架Vben Admin，兼顾微服务的扩展性与单体部署的便捷性。

在企业级中后台系统开发中，身份认证与授权是核心安全能力。JWT（JSON Web Token）凭借其无状态、轻量化、跨平台的特性，成为分布式系统中身份校验的优选方案。GoWind Admin 作为企业级前后端一体中后台框架，已将 JWT 核心逻辑封装至 github.com/tx7do/kratos-authn 组件中，彻底简化了底层引擎初始化、策略加载、签名验证等重复开发工作。开发者只需遵循以下标准化步骤，即可快速完成 JWT 集成，无缝对接框架的 OPA 权限管控体系，构建安全可靠的身份认证链路。

在后端开发领域，分层设计是破解系统复杂度、提升可维护性的“核心心法”。对于 GoWind Admin 这类企业级中后台框架而言，API 层、Service 层（业务逻辑层）与 Data 层（数据访问层）的交互模式，直接决定了框架的灵活性、开发效率与长期演进能力。其中，Service 层与 Data 层的耦合程度，更是架构设计的“关键胜负手”。​

本文将聚焦 GoWind Admin 的实际开发场景，深入剖析“Service 层直接引用 Data 层 Repo”（简单粗暴方案）、“基于依赖倒置的接口解耦”（工程化方案）以及“新增 biz 层的进阶方案”三种核心模式，拆解分层设计的取舍逻辑——架构设计没有“最优解”，只有“最适配当前场景的解”，尤其对于需要兼顾“开箱即用效率”与“企业级扩展需求”的中后台框架而言，平衡感至关重要。

在企业级中后台系统中，列表查询是贯穿“数据管理、业务审核、统计分析”的核心高频场景——从用户列表的多条件筛选，到订单数据的时间区间查询，再到报表的排序分页，其易用性与灵活性直接决定研发效率与业务操作体验。风行·GoWind Admin 作为开箱即用的 Go 语言后台管理系统，以“降低开发成本、提升研发效率”为核心设计理念，针对性打造了一套“配置化、高兼容、可扩展”的列表查询规则，让开发者无需关注底层 SQL 实现，仅通过简单配置即可完成复杂查询需求。

一、核心设计理念：声明式语法与 Go 生态适配

GoWind Admin 列表查询规则的设计，深度借鉴了 Python 生态中 Django ORM、SQLAlchemy 等优秀框架的“声明式语法”核心思想——通过贴近自然语言的配置方式屏蔽底层数据访问细节，让开发者聚焦业务逻辑而非 SQL 拼接。但不同于简单照搬，我们基于 Go 语言“强类型、高性能”的特性做了全链路适配，最终实现“简洁直观”与“原生兼容”的平衡：

在企业级中后台框架的开发过程中，高效的工程化管理是提升团队协作效率、保障开发流程规范的核心。GoWind Admin（风行）作为一款基于 Go 微服务框架 go-kratos 和 Vue 前端框架 Vben Admin 的全栈解决方案，其后端工程化体系中，Makefile 扮演了至关重要的角色 —— 它通过统一的命令集简化了复杂的构建流程，实现了环境初始化、依赖管理、代码生成、服务部署等操作的自动化，让开发者能够聚焦业务逻辑而非繁琐的工具链配置。本文将系统介绍 Windows 环境下 make 工具的安装方法、Makefile 的分层设计逻辑，以及核心命令的实战应用。

一、Makefile 在 GoWind Admin 后端开发中的核心价值

MongoDB 是一款开源的文档型 NoSQL 数据库，以灵活的 Schema 设计、原生 JSON/BSON 支持、高可扩展性和高性能查询著称，非常适合处理中后台系统中的非结构化 / 半结构化数据（如用户行为日志、动态表单配置、多维度报表、个性化配置等）。

GoWind Admin（风行）是面向企业级场景的前后端一体中后台框架，本文将从「环境部署→配置集成→模型设计→仓储实现→最佳实践」全流程讲解如何在 GoWind Admin 中优雅集成 MongoDB，覆盖开发、部署、调优全环节。

Open Policy Agent（简称 OPA）是一款开源的通用策略引擎，核心价值在于实现“策略即代码”（Policy as Code），将分散在各系统中的权限控制、资源访问规则等策略逻辑抽离出来，进行统一管理、版本控制与执行。如今，OPA 已成为云原生生态中策略管控的事实标准，被 Netflix、Cloudflare、Pinterest、Chef 等巨头广泛应用——从内部 API 权限管控、Kubernetes 集群资源调度，到终端产品的 IAM 功能实现，均能看到其身影。

OPA 由 Styra 公司于 2016 年开源，2018 年加入 CNCF（云原生计算基金会）成为沙箱项目，2021 年 2 月正式毕业，其快速晋升的背后，是社区的高度活跃与行业对统一策略管控需求的迫切性。本文将从 OPA 核心原理、Rego 语言入门，逐步深入到 GoWind Admin 企业级中后台框架的完整集成流程，帮助开发者快速落地权限管控能力。

go-wind-admin 作为开箱即用的企业级 Admin 全栈解决方案，核心优势之一是通过 backend/script 目录的 自动化脚本 降低跨系统部署门槛。本文以 “脚本驱动 + 实操验证” 为核心，优化步骤连贯性与细节提示，补充用户高频踩坑点，帮你更顺畅地完成从环境到服务的全流程搭建。

前置检查清单（启动前必看）

避免因基础条件缺失导致流程中断，启动前确认以下事项：

1. 操作系统权限：Windows 需 管理员身份 打开 PowerShell；Linux/macOS 需拥有 sudo 权限（执行脚本时可能需要）。
2. 网络状态：确保能访问 GitHub、Docker Hub、Homebrew/Scoop 源（建议提前配置国内镜像，见各系统备注）。
3. 磁盘空间：预留至少 10GB 空间（用于存储 Docker 镜像、依赖包、编译产物）。

Go Wind Admin 的数据脱敏能力，是基于 Protobuf 生态下的arrakis-digital/protoc-gen-redact插件实现的 —— 通过在 Protobuf 消息定义中为敏感字段（如手机号、身份证号）添加脱敏注解（如((redact.custom).string = "r*d@ct*d")），由插件自动生成适配业务的脱敏方法（如 Go 语言的Redact()方法），无需侵入业务逻辑即可完成敏感数据的遮挡处理，同时保持与 Protobuf 消息结构的强绑定，避免跨层配置不一致问题。配微服务接口、日志打印、数据存储等场景的隐私保护需求。

在企业级中后台系统开发领域，「业务规则频繁迭代」与「个性化需求快速响应」始终是困扰开发团队的核心痛点。试想这样的场景：电商平台的促销规则需随节日实时调整， SaaS 系统需为不同行业客户定制专属审批流程，风控系统需根据最新风险模型动态更新校验逻辑…… 传统「代码开发 - 编译打包 - 部署上线」的全流程，往往需要数小时甚至数天才能完成迭代，严重滞后于业务节奏。

脚本引擎的嵌入式集成，为这一困境提供了优雅的破局思路——通过动态执行脚本代码，实现业务逻辑的「热更新、热部署」，无需重启服务即可完成规则迭代与需求适配。GoWind Admin（风行）作为一款主打「开箱即用」的企业级前后端一体中后台框架，精准洞察这一需求，深度整合 kratos-bootstrap 生态中的 script_engine 组件（https://github.com/tx7do/kratos-bootstrap/tree/main/script_engine），实现了对 JavaScript、Lua 两种主流脚本语言的无缝支持，让开发者能够以极低成本嵌入动态逻辑，为中后台系统注入「随需而变」的灵活基因。

在企业级中后台系统开发中，接口调试、测试与文档同步始终是困扰前后端团队的核心痛点：接口变更后文档未及时更新、手动编写文档效率低下、调试工具切换繁琐等问题，严重影响开发协作效率。而 OpenAPI 规范（原 Swagger 规范）及其配套工具 Swagger UI，正是解决这些问题的最优解之一。

笔者在使用 Python 生态的 FastAPI 框架时，发现其内置的 Swagger UI 体验极佳——开发者可直接通过 http://127.0.0.1:8000/docs 访问交互式 API 文档，实现接口可视化调试与测试，无需额外部署工具。受此启发，我们将这一方案借鉴到 GoWind Admin（基于 Kratos 框架的企业级前后端一体中后台框架）中，实现了 API 文档的自动化生成与嵌入式访问。

在后台管理系统中，定时任务是一个很实用的功能，可以帮助我们自动执行一些周期性的任务，比如定期清理数据、发送邮件提醒等。

在go里面，如果想要简单的实现一个周期性任务，我们可以用cron或者gron等仿linux的crontab的库。

在一个CMS和Admin系统里面，文件上传是一个极其重要的功能之一。

在Kraots-Admin里面，我们把所有的文件都落地到MinIO。MinIO是一个非常优秀的分布式文件管理系统。

通常，后端可用的有两种上传方式：

1. 通过Kratos的服务向MinIO申请预签名URL，然后通过预签名URL向MinIO上传文件。
2. 直接向Kratos的服务上传文件，然后，微服务再将文件落地到MinIO。

方式一，这是最优的解决方案，因为文件不会经过微服务，直接上传到MinIO，减轻了微服务的压力。并且，MinIO支持分布式部署，可以很好的扩展。

先解决有没有，再解决好不好

极简User

CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    authority VARCHAR(50),
    password VARCHAR(255)
);

在企业级中后台框架开发中，依赖管理是贯穿全生命周期的核心挑战 —— 随着项目规模扩张，手动创建对象、传递依赖会导致代码耦合度陡增、测试成本居高不下、维护难度指数级上升。依赖注入（DI）通过 “控制反转” 机制，将对象的创建与依赖传递解耦，成为解决这一问题的最优解之一。本文以 GoWind Admin（风行）框架为实践载体，深度解析 Google 开源的编译期依赖注入工具 Wire，并完整呈现其在企业级中后台框架中的标准化集成方案。

一、基础认知：什么是依赖注入（DI）？

依赖注入（Dependency Injection，DI）是实现控制反转（IoC）的核心技术，其核心思想可概括为：对象的依赖由外部容器提供，而非对象自身创建。这里的 “依赖” 指对象运行所需的其他组件（如数据库连接、配置实例、业务服务等），“注入” 则是外部容器将依赖主动传递给目标对象的过程。

作为后端开发者，你是否曾为前后端接口联调反复沟通？作为前端新手，是否觉得手动封装 Rest 接口繁琐又易出错？今天就为大家推荐一套高效组合拳——GoWind Admin（开箱即用的全栈中后台框架）+ protoc-gen-typescript-http（Protobuf 驱动的 TS 接口生成器），让你从零到一快速搭建企业级管理系统，还能自动生成类型安全的前端接口，生产力直接翻倍！

一、先搞懂：这两个工具到底是什么？

动手实操前，我们先理清核心工具的定位，避免盲目上手：

1. GoWind Admin：企业级中后台的「脚手架王者」

让复杂归于简单，让聚合成为本能。

在微服务架构盛行的今天，企业中后台系统正面临前所未有的开发与性能双重挑战：前端需从数十个独立服务中零散拉取数据，网络请求冗余、状态管理繁琐；后端逻辑分散、接口复用性差、N+1 查询问题泛滥，既拖累开发效率，也让系统性能持续承压。如何在坚守系统解耦原则的同时，高效组装业务视图、简化开发链路？GoWind Admin（风行） 应运而生——一款专为现代企业打造的全栈中后台框架，以“开箱即用 + 内置智能聚合”为核心理念，彻底破解微服务时代的数据拼装难题，让开发者从接口拼接的繁琐工作中解放出来。

风行（GoWind HCH）是一款基于 Golang 全栈构建的企业级 Headless 内容中台（HCH=Headless Content Hub，无头内容中枢），以开箱即用的产品形态、灵活可扩展的架构设计，为企业打造全域内容管理与分发的一体化解决方案，助力企业打破内容孤岛，实现全场景内容高效运营。

为什么选择风行内容中台？

在数字化时代，企业内容资产的价值愈发凸显，但传统内容管理模式普遍面临「架构僵化、多端适配难、权限管控粗、运营效率低」等痛点。风行内容中台从企业实际业务场景出发，构建了「轻量化部署、全能力覆盖、高灵活拓展」的产品体系：

• 全栈技术底座：基于 Golang 高性能后端框架打造，兼顾稳定性与并发能力，多前端技术栈适配满足不同团队技术选型需求；
• Headless 核心架构：内容生产与展示层解耦，通过标准化 API 实现内容跨端、跨平台无缝分发，适配 Web、小程序、APP 等全终端场景；
• 企业级权限体系：从租户、部门、角色到按钮级权限的全维度管控，满足大型组织复杂的权限划分与数据隔离需求；
• 可视化高效运营：无需代码开发，通过可视化配置完成内容建模、菜单管理、站点配置等核心操作，大幅降低运营成本，提升内容上线效率。

在企业级中后台应用的建设中，数据权限是保障信息安全、符合业务合规要求的核心能力，更是平衡系统安全性与业务灵活性的关键支点。它不仅要精准解决 “谁能看到什么数据” 的核心问题，更需兼顾系统的可维护性、可扩展性与用户体验。GoWind Admin（风行）作为开箱即用的企业级全栈中后台框架，内置多层次、细粒度、高可扩展的一体化数据权限体系，从租户全局隔离到动态策略维度全面覆盖，原生支持单租户 / 多租户 SaaS 部署，让企业级应用的权限管理从 “重复开发” 变为 “开箱即用”。

一、数据权限的五大核心粒度层级

个人喜爱 Golang 的最突出原因之一是：我们可以轻松构建高可用且非阻塞的程序。

在本系列文章中，我将尝试回忆 Golang 中可用的模式。我将采用每种模式，并详细讨论它们适合的位置以及如何有效地使用它们。

什么是扇入扇出。这是一种将数据从多个流或从一个流汇聚到多个流或管道的单一数据流的方法。

generate函数

为了讨论这个模式，我们首先需要一个数据源。这是一个可以用作数据源的数据生成器。

func generate( data string) <-chan string{
    channel := make(chan string)
    
    go func() {
        for {
            channel <- data
            time.Sleep(time.Duration(100*time.Millisecond))
    
        }
    }()
    return channel
}

参考资料

• 手把手 Golang 实现静态图像与视频流人脸识别
• Golang人脸识别

GO模块版本号

模块的开发人员使用模块版本号的每个部分来表示版本的稳定性和向后兼容性。对于每个新版本，模块的发布版本号具体反映了自上一版本以来模块更改的性质。

当您开发使用外部模块的代码时，您可以在考虑升级时使用版本号来了解外部模块的稳定性。当您开发自己的模块时，您的版本号将向其他开发人员表明您的模块的稳定性和向后兼容性。

发布的模块在语义版本控制模型中使用版本号发布，如下图所示：

如何使用 Golang 连接 MongoDB

连接 MongoDB 非常简单，只需连接 MongoDB 生成的 uri。

然后我们可以使用 client.Database() 函数来确保我们连接到正确的数据库。

package main

import (
	"context"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatal(err)
	}

	db := client.Database("testdb")

	// disconnect the mongo client when main is completed
	defer func() {
		if err = client.Disconnect(ctx); err != nil {
			panic(err)
		}
	}()
}

最近在Go上面碰到了一个传出参数的问题：

func testOutString(out *string) {
	if out == nil {
		// str := "hellow"
		// out = &str
		out = new(string)
	}
	*out = "hello"
}

func main() {
	var str *string
	testOutString(str)
	fmt.Println(str)
}

在这篇简短的文章中，我们将介绍如何将 Golang 与 Bazel 构建系统结合使用。

具体来说，我们将讨论三个场景：

1. 从头开始一个 Golang 项目；
2. 将一个现有的 Golang 项目转换为 Bazel 构建；
3. 以及将一个第三方 Golang 项目引入到您的 Bazel 构建系统。

从头开始一个 Golang 项目

让我们从将 Go 与 Bazel 结合使用的基础知识开始。

为此，我们需要从 https://github.com/bazelbuild/rules_go 获取 Go 语言的官方构建规则。

什么是 Headless CMS？

Headless CMS 是一种 内容管理系统（Content Management System），它将【头部Head】表示层（内容呈现的地方）与【身体Body】后端（内容管理的地方）分离开来。即，把表示层和后端信息层分离开了。

这样，我们可以根据需要在 Web、移动和数字媒体平台上重复使用和重新混合内容。您甚至可以在印刷品中重复使用您的内容。

与格式无关的内容为所有参与者（作者、开发人员和用户）提供了变革性的体验。

通常PostgreSQL容器当中会内置一些扩展，一般存放在：/usr/lib/postgresql/{PostgreSQL版本号}/lib，扩展的实体都是.so文件，如果容器当中存在着扩展的so文件，那么就可以顺利的通过SQL语句进行安装，否则，则不能够顺利的安装，这时候，就需要编译扩展并拷贝进容器。

https://yum.postgresql.org/repopackages/

使用 Golang，可以构建小到简单的可执行工具大到完整的 Web 服务器的任何东西。为了交付应用程序，使用 Docker 是首选，它允许我们创建一个包含项目运行所需的一切的自包含环境。值得一提的是，Docker 命令行界面本身也是使用 GO 所开发。

为任何 GO 应用程序编写 Docker 镜像

通常，从一个尽可能小且具有所需基本依赖项的基本镜像开始，是一个好主意。alpine 镜像通常是一个可靠的选择，因为它们仅包含操作系统所需的最低限度。

所以，我们可以这样写 Dockerfile：

FROM golang:alpine3.15

time.Now().UnixNano

这是用的最多的，但是，也是安全隐患最大的方法。

从表面上看go的时间方法最大精度到纳秒，但是好像其实并不能到达的绝对的纳秒精度。

测试结果很不好，碰撞很高。

import "time"

func TestSeedNanoTime(t *testing.T) {
	var seeds = make(map[int64]bool)
	for i := 0; i < 100000; i++ {
		seed := time.Now().UnixNano()
		seeds[seed] = true
		fmt.Println(seed)
	}
	fmt.Println(len(seeds))
}

通过Google推出的Flutter framework，我们可以更为方便的开发跨平台APP，开发出来的APP能够在iOS、Android、Web、macOS、Windows和Linux上都可以执行。

在开发 Flutter App 之前，我们必须要先准备好开发环境，下面我将介绍如何在Mac环境下从零开始Flutter App的开发环境。

• 安装Xcode；
• 安装Android Studio；
• 安装VS Code；
• 安装CocoaPods；

安装Xcode

获取系统版本信息

lsb_release -a

在本文中，我将向您展示如何在 Mac 上安装Godot 4 游戏引擎。

在MacOS下面有两种安装途径可供使用：

1. Godot官网下载软件包安装；
2. brew安装。

1. Godot官网下载软件包安装

步骤 1. 安装 .Net SDK（可选）

Godot从4.0版本开始支持C#作为其脚本语言。

如果您希望能够使用 C# 编写和构建 Godot 项目，则需要先安装 .Net SDK。

从微软官方下载页面下载并安装：https://dotnet.microsoft.com/zh-cn/download

LLVM项目是一个模块化的、可重用的编译器和工具链集合。尽管它的名字-LLVM与传统虚拟机（low level virtual machine）名字相似。但“LLVM”这个名字本身不是一个缩略词，它就是这个项目的全称。所以，不要再把LLVM叫做low level virtual machine。

LLVM开始于伊利诺斯大学的一个研究项目。目的是提供一个现代的、基于SSA的、能够支持任意静态和动态编译的编程语言的编译策略。此后，LLVM成长为伞项目下的一个子项目。其中许多是被广泛用于各种各样的商业生产和开源代码项目以及学术研究中。LLVM项目源码采用“Apache 2.0许可协议”。

第 1 步：安装 OpenCV 的依赖项

使用以下命令安装编译 OpenCV 所需的所有依赖项：

yum groupinstall "Development Tools" -y

yum install cmake3 gcc gtk2-devel numpy pkconfig -y

平日冲咖啡挂耳包/滤挂式咖啡时，如果把挂耳包直接挂在杯边，有可能会挂耳会滑落。UCC分享能将挂耳包固定在原位的简单方法。

冲咖啡挂耳包正确步骤▼▼

1. 先将咖啡挂耳包向下轻甩2至3下，让咖啡粉沉底。

生成签名

在项目的android目录下执行以下命令：

keytool  -genkey -v -keystore ./app_key.jks -keyalg RSA -keysize 4096 -validity 10000 -alias flutter_key

什么是 UnityWebData

UnityWebData 文件是在 WebGL 游戏中与 WebAssembly 文件一起加载和使用的文件，主要是组合所有资产(Asset)、资源(Resource)和元数据(Meta)文件的文件。

UnityWebData的结构体

本节介绍基于UnityWebData1.0的二进制文件的结构进行介绍。

需要注意：int值必须以Little Endian方式读取。

Dexie.js 是对前端本地数据库 IndexedDB 的 API 进行封装的轻量级库，它简化了 IndexedDB 复杂的原生操作，提供了更简洁、直观的语法，便于开发者快速实现前端本地数据的持久化存储。

一、为什么选择 IndexedDB？

前端常见的本地存储方案（Cookie、LocalStorage、SessionStorage）均存在存储容量限制，无法满足大数据量的存储需求。IndexedDB 作为浏览器原生的本地数据库，具备大容量存储优势，具体对比如下：

• Cookie：存储容量不超过 4KB，主要用于存储会话标识等少量信息；
• LocalStorage：存储容量介于 2.5MB ~ 10MB 之间，仅支持字符串存储；
• SessionStorage：存储容量与 LocalStorage 相当，但仅在当前会话有效，页面关闭后数据丢失；
• IndexedDB：存储容量不低于 250MB，支持占用本地磁盘空间的 50%，可存储大量结构化数据，支持事务、索引等数据库核心特性。

GNU的Make是一个又古老又强大的构建工具，在我们的开发当中用得普遍。就Makefile的语法而言也不算复杂，没有特别复杂的需求的话，很容易就上手了，维护起来也容易，拿Make来做程序构建是一个好主意。

更复杂一点的项目构建可以选择Google的Bazel，但是通常的项目(至少70%-80%的项目)都没有这么复杂的需求。

在Unix、Linux、BSD、macOS等xNix下面使用Make是很方便的，很自然的，因为是出厂自带。

身为一个工程师，不管你写的是前端、后端、全端还是什么端，一定多少用过htop，就算真的没用过也会听同事说过。htop 是一个process manager，他可以让你看到执行中的process、系统资源的使用量，也可以让你轻松kill 掉任何一个process，总之，你想得到的功能统统都有～

虽然，大家都说htop 很好用，但许多人打开htop 也只看得懂CPU、Mem、PID、Command 这些简单的选项，对于Load average、NI、State、SHR 就没那么熟悉。

参考资料

• 从无到有：微信后台系统的演进之路
• 网易云信 - 超大群概述
• IM技术分享：万人群聊消息投递方案的思考和实践
• 现代IM系统中聊天消息的同步和存储方案探讨

最近，我想使用 Fluent 迁移器来为我的 postgres 数据库做种，该数据库作为 Docker 容器运行。我基本上有一个表 User，它有一个需要自动生成的 UUID 类型的主键。

我的迁移代码如下所示。

Create.Table(User.TABLE_NAME)
    .WithColumn("id").AsGuid().NotNullable().WithDefaultValue(SystemMethods.NewGuid).PrimaryKey()
    .WithColumn("username").AsString().NotNullable()
    .WithColumn("password").AsString().NotNullable();

本文适合那些正在寻找使用 Docker Compose 安装 Mattermost 的详细且简单的指南的人。

Mattermost是一种开源、可自托管的在线聊天服务，具有文件共享、搜索和集成功能。它被设计为组织和公司的内部聊天工具，主要将自己定位为 Slack 和 Microsoft Teams 的开源替代品。

💾您可以在GitHub上找到本指南中使用的存储库。

Qt（发音同 “cute”）是一套跨平台的 C++ 应用程序开发框架，由挪威公司 Trolltech（后被诺基亚、Digia 收购，现为 The Qt Company）开发，核心目标是让开发者用 “一次编写，到处运行”（Write Once, Run Everywhere）的方式，高效开发出在不同平台上（Windows、Linux、macOS、Android、iOS、嵌入式系统等）具有一致功能和体验的应用程序。

官方下载网址：http://download.qt.io/

OTP = One True Pairing = 天生一對

用来表示你认为是天生一对的两个角色。

ex.

• The Weeknd and Bella Hadid are my OTP. （The Weekend 和Bella Hadid 是我心目中的天生一对。）

DFTBA = Don’t Forget To Be Awesome = 记得要棒棒的！

通常用在与朋友道别的时候。平常我们可能会祝愿对方有个美好的一天，但比较熟的朋友之间说DFTBA 反而有种戏谑趣味感。

ex.

IoT（物联网） 是指由物理设备、车辆、家用电器和其他嵌入电子设备、软件、传感器和连接功能的物品组成的互连网络，使这些对象能够连接和交换数据。

HomeKit 是Apple 的家庭自动化框架，为智能家居设备之间的通信提供了通用平台。它使开发人员能够轻松创建可以从中央位置控制智能家居设备（例如灯、锁、恒温器等）的应用程序。

Swift 是 Apple Inc. 为 iOS、iPadOS、macOS、watchOS 和 tvOS 开发的一种功能强大的开源编程语言。 Swift 广泛用于为 Apple 平台开发应用程序，并已成为许多开发人员的首选语言。

substr替换成slice；

JetBrains IDE 基本快捷键

导航快捷键

FileReader的使用机会很多，但是它是异步的，因此很容易出现回调地狱。

我们可以使用async/await特性，它允许我们以同步的方式调用异步代码。

封装成方法

export async function readTextFile(file: File) {
    const reader = new FileReader();
    reader.readAsText(file);
    return new Promise((resolve, reject) => {
        reader.onload = () => resolve(reader.result);
        reader.onerror = () => reject(reader.error);
    });
}

export async function readBinaryFile(file: File) {
    const reader = new FileReader();
    reader.readAsArrayBuffer(file);
    return new Promise((resolve, reject) => {
        reader.onload = () => resolve(reader.result);
        reader.onerror = () => reject(reader.error);
    });
}

export async function readAsText(file: File) {
    const reader = new FileReader();
    reader.readAsText(file);
    return new Promise((resolve, reject) => {
        reader.onload = () => resolve(reader.result);
        reader.onerror = () => reject(reader.error);
    });
}

Kratos的RPC默认使用的是gRPC，与此同时我们还可以通过gRPC的grpc-gateway功能对RESTfull进行支持。这样，我们就可以同时支持gRPC和REST了。而这一切Kratos都已经封装好，无需知道底层的一切，用就好了。

任务队列（Task Queue） 一般用于跨线程或跨计算机分配工作的一种机制。其本质是生产者消费者模型，生产者发送任务到消息队列，消费者负责处理任务。

任务队列的输入是称为任务(Task)的工作单元。专用的工作进程不断监视任务队列以查找要执行的新工作。

在Golang语言里面，我们有像Asynq和Machinery这样的类似于Celery的分布式任务队列。

从单体应用迁移到微服务架构，虽能收获松耦合、可扩展等诸多优势，但也引入了新的安全挑战。微服务通过开放 API 实现服务间通信，与单体应用相比：​

• 攻击面显著扩大：每个独立服务都需单独保障安全性，风险点呈指数级增加​
• 通信安全性要求更高：API 调用不仅要验证身份，还需保障传输安全与可用性​

因此，微服务架构需要一套与单体应用截然不同的安全解决方案，核心聚焦于认证（Authentication） 与鉴权（Authorization） 两大核心能力。

一、认证与鉴权的核心区别​

Kratos是一个微服务框架，既然是微服务，那么一个工程下肯定会存在不少的服务，一个服务就是一个二进制可执行程序，那么我们将会面对一个问题：如何去构建（Build）这些服务程序。这件事情，通常都交由构建系统去做。我们能够选择的构建系统有很多：Make、CMake、Bazel……那么，我们又该如何选择一个构建系统呢？

项目结构简单，服务少，我们完全可以使用Make来进行构建。要学会使用Make，您需要学会使用Makefile来编写构建脚本，如果整个构建只是组织一些简单的编译命令，那还好，学习和使用都会是简单轻松的事情。

但是，理想很丰满，现实很骨感。在实际的工程实践中，一切都会朝着复杂的方向发展。服务的数量肯定不会少，工程的组织结构也肯定不会简单，那么，构建也就会变得相应的复杂起来，需要编写大量的Makefile，Makefile的复杂度也越来越大了。另外还有，构建环境的搭建问题，持续集成的问题，自动构建的问题，构建时间变长的问题……抱歉，面对这样复杂的工程环境，Make难以满足我们的需求。

Casbin（https://github.com/casbin/casbin）是一套访问控制开源库，致力于帮助复杂系统解决权限管理的难题。同时也是一个国产开源项目。Casbin采用了元模型的设计思想，既支持ACL（访问控制列表），RBAC（基于角色访问控制），ABAC（基于属性访问控制）等经典的访问控制模型，也支持用户按照自身需求灵活定义权限。Casbin已经被Intel、IBM、腾讯云、VMware、RedHat、T-Mobile等公司开源使用，被Cisco、Verizon等公司闭源使用。具体详见Casbin主页（https://casbin.org/）。

• ClickHouse
• Fluent Bit
• Grafana

微服务，是一种分布式软件架构。采用了分而治之的方法去解决复杂的应用问题。我们可以把复杂的系统拆解成不同的服务，并使之可以方便的进行横向扩容，提升整个系统的负载。

任何一个系统，它都需要一个管理系统，即便是使用微服务的架构也是需要的。在本文里，我们将使用B站开源的Golang语言微服务框架Kratos去实现一个最简单的CMS：博客系统。

命令查询的责任分离Command Query Responsibility Segregation 通常被简化为 命令查询分离，即读写分离。

在特定的场景下，它可以提供更好的性能。但是，在强一致性方面，它并不能够保证。而且，还会带来认知负担。所以，实际运用上，需要谨慎。

什么是 CQRS

这个概念出自于 命令与查询分离（CQS, Command Query Separation），出自于1987 年 Bertrand Meyer 的 《面向对象软件构造》(Object-Oriented Software Construction)一书，其原始概念是我们可以把对象操作分为：命令（Command）和 查询（Query）两种形式。

在早期的单体服务时代，如果想要在生产环境中通过日志去定位业务逻辑的Bug或者性能问题，那么我们需要让运维人员逐个远程登入服务器，逐个服务实例去查询日志文件，这样排查问题的效率是相当的低，当线上发生了紧急状况的时候，人都要急死，却又无法有效率的排查出问题所在，更不用说解决问题。

而在微服务时代，服务实例部署在不同的物理机上，各个微服务的日志也被分散储存在不同的物理机上。当服务集群足够大，成百上千，甚至上万，此时再使用上述的传统方式查阅日志，那已经是不可完成的任务。因此，我们需要集中化管理分布式系统中的日志，其中有开源的组件如Syslog，用于将所有服务器上的所有服务的日志进行收集、汇总。

为什么Protobuf定义成int64，转成json之后却变成了string类型？

比如说，定义了一个proto文件

message PartyMusicSearchItem {
    string name = 1;
    int32  fileSize = 2;
    string author = 3;
    string musicId = 4;
    int32 type = 6;
    int64 createdAt = 7;
    int64 lastTime = 8;
}

当我们使用 gRPC 进行跨服务通讯时，调用方往往只需要响应中的部分字段 —— 冗余字段不仅会增加网络传输成本，更可能触发不必要的下游依赖调用（比如为了返回一个非核心字段，需要额外调用 2 个服务）。​

在微服务场景中，这种「无效计算 + 无效传输」的开销会被放大：一次 RPC 级联 3~5 个下游是常态，而响应体中 60% 以上的字段可能都是调用方不需要的。​

此时，我们需要一种「字段按需筛选」机制：

• GraphQL 用「字段选择器」实现​
• JSON:API 用「稀疏字段集」实现​
• 而 gRPC 生态中，Protobuf FieldMask 是标准且高效的解决方案。

在 GO 语言生态中，DTM（Distributed Transaction Manager） 是一个开源的分布式事务管理服务，专门用于解决微服务架构下分布式事务的一致性问题。它以轻量、易用、高性能为特点，支持多种分布式事务模式，是 GO 语言开发者在处理跨服务数据一致性时的常用工具。

DTM 的核心功能与特点

1. 支持多种事务模式

DTM 针对不同业务场景，实现了主流的分布式事务协议，包括：

• TCC（Try-Confirm-Cancel）：适用于核心业务场景，通过拆分业务为 “尝试”、“确认”、“取消” 三个阶段，保证最终一致性。
• SAGA：适用于长事务场景，将分布式事务拆分为多个本地事务步骤，每个步骤对应一个补偿操作，若某步失败则执行反向补偿。
• 本地消息表（Local Message Table）：基于消息的异步确认机制，通过本地事务与消息发送的原子性，确保跨服务操作的最终一致。
• 事务消息：结合消息队列实现，通过 “半消息”、“确认发送”、“消费确认” 等机制，保证消息可靠投递与业务操作的一致性。
• XA：基于数据库的 XA 协议（如 MySQL 的 XA 事务），适用于对强一致性要求高且支持 XA 协议的数据库场景。

什么是ORM？

面向对象编程和关系型数据库，都是目前最流行的技术，但是它们的模型是不一样的。

面向对象编程把所有实体看成对象（object），关系型数据库则是采用实体之间的关系（relation）连接数据。很早就有人提出，关系也可以用对象表达，这样的话，就能使用面向对象编程，来操作关系型数据库。

简单说，ORM 就是通过实例对象的语法，完成关系型数据库的操作的技术，是"对象-关系映射"（Object/Relational Mapping） 的缩写。

ORM 把数据库映射成对象。

• 数据库的表（table） --> 类（class）
• 记录（record，行数据）--> 对象（object）
• 字段（field）--> 对象的属性（attribute）

什么是ORM？

面向对象编程和关系型数据库，都是目前最流行的技术，但是它们的模型是不一样的。

面向对象编程把所有实体看成对象（object），关系型数据库则是采用实体之间的关系（relation）连接数据。很早就有人提出，关系也可以用对象表达，这样的话，就能使用面向对象编程，来操作关系型数据库。

简单说，ORM 就是通过实例对象的语法，完成关系型数据库的操作的技术，是"对象-关系映射"（Object/Relational Mapping） 的缩写。

ORM 把数据库映射成对象。

• 数据库的表（table） --> 类（class）
• 记录（record，行数据）--> 对象（object）
• 字段（field）--> 对象的属性（attribute）

什么是依赖注入？

依赖注入 (Dependency Injection，缩写为 DI)，是一种软件设计模式，也是实现控制反转(Inversion of Control)的其中一种技术。这种模式能让一个物件接收它所依赖的其他物件。“依赖”是指接收方所需的对象。“注入”是指将“依赖”传递给接收方的过程。在“注入”之后，接收方才会调用该“依赖”。此模式确保了任何想要使用给定服务的物件不需要知道如何建立这些服务。取而代之的是，连接收方物件（像是 client）也不知道它存在的外部代码（注入器）提供接收方所需的服务。

依赖注入涉及四个概念：

1. 服务：任何类，提供了有用功能。
2. 客户：使用服务的类。
3. 接口：客户不应该知道服务实现的细节，只需要知道服务的名称和 API。
4. 注入器：Injector，也称 assembler、container、provider 或 factory。负责把服务引入给客户。 依赖注入把对象构建与对象注入分开。因此创建对象的 new 关键字也可消失了。

GraphQL 是一种用于应用编程接口（API）的查询语言和服务器端运行时，它可以使客户端准确地获得所需的数据，没有任何冗余。

GraphQL 由 Facebook 开发，并于 2012 年首次应用于移动应用。GraphQL 规范于 2015 年实现开源。现在，它受 GraphQL 基金会监管。

GraphQL有什么用？

GraphQL 旨在让 API 变得快速、灵活并且为开发人员提供便利。它甚至可以部署在名为 GraphiQL 的集成开发环境（IDE）中。作为 REST 的替代方案，GraphQL 允许开发人员构建相应的请求，从而通过单个 API 调用从多个数据源中提取数据。

Kratos默认的RPC框架使用的是gRPC，支持REST和protobuf两种通讯协议。其API都是使用protobuf定义的，REST协议是通过grpc-gateway转译实现的。使用protobuf定义API是具有极大优点的，具有很强的可读性、可维护性，以及工程性。工程再大，人员再多，也不会乱。

一切看起来都是很美好的。那么，问题来了，我们现在使用的是其他的Web框架，迁移就会有成本，有风险，不可能一下子就把历史存在的代码一口气转换过来到Kratos框架。那我可以在Kratos中整合其他的Web框架做过渡吗？答案是：可以的。Kratos是基于的插件化设计，万物皆可插。

IoT，也就是物联网，万物互联，在未来肯定是一个热点——实际上，现在物联网已经很热了。

那好，既然这一块这么有前途。那我们就来学习怎么开发物联网系统吧。可是，作为一个小白，两眼一抹黑：我想学，可是我该如何开始？这玩意儿到底该咋整呢？

于是，我各种找资料，各种学习——此处省略一亿个字，其中的艰辛，其中的曲折，总之就是：说来都是泪，欲哭却无声——总算是有了基础的认知，有了一个模糊的方向。我知道了物联网设备通讯协议MQTT、CoAP、LwM2M，知道了微服务，知道了MQ，知道了Websocket，知道了REST，知道了gRPC……有了这些认知，看起来可以开始做技术选型了。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是Kafka？怎样在微服务框架Kratos当中应用Kafka进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

任务队列（Task Queue） 一般用于跨线程或跨计算机分配工作的一种机制。其本质是生产者消费者模型，生产者发送任务到消息队列，消费者负责处理任务。

任务队列的输入是称为任务(Task)的工作单元。专用的工作进程不断监视任务队列以查找要执行的新工作。

在Golang语言里面，我们有像Asynq和Machinery这样的类似于Celery的分布式任务队列。

在微服务与多模块协同场景下，实现服务间的标准化通信与流程调度是核心挑战。本文聚焦 go-kratos-mcp-demo 项目，讲解如何基于 Go-Kratos 框架与 MCP（模块化协同协议）构建可扩展的推荐服务，涵盖服务契约设计（proto）、模块化流程编排、召回/过滤/排序等关键模块的实现与测试，并展示实战部署与可观测性方案。

技术基石：Go-Kratos 与 MCP 的协同架构

项目技术选型围绕 “模块化协同” 核心需求展开，Go-Kratos 与 MCP 构成架构的两大支柱，形成 “框架赋能 + 协议规范” 的协同模式：

TL;DR

微服务框架也是可以用于开发单体架构(monolith architecture)的应用。并且，单体应用也是最小的、最原始的、最初的项目状态，经过渐进式的开发演进，单体应用能够逐步的演变成微服务架构，并且不断的细分服务粒度。微服务框架开发的单体架构应用，既然是一个最小化的实施，那么它只需要使用到微服务框架最小的技术，也就意味着它只需要用到微服务框架最少的知识点，拿它来学习微服务框架是极佳的。

本文将围绕着一个我写的demo项目：kratos-monolithic-demo开展，它既是一个微服务框架Kratos的最小化实践，也是一个工程化实践的完全体。从中你可以学习到：

什么是消息队列

MQ就是消息队列，是Message Queue的缩写。消息队列是一种通信方式。消息的本质就是一种数据结构。因为MQ把项目中的消息集中式的处理和存储，所以MQ主要有解耦，并发，和削峰的功能。

为什么要使用消息队列

1. 异步

通常的微服务实现里面，都是通过RPC进行微服务之间的相互调用，这是同步的。如果消息队列的话，可以实现异步的调用。至于异步有啥好处呢，主要是为了削峰。

2. 削峰

同步的调用会带来一个问题：瞬时流量。客户的调用同步接口节奏，你是无法把控的，流量将会是忽高忽低的，猛的来一波，搞不好系统就崩了溃了。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是MQTT？怎样在微服务框架Kratos当中应用MQTT进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

什么是SSL

SSL（安全套接字层） 及其后继者 TLS（传输层安全性） 是用于在联网计算机之间建立经过身份验证和加密的链接的协议。 尽管SSL协议已随着以下版本的发布而被弃用 TLS 1.0，在1999年，将这些相关技术称为“ SSL”或“ SSL /TLS。” 最新版本是 TLS 1.3，定义于 RFC 8446 （八月2018）。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是NATS

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

消息中间件是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的构建。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是NSQ？怎样在微服务框架Kratos当中应用NSQ进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。 消息中间件是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的构建。

Open Policy Agent，官方简称OPA，旨在统一不同技术和系统的策略执行。今天，OPA 被科技行业内的巨头们所使用。例如，Netflix 使用 OPA 来控制对其内部 API 资源的访问。Chef 用它来为他们的终端用户产品提供 IAM 功能。此外，许多其他公司，如 Cloudflare、Pinterest 等，都使用 OPA 在他们的平台上执行策略（如 Kubernetes 集群）。

OPA 最初是由 Styra 公司在 2016 年创建并开源的项目，目前该公司的主要产品就是提供可视化策略控制及策略执行的可视化 Dashboard 服务的。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是Pulsar？怎样在微服务框架Kratos当中应用Pulsar进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是RabbitMQ？怎样在微服务框架Kratos当中应用RabbitMQ进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

消息队列是一种异步的服务间通信方式，适用于无服务器和微服务架构。消息在被处理和删除之前一直存储在队列上。每条消息仅可被一位用户处理一次。消息队列可被用于分离重量级处理、缓冲或批处理工作以及缓解高峰期工作负载。

消息队列是大型分布式系统不可缺少的中间件，也是高并发系统的基石中间件，所以掌握好消息队列MQ就变得极其重要。

在本文当中，您将了解到：什么是消息队列？什么是RocketMQ？怎样在微服务框架Kratos当中应用RocketMQ进行业务开发。

什么是消息队列

消息队列（Message Queue，简称MQ）指保存消息的一个容器，其实本质就是一个保存数据的队列。

supervisor

安装supervisor

Centos：

# 先安装 EPEL
yum install -y epel-release

# 安装supervisor
sudo yum -y install supervisor

# 设置为开机启动
sudo systemctl enable supervisord

# 启动进程
sudo systemctl start supervisord

基于 SignalR 可以实现客户端和服务器之间进行即时通信。

适合 SignalR 的应用场景：

需要从服务器进行高频率更新的应用。 示例包括游戏、社交网络、投票、拍卖、地图和 GPS 应用。 仪表板和监视应用。 协作应用。 协作应用的示例包括白板应用和团队会议软件。 需要通知的应用。 社交网络、电子邮件、聊天、游戏、旅行警报和很多其他应用都需使用通知。

SignalR 自动选择服务器和客户端能力范围内的最佳传输方法，如WebSockets、Server-Sent Events、长轮询。Hub 是一种高级管道，允许客户端和服务器相互调用方法。 SignalR 自动处理跨计算机边界的调度，并允许客户端调用服务器上的方法，反之亦然。SignalR 提供两个内置协议：基于 JSON 的文本协议和基于 MessagePack 的二进制协议。

Socket.IO 是一个面向实时 web 应用的 实时通讯库。它使得服务器和客户端之间实时双向的通信成为可能。底层使用EngineIO。SocketIO的的客户端使用Engine.IO-Client，服务端使用Engine.IO实现。

Socket.IO 主要使用WebSocket协议。但是如果需要的话，Socket.IO 可以回退到几种其它方法，例如Adobe Flash Sockets，JSONP拉取，或是传统的AJAX拉取，并且在同时提供完全相同的接口。尽管它可以被用作WebSocket的包装库，它还是提供了许多其它功能，比如广播至多个套接字，存储与不同客户有关的数据，和异步IO操作。

我也是最近才知道SSE的，问了下周围的人，发现知道的人也着实不多的。我是怎么知道SSE的呢？我看了下OpenAI的API，有一个Stream模式，就是使用的SSE实现的。说白了，这就是一个HTTP长连接通过服务端持续发送数据到前端的协议。在网络不稳定的情况下，它比Websocket要更好。

什么是SSE

Server-Sent Events（简称 SSE）

严格地说，HTTP 协议无法做到服务器主动推送信息。但是，有一种变通方法，就是服务器向客户端声明，接下来要发送的是流信息（streaming）。

也就是说，发送的不是一次性的数据包，而是一个数据流，会连续不断地发送过来。这时，客户端不会关闭连接，会一直等着服务器发过来的新的数据流，视频播放就是这样的例子。本质上，这种通信就是以流信息的方式，完成一次用时很长的下载。

在我们的开发当中，调试接口，测试接口，提供接口文档给前端，那都是非常频繁的工作内容。

那么，我们需要用什么方法和工具来实施这些工作内容呢？

Swagger，或者说OpenAPI。

下面先让我们了解一下下什么是Swagger，什么是OpenAPI。

什么是 OpenAPI

OpenAPI 是编写 RESTful API 的全球标准。它是一种规范，使得全球开发人员可以标准化 API 的设计，并在从头开始编写 REST API 时遵守所有安全、版本控制、错误处理和其他最佳实践。不仅仅是从头开始，即使现有的 API 也可以进行微调以符合全球标准。

任务队列（Task Queue） 一般用于跨线程或跨计算机分配工作的一种机制。其本质是生产者消费者模型，生产者发送任务到消息队列，消费者负责处理任务。

任务队列的输入是称为任务(Task)的工作单元。专用的工作进程不断监视任务队列以查找要执行的新工作。

在Golang语言里面，我们有像Asynq和Machinery这样的类似于Celery的分布式任务队列。

什么是Thrift

Thrift是Facebook于2007年开发的跨语言的rpc服框架，提供多语言的编译功能，并提供多种服务器工作模式；用户通过Thrift的IDL（接口定义语言）来描述接口函数及数据类型，然后通过Thrift的编译环境生成各种语言类型的接口文件，用户可以根据自己的需要采用不同的语言开发客户端代码和服务器端代码。2007年由facebook贡献到apache基金，是apache下的顶级项目，具备如下特点：

• 支持多语言：C、C++ 、C# 、D 、Delphi 、Erlang 、Go 、Haxe 、Haskell 、Java 、JavaScript、node.js 、OCaml 、Perl 、PHP 、Python 、Ruby 、SmallTalk
• 消息定义文件支持注释，数据结构与传输表现的分离，支持多种消息格式
• 包含完整的客户端/服务端堆栈，可快速实现RPC，支持同步和异步通信

本文将带你了解什么是 BI（商业智能） 和 UBA（用户行为分析），并且使用go语言和微服务框架kratos去实现一个UBA系统。

这个系统简单的描述就是：前端通过埋点SDK上报前端采集到的埋点数据，后端的代理服务（Agent Service）接收到了埋点数据之后，将数据入列到Kafka当中，然后我们消费Kafka当中的消息，入库到ClickHouse当中，分析服务对入库的埋点数据进行分析并且生成报表，最后在前端页面进行展示。

什么是BI？

BI，即商业智能，指利用大数据分析、现代数据仓库等技术收集企业最新数据、形成BI报表并及时为企业员工提供BI数据分析报告，实现对业务数据的深入挖掘以获取更多商业价值。大多数企业每天都会收集海量业务数据，这些数据来自其 ERP 软件、电商平台、供应链以及许多其他内部和外部数据源。要想充分利用这些数据，制定由数据驱动的决策，现代商业智能 (BI) 系统必不可少。

首先，我们需要知道：Kratos能够上传文件。

其次，我们需要知道：需要一些手工代码来支撑（不能够代码生成一波流）。

最后，我们所有的文件都落地到MinIO当中。对于使用过各种上传方案的我而言，MinIO是一个非常完美的文件解决方案。

在这里，我们不讨论前端的上传，我们只讨论后端的上传。我另外有一篇偏向于前端的文章，有兴趣的同学可以阅读它：JavaScript/TypeScript前端实现文件上传到MinIO。

什么是WebSocket

WebSocket 协议主要为了解决基于 HTTP/1.x 的 Web 应用无法实现服务端向客户端主动推送的问题, 为了兼容现有的设施, WebSocket 协议使用与 HTTP 协议相同的端口, 并使用 HTTP Upgrade 机制来进行 WebSocket 握手, 当握手完成之后, 通信双方便可以按照 WebSocket 协议的方式进行交互

WebSocket 使用 TCP 作为传输层协议, 与 HTTP 类似, WebSocket 也支持在 TCP 上层引入 TLS 层, 以建立加密数据传输通道, 即 WebSocket over TLS, WebSocket 的 URI 与 HTTP URI 的结构类似, 对于使用 80 端口的 WebSocket over TCP, 其 URI 的一般形式为 ws://host:port/path/query 对于使用 443 端口的 WebSocket over TLS, 其 URI 的一般形式为 wss://host:port/path/query

用户的权限管理对每个项目来说都至关重要。不同的业务场景决定了不同的权限管理需求，不同的技术栈也有不同的解决方案：

1. 如果你在写一个Ruby On Rails应用，那你可能会选择cancan；
2. 如果你在写一个Java Spring应用，那你可能会选择Spring Security 或者 Apache Shiro；
3. 如果你正在使用K8S，那你很可能需要与K8S的鉴权模块打交道。

nm

# 查看静态库或动态库定义了哪些函数
nm -n --defined-only xxxx.a
nm -g -C --defined-only xxxx.so
nm -D xxxx.so

# 显示hello.a 中的未定义符号，需要和其他对象文件进行链接.
nm -u hello.o

# 在 ./ 目录下找出哪个库文件定义了close_socket函数. 
nm -A ./* 2>/dev/null | grep "T close_socket"

有3个专有名词：

• I18N - 国际化，internationalization，缩写源自于在I和N之间有18个字母。
• L10N - 本地化，localization，缩写源自于在L和N之间有10个字母。
• M17N - 多语言化，multilingualization，缩写源自于在M和N之间有17个字母。

国际化 (I18N)

该术语用于设计、分析和采用支持本地市场甚至全球市场多语言的软件。

国际化是指去本地化，移除本地语言写的提示信息，异常信息，区域信息等，采用国际标准或者提取资源。

在Windows 上有「Delete」跟「Backspace」两个按键，一个是往左删除字符，一个是往右删除字符；可是在Mac 上却只有一个delete 键，要怎样灵活的用它，让它变得跟Windows 一样好用呢？

fn + delete，删除右边文字

fn + delete 可以让光标向右边删除文字，跟Windows 的 del 键功能一样。

基础泡泡水

• 950毫升温水
• 115克白砂糖
• 120毫升洗碗液

超级泡泡水

• 1400毫升水
• 65克玉米淀粉
• 120毫升洗碗液
• 13克泡打粉
• 15毫升甘油或玉米糖浆

彩色泡泡水

• 300毫升温水
• 30克白砂糖
• 80毫升洗碗液
• 食用色素

芳香泡泡水

• 240毫升温水
• 120毫升温和的，或者无香型洗手液
• 精油
• 30到60毫升甘油或玉米淀粉（可选）

一、Markdown

简介

应用

当前许多网站都广泛使用 Markdown 来撰写帮助文档或是用于论坛上发表消息。例如：GitHub、简书、知乎等

编辑器

推荐使用Typora，官网：https://typora.io/

在 Go 语言微服务生态中，单一框架的能力边界往往决定项目上限，而 “核心框架 + 生态扩展” 的架构协同性，才是长期支撑业务迭代的关键。面对 Gin、Go-Micro、Kitex 等选项，go-kratos 不仅自身架构卓越，更通过kratos-transport（通信扩展）、kratos-authn/authz（安全扩展）、kratos-cli（工具扩展）及go-wind-admin/cms/go-crud（应用模板），构建了 “核心定义标准、扩展补全能力、应用落地业务” 的全链路架构体系。本文从架构视角拆解这一生态，解析技术选型优先选择 go-kratos 的深层逻辑。

基础概念

机器学习

机器学习 (ML) 是人工智能 (AI) 的一部分，属于计算科学领域，专门分析和解释数据的模式及结构，以实现无需人工交互即可完成学习、推理和决策等行为的目的。简单来说，机器学习即支持用户向计算机算法馈送大量数据，然后让计算机分析这些数据，并仅根据输入数据给出数据驱动型建议和决策。如果算法识别出任何更正，它会整合更正信息，改进未来决策。

机器学习由三个部分组成：

• 属于决策核心的计算算法。
• 组成决策的变量和特征。
• 支持（训练）系统学习的具有已知答案的相关基础知识。

MQTT开源服务器有不少,我只用了两个Erlang开发的开源服务器:

• RabbitMQ
• EMQX.

现实中,我们需要提供一个HTTP认证服务器,来认证我们的MQTT客户端.

Docker部署开发服务器

Last Will and Testament（LWT，遗嘱消息）其作用是当客户端异常断开（如网络中断）时，EMQ X 自动发布一条预设的遗嘱消息，通知系统该用户离线。

该消息由MQTT的服务端（Broker）发出。

该消息，在客户端正常离线的时候不会被发出，只有客户端非正常断开网络连接的时候才会发出。

LWT的Topic设计上，从两个维度设计分别为：

1. 用户维度：user/status/{user_id}
2. 设备维度：device/status/{device_id}

什么是SSL

SSL（安全套接字层） 及其后继者 TLS（传输层安全性） 是用于在联网计算机之间建立经过身份验证和加密的链接的协议。 尽管SSL协议已随着以下版本的发布而被弃用 TLS 1.0，在1999年，将这些相关技术称为“ SSL”或“ SSL /TLS。” 最新版本是 TLS 1.3，定义于 RFC 8446 （八月2018）。

MSB 最高有效位（The Most Significant Bit）

LSB 最低有效位（The Least Significant Bit）

参考资料

• Most Significant Bit
• Least Significant Bit

我从 2018 年初就开始使用 Flutter，我仍然对自己为客户和公司开发和部署应用程序的速度感到惊讶。由于我的开发周期的重点是提供有价值的产品，因此我避免重新发明轮子，这就是为什么我有一个在大多数项目中使用的安全和流行的软件包列表。今天我将分享我最常用的 5+1 个 Flutter 包，以帮助您完成下一个项目。

1. cached_network_image

随着移动应用程序对富媒体内容的需求不断增长，高效的图像加载和缓存变得至关重要。 cached_network_image 是一个可靠的解决方案，可以无缝处理图像加载、缓存和错误处理。通过在本地智能缓存图像，即使在具有挑战性的网络条件下，该软件包也能确保流畅且响应迅速的用户体验。凭借其简单性和性能，cached_network_image 几乎在我所有的应用程序中使用，以最佳效率提供具有迷人视觉的应用程序。

• 国内镜像

1. Tesseract https://github.com/tesseract-ocr/tesseract
2. PaddleOCR https://github.com/PaddlePaddle/PaddleOCR
3. EasyOCR https://github.com/JaidedAI/EasyOCR
4. chineseocr https://github.com/chineseocr/chineseocr
5. chineseocr_lite https://github.com/DayBreak-u/chineseocr_lite
6. CnOCR https://github.com/breezedeus/cnocr
7. TrWebOCR https://github.com/alisen39/TrWebOCR

OHLC

• 开盘价（Open）：这被视为特定时间段或时间范围开始时资产或加密代币的开盘价。
• 最高价（High）：这是给定时间范围内资产交易的最高价格
• 最低价（Low）：这是指定时间段内资产的最低交易价格。
• 收盘价（Close）：这是指定时间结束时资产的最后交易价格。

OHLCV

• Open: opening price
• High: highest price
• Low: lowest price
• Close: closing price
• Volume: volume of transactions

OLTP 和 OLAP：这两个术语看起来相似，但指的是不同类型的系统。在线事务处理 (OLTP) 实时捕获、存储和处理来自事务的数据。在线分析处理 (OLAP) 使用复杂的查询来分析来自 OLTP 系统的汇总历史数据。

OLTP

什么是OLTP？

OLTP 是指Online Transactional Processing 的简称，这个词中 Transactional 是非常重要的，代表的是说他的处理通常包含了读以及写，通常OLTP 是指系统能够处理大量的更新以及新增的查询。所以在传统的OLTP 系统中，数据的正确性以及一致性是首要要达到的目标之一。所以一般的OLTP 中会常常听到ACID (Atomatic, Consistent, Isolated, Durable) 合规。这代表他们遵循着一个事务(Transaction) 完成后才会执行下一笔，确保整个系统的数据一致性。

添加依赖库

go get github.com/Azure/azure-sdk-for-go

一开始我走入了误区，应该从Protobuf生成dts，但是，现在来看，通过OpenAPI文档生成dts文件会更好一些。

首先，Protobuf对于前端来说，知识面几乎没有交集。你要找出知道Protobuf的前端，这并不是一件很容易的事情。但是，你要问前端OpenAPI，Swagger，他一定能够会告诉你，必须的知道。

其次，Protobuf通常都是后端定义，后端使用，要开放VSC的权限给前端，有时候会是一个很艰难的问题。那么，现实是，通常生成的工作都要后端去做——这就给工作中带来了极大的不便。

综上，通过Protobuf生成dts其实并不是一个明智之举。

什么是数织？

数织是一种逻辑游戏，以猜谜的方式绘画黑白位图。在一个网格中，每一行和列都有一组数，玩家需根据它们来填满或留空格子，最后就可以由此得出一幅图画。例如，“4 8 3”的意思就是指该行或列上有三条独立的线，分别占了4、8和3格，而每条线最少要由一个空格分开。传统上，玩家是以黑色填满格子，和以“×”号标记一定不需要填充的格子。数织是一个NP完全的问题。

数织是在1987年由日本人西尾彻也发明的。数织的日文名称是“お絵かきロジック”，意思是“绘画逻辑”。数织初见于日本的谜题杂志，玩家用纸和笔来玩。随后，任天堂以“Mario's Picross”为名推出了两款Game Boy和九款超级任天堂游戏。现时NDS上亦有名为Picross DS的同款游戏。2015年十二月，任天堂推出了名为“Pokemon Picross”的3DS游戏。

Windows

ping结果示例

中文：

ping www.baidu.com -n 3

正在 Ping www.a.shifen.com [120.232.145.185] 具有 32 字节的数据:
来自 120.232.145.185 的回复: 字节=32 时间=45ms TTL=49
来自 120.232.145.185 的回复: 字节=32 时间=627ms TTL=49
来自 120.232.145.185 的回复: 字节=32 时间=49ms TTL=49

120.232.145.185 的 Ping 统计信息:
    数据包: 已发送 = 3，已接收 = 3，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
    最短 = 45ms，最长 = 627ms，平均 = 240ms

参考资料

• Github开源人体姿态识别项目OpenPose中文文档
• MediaPipe Pose
• 基于人体姿态识别的AI健身系统
• 基于深度学习的人体姿态估计技术与应用
• On-device, Real-time Body Pose Tracking with MediaPipe BlazePose

在我的 SQL 之旅的早期，我认为在数据库中搜索一段文本主要涉及这样的查询：

SELECT col FROM table WHERE col LIKE '%some_value%';

什么是交叉表？

交叉表（Cross Tabulations） 是一种常用的分类汇总表格。利用交叉表查询数据非常直观明了，被广泛应用。交叉表查询也是数据库的一个特点。

概念

在统计学中，交叉表是矩阵格式的一种表格，显示变量的（多变量）频率分布。交叉表被广泛用于调查研究，商业智能，工程和科学研究。它们提供了两个变量之间的相互关系的基本画面，可以帮助他们发现它们之间的相互作用。卡尔·皮尔逊（Karl Pearson）首先在“关于应变的理论及其关联理论与正常相关性”中使用了交叉表。

多元统计学的一个关键问题是找到高维应变表中包含的变量的（直接）依赖结构。如果某些有条件的独立性被揭示，那么甚至可以以更智能的方式来完成数据的存储。为了做到这一点，可以使用信息理论概念，它只能从概率分布中获得信息，这可以通过相对频率从交叉表中容易地表示。

做了一些配置的修改之后，查询到的数据倒是显示的是+8的时区，可是，执行show timezone;之后，不论怎么样都是显示的是UTC时间。

环境变量

docker-compose的相关配置如下：

services:
  postgres:
    environment:
      - TZ=Asia/Shanghai
      - PGTZ=Asia/Shanghai

Prometheus有4大指标类型（Metrics Type），分别是：

1. Counter（计数器）
2. Gauge（仪表盘）
3. Histogram（直方图）
4. Summary（摘要）

1. Counter（计数器）

计数器表示一种单调递增的指标，除非发生重置的情况下下只增不减，其样本值应该是不断增大的。

例如，可以使用Counter类型的指标来表示服务的请求数、已完成的任务数、错误发生的次数等。

2. Gauge（仪表盘）

仪表盘类型代表一种。它可以理解为状态的快照，Gauge通常用于表示温度或者内存使用率这种指标数据，也可以表示能随时增加或减少的“总数”，例如当前并发请求的数量node_memory_MemFree（主机当前空闲的内容大小）、node_memory_MemAvailable（可用内存大小）等。在使用Gauge时，用户往往希望使用它们等。

要将Protobuf协议生成目标语言的代码，必须要通过生成器protoc来实现，protoc是通过插件机制来实现各种语言的生成功能。

插件生成文件一览表

7.x.x和6.x.x差异

6是运行时和CLI都在一起，7则拆分开来了。

pnpm install -D protobufjs
pnpm install -D protobufjs-cli

python下面关于文档操作的工具倒是多的，比如：

• win32com
• python-docx
• pydocx
• docx2pdf
• Aspose.Words
• python-docx-template

国内常用软件源列表

在 Qt 6 开发中，C++ 与 QML 混合编程是常见场景。当 C++ 处理异步操作（如登录验证、网络请求、数据库查询）时，需要将结果通知给 QML 界面，回调函数是最直观的通信方式之一。本文将基于你提供的代码框架，补充关键细节、修复潜在问题，并完整实现从 C++ 调用 QML 回调的全流程。

一、核心场景说明

我们需要实现：

1. QML 调用 C++ 的 login 方法（传入用户名、密码和两个回调函数：成功回调 onSuccess、失败回调 onFailure）；
2. C++ 异步处理登录逻辑（模拟耗时操作）；
3. 登录完成后，C++ 调用对应的 QML 回调函数，将结果（成功响应 / 错误信息）传递给 QML。

在 Qt 开发中，原生的日期时间选择组件往往难以满足个性化的 UI 设计和交互需求（如深色主题、自定义时间范围、键盘导航等）。本文基于 Qt6.10 版本，从零实现一款功能完整、交互友好的 DateTimePicker 组件，支持日期 + 时间联动选择、时间范围限制、键盘 / 鼠标双交互、深色主题适配等特性，可直接集成到 QML 项目中。

一、组件核心特性

在 Qt 开发中，单例模式是高频使用的设计模式，用于全局共享一个实例（如配置管理、网络服务、日志系统等）。一个健壮的 Qt 单例需要满足 线程安全、自动清理、通用性强、支持任意构造参数 等核心需求。本文将基于模板封装 + 管理器的设计思路，实现一套可直接复用的单例框架，并详细讲解其设计原理与最佳实践。

一、单例模式的核心诉求

在 Qt 环境中，单例的设计需要解决以下关键问题：

1. 线程安全： 多线程并发调用时避免创建多个实例；
2. 自动清理： 程序退出时自动释放资源，避免内存泄漏（尤其配合 Qt 的 QCoreApplication::aboutToQuit 机制）；
3. 通用性： 支持任意类作为单例，无需重复编写单例逻辑；
4. 灵活构造： 支持带参数的构造函数，且不丢失参数语义；
5. 安全校验： 避免未初始化就调用实例的错误；
6. 可手动控制： 支持主动初始化 / 销毁单例。

「程序交易」（Program Trading）也可以称为「量化交易」（Quantitative Trading） ，投资人通过计算机程序「全自动」执行投资交易。

其优势在于可以大量节省时间盯盘，也可以同时关注多种商品。程序交易可以避免人性的主观影响，透过软件严格执行保持交易的一致性。

什么是量化交易？起源为何？

• 量化交易简单来说就是将自己的金融操作方式，用很明确的方式去定义和描述，透过程序去回测验证，评估后确认方法具有交易优势后，让程序依照所设定的规则去执行交易。

• 量化交易开始于1980年代初，大型投资机构利用程序设计的方式将交易规则明确的以程序语言定义，将交易流程系统化，至今有大多数的对冲基金（hedge fund）用到量化交易。在华尔街，传统的主观操盘手，将面临淘汰的压力，已经很少对冲基金利用基本面来选股了。

框架和开源实现

C/C++

参考资料

• 《Go组件设计与实现》-netpoll的总结
• Go netpoll I/O 多路复用构建原生网络模型之源码深度解析
• Go netpoller 原生网络模型之源码全面揭秘
• epoll在Golang中的应用
• 百万 Go TCP 连接的思考: epoll方式减少资源占用

有需求，Key到期的时候需要一个通知给服务器端用于感知数据的改变。刚好Redis提供了一个Keyspace Notifications功能，可以让服务器端监听某个Key的到期事件。

官方文档说，这个功能是很耗费CPU的，所以，默认是关闭的。需要开启的话，可以使用命令：

config set notify-keyspace-events KEA

我交谈过的大多数开发人员最终都会谈论 REST，他们都希望构建尽可能最好的 REST API。这当然会引发关于什么是好的 REST API 的常见讨论，或者您应该如何确保您的 API 是 REST风格的。有时，气氛会很紧张，所以我决定写一篇文章来解决这个问题。

这篇文章旨在收集我所认为的 REST 背后的主要设计原则。我当然会更新该文档，以反映我的任何不足或任何可以帮助任何有疑问的人的新想法。

什么是REST

REST 或“表述性状态传输”是一种架构风格，它定义了 Web 服务的设计和行为方式。REST 定义了一组必须遵循的约束，以便在互联网上的系统之间提供更好的互操作性。遵循这些原则的 Web 服务被认为是 REST风格的。

在本指南中，我们将学习如何在 Docker 容器中运行 CoTURN。COTURN 是一款免费的开源 TURN 服务器，可用于 WebRTC 视频和音频通信以及 VoIP 服务

先决条件

• 您应该在系统上安装 docker。了解如何在系统上安装 docker 超出了本文的范围
• 建议但不要求具备一些 docker 基础知识

安装

Docker 提供了 CoTURN 镜像，可用于在容器中轻松设置 CoTURN 服务器

步骤 1 拉取 Docker 镜像

安装docker coturn。从云存储库Docker Hub中拉取coturn的docker镜像。

RBAC 是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

RBAC 简介

RBAC 认为授权实际上是 Who 、What 、How 三元组之间的关系，也就是 Who 对 What 进行 How 的操作，也就是“主体”对“客体”的操作。

第一次使用Selenium后，在循环处理时，我遇到了一个莫名其妙的错误，我被卡住了一阵子，故而我留下本文作为备忘录。

stale element reference: element is not attached to the page document

基准测试（benchmark）是针对系统设计的一种压力测试，目标是为了掌握系统的行为。

利特尔法则(Little’s law)

利特尔法则（英语：Little's law），基于等候理论，由约翰·利特尔在1954年提出。利特尔法则可用于一个稳定的、非占先式的系统中。

利特尔法则可用来确定在途存货的数量。此法则认为，系统中的平均存货等于存货单位离开系统的比率（亦即平均需求率）与存货单位在系统中平均时间的乘积。

利特尔法则的公式描述为：

Lead Time(产出时间) = 存货数量 × 生产节拍 或 TH(生产效率) = WIP(存货数量) / CT(周期时间)

下载Skeleton Viewer

下载页面：https://zh.esotericsoftware.com/spine-skeleton-viewer

打开界面

java -jar skeletonViewer.jar

交易制度

• 竞价制度
• 做市商制度

竞价制度

撮合交易也叫竞价交易，它由买卖双方直接进行交易，或将委托交给各自的代理经纪商，由代理经纪商将委托者的委托呈交到交易市场，在市场的交易中心以买卖双向价格为基准实行撮合，达成交易。 撮合交易（竞价交易）的类型包括：连续竞价方式和集合竞价方式。

• 集合竞价交易制度（Call Auction Mechanism）
• 连续竞价交易制度（Continues Auction Mechanism）

集合竞价交易制度（Call Auction Mechanism）

3月24日上午10点30分左右，罗某保存了贩卖机上原本的收款码，并将两张伪造二维码贴在了口罩自动贩卖机上。只要有人扫码，他支付宝收到转账，就用自己手机扫一下事先拍好的贩卖机二维码照片完成购买，这样虽然有个时间差，但顾客也能拿到口罩，自己又轻松赚到了差价，为了以假乱真，罗某还设置了首单减一块钱的优惠，买一个口罩需要14元，两个29元。截止到24日下午6时，贩卖机上的二维码被民警发现并撕除，罗某通过此方法共非法获利74元。

新闻来源: 都要注意！6元口罩突然涨到14元？这个自动贩卖机，一查果然有猫腻！

roguelike 的魅力在于：重复奖励和诱人的希望，无论是因为你收集的新工具、你开发的新技能，还是你增强的新统计数据，你的下一次运行都会更加成功比最后一次。Roguelike 游戏很难停止，因为通常情况下，你会在某些方面有所进步。

尽管 Roguelike 的流行是最近才出现的现象，但其历史可以追溯到 40 多年前——准确地说，是从 1980 年开始。

尽管如此，Roguelike 游戏直到最近十年左右才进入主流。事实上，它们已经变得如此流行。天哪，2021 年最好的游戏之一是 PlayStation 工作室的 Roguelike 游戏。这导致了市场的某种程度的饱和，通常很难知道数百种游戏中哪一款最适合您。这就是我们进来的地方。

ThingsBoard设备有关的表

• device_profile 这个表相当于国内的“产品”的概念
• ota_package 这个表是OTA升级包相关的数据
• device 这个表是设备的数据
• device_credentials 这个表是设备的登陆验证凭证信息

• HTTP POST /provision

递交给HttpTransportContext

传递到了DefaultTransportService::process当中做处理。

public enum DeviceProfileProvisionType {
    DISABLED,
    ALLOW_CREATE_NEW_DEVICES,
    CHECK_PRE_PROVISIONED_DEVICES
}

微服务系统架构

规则引擎系统架构

系统默认的规则链

关于Unix时间戳(Unix timestamp)

时间戳(Timestamp) 也被称作为 Unix时间戳(Unix timestamp)，或称Unix时间(Unix time)、POSIX时间(POSIX time)，是一种时间表示方式，定义为从世界协调时间（Coordinated Universal Time，即UTC）或称 格林威治时间的 1970年01月01日00时00分00秒（00:00:00 GMT） 起至现在的总秒数。Unix时间戳不仅被使用在Unix系统、类Unix系统中，也在许多其他操作系统中被广泛采用。

数据库简介

搭建本地Docker数据库

docker pull bitnami/elasticsearch:latest

docker run -d \
--name elasticsearch-test \
-p 9200:9200 \
-p 9300:9300 \
-e ELASTICSEARCH_USERNAME=elastic \
-e ELASTICSEARCH_PASSWORD=elastic \
-e xpack.security.enabled=true \
-e discovery.type=single-node \
-e http.cors.enabled=true \
-e http.cors.allow-origin=http://localhost:13580,http://127.0.0.1:13580 \
-e http.cors.allow-headers=X-Requested-With,X-Auth-Token,Content-Type,Content-Length,Authorization \
-e http.cors.allow-credentials=true \
bitnami/elasticsearch:latest

docker pull appbaseio/dejavu:latest

docker run -d \
--name dejavu-test \
-p 13580:1358 \
appbaseio/dejavu:latest


http://localhost:13580/

数据库简介

搭建本地Docker数据库

参考资料

数据库简介

TimescaleDB是基于PostgreSQL的时序数据库插件，完全继承了PostgreSQL的功能，TimescaleDB是一个开放源代码的时间序列数据库，针对快速提取和复杂查询进行了优化。它使用“完整的SQL”，并且与传统的关系数据库一样易于使用，但是扩展的方式以前只适用于NoSQL数据库。与这两种方案(关系型和NoSQL)所要求的权衡相比，TimescaleDB为时间序列数据提供了两种方案的最佳选择:

有多种类型的交易所可以促进金融工具的交易。最常见的交易所类型是：

股票(Stock) 和 ETF 交易所

股票和 ETF 交易所受美国证券交易委员会( SEC )监管，是最常见和最知名的资产交易所类型。股票和 ETF 交易所允许投资者和交易者买卖股票和交易所交易基金 ( ETF )。

股票代表着对公司的所有权，可以像任何其他类型的资产一样买卖。ETF 是在证券交易所交易的投资基金，由股票、债券、商品和/或其他资产的投资组合组成。

期权(Options)交易所

期权交易所受美国商品期货交易委员会 ( CFTC )监管，是一种衍生资产交易所。期权交易所允许交易者买卖期权合约。

验证IP有效性

// 验证IP有效性
function isValidIP(ip: string): boolean {
  const reg = /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/
  return reg.test(ip);
}

以往前端实现文件上传到服务端，常用方案为 HTTP 上传或 FTP 上传，但这两种方式均存在明显短板：HTTP 上传易受网络波动影响，可靠性较差；FTP 配置复杂且安全性不足。随着对象存储服务（Object Storage Service, OSS）的普及，这一问题得到了有效解决。 对象存储（基于对象的存储）是一种专为海量非结构化数据设计的存储架构。与传统存储不同，它将数据封装为独立对象，捆绑元数据和唯一标识符，便于快速查找与访问。OSS 提供与平台无关的 RESTful API 接口，支持在任意应用、任意时间、任意地点存储和访问各类数据。

目前主流的开源 OSS 方案包括 MinIO和Ceph。其中 MinIO 凭借轻量、易用、兼容 S3 接口等优势，使用率持续攀升，成为开源对象存储的首选方案之一。本文将详细介绍如何基于 JavaScript/TypeScript 前端实现文件上传到 MinIO。

1. 使用Apt安装

sudo apt update; sudo apt upgrade;
sudo apt install cmake;

使用apt安装

sudo apt-get -y update
sudo apt-get -y install coturn

什么是AssetBundle

AssetBundle 为资源的集合，可包含贴图(Textures)，材质(Materials)，声音(Audio)，动画资源(Animation Clips & Animator controllers)，文字(Text assets)，甚至场景(Scenes) 等各式资源，允许游戏在运行时向远端服务器(Remote server)，要求载入AssetBundle 并且使用里头的资源。

因此可以利用AssetBundle 功能来制作关卡更新资源包，下载新的关卡资源，即是DLC (Downloadable content)。亦可用来更新游戏，例如特殊节庆时，更新游戏贴图材质，让游戏与玩家一同过节。

UnityEngine.Application' does not contain a definition for bundleIdentifier'

把 Application.bundleIdentifier修改为Application.identifier。

升级粒子系统

Unity2018.2.x之后，旧版 Particle System 相关API就完全移除掉了，这个升级器是Unity官方发布的，它可以ParticleEmitter, ParticleAnimator, ParticleRenderer等组件转换为ParticleSystem 和 ParticleSystemRenderer组件。

用户画像的3种标签类型

用户画像建模其实就是对用户“打标签”，从对用户打标签的方式来看，一般分为3种类型：①统计类标签；②规则类标签；③机器学习挖掘类标签。

下面我们介绍这3种类型的标签的区别：

1. 统计类标签

   这类标签是最为基础也最为常见的标签类型，例如，对于某个用户来说，其性别、年龄、城市、星座、近7日活跃时长、近7日活跃天数、近7日活跃次数等字段可以从用户注册数据、用户访问、消费数据中统计得出。该类标签构成了用户画像的基础。

2. 规则类标签

   该类标签基于用户行为及确定的规则产生。例如，对平台上“消费活跃”用户这一口径的定义为“近30天交易次数≥2”。在实际开发画像的过程中，由于运营人员对业务更为熟悉，而数据人员对数据的结构、分布、特征更为熟悉，因此规则类标签的规则由运营人员和数据人员共同协商确定；

3. 机器学习挖掘类标签

   该类标签通过机器学习挖掘产生，用于对用户的某些属性或某些行为进行预测判断。例如，根据一个用户的行为习惯判断该用户是男性还是女性、根据一个用户的消费习惯判断其对某商品的偏好程度。该类标签需要通过算法挖掘产生。

这篇博文将会逐步介绍如何使用 PgBouncer 连接池来改进 PostgreSQL 数据库服务器架构连接管理、减少 PostgreSQL 服务器上的负载并提高性能。

以下是我们在本文中将要讲解的内容的细分主题：

• PostgreSQL 数据库服务器如何工作
• 使用 PgBouncer 池化器提高效率
• 如何安装和配置 PgBouncer

Sass在v4.3.0版本之前使用node-sass需要原生编译libsass导致的问题

Sass在v4.3.0版本之前都是使用的node-sass，而node-sass的底层依赖 libsass，libsass是一个原生库，因此，在Windows下面需要强制用户必须安装python2和Visual Studio才能编译成功。这并不是一件很友好的事情，而且经常导致编译不成功。

引擎列表

介绍

Flutter 上的 WebRTC 通常通过flutter_webrtc 库实现，该库包含 Flutter 支持的所有平台所需的 WebRTC 代码。该插件抽象出了 WebRTC 中几个难以实现的部分，本文构建的应用程序基于插件中给出的示例代码。

在本教程中，我们将向 Flutter 应用程序添加基于 WebRTC 的通话解决方案。

设置 flutter_webrtc 插件

必须设置各种组件才能实现完整的视频通话体验。第一个是将基础 WebRTC 插件添加到您的 Flutter 应用。在本课中，我们仅关注 Android 和 iOS，但请注意，可能需要进行额外设置才能在其他平台上设置类似的体验。

1. Linear Scan（线性扫描）
2. Binary Search（二叉查找）
3. Hopscotch Selection（跳房子）
4. Alias Method（别名方法）

Linear Scan（线性扫描）

Binary Search（二叉查找）

Hopscotch Selection（跳房子）

Walker-Vose Alias Method（别名方法）

别名采样方法分为两个步骤：

1. 做表；
2. 根据表进行采样。

BI的定义

BI全称：商业智能（Business Intelligence），在传统企业中，它是一套完整的解决方案。将企业的数据有效整合，快速制作出报表以作出决策。商业智能BI在数据架构中处于前端分析的位置，其核心作用是对获取数据的多维度分析、数据的切片、数据的上钻和下钻、cube等。通过ETL数据抽取、转化形成一个完整的数据仓库、然后对数据仓库的数据进行抽取，而后是商业智能的前端分析和展示。

BI的用途

BI工具主要有两种用途。一种是利用BI制作自动化报表，数据类工作每天都会接触大量数据，并且需要整理汇总，这是一块很大的工作量。这部分工作可以交给BI自动化完成，从数据规整、建模到下载。

大数据时代，数据的来源极其广泛，各种类型的数据在快速产生，数据也是爆发性增长。从数据的产生，通过加工融合流转产生新的数据，到最终消亡，数据之间的关联关系可以称之为数据血缘关系。在数据中台的大背景下，数仓的开发者经常需要解决以下问题：

面对成百上千张的数据表，不知道该如何关联，也不知道这些表具有什么业务价值

执行过长，慢的无法忍受的SQL脚本，却不敢轻易进行整改

数据表是否包含机密数据需要被清理，以及这些机密数据是否被转存导致权限放大

其实，以上的这些问题都可以统一归类为数据发现问题。大部分企业会针对离线数仓任务进行SQL分析，构建表和字段的血缘关系，数据发现包括但不限于: 数据 表/列的业务分类分级和机密字段识别等。

如果有留意独立游戏，应该不时会看到「Roguelike」或「Roguelite」等字眼，我们介绍过的独立游戏中亦不乏此类作品。下文会为大家科普「Roguelike」的种种，以后看到游戏介绍中有这些字眼时，便知道是否自己想玩的类型了。

《Rogue》的诞生

原来「Roguelike」并不是一个生字，而是由「Rogue」及「like」两字组成，指的是「像Rogue的游戏」。《Rogue》，全名《Rogue: Exploring the Dungeons of Doom》，是由Michael Toy 和Glenn Wichman开发的地下城冒险游戏，当时两人都是加州大学克鲁兹分校的学生。

简单是一件非常困难的事！而深思熟虑的简单，可以给我们与学习最多的思考

Protocol Buffer 的第 3 版删除了一些特性（required, optional...），并且在默认值的设计上，做出了一个看起来很危险的重要决定。乍看之下匪夷所思，网路上也引起多人讨论。通常这种去掉重要功能的决定，都有非常的理由，尝试理解别人的设计，可以让我们看得更远。现在，就让我们尝试从google的角度，思考一下Protocol Buffer的设计吧！

查看网卡名称

ifconfig

使用下面的命令清理镜像：

docker system prune

安装Flutter

scoop install flutter

Docker Desktop安装不了，只能安装Docker Toolbox。

通过国内镜像站下载：

• 阿里云：https://mirrors.aliyun.com/docker-toolbox/windows/docker-toolbox/
• DaoCloud： https://get.daocloud.io/toolbox/

列出WSL子系统

wslconfig /list
wsl --list
wsl -l -v

为了生计所迫，有时候不得不需要在WSL2下面使用代理。

获取到宿主的访问IP地址

WSL2要访问宿主的服务，并没有那么容易，并不能简单的通过127.0.0.1来访问，需要获取到宿主的访问IP地址。有两种办法可以访问宿主的IP：

1. cat /etc/resolv.conf命令获取nameserver；
2. 如果安装了Docker，可以获取host.docker.internal。

推荐使用第一种方法。

配置代理