Tauri
Tauri 是一个开源框架，用于构建轻量级、高性能的桌面应用程序，它使用 Rust 作为后端，前端则可以使用任何前端框架（如 Vue.js、React、Svelte 等）来构建用户界面。Tauri 旨在成为 Electron 的安全且资源高效的替代品，通过在系统上运行 Web 视图来提供原生应用程序的体验。
Tauri 和 Electron 的主要区别是什么Tauri 和 Electron 都是用于构建跨平台桌面应用的框架，但它们在架构和性能上有显著差异：
## 架构差异
- **Electron**：打包完整的 Chromium 浏览器和 Node.js 运行时，每个应用都包含完整的浏览器实例
- **Tauri**：使用操作系统的原生 WebView，不打包浏览器，只包含必要的运行时组件
## 性能对比
- **包体积**：Tauri 应用通常 3-10 MB，Electron 应用通常 100-200 MB
- **内存占用**：Tauri 约为 Electron 的 1/3 到 1/2
- **启动速度**：Tauri 启动更快，因为不需要加载完整的浏览器
## 开发语言
- **Electron**：JavaScript/TypeScript（前端 + Node.js 后端）
- **Tauri**：JavaScript/TypeScript（前端）+ Rust（后端）
## 安全性
- **Electron**：默认权限较大，需要手动配置安全策略
- **Tauri**：默认最小权限原则，需要显式声明所需权限
## 适用场景
- **Electron**：适合需要复杂浏览器功能、团队熟悉 JS 生态的项目
- **Tauri**：适合追求性能、安全性，或有 Rust 背景的团队
前端 · 2月19日 19:27
Tauri 在实际项目中的应用场景有哪些Tauri 在实际项目中有很多成功的应用案例，以下是一些典型场景和实现要点：
## 1. 代码编辑器
### 典型案例：VS Code 替代品
**技术要点**：
- 使用 Monaco Editor 或 CodeMirror 作为编辑器核心
- Rust 后端处理文件系统操作和 Git 集成
- 实现语法高亮、代码补全、错误检查等功能
**实现示例**：
```rust
#[tauri::command]
async fn read_file(path: String) -> Result<String, String> {
fs::read_to_string(&path).map_err(|e| e.to_string())
}
#[tauri::command]
async fn write_file(path: String, content: String) -> Result<(), String> {
fs::write(&path, content).map_err(|e| e.to_string())
}
```
## 2. 数据可视化工具
### 典型案例：数据分析仪表板
**技术要点**：
- 使用 D3.js、Chart.js 或 ECharts 进行数据可视化
- Rust 后端处理大数据计算和数据库查询
- 实现实时数据更新和交互式图表
**性能优化**：
```rust
// 使用 Rayon 进行并行数据处理
use rayon::prelude::*;
#[tauri::command]
async fn process_data(data: Vec<f64>) -> Vec<f64> {
data.par_iter()
.map(|x| x * 2.0)
.collect()
}
```
## 3. 系统监控工具
### 典型案例：资源监控器
**技术要点**：
- 使用 sysinfo crate 获取系统信息
- 实时更新 CPU、内存、磁盘使用情况
- 使用 Canvas 或 SVG 绘制监控图表
**实现示例**：
```rust
use sysinfo::{System, SystemExt, ProcessorExt};
#[tauri::command]
async fn get_system_info() -> Result<SystemInfo, String> {
let mut sys = System::new_all();
sys.refresh_all();
Ok(SystemInfo {
cpu_usage: sys.global_processor_info().cpu_usage(),
total_memory: sys.total_memory(),
used_memory: sys.used_memory(),
})
}
```
## 4. 多媒体应用
### 典型案例：音乐播放器
**技术要点**：
- 使用 Web Audio API 处理音频
- Rust 后端管理媒体库和元数据
- 实现播放列表、均衡器等功能
**文件管理**：
```rust
#[tauri::command]
async fn scan_music_library(path: String) -> Result<Vec<Track>, String> {
let entries = fs::read_dir(&path)
.map_err(|e| e.to_string())?;
let mut tracks = Vec::new();
for entry in entries {
if let Ok(entry) = entry {
// 解析音频文件元数据
let track = parse_audio_metadata(entry.path())?;
tracks.push(track);
}
}
Ok(tracks)
}
```
## 5. 企业级应用
### 典型案例：CRM 系统
**技术要点**：
- 使用 React/Vue 构建复杂 UI
- Rust 后端处理业务逻辑和数据验证
- 集成数据库（SQLite、PostgreSQL）
**数据库集成**：
```rust
use sqlx::SqlitePool;
#[tauri::command]
async fn query_customers(pool: tauri::State<'_, SqlitePool>) -> Result<Vec<Customer>, String> {
sqlx::query_as::<_, Customer>("SELECT * FROM customers")
.fetch_all(pool.inner())
.await
.map_err(|e| e.to_string())
}
```
## 6. 开发工具
### 典型案例：API 测试工具
**技术要点**：
- 使用 reqwest crate 发送 HTTP 请求
- 实现请求历史和收藏功能
- 支持 WebSocket 和 GraphQL
**HTTP 请求**：
```rust
use reqwest::Client;
#[tauri::command]
async fn send_request(url: String, method: String, body: Option<String>) -> Result<Response, String> {
let client = Client::new();
let request = match method.as_str() {
"GET" => client.get(&url),
"POST" => client.post(&url).body(body.unwrap_or_default()),
_ => return Err("Unsupported method".to_string()),
};
let response = request.send().await.map_err(|e| e.to_string())?;
let status = response.status();
let text = response.text().await.map_err(|e| e.to_string())?;
Ok(Response { status: status.as_u16(), body: text })
}
```
## 7. 游戏相关应用
### 典型案例：游戏启动器
**技术要点**：
- 管理游戏安装和更新
- 实现云同步和成就系统
- 集成社交功能
**下载管理**：
```rust
#[tauri::command]
async fn download_game(url: String, progress: tauri::Window) -> Result<String, String> {
let response = reqwest::get(&url).await.map_err(|e| e.to_string())?;
let total_size = response.content_length().unwrap_or(0);
let mut downloaded = 0;
let mut stream = response.bytes_stream();
while let Some(chunk) = stream.next().await {
let chunk = chunk.map_err(|e| e.to_string())?;
downloaded += chunk.len() as u64;
let percent = (downloaded as f64 / total_size as f64) * 100.0;
progress.emit("download-progress", percent)?;
}
Ok("Download completed".to_string())
}
```
## 最佳实践总结
1. **性能优化**：合理使用 Rust 的并发特性
2. **用户体验**：实现流畅的动画和响应式设计
3. **错误处理**：提供清晰的错误信息和恢复机制
4. **安全性**：遵循最小权限原则，验证用户输入
5. **可维护性**：模块化设计，编写清晰的文档
6. **测试覆盖**：编写单元测试和集成测试
7. **持续集成**：使用 CI/CD 自动化构建和部署
这些案例展示了 Tauri 在不同领域的应用潜力，结合了 Web 技术的灵活性和 Rust 的性能优势。
前端 · 2月19日 19:27
Tauri 提供哪些常用的系统 APITauri 提供了丰富的 API 来访问系统功能，主要包括以下模块：
## 文件系统 API
```typescript
import { readTextFile, writeTextFile, exists } from '@tauri-apps/api/fs';
// 读取文件
const content = await readTextFile('path/to/file.txt');
// 写入文件
await writeTextFile('path/to/file.txt', 'Hello World');
// 检查文件是否存在
const fileExists = await exists('path/to/file.txt');
```
## Shell API
```typescript
import { open } from '@tauri-apps/api/shell';
// 打开外部链接
await open('https://example.com');
// 执行命令
const { stdout } = await Command.create('ls', ['-l']).execute();
```
## 对话框 API
```typescript
import { open, save } from '@tauri-apps/api/dialog';
// 打开文件选择器
const selected = await open({
multiple: true,
filters: [{
name: 'Images',
extensions: ['png', 'jpg', 'jpeg']
}]
});
// 保存文件对话框
const filePath = await save({
defaultPath: 'document.txt',
filters: [{
name: 'Text',
extensions: ['txt']
}]
});
```
## 窗口 API
```typescript
import { appWindow } from '@tauri-apps/api/window';
// 获取窗口信息
const label = appWindow.label;
const scaleFactor = await appWindow.scaleFactor();
// 窗口控制
await appWindow.minimize();
await appWindow.maximize();
await appWindow.close();
// 监听窗口事件
const unlisten = await appWindow.onResized(({ payload }) => {
console.log('Window resized:', payload);
});
```
## 通知 API
```typescript
import { sendNotification } from '@tauri-apps/api/notification';
sendNotification({
title: 'Notification',
body: 'This is a notification'
});
```
## 剪贴板 API
```typescript
import { readText, writeText } from '@tauri-apps/api/clipboard';
// 读取剪贴板
const text = await readText();
// 写入剪贴板
await writeText('Hello World');
```
## 全局快捷键 API
```typescript
import { register, unregisterAll } from '@tauri-apps/api/globalShortcut';
// 注册快捷键
await register('CommandOrControl+Shift+1', () => {
console.log('Shortcut pressed');
});
// 注销所有快捷键
await unregisterAll();
```
## 权限配置
在 `tauri.conf.json` 中声明所需权限：
```json
{
"tauri": {
"allowlist": {
"fs": { "all": true },
"shell": { "all": true },
"dialog": { "all": true },
"window": { "all": true },
"notification": { "all": true },
"clipboard": { "all": true },
"globalShortcut": { "all": true }
}
}
}
```
前端 · 2月19日 19:25
什么是 Tauri 框架及其核心架构Tauri 是一个使用 Rust 后端和 Web 前端技术构建桌面应用程序的框架。它通过系统原生 WebView 来渲染前端界面，而不是像 Electron 那样打包完整的 Chromium 浏览器。
核心架构包括：
- **前端层**：可以使用任何 Web 框架（React、Vue、Svelte 等）
- **核心层**：Rust 编写的后端逻辑，提供系统 API 访问
- **WebView 层**：使用操作系统的原生 WebView（macOS 的 WKWebView、Windows 的 WebView2、Linux 的 WebKitGTK）
主要优势：
1. 更小的安装包体积（通常比 Electron 小 80-90%）
2. 更低的内存占用
3. 更好的性能表现
4. 更强的安全性（默认最小权限原则）
5. 更灵活的构建配置
Tauri 使用 IPC（进程间通信）机制让前端与 Rust 后端进行通信，通过 `invoke` 和 `emit` 方法实现双向数据传输。
前端 · 2月19日 19:24
Tauri 如何实现前端与 Rust 后端的 IPC 通信Tauri 的 IPC（进程间通信）机制是前端与 Rust 后端通信的核心，主要通过以下方式实现：
## 前端调用 Rust 后端
使用 `@tauri-apps/api/tauri` 的 `invoke` 方法：
```typescript
import { invoke } from '@tauri-apps/api/tauri';
// 调用 Rust 命令
const result = await invoke('greet', { name: 'World' });
```
## Rust 端定义命令
在 `src-tauri/src/main.rs` 中使用 `#[tauri::command]` 宏：
```rust
#[tauri::command]
fn greet(name: &str) -> String {
format!("Hello, {}!", name)
}
fn main() {
tauri::Builder::default()
.invoke_handler(tauri::generate_handler![greet])
.run(tauri::generate_context!())
.expect("error while running tauri application");
}
```
## Rust 后端主动推送消息到前端
使用 `emit` 方法：
```rust
// Rust 端
window.emit("event-name", payload)?;
// 前端监听
import { listen } from '@tauri-apps/api/event';
const unlisten = await listen('event-name', (event) => {
console.log(event.payload);
});
```
## 数据序列化
- 自动使用 JSON 进行序列化和反序列化
- 支持复杂的数据类型（对象、数组等）
- Rust 端需要实现 `Serialize` 和 `Deserialize` trait
## 错误处理
- Rust 端返回 `Result` 类型会自动转换为 Promise
- 前端可以使用 try-catch 捕获错误
服务端 · 2月19日 19:24
Tauri 应用的构建和打包流程是什么Tauri 应用的构建和打包流程涉及多个步骤，以下是详细说明：
## 1. 开发环境准备
### 安装依赖
```bash
# 安装 Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# 安装 Node.js 和包管理器
# 安装系统依赖（macOS）
xcode-select --install
# 安装系统依赖（Linux）
sudo apt update
sudo apt install libwebkit2gtk-4.0-dev \
build-essential \
curl \
wget \
file \
libssl-dev \
libayatana-appindicator3-dev \
librsvg2-dev
```
### 安装 Tauri CLI
```bash
cargo install tauri-cli
```
## 2. 项目配置
### tauri.conf.json 配置
```json
{
"build": {
"beforeDevCommand": "npm run dev",
"beforeBuildCommand": "npm run build",
"devPath": "http://localhost:1420",
"distDir": "../dist",
"withGlobalTauri": false
},
"package": {
"productName": "MyApp",
"version": "1.0.0"
},
"tauri": {
"bundle": {
"identifier": "com.example.myapp",
"icon": ["icons/32x32.png", "icons/128x128.png", "icons/128x128@2x.png", "icons/icon.icns", "icons/icon.ico"],
"targets": ["dmg", "msi", "appimage"],
"category": "Developer Tool"
}
}
}
```
## 3. 开发模式
```bash
npm run tauri dev
```
这个命令会：
1. 运行 `beforeDevCommand` 启动开发服务器
2. 编译 Rust 代码
3. 启动应用并连接到开发服务器
4. 支持热重载
## 4. 构建生产版本
### 基础构建
```bash
npm run tauri build
```
构建流程：
1. 运行 `beforeBuildCommand` 构建前端资源
2. 编译 Rust 代码为二进制文件
3. 打包前端资源到应用中
4. 生成平台特定的安装包
### 构建特定平台
```bash
# macOS
npm run tauri build -- --target universal-apple-darwin
# Windows
npm run tauri build -- --target x86_64-pc-windows-msvc
# Linux
npm run tauri build -- --target x86_64-unknown-linux-gnu
```
## 5. 打包选项
### macOS 打包
```json
{
"bundle": {
"targets": ["dmg", "app"],
"macOS": {
"signingIdentity": "Developer ID Application: Your Name",
"entitlements": "entitlements.plist",
"hardenedRuntime": true,
"minimumSystemVersion": "10.13"
}
}
}
```
### Windows 打包
```json
{
"bundle": {
"targets": ["msi", "nsis"],
"windows": {
"certificateThumbprint": "YOUR_CERTIFICATE_THUMBPRINT",
"digestAlgorithm": "sha256",
"timestampUrl": "http://timestamp.digicert.com"
}
}
}
```
### Linux 打包
```json
{
"bundle": {
"targets": ["appimage", "deb"],
"linux": {
"deb": {
"depends": ["libwebkit2gtk-4.0-37"]
}
}
}
}
```
## 6. 代码签名
### macOS 签名
```bash
# 导入证书
security import certificate.p12 -k ~/Library/Keychains/login.keychain
# 自动签名（在配置中设置）
```
### Windows 签名
```bash
# 使用 signtool
signtool sign /f certificate.pfx /p password /t http://timestamp.digicert.com app.exe
```
## 7. 发布流程
### GitHub Actions 自动化
```yaml
name: Release
on:
push:
tags:
- 'v*'
jobs:
release:
strategy:
matrix:
os: [macos-latest, ubuntu-latest, windows-latest]
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
- uses: dtolnay/rust-toolchain@stable
- run: npm install
- run: npm run tauri build
- uses: softprops/action-gh-release@v1
with:
files: src-tauri/target/release/bundle/*
```
## 8. 构建优化
### 减小包体积
```toml
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
strip = true
```
### 并行构建
```bash
cargo build --release -j $(nproc)
```
## 9. 常见问题
### 构建失败
- 检查系统依赖是否完整
- 确认 Rust 和 Node.js 版本兼容
- 查看详细错误日志
### 签名问题
- 确保证书有效
- 检查签名配置
- 验证时间戳服务器可用性
### 跨平台构建
- 使用 GitHub Actions 或 CI/CD
- 配置不同的构建目标
- 测试各平台兼容性
服务端 · 2月19日 19:24
Tauri 插件系统如何工作Tauri 插件系统允许扩展框架功能，创建可复用的模块：
## 插件架构
Tauri 插件由两部分组成：
- **前端部分**：JavaScript/TypeScript API
- **后端部分**：Rust 扩展
## 创建插件
### 1. 初始化插件项目
```bash
cargo create-tauri-plugin --name my-plugin
```
### 2. Rust 端实现
`src-tauri/plugins/my-plugin/src/lib.rs`:
```rust
use tauri::{plugin::Plugin, Runtime};
#[tauri::command]
async fn my_command(name: String) -> Result<String, String> {
Ok(format!("Hello, {}!", name))
}
pub struct MyPlugin<R: Runtime> {
phantom: std::marker::PhantomData<R>,
}
impl<R: Runtime> Plugin<R> for MyPlugin<R> {
fn name(&self) -> &'static str {
"my_plugin"
}
fn initialize(&mut self, app: &tauri::AppHandle<R>, config: serde_json::Value) -> Result<(), Box<dyn std::error::Error>> {
// 初始化逻辑
Ok(())
}
}
pub fn init<R: Runtime>() -> MyPlugin<R> {
MyPlugin {
phantom: std::marker::PhantomData,
}
}
```
### 3. 注册命令
```rust
impl<R: Runtime> MyPlugin<R> {
pub fn commands() -> Vec<Box<dyn tauri::command::CommandItem<R>>> {
vec![
tauri::command::CommandItem::new(my_command)
]
}
}
```
### 4. 前端 API
`src-tauri/plugins/my-plugin/src-js/index.ts`:
```typescript
import { invoke } from '@tauri-apps/api/tauri';
export async function myCommand(name: string): Promise<string> {
return invoke('plugin:my_plugin|my_command', { name });
}
```
### 5. 使用插件
在 `tauri.conf.json` 中配置：
```json
{
"plugins": {
"my_plugin": {
"enabled": true,
"config": {}
}
}
}
```
## 常用官方插件
### tauri-plugin-clipboard
```typescript
import { writeText, readText } from 'tauri-plugin-clipboard-api';
await writeText('Hello');
const text = await readText();
```
### tauri-plugin-fs-extra
```typescript
import { copyFile, moveFile } from 'tauri-plugin-fs-extra-api';
await copyFile('src.txt', 'dest.txt');
```
### tauri-plugin-store
```typescript
import Store from 'tauri-plugin-store-api';
const store = new Store('.settings.dat');
await store.set('key', 'value');
const value = await store.get('key');
```
### tauri-plugin-sql
```typescript
import Database from 'tauri-plugin-sql-api';
const db = await Database.load('sqlite:test.db');
const result = await db.select('SELECT * FROM users');
```
## 插件最佳实践
1. **错误处理**：使用 `Result` 类型处理错误
2. **异步操作**：使用 `async/await` 处理耗时操作
3. **类型安全**：使用 TypeScript 确保类型安全
4. **文档完善**：提供清晰的 API 文档和使用示例
5. **测试覆盖**：编写单元测试和集成测试
## 插件发布
```bash
# 发布到 crates.io
cd src-tauri/plugins/my-plugin
cargo publish
# 发布到 npm
cd src-tauri/plugins/my-plugin/src-js
npm publish
```
## 社区插件
Tauri 社区提供了丰富的插件，可以在 [awesome-tauri](https://github.com/tauri-apps/awesome-tauri) 中找到。
服务端 · 2月19日 19:16
如何优化 Tauri 应用的性能优化 Tauri 应用性能可以从多个方面入手：
## 1. 减少包体积
### 前端优化
- 使用 Tree Shaking 移除未使用的代码
- 压缩和混淆 JavaScript 代码
- 优化图片资源（使用 WebP 格式、压缩）
- 按需加载第三方库
### Rust 优化
```toml
# Cargo.toml
[profile.release]
opt-level = "z" # 优化大小
lto = true # 链接时优化
codegen-units = 1 # 减少代码生成单元
strip = true # 移除符号表
```
## 2. 优化启动速度
### 延迟加载
```typescript
// 延迟加载大型模块
const heavyModule = await import('./heavy-module');
```
### 减少初始渲染
- 使用虚拟列表处理长列表
- 懒加载组件和路由
- 预渲染关键内容
## 3. IPC 通信优化
### 批量处理请求
```rust
// Rust 端
#[tauri::command]
async fn batch_process(items: Vec<String>) -> Vec<Result> {
// 批量处理而不是单个处理
}
```
### 使用二进制数据
```typescript
// 对于大量数据，使用 Uint8Array 而非 JSON
const data = new Uint8Array(await invoke('get_binary_data'));
```
### 减少通信频率
- 使用防抖和节流
- 本地缓存常用数据
- 使用事件推送替代轮询
## 4. WebView 优化
### 禁用不必要的功能
```json
{
"tauri": {
"webview": {
"transparent": false,
"dragDropEnabled": false
}
}
}
```
### 优化 CSS 和 JavaScript
- 使用 CSS containment
- 减少 DOM 操作
- 使用 Web Workers 处理计算密集型任务
## 5. 内存管理
### 前端内存优化
```typescript
// 及时清理监听器
const unlisten = await listen('event', handler);
// 使用后取消监听
unlisten();
```
### Rust 内存优化
```rust
// 使用 Arc 共享数据
use std::sync::Arc;
let shared_data = Arc::new(data);
// 避免不必要的克隆
```
## 6. 构建优化
```bash
# 使用并行构建
cargo build --release -j $(nproc)
# 使用增量编译
export CARGO_INCREMENTAL=1
```
## 7. 监控和分析
### 使用性能分析工具
```typescript
import { invoke } from '@tauri-apps/api/tauri';
// 监控 IPC 调用时间
const start = performance.now();
await invoke('command');
console.log(`IPC took ${performance.now() - start}ms`);
```
### Rust 性能分析
```bash
# 使用 flamegraph
cargo install flamegraph
cargo flamegraph
```
## 最佳实践
1. 定期使用 Chrome DevTools 分析性能
2. 监控内存使用情况，避免内存泄漏
3. 使用 Web Workers 处理 CPU 密集型任务
4. 合理使用缓存策略
5. 保持依赖项更新到最新稳定版本
服务端 · 2月19日 19:12
如何在 Tauri 中集成 React 或其他前端框架在 Tauri 应用中集成前端框架（React、Vue、Svelte 等）需要以下步骤：
## 1. 创建 Tauri 项目
```bash
npm create tauri-app@latest
# 或
cargo tauri init
```
## 2. 安装前端框架
以 React 为例：
```bash
npm install react react-dom
npm install --save-dev @vitejs/plugin-react
```
## 3. 配置构建工具
修改 `vite.config.ts`：
```typescript
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
clearScreen: false,
server: {
port: 1420,
strictPort: true,
watch: {
ignored: ["**/src-tauri/**"],
},
},
});
```
## 4. 配置 Tauri 前端入口
修改 `src-tauri/tauri.conf.json`：
```json
{
"build": {
"beforeDevCommand": "npm run dev",
"beforeBuildCommand": "npm run build",
"devPath": "http://localhost:1420",
"distDir": "../dist"
}
}
```
## 5. 创建前端应用
`src/main.tsx`:
```typescript
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
ReactDOM.createRoot(document.getElementById('root')!).render(
<React.StrictMode>
<App />
</React.StrictMode>
);
```
## 6. 使用 Tauri API
```typescript
import { invoke } from '@tauri-apps/api/tauri';
import { open } from '@tauri-apps/api/dialog';
const App = () => {
const handleClick = async () => {
const selected = await open();
console.log(selected);
};
return <button onClick={handleClick}>Open File</button>;
};
```
## 7. 开发和构建
```bash
# 开发模式
npm run tauri dev
# 构建生产版本
npm run tauri build
```
## 不同框架的注意事项
- **React**：确保正确配置 JSX 转换
- **Vue**：配置 Vue 插件和模板编译器
- **Svelte**：使用 Svelte 插件处理 `.svelte` 文件
- **Next.js**：需要禁用服务端渲染，配置静态导出
服务端 · 2月19日 17:51
Tauri 的安全机制和权限系统如何工作Tauri 的安全机制是其核心优势之一，通过多层防护确保应用安全：
## 权限系统
Tauri 采用**最小权限原则**，默认情况下前端无法访问系统资源。需要在 `tauri.conf.json` 中显式声明权限：
```json
{
"tauri": {
"allowlist": {
"fs": {
"all": false,
"readFile": true,
"writeFile": true,
"scope": ["$HOME/*"]
},
"shell": {
"all": false,
"open": true
}
}
}
}
```
## 内容安全策略（CSP）
通过 CSP 限制资源加载和脚本执行：
```rust
tauri::Builder::default()
.plugin(tauri_plugin_csp::Builder::new()
.default_policy(ContentSecurityPolicy {
default_src: vec!["'self'"],
script_src: vec!["'self'"],
style_src: vec!["'self'"],
..Default::default()
})
.build())
```
## 作用域限制
为文件系统、Shell 等操作设置作用域，防止访问敏感路径：
```json
{
"fs": {
"scope": ["$HOME/documents/*", "$APPDATA/*"]
}
}
```
## 协议白名单
限制 WebView 可以访问的协议和域名：
```json
{
"tauri": {
"security": {
"csp": "default-src 'self'",
"dangerousDisableAssetCspModification": false
}
}
}
```
## Rust 后端隔离
- Rust 代码在独立进程中运行
- 前端无法直接执行 Rust 代码
- 所有系统调用都通过 Tauri 的 API 进行
## 最佳实践
1. 只授予必要的最小权限
2. 使用 CSP 限制资源加载
3. 验证和清理所有用户输入
4. 定期更新依赖项
5. 审计第三方插件的安全性
服务端 · 2月19日 13:26