从Electron到Tauri，Rust+Vue(Tauri) 实现超高性能桌面日志应用开发，以及开发避坑指南

见证了从 Electron 到 Tauri 的技术演进。今天想和大家聊聊在 Rust + Vue 跨语言开发中遇到的真实痛点，以及我们团队在实践中摸索出的解决方案。

一、为什么选择 Rust + Vue？

在介绍痛点之前，先说说我们为什么选择这个技术栈。我们的项目是一个智能工作日志记录器（WorkLogger），需要：

• 系统级 API 调用：监控窗口切换、进程启停、剪贴板变化
• 高性能数据处理：SQLite 全文索引、实时统计
• 小体积安装包：目标 < 10MB（Electron 动辄 100MB+）
• 离线授权系统：基于机器指纹的激活码验证

最终技术选型：

前端：Vue 3.4 + TypeScript + Vite + Pinia + TailwindCSS
后端：Rust + Tauri 2.0 + SQLite + Tokio
通信：Tauri IPC（基于 Serde JSON 序列化）

二、核心痛点与解决方案

痛点 1：类型定义同步 ------ 双端维护的噩梦

问题描述 ：

Rust 和 TypeScript 需要分别定义数据结构，修改一方容易忘记同步另一方。更糟糕的是，枚举值、可选字段、日期格式等细节容易出错。

实际案例：

// Rust 端定义（src-tauri/src/monitor/mod.rs）
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogEntry {
    pub id: String,
    pub timestamp: DateTime<Local>,  // chrono 时间类型
    pub category: LogCategory,        // 枚举类型
    pub application: String,
    pub window_title: String,
    pub process_id: u32,
    pub description: String,
    pub details: String,
    pub duration_secs: Option<i64>,   // 可选字段
    pub tags: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum LogCategory {
    Development,
    DocumentEditing,
    WebBrowsing,
    Communication,
    Email,
    FileManagement,
    Design,
    Meeting,
    SystemOperation,
    Entertainment,
    Other,
}

// TypeScript 端定义（src/types/index.ts）
export interface LogEntry {
  id: string
  timestamp: string              // 序列化后变成 ISO 8601 字符串
  category: string               // 枚举变成字符串
  category_label: string         // 额外字段：中文标签
  application: string
  window_title: string
  process_id: number
  description: string
  details: string
  duration_secs: number | null   // Option<T> 变成 T | null
  tags: string[]
}

踩过的坑：

1. DateTime<Local> 序列化后是字符串，但 TypeScript 端容易误以为是 Date 对象
2. Rust 枚举序列化为 "Development" 这样的字符串，但前端需要显示中文 "开发编程"
3. Option<i64> 在 JSON 中可能为 null，TypeScript 必须用 number | null

解决方案：

方案 A：使用 ts-rs 自动生成 TypeScript 类型（推荐）

// Cargo.toml
[dependencies]
ts-rs = "7"

// Rust 代码
use ts_rs::TS;

#[derive(Debug, Clone, Serialize, Deserialize, TS)]
#[ts(export)]
pub struct LogEntry {
    #[ts(type = "string")]
    pub timestamp: String,  // 强制导出为 string 类型
    pub category: LogCategory,
    // ...
}

#[derive(Debug, Clone, Serialize, Deserialize, TS)]
#[ts(export)]
pub enum LogCategory {
    Development,
    DocumentEditing,
    // ...
}

运行 cargo test 后自动生成 bindings/LogEntry.ts：

// 自动生成的 TypeScript 类型
export interface LogEntry {
  timestamp: string
  category: LogCategory
  // ...
}

export const enum LogCategory {
  Development = "Development",
  DocumentEditing = "DocumentEditing",
  // ...
}

方案 B：建立类型同步的 CI 检查

# .github/workflows/type-check.yml
name: Type Sync Check
on: [push, pull_request]

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Generate TypeScript types
        run: cargo test  # 触发 ts-rs 生成
      - name: Compare types
        run: |
          diff -r bindings/ src/types/ || {
            echo "❌ TypeScript 类型未同步！请运行 cargo test 重新生成"
            exit 1
          }

方案 C：前端添加运行时类型校验（开发环境）

// src/utils/type-guard.ts
import type { LogEntry } from '@/types'

export function isLogEntry(obj: unknown): obj is LogEntry {
  if (typeof obj !== 'object' || obj === null) return false
  
  const entry = obj as Record<string, unknown>
  return (
    typeof entry.id === 'string' &&
    typeof entry.timestamp === 'string' &&
    typeof entry.category === 'string' &&
    typeof entry.application === 'string' &&
    // ... 其他字段校验
    true
  )
}

// 使用示例
const result = await invoke('query_logs', { params })
if (import.meta.env.DEV) {
  result.data.forEach((item, i) => {
    if (!isLogEntry(item)) {
      console.error(`❌ 第 ${i} 条数据类型不匹配:`, item)
    }
  })
}

痛点 2：跨语言调试 ------ 调用链追踪困难

问题描述 ：

前端调试用浏览器 DevTools，后端调试用 Rust 日志，无法统一追踪一次完整的跨语言调用。

实际案例：

前端调用 queryLogs() 时出错，但不知道是：

• 前端参数传递错误？
• Rust 反序列化失败？
• 数据库查询出错？
• 返回值序列化失败？

解决方案：统一请求 ID 追踪

// src/utils/api.ts
import { invoke } from '@tauri-apps/api/core'

// 生成唯一请求 ID
function generateRequestId(): string {
  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
}

// 封装 invoke，添加追踪日志
export async function tracedInvoke<T>(
  command: string,
  args: Record<string, unknown> = {}
): Promise<T> {
  const requestId = generateRequestId()
  const startTime = performance.now()
  
  console.log(`[${requestId}] 📤 调用 ${command}`, args)
  
  try {
    const result = await invoke<T>(command, {
      ...args,
      _request_id: requestId,  // 传递给后端
    })
    
    const duration = performance.now() - startTime
    console.log(`[${requestId}] ✅ 成功 (${duration.toFixed(2)}ms)`, result)
    
    return result
  } catch (error) {
    const duration = performance.now() - startTime
    console.error(`[${requestId}] ❌ 失败 (${duration.toFixed(2)}ms)`, error)
    throw error
  }
}

// 使用示例
export async function queryLogs(params: QueryParams) {
  return tracedInvoke<{ data: LogEntry[]; total: number }>('query_logs', { params })
}

// src-tauri/src/utils/tracing.rs
use log::{info, error};

pub fn log_request(request_id: &str, command: &str, stage: &str, data: &str) {
    info!("[{}] {} - {}: {}", request_id, command, stage, data);
}

// 在命令中使用
#[tauri::command]
pub fn query_logs(
    state: State<'_, AppState>,
    params: QueryParams,
    _request_id: Option<String>,  // 接收前端传来的请求 ID
) -> Result<serde_json::Value, String> {
    let request_id = _request_id.unwrap_or_else(|| "unknown".to_string());
    
    log::info!("[{}] query_logs - 开始查询: {:?}", request_id, params);
    
    let db = state.db.read();
    match db.query_logs(params) {
        Ok(result) => {
            log::info!("[{}] query_logs - 查询成功，返回 {} 条记录", 
                request_id, 
                result["data"].as_array().map(|a| a.len()).unwrap_or(0)
            );
            Ok(result)
        }
        Err(e) => {
            log::error!("[{}] query_logs - 查询失败: {}", request_id, e);
            Err(e)
        }
    }
}

效果示例：

前端控制台：
[1704067200000-a3b5c7] 📤 调用 query_logs {params: {page: 1, page_size: 50}}
[1704067200000-a3b5c7] ✅ 成功 (45.23ms) {data: Array(50), total: 1234}

Rust 日志：
[2024-01-01 10:00:00 INFO] [1704067200000-a3b5c7] query_logs - 开始查询: QueryParams { page: 1, page_size: 50 }
[2024-01-01 10:00:00 INFO] [1704067200000-a3b5c7] query_logs - 查询成功，返回 50 条记录

痛点 3：状态管理 ------ 双端状态一致性

问题描述 ：

Rust 端用 Arc<RwLock<T>> 管理全局状态，Vue 端用 Pinia，两者可能不一致。

实际案例：

用户在前端点击"暂停监控"，但 Rust 后端的监控线程仍在运行。或者 Rust 端检测到空闲状态，但前端 UI 没有更新。

解决方案：事件驱动的状态同步

// Rust 端：状态变化时主动推送事件
use tauri::Emitter;

pub struct AppState {
    pub is_monitoring: Arc<RwLock<bool>>,
    pub app_handle: tauri::AppHandle,  // 保存应用句柄
}

impl AppState {
    pub fn set_monitoring(&self, value: bool) {
        *self.is_monitoring.write() = value;
        
        // 主动推送状态变化事件
        self.app_handle.emit("monitoring-status-changed", value).ok();
    }
}

// 监控线程中检测到空闲
if idle_duration > IDLE_THRESHOLD {
    self.app_handle.emit("user-idle-detected", IdleInfo {
        duration: idle_duration,
        timestamp: Local::now(),
    }).ok();
}

// Vue 端：监听后端事件
import { listen } from '@tauri-apps/api/event'
import { defineStore } from 'pinia'

export const useAppStore = defineStore('app', () => {
  const isMonitoring = ref(false)
  const isIdle = ref(false)

  // 监听后端事件
  async function setupListeners() {
    // 监听监控状态变化
    await listen<boolean>('monitoring-status-changed', (event) => {
      isMonitoring.value = event.payload
      console.log('📡 监控状态已同步:', event.payload)
    })

    // 监听空闲检测
    await listen<IdleInfo>('user-idle-detected', (event) => {
      isIdle.value = true
      console.log('📡 检测到用户空闲:', event.payload)
      
      // 5 秒后自动恢复
      setTimeout(() => { isIdle.value = false }, 5000)
    })
  }

  // 初始化时同步状态
  async function init() {
    await setupListeners()
    isMonitoring.value = await invoke('get_monitoring_status')
  }

  return { isMonitoring, isIdle, init }
})

关键点：

1. 单向数据流：Rust 是状态的唯一真实来源（Single Source of Truth）
2. 事件驱动：状态变化时主动推送，而非前端轮询
3. 初始化同步：应用启动时从后端拉取初始状态

痛点 4：错误处理 ------ 跨语言错误传递

问题描述 ：

Rust 的 Result<T, E> 和 TypeScript 的 Promise<T> 错误处理机制不同，错误信息容易丢失。

实际案例：

// Rust 端错误
#[tauri::command]
pub fn query_logs(...) -> Result<serde_json::Value, String> {
    let db = state.db.read();
    db.query_logs(params).map_err(|e| {
        // 错误信息可能不够详细
        format!("查询失败: {}", e)
    })
}

// 前端捕获错误
try {
  const result = await invoke('query_logs', { params })
} catch (e) {
  console.error('查询失败:', e)  // 只有一个字符串，没有堆栈信息
}

解决方案：结构化错误类型

// src-tauri/src/error.rs
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiError {
    pub code: String,        // 错误代码：DB_QUERY_FAILED
    pub message: String,     // 用户友好的错误信息
    pub details: String,     // 技术细节（仅开发环境显示）
    pub stack_trace: Option<String>,  // Rust 堆栈（可选）
}

impl ApiError {
    pub fn new(code: &str, message: &str, details: &str) -> Self {
        Self {
            code: code.to_string(),
            message: message.to_string(),
            details: details.to_string(),
            stack_trace: None,
        }
    }
    
    pub fn db_error(message: &str) -> Self {
        Self::new("DB_ERROR", message, "数据库操作失败")
    }
    
    pub fn serialization_error(message: &str) -> Self {
        Self::new("SERIALIZATION_ERROR", message, "数据序列化失败")
    }
}

// 使用示例
#[tauri::command]
pub fn query_logs(...) -> Result<serde_json::Value, ApiError> {
    let db = state.db.read();
    db.query_logs(params).map_err(|e| {
        ApiError::db_error(&format!("查询日志失败: {}", e))
    })
}

// src/utils/api.ts
export interface ApiError {
  code: string
  message: string
  details: string
  stack_trace?: string
}

export async function queryLogs(params: QueryParams) {
  try {
    return await invoke<{ data: LogEntry[]; total: number }>('query_logs', { params })
  } catch (error) {
    // 解析结构化错误
    const apiError = error as ApiError
    
    // 生产环境：显示用户友好信息
    console.error(`[${apiError.code}] ${apiError.message}`)
    
    // 开发环境：显示技术细节
    if (import.meta.env.DEV) {
      console.error('技术细节:', apiError.details)
      if (apiError.stack_trace) {
        console.error('Rust 堆栈:', apiError.stack_trace)
      }
    }
    
    throw apiError
  }
}

痛点 5：构建配置 ------ 多工具链协调

问题描述 ：

需要同时配置 Vite、Tauri、TypeScript、TailwindCSS、Rust，构建流程复杂。

实际案例：

开发时运行 npm run tauri:dev，但遇到以下问题：

• Vite 热更新失效
• Rust 编译缓存导致前端未更新
• Windows 打包需要额外安装 WiX Toolset

解决方案：标准化构建脚本

// package.json
{
  "scripts": {
    "dev": "vite",
    "tauri:dev": "tauri dev",
    "build": "vite build",
    "tauri:build": "tauri build",
    
    // 开发模式：同时启动前端和后端
    "dev:full": "concurrently \"npm run dev\" \"npm run tauri:dev\"",
    
    // 生产构建：先检查类型，再构建
    "build:prod": "vue-tsc --noEmit && npm run build && npm run tauri:build",
    
    // Windows 打包：自动安装 WiX
    "package:msi": "npm run setup:wix && npm run build:prod -- --bundles msi",
    "package:nsis": "npm run setup:wix && npm run build:prod -- --bundles nsis",
    
    // WiX 安装脚本
    "setup:wix": "powershell -ExecutionPolicy Bypass -File ./scripts/setup-wix.ps1"
  }
}

# scripts/setup-wix.ps1
# 自动下载并安装 WiX Toolset（Windows 打包 MSI 必需）

$wixVersion = "3.14"
$wixUrl = "https://github.com/wixtoolset/wix3/releases/download/wix$($wixVersion)rtm/wix$($wixVersion)-binaries.zip"

if (-not (Get-Command "candle" -ErrorAction SilentlyContinue)) {
    Write-Host "正在下载 WiX Toolset $wixVersion..."
    $tempZip = "$env:TEMP\wix.zip"
    $tempDir = "$env:TEMP\wix"
    
    Invoke-WebRequest -Uri $wixUrl -OutFile $tempZip
    Expand-Archive -Path $tempZip -DestinationPath $tempDir -Force
    
    # 添加到 PATH
    $env:PATH += ";$tempDir"
    [Environment]::SetEnvironmentVariable("PATH", $env:PATH, "User")
    
    Write-Host "✅ WiX Toolset 安装完成"
} else {
    Write-Host "✅ WiX Toolset 已安装"
}

Tauri 配置优化：

// src-tauri/tauri.conf.json
{
  "build": {
    "beforeBuildCommand": "npm run build",
    "beforeDevCommand": "npm run dev",
    "devUrl": "http://localhost:1420",
    "frontendDist": "../dist"
  },
  "bundle": {
    "active": true,
    "targets": ["msi", "nsis"],
    "windows": {
      "wix": {
        "language": "zh-CN"
      },
      "nsis": {
        "languages": ["SimpChinese"],
        "displayLanguageSelector": false
      }
    }
  }
}

三、完整示例：可运行的 Demo

下面是一个最小化的 Rust + Vue 示例，展示上述所有痛点的解决方案。

3.1 项目结构

demo/
├── src/                    # Vue 前端
│   ├── App.vue
│   ├── main.ts
│   ├── types/
│   │   └── index.ts        # TypeScript 类型
│   └── utils/
│       └── api.ts          # Tauri IPC 封装
├── src-tauri/              # Rust 后端
│   ├── src/
│   │   ├── lib.rs          # 主入口
│   │   ├── commands.rs     # Tauri 命令
│   │   └── error.rs        # 错误类型
│   ├── Cargo.toml
│   └── tauri.conf.json
├── package.json
└── vite.config.ts

3.2 Rust 后端代码

// src-tauri/src/error.rs
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiError {
    pub code: String,
    pub message: String,
    pub details: String,
}

impl ApiError {
    pub fn new(code: &str, message: &str, details: &str) -> Self {
        Self {
            code: code.to_string(),
            message: message.to_string(),
            details: details.to_string(),
        }
    }
}

// src-tauri/src/commands.rs
use serde::{Serialize, Deserialize};
use ts_rs::TS;
use crate::error::ApiError;

// 使用 ts-rs 自动生成 TypeScript 类型
#[derive(Debug, Clone, Serialize, Deserialize, TS)]
#[ts(export, export_to = "../src/types/generated/")]
pub struct User {
    pub id: u32,
    pub name: String,
    pub email: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, TS)]
#[ts(export, export_to = "../src/types/generated/")]
pub struct QueryParams {
    pub page: u32,
    pub page_size: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize, TS)]
#[ts(export, export_to = "../src/types/generated/")]
pub struct QueryResult {
    pub data: Vec<User>,
    pub total: u32,
}

// Tauri 命令
#[tauri::command]
pub fn query_users(params: QueryParams) -> Result<QueryResult, ApiError> {
    // 模拟数据库查询
    let users = vec![
        User { id: 1, name: "张三".to_string(), email: "zhangsan@example.com".to_string() },
        User { id: 2, name: "李四".to_string(), email: "lisi@example.com".to_string() },
    ];
    
    Ok(QueryResult {
        data: users,
        total: 100,
    })
}

// src-tauri/src/lib.rs
mod commands;
mod error;

use tauri::Manager;

pub struct AppState {
    pub is_monitoring: std::sync::Arc<parking_lot::RwLock<bool>>,
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    let state = AppState {
        is_monitoring: std::sync::Arc::new(parking_lot::RwLock::new(false)),
    };
    
    tauri::Builder::default()
        .manage(state)
        .invoke_handler(tauri::generate_handler![
            commands::query_users,
        ])
        .run(tauri::generate_context!())
        .expect("启动失败");
}

3.3 Vue 前端代码

// src/types/index.ts
// 从 Rust 自动生成的类型（通过 ts-rs）
export * from './generated/User'
export * from './generated/QueryParams'
export * from './generated/QueryResult'

// src/utils/api.ts
import { invoke } from '@tauri-apps/api/core'
import type { QueryParams, QueryResult, ApiError } from '@/types'

// 生成请求 ID
function generateRequestId(): string {
  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
}

// 封装 invoke，添加追踪
export async function tracedInvoke<T>(
  command: string,
  args: Record<string, unknown> = {}
): Promise<T> {
  const requestId = generateRequestId()
  const startTime = performance.now()
  
  console.log(`[${requestId}] 📤 调用 ${command}`, args)
  
  try {
    const result = await invoke<T>(command, args)
    console.log(`[${requestId}] ✅ 成功 (${(performance.now() - startTime).toFixed(2)}ms)`, result)
    return result
  } catch (error) {
    const apiError = error as ApiError
    console.error(`[${requestId}] ❌ 失败`, apiError)
    throw apiError
  }
}

// 查询用户
export async function queryUsers(params: QueryParams): Promise<QueryResult> {
  return tracedInvoke<QueryResult>('query_users', { params })
}

// src/App.vue
<script setup lang="ts">
import { ref, onMounted } from 'vue'
import { queryUsers } from './utils/api'
import type { QueryParams, User } from './types'

const users = ref<User[]>([])
const total = ref(0)
const loading = ref(false)

async function loadUsers() {
  loading.value = true
  try {
    const params: QueryParams = { page: 1, page_size: 10 }
    const result = await queryUsers(params)
    users.value = result.data
    total.value = result.total
  } catch (error) {
    console.error('加载用户失败:', error)
  } finally {
    loading.value = false
  }
}

onMounted(() => {
  loadUsers()
})
</script>

<template>
  <div class="p-8">
    <h1 class="text-2xl font-bold mb-4">用户列表</h1>
    
    <div v-if="loading" class="text-gray-500">加载中...</div>
    
    <div v-else>
      <p class="mb-4">共 {{ total }} 条记录</p>
      
      <ul class="space-y-2">
        <li v-for="user in users" :key="user.id" class="p-4 bg-gray-100 rounded">
          {{ user.name }} ({{ user.email }})
        </li>
      </ul>
    </div>
  </div>
</template>

3.4 运行步骤

# 1. 安装依赖
npm install

# 2. 生成 TypeScript 类型（Rust 端）
cd src-tauri
cargo test  # 触发 ts-rs 生成类型

# 3. 启动开发服务器
cd ..
npm run tauri:dev

预期输出：

前端控制台：
[1704067200000-a3b5c7] 📤 调用 query_users {params: {page: 1, page_size: 10}}
[1704067200000-a3b5c7] ✅ 成功 (12.34ms) {data: Array(2), total: 100}

Rust 日志：
[INFO] query_users - 查询成功，返回 2 条记录

四、最佳实践总结

4.1 类型同步

方案	优点	缺点	适用场景
ts-rs 自动生成	零维护，类型永远同步	需要额外依赖	推荐，适合所有项目
手动同步 + CI 检查	无额外依赖	容易忘记同步	小型项目
运行时类型校验	开发环境即时发现错误	性能开销	辅助手段

4.2 调试追踪

推荐方案：统一请求 ID + 结构化日志

前端：console.log(`[${requestId}] 📤 调用 ${command}`, args)
后端：log::info!("[{}] {} - 开始执行", request_id, command)

效果：通过 requestId 关联前后端日志，快速定位问题

4.3 状态管理

核心原则：Rust 是状态的唯一真实来源

1. Rust 端：Arc<RwLock<T>> 管理状态
2. 状态变化时：通过 emit() 推送事件
3. Vue 端：Pinia 监听事件，同步状态
4. 初始化时：从 Rust 拉取初始状态

4.4 错误处理

// Rust 端：结构化错误
pub struct ApiError {
    pub code: String,      // 错误代码
    pub message: String,   // 用户友好信息
    pub details: String,   // 技术细节
}

// 前端：根据环境显示不同信息
if (import.meta.env.DEV) {
  console.error('技术细节:', error.details)
} else {
  console.error(error.message)
}

4.5 构建配置

开发环境：npm run tauri:dev
  - Vite 热更新
  - Rust 增量编译

生产构建：npm run build:prod
  - TypeScript 类型检查
  - Vite 构建
  - Tauri 打包

Windows 打包：npm run package:msi
  - 自动安装 WiX Toolset
  - 生成 MSI 安装包

五、性能优化建议

5.1 Rust 端优化

// 1. 使用 parking_lot 替代 std::sync
use parking_lot::RwLock;  // 比 std::sync::RwLock 快 2-5 倍

// 2. SQLite WAL 模式
PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;

// 3. 批量插入
let tx = db.transaction()?;
for item in items {
    tx.execute("INSERT INTO logs (...) VALUES (?1, ?2)", params![...])?;
}
tx.commit()?;

5.2 Vue 端优化

// 1. 虚拟滚动（大数据列表）
import { useVirtualList } from '@vueuse/core'

// 2. 防抖搜索
import { useDebounceFn } from '@vueuse/core'
const debouncedSearch = useDebounceFn(search, 300)

// 3. 懒加载组件
const LogsView = defineAsyncComponent(() => import('./components/LogsView.vue'))

六、结语

Rust + Vue 的跨语言开发确实存在不少痛点，但通过合理的架构设计和工具链支持，这些问题都可以得到有效解决。关键在于：

1. 类型同步：使用 ts-rs 自动生成，避免手动维护
2. 调试追踪：统一请求 ID，关联前后端日志
3. 状态管理：Rust 作为唯一真实来源，事件驱动同步
4. 错误处理：结构化错误类型，区分用户和技术信息
5. 构建配置：标准化脚本，自动化工具链安装

希望这篇文章能帮助正在探索 Rust + Vue 开发的朋友们少走弯路。如果有更好的解决方案，欢迎交流讨论！

---

本文原创，原创不易，如需转载，请联系作者授权。