跨平台 on Liangweidong's blog

Tauri 2.x 跨平台桌面应用：Rust + WebView2 实战

Fri, 15 May 2020 00:00:00 +0800

什么是 Tauri 2.x

Tauri 是 2020 年起 Rust 生态的跨平台桌面应用框架，2.0 版本（2024-10 GA）带来更完善的插件体系和移动端支持。

核心架构

前端：任意 Web 框架（React / Vue / Svelte / Solid）
后端：Rust 二进制，编译成原生代码
WebView：复用系统 WebView（Windows WebView2 / macOS WKWebView / Linux WebKitGTK）
进程间通信：Rust 命令 + JS 桥

优势

包大小 2~10MB（vs Electron 80MB+）
内存低：复用系统 WebView，不开新 Chromium
Rust 内存安全：无 GC 抖动
细粒度权限：声明式 ACL
移动端支持（2.0+）：iOS / Android

前置环境

通用

Rust 工具链：curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Node.js 18+（推荐 22 LTS）
包管理：pnpm

Windows

Microsoft C++ Build Tools（安装时勾选"使用 C++ 的桌面开发"）
WebView2 Runtime（Win10 1803+ 预装）
- 旧版：下载 https://developer.microsoft.com/zh-cn/microsoft-edge/webview2/

macOS

1

xcode-select --install

Linux (Debian/Ubuntu)

1
2
3
4
5
6
7
8


sudo apt install -y \
 libwebkit2gtk-4.1-dev \
 libgtk-3-dev \
 libayatana-appindicator3-dev \
 librsvg2-dev \
 libssl-dev \
 libjavascriptcoregtk-4.1-dev \
 libsoup-3.0-dev

创建项目

1. 创建工作区

1
2
3
4


mkdir -p tauri-app && cd tauri-app

# pnpm-workspace.yaml
nvim pnpm-workspace.yaml

1
2
3


packages:
 - 'frontend'
 - 'src-tauri'

2. 创建 Vite + React 前端

1

pnpm create vite frontend --template react-ts

3. 添加 Tauri CLI

1

pnpm add -D @tauri-apps/cli@latest -w

package.json 会加：

1

"@tauri-apps/cli": "^2.11.1"

4. 初始化 Tauri

1

pnpm tauri init

按提示填写：

1
2
3
4
5
6


✔ What is your app name? · tauri-app
✔ What should the window title be? · tauri-app
✔ Where are your web assets (HTML/CSS/JS) located, relative to the "<current dir>/src-tauri/tauri.conf.json" file that will be created? · ../frontend/dist
✔ What is the url of your dev server? http://localhost:1420
✔ What is your frontend dev command? · pnpm -F frontend dev
✔ What is your frontend build command? · pnpm -F frontend build

5. 安装依赖

1
2


pnpm install
mkdir -p frontend/dist # dist 必须存在

6. 修改 tauri.conf.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


{
 "productName": "tauri-app",
 "version": "0.1.0",
 "identifier": "com.example.tauri-app",
 "build": {
 "frontendDist": "../frontend/dist",
 "devUrl": "http://localhost:1420",
 "beforeDevCommand": "pnpm -F frontend dev",
 "beforeBuildCommand": "pnpm -F frontend build"
 },
 "app": {
 "windows": [
 {
 "title": "tauri-app",
 "width": 1200,
 "height": 800
 }
 ],
 "security": {
 "csp": null
 }
 }
}

开发与打包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 开发（自动打开 DevTools 调试）
pnpm tauri dev

# 打包
pnpm tauri build

# 结果
# Windows: src-tauri/target/release/tauri-app.exe
# macOS: src-tauri/target/release/bundle/macos/tauri-app.app
# Linux: src-tauri/target/release/bundle/deb/*.deb

Cargo 工作区改造

Tauri 2.x 推荐用 Cargo 工作区管理（多包）：

1
2
3
4


# Cargo.toml (根目录)
[workspace]
members = ["src-tauri"]
resolver = "2"

迁移步骤：

删 src-tauri/target（构建会在根目录的 target 重新生成）
迁移 src-tauri/.gitignore 到根目录并修改
删 frontend/.gitignore（如果根目录有覆盖）

根目录 .gitignore：

1
2
3
4
5


**/target/
/src-tauri/gen/schemas

**/node_modules
**/dist

Vite 配置

frontend/vite.config.ts：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

const host = process.env.TAURI_DEV_HOST;

export default defineConfig({
 plugins: [react()],
 // 防止 Vite 清除 Rust 显示的错误
 clearScreen: false,
 server: {
 port: 5173,
 strictPort: true, // Tauri 需要固定端口
 host: host || false,
 hmr: host
 ? {
 protocol: "ws",
 host,
 port: 5174,
 }
 : undefined,
 watch: {
 // 告诉 Vite 忽略 src-tauri 目录
 ignored: ["**/src-tauri/**"],
 },
 },
 envPrefix: ["VITE_", "TAURI_ENV_*"],
 build: {
 // Windows 用 chromium，其他用 safari13
 target:
 process.env.TAURI_ENV_PLATFORM == "windows" ? "chrome105" : "safari13",
 minify: !process.env.TAURI_ENV_DEBUG ? "esbuild" : false,
 sourcemap: !!process.env.TAURI_ENV_DEBUG,
 },
});

Rust 后端命令

Tauri 2.x 用 #[tauri::command] 宏定义命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


// src-tauri/src/main.rs (或 src/lib.rs)
use tauri::Manager;

#[tauri::command]
fn greet(name: &str) -> String {
 format!("Hello, {}! 你好, Tauri!", name)
}

#[tauri::command]
async fn fetch_data(url: String) -> Result<String, String> {
 reqwest::get(&url)
 .await
 .map_err(|e| e.to_string())?
 .text()
 .await
 .map_err(|e| e.to_string())
}

fn main() {
 tauri::Builder::default()
 .invoke_handler(tauri::generate_handler![greet, fetch_data])
 .setup(|app| {
 #[cfg(debug_assertions)]
 {
 let window = app.get_webview_window("main").unwrap();
 window.open_devtools();
 }
 Ok(())
 })
 .run(tauri::generate_context!())
 .expect("error while running tauri application");
}

前端调用 Rust 命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// frontend/src/App.tsx
import { invoke } from "@tauri-apps/api/core";
import { useState } from "react";

function App() {
 const [greeting, setGreeting] = useState("");

 async function handleClick() {
 const msg = await invoke<string>("greet", { name: "World" });
 setGreeting(msg);
 }

 return (
 <div>
 <button onClick={handleClick}>调用 Rust</button>
 <p>{greeting}</p>
 </div>
 );
}

export default App;

常用插件

1
2
3
4
5
6
7
8


pnpm tauri add fs
pnpm tauri add dialog
pnpm tauri add notification
pnpm tauri add shell
pnpm tauri add http
pnpm tauri add store
pnpm tauri add window
pnpm tauri add updater

权限配置

src-tauri/capabilities/default.json：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


{
 "$schema": "../gen/schemas/desktop-schema.json",
 "identifier": "default",
 "description": "默认权限",
 "windows": ["main"],
 "permissions": [
 "core:default",
 "fs:allow-read-text-file",
 "fs:allow-write-text-file",
 "dialog:default",
 "notification:default"
 ]
}

文件系统

1
2
3
4
5
6
7
8


// Rust
use tauri_plugin_fs::FsExt;

#[tauri::command]
fn read_config(app: tauri::AppHandle) -> Result<String, String> {
 let path = app.path().app_config_dir().unwrap().join("config.json");
 std::fs::read_to_string(path).map_err(|e| e.to_string())
}

1
2
3
4


// 前端
import { readTextFile } from '@tauri-apps/plugin-fs';

const content = await readTextFile('/path/to/file.txt');

状态管理

Tauri 用 tauri::State 在命令间共享状态：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


use std::sync::Mutex;

struct AppState {
 counter: Mutex<i32>,
}

#[tauri::command]
fn increment(state: tauri::State<AppState>) -> i32 {
 let mut count = state.counter.lock().unwrap();
 *count += 1;
 *count
}

fn main() {
 tauri::Builder::default()
 .manage(AppState { counter: Mutex::new(0) })
 .invoke_handler(tauri::generate_handler![increment])
 .run(tauri::generate_context!())
 .expect("failed to run app");
}

事件系统

1
2
3
4
5
6
7


// Rust 发送事件
use tauri::Emitter;

#[tauri::command]
fn start_task(app: tauri::AppHandle) {
 app.emit("task-progress", "started").unwrap();
}

1
2
3
4
5
6
7
8
9


// 前端监听
import { listen } from '@tauri-apps/api/event';

const unlisten = await listen<string>('task-progress', (event) => {
 console.log('收到:', event.payload);
});

// 取消监听
unlisten();

跨平台打包

1
2
3
4
5
6
7
8


# 当前平台
pnpm tauri build

# 指定平台（需要对应工具链）
pnpm tauri build --target x86_64-pc-windows-msvc
pnpm tauri build --target x86_64-apple-darwin
pnpm tauri build --target aarch64-apple-darwin
pnpm tauri build --target x86_64-unknown-linux-gnu

性能对比

指标	Tauri 2.x	Electron
包大小（Hello World）	3~5MB	80MB
内存空闲	30~80MB	100~200MB
启动时间	0.3~1s	1.5~3s
CPU 占用	低	中等

下一步

Electron 入门，看 2018-12-15《Electron 跨平台桌面应用》
桌面开发技术栈对比，看 2014-08-15《桌面开发技术栈对比》

参考资料

Tauri 官方：https://tauri.app/
Tauri 2.x 文档：https://v2.tauri.app/
Awesome Tauri：https://github.com/tauri-apps/awesome-tauri
tauri-plugin-* 插件列表：https://v2.tauri.app/plugin/

Electron 跨平台桌面应用：从零搭建到打包分发

Sat, 15 Dec 2018 00:00:00 +0800

什么是 Electron

Electron 是 GitHub 2013 年推出的开源框架，让开发者用 HTML + CSS + JavaScript 构建跨平台桌面应用。核心 = Chromium + Node.js。

优势

Web 技术栈：React / Vue / Angular 任意
跨平台：一套代码，Windows / macOS / Linux
完整 Node.js API：文件系统、子进程、网络
生态丰富：VSCode、Slack、Discord、Notion 都是 Electron

快速开始

环境要求

Node.js 18+
npm / yarn / pnpm
平台原生工具：Windows 需 Visual Studio Build Tools，macOS 需 Xcode CLT，Linux 需 libnss3 等

创建项目

1
2


mkdir my-electron-app && cd my-electron-app
npm init -y

修改 package.json：

1
2
3
4
5
6
7
8


{
 "name": "my-electron-app",
 "version": "1.0.0",
 "main": "main.js",
 "scripts": {
 "start": "electron ."
 }
}

安装：

1

npm install --save-dev electron

package.json 会加：

1
2
3


"devDependencies": {
 "electron": "^33.2.0"
}

main.js（主进程）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


const { app, BrowserWindow } = require('electron');
const path = require('path');

const createWindow = () => {
 const win = new BrowserWindow({
 width: 1200,
 height: 800,
 webPreferences: {
 preload: path.join(__dirname, 'preload.js'),
 contextIsolation: true, // 默认 true（安全）
 nodeIntegration: false, // 默认 false（安全）
 },
 });

 win.loadFile('index.html');
 // win.webContents.openDevTools();
};

app.whenReady().then(() => {
 createWindow();

 app.on('activate', () => {
 if (BrowserWindow.getAllWindows().length === 0) {
 createWindow();
 }
 });
});

app.on('window-all-closed', () => {
 if (process.platform !== 'darwin') {
 app.quit();
 }
});

preload.js（预加载）

1
2
3
4
5
6
7


const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('api', {
 sendMessage: (msg) => ipcRenderer.send('message', msg),
 onReply: (callback) => ipcRenderer.on('reply', callback),
 invokeMethod: (method, args) => ipcRenderer.invoke(method, args),
});

index.html（渲染进程）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


<!DOCTYPE html>
<html>
<head>
 <meta charset="UTF-8">
 <title>My App</title>
</head>
<body>
 <h1>Hello, Electron!</h1>
 <button id="btn">点击</button>
 <p id="output"></p>

 <script>
 document.getElementById('btn').addEventListener('click', () => {
 window.api.invokeMethod('greet', 'World').then((result) => {
 document.getElementById('output').textContent = result;
 });
 });
 </script>
</body>
</html>

启动

1

npm start

打开开发者工具（DevTools）：Ctrl + Shift + I

进程架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


┌──────────────────────┐ ┌──────────────────────┐
│ Main Process │ │ Renderer Process │
│ (Node.js) │ IPC │ (Chromium) │
│ │ ←─────→ │ │
│ - 应用生命周期 │ │ - 渲染 UI │
│ - 创建 / 关闭窗口 │ │ - Web 前端 │
│ - 菜单 / 托盘 │ │ - 不能直接用 Node │
│ - 调用系统 API │ │ │
└──────────────────────┘ └──────────────────────┘
 ↑ ↑
 │ │
 │ ┌────────────────┐ │
 └────────→│ Preload │←──────┘
 │ (桥接) │
 │ - contextBridge│
 │ - 暴露受限 API │
 └────────────────┘

IPC 通信

方式 1：invoke / handle（推荐）

渲染进程：

1
2
3


// renderer.js
const result = await window.api.invokeMethod('greet', 'World');
console.log(result);

preload.js：

1
2
3


contextBridge.exposeInMainWorld('api', {
 invokeMethod: (method, args) => ipcRenderer.invoke(method, args),
});

主进程：

1
2
3
4
5


const { ipcMain } = require('electron');

ipcMain.handle('greet', async (event, name) => {
 return `Hello, ${name}!`;
});

方式 2：send / on（单向）

渲染进程：

1
2
3
4


window.api.sendMessage('用户点击了');
window.api.onReply((event, data) => {
 console.log('收到主进程回复:', data);
});

preload.js：

1
2
3
4


contextBridge.exposeInMainWorld('api', {
 sendMessage: (msg) => ipcRenderer.send('message', msg),
 onReply: (callback) => ipcRenderer.on('reply', callback),
});

主进程：

1
2
3
4


ipcMain.on('message', (event, msg) => {
 console.log('收到:', msg);
 event.sender.send('reply', '已收到');
});

主进程 API

菜单

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


const { Menu, app } = require('electron');

const template = [
 {
 label: '文件',
 submenu: [
 { label: '新建', accelerator: 'CmdOrCtrl+N', click: () => { /* ... */ } },
 { type: 'separator' },
 { role: 'quit' },
 ],
 },
 {
 label: '编辑',
 submenu: [
 { role: 'undo' },
 { role: 'redo' },
 { type: 'separator' },
 { role: 'cut' },
 { role: 'copy' },
 { role: 'paste' },
 ],
 },
];

const menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);

对话框

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


const { dialog } = require('electron');

// 打开文件
const result = await dialog.showOpenDialog({
 title: '选择文件',
 filters: [{ name: 'Text', extensions: ['txt', 'md'] }],
});
console.log(result.filePaths);

// 保存文件
const result = await dialog.showSaveDialog({
 title: '保存',
 defaultPath: 'untitled.txt',
});

// 消息框
await dialog.showMessageBox({
 type: 'info',
 title: '提示',
 message: '操作成功',
 detail: '已保存到磁盘',
});

系统托盘

1
2
3
4
5
6
7
8


const { Tray, Menu, nativeImage } = require('electron');

const tray = new Tray(nativeImage.createEmpty());
tray.setToolTip('My App');
tray.setContextMenu(Menu.buildFromTemplate([
 { label: '显示', click: () => { /* show window */ } },
 { label: '退出', click: () => { app.quit(); } },
]));

通知

1
2
3
4


new Notification({
 title: '新消息',
 body: 'Hello from main process',
}).show();

文件系统

主进程用 fs，渲染进程通过 IPC：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 主进程
ipcMain.handle('read-file', async (event, path) => {
 const fs = require('fs/promises');
 return await fs.readFile(path, 'utf8');
});

ipcMain.handle('write-file', async (event, path, content) => {
 const fs = require('fs/promises');
 await fs.writeFile(path, content);
});

渲染进程访问

完整框架（React / Vue）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# React + Vite
npm create vite@latest my-electron-app -- --template react-ts
cd my-electron-app
npm install
npm install --save-dev electron electron-builder

# 配置 vite.config.ts
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
 base: './',
 plugins: [react()],
 build: {
 outDir: 'dist',
 },
});

1
2
3
4
5
6
7


// package.json
"main": "main.js",
"scripts": {
 "dev": "concurrently \"vite\" \"electron .\"",
 "build": "vite build",
 "package": "electron-builder"
}

文件结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


my-electron-app/
├── electron/
│ ├── main.js
│ └── preload.js
├── src/
│ ├── App.tsx
│ └── main.tsx
├── index.html
├── vite.config.ts
└── package.json

打包分发

electron-builder

1

npm install --save-dev electron-builder

package.json：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


{
 "build": {
 "appId": "com.example.myapp",
 "productName": "MyApp",
 "directories": {
 "output": "dist"
 },
 "files": [
 "electron/**/*",
 "dist/**/*",
 "package.json"
 ],
 "win": {
 "target": ["nsis", "portable"],
 "icon": "build/icon.ico"
 },
 "mac": {
 "target": ["dmg", "zip"],
 "icon": "build/icon.icns",
 "category": "public.app-category.developer-tools"
 },
 "linux": {
 "target": ["AppImage", "deb"],
 "icon": "build/icon.png",
 "category": "Development"
 }
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 用 forge 一键导入
npx electron-forge import

# 打包
npm run make

# 结果
# Windows: out/MyApp Setup 1.0.0.exe
# macOS: out/MyApp-1.0.0.dmg
# Linux: out/MyApp-1.0.0.AppImage

electron-forge（替代方案）

1
2
3


npm install --save-dev @electron-forge/cli
npx electron-forge import
npm run make

安全最佳实践

必须开启

1
2
3
4
5
6
7
8


new BrowserWindow({
 webPreferences: {
 contextIsolation: true, // 沙箱
 nodeIntegration: false, // 渲染进程禁用 Node
 sandbox: true, // Chromium 沙箱
 preload: path.join(__dirname, 'preload.js'),
 },
});

关闭新窗口

1
2
3
4
5
6


app.on('web-contents-created', (event, contents) => {
 contents.setWindowOpenHandler(({ url }) => {
 require('electron').shell.openExternal(url);
 return { action: 'deny' };
 });
});

CSP

1
2


<meta http-equiv="Content-Security-Policy"
 content="default-src 'self'; script-src 'self'">

自动更新

1

npm install --save-dev electron-updater

1
2
3
4


// main.js
const { autoUpdater } = require('electron-updater');

autoUpdater.checkForUpdatesAndNotify();

package.json：

1
2
3
4
5
6
7


"build": {
 "publish": {
 "provider": "github",
 "owner": "yourname",
 "repo": "myapp"
 }
}

性能优化

开启 V8 缓存：--js-flags="--max-old-space-size=4096"
启用 lazy load：路由懒加载
Web Worker 处理密集计算
offscreen 渲染：截图 / 录屏

常见问题

启动白屏

通常是预加载脚本报错。检查 preload.js 路径和 contextBridge 用法。

require is not defined

渲染进程不能直接用 require，必须通过 preload.js 暴露。

跨域请求

主进程可以任意跨域；渲染进程需要用 IPC 转发到主进程发起请求。

macOS 签名

1
2
3


# 开发者证书
codesign --deep --force --verify --verbose --sign "Developer ID Application: Name" MyApp.app
xcrun notarytool submit MyApp.zip --keychain-profile "AC_PASSWORD"

下一步

Tauri 2.x 实战，看 2020-05-15《Tauri 2.x 跨平台桌面应用》
桌面开发技术栈对比，看 2014-08-15《桌面开发技术栈对比》

参考资料

Electron 官方：https://www.electronjs.org/
Electron 文档：https://www.electronjs.org/docs/latest/
electron-builder：https://www.electron.build/
electron-forge：https://www.electronforge.io/
Awesome Electron：https://github.com/sindresorhus/awesome-electron

接口文档模板与 .NET 平台应用场景

Tue, 15 May 2018 00:00:00 +0800

前置知识

至少调用过一个 HTTP API（GET / POST / JSON）
知道什么是 REST、什么是接口
了解任一后端语言（Java / Go / Python 即可）

一份合格的接口文档应该长什么样

2010 年代中后期，微服务、API 经济、OpenAPI 规范逐步走向主流——前后端分离的协作模式倒逼后端必须给前端 / 移动端 / 第三方提供"机器可读 + 人可读"两份接口契约。

一份合格的接口文档必须回答 5W1H：

维度	回答什么
What	接口是什么？功能描述
Where	接口在哪？URL / IP / 端口
When	何时调用？超时、重试、限流
Who	谁可以调？鉴权方式
Which	进出什么数据？字段含义、类型、必填
How	怎么调？HTTP 方法、Headers、错误码

下面是一份可直接复用的 Markdown 模板。

一、接口文档 Markdown 模板

1.1 顶层信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 接口名

## 接口协议：http / https

## 接口地址：写明需要调用的地址或 IP

## 接口端口：服务开启的端口号

## 目录（自动生成）

[TOC]

1.2 单接口详细说明

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


## 1. 简单描述接口

### 接口功能

> 描述这个接口是干什么用的，基本逻辑是什么

### URL

> 接口调用地址，例：`/api/rest/wasteMap/entInfo/getEntInfoById`

### 支持格式

> `json` / `html` / `xml`

### HTTP 请求方式

> `GET` / `POST` / `PUT` / `DELETE`

### 请求参数

| 参数 | 必选 | 类型 | 说明 |
| :--- | :--- | :--- | :--- |
| id | 是 | string | 实体唯一标识 |
| name | 否 | string | 名称（模糊匹配） |

### 返回字段

| 返回字段 | 字段类型 | 说明 |
| :--- | :--- | :--- |
| code | int | 状态码，200=成功 |
| msg | string | 提示信息 |
| data | object | 业务数据 |
| data.id | string | 实体 ID |
| data.name | string | 实体名称 |

### 接口示例

> 调用地址：`http://api.example.com:8080/api/rest/...`

#### 请求参数

```json
{
 "id": "10001"
}

返回结果

1
2
3
4
5
6
7
8


{
 "code": 200,
 "msg": "成功",
 "data": {
 "id": "10001",
 "name": "示例"
 }
}

错误码

错误码	含义	处理建议
200	成功	-
400	参数错误	检查请求参数
401	未授权	重新登录获取 token
403	无权限	联系管理员
404	资源不存在	检查 id
500	服务器异常	联系后端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53



### 1.3 完整示例

```markdown
# 危险废物地图 - 企业详情查询

## 接口协议：https

## 接口地址：api.example.com

## 接口端口：443

## 1. 简单描述接口

### 接口功能

> 根据企业 ID 查询企业基本信息、许可证信息、危废产生量

### URL

> `/api/rest/wasteMap/entInfo/getEntInfoById`

### 支持格式

> json

### HTTP 请求方式

> GET

### 请求参数

| 参数 | 必选 | 类型 | 说明 |
| :--- | :--- | :--- | :--- |
| entId | 是 | string | 企业 ID |

### 返回字段

| 返回字段 | 字段类型 | 说明 |
| :--- | :--- | :--- |
| code | int | 状态码 |
| msg | string | 描述 |
| data | object | 企业信息 |
| data.entName | string | 企业名称 |
| data.legalPerson | string | 法人 |
| data.address | string | 地址 |
| data.licenses | array | 许可证列表 |

### 接口示例

> 地址：`https://api.example.com/api/rest/wasteMap/entInfo/getEntInfoById?entId=10001`

#### 请求 Headers

Authorization: Bearer eyJhbGciOiJIUzI1NiJ9… Content-Type: application/json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19



#### 返回结果

```json
{
 "code": 200,
 "msg": "成功",
 "data": {
 "entName": "某环保科技公司",
 "legalPerson": "张三",
 "address": "江苏省南京市江宁区...",
 "licenses": [
 {
 "licNo": "HW-2024-001",
 "validUntil": "2027-12-31"
 }
 ]
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42



## 二、接口文档工具链

### 2.1 OpenAPI 3.0（Swagger）

2015 年 Swagger 规范被 SmartBear 捐给 Linux 基金会，演化为 **OpenAPI 3.0**——机器可读的接口定义标准。

```yaml
# openapi.yaml
openapi: 3.0.0
info:
 title: 示例 API
 version: 1.0.0
 description: 危险废物地图服务
servers:
 - url: https://api.example.com
paths:
 /api/rest/wasteMap/entInfo/getEntInfoById:
 get:
 summary: 查询企业详情
 parameters:
 - name: entId
 in: query
 required: true
 schema:
 type: string
 responses:
 '200':
 description: 成功
 content:
 application/json:
 schema:
 $ref: '#/components/schemas/EntInfo'
components:
 schemas:
 EntInfo:
 type: object
 properties:
 entName:
 type: string
 legalPerson:
 type: string

工具链：

Swagger UI：把 YAML 渲染成可调试的网页（/swagger-ui/index.html）
Swagger Editor：在线编辑器
Swagger Codegen：自动生成 Java / Go / TS 客户端 SDK
Springdoc / springfox：Java 注解自动生成 OpenAPI YAML

2.2 API 文档平台

工具	优势	适合
Swagger / OpenAPI	行业标准	任何规模
Postman	协作 + 调试	前后端协作
Apifox	国产、UI 友好	中小团队
ShowDoc	国产、轻量	内部文档
语雀 / 飞书	知识库	业务文档为主
ReadMe	商业化、交互式	SaaS 产品

2.3 文档即代码（Doc-as-Code）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Git 仓库结构
docs/
├── api/
│ ├── openapi.yaml # 接口定义
│ ├── errors.md # 错误码字典
│ └── auth.md # 鉴权说明
├── guides/
│ ├── quickstart.md
│ └── best-practices.md
└── README.md

版本随代码走（PR review 改接口必改文档）
CI 自动部署到内网 / 公网（GitHub Pages + 自动构建）
评审流程与代码一致

三、.NET 平台应用场景

3.1 .NET Framework vs .NET Core

维度	.NET Framework	.NET Core / .NET 5+
平台	Windows only	跨平台（Win / macOS / Linux）
开源	闭源	MIT 开源（2014 年起）
性能	一般	比 Framework 快 2-10 倍
微服务	不友好	一等公民
容器化	难	镜像 100MB-
现状	维护模式	主流

2016 年微软开源 .NET Core 1.0、2017 年发布 2.0、2020 年 .NET 5 统一品牌、2024 年 .NET 9 已是事实标准。

3.2 七大应用领域

① Web 应用

ASP.NET Core MVC / Razor Pages / Blazor：

1
2
3
4
5
6
7
8
9


// Razor Page
@page
@model IndexModel
@{
 ViewData["Title"] = "首页";
}

<h1>@Model.Greeting</h1>
<p>当前时间：@DateTime.Now</p>

适合：企业内网系统、SaaS 后台、CMS。

② 移动开发

Xamarin（2011 年起）+ .NET MAUI（2022 年起）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// .NET MAUI
public partial class MainPage : ContentPage
{
 public MainPage()
 {
 InitializeComponent();
 }

 void OnCounterClicked(object sender, EventArgs e)
 {
 count++;
 CounterLabel.Text = $"点击 {count} 次";
 }
}

一份 C# 代码，编译成 iOS / Android / Windows / macOS 原生应用。

③ 桌面应用程序

WPF（Windows Presentation Foundation）——Windows 桌面 UI
WinForms —— 老式 Windows 桌面
WinUI 3 —— 现代 Windows 11 风格
Avalonia —— 跨平台桌面 UI（类似 Flutter 思路）

适合：企业内部工具、IDE 插件、客户端软件。

④ 微服务与容器

ASP.NET Core + Docker + Kubernetes：

1
2
3
4
5


# 5MB 镜像级别
FROM mcr.microsoft.com/dotnet/aspnet:9.0-alpine
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyService.dll"]

.NET 9 + NativeAOT（Ahead-of-Time）编译后镜像 50MB，启动 < 100ms——对标 Go 的部署体验。

⑤ 云应用程序

Azure 一等公民，AWS / 阿里云 / 腾讯云都有 SDK：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Azure Functions 写法（无服务器）
public class HttpExample
{
 [Function("HttpExample")]
 public async Task<HttpResponseData> Run(
 [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req)
 {
 var response = req.CreateResponse(HttpStatusCode.OK);
 await response.WriteStringAsync("Hello from Azure Functions!");
 return response;
 }
}

⑥ 物联网（IoT）

.NET nanoFramework —— 跑在 STM32 / ESP32 嵌入式芯片
Meadow —— IoT 主板，完整 .NET 运行时
Azure IoT Hub SDK —— 云端接入

⑦ 机器学习

ML.NET —— 微软的机器学习框架，2018 年开源：

1
2
3
4
5
6


// 训练一个情感分析模型
var mlContext = new MLContext();
var data = mlContext.Data.LoadFromTextFile<SentimentData>("sentiment.csv", hasHeader: true);
var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", "Text")
 .Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression());
var model = pipeline.Fit(data);

也支持调用 ONNX 模型、TensorFlow .NET 绑定。

⑧ 游戏

Unity 是全球最大游戏引擎（手游市场 50%+），C# 是 Unity 的唯一脚本语言。王者荣耀、原神、纪念碑谷都用 C# / Unity。

四、.NET 选型决策树

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


新项目，应该选什么 .NET？
│
├─ Web / 微服务？
│ ├─ Windows only + 老系统集成 → ASP.NET (.NET Framework 4.8)
│ └─ 跨平台 / 容器 / 云原生 → ASP.NET Core (.NET 8 / 9)
│
├─ 桌面？
│ ├─ 内部工具 / Windows only → WPF / WinForms
│ ├─ 现代 Windows UI → WinUI 3
│ └─ 跨平台桌面 → Avalonia / .NET MAUI
│
├─ 移动？
│ ├─ iOS / Android / Windows 跨平台 → .NET MAUI
│ └─ Unity 游戏 → Unity + C#
│
├─ 嵌入式 / IoT？
│ ├─ 资源极受限（< 256KB RAM）→ C / C++
│ └─ STM32 / ESP32 → .NET nanoFramework
│
└─ ML？
 └─ ML.NET / 调 ONNX / 调 TensorFlow.NET

五、为什么 2018 年 .NET 突然火了

跨平台 + 开源：2014 年 .NET Core 开源后，Linux 服务器也能跑 C#——Linux 工程师不再鄙视 .NET
性能飞升：TechEmpower Round 14 基准测试，ASP.NET Core 超过 Node.js、Go、Java
VS Code + Rider：跨平台 IDE 体验不输 Visual Studio
云原生友好：镜像小、启动快、K8s 一等公民
企业级生态：Entity Framework Core、xUnit、Serilog、MediatR——dotnet add package 一行解决

六、下一步

入门：.NET 官方文档 https://learn.microsoft.com/dotnet/，先跑通 dotnet new web
Web 框架：ASP.NET Core 8 / 9 Minimal API
微服务：Steeltoe（Spring Cloud 之于 Spring Boot）
测试：xUnit + FluentAssertions + NSubstitute
ORM：EF Core（官方）、Dapper（轻量）、FreeSQL（国产）

参考资料

.NET 官方文档：https://learn.microsoft.com/dotnet/
OpenAPI 规范：https://spec.openapis.org/oas/v3.0.3
Swagger 工具链：https://swagger.io/tools/
ASP.NET Core 源码：https://github.com/dotnet/aspnetcore
.NET 基金会：https://dotnetfoundation.org/

Go-Fyne 入门：Go 跨平台 GUI 实战

Sat, 15 Oct 2016 00:00:00 +0800

什么是 Fyne

Fyne（发音 “feign”）是 2018 年起的 Go 跨平台 GUI 框架，目标：用 Go 写原生体验的桌面应用。

特点：

跨平台：Windows / macOS / Linux（也支持 FreeBSD、嵌入式）
单二进制：编译后无外部依赖
原生控件：用系统原生 GUI 库（Win32 GDI、Cocoa、GTK）
Material Design 风格：类 Flutter 的现代化外观
声明式 API：v2 起更接近 React / Flutter

安装

1
2
3
4
5
6
7
8


# Go 1.20+
go version

# 安装 fyne CLI
go install fyne.io/fyne/v2/cmd/fyne@latest

# 验证
fyne version

系统依赖

Linux (Debian / Ubuntu)

1
2
3
4
5
6
7
8
9


sudo apt install -y \
 libgl1-mesa-dev \
 xorg-dev \
 pkg-config \
 libxrandr-dev \
 libxinerama-dev \
 libxcursor-dev \
 libxi-dev \
 libxxf86vm-dev

macOS

Xcode Command Line Tools：

1

xcode-select --install

Windows

MinGW-w64 + GCC。Scoop 一键装：

1

scoop install gcc

第一个程序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import (
 "fyne.io/fyne/v2/app"
 "fyne.io/fyne/v2/widget"
)

func main() {
 a := app.New()
 w := a.NewWindow("Hello Fyne")
 w.SetContent(widget.NewLabel("Hello, 世界!"))
 w.ShowAndRun()
}

1

go run main.go

布局

Fyne 提供 6 种布局：

布局	用途
`container.NewVBox`	垂直排列
`container.NewHBox`	水平排列
`container.NewBorder`	四边 + 中心
`container.NewGrid`	等宽网格
`container.NewGridWrap`	自适应网格
`container.NewCenter`	居中
`container.NewPadded`	加内边距
`container.NewMax`	重叠

1
2
3
4
5
6
7
8
9


vbox := container.NewVBox(
 widget.NewLabel("顶部"),
 widget.NewButton("按钮", func() {
 fmt.Println("点击")
 }),
 widget.NewEntry(),
 widget.NewLabel("底部"),
)
w.SetContent(vbox)

常用控件

基础控件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 文本
widget.NewLabel("静态文本")
widget.NewEntry() // 单行输入
widget.NewMultiLineEntry() // 多行输入
widget.NewPasswordEntry() // 密码
widget.NewRichText() // 富文本

// 按钮
widget.NewButton("普通按钮", callback)
widget.NewButtonWithIcon("图标按钮", theme.DocumentIcon(), callback)
widget.NewHyperlink("链接", url)

// 选择
widget.NewCheck("复选框", onChange)
widget.NewRadio([]string{"男", "女"}, onChange)
widget.NewSelect([]string{"Java", "Go", "Rust"}, onChange)
widget.NewSlider(0, 100) // 滑块
widget.NewProgressBar() // 进度条

// 容器
widget.NewCard("标题", "副标题", content)
widget.NewAccordion() // 手风琴
widget.NewTabContainer() // 标签页
widget.NewSplit() // 分割

表单

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


form := &widget.Form{
 Items: []*widget.FormItem{
 {Text: "用户名", Widget: widget.NewEntry()},
 {Text: "密码", Widget: widget.NewPasswordEntry()},
 },
 OnSubmit: func() {
 fmt.Println("提交")
 },
 OnCancel: func() {
 fmt.Println("取消")
 },
}

列表

1
2
3
4
5
6
7


list := widget.NewList(
 func() int { return len(items) },
 func() fyne.CanvasObject { return widget.NewLabel("") },
 func(i int, o fyne.CanvasObject) {
 o.(*widget.Label).SetText(items[i])
 },
)

表格

1
2
3
4
5
6
7
8
9


table := widget.NewTable(
 func() (int, int) { return len(rows), 2 },
 func() fyne.CanvasObject {
 return widget.NewLabel("wide content")
 },
 func(i int, j int, o fyne.CanvasObject) {
 o.(*widget.Label).SetText(fmt.Sprintf("%d-%d", i, j))
 },
)

Canvas 绘图

Fyne Canvas 2D API 适合自定义图形：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import (
 "fyne.io/fyne/v2/canvas"
 "image/color"
)

// 矩形
rect := canvas.NewRectangle(color.RGBA{255, 0, 0, 255})
rect.Resize(fyne.NewSize(100, 100))

// 圆形
circle := canvas.NewCircle(color.RGBA{0, 255, 0, 255})

// 文本
text := canvas.NewText("Canvas Text", color.Black)
text.TextSize = 24

// 线条
line := canvas.NewLine(color.Black)
line.StrokeWidth = 2

// 图片
img := canvas.NewImageFromResource(resource.ExamplePng())
img.FillMode = canvas.ImageFillOriginal

// 组合
canvasContainer := container.NewWithoutLayout(rect, circle, text, line)

菜单

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


menu := fyne.NewMainMenu(
 fyne.NewMenu("文件",
 fyne.NewMenuItem("新建", func() { /* ... */ }),
 fyne.NewMenuItem("打开", func() { /* ... */ }),
 fyne.NewMenuItemSeparator(),
 fyne.NewMenuItem("退出", func() { a.Quit() }),
 ),
 fyne.NewMenu("帮助",
 fyne.NewMenuItem("关于", func() { /* ... */ }),
 ),
)
w.SetMainMenu(menu)

主题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import "fyne.io/fyne/v2/theme"

// 亮色 / 暗色
a.Settings().SetTheme(theme.LightTheme())
a.Settings().SetTheme(theme.DarkTheme())

// 自定义
type MyTheme struct{}
func (m MyTheme) Color(name fyne.ThemeColorName, variant fyne.ThemeVariant) color.Color {
 return color.RGBA{0, 100, 200, 255}
}
a.Settings().SetTheme(MyTheme{})

数据绑定

Fyne v2.1+ 支持响应式数据绑定：

1
2
3
4
5
6
7
8
9


str := binding.NewString()
str.Set("Hello")

entry := widget.NewEntryWithData(str)

// 监听变化
str.AddListener(binding.NewDataListener(func() {
 fmt.Println("值变了:", str.Get())
}))

绑定类型：

binding.NewString() / NewInt() / NewFloat() / NewBool()
binding.NewList() / NewMap()

跨平台编译

1
2
3
4
5
6
7
8


# 在 macOS 上编译 Linux 版本
GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

# 编译 Windows
GOOS=windows GOARCH=amd64 go build -o myapp.exe main.go

# 编译 macOS（arm64 M1）
GOOS=darwin GOARCH=arm64 go build -o myapp-mac main.go

打包分发

Fyne 自带 fyne CLI 打包：

1
2
3
4
5
6
7


# 打包当前平台
fyne package -name MyApp -icon icon.png

# 跨平台打包（需要对应工具链）
fyne package -os darwin -name MyApp
fyne package -os linux -name MyApp
fyne package -os windows -name MyApp

打包结果：

Linux：MyApp.tar.xz（含 .desktop 文件）
macOS：MyApp.app
Windows：MyApp.exe（可加 installer）

实战：计算器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package main

import (
 "fmt"
 "fyne.io/fyne/v2/app"
 "fyne.io/fyne/v2/container"
 "fyne.io/fyne/v2/widget"
)

func main() {
 a := app.New()
 w := a.NewWindow("计算器")
 w.Resize(fyne.NewSize(300, 400))

 output := widget.NewLabel("0")
 output.TextStyle = fyne.TextStyle{Bold: true}
 output.Alignment = fyne.TextAlignTrailing

 btn := func(label string, fn func()) *widget.Button {
 return widget.NewButton(label, fn)
 }

 digits := container.NewGridWithColumns(3,
 btn("7", func() { output.SetText(output.Text + "7") }),
 btn("8", func() { output.SetText(output.Text + "8") }),
 btn("9", func() { output.SetText(output.Text + "9") }),
 // ...
 )

 w.SetContent(container.NewVBox(output, digits))
 w.ShowAndRun()
}

实战：Todo List

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


type Todo struct {
 Title string
 Done bool
}

var todos []Todo

func main() {
 a := app.New()
 w := a.NewWindow("Todo")
 w.Resize(fyne.NewSize(400, 600))

 input := widget.NewEntry()
 input.SetPlaceHolder("输入新任务")

 list := widget.NewList(
 func() int { return len(todos) },
 func() fyne.CanvasObject {
 return container.NewHBox(
 widget.NewCheck("", nil),
 widget.NewLabel(""),
 )
 },
 func(i int, o fyne.CanvasObject) {
 c := o.(*fyne.Container)
 c.Objects[0].(*widget.Check).SetChecked(todos[i].Done)
 c.Objects[1].(*widget.Label).SetText(todos[i].Title)
 },
 )

 addBtn := widget.NewButton("添加", func() {
 if input.Text != "" {
 todos = append(todos, Todo{Title: input.Text})
 input.SetText("")
 list.Refresh()
 }
 })

 w.SetContent(container.NewVBox(
 container.NewBorder(nil, nil, nil, addBtn, input),
 list,
 ))
 w.ShowAndRun()
}

下一步

跨平台桌面技术栈对比，看 2014-08-15《桌面开发技术栈对比》
Tauri 2.x 实战，看 2020-05-15《Tauri 2.x 跨平台桌面应用》
Electron 入门，看 2018-12-15《Electron 跨平台桌面应用》

参考资料

Fyne 官方：https://fyne.io/
Fyne Tour：https://tour.fyne.io/
Fyne GitHub：https://github.com/fyne-io/fyne
Fyne 示例：https://github.com/fyne-io/fyne/tree/master/v2/cmd/fyne_demo

桌面开发技术栈对比：Electron vs Tauri vs Qt vs Fyne

Fri, 15 Aug 2014 00:00:00 +0800

跨平台桌面应用 4 大技术栈

技术	底层	语言	包大小	性能	生态
Electron	Chromium + Node.js	JS/TS	80~150MB	★★★	★★★★★
Tauri	系统 WebView + Rust	TS + Rust	2~10MB	★★★★★	★★★
Qt	Qt 库	C++ / QML / Python	30~80MB	★★★★★	★★★★
Fyne	系统 GUI	Go	10~30MB	★★★★	★★

一、Electron

原理

Chromium：渲染 UI（每个窗口一个）
Node.js：调用本地 API（文件系统、进程、IPC）
主进程 + 渲染进程：主进程（Node.js）管理窗口，渲染进程（Chromium）展示 UI

优势

Web 生态完整：React、Vue 任意用
跨平台：Windows / macOS / Linux 一套代码
第三方 SDK 丰富：自动更新、native dialog、native menu

劣势

包大：80MB 起步
内存高：每个窗口一个 Chromium
性能：JS 引擎有 GC 抖动

代表应用

VSCode、Slack、Discord、Notion、Postman、Figma Desktop

适用场景

内部工具 / 中后台
重 UI 重数据展示
团队 JS 技术栈

二、Tauri

原理

系统 WebView：Windows 用 WebView2，macOS 用 WKWebView，Linux 用 WebKitGTK
Rust 后端：编译成原生二进制，提供 IPC、文件系统、shell 等
前端任意：React / Vue / Svelte / Solid / 纯 HTML

优势

极小包：2~10MB（vs Electron 80MB）
低内存：复用系统 WebView
Rust 后端：性能强、安全（内存安全）
细粒度权限：声明式 ACL

劣势

WebView 跨平台表现不一致（Windows 较新，Linux GTK 旧）
生态比 Electron 小
学习曲线：Rust + 前端

代表应用

各种 Rust 生态工具
部分 VSCode 插件、Cursor 编辑器
OpenCode、cc-connect、tinyhumans/openhuman

适用场景

追求包大小 / 启动速度
Rust 团队
命令行 + GUI 一体

三、Qt

原理

Qt 库：跨平台 C++ GUI 库
QWidget：传统 UI
QML：声明式 UI（类 QML + JavaScript）
PyQt / PySide：Python 绑定

优势

性能极强：原生绘制
跨平台：Windows / macOS / Linux / Android / iOS / 嵌入式
工业级：KDE、Autodesk Maya、VirtualBox、VLC
工具链成熟：Qt Creator IDE

劣势

学习曲线陡：C++ + Qt 框架
商业授权：LGPL / GPL / Commercial 三种
包大：30MB+
UI 不够现代（vs Web）

适用场景

工业控制 / 嵌入式 UI
科学计算 / 数据可视化
跨平台 + 高性能

四、Fyne

原理

Go 语言：编译成单一二进制
系统原生控件：Windows GDI、macOS Cocoa、Linux GTK
声明式 API：类 Flutter 风格

优势

跨平台编译：Go 一份代码，Windows/macOS/Linux 任意编译
单二进制：无外部依赖
小包：10~30MB
简单易学

劣势

生态小：第三方库少
UI 不够丰富：控件有限
性能中等：没有 GPU 加速

适用场景

Go 团队
内部工具
简单桌面应用

详细对比

包大小

应用	Electron	Tauri	Qt	Fyne
Hello World	80MB	3MB	30MB	12MB
复杂应用（VSCode 级别）	200MB+	15MB	100MB	40MB

启动时间

应用	Electron	Tauri	Qt	Fyne
冷启动	1.5~3s	0.3~1s	0.2~0.5s	0.5~1s
热启动	0.5~1s	0.1~0.3s	0.1~0.2s	0.2~0.5s

内存占用

应用	Electron	Tauri	Qt	Fyne
空闲	100~200MB	30~80MB	20~50MB	30~70MB
复杂场景	500MB+	150MB	100MB	150MB

选型决策树

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


你的团队用什么语言？
├── JS/TS → Electron（生态最好）
├── Rust → Tauri（性能 + 体积最优）
├── C++ → Qt（性能 + 工业级）
├── Go → Fyne（最简单）
└── Python → PyQt / PySide

你的核心需求是？
├── 包小 + 快 → Tauri
├── 生态丰富 → Electron
├── 高性能 3D / 工业 → Qt
└── Go 写小工具 → Fyne

安装包大小优化

Electron

移除不必要的依赖
用 electron-builder 拆分 platform / arch
用 asar 压缩资源

Tauri

用 release 模式（默认）
启用 LTO（Link Time Optimization）
拆分 release（不同 OS 单独打包）

Qt

静态链接 vs 动态链接
删除用不到的 Qt 模块

Fyne

UPX 压缩
Go 1.20+ 链接器优化

跨平台坑

macOS

签名 + 公证（notarization）必需
沙箱（sandbox）
Apple Silicon（arm64）vs Intel（x64）

Linux

各种发行版：deb / rpm / AppImage / Flatpak
WebView 版本：Ubuntu LTS 用 snap，WebView 是 Chromium

Windows

32 / 64 位
WebView2 Runtime（Win10 1803+ 预装，旧版需引导安装）

下一步

Electron 入门，看 2018-12-15《Electron 跨平台桌面应用》
Tauri 2.x 实战，看 2020-05-15《Tauri 2.x 跨平台桌面应用》
Fyne 入门，看 2016-10-15《Go-Fyne 入门》

参考资料

Electron 官方：https://www.electronjs.org/
Tauri 官方：https://tauri.app/
Qt 官方：https://www.qt.io/
Fyne 官方：https://fyne.io/
Wails（Go + WebView）：https://wails.io/
Flutter Desktop：https://flutter.dev/desktop