<div class="markdown-text"><p>RT.</p>
<p>请大家遵守法律法规，勿发布不合规内容。</p>
<ul>
<li>2021/11/26：针对部分打擦边球的推广行为（如各种云服务商的推广链接），将会对账户做出屏蔽处理。</li>
<li>2021/11/26：针对机器人频繁发布广告与违规内容，新增发帖限制如下：新用户五天内不允许发帖（不影响回帖）。</li>
</ul>
</div>

【2021/11/26】请大家遵纪守法，勿发布不合规内容

<div class="markdown-text"><p><a href="https://registry.npmmirror.com">https://registry.npmmirror.com</a> npmmirror 镜像站在2013年12月开始就使用基于 koa 的 <a href="https://github.com/cnpm/cnpmjs.org">https://github.com/cnpm/cnpmjs.org</a> 私有 npm 应用搭建，这些年 node 应用框架在快速换代升级，连我们自己造的 egg 都要升级到 TypeScript 了，所以在 2021 年我们启动了 <a href="http://cnpmjs.org">cnpmjs.org</a> 的技术升级重构，基于 egg 的 TypeScript 模式重新实现 <a href="https://github.com/cnpm/cnpmcore">https://github.com/cnpm/cnpmcore</a> 。</p>
<p>npm registry 的接口是 100% 实现迁移，然后在数据同步上通过数据库实现足够简单的任务系统，已经在 2022年1月30日完全老数据迁移。
非常感谢阿里云这么多年来的对中国 npm 镜像云服务器的开源赞助，只能靠仅有的广告位和每年的感谢帖子来回报这份天价的云资源账单。这一次重构之后，我们验证下来至少可以节省一半的云服务器资源，也算是让阿里云的开源赞助可以减轻一些成本负担。</p>
<p>当然 cnpmcore 不仅仅是为了技术升级，我们的核心新能力会跟随 npmfs 黑科技在 2022 年发布出来，到时候 npm install 的安装速度会在 cli 侧和 registry 侧同时发力，让 npm 模块安装速度在可预见的未来达到秒级。</p>
<p>PS：预估你在此期间遇到包数据同步和丢失问题，请先手动同步一次，如果还是没有，请回帖反馈给我们。</p>
</div>

npmmirror 镜像站升级公告

<div class="markdown-text"><p>很多人觉得Node.js没有往年那么火了，事实上不是这样的，Node.js社区健康稳步的发展中，主要是从性能好向好用转变，在易用性上有很大提升，从Node.js源码更新的内容看，大抵如此。Node.js Diagnostics Working Group是近二年Node.js社区的重点工作组，Node.js 14版本之后的大部分功能特性都是这个工作组推动的。早在2015年，有2个跟踪工作组tracing WG 和事后分析工作组 postmortem WG，在2017年合并到Diagnostics WG。核心产出是async_hooks, profiling, tracing, dump debug, report等，都是在易用性和好用性上做提升。让每个Node.js开发者更低门槛的提升Node.js应用的开发体验。</p>
<p>秦粤老师在《浮华过后的Node.js》分享里，也表达了同样观点，他用的是产品化平缓期，也是健康稳步的发展的意思。</p>
<p><img src="//static.cnodejs.org/FqRK1Uehhaz3lFDF3oHeL97Z7zYm" alt="image.png"></p>
<p>社区方面，Web框架已经没有多少空间，以特性取胜的框架，应该不会很多，比较期待Egg3。像fastify这种，修改Node.js机制，在性能领域深耕的框架，目前看是比较有作为的。pnpm是有创新的，但代码是有点可读性不太好。我更加喜欢rushstack对menorepo的改进，大规模编程范式还需要探索。除了去年提的midway-hooks，easy-monitor，看起来remix和morden算新，但还没有超出之前的范畴。</p>
<p>下面结合《<a href="https://nodersurvey.github.io/reporters">Node.js开发者2021报告</a>》内容，我们详细解读一下Node.js 2021年的情况。这份解读是根据冰森&amp;狼叔直播内容整理的，要点如下。
​</p>
<h3>1）开发框架变化较大，造轮子变少，TS变多，使用企业级框架变多</h3>
<p>​</p>
<p>去年express占比还非常高，今年企业级框架变多，尤其是大而全的框架更受欢迎。</p>
<p><img src="//static.cnodejs.org/Fl-QFKuag-dvFGbx7Q45WabMH5d8" alt="image.png"></p>
<p>Egg在国内普及率很高，而Midway和Nest增长较快，其实和TS普及有一定关系。
​
<img src="//static.cnodejs.org/FvoNa6PGZJN1ZaqZlmXZuRnNUI5_" alt="image.png">
​</p>
<h3>2）版本更新变化较大，从Node 12升级到Node 14，升级比较积极</h3>
<p>​</p>
<p>去年Node.js主要是使用Node 12，2021年Node 14占比将近一半，更新还是较快的。</p>
<p><img src="//static.cnodejs.org/FpQcq4qzd9rl-R-VEXzLZAiVMPaa" alt="image.png">
​</p>
<h3>3）吐槽变多，意味着用的人变多，趋于成熟</h3>
<p>​</p>
<p>C++之父Bjarne Stroustrup说过：世界上只有两种编程语言,一种是整天被人骂的,还有一种是没人用的。
​</p>
<p>大家对Node.js吐槽变多，实际上是在应用场景上使用较多，不再是针对于某些特性而进行吹捧。回归理性，在真实应用场景上，分布广泛，核心围绕API和BFF层，CLI&amp;工具。
​
<img src="//static.cnodejs.org/FkEeeI7hvEdSMIyUNaKxnQx9pzcJ" alt="image.png"></p>
<h3>4）出圈：年龄分布较去年比变大，使用工种也变得比较丰富。</h3>
<p>除了应用场景上，分布广泛外，非前端意外的开发者相关角色也有很大比例的提升，比如架构师，技术总监，项目经理等都一定程度上使用Node.js。可以说Node.js走出了前端圈，面向更大群体提供服务。另外受访者的年龄分布也变大了，这和出圈是有直接关系的。
​
<img src="//static.cnodejs.org/FsnHAf1Map8P8i4bEAn89POQf_8E" alt="image.png"></p>
<h3>5）使用困惑：性能优化，内存泄漏以及npm依赖</h3>
<p>​</p>
<p>以往对Node.js困惑最多的是异步流程控制，随着async/await的普及，这个问题已经慢慢在弱化。随着开发者使用Node.js深度增加，对性能优化，内存泄漏更为关注，这也是比较容易理解的。</p>
<p><img src="//static.cnodejs.org/FkPiwL5U9kbNq1vUE1J8AQKn54z4" alt="image.png"></p>
<p>​</p>
<h3>6）未来：从业经验越高则越关注性能和 Serverless</h3>
<p>​</p>
<p>关注性能比较容易理解，关注Serverless最主要是的原因是Serverless可以做到低运维甚至是0运维。运维作为Node.js开发者必备技能，Serverless的出现使得很多非专业Node.js也能轻松搞定Node.js各种服务端场景。</p>
<p><img src="//static.cnodejs.org/FjZSOZ1uO-Tqh8yTL2E4CtvMUFbN" alt="image.png"></p>
<p><img src="//static.cnodejs.org/FshPaWkMvnMKMxJckqf0L-M5OYe1" alt="image.png"></p>
<h3>推荐阅读</h3>
<ul>
<li>天猪《EggJS 的前世今生与未来》，比较期待Egg3，easy-monitor作者一君也加入Egg3项目组了 <a href="https://www.yuque.com/atian25/blog/egg-1to2to3">https://www.yuque.com/atian25/blog/egg-1to2to3</a></li>
<li>秦粤 《浮华过后的Node.js》链接稍后给出来</li>
</ul>
<h3>参考</h3>
<ul>
<li>原文  <a href="https://cnodejs.org/topic/6108bbc2a5d29d175c2d4208">https://cnodejs.org/topic/6108bbc2a5d29d175c2d4208</a></li>
<li>报告 <a href="https://nodersurvey.github.io/reporters">https://nodersurvey.github.io/reporters</a></li>
</ul>
<p>如果大家想参与讨论，欢迎回复</p>
</div>

Node.js 2021年开发者报告解读：健康稳步的发展中

<div class="markdown-text"><h2>概述</h2>
<p>Node.js 刚刚发布了 18.0.0 版本，内置了 <code>fetch</code>、<code>node:test</code> 等标准模块。</p>
<p><strong>一句话点评：std lib 在标准化，user lib 在精细化。</strong></p>
<blockquote>
<p>原文地址：<a href="https://zhuanlan.zhihu.com/p/502951532">EggJS 知乎专栏</a>，求点赞。</p>
</blockquote>
<hr>
<h2>如何快速体验</h2>
<p>推荐用 <a href="https://github.com/Schniz/fnm">fnm</a>，<a href="https://github.com/jasongin/nvs">nvs</a>，<a href="https://github.com/nvm-sh/nvm">nvm</a> 等 Node.js 版本管理器。</p>
<pre class="prettyprint language-bash"><code>$ fnm install 18
Installing Node v18.0.0 (arm64)

$ fnm use 18
Using Node v18.0.0

$ node -v
v18.0.0
</code></pre><p>需要注意的是，该版本不是 LTS 版本，请勿在生产环境使用，需要等到 2022-10-25 才会成为 LTS 版本。</p>
<p><img src="https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/012135a1091b40ef807c8b6e3919bcce~tplv-k3u1fbpfcp-zoom-1.image" alt="image.png" title="https://github.com/nodejs/Release"></p>
<h2>Looking to the future</h2>
<blockquote>
<p>The project is also continuing its ‘Next 10’ effort.  The goal of this effort is to reflect on what led to success in the first 10 years of Node.js and set the direction for success in the next 10.</p>
</blockquote>
<p>Node.js 官方启动了 <a href="https://github.com/nodejs/next-10">next-10</a> 工作，并讨论出了<a href="https://github.com/nodejs/node/blob/master/doc/contributing/technical-priorities.md">未来重要的几件事</a>：</p>
<ul>
<li>现代化的 HTTP</li>
<li>友好的类型支持</li>
<li>对初学者更友好的渐进式文档</li>
<li>对 ECMAScript 规范的支持和及时跟进</li>
<li>可观测性，包括 logging/metrics/tracing，以及 APM 等</li>
<li>更好的多线程支持</li>
<li>支持打包为单文件的分发方式</li>
</ul>
<p>譬如前面说的 Fetch 就和 Modern HTTP 的会议讨论有关，<a href="https://github.com/nodejs/next-10/blob/main/meetings/summit-jan-2022.md">相关纪要</a>。</p>
<blockquote>
<p>6 月份的 OpenJS World 会议中将分享 ESM 和 Observability 进展，可以关注下相关动态。</p>
</blockquote>
<hr>
<h2>Fetch API</h2>
<p>前端同学应该都很熟悉<code>fetch()</code>这个 API，它提供了标准的网络请求能力，取代了远古的  XMLHttpRequest 。</p>
<p>反观 Node.js 侧，官方提供的 <a href="https://nodejs.org/dist/latest-v18.x/docs/api/http.html#httprequesturl-options-callback">http.request()</a>，太底层太基础了，用起来往往需要大量的封装。譬如 302 后自动跳转、文件上传、响应结果解析等等。</p>
<p>因此在 Node.js 社区有非常多的上层请求库封装：</p>
<ul>
<li>曾经广受社区欢迎的 request 库去年<a href="https://github.com/request/request/issues/3142">宣布停止维护</a>后，也引起了社区比较大的混乱。。</li>
<li>我们 Egg 内置的是 <a href="https://www.npmjs.com/package/urllib">urllib</a>，沉淀了阿里多年在网络请求上踩的坑，足够稳定，不过代码也有点久远了。</li>
<li>更多参见 <a href="https://github.com/request/request/issues/3143">Alternative libraries to request</a> 以及 <a href="https://zhuanlan.zhihu.com/p/415361629">《天猪：那些你应该说再见的 npm 祖传老库》</a>。</li>
</ul>
<p><strong>去年 Node.js 官方推出了 <strong><a href="https://undici.nodejs.org/"><strong>undici</strong></a></strong>，一个非常现代化的库，具备优越的性能，良好的扩展性，内置的 mock 等能力，集大成者。</strong></p>
<blockquote>
<p>undici 的命名也很有趣：A HTTP/1.1 client → 11 → Eleven → Undici，即意大利语的 11。</p>
</blockquote>
<p>从而 <strong>Node.js 终于内置了新的请求库</strong>，它遵循 <a href="https://fetch.spec.whatwg.org/">Fetch 规范</a>，底层就是基于 undici 来实现的。</p>
<pre class="prettyprint language-javascript"><code>const res = await fetch(&#x27;https:&#x2F;&#x2F;nodejs.org&#x2F;api&#x2F;documentation.json&#x27;);
if (res.ok) {
  const data = await res.json();
  console.log(data);
}
</code></pre><p>就这么简单，比 <a href="https://nodejs.org/dist/latest-v18.x/docs/api/http.html#httprequesturl-options-callback">http.request()</a> 那一坨 callback-style 代码简洁多了，平时写个脚本啥的，不用再引入额外的类库了。</p>
<p>全局增加了 fetch, FormData, Headers, Request, Response 这几个 API，以及 Web Streams API。</p>
<p>目前还处于默认开启的实验性特性阶段，文档在 <a href="https://nodejs.org/dist/latest-v18.x/docs/api/globals.html#fetch">Globals</a> 章节，近乎没有，有需要直接看 <a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API">MDN 文档</a> 即可。</p>
<p>可能是为了遵循规范， undici 的很多能力如 Mock，Proxy，Pool 等都没有提供出来。</p>
<hr>
<h2>Test Runner</h2>
<p>单元测试很重要，很多新兴的编程语言都是会内置对应的能力，但前端这块一直都是由社区来实现，前端同学耳熟能详的 Test Runner 有 <a href="https://mochajs.org/">Mocha</a>、<a href="https://jestjs.io/">Jest</a>。</p>
<pre class="prettyprint language-javascript"><code>&#x2F;&#x2F; mocha showcase
import assert from &#x27;assert&#x2F;strict&#x27;;

describe(&#x27;test&#x2F;index.test.js&#x27;, () =&gt; {
  it(&#x27;test1&#x27;, async () =&gt; {
    const res = await fetch(&#x27;https:&#x2F;&#x2F;nodejs.org&#x2F;api&#x2F;documentation.json&#x27;);
    assert(res.ok);
  });
  
  it.skip(&#x27;skip some test&#x27;, () =&gt; {});
});
</code></pre><p>终于，Node.js 在 18.x 里官方支持了 <a href="https://nodejs.org/dist/latest-v18.x/docs/api/test.html">Test 能力</a>：</p>
<pre class="prettyprint language-javascript"><code>import test from &#x27;node:test&#x27;;
import assert from &#x27;assert&#x2F;strict&#x27;;

&#x2F;&#x2F; 等价于 describe()
test(&#x27;asynchronous passing test&#x27;, async () =&gt; {
  const res = await fetch(&#x27;https:&#x2F;&#x2F;nodejs.org&#x2F;api&#x2F;documentation.json&#x27;);
  assert(res.ok);
});

test(&#x27;multi level test&#x27;, async (t) =&gt; {
  &#x2F;&#x2F; 等价于 it()
  await t.test(&#x27;subtest 1&#x27;, (t) =&gt; {
    assert.strictEqual(1, 1);
  });

  await t.test(&#x27;subtest 2&#x27;, (t) =&gt; {
    assert.strictEqual(2, 2);
  });
});

&#x2F;&#x2F; 等价于 describe.skip() &#x2F; it.skip()
test(&#x27;skip option&#x27;, { skip: true }, () =&gt; {});

&#x2F;&#x2F; 等价于 describe.only() &#x2F; it.only()
test(&#x27;only option&#x27;, { only: true }, () =&gt; {});
</code></pre><p>可以看到：</p>
<ul>
<li>语法其实差不多，会更简洁一点，就一个 <code>test()</code>，options 除了 skip 和 only 外，还支持 concurrency 并发。</li>
<li>无需启动器，每一个文件都是一个可执行的 Node.js 代码。</li>
<li>暂未支持 <code>before/after/beforeEach/afterEach</code> 能力，看 issue 描述会后续支持。</li>
<li>暂未支持 Reporter，但日志输出为标准 <a href="https://testanything.org/">TAP</a> 格式，所以应该很容易能复用现有的社区生态。</li>
</ul>
<p>类似覆盖率的演进过程，以前我们需要通过 nyc 对代码转译打桩，现在变为的 Node.js 内置覆盖率输出，nyc 变为 c8 这样的覆盖率报告生成工具。</p>
<p>后续 mocha 等估计会变为类似的上层封装，提供批量执行 和 Reporter 等能力。</p>
<hr>
<h2>Build-time user-land snapshot</h2>
<p>简单的说，可以把某个 js 直接编译成 v8 snapshot，从而可以极大的提速启动时间。</p>
<p>目前这个版本，还只能通过 Node.js 源码来编译，且只能编译成 Node.js Runtime 的方式，即 Build-time。</p>
<pre class="prettyprint language-bash"><code># 把一段 markdown 渲染的逻辑，直接打包到 Node Runtime
$ cd &#x2F;path&#x2F;to&#x2F;node&#x2F;source
$ .&#x2F;configure --node-snapshot-main=marked.js
$ make node

# 执行编译好的 Node Runtime
$ out&#x2F;Release&#x2F;node
&gt; const html = globalThis.marked(&#x27;# this is title&#x27;);
</code></pre><p>秋怡正在继续推进<a href="https://github.com/nodejs/node/issues/35711">该能力</a>，未来可以无需编译 Node.js 源码：</p>
<pre class="prettyprint language-bash"><code>$ node --build-snapshot --snapshot-blob marked.blob marked.js 
$ node --snapshot-blob marked.blob
</code></pre><p>PS：这个能力用在命令行 CLI 的独立打包好像也不错。<a href="https://github.com/nodejs/node/issues/42566">https://github.com/nodejs/node/issues/42566</a></p>
<hr>
<h2>V8 引擎升级</h2>
<p>内置的 V8 引擎升级到 10.1 版本，值得注意的特性：</p>
<ul>
<li>class fields 和 private class methods 的性能优化。</li>
<li><a href="https://v8.dev/blog/v8-release-99#intl.locale-extensions">Intl 规范</a> 的支持，在做日期的本地化，字符串处理的时候非常有用。</li>
<li>数组支持 findLast() 和 findLastIndex() 等。</li>
</ul>
<p>秋怡也写了一篇文章 <a href="https://v8.dev/blog/faster-class-features">Faster initialization of instances with new class features</a> 分享了背后的实现。</p>
<p>PS：<a href="https://mp.weixin.qq.com/s/6PTcjJQTED3WpJH8ToXInw">ECMAScript 双月报告：装饰器提案进入 Stage 3</a> ，阿里的 Node 架构团队今年会推动 Decorator 方案在 V8 的落地实现，不过肯定赶不上了，只能 Node.js 20.x 见了。</p>
<hr>
<h2>ESM 的支持</h2>
<p>虽然在 18.x 中没有新的内容，但在过去的几个月中一直在持续推动 ECMAScript模块实现：</p>
<ul>
<li>对 <a href="https://github.com/tc39/proposal-import-assertions">JSON Import Assertions</a> 的支持。</li>
<li>JSON 模块的正式支持。</li>
<li>对 HTTPS 和 HTTP 导入的实验性支持。</li>
<li><a href="https://github.com/nodejs/loaders">Node.js 加载器团队</a>也在继续开发 ECMAScript 模块加载器实现。</li>
</ul>
<hr>
<h2>工具链和编译器的升级</h2>
<ul>
<li>Linux 版是在 RHEL8 上构建的，要求 glibc 2.28 以上版本。</li>
<li>macOS 要求 10.15 以上版本。</li>
<li>Windows 很多旧版本也不支持了。</li>
</ul>
<p>PS：CentOS 7 官方不再维护了，它对应的 glibc 版本太低，所以升不了。。。</p>
<ul>
<li><a href="https://developer.aliyun.com/article/780803">centos7和8不维护停止更新之后，服务器选择使用什么系统好？</a></li>
<li><a href="https://github.com/nodejs/node/pull/42659">doc: update minimum glibc requirements for Linux by richardlau</a></li>
</ul>
<hr>
<h2>相关资料</h2>
<ul>
<li><a href="https://nodejs.org/en/blog/announcements/v18-release-announce">https://nodejs.org/en/blog/announcements/v18-release-announce</a></li>
<li><a href="https://nodejs.org/en/blog/release/v18.0.0/">https://nodejs.org/en/blog/release/v18.0.0/</a></li>
</ul>
</div>

Node.js 18 新特性解读

<div class="markdown-text"><p>继 2019 年开源 Midway 框架之后，阿里一直在 Node.js 的前沿进行深度研究，除了加入 TC39 参与标准化建设，向上游 Node.js 项目持续贡献，与龙蜥社区合作优化之外，也在 Serverless 领域有了不小的成果。</p>
<p>今天，向大家介绍我们最新的面向云原生场景，面向 Serverless 架构下的新产品， 代号 <strong>Noslate</strong>。</p>
<h2>Noslate 是什么？</h2>
<p>欢迎访问项目了解更多内容：<a href="https://github.com/noslate-project/noslate">Noslate</a>
<img src="https://gw.alicdn.com/imgextra/i4/O1CN01hh1Db41sqh60CiNhD_!!6000000005818-2-tps-1324-390.png" alt="Noslate">
JavaScript 是开发者数量最庞大的编程语言，早些年 Node.js 等技术的出现，让 JavaScript 可以轻松地处理各类服务端任务。</p>
<p>但随着云原生/Serverless 等新架构概念的引导，弹性效率成为了全新的架构设计目标。为了能够让 JavaScript 任务拥有更高的弹性效率，进而满足在泛终端、全栈交付等领域的效率期待。我们逐步深入探索的过程中逐渐形成了 Noslate Project，旨在提升云原生场景下 JavaScript 的被调度性能，解决诊断性黑盒问题。</p>
<p>Noslate 它主要由三个子项目组成，分别体现了我们在提升 Javascript 任务弹性效率过程中碰到的问题以及解决方式：</p>
<ol>
<li>Node.js Distribution：初期针对函数计算冷启动场景优化，降低 Node.js 用户代码加载耗时，形成了针对性的 Node.js 发行版本。</li>
<li>Noslate Workers：随着探索的深入，我们设计了面向轻量端云同构场景的 W3C Web-interoperable JavaScript 轻量化容器方案。在交付灵活度上和资源、执行效率上形成平衡，现在主要应用于中心化的 SSR 渲染等轻量任务场景，效果显著。</li>
<li>Noslate Debugger：在落地业务过程中，我们发现在弹性效率提升后，对于异常和崩溃变得难以定位，得益于 Linux 系统 Coredump 机制的启发，我们设计了基于 Corefile 对问题进行离线诊断的 Noslate Debugger 产品，帮助用户实现问题的回溯和实时定位。</li>
</ol>
<p>简而言之，Noslate 目标是通过提供完整的技术产品方案， 将 JavaScript 打造成云原生时代最灵活的交付语言。</p>
<h2>为什么开源？</h2>
<p>一方面我们希望通过开源加强项目产品化程度；另一方面希望在社区中吸收更多的实践场景进而继续完善产品设计，也欢迎大家参与到项目中来。
同时，依托阿里云龙蜥社区和 Anolis 操作系统的合作关系，我们得以在底层探索，实现技术的演进。</p>
<h3>一、Noslate Workers</h3>
<p><img src="https://gw.alicdn.com/imgextra/i4/O1CN01L6QLHh1NRjQD5l5PE_!!6000000001567-2-tps-1270-339.png" alt="Noslate Workers">
W3C Web-interoperable 运行时 Aworker，提供了一个轻量，近乎 0 冷启动的 JavaScript Serverless 运行环境。通过它，可以轻松的在已有的架构中集成轻量化类 Serverless 的能力。
<img src="https://gw.alicdn.com/imgextra/i2/O1CN015XmQ8e20OlsVamGdC_!!6000000006840-2-tps-1729-672.png" alt="Noslate Workers 架构">
与传统的 FaaS 架构不同，这是一个在普通应用容器之上的轻量任务单位。得益于良好的动态任务高密度混部和隔离特性、以及基于任务状态拷贝 API 带来的近乎 0 冷启动特性，可以实现任务的即用即启与即停即抛，进而无需关心在整个大集群中任务节点的编排问题。
与既有架构的关系：
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01hwla1u1WSUch3qhT0_!!6000000002787-0-tps-3337-1879.jpg" alt="弹性架构分层">
Noslate Workers 由两个主要组件组成：</p>
<ol>
<li>Aworker - 轻量、Web-interoperable JavaScript Runtime</li>
<li>Noslated - Serverless 化的 Aworker 调度管控实现</li>
</ol>
<h4>关于 Aworker</h4>
<p>提供 Web API 标准的 Web-interoperable JavaScript 运行时，适合不直接依赖系统接口的业务逻辑部署。 Aworker 实现了近似 <a href="https://www.w3.org/TR/service-workers/">Service Worker API</a> 的规范，提供了基本的 <a href="https://www.w3.org/TR/service-workers/#fetchevent">Request-Response</a> 服务 API。
因为提供了相比于 Node.js 的 API 更加高层次、抽象的定义，不会泄漏系统底层状态，Aworker 通过 Startup Snapshot 和 Warmfork 能力， 实现了更快的水平及垂直扩容，能够在毫秒级启动并处理流量，具备更高的弹性效率。</p>
<h5>亮点特性一、Warmfork</h5>
<p>熟悉 Linux 系统编程的同学都知道 fork(2) 系统调用有几个优势：</p>
<ol>
<li>新进程可以继承母进程的当前状态，而无需从 main() 开始初始化；</li>
<li>pcb、栈、内存页，页表都是纯内存复制，所以进程创建快 (&lt;1ms)；</li>
<li>CopyOnWrite，新进程可以继承母进程的静态页表，可节省系统内存；</li>
</ol>
<p>对于 Node.js 来说，因为其无法在主线程持有所有多线程的状态 (如锁，信号量等)，所以 Node.js 进行 fork 的修改难度很大。其多线程设计主要 来源于 libuv 库和 V8 Platform Worker 线程：</p>
<ol>
<li>因部分 IO 操作存在同步调用，如 dns，文件读写等，所以 libuv 使用 IO 线程将同步操作转换成异步操作；</li>
<li>Node.js 的 V8 默认配置为多线程 GC、Background Compilation/Optimization 的方式；</li>
</ol>
<p>Node.js 的单进程多线程模型可以由下图表示：
<img src="https://gw.alicdn.com/imgextra/i1/O1CN01f3vkhU1gZxESjIBhq_!!6000000004157-2-tps-767-267.png" alt="Node.js 单进程多线程模型">
Aworker 的设计是采用单进程单线程的模型，也就是将上述模型中的 worker thread 单独抽出放到一独立进程中。Worker 因此可支持 fork，从而避免从 main() 开始的启动消耗，达到快速启动的目的。
<img src="https://gw.alicdn.com/imgextra/i1/O1CN01vaKK3b1NniQw29c7a_!!6000000001615-2-tps-734-266.png" alt="Aworker 单进程单线程模型">
为了支持单线程，Aworker 还做了如下修改：</p>
<ol>
<li>使用了 Linux AIO 特性替掉了 libuv 中同步的文件系统操作（不是 POSIX AIO，两者有区别。Posix AIO 类似于 libuv 现有的实现）；</li>
<li>使用 V8 的 SingleThread 模式，这是一个给低端设备（Low-end devices）实现的能力，不过非常符合 Serverless 资源模型；</li>
</ol>
<p>而为了管理、隔离这些工作进程，我们设计了一个轻量的业务进程容器管理组件 Turf ，该组件能通过 Warmfork 方式创建新的 Aworker 服务进程，并能提供一定的资源、环境的隔离能力，同时兼容 OCI。区别于传统 runc, rund 的容器，turf 旨在承载如 Aworker 这类轻 JS Runtime，它无需镜像运行，开销更低，可以支持更高的部署密度。</p>
<p>Warmfork 具体的对比：
<img src="https://gw.alicdn.com/imgextra/i2/O1CN01cLR5kd1JGVFa2tPic_!!6000000001001-2-tps-480-391.png" alt="warmfork">
提供 “被复制” 的进程，称为 “种子进程”，其他服务进程都是该进程的克隆。譬如 Aworker 作为种子进程，它需要确定自己一个 “可被克隆” 的时间点，将自己的所在状态（内存）作为克隆进程的初始状态。</p>
<p>Warmfork 的系统时序如下：
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01dTl9w71ZcW8TdBOon_!!6000000003215-2-tps-675-386.png" alt="warmfork 时序"></p>
<h5>亮点特性二、Startup Snapshot</h5>
<p>Warmfork 能实现了单机上服务进程的快速启动，而对于优化冷机启动加载速度，需要采用 Startup Snapshot 方案。
Startup Snapshot 和 CodeCache 的区别在于 Startup Snapshot 能够保存用户代码逻辑执行状态，而 CodeCache 只保存代码解析结果、仍然需要重新执行 用户代码逻辑。</p>
<p>设计上，Startup Snapshot 可提供携带用户代码逻辑的快速恢复，但是也有局限性：</p>
<ol>
<li>Startup Snapshot 对内存开销敏感，如果应用启动阶段用了大量内存，可能造成负优化；</li>
<li>用户代码启动需要没有歧义的状态，比如 IP 地址、日期、连接状态、服务发现结果等，针对这些歧义内容用户代码需要在进程恢复时有修正能力；</li>
</ol>
<p>V8 的 Startup Snapshot Serializer 就是一个类似于 GC 的对象遍历器。这个遍历器通过遍历加入到 Snapshot 中的 Root 对象，遍历它所对应的对象图并按照对象关系生成一系列的反序列化指令。</p>
<p>Startup Snapshot 相当于从 V8 Context 对象与它的 globalThis 开始，遍历堆中所有的对象并将对象关系与引用序列化成 特有的字节码，形成一个线性的可存储状态。并在恢复时，解释执行这些字节码，恢复堆中的对象内容与他们之间的引用关系。
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01VbTxVV1j7xsJEqEGB_!!6000000004502-2-tps-750-390.png" alt="V8 对象">
上述的两类和被调度性能相关的特性被统一归类为状态拷贝 API，具体使用可以参考官网文档中的<a href="https://noslate.midwayjs.org/docs/noslate_workers/aworker/serialize-api">《状态拷贝 API》</a>章节，详细介绍了命令行参数和程序内的 Events。</p>
<h4>Noslated</h4>
<p>Noslate Container Deamon，作为 Noslate Workers 解决方案的核心管控程序，提供了实例调度、弹性扩缩容、配置管理、流量管理等能力。</p>
<p>基于健壮性考虑，它由两个角色组成：控制面（Control Plane）、数据面（Data Plane）
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01OGE8Xk1hEiU0mY4Nw_!!6000000004246-2-tps-2845-1351.png" alt="Noslated 架构">
Noslated 对于实例的管控主要有三个模式：</p>
<ol>
<li>基础模式 - 基于流量的扩缩容</li>
<li>即抛模式 - 运行完即销毁</li>
<li>预留模式 - 面向历史场景兼容，在此不额外展开，详情可以查阅官网<a href="https://noslate.midwayjs.org/docs/noslate_workers/references/scale/#%E4%B8%89%E9%A2%84%E7%95%99%E7%AD%96%E7%95%A5">【预留策略】</a>。</li>
</ol>
<h5>一、基础模式</h5>
<p>当流量进入 Data Plane 后，如果没有能够处理请求的 Worker 实例，会通过 requestQueueing 事件通知 Control Plane，它会根据当前水位决定扩容数量，如果当前已无法创建 Worker 实例，会返回资源上限报错。新的 Worker 实例启动后，会自动连接到 Data Plane，Data Plane 发现新的 Worker 实例连接后会主动触发初始化请求，初始化成功后开始消费请求队列里堆积的请求。</p>
<p>当 Worker 实例闲置一段时间后，Control Plane 会主动发起 GC 操作，告知 Data Plane 关闭流量，流量关闭后，Control Plane 会通知 Turf 关闭 Worker 实例，清理资源残留。
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01TWklUC1OusEnQ5ENK_!!6000000001766-2-tps-1207-1020.png" alt="基础弹性模式"></p>
<h5>二、即抛模式</h5>
<p>针对特定的灵活场景，一次性的轻量用户脚本执行（比如特别高密度的混部执行二方任务如 SSR），为了隔离不同请求间的上下文，可以针对每个请求创建一个实例，并在执行后销毁。
<img src="https://gw.alicdn.com/imgextra/i3/O1CN01k7ZGMG1DHWQzoQWSV_!!6000000000191-2-tps-1207-1020.png" alt="即抛模式">
在常规 Node.js 实例带上业务逻辑启动一般都不会太快，如果直接用于响应用户流量 RT 会难以接受。得益于 Aworker 运行时的 Warmfork 以及 Startup Snapshot 能力，把部分业务初始化逻辑放置到 Warmfrok 特性中，进而让新实例都是更快的启动并具备响应能力，这才让高密度混部二方任务成为可能。</p>
<h2>二、Noslate Debugger</h2>
<p><img src="https://gw.alicdn.com/imgextra/i1/O1CN010OWgpL1yU9IWuE5XG_!!6000000006581-2-tps-1270-339.png" alt="Noslate Debugger">
Noslate Debugger 是针对 V8 应用的离线分析工具，它可以分析 Node.js 等应用程序产生的 Corefile (Core 文件)：</p>
<ol>
<li>检查 Node.js/V8 应用程序的结构体、堆栈等内容</li>
<li>检查 V8 堆内的各种对象信息</li>
<li>从 Corefile 中导出 Heap Snapshot</li>
<li>业务无感获取 Corefile (通过 Arthur 工具)</li>
<li>已支持 Node.js / AWorker LTS 官方发行版</li>
</ol>
<p>为了更好的解决问题而不是造轮子，在未来的几个月 Noslate Debugger 也会和国内社区 Node.js 稳定性领域优秀的开源软件 Easy Monitor 共建整合，在 Node.js/V8 的问题诊断领域形成合力，也是值得期待的事情。</p>
<h5>优点一：基于 Corefile 的 “快照” 更适应 Serverless</h5>
<p>Serverless 应用通常会使用大量生命周期短、规格小的任务实例，但在此类任务实例上获得调试诊断能力并不容易，这使得 Serverless 应用长期处于较为黑盒的窘境。比如，Inspector 需要稳定和长时的网络连接、运行时 Heap Snapshot 需要较多的计算和内存资源，都是和 Serverless 架构背道而驰的。</p>
<p>不管是 V8 的对象还是堆快照，它都是 “信息” 在内存中的存储，而 Inspector 功能就是可以在 “运行时” 能提取这些信息。Noslate Debugger 通过 Corefile 将这部分调试诊断能力转移到了离线时进行，让原有实时性要求高的在线诊断调试转化为只需简单文件上传即可集成使用。</p>
<p>在用户本地或云端服务上提供接近用户本地开发时的调试诊断体感：
<img src="https://gw.alicdn.com/imgextra/i2/O1CN01OCIltT1LGcaAR4r8G_!!6000000001272-2-tps-861-519.png" alt="调试流程"></p>
<blockquote>
<p>Corefile (特指 GNU Corefile 格式) 主要记录的是 Node.js 进程的内存和寄存器转储(CoreDump: 内存到磁盘的过程)。所以它也是进程完整“信息”，被用于 Linux 系统应用 Crash(有损) 的调试载体，也可用于 GCore(无损) 产生进程快照用于离线分析。</p>
</blockquote>
<h5>优点二：更小的业务影响​</h5>
<p>对比原有线上 “堆快照” 对业务的影响长达数分钟，到只影响业务 RT 秒级（通过 GCore），甚至只有几十毫秒 （通过 Arthur 工具）。Corefile 快照也不会有任何运行时的&quot;添油加醋&quot;，所以它也适合那些还未被GC的对象定位，譬如诊断已经结束了的业务处理等。</p>
<p>Arthur 是 Noslate Debugger 中用于低影响获取 core文件的工具，利用 fork 减少进程暂停时间，LZ4 压缩减少转储体积。带业务流量的线上环境抓取，业务影响 31.106 毫秒，Corefile 大小为 338 MB （进程原使用 1.44GB 物理内存）。</p>
<h2>三、Node.js 发行版</h2>
<p><img src="https://gw.alicdn.com/imgextra/i1/O1CN01wxGn641fHLWa312QP_!!6000000003981-2-tps-1270-339.png" alt="Anode">
我们还对 Node.js 的实例进行了定向弹性场景的优化，提高了用户代码的加载速度，从而降低了冷启动时间。主要包括 Require 关系加速、Bytecode Cache，优化效果提升可高达 100% ~ 200%。该发行版，同时包含来自阿里云基础软件团队在 ARM 架构的性能优化特性。</p>
<h3>冷启动优化</h3>
<p>PGO（Profile Guided Optimization），是一种根据运行时 Profiling Data 来进行编译优化的技术，这里我们借鉴了这一概念。主要是通过执行一遍之后收集启动阶段的热点数据生成缓存文件，后续通过内存映射直接加载高效的缓存文件，即可获得提升在 100% ~ 200% 的用户代码冷启动优化效果。
<img src="https://gw.alicdn.com/imgextra/i4/O1CN01nHx1UD1yE7Qqlfef6_!!6000000006546-2-tps-1164-930.png" alt="PGO 流程"></p>
<h3>面向特定平台架构优化</h3>
<p>Node.js 支持包括 x64、arm64 等在内的多种架构。 但针对 ARM 芯片的快速发展，上游版本往往仅提供基础适配，缺少针对新指令集的优化，导致在 ARM 芯片上无法获得潜在的性能提升。当下主流云厂商大都提供了 ARM 架构、高性价比的运行环境。 Noslate Node.js 发行版针对 ARM 等平台的优化可以让应用在这些架构上获得更高的性能和效率。
目前 Noslate Node.js 发行版已经在进行针对阿里云 Ampere、阿里云倚天的定制优化，未来计划包括支持龙蜥社区中的其他架构。主要包括：zlib 特性优化、其他一些利用 SIMD 的性能提升都在 PR 合并和准别中。
上面是对 Noslate Project 的简单介绍，如果想要详细了解可通过下述方式：
● GitHub: <a href="https://github.com/noslate-project/noslate">https://github.com/noslate-project/noslate </a>
● 网站：<a href="https://noslate.midwayjs.org/">https://noslate.midwayjs.org/</a>
● 龙蜥社区 SIG（特殊兴趣小组，有钉钉群）：<a href="https://openanolis.cn/sig/web-platform">https://openanolis.cn/sig/web-platform</a>
● 邮件列表：noslate-support@list.alibaba-inc.com</p>
<p>致谢
感谢阿里巴巴集团内业务方的支持，同时还要特别感谢所有给本项目贡献过代码、一起探索过技术方向伙伴们（包括不限于 legendecas、mariodu、zhaolei0505、XadillaX、umuoy1、oraluben、hyj1991 等）。</p>
</div>

阿里巴巴 Noslate 正式开源 - 面向云原生的 JavaScript 容器方案

<div class="markdown-text"><p>CNode TG Channel 开启 !</p>
<p>Channel 将定期推送最新技术文章、资讯以及活动，欢迎订阅！</p>
<p><a href="https://t.me/cnode_js">https://t.me/cnode_js</a></p>
<p><img src="//static.cnodejs.org/FkwbDvoUIeRAccpPd6f53rgXwrDz" alt="qrcode_tg_channel_cnode.png"></p>
<blockquote>
<p>Tips: 订阅后点击 “设置- View Discussion” 即可加入交流群!</p>
</blockquote>
</div>

CNode - TG 频道

<div class="markdown-text"><p><img src="https://p.inari.site/usr/1819/68f6d0c38fada.png" alt="Picture2.png"></p>
<p><strong>随着网络的蓬勃发展，访问外网资源如TikTok、YouTube等需要可靠稳定 的工具，许多小伙伴都想知道如何上外网免费或如何上外网TikTok，尤其是手机用户希望得到手机上外网梯子推荐或者电脑用户希望找到稳定的电脑梯子。小编以知乎上热门梯子加速器为基础，结合最新趋势，提供新颖实用的指南，帮助你匿名切换IP、突破限制，享受高清流畅体验。无论免费入门还是付费升级，这里都有方案，让你轻松连接全球网络！</strong></p>
<h2>1.Tinny：全球节点覆盖的稳定多端选择</h2>
<p>官网地址：<a href="https://rrkk6969.com">https://rrkk6969.com</a></p>
<p>Tinny作为一款稳定的电脑外网梯子软件，覆盖50多个国家和地区、400多条服务器线路，节点遍布全球，完美适配YouTube和TikTok等平台。它支持1080P+超高清视频播放，网速高速稳定，适合工作、娱乐或跨境电商用户。无论你是用电脑刷剧还是手机上TikTok，它都能提供无缝连接，避免缓冲和延迟。</p>
<p>新用户可享2天的免费试用时间，体验免费上外网的乐趣！根据最新评测，它在Windows、Android和iOS上兼容性强，尤其适合iPhone手机上外网的用户，无需复杂设置。</p>
<p>实测亮点：在连接后访问YouTube，首页秒载，随机视频自动匹配1080P，缓冲条远超播放进度——零卡顿！扩展到TikTok，同样流畅，支持直播和短视频下载。虽有配置门槛，但官网提供图文教程，小白也能上手；开机自启功能让日常使用更便捷。</p>
<h2>2.WSTD：老牌高速工具，免费试用无负担</h2>
<p>官网地址：<a href="https://free99bai.com/i/th098">https://free99bai.com/i/th098</a></p>
<p>WSTD是小编使用多年的<a href="https://github.com/freedoa/wdkaopu">手机和电脑上外网梯子软件</a>，用户基数适中，避免服务器拥挤，确保更快网速。作为一款优质的梯子软件产品，下载便捷，一键安装，支持Android、iOS和Windows，界面简洁，新手友好。它强调安全稳定翻墙，完美解锁TikTok、YouTube等，网速快、连接可靠。</p>
<p>免费福利：新用户可以免费试用3天，长期用户价格也不贵，每月只需要一顿盒饭钱。当前评测显示，日本节点Ping 194ms、下载230Mbps；香港节点Ping 63ms、下载121Mbps——高端表现！测试TikTok：首页加载迅捷，视频高清无卡，适合刷海外热门内容。</p>
<p>用户反馈口碑佳：下载简单、多端适配，上网速度不错，虽节点分布稍限，但基本需求足矣。它提供可靠代理，不记录日志，隐私优先。总体，它是注重体验的用户的可靠伙伴，结合免费试用，试错成本低。</p>
<h2>3.Moon：免费模式为主的入门级选项</h2>
<p>官网地址：<a href="https://go.satr2000.com">https://go.satr2000.com</a></p>
<p>Moon是小编上外网梯子中使用频率最高的一款，支持Android和iOS，免费版可以不限制流量使用，付费VIP解锁高级功能。作为一款安全快速的梯子软件，它帮助用户突破封锁，访问Facebook、YouTube和TikTok等外网资源。免费模式下，网速可轻松播放1080P视频。</p>
<p>免费版零成本，稳定性也还可以，节点包括美国、英国、新加坡、法国、日本、德国、荷兰——覆盖有限，无港澳台，解锁TikTok需选美日节点。</p>
<p>实测：连接后YouTube 1080P流畅，TikTok视频加载正常。作为手机上外网的梯子推荐列表中的常驻人员，它在iPhone上的免费代理功能实用，适合预算有限用户。</p>
<h2>外网梯子趋势与更多选择</h2>
<p>为了丰富内容，结合最新搜索趋势，以下扩展<a href="https://github.com/hwanz/SSR-V2ray-Trojan-vpn/issues/101">电脑外网梯子软件</a>和适合<a href="https://github.com/w1770946466/Auto_proxy/issues/12">iPhone手机的外网梯子</a>。</p>
<p>免费方案：Psiphon或Lantern提供无限免费，但速度有限；油管和点点试用可作为起点。</p>
<p>iPhone专属：ExpressVPN（$3.49/月，30天免费）稳定翻墙，iOS优化好；Surfshark无限设备，伪装模式强，解锁TikTok无压力。</p>
<p>电脑优化：NordVPN（3.71美元/月）服务器多，安全高；StrongVPN支付宝支付，便捷。</p>
<p>TikTok解锁：选有美日节点的梯子，如油管加速器；AI路由趋势让工具更智能，避免检测。 安全性优先：用加密协议，定期更新。预算低从免费试用起；高端选VIP。测试多场景，确保稳定。</p>
<p><strong>总之，在当前环境下，如何上外网免费并非是一件很困难的事情，以上手机上外网的梯子推荐和电脑外网梯子软件基于实测，助你自由探索TikTok等世界。</strong></p>
</div>

如何上外网免费?手机电脑外网梯子软件推荐-适合iPhone上TikTok的梯子

<div class="markdown-text"><p>关于WordPress独立网站或个人博客的国外虚拟托管主机购买推荐，免备案。</p>
<p>网站管理平台（如WordPress）、域名domain和虚拟主机空间hosting是构成一个独立博客或网站的三个重要组成部分</p>
<p><em>域名的话，非常推荐在很受用户好评的<a href="https://www.namesilo.com/?rid=adf2827hj"><strong>namesilo</strong></a>注册购买(拿去用，1美元注册优惠码：webcom)，简单好用便宜靠谱，不建议选择使用购买主机时送的第一年免费的域名，都是套路呀</em></p>
<p>这个页面主要简单介绍和推荐几个好用的优质国外WordPress虚拟主机，不要用免费的，所谓的&quot;免费&quot;都不过是幌子而已，也不要用国内的主机，还得备案等，不多解释。</p>
<p><em>WordPress是目前最主流最成熟的网站搭建平台，根据wordpress.com的介绍，42% 的网页是在 WordPress 平台上构建的。 越来越多的博主、小型企业和《财富》500 强公司使用 WordPress，其数量超过了其他所有选项的总和。wordpress.com本身就是用wordpress系统搭建的免费博客网站，所以你打算搭建个人的独立博客或网站的话，WordPress肯定会是一个非常不错的平台</em></p>
<p>搭建Wordpress独立博客或网站对于新手来说可能一开始会因为陌生而有些困难，其实操作熟练之后会很简单，wp网站系统完善到现在已经非常成熟和强大了，主要是要先准备好靠谱的域名和主机就行了，不要用免费的域名或虚拟主机，这样会免去很多不必要的麻烦（主要是免费的东西太浪费时间和精力）</p>
<h2>几个好用的国外虚拟主机：</h2>
<p>以下虚拟主机都支持WordPress网站的一键快速安装；都可以通过PayPal或visa等国际信用卡付款，基本上也都支持支付宝；最重要的是都可以在购买之后的规定期限内发起退款，有问题可以联系在线客服或邮件。</p>
<ul>
<li>
<p><a href="https://www.bluehost.com/track/ykq">bluehost</a>，公司总部在美国犹他州，2003年成立，WordPress org官方推荐第一位的主机，老牌主机服务商，名气也比较大，有超过200多万的优质网站在这里搭建，免费提供SSL(https)，不要用它提供的首年免费的域名，30天内可退款。<em>另，bluehost客服确认所谓的bluehost中国其实跟bluehost官方是两个不同的系统，虽然它们共用一个主域名，故不再推荐在bluehost中国购买，需要的直接在<a href="https://www.bluehost.com/track/ykq">bluehost.com</a>官网购买，当然你自己拿主意</em></p>
</li>
<li>
<p><a href="https://www.sugarhosts.com/members/aff.php?aff=3080">sugarhosts</a>，糖果主机，位于英国爱尔兰，2009年成立，支持中文界面和中文客服，风格比较文艺，30天内可以退款，免费提供ssl证书，购买pro套餐按年付款的可以申请免费独立ip，其香港的主机挺快的，托管个人独立博客完全够用了，可以支付宝付款。</p>
</li>
<li>
<p><a href="https://my.hawkhost.com/aff.php?aff=12414">hawkhost</a>，其标志是一个老鹰，2004年在加拿大成立，主要销售共享主机，免费SSL证书，价格也比较便宜，可以支付宝，30天内可以发起退款，它提供的主机主要分布在加拿大、美国、欧洲荷兰，亚洲的中国香港和新加坡。</p>
</li>
<li>
<p><a href="https://www.siteground.com/index.htm?afcode=d374ff711fd59832e23687367eb84f3c">site ground</a>，<strong>非常好用，客户评价非常好，特别推荐）有点贵）</strong>，最近又涨价了，尤其是续费价格更贵（最低套餐续费价格14.99美元/月），虽然稳定，但是确实比较贵了。siteground公司在美国田纳西州，2003年成立，它也是WordPress org的官方推荐主机，针对WP特别优化，备份最近30天，共享主机shared wordpress hosting30天/一个月内可以退款，云主机cloud hosting 14天/两个星期内可退款，速度、稳定性什么的都非常好，在线客服支持非常的专业高效，很多人选择用siteground来搭建外贸网站，放在比较后面的原因是它的付款对于中国用户比较麻烦点，只接受visa/mastercard万事达卡等国际信用卡，PayPal的话需要在购买的时候联系客服，不支持支付宝。</p>
</li>
<li>
<p><a href="https://partners.hostgator.com/KBOoA">hostgator</a>，2003年成立，公司位于美国德克萨斯州，其标志是一条鳄鱼，购买共享主机45天内可以退款（0.01美元的订单不支持退款，如果你能买到话），提供免费SSL，价格也挺便宜的。有专门的<a href="https://partners.hostgator.com/9Vnb0">中文网页</a>，可以支付宝。</p>
</li>
</ul>
<p>另外简单说一下虚拟主机空间地理位置的选择，中文网站或个人博客的话，建议选择亚洲的机房，比如位于中国香港、新加坡或日本和韩国的主机，当然也只是建议。
WordPress网站的theme主题的选择：默认的那几个主题就可以的，你也可以搜索选择自己喜欢的免费主题风格，也可以考虑使用付费主题</p>
<p>以上哪个主机最好呢？ 尺有所短、寸有所长，不能绝对的说哪个最好用，都不错，要根据个人的需要和预算等选一个合适的就行了。</p>
<p><em>“wordpress” “网站” “博客” “国外” “美国” “香港” “主机” “域名” “主题” “教程” “建站” “推荐” “website” “blog” “hosting” “com domain”</em></p>
</div>

几个非常好用的国外(wordpress网站)虚拟主机推荐

<div class="markdown-text"><p>如题。
用了一个月的linode，速度、服务什么的没什么可挑剔的，就是价格太贵了扛不住，老大让看下photonvps。
用过的童鞋给下建议呗，或者有其他性价比好点的VPS推荐下？
目前用于放wordpress博客，还可能后面会搭建node环境，在上面折腾点东西，主要看中速度和流量（越大越好），因为网站流量还算大。
多谢！！</p>
</div>

photonvps这个VPS如何？

<div class="markdown-text"><p>VCC Visa万事达虚拟信用卡|轻松付全球|跨境支付
适用各种跨境场景，轻松付全球！支持AWS、tiktok、Facebook、Alipay 、Google、paypal、推特、星链、广告投放、域名服务器、 购物、注册、订阅等，覆盖多种消费场景，支持多币种交易、开卡即用、实时到账、极速消费，可自助机器人开卡与开后台管理，支持API对接代理。产品频道：<a href="https://t.me/+vCIqSgwsBDxiODIy">https://t.me/+vCIqSgwsBDxiODIy</a></p>
</div>

🚀 购物/订阅/广告投放/域名服务器，一张虚拟卡轻松付全球！

<div class="markdown-text"><blockquote>
<p>知乎原文地址：<a href="https://zhuanlan.zhihu.com/p/430580607">https://zhuanlan.zhihu.com/p/430580607</a></p>
</blockquote>
<h2>源起</h2>
<p>淘宝 NPM 镜像站（<a href="http://npm.taobao.org">npm.taobao.org</a>）自 <a href="https://www.yuque.com/egg/data/taobaonpm#7f2e">2014 年</a> 正式对外服务，一开始只是想简单地做 NPM 的中国镜像站点，回馈国内前端社区，不知不觉竟然一直运行到现在。当年参考 <code>Ruby Gems 淘宝镜像</code> 的方式，跟阿里开源组织申请了 <a href="http://taobao.org">taobao.org</a> 的二级域名，镜像站点名称也自然而然地取名为 <code>淘宝 NPM 镜像站</code> （下称 CNPM）。</p>
<p><img src="//static.cnodejs.org/Fuab0SKMfdsQUQZlbySva7BKTZsM" alt="cnpm.png"></p>
<blockquote>
<p>图片来源：<a href="https://time.graphics/line/579718">https://time.graphics/line/579718</a></p>
</blockquote>
<p>如上图，从 2014 年 CNPM 正式提供服务到今天，NPM 包从 10 万 → 178 万，CNPM 的包下载量从 1 亿 → 200 亿（未包含阿里等私有源）。
<strong>​</strong></p>
<p><strong>可以毫不谦虚的说， CNPM 见证了国内前端蓬勃发展的这 8 年</strong>，未来我们希望继续陪伴中国的前端开发者持续走下去。</p>
<p>PS：虽然核心参与者大部分来自国内大厂，不过 CNPM 本身是一个中立的公益项目，日常巨大的运维费用均来自社区捐赠。</p>
<hr>
<h2>新的起航</h2>
<p>随着前端的蓬勃发展， NPM 包数据量和内容复杂度仍在不断地加速增长，CNPM 当年的架构已经很难满足当今的形势。</p>
<p>为了提供更稳定、更安全、更符合国家法律法规要求的镜像服务，我们今年启动了 CNPM 的优化工作：</p>
<ul>
<li><strong>启动新的域名。</strong></li>
<li>Registry 全面重构，提升稳定性，降低同步失败率。</li>
<li>CLI 优化，提升安装速度，去掉软连接等带来的兼容性问题。</li>
<li>沉淀自企业级大规模应用的使用经验手册。</li>
<li>等等。。。</li>
</ul>
<p>应该有不少开发者已经发现，访问淘宝 NPM 已经会自动 301 跳转到 <a href="https://npmmirror.com/">npmmirror.com</a> 新域名，这是我们独立注册和备案的域名。</p>
<ul>
<li>Web 站点：<a href="https://npmmirror.com">https://npmmirror.com</a></li>
<li>Registry Endpoint：<a href="https://registry.npmmirror.com">https://registry.npmmirror.com</a></li>
</ul>
<p>随着新的域名已经正式启用，老 <a href="http://npm.taobao.org">npm.taobao.org</a> 和 <a href="http://registry.npm.taobao.org">registry.npm.taobao.org</a> 域名将于 2022 年 05 月 31 日零时起停止服务。
<strong>​</strong></p>
<p><strong>恳请有强依赖老域名的各位开发者尽快更新到新域名，企业用户可能还需要联系网管/IT/SRE 更新防火墙白名单。</strong> 当然如果你使用的是 cnpm 的 CLI 命令行工具，我们会去全部替换并发布新版本，大家只需要重新安装到最小版本即可。</p>
<p>我们深知更换域名并停止对老域名的支持是一种体验非常不好的事情，但为了能在符合网站合规运营要求的情况下，可以更长期可持续运行下去，我们还是最终做出这个更换域名的决定，再次说声抱歉。</p>
<p>其他功能正在开发中，欢迎围观 <a href="https://github.com/cnpm/cnpmcore">GitHub</a> ，更期待您能提 PR 参与开源共建。</p>
<hr>
<h2>特别感谢</h2>
<p>非常感谢 <a href="https://developer.aliyun.com/mirror/">阿里云开发者社区的开源镜像站</a> 对淘宝 NPM 镜像站这些年来的持续赞助，才让我们可以不为巨大流量和存储费用而烦恼，才让我们可以持续专注做好专业的技术工作。</p>
<p>还要特别感谢 <a href="https://fed.taobao.org/">淘宝前端团队</a>，帮助我们处理这些来年关于 <a href="http://npm.taobao.org">npm.taobao.org</a> 的域名注册、证书更新、合规等许多复杂流程。</p>
<p>最后，为了国内开发者能尽可能早的完成切换，我们厚着脸皮请求大家帮忙传播下，谢谢。</p>
</div>

【望周知，求扩散】淘宝 NPM 镜像站喊你切换新域名啦

<div class="markdown-text"><blockquote>
<p>知乎原文地址：<a href="https://zhuanlan.zhihu.com/p/546175922">https://zhuanlan.zhihu.com/p/546175922</a> ， 求个赞~
NodeParty 2022.08.08 邀您线上围观，直播预约地址见文末。</p>
</blockquote>
<h2>相识于微末</h2>
<p>我是一个野生的程序猿，非科班出身，在非互联网小公司待了很多年。刚开始工作的时候，还没有前端这个岗位，不过高三的时候就接触过网页三剑客，一见钟情于 HTML/CSS/JS 的『所见即所得』，懵懵懂懂间经历过 JavaScript 停滞的那几年，也被 GMail 引领的翻身之战惊艳过，重新认识了前端。</p>
<p><img src="//static.cnodejs.org/FlRpbwKzQWfj6vKKPI7vRILJ7aqk" alt="yuque_diagram.jpg"></p>
<p>JavaScript 一开始只能在浏览器这个容器中运行，2009 年 Ryan Dah 在研究 V8 引擎时突发奇想，JavaScript 本身就是单线程的，而且浏览器发起的 AJAX 请求就是非阻塞的，如果将 JavaScript 和异步 IO 以及一个简单的 HTTP 服务器集合在一起，就会变成一个很酷的东西。于是在同年 05 月 01 日，Ryan Dah 在与 Tim Becker 的邮件讨论中正式把它命名为 node，同月 27 日发布第一个版本，随即在 11 月的 JSConf EU 上正式对外发布。</p>
<p>2011 年，正在沉浸于用 ExtJS 和 Flash 为电信 ERP 系统打工的我，时不时会写一些小工具来帮自己偷懒，但一直没找到合适的工具，苟且于 Groovy 和 Swing。有一天无意间刷 OSChina 资讯时看到 Node.js 的新闻，当时的第一反应是：『又一个 jQuery 轮子？切~~』，幸运的是基于『多少看一下反正不要钱，闲着也是闲着』的想法，点击了进去，于是发现了一个新的世界，真香~</p>
<p>记得当时微信公众平台刚出来，我的第一个练手项目就是 <a href="https://github.com/node-webot">node-webot</a>，也是第一次参与开源。</p>
<hr>
<h2>刀耕火种</h2>
<p>2013 年，入职了 UC。此时的业界，已经有了前端岗位，归属于设计部门，也叫重构工程师。前端开始进入富应用时代，但还非常的刀耕火种。</p>
<p>2014 年，在 UC 遇到了 云龙，有幸和他一起探索 UC 的前端工程化，基于 FIS 之上实现了 Scrat，那是一段很快乐的时光。 FIS 的实现本身虽然比较粗糙，是基于正则表达式而不是 AST 的，但它的工程化思维却非常的前沿。</p>
<p>现在很多人聊起 Node.js，第一印象可能是：『一个自不量力的想抢 Java 饭碗的语言』，但其实 <strong>命令行工具 才是 Node.js 最初落地及最大的应用场景，它给前端领域带来了巨大的变革：Grunt 的出现让前端有了自己的构建工具，Babel 的出现让我们停滞已久的标准化重焕生机，Webpack 的出现让前端工程化有了基石，前端基建进入新石器时代。</strong></p>
<p><img src="//static.cnodejs.org/FurQDrabVnkNOE4weUDSAw2aspUl" alt="1658733897206-5fb8a56d-1330-4108-b54a-287ff9a43c7e.png"></p>
<blockquote>
<p>参考阅读：《前端工具链十年盘点》，<a href="https://zhuanlan.zhihu.com/p/462985064">https://zhuanlan.zhihu.com/p/462985064</a></p>
</blockquote>
<hr>
<h2>全栈工程师</h2>
<p>2014 年，随着 UC 被阿里收购，我被动的完成了毕业时的目标之一。同年 6 月 21 日的 JSConf CN 大会上，赫门 分享了 《淘宝前后端分离实践》，吹响了国内前端 <strong>前后端分层</strong> 的号角，BFF 的基石也正是 Node.js 这一武器。</p>
<p>2015 年 11 月 13 日，在 苏千 的号召下，成立了 Node.js 虚拟工作组，聚集了来自蚂蚁、淘宝、ICBC、UC 等等 BU 的接口人进行共建，我作为 UC 的代表来到了杭州，核心成员闭关一周，产出了 EggJS，寓意是希望帮助各团队架构师孕育出适合团队业务场景的上层框架。随着它的完善，Node.js 生态有了三驾马车（ EggJS 框架、TNPM 包管理、AliNode 性能分析）的护航。</p>
<p><img src="//static.cnodejs.org/FrC78irYYLL0KKSRqE_NcrirPojf" alt="1658744625445-5ab86d91-d3b2-4548-b89e-fad3963508ba.png"></p>
<p>Node.js 在服务端的起点，是 BFF 聚合层。BFF 聚合层一直都存在，它不局限于语言，只不过之前由 Java 团队来负责。随着业务复杂度和专业度提升的要求，由前端团队来接管这一层，更有利于服务自治和高效协作，于是很多前端团队选择了 Node.js 来承载它。同时也有一拨人基于它来建设前端新基建，如 npmmirror 前端包镜像服务、前端研发平台、前端活动运营平台等等。</p>
<p><strong>在移动互联网的浪巅下，前端肆意地探索着自己的边界，从 PC 到 H5，从 WebView 到 APP，从 Browser 到 Server，这是属于前端的大航海时代，一时间人人都是全栈工程师。</strong></p>
<p>这是一个全栈爆发的时代，这是一个活力四射的时代。我们冲锋陷阵有了不少突破，但我们也留下了很多历史债。</p>
<hr>
<h2>静水深流</h2>
<p>2019 年初，我加入了蚂蚁体验技术部，来到了那个 EggJS、CNPM 诞生的地方，成为了一名前端基础技术人，专注于 Node.js 基础设施的建设。</p>
<p>真正投入到基础设施后，你会发现后端的领域非常广阔，要让一个新生的基础设施完善以及得到认可，需要一代代人的努力和沉淀。</p>
<ul>
<li>我们实现了各种后端服务的 SDK，因为在那个年代跨语言支持友好性不像今天这样是一个共识。</li>
<li>我们实现了 EggJS 框架、TNPM 包管理、AliNode 性能分析 三驾马车来为业务开发护航。</li>
<li>我们实现了自己的研发平台，收敛研发模式，对接下游 PaaS 等基础设施。</li>
<li>我们在语雀、云凤蝶、雨燕等场景都大规模的深度使用了 Node.js。</li>
</ul>
<p>近年来，我们进入了平台治理期，我们变得更耐心和更克制，围绕着前端核心场景去深入，不会把 Node.js 作为锤子去找钉子。</p>
<p><strong>我们不再追求人人都是全栈工程师，前端领域目前已经足够广大，术业有专攻，我们的目标是把部分前端培养成全栈，成为前端新基建的护航者，让一线前端可以无感的没有额外负担的享受到这些能力，从而给业务带来创新。</strong></p>
<p>我们不再追求全民 BFF 化，而是会帮助业务一起分析架构选型，协建上层业务平台的方式来提升效能和 ROI。我们重新审视原来的基础设施，结合最新的前端实践进行更极致的翻新，如过去一年在 CNPM Rapid 等方面的实践。</p>
<blockquote>
<p>“<strong>Any application that can be written in JavaScript, will eventually be written in JavaScript</strong>.” – Jeff Atwood（任何可以用 JavaScript 来写的应用，最终都将用 JavaScript 来写。）</p>
</blockquote>
<p>这段话曾经在前端圈很流行，我个人觉得它既对，也不对。在那个时代，Node.js 这个少年处于野蛮生长时代，年轻人总需要去证明一点什么，证明这世界上没有什么是不可能的，一切皆有可能。但成长后的少年，已经不需要去为了证明什么而去做些什么，而是需要聚焦回核心航道上的事，不用分心在可以做但没必要做的事上。</p>
<blockquote>
<p>“<strong>The strength of JavaScript is that you can do anything. The weakness is that you will.</strong>” – Reg Braithwaite （JavaScript 的优点是可以写任何东西，缺点是你真的会用它去写这些东西。）</p>
</blockquote>
<p>这句话，我认为是对上一段话的回应，或者说下联，我们需要正确且理智的看待手中的武器，并使用在合适的场景。</p>
<hr>
<h2>Node Party</h2>
<p>不知不觉，Node.js 已经陪伴了我十年，在工作中一直在深度实践，在社区也一直在做 Node.js 的科普工作。但我一直不觉得自己是 Node.js 布道师，我只是一个记录者，我也不觉得 Node.js 是万能的，不觉得它能拳打脚踢 Java 等语言，每个团队的起点、技术背景、基础设施都不一样，不能一概而论。</p>
<p><strong>我坚信它对前端领域的价值，是一个不可或缺的基础设施，或许未来前端的变革使得一切工程问题从根本上得到解决，但不管怎样，我只是希望当下能认真记录自己以及同行者们在这个领域的所见所想，与正在经历前端工业化演进并被此过程困扰的同学交流心得，让大家有所参考从而迈出自己的路。</strong></p>
<p>经历过前端大航海时代的同学，一定还记得当年 JSConf CN、Node Party、前端圈等各种大会，那真是一个令人怀念的纯真的技术年代啊。近几年来，各种大会少了不少，也有人会吐槽没啥干货，其实不必纠结，因为前端已经到了一个平台期了，它涉猎的范围太广了，自然会显得有点平淡，其实不尽然，我们一直都在前行着。</p>
<p>去年底 苏千 找我说，办个 Node Party 吧，我一开始有点疑虑，因为我们正在做的很多都是内部的治理工作，社区的同学不一定能理解和有所收获。苏千说：『没关系的，我们既然一直在这条路上走着，我们有义务跟社区分享下我们的所思所得，让大家知道，还有这么一群人一直在前行着』。</p>
<p>因此，今天诚邀大家参与蚂蚁集团举办的 <strong>Node Party 2022.08.08 线上直播</strong>，我们分享的内容包括：</p>
<ul>
<li><strong>Node.js What’s Next</strong>，来自 Node.js Contributor 的分享，介绍  Node.js 工作组正在推进的战略计划，以及如何参与定义  Node.js 的未来。</li>
<li><strong>基于 cnpmcore 实现企业级包管理服务</strong>， 来听一听 cnpm registry 全新重构的技术内幕和架构思考。</li>
<li><strong>cnpm rapid 正式开源</strong>，上半年我们曾分享过的 『深入浅出 tnpm rapid 模式 - 如何比 pnpm 快 10 秒』，终于到 show me the code 环节了。</li>
<li><strong>从 Egg 到 Artus，谈谈框架的框架的初心</strong> ，分享来自蚂蚁、字节、蔚来团队的共建。</li>
</ul>
<p>也许我们还没完全准备好，还在持续的完善中，但我们希望能让社区的同学知道，我们一直都在前行，等你~</p>
<p>B 站预约传送门： <a href="https://live.bilibili.com/21726701">https://live.bilibili.com/21726701</a>，敬请关注。</p>
</div>

我的 Node.js 十年 -- 写在 NodeParty 2022 前夕

深夜放毒——阿里开源的企业级Node框架Egg使用指南

<div class="markdown-text"><p>GitHub repo 地址：<a href="https://github.com/alsotang/node-lessons">https://github.com/alsotang/node-lessons</a></p>
<p>如果大家认为漏了哪些初学者应会的内容，可以在此留言，或者开个 issue 给我（!!推荐）。</p>
<hr>
<h1>《Node.js 包教不包会》 – by alsotang</h1>
<h1>为何写作此课程</h1>
<p>在 CNode(<a href="https://cnodejs.org/">https://cnodejs.org/</a>) 混了那么久，解答了不少 Node.js 初学者们的问题。回头想想，那些问题所需要的思路都不难，但大部分人由于练手机会少，所以在遇到问题的时候很无措。国内唯一一本排的上号的 Node.js 书是 @朴灵(<a href="https://github.com/JacksonTian">https://github.com/JacksonTian</a>) 的 《深入浅出Node.js》(<a href="http://book.douban.com/subject/25768396/">http://book.douban.com/subject/25768396/</a> )，但这本书离实战还是比较远的。</p>
<p>这个课程是希望提供更多的 Node.js 实战机会，通过每一节精心安排的课程目标，让 Node.js 的初学者们可以循序渐进地，有目的有挑战地开展 Node.js 的学习。</p>
<p>更多 Node.js 入门资料请前往：<a href="https://cnodejs.org/getstart">https://cnodejs.org/getstart</a></p>
<h1>课程列表</h1>
<ul>
<li>Lesson 0: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson0">《搭建 Node.js 开发环境》</a></li>
<li>Lesson 1: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson1">《一个最简单的 express 应用》</a></li>
<li>Lesson 2: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson2">《学习使用外部模块》</a></li>
<li>Lesson 3: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson3">《使用 superagent 与 cheerio 完成简单爬虫》</a></li>
<li>Lesson 4: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson4">《使用 eventproxy 控制并发》</a></li>
<li>Lesson 5: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson5">《使用 async 控制并发》</a></li>
<li>Lesson 6: <a href="https://github.com/alsotang/node-lessons/tree/master/lesson6">《测试用例：mocha，should，istanbul》</a></li>
<li>Lesson 7: 《测试用例：supertest》</li>
<li>Lesson 8: 《Mongodb 与 Mongoose 的使用》</li>
<li>Lesson 9: 《一个简单的 blog》</li>
</ul>
<h1>License</h1>
<p>MIT</p>
</div>

一个面向 Node.js 初学者的系列课程：node-lessons

<div class="markdown-text"><p>最近在折腾建站和游戏服务器，用了好几家VPS，最后留下这个：
BaseCloud｜来自新加坡的VPS聚合平台。</p>
<p>🌍 聚合阿里云、腾讯云、AWS 等大厂资源，
全球节点都有，国内延迟低，海外（香港、新加坡、日本）跑跨境业务很稳。</p>
<p>⚙️ 支持一键部署 WordPress、Docker、ERP，
自助升降配、实时监控、原生DDoS防护，
还支持加密货币付款，全程免实名。</p>
<p>💰 长期85折标价，不是限时价，账号开通也很快。</p>
<p>适合做独立站、电商、游戏服、AI部署的都可以试试。</p>
<p>👉 <a href="https://www.basecloud.cc/?utm_source=ondeseek&amp;utm_medium=forum&amp;utm_campaign=forum">BaseCloud 官网直达</a>BaseCloud 官网直达
📢 <a href="https://t.me/+V-BhrqN1hUdiZGQ8">官方TG频道</a>官方TG频道 有节点上新和福利活动</p>
</div>

🚀 分享个好用的VPS平台，电商/建站/游戏都能用

<div class="markdown-text"><p>Deno 中文社区来了，<a href="https://deno.js.cn">https://deno.js.cn</a></p>
<p>------------ 分割线 -----------</p>
<p>10 年前的 2009 年 Node.js 首次发布，我从一名 Java 程序员转行为了 JavaScript 程序员。ry 也成为了我心中的偶像之一。</p>
<p>10 年后的 2019 年 Node.js 与 Deno 之父 ry 首次来中国旅游，期间给我发了一封邮件，邀请我在北京喝咖啡，并讨论一下 Deno 的未来开发计划。</p>
<p><img src="//static.cnodejs.org/FrE4iRKmfLPym1cu1-BWCS64G9ay" alt="justjavac 与 nodejs/deno 之父 ry"></p>
<p>去年我开始在国内写 Deno 技术文章，今年我成为了 Deno 核心代码的贡献者。完成了多个 WHATWG 规范兼容性的实现，并为 VSCode 开发了支持 Deno 的扩展（vscode-deno）。</p>
<p>在 Deno 1.0 正式版发布前夕，我为 Deno 开发的 VS Code 扩展也被移入到了官方仓库。<a href="https://github.com/denoland/vscode_deno/commit/37c7ad34248506bf778d89b3ab755f6920c705cf">https://github.com/denoland/vscode_deno/commit/37c7ad34248506bf778d89b3ab755f6920c705cf</a>，目前依然由我在维护。</p>
<p>欢迎来 <a href="https://deno.js.cn/">Deno 中文社区</a>交流。</p>
<p>帖子索引：</p>
<ul>
<li><a href="https://deno.js.cn/t/topic/32">了不起的 Deno 入门篇</a></li>
<li><a href="https://deno.js.cn/t/topic/35">了不起的 Deno 实战教程</a></li>
<li><a href="https://deno.js.cn/t/topic/37">Deno bytes 模块全解析</a></li>
<li><a href="https://deno.js.cn/t/topic/38">Deno 入门手册：附大量 TypeScript 代码实例</a></li>
</ul>
<p><em>★,°</em>:.☆(￣▽￣)/$:<em>.°★</em> 。</p>
</div>

Deno 中文社区来了 deno.js.cn

<div class="markdown-text"><p>如果用过NestJS框架都知道，在NestJS框架中AOP编程包括以下几个能力：Middleware、Guard、Interceptor、Pipe、Filter。事实上AOP编程的应用场景更广泛，上述所列5个能力仅仅是AOP编程的子集。下面，我们看看在VonaJS框架中，AOP编程是怎样的。</p>
<h2>VonaJS AOP编程</h2>
<p>VonaJS AOP 编程包括三个方面的能力：</p>
<ol>
<li><code>控制器切面</code>: 为 Controller 方法切入逻辑</li>
<li><code>内部切面</code>: 在 Class 内部，为任何 Class 的任何方法切入逻辑</li>
<li><code>外部切面</code>: 在不改变 Class 源码的前提下，从外部为任何 Class 的任何方法切入逻辑</li>
</ol>
<h2>控制器切面</h2>
<h3>控制器切面清单</h3>
<ul>
<li>Middleware</li>
<li>Guard</li>
<li>Intercepter</li>
<li>Pipe</li>
<li>Filter</li>
</ul>
<h3>执行时序图</h3>
<p>控制器切面的执行时序图如下：</p>
<p><img src="//static.cnodejs.org/Fsx_N3n61Q2nKWzzXlvCIc5jTrQZ" alt="aspect-controller.png"></p>
<ul>
<li><code>洋葱模型</code>: <code>Middleware</code>和<code>Intercepter</code>支持<code>洋葱模型</code>，允许在<code>Controller Action</code>之前和之后执行切面逻辑</li>
<li><code>Middleware</code>: 针对不同的执行时序节点，系统提供了三种 Middleware: <code>Middleware System</code>、<code>Middleware Global</code>和<code>Middleware Local</code>，从而可以实现更精细化的切面逻辑</li>
<li><code>Route Match</code>: 只有<code>Middleware System</code>在路由匹配之前执行，其余在路由匹配之后执行</li>
<li><code>Filter</code>: 任何环节抛出异常，都会执行<code>Filter</code>，从而自定义<code>错误信息</code>和<code>错误日志</code>的处理逻辑</li>
</ul>
<h2>内部切面</h2>
<p>内部切面提供两个机制：<code>AOP Method</code>和<code>魔术方法</code></p>
<h3>1. AOP Method</h3>
<p>直接在 Class Method 上通过装饰器切入逻辑</p>
<h4>举例：数据库事务</h4>
<pre class="prettyprint language-diff"><code>class ServiceStudent {
+ @Database.transaction()
  async update(id: TableIdentity, student: DtoStudentUpdate) {
    return await this.scope.model.student.updateById(id, student);
  }
}
</code></pre><ul>
<li><code>@Database.transaction</code>：通过<code>AOP Method</code>机制实现的装饰器，可以直接提供数据库事务能力</li>
</ul>
<h4>举例：日志</h4>
<pre class="prettyprint language-diff"><code>class ServiceStudent {
+ @Log()
  async update(id: TableIdentity, student: DtoStudentUpdate) {
    return await this.scope.model.student.updateById(id, student);
  }
}
</code></pre><ul>
<li><code>@Log</code>：通过<code>AOP Method</code>机制实现的装饰器，可以直接提供日志能力</li>
</ul>
<h3>2. 魔术方法</h3>
<p>可以在 Class 内部通过<code>__get__</code>和<code>__set__</code>切入动态属性或方法</p>
<h4>举例：获取 model 实例</h4>
<pre class="prettyprint language-diff"><code>class ServiceStudent {
  async update(id: TableIdentity, student: DtoStudentUpdate) {
+   return await this.scope.model.student.updateById(id, student);
  }
}
</code></pre><ul>
<li><code>this.scope.model.xxx</code>: 没有使用<code>依赖注入</code>，而是使用<code>依赖查找</code>，直接通过 scope 对象获取 model 实例，从而简化代码的书写风格</li>
</ul>
<h4>实现思路</h4>
<p>系统提供了一个 Class <code>ServiceModelResolver</code>，用于实现 model 实例的动态解析，代码如下：</p>
<pre class="prettyprint language-typescript"><code>class ServiceModelResolver {
  protected __get__(prop: string) {
    const beanFullName = &#96;${this[SymbolModuleScope]}.model.${prop}&#96;;
    return this.bean._getBean(beanFullName as any);
  }
}
</code></pre><ol>
<li>当调用<code>this.scope.model.student</code>时，会自动执行<code>__get__</code>方法，并且传入参数<code>prop: 'student'</code></li>
<li>将参数<code>prop</code>与当前模块名称合并成<code>beanFullName</code></li>
<li>通过<code>beanFullName</code>从全局容器中获取 model 实例，并返回给调用者</li>
</ol>
<h2>外部切面</h2>
<p>仍以 Class <code>ServiceStudent</code>的<code>update</code>方法为例，通过<code>外部切面</code>来实现日志能力：</p>
<pre class="prettyprint language-typescript"><code>import { Aop } from &#x27;vona-module-a-aspect&#x27;;

@Aop({ match: &#x27;demo-student.service.student&#x27; })
class AopLog {
  async update(_args: Parameters&lt;any&gt;, next: Function, _receiver: any) {
    const timeBegin = Date.now();
    const res = await next();
    const timeEnd = Date.now();
    console.log(&#x27;time: &#x27;, timeEnd - timeBegin);
    return res;
  }
}
</code></pre><ul>
<li><code>@Aop</code>: 此装饰器用于实现<code>外部切面</code></li>
<li><code>match</code>: 用于将 Class <code>AopLog</code>与 Class <code>ServiceStudent</code>关联，<code>ServiceStudent</code>的 beanFullName 是<code>demo-student.service.student</code></li>
<li><code>update</code>: 在<code>AopLog</code>中提供与<code>ServiceStudent</code>同名的方法<code>update</code>，实现自定义逻辑即可</li>
</ul>
<h2>资源</h2>
<ul>
<li>Github：<a href="https://github.com/vonajs/vona">https://github.com/vonajs/vona</a></li>
<li>文档：<a href="https://vona.js.org/">https://vona.js.org/</a></li>
</ul>
</div>

AOP编程有三大场景：控制器切面，内部切面，外部切面，你get到了吗？

xlsx-handlebars 一个用于处理 XLSX 文件 Handlebars 模板的 Rust 库，支持多平台使

<div class="markdown-text"><p>在2025年，随着 科学上网 需求的日益增长，无论是外贸人员需要 外贸VPN加速器 访问谷歌、LinkedIn，还是流媒体爱好者使用 TIKTOK直播、VPN解锁Netflix、YouTube的4K内容，稳定、高速的 翻墙软件 和 网络梯子 已成为手机和电脑用户的必备工具。
传统免费工具速度慢、易被封，已难以满足需求，而付费的 VPN软件 和 加速器 以其卓越性能和高性价比脱颖而出。本文精选了六款主流SSR/V2Ray/Trojan节点机场，为您提供2025年最优质的 翻墙机场 推荐。</p>
<h2>为什么要选择翻墙机场？</h2>
<p>传统的 科学上网 方法，如免费VPN或自建VPS，常常面临速度慢、晚高峰卡顿或被封锁的问题。而 翻墙机场 依托SS/SSR、V2Ray、Trojan协议，结合BGP中转和IPLC专线，提供更强的抗封锁能力和流畅体验。相比免费 网络梯子 的安全隐患和不稳定性，付费 VPN梯子 更可靠，已成为 科学上网 的首选。</p>
<p><img src="https://discuss.d2l.ai/uploads/default/original/3X/d/b/db08f349abe57a30899c2433ec3bc63009f28ccb.jpeg" alt></p>
<h3>2025年顶级翻墙机场推荐</h3>
<h3>1. 扬帆云加速器 – 最稳定的VPN软件与翻墙机场首选</h3>
<p><strong><a href="https://affgo.cc/yafa">进入扬帆云官网：点击注册</a></strong></p>
<p>扬帆云加速器 是一款集 VPN软件、加速器 和 翻墙软件 于一体的科学上网神器，全球部署超5000台服务器，200+节点覆盖美国、日本、新加坡、香港等地，配备IPLC专线，确保高速稳定。</p>
<p>加速器特点：</p>
<p>✅超高性价比：包月仅 15元，100GB流量，2设备同时在线。<br>
✅流媒体解锁：支持Netflix、Hulu、Disney+，8K视频无缓冲。<br>
✅GPT专用VPN：专为ChatGPT优化，低延迟，程序员必备。<br>
✅TIKTOK直播VPN：专属节点助力TikTok直播，无卡顿。<br>
✅外贸VPN加速器：稳定访问谷歌、LinkedIn，助力外贸业务。<br>
✅安全可靠：AES-256加密，无日志政策。<br>
套餐一览：</p>
<p>标准版：15元/月，100GB
高级版：20元/月，200GB
评测：
扬帆加速器 以15元的超低价格和卓越性能，成为2025年 翻墙机场 中的最佳选择。无论是日常浏览、外贸VPN加速器 需求，还是 TIKTOK直播VPN，都能提供稳定体验。</p>
<p>优惠提示： 通过官网注册，年付7折</p>
<h3>2. 尔湾云 稳定魔法梯子推荐</h3>
<p><strong><a href="https://affgo.cc/ewan">进入耐思云官网：点击注册</a></strong></p>
<p>尔湾云主打Shadowsocks协议，提供IEPL专线支持。</p>
<p>尔湾云特点：</p>
<p>✅月付12元起，50GB流量。<br>
✅支持Netflix，4K秒开。<br>
✅支持24小时不满意退款。<br>
套餐一览：</p>
<p>初级套餐：12元/月，100GB，2设备
高级套餐：25元/月，200GB，3设备
评测：
耐思云价格亲民，晚高峰表现稳定，是预算有限用户的 网络梯子 优选。</p>
<h3>3. 疾风云 老牌机场推荐</h3>
<p><strong><a href="https://affgo.cc/jife">进入疾风云官网：点击注册</a></strong></p>
<p>疾风云是一家运营多年的 翻墙机场，口碑极佳。</p>
<p>疾风云特点：</p>
<p>✅月付14元起，50GB流量。<br>
✅支持Netflix、Disney+，8K流畅。<br>
✅年付七折，优惠码 jf2025。<br>
套餐一览：</p>
<p>入门版：14元/月，50GB，1设备
标准版：28元/月，200GB，3设备
评测：
疾风云适合流媒体爱好者，但性价比不及 DOVE加速器。</p>
<h3>4. 速云梯 高端VPN梯子</h3>
<p><strong><a href="https://affgo.cc/suyu">进入速云梯官网：点击注册</a></strong></p>
<p>速云梯机场提供 IPLC 高速专线 VPN梯子 服务，运营六年的安全可靠大机场。</p>
<p>速云梯特点：</p>
<p>✅月付19元起，100GB流量。<br>
✅支持Netflix，8K视频流畅。<br>
✅年付7折优惠。<br>
套餐一览：</p>
<p>基础版：19元/月，100GB，2设备
标准版：39元/月，350GB，5设备
评测：
速云梯稳定低调，市场口碑好，适合对网络要求较高的用户。</p>
<h2>如何使用翻墙机场？</h2>
<p>使用 VPN软件 或 翻墙机场 很简单：</p>
<h2>注册购买：<a href="https://affgo.cc/yafa">访问扬帆云加速器官网，选择套餐</a></h2>
<p>下载客户端：Clash（PC/Android）、Shadowrocket（iOS）。
导入订阅：复制订阅链接，加载节点。
连接测试：选择低延迟节点，验证访问。
我们为什么要翻墙？
翻墙，即通过技术手段绕过网络封锁访问被限制的网站，是许多中国网民的常见行为。</p>
<h2>以下是一些主要原因解释为什么人们选择翻墙：</h2>
<p>获取信息自由 访问被封锁的网站： 中国的防火长城（GFW）屏蔽了许多国外网站和服务，如Google、Facebook、Twitter、YouTube等。翻墙可以让用户访问这些被封锁的网站，获取更多的信息和资源。</p>
<p>获取多样化的资讯： 国内的新闻和信息可能受到审查和过滤，翻墙可以让用户接触到更多元化的国际新闻和观点，帮助他们形成更全面的世界观。</p>
<p>技术学习和工作需求 访问技术资源： 许多技术资源和开发者社区，如GitHub、Stack Overflow、Google Scholar等，在国内访问受限。翻墙可以帮助技术人员和学生获取这些重要的资源，提升专业技能。</p>
<p>跨国工作和交流： 跨国企业和外贸公司需要与国际客户和合作伙伴保持联系，翻墙可以帮助他们顺利进行跨国业务和沟通。</p>
<p>娱乐和文化需求 解锁流媒体内容： 许多国际流媒体平台，如Netflix、Hulu、Disney+等，在中国无法直接访问。翻墙可以帮助用户观看这些平台上的影视内容，满足他们的娱乐需求。</p>
<p>访问国外社交媒体： 一些用户希望与国外的朋友和家人保持联系，或者参与国际社交媒体平台上的讨论和交流，翻墙可以帮助他们实现这一目标。</p>
<p>隐私和安全 保护隐私： 翻墙工具通常会加密用户的网络流量，保护他们的隐私和数据安全，防止被监控和窃取。</p>
<p>避免审查和监控： 在某些情况下，用户希望避免国内的网络审查和监控，翻墙可以提供一个相对自由和安全的网络环境。</p>
<h2>有效使用翻墙机场的方法：</h2>
<p>有效使用翻墙机场的方法可以帮助用户在网络封锁环境中获得更稳定和快速的互联网连接。</p>
<p>以下是一些详细的建议和步骤，帮助您更好地使用翻墙机场和选择合适的机场：</p>
<p>评估机场的稳定性和口碑： 选择运营时间较长、口碑较好的机场，避免选择新开的小机场，因为这些机场可能会因为资金不足或其他原因突然关闭。</p>
<p>关注节点质量： 选择拥有高质量节点的机场，特别是那些提供IPLC（国际专线）或IEPL（国际以太网专线）节点的机场，这些节点通常更稳定，速度更快。</p>
<p>了解套餐详情： 注意机场套餐的流量限制和倍率（例如，使用1GB流量可能会被计为2GB），选择适合自己需求的套餐。</p>
<p>配置和使用 获取订阅链接： 在购买机场服务后，您会获得一个订阅链接。这个链接通常以 https:// 开头，包含所有可用节点的信息。</p>
<p>安装客户端： 根据您的设备选择合适的客户端软件，例如： Windows：V2RayN、Clash for Windows macOS：ClashX、V2RayU Android：V2RayNG、Clash for Android iOS：Shadowrocket、Quantumult X</p>
<p>导入订阅链接： 打开客户端软件，找到订阅管理选项，将订阅链接粘贴进去并更新节点列表。这样，您就可以看到所有可用的节点。</p>
<p>选择合适的节点： 根据您的需求选择合适的节点。</p>
<p>观看流媒体：选择解锁Netflix、Disney+等流媒体的节点。</p>
<p>日常浏览：选择延迟较低、速度较快的节点。</p>
<p>游戏：选择专门的游戏加速节点，确保低延迟和稳定性。</p>
<p>设置路由规则： 在客户端中设置路由规则，确保国内网站不走代理，减少不必要的流量消耗，提高访问速度。例如，在Clash中，可以设置“绕过局域网及中国大陆地址”的规则。</p>
<p>优化使用体验 定期更换节点： 由于防火墙的不断升级，某些节点可能会被封锁。定期更换节点可以确保连接的稳定性和速度。</p>
<p>关注机场公告： 机场通常会在特殊时期（如国庆、两会等）发布公告，建议用户使用特定的节点或协议。关注这些公告可以帮助您在特殊时期保持稳定的连接。</p>
<p>使用备用机场： 为了防止某个机场突然关闭或节点被封锁，建议购买多个机场的服务，确保有备用方案。</p>
<p>安全支付： 尽量使用安全的支付方式，如数字货币或国际支付平台，避免使用真实个人信息，保护隐私。 通过以上方法，您可以更有效地使用<a href="https://discuss.d2l.ai/t/vpn/30605">翻墙机场</a>，获得更稳定和快速的互联网连接。</p>
<p>结语：在2025年，扬帆加速器 以15元/月的超值价格、卓越稳定性和对 GPT专用VPN、外贸VPN加速器、TIKTOK直播VPN 的优化，成为 翻墙机场 中的顶尖选择。立即访问官网，体验高速、无界的网络世界吧！</p>
<p>机场推荐 ，翻墙机场，机场推荐 ，SS/SSR/机场，机场加速器购买，V2ray机场梯子，Trojan机场 ，Clash节点，好用的便宜梯子，翻墙梯子，VPN梯子 ，稳定梯子 ，手机电脑梯子，外网梯子，外贸梯子，油管梯子</p>
</div>

四款最稳定的翻墙机场节点和魔法外网梯子 VPN 推荐

<div class="markdown-text"><p>在VonaJS中实现<code>读写分离</code>，只需提供一组<code>写数据源</code>和一组<code>读数据源</code>。当用户访问后端 API 时，系统会按照规则自动选择<code>写数据源</code>或<code>读数据源</code>，访问相应的数据库，从而分摊压力，提升系统性能</p>
<h2>安装模块</h2>
<p><code>读写分离</code>作为独立的模块提供，因此需要在VonaJS项目中安装此模块：</p>
<pre class="prettyprint language- bash"><code>$ pnpm add vona-module-a-datasharding -w
</code></pre><h2>添加数据源</h2>
<p>首先，需要添加一组数据源</p>
<h3>1. 添加类型定义</h3>
<p>为新数据源添加类型定义</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>declare module &#x27;vona-module-a-orm&#x27; {
  export interface IDatabaseClientRecord {
    read1: never;
    read2: never;
    write1: never;
    write2: never;
  }
}
</code></pre><h3>2. 增加数据源配置</h3>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; database
config.database = {
  clients: {
    read1: {
      client: &#x27;pg&#x27;,
      connection: {
        host: &#x27;127.0.0.1&#x27;,
        port: 5432,
        user: &#x27;postgres&#x27;,
        password: &#x27;&#x27;,
        database: &#x27;xxxx-read1&#x27;,
      },
    },
    read2: {...},
    write1: {...},
    write2: {...},
  },
};
</code></pre><h2>配置读写数据源</h2>
<p>然后配置模块的读写数据源</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; modules
config.modules = {
  &#x27;a-datasharding&#x27;: {
    client: {
      reads: [&#x27;read1&#x27;, &#x27;read2&#x27;],
      writes: [&#x27;write1&#x27;, &#x27;write2&#x27;],
      randomRead: undefined,
      randomWrite: undefined,
    },
  },
};    
</code></pre><table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>reads</td>
<td>指定一组读数据源</td>
</tr>
<tr>
<td>writes</td>
<td>指定一组写数据源</td>
</tr>
<tr>
<td>randomRead</td>
<td>可指定自定义函数，从<code>reads</code>中提取一个读数据源。默认为<code>undefined</code>，由系统随机提取</td>
</tr>
<tr>
<td>randomWrite</td>
<td>可指定自定义函数，从<code>writes</code>中提取一个写数据源。默认为<code>undefined</code>，由系统随机提取</td>
</tr>
</tbody>
</table>
<h2>读写分离的运行机制</h2>
<p>当配置好读写数据源之后，读写分离机制就自动生效了</p>
<p>现在，解释一下读写分离的运行机制：</p>
<blockquote>
<p>模块提供了一个全局拦截器<code>a-datasharding:datasharding</code>。该拦截器判断当前 API Method，如果是<code>POST/PATCH/DELETE/PUT</code>，那么就使用<code>写数据源</code>，否则使用<code>读数据源</code></p>
</blockquote>
<h2>数据一致性: 缓存<code>写数据源</code></h2>
<h3>场景分析：同一个用户</h3>
<p>由于数据库同步有延时，会出现数据不一致性的情况。比如，用户访问<code>Write-API</code>，将数据写入<code>写数据库</code>。接下来，用户访问<code>Read-API</code>，此时<code>读数据库</code>还没有同步，那么就会读到旧数据</p>
<p>为了解决以上问题，模块自动提供了一个机制：当用户访问<code>Write-API</code>时，会自动将<code>写数据源</code>存入<code>二级缓存</code>，并设置过期时间。在这个时间之内，用户访问<code>Read-API</code>时，也会继续使用同一个<code>写数据源</code>，从而确保在写入数据后总是可以读取到最新的数据</p>
<h3>修改过期时间</h3>
<p><code>二级缓存</code>的名称是<code>a-datasharding:datasourceWrite</code>，可以在 App config 中修改过期时间：</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; onions
config.onions = {
  summerCache: {
    &#x27;a-datasharding:datasourceWrite&#x27;: {
      mem: {
        ttl: 5 * 1000, &#x2F;&#x2F; 5s
      },
      redis: {
        ttl: 5 * 1000, &#x2F;&#x2F; 5s
      },
    },
  },
};
</code></pre><table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>mem.ttl</td>
<td>Mem缓存的过期时间，默认为<code>3</code>秒</td>
</tr>
<tr>
<td>redis.ttl</td>
<td>Redis缓存的过期时间，默认为<code>3</code>秒</td>
</tr>
</tbody>
</table>
<h2>数据一致性: 缓存双删</h2>
<h3>场景分析：不同用户</h3>
<p>Vona ORM 提供了开箱即用的缓存机制，参见：<a href>缓存</a></p>
<p>由于数据库同步有延时，会出现缓存不一致性的情况。比如，用户 A 访问<code>Write-API</code>，将数据写入<code>写数据库</code>，并自动删除缓存。接下来，用户 B 访问<code>Read-API</code>，此时<code>读数据库</code>还没有同步，那么就会读到旧数据，并存入缓存</p>
<p>为了解决以上问题，模块<code>a-orm</code>提供了<code>缓存双删</code>机制：当用户 A 访问<code>Write-API</code>时，将数据写入<code>写数据库</code>，并自动删除缓存。然后在指定时间之后再次删除缓存，从而确保缓存总是最新数据</p>
<h3>启用缓存双删</h3>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; modules
config.modules = {
  &#x27;a-orm&#x27;: {
    sharding: {
      cache: {
        doubleDelete: true,
      },
    },
  },
};
</code></pre><h3>修改缓存双删延迟时间</h3>
<p>系统采用队列任务执行缓存双删，<code>队列</code>名称是<code>a-orm:doubleDelete</code>，可以在 App config 中修改缓存双删延迟时间：</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; onions
config.onions = {
  queue: {
    &#x27;a-orm:doubleDelete&#x27;: {
      options: {
        job: {
          delay: 5 * 1000, &#x2F;&#x2F; 5s
        },
      },
    },
  },
};
</code></pre><table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>job.delay</td>
<td>指定延迟多长时间执行缓存双删任务，默认为<code>3</code>秒</td>
</tr>
</tbody>
</table>
<p>Vona ORM已开源：<a href="https://github.com/vonajs/vona">https://github.com/vonajs/vona</a></p>
</div>

VonaJS提供的读写分离，直观，优雅🌼

<div class="markdown-text"><p>分享一个朋友的网站：<a href="https://www.dkluge.com/draw">刀刻网</a>
<img src="https://asset.dkluge.com/uploads/dkluge-forum-images/bfa483d97ebddd2e95aac0857098fb6c75aa2204eaa5a10c4a0343ac3e823bdb.png" alt="使用引导__ (3).png"></p>
<p>支持 AI 生成：</p>
<p><img src="https://dkluge-files-v1.oss-cn-hangzhou.aliyuncs.com/uploads/dkluge-images/ce5e1e4835aee8814d50740c3138e3fd5d5da6cb5be50c16b6f8df99a0e60216.png" alt="AI 生成"></p>
</div>

分享一个画流程图各种图的网站

<div class="markdown-text"><p>同志们，Cnode社区阔别好多年了，今天终于回来了！欢迎大家一起探讨学习JS！</p>
</div>

阔别好多年，我回来了！

<div class="markdown-text"><p><strong>在当下的网络环境中，使用翻墙机场节点进行科学上外网成为电脑和手机用户畅游全球互联网的必备技能。SSR以其轻量、高效的代理特性，成为搭建魔法外网梯子的热门选择。本文围绕电脑SSR梯子推荐、SSR手机小飞机安装包、SSR手机梯子推荐、SSR免费节点分享等用户核心需求，推荐稳定安全的SSR梯子软件。无论您追求免费节点还是稳定付费服务，这份指南将助您快速实现高效的科学上网体验。</strong></p>
<p><img src="https://p.inari.site/usr/1819/68cce0617d7c5.png" alt="Picture2.png"></p>
<p>Shadowsocks（SSR）是一款轻量级代理工具，凭借加密强、速度快、配置灵活的特点，成为电脑和手机科学上网的首选。本文推荐的SSR客户端（如SSR小火箭客户端下载、Shadowsocks手机最新版）和机场服务，适用于Windows、macOS、Android、iOS等平台，支持解锁Netflix、YouTube、ChatGPT等平台。</p>
<h2>1.YAFA</h2>
<p><a href="https://affg.cc/yafa"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐⭐⭐</p>
<p>收费：15元/月（官网7折优惠）</p>
<p>简介：老牌电脑SSR梯子推荐，支持SSR协议，节点覆盖香港、日本、美国，IPLC/CN2 GIA专线，速度损失&lt;6%，解锁Netflix、Disney+，支付宝支付。</p>
<h2>2.EW梯子</h2>
<p><a href="https://affg.cc/ewan"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐⭐</p>
<p>收费：12元/月</p>
<p>简介：新兴SSR机场，节点包括新加坡、韩国，支持24小时不满意退款的免费试用，解锁ChatGPT、TikTok，TG群超4000用户，客服7x12小时。</p>
<h2>3.疾风机场</h2>
<p><a href="https://affg.cc/jife"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐⭐</p>
<p>收费：13元/月</p>
<p>简介：7年历史，IEPL专线机场，节点45+，旗舰套餐（30元/月）支持8K视频无卡顿，适合游戏（PING&lt;10ms）。</p>
<h2>4.优信梯子</h2>
<p><a href="https://affg.cc/uxin"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐</p>
<p>收费：15元/月</p>
<p>简介：小众SSR机场，隧道中转+IPLC，节点覆盖美、法、日，解锁Hulu、HBO，官网提供详细教程。</p>
<h2>5.SUYUN</h2>
<p><a href="https://affg.cc/suyu"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐</p>
<p>收费：18元/月</p>
<p>简介：支持SSR/V2Ray/Trojan，节点分布港台、欧洲，适合多平台（Windows、Android、iOS），一键导入订阅。</p>
<h2>6.青云梯子</h2>
<p><a href="https://affg.cc/qyun"><strong>直达官网地址</strong></a></p>
<p>推荐指数：⭐⭐⭐⭐</p>
<p>收费：20元/月（提供按流量计费套餐）</p>
<p>简介：高端机场，支持SSR协议，解锁流媒体，稳定性高，适合长期使用。</p>
<h2>SSR手机梯子推荐：Shadowsocks客户端安装与配置</h2>
<p>Shadowsocks客户端下载 Shadowsocks手机梯子最新版推荐使用ShadowsocksR（SSR小飞机）客户端，适用于安卓和iOS。</p>
<p>安卓：从SSR手机小飞机安装包官方渠道（如GitHub Releases）下载APK（如ShadowsocksR_3.8.2.apk）。推荐APKPure或F-Droid，确保无毒。</p>
<p>安装步骤：启用“未知来源”，运行APK，约10秒完成，支持ARM64/x86架构。</p>
<p>iOS（SSR苹果梯子）：需美区App Store下载Potatso Lite（Shadowrocket替代品，免费）。注册美区Apple ID，搜索“Potatso Lite”下载。</p>
<p>验证：打开客户端，检查版本。</p>
<p>配置SSR客户端</p>
<p>参考SSR免费节点分享：</p>
<p>打开ShadowsocksR（安卓）或Potatso Lite（iOS），点击“添加节点”。</p>
<p>SSR免费节点分享推荐：</p>
<p>GitHub ssr-free-nodes（每日更新，覆盖香港、日本、美国等50+节点）。</p>
<p>手动输入或扫描二维码导入，点击连接（绿色图标表示成功）。</p>
<p>电脑SSR梯子推荐：ShadowsocksR-PC客户端</p>
<p>For Windows/macOS/Linux, SSR小火箭客户端下载推荐ShadowsocksR-Win（类似V2rayN）：</p>
<p>下载：访问SSR梯子官网或GitHub，获取最新版本（如SSR-Win_4.9.3.exe）。</p>
<p>配置：</p>
<p>运行客户端，添加SSR免费节点分享链接或手动输入节点（服务器、端口、密码、加密方式等）。</p>
<p>设置PAC/全局模式，优化访问Google、YouTube。</p>
<p><strong>通过电脑SSR梯子推荐和SSR手机梯子推荐的优质服务，您可以轻松实现高速、稳定的科学上网。立即访问SSR梯子官网下载SSR手机小飞机安装包或SSR小火箭客户端，结合SSR免费节点分享或付费专线，享受国外梯子无限时长的畅快体验！如需帮助，加入GitHub或TG社区，与全球用户交流。SSR不仅是工具，更是通往自由网络的钥匙，安全、隐私、速度兼得！</strong></p>
</div>

[稳定 SSR 梯子推荐]支持电脑手机科学上外网的梯子全攻略，免费节点与安装包下载

<div class="markdown-text"><p>github 链接 <a href="https://github.com/Jugging/cicada-flowchart">https://github.com/Jugging/cicada-flowchart</a></p>
<p>截图
<img src="//static.cnodejs.org/FkoLI0977mkMOp-sMdj3T0WV9uxL" alt="20191222162202.png">
<img src="https://i.loli.net/2019/12/23/iABxILKJ3Pvprmt.png" alt="c015a17d-64ff-46cf-8d4c-5149f60cbd17.png">
<img src="//static.cnodejs.org/Flk1eKpyhM5ScFyM6c7BveNGtHu5" alt="8d02be4b-680f-4b2d-8f6d-91cc3aa77aa0.png"></p>
</div>

cicada-flowchart  基于vue、zrender构建的流程图

<div class="markdown-text"><h1>多实例/多租户</h1>
<p>VonaJS 通过<code>多实例</code>的概念来支持多租户 SAAS 系统的开发。只需启动一个后端服务，即可支持多个实例同时运行</p>
<p>VonaJS 支持以下几种<code>多实例/多租户</code>模式：</p>
<ol>
<li><code>共享模式</code>：多个实例共享同一个数据库，通过<code>实例Id</code>字段隔离多实例之间的数据</li>
<li><code>独立模式</code>：每个实例都使用独立的数据库，从而满足大数据量的业务需求</li>
<li><code>混合模式</code>：在一个系统中同时支持<code>共享模式</code>和<code>独立模式</code>，从而可以精确指定某个实例使用<code>共享数据库</code>还是<code>独立数据库</code></li>
</ol>
<h2>实例配置</h2>
<h3>1. 测试环境、开发环境</h3>
<p>在测试环境和开发环境中，系统默认提供了一个<code>缺省实例</code>。同时提供了两个<code>测试实例</code>，用于演示如何使用<code>共享模式</code>和<code>独立模式</code>：</p>
<p><code>src/backend/config/config/config.test.ts</code></p>
<p><code>src/backend/config/config/config.dev.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; instances
config.instances = [
  { name: &#x27;&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27;, config: {} },
  { name: &#x27;shareTest&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27; },
  { name: &#x27;isolateTest&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27;, id: 1000, isolate: true, isolateClient: &#x27;isolateTest&#x27; },
];
</code></pre><ul>
<li>实例清单</li>
</ul>
<table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>empty</td>
<td>缺省实例</td>
</tr>
<tr>
<td>shareTest</td>
<td>用于演示<code>共享模式</code>，具体而言，<code>shareTest</code>与<code>empty</code>共享同一个数据库</td>
</tr>
<tr>
<td>isolateTest</td>
<td>用于演示<code>独立模式</code>，具体而言，<code>isolateTest</code>使用独立的数据库</td>
</tr>
</tbody>
</table>
<ul>
<li>实例属性</li>
</ul>
<table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>name</td>
<td>实例名</td>
</tr>
<tr>
<td>password</td>
<td>实例中用户<code>admin</code>的初始密码，默认是<code>123456</code></td>
</tr>
<tr>
<td>title</td>
<td>网站标题</td>
</tr>
<tr>
<td>config</td>
<td>实例的配置信息</td>
</tr>
<tr>
<td>id</td>
<td>当使用<code>独立模式</code>时，必须明确指定唯一的<code>实例Id</code></td>
</tr>
<tr>
<td>isolate</td>
<td>是否使用<code>独立模式</code>，默认为<code>共享模式</code></td>
</tr>
<tr>
<td>isolateClient</td>
<td>当使用<code>独立模式</code>时，必须明确指定<code>数据源</code></td>
</tr>
</tbody>
</table>
<h3>2. 生产环境</h3>
<p>在生产环境，需要自行配置实例信息</p>
<p><code>src/backend/config/config/config.prod.ts</code></p>
<pre class="prettyprint language- typescript"><code>config.instances = [
  { name: &#x27;&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27;, config: {} },
  { name: &#x27;vona&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27;, config: {} },
];
</code></pre><h2>如何添加新实例</h2>
<p>下面以实例<code>shareTest</code>为例，演示如何添加新实例：</p>
<h3>1. 添加类型定义</h3>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>declare module &#x27;vona&#x27; {
  export interface IInstanceRecord {
    shareTest: never;
  }
}
</code></pre><ul>
<li>采用接口合并机制添加新实例的类型定义</li>
</ul>
<h3>2. 增加实例配置</h3>
<p>在需要的 config 文件中添加实例配置，比如在测试环境配置新实例：</p>
<p><code>src/backend/config/config/config.test.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; instances
config.instances = [
  { name: &#x27;shareTest&#x27;, password: &#x27;&#x27;, title: &#x27;&#x27; },
];
</code></pre><ul>
<li>对于<code>独立模式</code>，还需要配置数据源，此处从略</li>
</ul>
<h2>获取当前实例名的规则</h2>
<p>当用户访问后端 Api 时，后端会自动根据规则获取当前实例名，然后根据实例名获取实例信息</p>
<h3>1. 模块配置</h3>
<p>多实例是由模块 a-instance 提供的核心能力，可以在 App config 中修改模块的配置：</p>
<p><code>src/backend/config/config/config.prod.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; modules
config.modules = {
  &#x27;a-instance&#x27;: {
    getInstanceName: undefined,
    headerField: &#x27;x-vona-instance-name&#x27;,
    queryField: &#x27;x-vona-instance-name&#x27;,
  },
};
</code></pre><table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>getInstanceName</td>
<td>提供自定义函数，用于获取当前实例名</td>
</tr>
<tr>
<td>headerField</td>
<td>从request header中获取当前实例名，header key默认为<code>x-vona-instance-name</code></td>
</tr>
<tr>
<td>queryField</td>
<td>从request query中获取当前实例名，query key默认为<code>x-vona-instance-name</code></td>
</tr>
</tbody>
</table>
<h3>2. 规则次序</h3>
<p>系统按以下次序，依次判断当前实例名，当获取到实例名时则停止判断流程</p>
<ol>
<li>如果提供了<code>getInstanceName</code>，则调用此函数</li>
<li>如果<code>queryField</code>不为空，则从 request query 中获取</li>
<li>如果<code>headerField</code>不为空，则从 request header 中获取</li>
<li>从域名中解析实例名</li>
</ol>
<h3>3. 如何从域名中解析实例名</h3>
<p>比如，域名为<code>https://cabloy.com</code>，那么对应的实例名是<code>cabloy</code>。可以通过配置<code>SERVER_SUBDOMAINOFFSET</code>来修改计算规则</p>
<p><code>env/.env</code></p>
<pre class="prettyprint language- typescript"><code># server
SERVER_SUBDOMAINOFFSET = 1
</code></pre><ul>
<li>当<code>SERVER_SUBDOMAINOFFSET = 1</code>时，域名与实例名对应关系如下：</li>
</ul>
<table>
<thead>
<tr>
<th>域名</th>
<th>实例名</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="http://cabloy.com">cabloy.com</a></td>
<td>cabloy</td>
</tr>
<tr>
<td><a href="http://store.cabloy.com">store.cabloy.com</a></td>
<td>cabloy.store</td>
</tr>
</tbody>
</table>
<ul>
<li>当<code>SERVER_SUBDOMAINOFFSET = 2</code>时，域名与实例名对应关系如下：</li>
</ul>
<table>
<thead>
<tr>
<th>域名</th>
<th>实例名</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="http://cabloy.com">cabloy.com</a></td>
<td>空字符串</td>
</tr>
<tr>
<td><a href="http://store.cabloy.com">store.cabloy.com</a></td>
<td>store</td>
</tr>
</tbody>
</table>
<h2>使用多实例</h2>
<h3>1. 访问当前实例信息</h3>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; 当前实例名
const name = this.ctx.instanceName;
&#x2F;&#x2F; 当前实例对象
const instance = this.ctx.instance;
&#x2F;&#x2F; 当前实例Id
const iid = this.ctx.instance.id;
</code></pre><h3>2. 使用Model操作数据库</h3>
<p>由于多实例的数据是相互隔离的，因此在操作数据库时，需要指定<code>实例Id</code>。VonaJS 提供了非常强大的<code>Model</code>对象，从而可以透明的处理多实例</p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; create
await this.scope.model.student.insert({ name: &#x27;Tom&#x27; });
&#x2F;&#x2F; select
await this.scope.model.student.select();
&#x2F;&#x2F; get
await this.scope.model.student.get({ id: 1 });
&#x2F;&#x2F; update
await this.scope.model.student.update({ id: 1, name: &#x27;Jimmy&#x27; });
&#x2F;&#x2F; delete
await this.scope.model.student.delete({ id: 1 });
</code></pre><p>当我们使用 Model <code>student</code>操作数据时，系统会自动设置<code>实例Id</code></p>
<h3>3. 使用Query Builder操作数据库</h3>
<p>如果使用<code>builder()</code>方法操作数据库，就需要自行添加<code>实例Id</code></p>
<pre class="prettyprint language- typescript"><code>await this.scope.model.student.builder().where({
  iid: this.ctx.instance.id,
  name: &#x27;Tom&#x27;,
});
</code></pre><p>如果使用<code>builderSelect()</code>方法操作数据库，系统会自动添加<code>实例Id</code></p>
<pre class="prettyprint language- typescript"><code>await this.scope.model.student.builderSelect().where({
  name: &#x27;Tom&#x27;,
});
</code></pre><h3>4. 使用原生Sql操作数据库</h3>
<p>如果使用<code>原生Sql</code>操作数据库，就需要自行添加<code>实例Id</code></p>
<pre class="prettyprint language- typescript"><code>await this.scope.model.student.query(
  &#x27;select * from demoStudent where iid=?&#x27;,
  [this.ctx.instance.id],
);
await this.scope.model.student.queryOne(
  &#x27;select * from demoStudent where iid=? and id=?&#x27;,
  [this.ctx.instance.id, 1],
);
</code></pre><p>Vona ORM已开源：<a href="https://github.com/vonajs/vona">https://github.com/vonajs/vona</a></p>
</div>

VonaJS多租户同时支持共享模式和独立模式

<div class="markdown-text"><p>最近在找工作，感觉很卷，真的完蛋了吗</p>
</div>

35岁的前端真的完蛋了吗？

<div class="markdown-text"><h1>分表</h1>
<p>针对高并发、数据量大的场景，通常会考虑采用分表机制进行优化。下面以 Model User/Order 为例，通过查询用户的订单列表，来演示<code>分表</code>的使用方法</p>
<h2>分表规则</h2>
<p>比如需要对订单表进行分表操作。可以根据实际业务需求设计分表规则，在这里，根据<code>用户Id</code>取模动态生成表名。比如，拆分为<code>16</code>张表，<code>用户Id</code>为<code>129</code>，对应的表名如下：</p>
<pre class="prettyprint language- typescript"><code>const tableName = &#96;Order_${129 % 16}&#96;;  &#x2F;&#x2F; Order_1
</code></pre><h2>准备Models</h2>
<p>先准备两个 Models：User/Order</p>
<ol>
<li>Model Order</li>
</ol>
<pre class="prettyprint language- typescript"><code>@Model({
  entity: EntityOrder,
})
class ModelOrder{}
</code></pre><ol>
<li>Model User</li>
</ol>
<pre class="prettyprint language- typescript"><code>@Model({
  entity: EntityUser,
  relations: {
    orders: $relation.hasMany(() =&gt; ModelOrder, &#x27;userId&#x27;),
  },
})
class ModelUser {}
</code></pre><h2>查询数据</h2>
<h3>1. 直接查询订单列表</h3>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectOrdersDirectly() {
    const userId = 129;
    const orders = await this.scope.model.order.select({
      where: {
        userId,
      },
    });
  }
}  
</code></pre><p>到目前为止，使用<code>默认表名</code>查询<code>userId=129</code>的订单列表</p>
<h3>2. 基于关系查询订单列表</h3>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectOrdersByRelation() {
    const userId = 129;
    const userAndOrders = await this.scope.model.user.get({
      id: userId,
    }, {
      include: {
        orders: true,
      },
    });
  }
}  
</code></pre><p>到目前为止，使用<code>默认表名</code>查询<code>userId=129</code>的用户信息，使用<code>默认表名</code>查询该用户的订单列表</p>
<h2>使用分表：动态方式</h2>
<p>可以在代码中动态使用分表：</p>
<pre class="prettyprint language- diff"><code>class ServiceOrder {
  async selectOrdersDirectly() {
    const userId = 129;
+   const tableName = &#96;Order_${userId % 16}&#96;;
+   const modelOrder = this.scope.model.order.newInstance(undefined, tableName as any);
    const orders = await modelOrder.select({
      where: {
        userId,
      },
    });
  }
}  
</code></pre><ul>
<li><code>newInstance</code>: 传入要使用的表名，返回新的 Model 实例</li>
</ul>
<p>到目前为止，使用<code>分表</code>查询<code>userId=129</code>的订单列表</p>
<h2>使用分表：Relation动态选项</h2>
<p>可以在 relation 选项中动态指定表名：</p>
<pre class="prettyprint language- diff"><code>class ServiceOrder {
  async selectOrdersByRelation() {
    const userId = 129;
+   const tableName = &#96;Order_${userId % 16}&#96;;
    const userAndOrders = await this.scope.model.user.get({
      id: userId,
    }, {
      include: {
        orders: {
+         meta: {
+           table: tableName as any,
+         },
        },
      },
    });
  }
}  
</code></pre><ul>
<li><code>meta.table</code>: 指定 relation <code>orders</code>要使用的表名</li>
</ul>
<p>到目前为止，使用<code>默认表名</code>查询<code>userId=129</code>的用户信息，使用<code>分表</code>查询该用户的订单列表</p>
<h2>使用分表：Model配置</h2>
<p>也可以直接在 Model 中配置分表规则，从而简化查询代码</p>
<ol>
<li>Model Order</li>
</ol>
<pre class="prettyprint language- diff"><code>@Model({
  entity: EntityOrder,
+ table(_ctx: VonaContext, where: EntityOrder | undefined, defaultTable: keyof ITableRecord) {
+   const userId = where?.userId;
+   if (!userId) return defaultTable;
+   return &#96;Order_${Number(userId) % 16}&#96;;
+ },
})
class ModelOrder{}
</code></pre><ul>
<li><code>table</code>: 指定函数，实现分表规则</li>
</ul>
<ol>
<li>查询数据</li>
</ol>
<p>现在，又可以使用常规的方式查询用户的订单列表</p>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectOrdersDirectly() {
    const userId = 129;
    const orders = await this.scope.model.order.select({
      where: {
        userId,
      },
    });
  }
}  
</code></pre><pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectOrdersByRelation() {
    const userId = 129;
    const userAndOrders = await this.scope.model.user.get({
      id: userId,
    }, {
      include: {
        orders: true,
      },
    });
  }
}  
</code></pre><h2>使用分表：App Config配置</h2>
<p>也可以在 App config 中配置 Model options:</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; onions
config.onions = {
  model: {
    &#x27;test-vona:order&#x27;: {
      table(_ctx: VonaContext, where: EntityOrder | undefined, defaultTable: keyof ITableRecord) {
        const userId = where?.userId;
        if (!userId) return defaultTable;
        return &#96;Order_${Number(userId) % 16}&#96;;
      },
    },
  },
};
</code></pre><p>于是，也可以使用常规的方式查询用户的订单列表</p>
<h2>使用分表：Relation静态选项</h2>
<p>也可以在定义 Relation 时指定静态选项：</p>
<pre class="prettyprint language- diff"><code>@Model({
  entity: EntityUser,
  relations: {
    orders: $relation.hasMany(() =&gt; ModelOrder, &#x27;userId&#x27;, {
+     meta: {
+       table(_ctx: VonaContext, where: EntityOrder | undefined, defaultTable: keyof ITableRecord) {
+         const userId = where?.userId;
+         if (!userId) return defaultTable;
+         return &#96;Order_${Number(userId) % 16}&#96;;
+       },
+     },
    }),
  },
})
class ModelUser {}
</code></pre><p>同样，也可以使用常规的方式查询用户的订单列表</p>
<p>Vona ORM已开源：<a href="https://github.com/vonajs/vona">github.com/vonajs/vona</a></p>
</div>

Vona ORM分表全攻略

<div class="markdown-text"><p>在Vona ORM中实现<code>多数据库/多数据源</code>非常直观、简便。下面以 Model User/Order 为例，通过查询用户的订单列表，来演示<code>多数据库/多数据源</code>的使用方法</p>
<h2>准备Models</h2>
<p>先准备两个 Models：User/Order</p>
<ol>
<li>Model Order</li>
</ol>
<pre class="prettyprint language- typescript"><code>@Model({
  entity: EntityOrder,
})
class ModelOrder{}
</code></pre><ul>
<li>需要指定ModelOrder关联的Entity，限于篇幅，EntityOrder代码从略</li>
</ul>
<ol>
<li>Model User</li>
</ol>
<pre class="prettyprint language- typescript"><code>@Model({
  entity: EntityUser,
  relations: {
    orders: $relation.hasMany(() =&gt; ModelOrder, &#x27;userId&#x27;),
  },
})
class ModelUser {}
</code></pre><ul>
<li>在ModelUser中定义<code>1:n</code>关系: <code>orders</code></li>
</ul>
<h2>查询数据</h2>
<p>然后查询用户的订单列表</p>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectUserOrders() {
    const userId = 1;
    const userAndOrders = await this.scope.model.user.get(
      {
        id: userId,
      },
      {
        include: {
          orders: true,
        },
      },
    );
  }
}  
</code></pre><p>到目前为止，使用<code>系统默认数据源</code>查询到了<code>userId=1</code>的用户信息，和该用户的所有订单列表</p>
<h2>创建多数据源</h2>
<p>接下来，创建两个数据源：<code>user-pg</code>和<code>order-mysql</code></p>
<h3>1. 添加数据源的类型定义</h3>
<ul>
<li>
<p>在 VSCode 中，通过右键菜单<code>Vona Init/Types</code>在模块中创建类型文件</p>
</li>
<li>
<p>然后在类型文件中添加类型定义</p>
</li>
</ul>
<p><code>{module path}/src/types/index.ts</code></p>
<pre class="prettyprint language- typescript"><code>declare module &#x27;vona-module-a-orm&#x27; {
  export interface IDatabaseClientRecord {
    &#x27;user-pg&#x27;: never;
    &#x27;order-mysql&#x27;: never;
  }
}
</code></pre><ul>
<li><code>IDatabaseClientRecord</code>是模块<code>vona-module-a-orm</code>提供的接口类型。在这里通过接口合并的机制来添加新的数据源类型</li>
</ul>
<h3>2. 数据源配置</h3>
<p>在项目的App config文件中定义数据源的配置信息。由于前面已经添加了数据源类型，在App config文件中就可以享受完整的类型提示</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; database
config.database = {
  clients: {
    &#x27;user-pg&#x27;: {
      client: &#x27;pg&#x27;,
      connection: {
        host: &#x27;127.0.0.1&#x27;,
        port: 5432,
        user: &#x27;postgres&#x27;,
        password: &#x27;&#x27;,
        database: &#x27;user-xxx&#x27;,
      },
    },
    &#x27;order-mysql&#x27;: {
      client: &#x27;mysql2&#x27;,
      connection: {
        host: &#x27;127.0.0.1&#x27;,
        port: 3306,
        user: &#x27;root&#x27;,
        password: &#x27;&#x27;,
        database: &#x27;order-xxx&#x27;,
      },
    },
  },
};
</code></pre><ul>
<li><code>user-pg</code>: 使用数据库方言：<code>pg</code></li>
<li><code>order-mysql</code>: 使用数据库方言：<code>mysql2</code></li>
</ul>
<h2>使用数据源：动态方式</h2>
<p>可以在代码中动态使用数据源：</p>
<pre class="prettyprint language- diff"><code>class ServiceOrder {
  async selectUserOrders() {
    const userId = 1;
+   const modelUser = this.scope.model.user.newInstance(&#x27;user-pg&#x27;);
    const userAndOrders = await modelUser.get(
      {
        id: userId,
      },
      {
        include: {
          orders: true,
        },
      },
    );
  }
}  
</code></pre><ul>
<li><code>newInstance</code>: 传入要使用的数据源，返回新的 Model 实例</li>
</ul>
<p>到目前为止，使用数据源<code>user-pg</code>查询用户信息，使用<code>系统默认数据源</code>查询订单列表</p>
<h2>使用数据源：Relation动态选项</h2>
<p>可以在 relation 选项中动态指定数据源：</p>
<pre class="prettyprint language- diff"><code>class ServiceOrder {
  async selectUserOrders() {
    const userId = 1;
    const modelUser = this.scope.model.user.newInstance(&#x27;user-pg&#x27;);
    const userAndOrders = await modelUser.get(
      {
        id: userId,
      },
      {
        include: {
          orders: {
+           meta: {
+             client: &#x27;order-mysql&#x27;,
+           },
          },
        },
      },
    );
  }
}  
</code></pre><ul>
<li><code>meta.client</code>: 指定 relation <code>orders</code>要使用的数据源</li>
</ul>
<p>到目前为止，使用数据源<code>user-pg</code>查询用户信息，使用数据源<code>order-mysql</code>查询订单列表</p>
<h2>使用数据源：Model配置</h2>
<p>也可以直接在 Model 中配置数据源，从而简化查询代码</p>
<ol>
<li>Model Order</li>
</ol>
<pre class="prettyprint language- diff"><code>@Model({
  entity: EntityOrder,
+ client: &#x27;order-mysql&#x27;,
})
class ModelOrder{}
</code></pre><ul>
<li>在VonaJS框架中，可以非常方便的为<code>@Model</code>装饰器指定参数</li>
</ul>
<ol>
<li>Model User</li>
</ol>
<pre class="prettyprint language- diff"><code>@Model({
  entity: EntityUser,
+ client: &#x27;user-pg&#x27;,
  relations: {
    orders: $relation.hasMany(() =&gt; ModelOrder, &#x27;userId&#x27;),
  },
})
class ModelUser {}
</code></pre><ol>
<li>查询数据</li>
</ol>
<p>现在，又可以使用常规的方式查询用户的订单列表</p>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async selectUserOrders() {
    const userId = 1;
    const userAndOrders = await this.scope.model.user.get(
      {
        id: userId,
      },
      {
        include: {
          orders: true,
        },
      },
    );
  }
}  
</code></pre><h2>使用数据源：App Config配置</h2>
<p>也可以在 App config 中配置 Model options:</p>
<p><code>src/backend/config/config/config.ts</code></p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; onions
config.onions = {
  model: {
    &#x27;test-vona:user&#x27;: {
      client: &#x27;user-pg&#x27;,
    },
    &#x27;test-vona:order&#x27;: {
      client: &#x27;order-mysql&#x27;,
    },
  },
};
</code></pre><ul>
<li>在VonaJS框架中，可以在App Config文件中提供配置，用于覆盖对应Model的options配置</li>
</ul>
<p>于是，也可以使用常规的方式查询用户的订单列表</p>
<h2>使用数据源：Relation静态选项</h2>
<p>也可以在定义 Relation 时指定静态选项：</p>
<pre class="prettyprint language- diff"><code>@Model({
  entity: EntityUser,
  client: &#x27;user-pg&#x27;,
  relations: {
    orders: $relation.hasMany(() =&gt; ModelOrder, &#x27;userId&#x27;, {
+     meta: {
+       client: &#x27;order-mysql&#x27;,
+     },
    }),
  },
})
class ModelUser {}
</code></pre><p>同样，也可以使用常规的方式查询用户的订单列表</p>
<p>Vona ORM已开源：<a href="https://github.com/vonajs/vona">github.com/vonajs/vona</a></p>
</div>

在Vona ORM中实现多数据库/多数据源

<div class="markdown-text"><p>本文将对一款基于 uni-app 开发的废品回收类多端应用，从多端支持范围、核心功能模块及部分界面展示进行客观说明，相关资源信息也将一并呈现。</p>
<h1>一、多端支持范围</h1>
<p>该应用基于 uni-app 技术开发，支持打包为多终端形态，具体覆盖以下场景：
H5 端
多平台小程序（微信、支付宝、小红书、抖音等）
App 端（适配 Android 与 iOS 两大移动操作系统）</p>
<h1>二、核心功能模块说明</h1>
<p>当前版本应用包含两大核心功能模块，各模块的作用与操作逻辑如下：</p>
<ol>
<li>废品回收商家入驻模块
此模块主要服务于废品回收商家的平台入驻需求，入驻后可实现以下操作：
接收用户发起的回收订单；
完成回收服务后，在系统内录入回收总量及对应回收金额。
同时，用户可依据所在城市维度及当前定位，获取附近已入驻商家的推荐结果，进而选择 “预约上门回收” 或 “自行到店回收” 两种服务方式。</li>
<li>用户回收预约模块
该模块为用户提供废品回收预约的全流程功能，具体操作步骤包括：
选择预约上门时间、废品类型，填写预计回收总量，上传废品照片及补充描述信息，提交后即完成回收预约；
回收服务完成后，用户可获得相应收益与积分；
用户可通过应用内指定界面，提交收益提现申请。</li>
<li>后续功能说明
除上述已实现的核心模块外，其他功能将以 “后续版本发布说明” 为准，具体更新内容需参考官方后续公示的信息。</li>
</ol>
<h1>三、相关资源获取地址</h1>
<p>该应用的开发资源及代码可通过以下平台获取，供技术研究或参考使用：
<a href="https://github.com/gooking/recycle">Github 地址</a>
<a href="https://gitee.com/javazj/recycle">码云镜像地址</a>
<a href="https://gitcode.com/gooking2/recycle">GitCode 镜像地址</a></p>
</div>

基于 uni-app 开发的废品回收类多端应用功能与界面说明

<div class="markdown-text"><p>客户端在请求 egg.js 服务的时候，每天都会有非常小量的 “connection reset by peer” 报错？</p>
</div>

eggjs 服务端返回 connection reset by peer ？

<div class="markdown-text"><p>在开发后端 API 服务时，DTO 是进行<code>参数验证</code>、<code>生成Swagger元数据</code>的关键节点。如果不能像推断类型一样动态推断出 DTO，那么，我们就仍然需要手工创建 DTO。随着业务的增长，复杂的表间关系会让手工补充 DTO 的工作日益繁重</p>
<p>而 Vona ORM 首创 DTO 动态推断与生成能力，解放我们的双手，显著提升生产力。甚至可以说，对于构建更加优雅的 Node.js 后端框架而言，能够动态推断与生成 DTO，是非常重要的<code>里程碑</code></p>
<h2>DTO清单</h2>
<p>Vona ORM 提供了以下 DTO：</p>
<table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>get</td>
<td>标注返回结果</td>
</tr>
<tr>
<td>query</td>
<td>标注Query参数</td>
</tr>
<tr>
<td>queryPage</td>
<td>标注带分页的Query参数</td>
</tr>
<tr>
<td>selectAndCount</td>
<td>标注带分页的返回结果</td>
</tr>
<tr>
<td>create</td>
<td>标注Create参数</td>
</tr>
<tr>
<td>update</td>
<td>标注Update参数</td>
</tr>
<tr>
<td>aggregate</td>
<td>标注聚合操作的返回结果</td>
</tr>
<tr>
<td>group</td>
<td>标注分组操作的返回结果</td>
</tr>
</tbody>
</table>
<h2>DTO使用方法</h2>
<p>下面以 Order/Product 为例，演示如何针对<code>主表-明细表</code>进行查询操作</p>
<h2>1. Model关系定义</h2>
<p>先在 Model Order 中定义与 Model Product 的<code>1:n</code>关系</p>
<pre class="prettyprint language-typescript"><code>@Model({
  entity: EntityOrder,
  relations: {
    products: $relation.hasMany(() =&gt; ModelProduct, &#x27;orderId&#x27;, {
      columns: [&#x27;id&#x27;, &#x27;name&#x27;, &#x27;price&#x27;, &#x27;quantity&#x27;, &#x27;amount&#x27;],
    }),
  },
})
class ModelOrder {}
</code></pre><ul>
<li><code>relations.products</code>: 定义<code>1:n</code>关系</li>
</ul>
<h2>2. 创建Api端点</h2>
<p>创建 Controller，提供 findAll 方法</p>
<pre class="prettyprint language-typescript"><code>class ControllerOrder {
  @Web.get(&#x27;findAll&#x27;)
  async findAll() {
    return this.scope.model.order.select({
      include: {
        products: true,
      },
    });
  }
}
</code></pre><ul>
<li><code>model.order</code>: 是Order的model实例</li>
<li><code>select</code>：指定<code>include.products: true</code>，从而查询出<code>主表-明细表</code>数据</li>
</ul>
<h2>3. 动态推断与生成DTO</h2>
<p>由于此 Api 返回的结果是<code>主表-明细表</code>结构，我们不能简单的使用<code>EntityOrder数组</code>来标注返回类型。而是使用 DTO 进行动态推断与生成</p>
<pre class="prettyprint language-diff"><code>+ import { $Dto } from &#x27;vona-module-a-orm&#x27;;

class ControllerOrder {
  @Web.get(&#x27;findAll&#x27;)
+ @Api.body(v.array($Dto.get(() =&gt; ModelOrder, { include: { products: true } })))
  async findAll() {
    return this.scope.model.order.select({
      include: {
        products: true,
      },
    });
  }
}
</code></pre><ul>
<li><code>@Api.body</code>：标注返回结果</li>
<li><code>v.array</code>: 标注数组</li>
<li><code>$Dto.get</code>: 用于动态推断与生成 DTO</li>
</ul>
<p><code>$Dto.get</code>生成的 DTO 是<code>主表-明细表</code>结构，其 Swagger/Openapi 效果如下：</p>
<p><img src="//static.cnodejs.org/Fp4KCNN059rhX3LYML6ay_ya-l9k" alt="dto-1.png"></p>
<h2>4. 封装DTO</h2>
<p>我们还可以创建一个新的 DTO class，将前面的<code>$Dto.get</code>动态推断代码封装起来，从而用于其他地方</p>
<ol>
<li>在 VSCode 中，可以通过右键菜单<code>Vona Create/Dto</code>创建 DTO 的代码骨架：</li>
</ol>
<pre class="prettyprint language-typescript"><code>@Dto()
export class DtoOrderResult {}
</code></pre><ol>
<li>使用继承机制来封装 DTO：</li>
</ol>
<pre class="prettyprint language-diff"><code>+ import { $Dto } from &#x27;vona-module-a-orm&#x27;;

@Dto()
export class DtoOrderResult
+ extends $Dto.get(() =&gt; ModelOrder, { include: { products: true } }) {}
</code></pre><ol>
<li>现在，我们再使用<code>DtoOrderResult</code>重构前面的 API 代码：</li>
</ol>
<pre class="prettyprint language-diff"><code>class ControllerOrder {
  @Web.get(&#x27;findAll&#x27;)
+ @Api.body(v.array(DtoOrderResult))
+ async findAll(): Promise&lt;DtoOrderResult[]&gt; {
    return this.scope.model.order.select({
      include: {
        products: true,
      },
    });
  }
}
</code></pre><ul>
<li>行 3: 直接使用<code>v.array(DtoOrderResult)</code>标注类型</li>
<li>行 4: 方法返回类型为<code>Promise&lt;DtoOrderResult[]&gt;</code></li>
</ul>
<p>Vona ORM已开源：<a href="https://github.com/vonajs/vona">github.com/vonajs/vona</a></p>
</div>

能够动态推断与生成DTO是Node生态的一个重要里程碑

<div class="markdown-text"><p>针对高并发、数据量大的场景，通常会考虑采用<code>分库分表</code>进行优化。在这篇文章，我们重点盘点一下Node.js主流ORM框架的动态分表方案：</p>
<h2>分表规则</h2>
<p>比如我们需要对订单表进行分表操作。可以根据实际业务需求设计分表规则，在这里，我们根据顾客Id取模动态生成表名。比如，拆分为16张表，顾客Id为129，对应的表名如下：</p>
<pre class="prettyprint language- typescript"><code>const tableName = &#96;Order_${129 % 16}&#96;;  &#x2F;&#x2F; Order_1
</code></pre><h2><a href="https://typeorm.io">TypeORM</a></h2>
<p>在TypeORM中可以按照如下方式设置动态表名：</p>
<pre class="prettyprint language- typescript"><code>&#x2F;&#x2F; 获取repository
const repositoryOrder = dataSource.createQueryBuilder().connection.getRepository(EntityOrder);
&#x2F;&#x2F; 设置动态表名
const userId = 129;
const tableName = &#96;Order_${userId % 16}&#96;;
repositoryOrder.metadata.tablePath = tableName;
&#x2F;&#x2F; 查询订单
const orders = await repositoryOrder.find();
</code></pre><h2><a href="https://orm.drizzle.team">Drizzle ORM</a></h2>
<p><code>schema.ts</code></p>
<pre class="prettyprint language- typescript"><code>const orderFactory = userId =&gt; pgTable(
  &#96;Order_${userId % 16}&#96;,
  {
    id: serial(&#x27;id&#x27;).primaryKey(),  
    name: text(&#x27;name&#x27;).notNull(),
  },
);

export const order0 = orderFactory(0);
...
export const order15 = orderFactory(15);
</code></pre><p><code>query.ts</code></p>
<pre class="prettyprint language- typescript"><code>import * as schema from &#x27;.&#x2F;db&#x2F;schema&#x27;;

const db = drizzle(process.env.DATABASE_URL!, { schema });

const userId = 129;
const modelName=&#96;order${userId % 16}&#96;;
const orders = await db.query[modelName].findMany();
</code></pre><h2><a href="https://www.prisma.io/docs">Prisma ORM</a></h2>
<p>Prisma ORM对动态表名的支持还在规划当中，参见：<a href="https://github.com/prisma/prisma/issues/1708">Table Partitioning</a></p>
<p>作为备选方案，我们可以使用<code>$queryRawUnsafe</code>直接构造原始SQL：</p>
<pre class="prettyprint language- typescript"><code>const userId = 129;
const tableName = &#96;Order_${userId % 16}&#96;;  
const orders = await prisma.$queryRawUnsafe(&#96;SELECT * FROM &quot;${tableName}&quot;&#96;);
</code></pre><h2><a href="https://vona.js.org/guide/techniques/orm/introduction.html">Vona ORM</a></h2>
<p>Vona ORM提供了两种模式：自动模式/手工模式</p>
<h3>1. 自动模式</h3>
<p><code>model/order.ts</code></p>
<pre class="prettyprint language- typescript"><code>import { EntityOrder } from &#x27;..&#x2F;entity&#x2F;order.ts&#x27;;

@Model({
  entity: EntityOrder,
  table(ctx: VonaContext, defaultTable: keyof ITableRecord) {
    const user = ctx.app.bean.passport.getCurrentUser();
    if (!user) return defaultTable;
    return &#96;${defaultTable}_${Number(user.id) % 16}&#96;;
  },
})
export class ModelOrder {}
</code></pre><ul>
<li>defaultTable: 是在EntityOrder中定义的缺省表名，如：<code>Order</code></li>
</ul>
<p><code>service/order.ts</code></p>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async findAll() {
    return await this.scope.model.order.select();
  }
}
</code></pre><h3>2. 手工模式</h3>
<p><code>service/order.ts</code></p>
<pre class="prettyprint language- typescript"><code>class ServiceOrder {
  async findAll() {
    const user = this.bean.passport.getCurrentUser();
    const tableName = &#96;Order_${Number(user!.id) % 16}&#96;;
    const modelOrder = this.scope.model.order.newInstance(undefined, tableName as any);
    return await modelOrder.select();
  }
}
</code></pre><ul>
<li>newInstance: 第一个参数可以传入数据源，从而实现<code>分库</code>能力。这里忽略，因此传入undefined</li>
</ul>
</div>

Node.js 主流ORM框架动态分表方案大盘点

<div class="markdown-text"><p>上周，我薅了 Warp 一个月的 Turbo 会员（包含一万次请求），趁着这波“东风”，开发了一个基于大模型的 OCR 网站：<a href="https://llmocr.com/zh">LLMOCR</a></p>
<p>目前，网站基于 Mistral OCR 打造，属于一个“套壳”版本，但已经能提供高效、稳定的文字识别服务。未来，我计划接入更多大模型并新增功能，让它变得更强大。</p>
<h2>网站速览</h2>
<ul>
<li><strong>核心技术</strong>：基于前沿大模型，OCR 识别又快又准。</li>
<li><strong>当前阶段</strong>：Mistral OCR 驱动，性能可靠，体验流畅。</li>
<li><strong>未来计划</strong>：更多大模型 + 新功能，敬请期待！</li>
</ul>
<h2>Warp 使用心得</h2>
<p>这次开发中，Warp 的表现让我眼前一亮。相比 Cursor，它的速度快了不少，Coding 起来特别带感。不过，用到 4000 次请求左右时，我感觉速度稍微慢了一点，可能是资源限制的原因。但总体来说，Warp 的性能和稳定性还是很值得点赞的！</p>
<h2>欢迎体验</h2>
<p>网站已经上线，快来 <a href="https://llmocr.com/zh">LLMOCR</a> 试试大模型 OCR 的魅力吧！后续我会持续优化，欢迎大家多提建议，一起把它打造成更好用的工具！</p>
</div>

Vibe Coding了一个LLM OCR工具

<div class="markdown-text"><p>为了响应快速开发企业网站，并且能够适配移动端，完整的使用tailwind css写一套还挺复杂。</p>
<p>虽然有很多的UI框架，这些框架开发管理系统还可以，有着统一的UI风格，企业网站主要面向C端用户，有着不同设计风格需求，那么之前的bootstrap布局的页面还是很不错的选择。</p>
<p>比如就可以在<a href="https://www.mobanwang.com/">模板王</a>中下载一套项目代码，通过将内容和文字做一些修改，即可给客户使用。</p>
<p>接下来是改造的过程：</p>
<p>改造最初通过询问AI，给出了2个方案；</p>
<ul>
<li>第一，使用bootstrap-vue-next，然后配合tailwind css进行改造【使用的此方法，改动量很大，放弃】；</li>
<li>第二，将js和css文件迁移的public目录下，然后在项目中加载，这样只需要将html文件修改为.vue的文件类型，然后修改很少的链接跳转方式即可。</li>
</ul>
<p>本文中采用第二种方案。</p>
<p><strong>&lt;font style=“background-color:#D9EAFC;”&gt;迁移过程最痛苦的2件事，在vue中js的加载时机 和 迁移静态资源public/assets。&lt;/font&gt;</strong></p>
<h2>下载代码</h2>
<p>本次改造的项目代码，原模板下载<a href="https://www.mobanwang.com/mb/demo/22705/">https://www.mobanwang.com/mb/demo/22705/</a>；</p>
<p>也可以下载其他网络上的优秀的企业站代码。</p>
<p><img src="//static.cnodejs.org/FqXmAFlI_6BfkixbyLswOj30D5cj" alt="1213233453.png"></p>
<pre class="prettyprint language-plain"><code>├── about.html
├── assets
│   ├── css
│   │   ├── bootstrap.min.css
│   │   ├── em-breadcrumb.css
│   │   ├── plugin_theme_css.css
│   │   └── responsive.css
│   ├── fonts
│   │   ├── Flaticon.woff
│   │   ├── Flaticon.woff2
│   │   ├── Sofia Pro Bold.ttf
│   │   ├── aprova0698.eot
│   │   ├── aprova0698.svg
│   │   ├── aprova0698.ttf
│   │   ├── aprova0698.woff
│   │   ├── fontawesome-webfont3295.ttf
│   │   ├── fontawesome-webfont3295.woff
│   │   ├── fontawesome-webfont3295.woff2
│   │   ├── icofont.eot
│   │   ├── icofont.svg
│   │   ├── icofont.ttf
│   │   ├── icofont.woff
│   │   ├── icofont.woff2
│   │   ├── themify.ttf
│   │   └── themify.woff
│   ├── images
│   │   ├── about-img-1.jpg
│   │   ├── b1.jpg
│   │   ├── b2.jpg
│   │   ├── b3.jpg
│   │   ├── b4.jpg
│   │   ├── b5.jpg
│   │   ├── b6.jpg
│   │   ├── b7.jpg
│   │   ├── b8.jpg
│   │   ├── blog-sidebar1.jpg
│   │   ├── blog-sidebar2.jpg
│   │   ├── blog-sidebar3.jpg
│   │   ├── br1.jpg
│   │   ├── br2.jpg
│   │   ├── br3.jpg
│   │   ├── br4.jpg
│   │   ├── br5.jpg
│   │   ├── contact-bg.jpg
│   │   ├── faq-img.png
│   │   ├── favicon.png
│   │   ├── fottor-bg.jpg
│   │   ├── logo1.png
│   │   ├── logo2.png
│   │   ├── service-bg-img.jpg
│   │   ├── service-img.png
│   │   ├── single-blog.jpg
│   │   ├── single-service.jpg
│   │   ├── skill-img.jpg
│   │   ├── slide-03.jpg
│   │   ├── slider1.jpg
│   │   ├── slider2.jpg
│   │   ├── tab-img.jpg
│   │   ├── tab-img2.jpg
│   │   ├── tab-img3.jpg
│   │   ├── team-bg.jpg
│   │   ├── team1.jpg
│   │   ├── team1.png
│   │   ├── team2.jpg
│   │   ├── team2.png
│   │   ├── team3.jpg
│   │   ├── team3.png
│   │   ├── team4.png
│   │   ├── test1.png
│   │   ├── test2.png
│   │   ├── test3.png
│   │   └── test4.png
│   ├── js
│   │   ├── BeerSlider.js
│   │   ├── ajax-mail.js
│   │   ├── bootstrap.min.js
│   │   ├── bootstrap.min.js.map
│   │   ├── customizer.js
│   │   ├── imagesloaded.pkgd.min.js
│   │   ├── isotope.pkgd.min.js
│   │   ├── jquery.appear.js
│   │   ├── jquery.knob.js
│   │   ├── jquery.meanmenu.js
│   │   ├── jquery.nivo.slider.pack.js
│   │   ├── jquery.waitforimages.js
│   │   ├── map.js
│   │   ├── modernizr.custom.79639.js
│   │   ├── owl.carousel.min.js
│   │   ├── slick.min.js
│   │   ├── swiper-bundle.min.js.map
│   │   ├── theme-pluginjs.js
│   │   ├── theme.js
│   │   └── vendor
│   │       ├── jquery-3.5.1.min.js
│   │       └── modernizr-2.8.3.min.js
│   └── webfonts
│       ├── fa-brands-400.eot
│       ├── fa-brands-400.svg
│       ├── fa-brands-400.ttf
│       ├── fa-brands-400.woff
│       ├── fa-brands-400.woff2
│       ├── fa-regular-400.eot
│       ├── fa-regular-400.svg
│       ├── fa-regular-400.ttf
│       ├── fa-regular-400.woff
│       ├── fa-regular-400.woff2
│       ├── fa-solid-900.eot
│       ├── fa-solid-900.svg
│       ├── fa-solid-900.ttf
│       ├── fa-solid-900.woff
│       └── fa-solid-900.woff2
├── blog-left-sidebar.html
├── blog-right-sidebar.html
├── blog.html
├── contact.html
├── faq.html
├── home-video.html
├── index.html
├── landing-page.html
├── portfolio-3column.html
├── portfolio-4column.html
├── portfolio.html
├── pricing-table.html
├── service.html
├── single-blog.html
├── single-service.html
├── style.css
├── team.html
├── testimonial.html
└── venobox
    ├── close.gif
    ├── next.gif
    ├── preload-circle.png
    ├── preload-dots.png
    ├── preload-ios.png
    ├── preload-quads.png
    ├── preload.png
    ├── prev.gif
    ├── venobox.css
    ├── venobox.js
    └── venobox.min.js

9 directories, 133 files
</code></pre><h2>迁移静态资源</h2>
<p>分为3中情况</p>
<ul>
<li>assets下的图片资源，统一存放到<code>public/assets</code>下，<strong>后边调整代码</strong>来获取该路径的资源</li>
<li>将assets下的js和css和font资源，放到<code>public/assets</code>下的js和css和font</li>
</ul>
<p>将venobox和style.css文件也迁移到<code>public/assets</code>下，style.css可以放到<code>public/assets/css</code>的目录下，&lt;font style=“color:#DF2A3F;”&gt;注意这里需要将&lt;/font&gt;<code>&lt;font style=&quot;color:#DF2A3F;&quot;&gt;style.css&lt;/font&gt;</code>&lt;font style=“color:#DF2A3F;”&gt;的图片引用，修改为相对引用地址。&lt;/font&gt;</p>
<ul>
<li>将html结尾的文件，复制body部分的代码到vue文件的template中。</li>
</ul>
<h2>关于js脚本加载的问题</h2>
<p>在bootstrap中，每个页面为独立html页面，打开都会加载js脚本，并且加载脚本的时间在dom结构渲染完成后进行加载。</p>
<p>那么在改写的vue中，就需要onMounted的生命周期中加载。</p>
<p>在改造过程中尝试了几种方案：</p>
<ul>
<li>写到plugin中，通过<code>nuxtApp.hook('app:mounted', async () =&gt; {})</code>的生命周期时机进行加载，这种方法对<code>index.vue</code>页面生效，但是只加载了一次，对其他页面会失效。</li>
<li>第二种还是想放到插件中，让每个页面的路由之后，加载js</li>
</ul>
<pre class="prettyprint language-javascript"><code>if (process.client) {
  const router = useRouter();

  &#x2F;&#x2F; 监听路由变化，模拟每个页面的 mounted
  router.afterEach(async (to, from) =&gt; {
    console.log(&#x27;页面 mounted 模拟:&#x27;, to.path);
    &#x2F;&#x2F; 在这里执行你的逻辑
    &#x2F;&#x2F; 加载脚本、埋点、初始化第三方库等
    &#x2F;&#x2F; const scripts = [
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;vendor&#x2F;modernizr-2.8.3.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;vendor&#x2F;jquery-3.5.1.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;bootstrap.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;isotope.pkgd.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;owl.carousel.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;jquery.nivo.slider.pack.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;slick.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;venobox&#x2F;venobox.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;imagesloaded.pkgd.min.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;jquery.appear.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;jquery.knob.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;BeerSlider.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;theme-pluginjs.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;jquery.meanmenu.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;ajax-mail.js&#x27;,
    &#x2F;&#x2F;   &#x27;&#x2F;js&#x2F;theme.js&#x27;,
    &#x2F;&#x2F; ];

    &#x2F;&#x2F; for (const src of scripts) {
    &#x2F;&#x2F;   try {
    &#x2F;&#x2F;     await loadScript(src);
    &#x2F;&#x2F;     console.log(&#x27;脚本加载成功:&#x27;, src);

    &#x2F;&#x2F;   } catch (err) {
    &#x2F;&#x2F;     console.error(err);
    &#x2F;&#x2F;   }
    &#x2F;&#x2F; }
  });
}
</code></pre><p>这种方案不能使用<code>&lt;nuxt-link&gt;</code>标签，使用此标签跳转的页面，还是无法正常加载和显示页面。使用<code>&lt;a&gt;</code>时可以生效，但是会刷新页面。</p>
<p>也放弃了这个方案</p>
<ul>
<li>使用<code>composables</code>下写一个公用的加载js的函数方法，在每个页面的<code>onMounted</code>周期中调用一下，这算是最好的解决办法。</li>
</ul>
<pre class="prettyprint language-javascript"><code>&#x2F;&#x2F; 缓存已加载的脚本
const loadedScripts = new Set&lt;string&gt;();

const loadScript = (src: string) =&gt; {
  return new Promise((resolve, reject) =&gt; {
    if (loadedScripts.has(src)) {
      resolve(true);
      return;
    }

    const script = document.createElement(&#x27;script&#x27;);
    script.src = src;
    script.defer = true;

    script.onload = () =&gt; {
      loadedScripts.add(src);
      resolve(true);
    };

    script.onerror = () =&gt; {
      reject(new Error(&#96;Failed to load script: ${src}&#96;));
    };

    document.body.appendChild(script);
  });
};
export const loadScriptClient = async () =&gt; {
  const script1 = document.createElement(&#x27;script&#x27;);
  script1.src = &#x27;&#x2F;js&#x2F;vendor&#x2F;modernizr-2.8.3.min.js&#x27;;
  document.body.appendChild(script1);

  const script2 = document.createElement(&#x27;script&#x27;);
  script2.src = &#x27;&#x2F;js&#x2F;vendor&#x2F;jquery-3.5.1.min.js&#x27;;
  document.body.appendChild(script2);

  const script3 = document.createElement(&#x27;script&#x27;);
  script3.src = &#x27;&#x2F;js&#x2F;bootstrap.min.js&#x27;;
  document.body.appendChild(script3);

  const script4 = document.createElement(&#x27;script&#x27;);
  script4.src = &#x27;&#x2F;js&#x2F;isotope.pkgd.min.js&#x27;;
  document.body.appendChild(script4);

  const script5 = document.createElement(&#x27;script&#x27;);
  script5.src = &#x27;&#x2F;js&#x2F;owl.carousel.min.js&#x27;;
  document.body.appendChild(script5);

  const script6 = document.createElement(&#x27;script&#x27;);
  script6.src = &#x27;&#x2F;js&#x2F;jquery.nivo.slider.pack.js&#x27;;
  document.body.appendChild(script6);

  const script7 = document.createElement(&#x27;script&#x27;);
  script7.src = &#x27;&#x2F;js&#x2F;slick.min.js&#x27;;
  document.body.appendChild(script7);

  const script18 = document.createElement(&#x27;script&#x27;);
  script18.src = &#x27;&#x2F;venobox&#x2F;venobox.min.js&#x27;;
  document.body.appendChild(script18);

  const script8 = document.createElement(&#x27;script&#x27;);
  script8.src = &#x27;&#x2F;js&#x2F;imagesloaded.pkgd.min.js&#x27;;
  document.body.appendChild(script8);

  const script9 = document.createElement(&#x27;script&#x27;);
  script9.src = &#x27;&#x2F;js&#x2F;jquery.appear.js&#x27;;
  document.body.appendChild(script9);

  const script10 = document.createElement(&#x27;script&#x27;);
  script10.src = &#x27;&#x2F;js&#x2F;jquery.knob.js&#x27;;
  document.body.appendChild(script10);

  const script11 = document.createElement(&#x27;script&#x27;);
  script11.src = &#x27;&#x2F;js&#x2F;BeerSlider.js&#x27;;
  document.body.appendChild(script11);

  const script12 = document.createElement(&#x27;script&#x27;);
  script12.src = &#x27;&#x2F;js&#x2F;theme-pluginjs.js&#x27;;
  document.body.appendChild(script12);

  const script13 = document.createElement(&#x27;script&#x27;);
  script13.src = &#x27;&#x2F;js&#x2F;jquery.meanmenu.js&#x27;;
  document.body.appendChild(script13);

  const script14 = document.createElement(&#x27;script&#x27;);
  script14.src = &#x27;&#x2F;js&#x2F;ajax-mail.js&#x27;;
  document.body.appendChild(script14);

  const script15 = document.createElement(&#x27;script&#x27;);
  script15.src = &#x27;&#x2F;js&#x2F;theme.js&#x27;;
  document.body.appendChild(script15);
  
};

</code></pre><p>在vue的页面中进行调用</p>
<pre class="prettyprint language-javascript"><code>&#x2F;&#x2F; 初始化脚本
onMounted(() =&gt; {
  loadScriptClient();
})
</code></pre><h2>关于图片资源引用的问题</h2>
<h3>public/css内部应用的图片路径地址</h3>
<p>public/assets/css内部应用的图片路径地址，是public/assets/images中的资源；</p>
<pre class="prettyprint language-css"><code>.consit_service_area2 {
    background-image: url(&quot;..&#x2F;images&#x2F;port-bg-img.jpg&quot;);
    background-repeat: no-repeat;
    background-size: cover;
    padding: 120px 0px 110px;
}
</code></pre><h3>vue文件的template的图片</h3>
<p>template模版内的图片引入：</p>
<ul>
<li>使用<code>&quot;/assets/images/logo1.png&quot;</code>的也是<code>public/assets/images</code>目录的资源。</li>
<li>如果代码<code>&quot;assets/images/logo1.png&quot;</code>则是使用了<code>assets/images</code>目录资源</li>
</ul>
<pre class="prettyprint language-vue"><code>&lt;template&gt;
  &lt;div class=&quot;mobile_menu_logo text-center&quot;&gt;
    &lt;a href=&quot;index.html&quot; title=&quot;consit&quot;&gt;
      &lt;img src=&quot;&#x2F;assets&#x2F;images&#x2F;logo1.png&quot; alt=&quot;consit&quot; &#x2F;&gt;
    &lt;&#x2F;a&gt;
  &lt;&#x2F;div&gt;
&lt;&#x2F;template&gt;
</code></pre><h3>vue文件的template的style中使用图片</h3>
<p>在template中的style添加背景图片，这里如果正常使用<code>/assets/images/logo1.png</code>，就会引用到/assets/images的资源，而不是public/assets/image的资源。</p>
<h4>下面代码引用了 <code>assets/image</code>的资源</h4>
<p>这里不管有没有 <code>/</code> 路径，都是使用的 <code>assets/image</code></p>
<pre class="prettyprint language-vue"><code>&lt;template&gt;
  &lt;div
      class=&quot;swiper-slide d1 t1 m1 witr_swiper_height&quot;
      style=&quot;background-image:	url(&#x2F;assets&#x2F;images&#x2F;slider1.jpg)&quot;
    &gt;
    1111
  &lt;&#x2F;div&gt;
&lt;&#x2F;template&gt;
</code></pre><h4>可以结合script，使用public的资源；</h4>
<p>主要思路是通过动态导入图片资源，然后在绑定到style中</p>
<pre class="prettyprint language-vue"><code>&lt;template&gt;
  &lt;div
      class=&quot;swiper-slide d1 t1 m1 witr_swiper_height&quot;
      :style=&quot;{ backgroundImage: &#96;url(${slider1})&#96; }&quot;
    &gt;
    1111
  &lt;&#x2F;div&gt;
&lt;&#x2F;template&gt;
&lt;script setup&gt;
  &#x2F;&#x2F; vue script内引入assets图片的方法
  import slider1 from &#x27;&#x2F;assets&#x2F;images&#x2F;slider1.jpg&#x27;;
&lt;&#x2F;script&gt;
</code></pre><h2>迁移完成后代码结构</h2>
<pre class="prettyprint language-javascript"><code>.&#x2F;
├── README.md
├── app.vue
├── components
│   ├── navFooter.vue
│   └── navHeader.vue
├── composables
│   └── index.ts
│── nuxt.config.ts
├── package.json
├── pages
│   ├── about.vue
│   ├── blog.vue
│   ├── blogLeft.vue
│   ├── blogRight.vue
│   ├── contact.vue
│   ├── faq.vue
│   ├── homeVideo.vue
│   ├── index.vue
│   ├── landingPage.vue
│   ├── portfolio.vue
│   ├── portfolio3column.vue
│   ├── portfolio4column.vue
│   ├── pricingTable.vue
│   ├── service.vue
│   ├── serviceSingle.vue
│   ├── singleBlog.vue
│   ├── team.vue
│   └── testimonial.vue
├── plugins
│   └── load-script.client.ts
├── pnpm-lock.yaml
├── public
│   ├── assets
│   │   └── images
│   │       ├── about-img-1.jpg
│   │       ├── b1.jpg
│   │       ├── b2.jpg
│   │       ├── b3.jpg
│   │       ├── b4.jpg
│   │       ├── ...
│   │       ├── css
│   │       │   ├── bootstrap.min.css
│   │       │   ├── em-breadcrumb.css
│   │       │   ├── plugin_theme_css.css
│   │       │   ├── responsive.css
│   │       │   └── style.css
│   │       ├── fonts
│   │       │   ├── Flaticon.woff
│   │       │   ├── ...
│   │       ├── js
│   │       │   ├── BeerSlider.js
│   │       │   ├── ajax-mail.js
│   │       │   ├── ...
│   │       ├── venobox
│   │       │   ├── close.gif
│   │       │   ├── next.gif
│   │       │   ├── preload-circle.png
│   │       │   ├── preload-dots.png
│   │       │   ├── preload-ios.png
│   │       │   ├── preload-quads.png
│   │       │   ├── preload.png
│   │       │   ├── prev.gif
│   │       │   ├── venobox.css
│   │       │   ├── venobox.js
│   │       │   └── venobox.min.js
│   │       └── webfonts
│   │           ├── fa-brands-400.eot
│   │           ├── fa-brands-400.svg
│   │           ├── ... 
│   ├── favicon.ico
│   ├── favicon.png
│   ├── robots.txt
└── tsconfig.json

29 directories, 146 files
</code></pre><p>以上是将bootstrap项目转为nuxt项目的代码结构。</p>
<h2>关于接口调用和打包发布上线的操作</h2>
<p>详细的操作和项目代码仓库，放置到个人网站中，如有需要请查看；</p>
<ul>
<li>文章地址：<a href="https://shenshuai89.github.io/pages/3926f2/">https://shenshuai89.github.io/pages/3926f2/</a></li>
<li>线上预览地址：<a href="https://www.shenshuai.site/nuxtapp202504114/">https://www.shenshuai.site/nuxtapp202504114/</a></li>
</ul>
</div>

用现有bootstrap的模板，改造成nuxt3项目

<div class="markdown-text"><p>不知道目前国内node发展是啥情况，但是搜node中文社区，貌似本站是最大的。
但是从阅读和回帖量等看，看起来本站死气沉沉，没有活跃度，不知道是node在国内使用量少还是咋回事？
有哪位老哥能解惑一下么？</p>
</div>

求解惑，为什么最大的中文node社区看着不活跃？

<div class="markdown-text"><p><a href="https://github.com/vonajs/vona">Vona</a> 是一款直观、优雅、强大的 Node.js Web 框架，用于快速开发任何规模的企业级应用。首创 DTO 动态推断与生成能力，从而显著提升开发效率和开发体验。Vona ORM 对数据库事务提供了完整的支持，提供了直观、优雅、强大的特性：</p>
<ol>
<li>使用装饰器启用事务</li>
<li>事务传播机制</li>
<li>事务补偿机制</li>
<li>确保数据库与缓存数据一致性</li>
</ol>
<h2>使用装饰器启用事务</h2>
<pre class="prettyprint language- typescript"><code>import { Database } from &#x27;vona-module-a-orm&#x27;;

class ServicePost {
  @Database.transaction()
  async transaction() {
    &#x2F;&#x2F; insert
    const post = await this.scope.model.post.insert({
      title: &#x27;Post001&#x27;,
    });
    &#x2F;&#x2F; update
    await this.scope.model.post.update({
      id: post.id,
      title: &#x27;Post001-Update&#x27;,
    });
  }
}  
</code></pre><h2>手工启用事务</h2>
<h3>1. 使用当前数据源</h3>
<pre class="prettyprint language- typescript"><code>class ServicePost {
  async transactionManually() {
    const db = this.bean.database.current;
    await db.transaction.begin(async () =&gt; {
      await this.scope.model.post.update({ id: 1, title: &#x27;Post001_Update&#x27; });
    });
  }
}
</code></pre><h3>2. 使用指定数据源</h3>
<pre class="prettyprint language- typescript"><code>class ServicePost {
  async transactionManually() {
    const db = this.bean.database.getDb({ clientName: &#x27;default&#x27; });
    await db.transaction.begin(async () =&gt; {
      const modelPost = this.scope.model.post.newInstance(db);
      await modelPost.update({ id: 1, title: &#x27;Post001_Update&#x27; });
    });
  }
}
</code></pre><h2>事务参数</h2>
<pre class="prettyprint language- diff"><code>class ServicePost {
  @Database.transaction({
+   isolationLevel: &#x27;READ_COMMITTED&#x27;,
+   propagation: &#x27;REQUIRED&#x27;
  })
  async transaction() {
    ...
  }
}  
</code></pre><pre class="prettyprint language- diff"><code>class ServicePost {
  async transactionManually() {
    const db = this.bean.database.getDb({ clientName: &#x27;default&#x27; });
    await db.transaction.begin(
      async () =&gt; {
        ...
      },
      {
+       isolationLevel: &#x27;READ_COMMITTED&#x27;,
+       propagation: &#x27;REQUIRED&#x27;,
      }
    );
  }
}  
</code></pre><h2>事务参数：isolationLevel</h2>
<table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>DEFAULT</td>
<td>数据库相关的缺省isolationLevel</td>
</tr>
<tr>
<td>READ_UNCOMMITTED</td>
<td></td>
</tr>
<tr>
<td>READ_COMMITTED</td>
<td></td>
</tr>
<tr>
<td>REPEATABLE_READ</td>
<td></td>
</tr>
<tr>
<td>SERIALIZABLE</td>
<td></td>
</tr>
<tr>
<td>SNAPSHOT</td>
<td></td>
</tr>
</tbody>
</table>
<h2>事务参数：propagation</h2>
<p>Vona ORM 支持数据库事务传播机制</p>
<table>
<thead>
<tr>
<th>名称</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>REQUIRED</td>
<td>默认的事务传播级别。如果当前存在事务, 则加入该事务。如果当前没有事务, 则创建一个新的事务</td>
</tr>
<tr>
<td>SUPPORTS</td>
<td>如果当前存在事务，则加入该事务. 如果当前没有事务, 则以非事务的方式继续运行</td>
</tr>
<tr>
<td>MANDATORY</td>
<td>强制性。如果当前存在事务, 则加入该事务。如果当前没有事务，则抛出异常</td>
</tr>
<tr>
<td>REQUIRES_NEW</td>
<td>创建一个新的事务。如果当前存在事务, 则把当前事务挂起。也就是说不管外部方法是否开启事务，总是开启新的事务, 且开启的事务相互独立, 互不干扰</td>
</tr>
<tr>
<td>NOT_SUPPORTED</td>
<td>以非事务方式运行。如果当前存在事务，则把当前事务挂起(不用)</td>
</tr>
<tr>
<td>NEVER</td>
<td>以非事务方式运行。如果当前存在事务，则抛出异常</td>
</tr>
</tbody>
</table>
<h2>事务补偿机制</h2>
<p>当事务成功或者失败时执行一些逻辑</p>
<h3>1. 成功补偿</h3>
<pre class="prettyprint language- typescript"><code>this.bean.database.current.commit(async () =&gt; {
  &#x2F;&#x2F; do something when success
});
</code></pre><h3>2. 失败补偿</h3>
<pre class="prettyprint language- typescript"><code>this.bean.database.current.compensate(async () =&gt; {
  &#x2F;&#x2F; do something when failed
});
</code></pre><h2>事务与Cache数据一致性</h2>
<p>许多框架使用最简短的用例来证明是否高性能，而忽略了业务复杂性带来的性能挑战。随着业务的增长和变更，项目性能就会断崖式下降，各种优化补救方案让项目代码繁杂冗长。而 Vona 正视大型业务的复杂性，从框架核心引入缓存策略，并实现了<code>二级缓存</code>、<code>Query缓存</code>和<code>Entity缓存</code>等机制，轻松应对大型业务系统的开发，可以始终保持代码的优雅和直观</p>
<p>Vona 系统对数据库事务与缓存进行了适配，当数据库事务失败时会自动执行缓存的补偿操作，从而让数据库数据与缓存数据始终保持一致</p>
<p>针对这个场景，Vona 提供了内置的解决方案</p>
<h3>1. 使用当前数据源</h3>
<pre class="prettyprint language- typescript"><code>class ServicePost {
  @Database.transaction()
  async transaction() {
    &#x2F;&#x2F; insert
    const post = await this.scope.model.post.insert({
      title: &#x27;Post001&#x27;,
    });
    &#x2F;&#x2F; cache
    await this.scope.cacheRedis.post.set(post, post.id);
  }
}  
</code></pre><ul>
<li>当新建数据后，将数据放入 redis 缓存中。如果这个事务出现异常，就会进行数据回滚，同时缓存数据也会回滚，从而让数据库数据与缓存数据保持一致</li>
</ul>
<h3>2. 使用指定数据源</h3>
<pre class="prettyprint language- typescript"><code>class ServicePost {
  async transactionManually() {
    const db = this.bean.database.getDb({ clientName: &#x27;default&#x27; });
    await db.transaction.begin(async () =&gt; {
      const modelPost = this.scope.model.post.newInstance(db);
      const post = await modelPost.insert({ title: &#x27;Post001&#x27; });
      await this.scope.cacheRedis.post.set(post, post.id, { db });
    });
  }
}  
</code></pre><ul>
<li>如果对指定的数据库进行操作，那么就需要将数据库对象<code>db</code>传入缓存，从而让缓存针对数据库对象<code>db</code>执行相应的补偿操作。当数据库事务回滚时，让数据库数据与缓存数据保持一致</li>
</ul>
</div>

这个Database Transaction功能多多，你用过吗？

<div class="markdown-text"><p>在node 16下，把cc安装在node 22下面。
然后node 16下 执行node 22下面的cc。。。</p>
<p>第一次见过这么骚的操作</p>
</div>

题目：如何在node 16上执行claude code（cc只能跑在node 18+）？

<div class="markdown-text"><p>在上一篇文章（<a href="https://juejin.cn/post/7534568184419893275">Prisma不能优雅的支持DTO，试试Vona ORM吧</a>）中，我们基于静态关系实现了<code>目录树</code>的关联查询，并且动态推断生成了DTO（用于Swagger元数据）。在这篇文章我们探讨<code>动态关系</code>的用法。</p>
<h2>什么是动态关系</h2>
<p>那么，什么是动态关系呢？在大型业务系统中，我们会创建大量数据模型，这些数据模型之间的关联众多，我们不可能将所有关联通过<code>静态关系</code>的机制事先声明出来。特别是当存在大量业务模块，这些数据模型散落在不同的业务模块中，那么通过<code>静态关系</code>事先声明所有的关联关系也变得不太现实。比如，Prisma就只支持<code>静态关系</code>。如果事先没有定义<code>静态关系</code>，在实际代码中，我们就需要提供一种使用<code>动态关系</code>的机制，让我们的查询、类型推断、DTO推断等能力得以正常使用。</p>
<h2>准备数据模型</h2>
<p>在上一篇文章中，我们已经介绍了如何创建Entity和Model，这里不再赘述。而是直接把Order和Customer的Entity和Model罗列出来，然后演示<code>动态关系</code>的用法</p>
<h3>Entity</h3>
<h4>1. Order</h4>
<pre class="prettyprint language-typescript"><code>@Entity()
export class EntityOrder extends EntityBase {
  @Api.field(v.openapi({ title: $locale(&#x27;OrderNo&#x27;) }), v.default(&#x27;&#x27;), v.min(3))
  orderNo: string;

  @Api.field(v.title($locale(&#x27;Remark&#x27;)), v.optional())
  remark?: string;

  @Api.field(v.tableIdentity())
  customerId: TableIdentity;
}
</code></pre><ul>
<li>v.openapi：声明字段的元数据，用于Swagger
<ul>
<li>title：采用$locale定义，从而让Swagger元数据支持多语言能力</li>
</ul>
</li>
<li>v.title：等价于v.openapi({ title: … })</li>
<li>TableIdentity：string | number</li>
</ul>
<h4>2. Customer</h4>
<pre class="prettyprint language-typescript"><code>@Entity()
export class EntityCustomer extends EntityBase {
  @Api.field(v.min(3))
  name: string;
}
</code></pre><h3>Model</h3>
<h4>1. Order</h4>
<pre class="prettyprint language-typescript"><code>@Model({ entity: EntityOrder })
export class ModelOrder extends BeanModelBase {}
</code></pre><h4>2. Customer</h4>
<pre class="prettyprint language-typescript"><code>@Model({ entity: EntityCustomer })
export class ModelCustomer extends BeanModelBase {}
</code></pre><h2>基于<code>动态关系</code>的查询</h2>
<p>现在我们查询订单列表，包含归属的顾客信息：</p>
<pre class="prettyprint language-typescript"><code>const orders = await this.scope.model.order.select({
  with: {
    customer: $relationDynamic.belongsTo(
      () =&gt; ModelOrder,
      () =&gt; ModelCustomer,
      &#x27;customerId&#x27;,
    ),
  },
});
</code></pre><ul>
<li>$relationDynamic:提供一组工具，用于定义动态关系</li>
<li>belongsTo：定义<code>多对一</code>的关系
<ul>
<li>参数1：Order模型</li>
<li>参数2：Customer模型</li>
<li>参数3：设置关联外键customerId</li>
</ul>
</li>
</ul>
<p>下面我们看一下<code>orders</code>的类型推断效果：</p>
<p><img src="https://origin.picgo.net/2025/08/08/686e78c52ec7f8abe.png" alt></p>
<p><img src="https://origin.picgo.net/2025/08/08/7e1a41a6d14a811cd.png" alt></p>
<h2>自动推断DTO</h2>
<p>现在我们自动推断DTO，并且设为API的返回数据的类型：</p>
<pre class="prettyprint language-typescript"><code>const DtoOrderResult = $Dto.get(
  () =&gt; ModelOrder,
  {
    with: {
      customer: $relationDynamic.belongsTo(
        () =&gt; ModelOrder,
        () =&gt; ModelCustomer,
        &#x27;customerId&#x27;,
      ),
    },
  },
);

@Controller(&#x27;order&#x27;)
export class ControllerOrder extends BeanBase {
  @Web.get()
  @Api.body(v.array(v.object(DtoOrderResult)))
  async findAll() {
    return await this.scope.service.order.findAll();
  }
}  
</code></pre><ul>
<li>行1：动态创建<code>DtoOrderResult</code></li>
<li>行17：将<code>DtoOrderResult</code>用于Swagger/Openapi的元数据</li>
</ul>
<p>下面我们看一下API的Swagger效果：</p>
<p><img src="https://origin.picgo.net/2025/08/08/8ddd9646456a51f11.png" alt></p>
<h2>封装DTO</h2>
<p>我们还可以创建一个新的DTO，将前面动态创建的<code>DtoOrderResult</code>封装起来，从而用于其他地方：</p>
<p>在VSCode中，可以通过右键菜单<code>Vona Create/Dto</code>创建DTO的代码骨架：</p>
<pre class="prettyprint language-typescript"><code>@Dto()
export class DtoOrderResult {}
</code></pre><p>然后我们通过继承机制来封装DTO：</p>
<pre class="prettyprint language-typescript"><code>const DtoOrderResultDynamic = $Dto.get(
  () =&gt; ModelOrder,
  {
    with: {
      customer: $relationDynamic.belongsTo(
        () =&gt; ModelOrder,
        () =&gt; ModelCustomer,
        &#x27;customerId&#x27;,
      ),
    },
  },
);

@Dto()
export class DtoOrderResult extends DtoOrderResultDynamic {}
</code></pre><p>现在，我们再使用新创建的DTO来改造前面的API代码：</p>
<pre class="prettyprint language-diff"><code>+ import { DtoOrderResult } from &#x27;..&#x2F;dto&#x2F;orderResult.ts&#x27;;

@Controller(&#x27;order&#x27;)
export class ControllerOrder extends BeanBase {
  @Web.get()
+ @Api.body(v.array(v.object(DtoOrderResult)))
+ async findAll(): Promise&lt;DtoOrderResult[]&gt; {
    return await this.scope.service.order.findAll();
  }
}
</code></pre><ul>
<li>行6: 直接传入<code>DtoOrderResult</code></li>
<li>行7: 返回类型为<code>Promise&lt;DtoOrderResult[]&gt;</code></li>
</ul>
<h2>结语</h2>
<p>Vonajs已开源：<a href="https://github.com/vonajs/vona">https://github.com/vonajs/vona</a>。</p>
<p>Vonajs作者正在B站直播撰写技术文档，工作日每晚8:30，欢迎围观：<a href="https://space.bilibili.com/454737998">濮水代码直播间</a></p>
</div>

如何基于动态关系进行ORM关联查询，并动态推断DTO？

<div class="markdown-text"><p>require 如果失败，服务停止，只能改错后，再次启动。
希望是这样的：
const m = require(‘m1’);
if (m) {
…
}
else {
	m = require(‘m2’);
}
有没有有个更好的函数，可以在失败是返回false 或者 null？这样，避免了终止，可以自行选择require其他。</p>
<p>比如以下连续，require不到时，返回false或null，就可以不出错
const m1 = require(‘m1’);
const m2 = require(‘m2’);
const m3 = require(‘m3’);</p>
<p>require 这个方法是不是该升级了？</p>
</div>

如何不在require调用失败时终止运行

<div class="markdown-text"><p>在Nodejs生态中，Prisma是一个非常流行的ORM库，支持Typescript，提供了非常友好的类型推断能力。但是，Prisma却不能优雅的支持DTO。在与其他后端框架整合时，DTO是进行参数验证、生成Swagger元数据的关键节点。如果不能像推断类型一样自动推断出DTO，那么，我们就仍然需要手工创建DTO。随着业务的增长，复杂的表间关系会让手工补充DTO的工作日益繁重。</p>
<p>而Vona ORM就提供了非常便利的工具，使我们可以非常直观的动态推断出DTO，就像推断类型一样，从而解放我们的双手，显著提升生产力。甚至可以说，能够自动推断DTO，为Nodejs后端框架打开了一扇窗。</p>
<p>Vona本身就是一款更直观的Nodejs框架，如果大家第一次接触，可以先参考这篇文章：<a href="https://juejin.cn/post/7509709812857110582">你认为Vonajs提供的这些特性会比Nestjs更好用吗？</a></p>
<p>限于篇幅，这里不展开讲解Vona ORM所有的知识点，而是以<code>目录树</code>为例，演示如何查询一棵目录树，以及如何动态生成DTO，并最终生成Swagger元数据。Vona框架作者正在直播撰写Vona文档。围观官方文档的实时编写过程，有利于加深对框架设计的理解，探索不一样的架构设计路径。有兴趣的欢迎移步：<a href="https://space.bilibili.com/454737998">B站濮水代码直播间</a></p>
<h2>1. 创建Entity</h2>
<p>在VSCode中，可以通过右键菜单<code>Vona Create/Entity</code>创建Entity的代码骨架：</p>
<pre class="prettyprint language-typescript"><code>@Entity(&#x27;demoStudentCategory&#x27;)
export class EntityCategory extends EntityBase {
  [@Api](&#x2F;user&#x2F;Api).field()
  name: string;

  [@Api](&#x2F;user&#x2F;Api).field(v.optional())
  categoryIdParent?: TableIdentity;
}
</code></pre><ul>
<li>行2: 继承自EntityBase，就会自动提供5个基础字段：id、createdAt、updatedAt、deleted、iid
<ul>
<li>iid：是实例Id，通过多实例的机制支持多租户系统的开发</li>
</ul>
</li>
<li>行4、7: 定义两个业务字段：name、categoryIdParent</li>
<li><a href="/user/Api">@Api</a>.field：通过此装饰器定义的信息，可同时应用于参数验证和Swagger元数据</li>
<li>v.optional：声明为可选字段</li>
<li>更多信息，参见：<a href="https://vona.js.org/zh/guide/essentials/scope/entity.html">Vona Entity</a></li>
</ul>
<h2>2. 创建Model</h2>
<p>在VSCode中，可以通过右键菜单<code>Vona Create/Model</code>创建Model的代码骨架：</p>
<pre class="prettyprint language-typescript"><code>import { EntityCategory } from &#x27;..&#x2F;entity&#x2F;category.ts&#x27;;

@Model({ entity: EntityCategory })
export class ModelCategory extends BeanModelBase&lt;EntityCategory&gt; {}
</code></pre><ul>
<li>行3: entity：指定Model所对应的Entity</li>
<li>行4: 继承自BeanModelBase，从而拥有大量操作数据库的方法，如：CRUD、聚合、分组，等等</li>
</ul>
<h2>3. 创建树形结构</h2>
<p>如果要创建一棵目录树，本质就是建立Model引用自身的递归结构。Vona ORM同样支持4种关系：<code>1对1</code>、<code>1对多</code>、<code>多对1</code>，<code>多对多</code>。那么，在这里，我们就需要采用<code>1对多</code>来创建目录的自身引用关系。</p>
<pre class="prettyprint language-diff"><code>import { EntityCategory } from &#x27;..&#x2F;entity&#x2F;category.ts&#x27;;

@Model({
  entity: EntityCategory,
+ relations: {
+   children: $relation.hasMany(() =&gt; ModelCategory, &#x27;categoryIdParent&#x27;, {
+     autoload: true,
+     columns: [&#x27;id&#x27;, &#x27;name&#x27;],
+   }),
+ },
})
export class ModelCategory extends BeanModelBase&lt;EntityCategory&gt; {}
</code></pre><ul>
<li>行5: relations：可以定义多个关系</li>
<li>行6: children：定义一个1对多的关系</li>
<li>$relation.hasMany：
<ul>
<li>参数1: 引用自身ModelCategory</li>
<li>参数2: 设置关联外键categoryIdParent</li>
<li>参数3: 关联选项
<ul>
<li>autoload：是否自动加载关联数据</li>
<li>columns：控制关联数据的字段列表</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2>4. 创建Controller</h2>
<p>在VSCode中，可以通过右键菜单<code>Vona Create/Controller</code>创建Controller的代码骨架：</p>
<pre class="prettyprint language-typescript"><code>@Controller()
export class ControllerCategory extends BeanBase {}
</code></pre><p>接下来我们创建一个Api，用于获取目录树：</p>
<pre class="prettyprint language-typescript"><code>export class ControllerCategory extends BeanBase {
  [@Web](&#x2F;user&#x2F;Web).get(&#x27;getCategoryTree&#x27;)
  async getCategoryTree() {
  }
}
</code></pre><ul>
<li>行2: 通过<a href="/user/Web">@Web</a>.get定义一个api，path为getCategoryTree</li>
</ul>
<h2>5. 查询目录树</h2>
<p>一般而言，我们还需要创建一个Service，从而实现以下调用链：Controller-&gt;Service-&gt;Model-&gt;操作数据库。为了简化起见，在这里，我们直接在Controller中调用Model方法：</p>
<pre class="prettyprint language-typescript"><code>export class ControllerCategory extends BeanBase {
  [@Web](&#x2F;user&#x2F;Web).get(&#x27;getCategoryTree&#x27;)
  async getCategoryTree() {
    const tree = await this.scope.model.category.select({
      columns: [&#x27;id&#x27;, &#x27;name&#x27;],
    });
    return tree;
  }
}
</code></pre><ul>
<li>行4: 通过<code>this.scope</code>取得Category Model，然后调用select方法
<ul>
<li>columns：指定要查询的字段列表</li>
</ul>
</li>
</ul>
<p>由于前面我们设置children关系为<code>autoload: true</code>，因此，查询结果<code>tree</code>就是一棵完整的目录树。下面我们看一下<code>tree</code>的类型推断效果：</p>
<p><img src="https://origin.picgo.net/2025/08/05/1c0db0a4260be4663.png" alt="1.png"></p>
<p><img src="https://origin.picgo.net/2025/08/05/2093623b1ca3e0dea.png" alt="2.png"></p>
<h2>6. 自动推断DTO</h2>
<p>现在我们自动推断DTO，并且设为API的返回数据的类型：</p>
<pre class="prettyprint language-diff"><code>export class ControllerCategory extends BeanBase {
  [@Web](&#x2F;user&#x2F;Web).get(&#x27;getCategoryTree&#x27;)
+ [@Api](&#x2F;user&#x2F;Api).body(v.array(v.object($Dto.get(() =&gt; ModelCategory, { columns: [&#x27;id&#x27;, &#x27;name&#x27;] }))))
  async getCategoryTree() {
    const tree = await this.scope.model.category.select({
      columns: [&#x27;id&#x27;, &#x27;name&#x27;],
    });
    return tree;
  }
}
</code></pre><ul>
<li>行3: 通过<a href="/user/Api">@Api</a>.body定义API返回数据的类型：
<ul>
<li>v.array：定义数组类型</li>
<li>v.object：定义对象类型</li>
</ul>
</li>
<li>$Dto.get：动态推断DTO
<ul>
<li>参数1：指定目标Model</li>
<li>参数2：指定选项
<ul>
<li>columns：指定要提取的字段列表</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>同样，由于前面我们设置children关系为<code>autoload: true</code>，因此，<code>$Dto.get</code>生成的DTO就是一棵完整的目录树。下面我们看一下API的Swagger效果：</p>
<p><img src="https://origin.picgo.net/2025/08/05/3f78f6b398ff25403.png" alt="3.png"></p>
<p><img src="https://origin.picgo.net/2025/08/05/45d0f5351e610e51b.png" alt="4.png"></p>
<p><img src="https://origin.picgo.net/2025/08/05/5892fcfd4e6028088.png" alt="5.png"></p>
<p>从示意图中，我们可以清晰的看到，这棵树引用的children类型是名称为<code>demo-student.entity.category_2c7d642ee581efa300341e343180fbb0ecdc785d</code>的动态Entity的数组，从而形成一种递归的引用关系。</p>
<h2>7. 封装DTO</h2>
<p>虽然我们已经实现了预期的目标，但是Vona ORM提供的能力还没有结束。我们可以创建一个新的DTO，将前面的代码<code>$Dto.get(() =&gt; ModelCategory, { columns: ['id', 'name'] })</code>封装起来，从而用于其他地方：</p>
<p>在VSCode中，可以通过右键菜单<code>Vona Create/Dto</code>创建DTO的代码骨架：</p>
<pre class="prettyprint language-typescript"><code>@Dto()
export class DtoCategoryTree {}
</code></pre><p>然后我们通过继承机制来封装DTO：</p>
<pre class="prettyprint language-diff"><code>@Dto()
export class DtoCategoryTree 
+ extends $Dto.get(() =&gt; ModelCategory, { columns: [&#x27;id&#x27;, &#x27;name&#x27;] }) {}
</code></pre><p>现在，我们再使用新创建的DTO来改造前面的API代码：</p>
<pre class="prettyprint language-diff"><code>export class ControllerCategory extends BeanBase {
  [@Web](&#x2F;user&#x2F;Web).get(&#x27;getCategoryTree&#x27;)
+ [@Api](&#x2F;user&#x2F;Api).body(v.array(v.object(DtoCategoryTree)))
+ async getCategoryTree(): Promise&lt;DtoCategoryTree[]&gt;{
    const tree = await this.scope.model.category.select({
      columns: [&#x27;id&#x27;, &#x27;name&#x27;],
    });
    return tree;
  }
}
</code></pre><ul>
<li>行3: 直接传入<code>DtoCategoryTree</code></li>
<li>行4: 返回类型为<code>Promise&lt;DtoCategoryTree[]&gt;</code></li>
</ul>
<h2>结语</h2>
<p>Vonajs已开源：<a href="https://github.com/vonajs/vona">https://github.com/vonajs/vona</a>。</p>
<p>Vonajs作者正在B站直播撰写技术文档，工作日每晚8:30，欢迎围观：<a href="https://space.bilibili.com/454737998">濮水代码直播间</a></p>
</div>

测试Next SSR渲染