我家自动化

这个屌丝很懒，什么也没留下！

热门标签

Tauri框架：使用Rust构建轻量级桌面应用_rust tarui 文件对话框

作者：我家自动化 | 2024-06-24 18:34:52

踩

rust tarui 文件对话框

Tauri是一款用Rust构建的开源框架，用于创建轻量级、安全且高效的桌面应用程序。它将Rust的强大功能与Web技术（如HTML、CSS和JavaScript）相结合，提供了一种现代的、跨平台的方式来开发桌面应用。Tauri的核心理念是“最小权限原则”，只在必要时调用操作系统API，以降低攻击面。

Tauri架构

Tauri架构主要由以下几个部分组成：

1. Rust后端：使用Rust编写，负责与操作系统交互、处理系统事件、安全控制和API调用。
2. Web前端：使用Web技术（HTML、CSS和JavaScript）创建用户界面，可以基于任何前端框架（如React、Vue或Svelte）。
3. Tauri API：Rust后端提供的一组API，用于与前端进行通信，实现前后端的数据交换和功能调用。
4. 包装器：一个轻量级的嵌入式Webview，用于展示前端界面并与Rust后端交互。

创建一个简单的Tauri应用

首先，确保你已经安装了Rust和Cargo。然后，使用tauri init命令创建一个新的Tauri项目：

cargo tauri init my-app
1

这会生成一个基本的项目结构，包括src-tauri（Rust后端）和src（Web前端）目录。

Rust后端（src-tauri/main.rs）

use tauri::{Manager, SubCommand};

fn main() {
  tauri::Builder::default()
    .run(tauri::generate_context!())
    .expect("error while running tauri app");
}
1
2
3
4
5
6
7

这是Tauri应用的主入口点。generate_context!宏会自动生成所需的API和事件处理器。

Web前端（`src/index.html` 和 `src/index.ts`）

index.html是你的应用界面，可以使用任何你喜欢的HTML结构。index.ts是TypeScript文件，用于处理Tauri API调用和事件监听。

<!-- src/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>My Tauri App</title>
</head>
<body>
  <h1>Hello, Tauri!</h1>
  <button id="click-me">Click me!</button>

  <script src="index.js"></script>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

// src/index.ts
import { invoke } from '@tauri-apps/api';

document.getElementById('click-me')?.addEventListener('click', async () => {
  const result = await invoke('sayHello');
  alert(`Tauri says: ${result}`);
});
1
2
3
4
5
6
7

在这个例子中，invoke函数用于调用Rust后端的sayHello方法。接下来，我们需要在Rust后端实现这个方法。

Rust后端实现API（`src-tauri/src/main.rs`）

// 引入必要的库
use tauri::{Command, Manager, Window};

// 定义say_hello命令
#[tauri::command]
fn say_hello() -> String {
  "Hello, frontend!".to_string()
}

fn main() {
  // ...其他代码

  // 注册say_hello命令
  let manager = Manager::build_app(tauri::generate_context!())
    .sub_command(Command::new("sayHello").exec(say_hello))
    .run();

  // ...其他代码
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

现在，当你点击按钮时，前端会调用Rust后端的sayHello方法，并显示返回的消息。

编译和运行

使用cargo tauri build编译项目，然后运行target/release/my-app（或在Windows上运行.exe文件）。

Tauri的高级功能和最佳实践

1. 自定义API和事件

Tauri允许你自定义API和事件，以便在Rust后端和Web前端之间进行更复杂的通信。例如，创建一个用于打开文件选择对话框的API：

// src-tauri/src/main.rs
use tauri::{Manager, Response, Window};

#[tauri::command]
async fn open_file() -> Result<String, String> {
  let file_path = tauri::api::dialog::open_file().await?;
  Ok(file_path.display().to_string())
}
1
2
3
4
5
6
7
8

在Web前端调用：

// src/index.ts
import { invoke } from '@tauri-apps/api';

document.getElementById('open-file')?.addEventListener('click', async () => {
  const filePath = await invoke('openFile');
  console.log(`Selected file: ${filePath}`);
});
1
2
3
4
5
6
7

2. 使用前端框架

Tauri与React、Vue、Svelte等前端框架无缝集成。例如，使用React创建一个组件：

// src/App.js (React)
import React, { useState } from 'react';
import { invoke } from '@tauri-apps/api';

const App = () => {
  const [filePath, setFilePath] = useState('');

  const handleOpenFile = async () => {
    const result = await invoke('openFile');
    setFilePath(result);
  };

  return (
    <div>
      <button onClick={handleOpenFile}>Open File</button>
      <p>{filePath}</p>
    </div>
  );
};

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

3. 资源管理

Tauri提供了内置的资源管理功能，可以将静态资源打包到应用中。在tauri.conf.json中配置：

{
  "build": {
    "resourcesPath": "./resources"
  }
}
1
2
3
4
5

然后在Rust后端使用tauri::api::fs::read读取资源：

// src-tauri/src/main.rs
use tauri::{Manager, Response, Window};

#[tauri::command]
fn read_resource() -> Result<String, String> {
  let content = tauri::api::fs::read("resources/myfile.txt")?;
  Ok(String::from_utf8_lossy(content.as_ref()).to_string())
}
1
2
3
4
5
6
7
8

4. 应用更新

Tauri支持自动更新功能，你可以使用tauri-update库来实现。配置tauri.conf.json：

{
  "update": {
    "enabled": true,
    "interval": "1d",
    "url": "https://myapp.com/releases"
  }
}
1
2
3
4
5
6
7

然后在Rust后端处理更新事件：

// src-tauri/src/main.rs
use tauri::{Manager, Update};

fn main() {
  let manager = Manager::build_app(tauri::generate_context!())
    .update(Update::new())
    .run();

  // ...其他代码
}
1
2
3
4
5
6
7
8
9
10

5. 系统集成

Tauri提供了丰富的系统集成API，如托盘图标、菜单、快捷键等。例如，创建一个托盘图标：

// src-tauri/src/main.rs
use tauri::{Manager, Window};

fn main() {
  let mut manager = Manager::build_app(tauri::generate_context!());

  manager.set_tray_icon("path/to/icon.png");

  manager.run();

  // ...其他代码
}
1
2
3
4
5
6
7
8
9
10
11
12

6. 安全性和沙箱

Tauri遵循最小权限原则，只在必要时调用系统API。你可以配置安全策略，限制应用的权限，例如禁用文件系统访问：

// tauri.conf.json
{
  "security": {
    "allow": {
      "fs": false
    }
  }
}
1
2
3
4
5
6
7
8

Tauri的插件系统与扩展能力

插件系统

Tauri的插件系统允许开发者扩展其核心功能，通过编写Rust库来提供额外的服务或集成外部库。插件能够以安全、高效的方式与Tauri应用交互，为应用增添更多可能性。

创建自定义插件

定义插件接口：首先，在Rust中定义你的插件接口。这通常涉及创建一个trait，定义你想要公开给前端的功能。

   // my_plugin.rs
   use tauri::plugin::{Builder, TauriPlugin};
   use tauri::Runtime;

   #[tauri::command]
   async fn custom_function<R: Runtime>(app: tauri::AppHandle<R>, arg: String) -> Result<String, String> {
       // 实现你的功能逻辑
       Ok(format!("Custom function received: {}", arg))
   }

   pub fn init<R: Runtime>() -> TauriPlugin<R> {
       Builder::new("myPlugin")
           .invoke_handler(tauri::generate_handler![custom_function])
           .build()
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在Tauri应用中使用插件：在src-tauri/src/main.rs中，通过Builder的.plugin()方法注册你的插件。

   // src-tauri/src/main.rs
   fn main() {
       tauri::Builder::default()
           .plugin(my_plugin::init())
           .run(tauri::generate_context!())
           .expect("error while running tauri application");
   }
1
2
3
4
5
6
7

前端调用插件方法：在前端代码中，通过@tauri-apps/api提供的invoke函数调用你的插件方法。

   // src/index.ts
   import { invoke } from '@tauri-apps/api';

   async function callCustomFunction() {
       const result = await invoke('myPlugin:customFunction', { arg: 'Hello from frontend!' });
       console.log(result);
   }
1
2
3
4
5
6
7

使用社区插件

Tauri社区活跃，已经有许多现成的插件可以使用，例如数据库集成、图形渲染、网络请求等。这些插件通常托管在GitHub或Crates.io上，可以通过阅读文档了解如何集成到你的项目中。

扩展与集成

数据库集成：可以使用Rust的数据库驱动（如Diesel、sqlx）编写插件，为应用提供数据库访问能力。
图形与多媒体：利用Rust的多媒体库（如image、rodio）开发图像处理、音频播放等功能。
硬件访问：通过Rust的低级别库访问硬件资源，如串口通信、GPIO控制等，适用于物联网(IoT)应用。

安全考量

虽然Tauri的设计原则强调安全性，但在开发插件时仍需注意安全实践：

最小权限原则：确保插件仅请求完成任务所必需的最低权限。
代码审计：对第三方插件进行代码审查，确保没有引入安全漏洞。
沙箱环境：利用Tauri的安全策略，限制插件对系统资源的访问。

Tauri的调试与测试

调试

Tauri提供了一些工具和方法来帮助开发者调试应用：

日志：Tauri支持输出详细的日志，可以在终端中查看。在tauri.conf.json中配置日志级别：

   {
     "logger": {
       "level": "debug"
     }
   }
1
2
3
4
5

开发者工具：在运行应用时，可以使用–dev标志启用开发者模式，这将开启Webview的开发者工具（F12）。

   cargo tauri dev --dev
1

Rust调试：使用Rust的cargo命令行工具进行源代码级别的调试，例如cargo rustc – --break和cargo run – --dev。
前端调试：在开发者模式下，可以使用Webview的开发者工具来调试前端代码，包括JavaScript、CSS和HTML。

测试

Tauri提供了单元测试和集成测试的支持：

Rust单元测试：对于Rust后端，可以编写标准的Rust单元测试。在src-tauri目录下创建tests子目录，然后在那里编写测试文件。
集成测试：Tauri提供了一个名为tauri-testing的库，用于编写集成测试。这些测试可以直接在模拟的Tauri环境中运行，无需实际构建和运行整个应用。

   // 在Cargo.toml中添加依赖
   [dependencies]
   tauri-testing = { version = "latest", features = ["mock"] }

   // 在测试文件中
   use tauri_testing::{mock, Command};

   #[test]
   fn test_say_hello() {
       let app = mock::init().unwrap();
       let result = app.invoke("sayHello").unwrap();
       assert_eq!(result, "Hello, world!");
   }
1
2
3
4
5
6
7
8
9
10
11
12
13

前端测试：对于前端代码，可以使用任何你喜欢的JavaScript测试框架（如Jest、Mocha）进行测试。

性能优化

资源压缩：在tauri.conf.json中配置build选项，启用资源压缩和合并，以减小应用大小。

   {
     "build": {
       "distDir": "../dist",
       "bundle": true,
       "minify": true,
       "target": "web",
       "resolveSymlinks": false
     }
   }
1
2
3
4
5
6
7
8
9

缓存策略：利用Tauri的cache配置来缓存资源，减少网络请求。
异步加载：使用动态导入和懒加载策略，仅在需要时加载前端代码。
性能监控：使用Chrome DevTools或其他性能分析工具监测应用性能，找出瓶颈并优化。

2024年礼包：2500G计算机入门到高级架构师开发资料超级大礼包免费送！

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】