使用 Tonic 构建 gRPC 服务：从入门到实践

什么是 Tonic？

Tonic 是一个基于 Rust 的高性能 gRPC 实现，它提供了构建 gRPC 客户端和服务器的全套工具。Tonic 使用 HTTP/2 作为传输协议，并支持异步/等待模式，非常适合构建高效的分布式系统。

为什么选择 Tonic？

• 高性能：基于 Tokio 异步运行时和 Hyper HTTP/2 实现
• 类型安全：Rust 的强类型系统保证接口安全
• 易用性：简洁的 API 和良好的开发者体验
• 生态系统：与 Rust 生态无缝集成

快速开始

1. 创建项目并添加依赖

首先创建一个新的 Rust 项目，然后在 Cargo.toml 中添加以下依赖：

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

[package]
name = "helloworld-tonic"
version = "0.1.0"
edition = "2024"

[[bin]] # 用于运行 gRPC 服务端
name = "helloworld-server"
path = "src/server.rs"

[[bin]] # 用于运行 gRPC 客户端
name = "helloworld-client"
path = "src/client.rs"

[dependencies]
tonic = "*"
prost = "0.13"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

[build-dependencies]
tonic-build = "*"

2. 定义 Protocol Buffers 接口

在项目根目录下创建 proto/helloworld.proto 文件：

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

syntax = "proto3";
package helloworld;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
   string name = 1;
}

message HelloReply {
    string message = 1;
}

3. 构建 Protocol Buffers 代码

创建 build.rs 文件来自动生成 Rust 代码：

1
2
3
4

fn main() -> Result<(), Box<dyn std::error::Error>> {
    tonic_build::compile_protos("proto/helloworld.proto")?;
    Ok(())
}

4. 实现 gRPC 服务端

在 src/server.rs 中实现服务端逻辑：

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

use tonic::{transport::Server, Request, Response, Status};

use hello_world::greeter_server::{Greeter, GreeterServer};
use hello_world::{HelloReply, HelloRequest};

pub mod hello_world {
    tonic::include_proto!("helloworld");
}

#[derive(Debug, Default)]
pub struct MyGreeter {}

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloReply>, Status> {
        println!("Got a request: {:?}", request);

        let reply = HelloReply {
            message: format!("Hello {}!", request.into_inner().name),
        };

        Ok(Response::new(reply))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "127.0.0.1:50051".parse()?;
    let greeter = MyGreeter::default();

    println!("Server listening on {}", addr);

    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;

    Ok(())
}

5. 实现 gRPC 客户端

在 src/client.rs 中创建客户端：

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

use hello_world::{HelloRequest};
use hello_world::greeter_client::GreeterClient;

pub mod hello_world {
    tonic::include_proto!("helloworld");
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GreeterClient::connect("http://127.0.0.1:50051").await?;

    let request = tonic::Request::new(HelloRequest {
        name: "Tonic".into(),
    });

    let response = client.say_hello(request).await?;

    println!("RESPONSE={:?}", response);

    Ok(())
}

测试服务

1. 启动服务端

1

cargo run --bin helloworld-server

2. 运行客户端测试

1

cargo run --bin helloworld-client

3. 使用 grpcurl 测试

1
2

grpcurl -plaintext -import-path ./proto -proto helloworld.proto \
  -d '{"name": "Tonic"}' '127.0.0.1:50051' helloworld.Greeter/SayHello

常见问题解决

1. 版本兼容性问题

确保 tonic、tonic-build 和 prost 版本兼容。推荐使用固定版本而非通配符(*)。

2. Protocol Buffers 编译器

确保已安装 protoc 编译器，可以从 Protocol Buffers 发布页 下载。

3. 连接问题

如果遇到连接问题，尝试：

• 检查服务是否正在运行
• 确认端口是否正确
• 尝试使用 127.0.0.1 替代 localhost

总结

Tonic 提供了一个强大而简洁的方式来构建 gRPC 服务。通过本文的指南，你应该能够快速搭建起一个基本的 gRPC 服务，并理解其核心概念。随着对 Tonic 的深入使用，你可以探索更多高级特性，如流式 RPC、拦截器和自定义错误处理等。

Happy coding with Tonic!

作为Rust生态的核心工具，Cargo远不止是一个包管理器。本文将系统介绍其核心概念、目录结构和实用技巧，助你高效管理Rust项目。

一、核心概念解析

1. Crate：Rust的模块化单元

• 定义：Rust中的依赖包或编译单元（官方文档）
• 特点：
  • 可以生成库(lib)或可执行文件(bin)
  • 通过crates.io集中分发

2. Feature：灵活的编译选项

1
2

[dependencies]
serde = { version = "1.0", features = ["derive"] }

📌 关键点：

• 允许选择性启用依赖项的功能
• 减少最终二进制体积
• 官方推荐Feature规范

3. 项目类型对比

二、项目目录结构详解

1
2
3
4
5
6
7
8

.
├── Cargo.lock   # 精确锁定的依赖版本（[作用说明](https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html)）
├── Cargo.toml   # 项目元数据和依赖声明
├── examples/    # 示例代码（每个文件都是独立可执行）
├── src/         # 主代码目录
│   ├── lib.rs   # 库项目入口
│   └── main.rs  # 二进制项目入口
└── tests/       # 集成测试（自动被`cargo test`加载）

💡 测试小技巧：

1
2
3
4
5
6
7

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

• 单元测试：直接写在模块中
• 集成测试：tests/目录下的独立文件

三、依赖管理实战

1. 三种依赖声明方式

1
2
3
4

[dependencies]
rand = "0.8.5"            # crates.io版本
tokio = { git = "https://github.com/tokio-rs/tokio" }  # Git仓库
local_lib = { path = "../my-local-lib" }  # 本地路径

2. 版本控制语义

⚠️ 安全建议：生产项目应使用Cargo.lock固定精确版本

3. 紧急补丁方案

1
2

[patch.crates-io]
some-crate = { git = "https://github.com/user/some-crate", branch = "fix-bug" }

官方文档参考：Overriding Dependencies

四、高级功能：构建脚本

build.rs的典型用途：

1. 链接系统库
2. 代码生成
3. 编译时环境检查

示例（查找OpenSSL）：

1
2
3
4
5

// build.rs
fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    pkg_config::Config::new().probe("openssl").unwrap();
}

更多案例见构建脚本指南

五、国内开发者必备：更换Cargo源

在~/.cargo/config中添加：

1
2
3
4
5

[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"

可用镜像源：

• 中科大：ustc
• 清华大学：tuna
• 上海交大：sjtu

延伸阅读

1. The Cargo Book（官方手册）
2. Rust模块系统详解
3. Cargo高级特性

Rust 核心概念解析：宏、借用、Move 和生命周期

目标读者：Rust 初学者
技术栈：Rust（Macro、Ownership、Borrowing、Lifetime）

1. 引言

Rust 以其内存安全和零成本抽象著称，但初学者常常对某些核心概念感到困惑。本文将介绍 宏（Macro）、借用与引用（Borrowing & References）、Move 语义 和 'static 生命周期，帮助新手快速理解 Rust 的核心机制。

2. 宏（Macro）

是什么？

宏是 Rust 的元编程工具，允许在编译时生成或修改代码，减少重复逻辑。

两种主要宏

1. 声明宏（macro_rules!）
   类似于模式匹配，如 println!：

   1 2 3 4 5 6 7 8

   macro_rules! say_hello { () => { println!("Hello!"); }; } fn main() { say_hello!(); // 输出: Hello! }

2. 过程宏（Procedural Macros）
   更灵活，可操作 AST（抽象语法树），如 #[derive(Debug)]。

适用场景

• 减少重复代码（如批量实现 trait）。
• 构建 DSL（领域特定语言）。

官方文档：Rust Macros

3. 借用与引用（Borrowing & References）

是什么？

Rust 通过 所有权（Ownership） 管理内存，而 借用（Borrowing） 允许临时访问数据而不获取所有权。

两种引用

1. 不可变引用（&T）
   允许多个读取，但不能修改：

   1 2	let s = String::from("hello"); let len = calculate_length(&s); // 借用 s

2. 可变引用（&mut T）
   唯一且独占，可修改数据：

   1 2	let mut s = String::from("hello"); change(&mut s); // 可变借用

借用规则

1. 同一时间，要么只能有一个可变引用，要么只能有多个不可变引用。
2. 引用必须始终有效（无悬垂指针）。

示例验证：

1
2
3
4
5
6
7

fn main() {
    let mut s = String::from("hello");
    let r1 = &s; // 允许
    let r2 = &s; // 允许
    // let r3 = &mut s; // 错误！已有不可变引用
    println!("{}, {}", r1, r2);
}

官方文档：Rust Ownership

4. Move 语义

是什么？

Rust 中赋值或传参默认是 移动（Move），所有权转移后，原变量失效。

示例

1
2
3

let s1 = String::from("hello");
let s2 = s1; // s1 的所有权移动到 s2
// println!("{}", s1); // 错误！s1 已失效

例外：实现了 Copy trait 的类型（如 i32、bool）会复制而非移动：

1
2
3

let x = 5;
let y = x; // 复制，x 仍然有效
println!("x = {}, y = {}", x, y); // 正确

官方文档：Rust Move Semantics

5. 'static 生命周期

是什么？

'static 是 Rust 中最长的生命周期，表示数据在整个程序运行期间有效。

常见场景

• 字符串字面量（存储在二进制中）：

  1	let s: &'static str = "I live forever!";

• 全局静态变量：

  1 2	static VALUE: i32 = 42; let r: &'static i32 = &VALUE;

注意：不能随意标记 'static，必须确保数据确实不会释放。

官方文档：Rust Lifetimes

6. 总结

7. 进阶学习

• Rust Book
• Rust by Example
• Rustonomicon（高级内存管理）

希望这篇博客能帮助你理解 Rust 的核心概念！ 🚀

为什么选择Tauri？

在当今多平台应用需求旺盛的时代，前端开发者经常面临这样的需求：如何快速将现有的Web应用打包为桌面程序？传统方案如Electron虽然流行，但存在包体积大、性能开销高等问题。而Tauri作为一个新兴的Rust框架，能生成极小的二进制文件（最小仅几百KB），完美解决了这些问题。

下面我将通过实战演示，只需3步即可完成转换，最后还会以it-tools项目为例展示完整流程。

核心三步曲

第一步：安装Tauri CLI

在项目根目录执行：

1

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

（也支持npm/yarn安装）

第二步：初始化配置

运行初始化命令并填写基本信息：

1

pnpm tauri init

典型配置示例：

1
2
3
4
5
6

✔ 应用名称？ my-app  
✔ 窗口标题？ My App  
✔ 静态资源路径？ ../dist 
✔ 开发服务器地址？ http://localhost:5173  
✔ 开发启动命令？ pnpm dev  
✔ 构建命令？ pnpm build

第三步：启动开发模式

1

pnpm tauri dev

此时会同时启动：

1. 前端开发服务器
2. 桌面应用窗口

实战案例：it-tools项目改造

让我们用一个真实项目(it-tools)演示完整流程：

1. 克隆项目

1
2

git clone https://github.com/CorentinTh/it-tools.git
cd it-tools

2. 安装依赖

1

pnpm install

3. 常规启动（验证项目）

1

pnpm dev

4. 集成Tauri

1
2
3

pnpm add -D @tauri-apps/cli@latest
pnpm tauri init
# 按提示填写配置（参考上文）

5. 启动桌面版

1

pnpm tauri dev

启动后可以看应用界面

常见问题解答

Q：构建后的应用体积有多大？
A：基础应用约2MB，相比Electron的100MB+有巨大优势。

Q：支持哪些前端框架？
A：所有主流框架（React/Vue/Svelte等）均可使用，Tauri与框架无关。

Q：如何自定义窗口样式？
修改tauri.conf.json中的：

1
2
3
4
5
6
7
8
9

"windows": [
  {
    "title": "My App",
    "width": 800,
    "height": 600,
    "resizable": true,
    "fullscreen": false
  }
]

进阶技巧

1. 添加系统托盘图标：通过Rust代码实现
2. 调用原生API：如文件系统操作
3. 打包发布：pnpm tauri build生成各平台安装包

提示：Tauri的Rust后端能力可以逐步探索，初期只需关注前端整合即可。

结语

通过这个教程，我们仅用几条命令就实现了：

• 保留原有前端开发体验
• 获得原生桌面应用的所有特性
• 最终产物极致轻量

如果你正在寻找Electron的替代方案，Tauri绝对是2025年最值得尝试的技术之一。

（完整代码示例可在GitHub获取）
https://github.com/tuyu79/it-tools

引言

系统托盘图标是桌面应用程序中常见的功能，它允许应用在窗口关闭后继续在后台运行，并通过托盘图标提供快捷操作。本文将详细介绍如何为Tauri应用添加这一实用功能。

准备工作

在开始之前，请确保你已经：

1. 安装了最新版本的Rust和Tauri
2. 创建了一个基础的Tauri项目

实现步骤

第一步：启用Tauri的托盘功能特性

首先，我们需要在Cargo.toml文件中启用 tray-icon 和 unstable 特性：

1
2

[dependencies]
tauri = { version = "2", features = ["tray-icon","unstable"] }

这个配置会告诉Tauri我们需要使用系统托盘功能。

第二步：编写系统托盘实现代码

以下是完整的实现代码，我们将其放在main.rs或适当的位置：

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

use tauri::{
menu::{Menu, MenuItem},
tray::TrayIconBuilder,
AppHandle, Manager,
};

fn setup_tray(app: &AppHandle) -> tauri::Result<()> {
    let main_window = app.get_window("main").unwrap();
    let main_window_clone = main_window.clone();

    // 监听窗口关闭事件
    main_window.on_window_event(move |event| {
        if let tauri::WindowEvent::CloseRequested { api, .. } = event {
            api.prevent_close();
            main_window_clone.hide().unwrap(); // 隐藏窗口而不是关闭
        }
    });

    // 创建托盘菜单项
    let show_main = MenuItem::with_id(app, "show_main", "显示主窗口", true, None::<&str>)?;
    let quit = MenuItem::with_id(app, "quit", "退出", true, None::<&str>)?;
    let menu = Menu::with_items(app, &[&show_main, &quit])?;

    let app_handle = app.clone();

    // 构建并配置托盘图标
    TrayIconBuilder::new()
        .icon(app.default_window_icon().unwrap().clone())
        .menu(&menu)
        .show_menu_on_left_click(true) // 左键点击显示菜单
        .on_menu_event(move |app: &AppHandle, event| match event.id.as_ref() {
            "show_main" => {
                app_handle.get_window("main").unwrap().show().unwrap();
            }
            "quit" => {
                app.exit(0);
            }
            _ => {
                println!("未处理的菜单项: {:?}", event.id);
            }
        })
        .build(app)?;

    Ok(())
}

代码解析

1. 窗口关闭处理：

   • 我们拦截了窗口的关闭事件，改为隐藏窗口
   • 这确保了应用不会真正退出，而是继续在后台运行

2. 托盘菜单创建：

   • 创建了两个菜单项：”显示主窗口”和”退出”
   • 使用Menu::with_items将它们组合成菜单

3. 托盘图标配置：

   • 使用应用的默认图标作为托盘图标
   • 设置了左键点击显示菜单
   • 为每个菜单项添加了事件处理逻辑

实际应用

要在你的Tauri应用中使用这个功能，只需在应用初始化时调用我们的setup_tray函数：

1
2
3
4
5
6
7
8
9

fn main() {
     tauri::Builder::default()
        .setup(|app| {
            let _ = setup_tray(app.handle());
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

启动后就可以看到效果了

1

pnpm tauri dev

注意事项

1. 跨平台兼容性：

   • 不同操作系统对托盘图标的支持可能略有不同
   • 在Linux上可能需要额外的依赖

2. 图标设计：

   • 建议使用清晰简洁的图标
   • 考虑为不同分辨率提供多个尺寸的图标

3. 用户体验：

   • 提供明显的退出选项
   • 考虑添加状态指示功能（如未读消息数）

进阶学习

想要了解更多高级功能，可以参考官方文档：

• System Tray
• AppHandle API

总结

通过本文的指导，你已经学会了如何为Tauri应用添加系统托盘功能。这个功能可以显著提升你的桌面应用的用户体验，让应用更加专业和实用。

引言

在前端开发中，我们经常需要为桌面应用添加快捷键功能来提升用户体验。本文将介绍如何使用Tauri框架实现通过全局快捷键（如Alt+A）快速创建新窗口的功能。这个功能非常适合需要快速调出辅助窗口的应用场景。

技术栈

• Tauri - 构建小型、快速、安全的桌面应用框架
• tauri-plugin-global-shortcut - Tauri全局快捷键插件
• Vue.js - 前端框架（也可以使用React或其他框架）

基本概念

1. Tauri Webview窗口

Tauri中的WebviewWindow允许我们创建和管理多个浏览器窗口。每个窗口可以加载不同的HTML内容或路由。

2. 全局快捷键

全局快捷键是指在整个操作系统范围内都能响应的快捷键组合，即使应用没有获得焦点也能触发。

3. 进程间通信

Tauri前端（Web）和后端（Rust）通过事件系统进行通信，这使得我们可以在Rust中监听快捷键，然后通知前端创建窗口。

实现步骤

1. 安装必要依赖

首先确保你已经创建了Tauri项目，然后安装全局快捷键插件：

1

pnpm tauri add global-shortcut

依赖安装完后，会自动在 Rust 启动代码里引用插件

2. 添加创建窗口逻辑

在前端（如Vue组件）中添加窗口创建逻辑：

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 { WebviewWindow } from '@tauri-apps/api/webviewWindow';

const createOrShowShortcutWindow = async () => {
  // 检查窗口是否已存在
  const existingWindow = await WebviewWindow.getByLabel('shortcut-window');
  if (existingWindow) {
    await existingWindow.setFocus(); // 存在则聚焦
    return;
  }

  // 创建新窗口
  const webview = new WebviewWindow('shortcut-window', {
    url: '/', // 加载的路由
    center: true,     // 居中显示
    width: 300,      // 宽度
    height: 600,     // 高度
    alwaysOnTop: true // 置顶
  });

  // 处理窗口创建事件
  webview.once('tauri://created', () => webview.show());
  webview.once('tauri://error', (e) => {
    console.error('窗口创建失败:', e);
  });
};

3. 根组件挂载时注册快捷键

1
2
3
4
5
6
7
8
9
10

import {register} from '@tauri-apps/plugin-global-shortcut';

onMounted(async () => {
  await register('Alt+A', (event) => {
    if (event.state === "Pressed") {
      console.log('Shortcut triggered');
      createOrShowShortcutWindow()
    }
  });
});

4. 配置权限

在src-tauri/capabilities/desktop.json中添加必要的权限：

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

{
  "identifier": "desktop-capability",
  "platforms": [
    "macOS",
    "windows",
    "linux"
  ],
  "windows": [
    "main"
  ],
  "permissions": [
    "global-shortcut:default",
    "global-shortcut:allow-is-registered",
    "global-shortcut:allow-register",
    "global-shortcut:allow-unregister",
    "core:webview:allow-create-webview",
    "core:webview:allow-create-webview-window",
    "core:window:allow-show",
    "core:window:allow-set-focus",
    "core:window:allow-destroy"
  ]
}

5. 启动查看效果

1

pnpm tauri dev

按下快捷键 Alt+A, 应该会看到新窗口弹出。

示例验证

1. 运行应用后，按下Alt+A应该会弹出新窗口
2. 再次按下组合键，如果窗口已存在则会聚焦到该窗口
3. 可以尝试修改窗口大小、位置等参数查看效果

常见问题

Q: 快捷键没有生效？
A: 检查：

• 是否正确安装了插件
• 权限配置是否正确
• 快捷键是否被其他应用占用

Q: 窗口创建失败？
A: 检查：

• 新窗口配置的路由是否存在
• 窗口label是否唯一
• 控制台错误信息

进阶学习

想要了解更多高级功能，可以参考官方文档：

• 快捷键插件
• WebviewWindow

结语

通过本文，我们学习了如何在Tauri应用中实现全局快捷键创建窗口的功能。这个功能可以大大提升应用的易用性。Tauri的强大之处在于它让前端开发者也能轻松实现原生功能，而无需深入了解系统级编程。

前言

在现代应用开发中，经常需要将高性能的Rust代码与灵活的前端界面结合。Tauri框架为此提供了优雅的解决方案。本文将带你了解如何使用Tauri实现Rust与前端之间的双向通信。

技术栈介绍

我们使用以下技术：

• Tauri：一个构建小型、快速、安全的桌面应用程序的框架
• Rust：系统级编程语言，提供高性能和内存安全
• Vue/React（示例中使用Vue）：现代前端框架

基本原理

Tauri提供了一个安全的桥梁，允许：

1. 前端JavaScript调用Rust函数（命令）
2. Rust代码触发前端JavaScript事件

这种通信基于进程间通信(IPC)机制，既安全又高效。

第一部分：前端调用Rust函数

第一步：Rust端定义命令

在Rust中，我们需要定义一个可以被前端调用的”命令”：

1
2
3
4

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

关键点说明：

• #[tauri::command]宏标记这个函数为可从前端调用的命令
• 函数接收一个String参数，返回一个String
• 命令名默认与函数名相同（这里是greet）

第二步：注册命令

在main.rs中注册这个命令：

1
2
3
4
5
6

pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

第三步：前端调用命令

在前端代码中（以Vue 3为例）：

1
2
3
4
5
6
7
8
9
10
11

import { invoke } from '@tauri-apps/api/core';

async function greet() {
   try {
        const result = await invoke('greet', { name: 'gulou' });
        console.log("收到Rust的回复: ", result);
        // 输出: "收到Rust的回复: Hello, gulou!"
    } catch (error) {
        console.error("调用失败:", error);
    }
}

最佳实践：

1. 总是使用try/catch处理可能的错误
2. 参数需要与Rust函数签名匹配
3. 使用TypeScript可以获得更好的类型提示

第二部分：Rust调用前端

第一步：前端设置事件监听

在前端组件中（如Vue的onMounted钩子）：

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

import { listen } from '@tauri-apps/api/event';

const unlisteners = ref(null);

onMounted(async () => {
    try {
        const unlisten = await listen('done', (event) => {
            console.log("收到Rust的消息: ", event.payload);
        });
        unlisteners.value = unlisten;
    } catch (error) {
        console.error("监听失败:", error);
    }
});

onUnmounted(() => {
    unlisteners.value();
});

第二步：Rust发送事件

在Rust代码中：

1
2
3
4

use tauri::{Emitter};

// 假设app是你的Tauri应用实例
app.emit("done", "hello").unwrap();

高级用法：

• emit发送所有 listener，这里还包括 rust 的 listener
• emit_to发送给指定的 webview
• 可以发送任何实现了Serialize的结构体

完整示例：计数器应用

Rust部分

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

use tauri::{Emitter};

#[tauri::command]
fn increment(count: i32) -> i32 {
    count + 1
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![increment])
        .setup(|app| {
            // 启动后2秒发送通知
            let app_handle = app.handle().clone();
            std::thread::spawn(move || {
                std::thread::sleep(std::time::Duration::from_secs(2));
                app_handle.emit("ready", ()).unwrap();
            });
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

前端部分

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

<script setup>
import {ref, onMounted, onUnmounted} from 'vue';
import {invoke} from '@tauri-apps/api/core';
import {listen} from '@tauri-apps/api/event';

const count = ref(0);
const unlisten = ref(null);

onMounted(async () => {
  unlisten.value = await listen('ready', () => {
    console.log('应用已准备好');
  });
});

onUnmounted(() => {
  unlisten.value()
})

const increment = async () => {
  count.value = await invoke('increment', {count: count.value});
};
</script>

<template>
  <button @click="increment">计数: {{ count }}</button>
</template>

最终效果

调试技巧

1. 前端调试：

   • 使用浏览器开发者工具
   • 添加console.log检查通信数据

2. Rust调试：

   • 使用println!宏输出日志
   • 配置RUST_LOG=debug环境变量获取详细日志

3. 常见问题：

   • 确保命令已正确注册
   • 检查事件名称拼写是否一致
   • 验证数据格式是否符合预期

进阶学习

1. Tauri官方文档(Rust 调用前端)
2. Tauri官方文档(前端调用 Rust)
3. 流式数据处理

通过实现前后端的双向通信，你可以构建复杂的Rust-前端交互应用，充分发挥两者的优势！

引言

你是否想过用前端技术开发桌面应用？Tauri 是一个创新的框架，让你能够使用熟悉的 Web 技术（HTML, CSS, JavaScript）构建小巧、快速的跨平台桌面应用。本文将带你从零开始创建你的第一个 Tauri 应用，并解释其中的关键概念。

技术栈介绍

• Tauri: 一个基于 Rust 的框架，用于构建轻量级桌面应用
• Rust: 系统级编程语言，提供高性能和安全性
• Node.js: JavaScript 运行时环境
• pnpm: 快速、节省磁盘空间的包管理工具

为什么选择 Tauri？

1. 体积小巧：生成的应用程序比 Electron 应用小很多
2. 性能优异：基于 Rust 构建，运行效率高
3. 跨平台：支持 Windows、macOS 和 Linux
4. 熟悉的开发体验：使用前端技术栈开发
5. 安全性强：内置安全最佳实践

环境搭建

1. 安装系统依赖

根据你的操作系统，可能需要安装一些基础工具链。请参考 Tauri 官方文档 获取详细要求。

2. 安装 Rust

Rust 是 Tauri 的核心依赖。打开终端运行以下命令：

1

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

安装完成后，运行以下命令确保 Rust 安装正确：

1

rustc --version

3. 安装 Node.js

推荐使用 nvm 管理 Node.js 版本：

1
2
3
4
5

# 安装 nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# 安装最新 LTS 版本的 Node.js
nvm install --lts

或者直接从 Node.js 官网 下载安装包。

4. 安装 pnpm

1

npm install -g pnpm 

创建你的第一个 Tauri 应用

1. 初始化项目

使用 pnpm 创建新项目（也可以使用 npm 或 yarn）：

1

pnpm create tauri-app

按照提示操作：

• 输入项目名称（如 my-tauri-app）
• 选择包管理器（pnpm/npm/yarn）
• 选择前端框架（Vanilla/React/Vue/Svelte 等）或纯 HTML/CSS/JS

✔ Project name · tauri-app
✔ Identifier · com.tauri-app.app
✔ Choose which language to use for your frontend · TypeScript / JavaScript - (pnpm, yarn, npm, deno, bun)
✔ Choose your package manager · pnpm
✔ Choose your UI template · Vue - (https://vuejs.org/)
✔ Choose your UI flavor · TypeScript

2. 安装依赖

进入项目目录并安装依赖：

1
2

cd tauri-app
pnpm install

3. 启动开发服务器

运行开发模式：

1

pnpm tauri dev

这将启动两个进程：

1. 前端开发服务器（通常是 Vite）
2. Tauri 应用窗口

你会看到一个桌面窗口，里面渲染着你的前端应用！

项目结构简介

1
2
3
4
5
6
7
8

my-tauri-app/
├── src/                # 前端源码
├── src-tauri/          # Tauri 相关配置和 Rust 代码
│   ├── Cargo.toml      # Rust 项目配置
│   ├── tauri.conf.json # Tauri 应用配置
│   └── src/            # Rust 源码
├── index.html          # 主 HTML 文件
└── package.json        # 前端项目配置

打包应用

当你的应用准备好发布时，运行：

1

pnpm tauri build

这会在 src-tauri/target/release 目录下生成可执行文件：

• Windows: .exe 文件
• macOS: .dmg 文件
• Linux: .AppImage 或 .deb 文件

如果要修改打包选项，可以编辑 src-tauri/tauri.conf.json 后重新打包

进阶学习

• Tauri 官方文档
• Rust 编程语言
• 前端框架文档 (根据你选择的框架)

总结

通过本文，你已经学会了：

1. Tauri 的基本概念和优势
2. 如何搭建开发环境
3. 创建和运行 Tauri 应用
4. 打包应用

Tauri 为前端开发者打开了桌面应用开发的大门，结合了 Web 开发的便利性和原生应用的性能。现在就开始你的 Tauri 开发之旅吧！

技术文档整理

Gradle 配置优先级（从高到低）

Gradle 官方文档

• 基础知识
  Getting Started with Gradle
• API 文档
  • Settings 对象
  • Project 对象

Gradle 依赖缓存位置

1

~/.gradle/caches/modules-2/files-2.1/

Maven 配置

1. 配置文件路径

• 全局配置：${maven.home}/conf/settings.xml
• 用户配置：${user.home}/.m2/settings.xml

  ⚠️ 用户配置优先级更高（合并时覆盖相同配置）。

2. 仓库类型

3. 常用插件

• maven-compiler-plugin：编译 Java 文件（官方提供）。
• kotlin-maven-plugin：编译 Kotlin 文件（Kotlin 官方提供）。
• spring-boot-maven-plugin：打包 Spring Boot 为可执行 JAR。

PNPM 全局安装配置

1. 设置全局路径

1
2

pnpm config set store-dir ~/.pnpm-store
pnpm config set global-bin-dir ~/.pnpm-global

• 将 ~/.pnpm-global 添加到 PATH：

  1	export PATH="$HOME/.pnpm-global:$PATH"

  Windows: $env:PATH += ";$env:USERPROFILE\.pnpm-global"

2. 配置环境变量

• Linux/macOS（添加到 ~/.bashrc 或 ~/.zshrc）：

  1 2	export PNPM_HOME="$HOME/.pnpm-global" export PATH="$PNPM_HOME:$PATH"

• Windows：通过系统设置添加 PNPM_HOME 变量。

3. 验证配置

1
2

pnpm config list  # 检查路径是否正确
pnpm add -g your-package-name  # 重新安装全局包

Shell 配置文件加载时机