2025最新版：用Rust构建类型安全API的终极指南 —— rspc全栈开发实战

2025最新版：用Rust构建类型安全API的终极指南 —— rspc全栈开发实战

【免费下载链接】rspc A blazingly fast and easy to use tRPC-like server for Rust. 项目地址: https://gitcode.com/gh_mirrors/rs/rspc

你是否厌倦了前后端接口对接时的类型不匹配问题？还在为手动编写API文档和类型定义而浪费时间？本文将带你深入探索rspc——这个专为Rust设计的类型安全API框架，让你彻底告别接口调试的痛苦，以惊人的效率构建全栈应用。

读完本文，你将能够：

• 理解rspc的核心优势及与传统API开发方式的对比
• 从零开始搭建一个完整的rspc服务端和客户端应用
• 掌握中间件、数据流和错误处理等高级特性
• 学会在实际项目中集成rspc，提升开发效率和代码质量

为什么选择rspc？—— 重新定义Rust API开发体验

rspc（Rust RPC）是一个受tRPC启发的高性能、类型安全的API框架，专为Rust生态系统设计。它通过在编译时强制执行类型安全，彻底消除了前后端接口不匹配的问题，同时大幅减少了样板代码和文档维护成本。

rspc vs 传统API开发：革命性的改进

特性	传统REST API	GraphQL	rspc
类型安全	❌ 运行时检查	❌ 部分类型安全	✅ 编译时完全类型安全
前后端类型同步	❌ 手动维护	❌ 需生成代码	✅ 自动生成并同步
网络请求优化	❌ 过度获取/获取不足	✅ 按需获取	✅ 按需获取+批量请求
代码量	多（定义+文档+验证）	中（Schema+解析器）	少（仅需实现业务逻辑）
学习曲线	低	高	中
Rust集成度	低	中	高

rspc核心优势解析

1. 零成本类型安全：通过Rust的类型系统和 procedural macro，在编译时确保API接口的一致性，无需运行时检查

2. 自动类型生成：为前端自动生成TypeScript类型定义，保持前后端类型同步，消除手动编写接口文档的负担

3. 极简API定义：使用直观的链式API定义路由和处理函数，大幅减少样板代码

4. 灵活的传输方式：支持HTTP、WebSocket等多种传输协议，满足不同场景需求

5. 丰富的生态集成：与Axum、Tauri、Next.js等主流框架无缝集成，适应各种应用场景

快速入门：15分钟上手rspc

让我们通过一个简单的示例，快速了解rspc的使用方法。我们将构建一个包含查询、变更和订阅功能的API服务，并创建对应的前端客户端。

环境准备

首先，确保你的开发环境中安装了以下工具：

• Rust 1.70+（推荐使用rustup安装）
• Node.js 18+（用于前端示例）
• Git

克隆rspc项目仓库：

git clone https://gitcode.com/gh_mirrors/rs/rspc
cd rspc

构建第一个rspc服务：Axum集成示例

我们以Axum（一个流行的Rust Web框架）为例，展示如何创建和使用rspc服务。

1. 创建项目结构

cargo new rspc-demo --bin
cd rspc-demo
cargo add rspc axum tokio serde -F serde/derive

2. 实现服务端代码

创建src/main.rs文件，添加以下代码：

use axum::{routing::get, Router};
use rspc::{Router as RspcRouter, Typescript};
use serde::Serialize;
use std::net::SocketAddr;

// 定义上下文类型，将在所有处理函数中可用
#[derive(Debug, Clone)]
struct Context {
    // 实际项目中可以包含数据库连接、认证信息等
    app_name: String,
}

// 定义API返回的数据类型
#[derive(Serialize)]
struct User {
    id: u64,
    name: String,
    email: String,
}

#[tokio::main]
async fn main() {
    // 创建rspc路由
    let router = RspcRouter::new()
        // 提供上下文
        .with_context(Context {
            app_name: "rspc-demo".to_string(),
        })
        // 定义查询过程
        .query("getUser", |t| {
            t(|ctx, user_id: u64| async move {
                // 实际项目中这里会查询数据库
                Ok(User {
                    id: user_id,
                    name: format!("User {}", user_id),
                    email: format!("user{}@example.com", user_id),
                })
            })
        })
        // 定义变更过程
        .mutation("createUser", |t| {
            t(|ctx, name: String| async move {
                // 实际项目中这里会插入数据库并返回新用户ID
                Ok(User {
                    id: 42, // 示例ID
                    name,
                    email: format!("{}@example.com", name.to_lowercase()),
                })
            })
        })
        // 定义订阅过程
        .subscription("userUpdates", |t| {
            t(|ctx, user_id: u64| async move {
                // 创建一个简单的更新流
                let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(5));
                Ok(ProcedureStream::new(move |mut tx| async move {
                    loop {
                        interval.tick().await;
                        // 模拟用户数据更新
                        let update = format!("User {} updated at {:?}", user_id, tokio::time::Instant::now());
                        if tx.send(Ok(update)).await.is_err() {
                            break;
                        }
                    }
                }))
            })
        });

    // 构建路由并生成TypeScript类型
    let (router, types) = router.build().unwrap();
    
    // 导出TypeScript类型定义
    Typescript::default()
        .header("// Generated by rspc")
        .export_to("./bindings.ts", &types)
        .unwrap();

    // 创建Axum应用
    let app = Router::new()
        .route("/", get(|| async { "Hello, rspc!" }))
        // 挂载rspc端点
        .nest("/rspc", rspc_axum::endpoint(router, |_req| {
            // 这里可以从请求中提取上下文，如认证信息
            Context {
                app_name: "rspc-demo".to_string(),
            }
        }));

    // 启动服务器
    let addr = SocketAddr::from(([127, 0, 0, 1], 4000));
    println!("服务器运行在 http://{}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

前端客户端：React与TypeScript集成

接下来，我们创建一个React客户端来使用刚刚构建的API。首先，确保已经生成了TypeScript类型定义文件bindings.ts。

安装必要的依赖：

npm init -y
npm install @rspc/client @rspc/react-query react react-dom @tanstack/react-query

创建客户端代码src/client.ts：

import { createClient, FetchTransport, WebsocketTransport } from "@rspc/client";
import { createReactQueryHooks } from "@rspc/react-query";
import { QueryClient } from "@tanstack/react-query";
import type { Procedures } from "../bindings";

// 创建rspc客户端
export const client = createClient<Procedures>({
  transport: 
    typeof window === "undefined" 
      ? // 服务端渲染时使用HTTP传输
        new FetchTransport("http://localhost:4000/rspc")
      : // 客户端使用WebSocket传输（支持订阅）
        new WebsocketTransport("ws://localhost:4000/rspc/ws"),
});

// 创建React Query客户端
export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      refetchOnWindowFocus: false,
    },
  },
});

// 创建rspc React hooks
export const {
  useContext,
  useMutation,
  useQuery,
  useSubscription,
  Provider: RSPCProvider,
} = createReactQueryHooks<Procedures>();

现在，我们可以在React组件中使用这些hooks来调用API：

import React from 'react';
import { RSPCProvider, useQuery, useMutation, useSubscription } from './client';
import { QueryClientProvider } from '@tanstack/react-query';
import { queryClient, client } from './client';

function UserProfile() {
  // 使用查询获取用户数据
  const { data: user, isLoading, error } = useQuery(['getUser'], {
    input: 1, // 用户ID
  });

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h2>User Profile</h2>
      <p>ID: {user?.id}</p>
      <p>Name: {user?.name}</p>
      <p>Email: {user?.email}</p>
    </div>
  );
}

function CreateUser() {
  // 使用变更创建新用户
  const { mutate, isLoading, data } = useMutation('createUser');

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    const name = (e.target as HTMLFormElement).name.value;
    mutate(name);
  };

  return (
    <div>
      <h2>Create User</h2>
      <form onSubmit={handleSubmit}>
        <input type="text" name="name" placeholder="Enter username" required />
        <button type="submit" disabled={isLoading}>
          {isLoading ? 'Creating...' : 'Create User'}
        </button>
      </form>
      {data && (
        <div>
          <h3>Created User:</h3>
          <p>ID: {data.id}</p>
          <p>Name: {data.name}</p>
          <p>Email: {data.email}</p>
        </div>
      )}
    </div>
  );
}

function UserUpdates() {
  // 使用订阅接收实时更新
  const { data: update, isLoading } = useSubscription('userUpdates', {
    input: 1, // 用户ID
  });

  return (
    <div>
      <h2>User Updates</h2>
      {isLoading ? (
        <div>Subscribing...</div>
      ) : (
        <div>Last update: {update}</div>
      )}
    </div>
  );
}

function App() {
  return (
    <div className="App">
      <h1>rspc Demo App</h1>
      <UserProfile />
      <CreateUser />
      <UserUpdates />
    </div>
  );
}

// 应用入口
function Root() {
  return (
    <QueryClientProvider client={queryClient}>
      <RSPCProvider client={client}>
        <App />
      </RSPCProvider>
    </QueryClientProvider>
  );
}

export default Root;

深入rspc架构：核心概念与工作原理

要充分利用rspc的强大功能，我们需要深入了解其核心架构和工作原理。rspc的设计遵循了几个关键原则：类型安全、零开销抽象、模块化和可扩展性。

rspc核心组件解析

1. Router（路由）：rspc的核心组件，用于定义API端点（查询、变更和订阅）。支持链式调用和路由合并，便于模块化组织代码。

2. Procedure（过程）：路由中的单个API端点，分为查询（Query）、变更（Mutation）和订阅（Subscription）三种类型，分别对应不同的使用场景。

3. Context（上下文）：每个请求的上下文对象，包含请求相关的元数据（如认证信息、数据库连接等），可通过中间件进行修改和扩展。

4. Transport（传输）：负责客户端与服务器之间的通信，支持HTTP、WebSocket等多种协议，抽象了底层通信细节。

5. Type Generation（类型生成）：自动生成客户端类型定义的机制，确保前后端类型同步，是实现类型安全的关键。

rspc请求生命周期

1. 请求发送：客户端通过传输层发送请求，包含过程名称和输入数据

2. 中间件处理：请求经过一系列中间件，中间件可以修改上下文、记录日志、进行认证等

3. 上下文创建：中间件创建或修改上下文对象，传递给过程处理函数

4. 业务逻辑执行：过程处理函数使用上下文和输入数据执行业务逻辑

5. 结果返回：处理结果经过中间件返回给客户端，完成一次请求-响应周期

高级特性实战：构建企业级应用

rspc提供了丰富的高级特性，帮助你构建健壮、可扩展的企业级应用。本节将深入探讨这些特性及其在实际项目中的应用。

中间件系统：横切关注点的优雅处理

中间件是rspc的强大功能之一，用于处理跨多个API端点的横切关注点，如认证、日志记录、错误处理等。

// 定义一个日志中间件
fn logging_middleware<TCtx, TMeta>(
) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(|ctx, next| async move {
        let start = std::time::Instant::now();
        let procedure_name = next.procedure_name().to_string();
        
        // 记录请求开始
        println!("[LOG] Starting procedure: {}", procedure_name);
        
        // 调用下一个中间件或过程处理函数
        let result = next.run(ctx).await;
        
        // 记录请求结束和耗时
        println!(
            "[LOG] Completed procedure: {} in {:?}",
            procedure_name,
            start.elapsed()
        );
        
        result
    })
}

// 定义一个认证中间件
fn auth_middleware<TCtx, TMeta>(
) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(|ctx, next| async move {
        let procedure_name = next.procedure_name();
        
        // 公开路由无需认证
        if procedure_name.starts_with("public.") {
            return next.run(ctx).await;
        }
        
        // 检查认证信息（实际实现中应从上下文中获取token并验证）
        if !is_authenticated(&ctx) {
            return Err(ProcedureError::new(
                "UNAUTHORIZED",
                "需要认证才能访问此接口",
            ));
        }
        
        next.run(ctx).await
    })
}

// 使用中间件
let router = RspcRouter::new()
    .middleware(logging_middleware())
    .middleware(auth_middleware())
    .query("public.healthcheck", |t| t(|ctx, _: ()| async { "OK" }))
    .query("private.userinfo", |t| t(|ctx, _: ()| async { "User info" }));

路由合并：大型项目的模块化组织

对于大型项目，将所有路由定义在一个文件中会导致代码难以维护。rspc支持路由合并，允许你将路由分散到多个文件或模块中。

// users.rs - 用户相关路由
pub fn router() -> Router<Ctx, ()> {
    Router::new()
        .query("get", |t| t(|ctx, id: u64| async move { /* 获取用户 */ }))
        .mutation("create", |t| t(|ctx, input: CreateUserInput| async move { /* 创建用户 */ }))
        .mutation("update", |t| t(|ctx, (id, input): (u64, UpdateUserInput)| async move { /* 更新用户 */ }))
        .mutation("delete", |t| t(|ctx, id: u64| async move { /* 删除用户 */ }))
}

// posts.rs - 文章相关路由
pub fn router() -> Router<Ctx, ()> {
    Router::new()
        .query("list", |t| t(|ctx, page: u32| async move { /* 列出文章 */ }))
        .query("get", |t| t(|ctx, id: u64| async move { /* 获取文章 */ }))
        .mutation("create", |t| t(|ctx, input: CreatePostInput| async move { /* 创建文章 */ }))
}

// main.rs - 合并路由
let app_router = Router::new()
    .merge("users.", users::router())
    .merge("posts.", posts::router())
    .query("version", |t| t(|ctx, _: ()| async move { "1.0.0" }));

// 生成的API端点将自动带有前缀：
// - users.get
// - users.create
// - posts.list
// - ...

实时数据订阅：构建响应式应用

rspc的订阅功能允许客户端建立持久连接，实时接收服务器推送的数据更新，非常适合构建聊天应用、实时仪表板等响应式系统。

// 服务器端：定义一个实时通知订阅
.router.subscription("notifications", |t| {
    t(|ctx, user_id: u64| async move {
        // 获取用户的通知通道（实际应用中可能是Redis Pub/Sub、数据库触发器等）
        let mut notification_channel = get_notification_channel(user_id);
        
        Ok(ProcedureStream::new(move |mut tx| async move {
            while let Some(notification) = notification_channel.recv().await {
                // 将通知发送给客户端
                if tx.send(Ok(notification)).await.is_err() {
                    // 客户端断开连接，退出循环
                    break;
                }
            }
        }))
    })
})

// 客户端：订阅通知
const Notifications: React.FC = () => {
  const { data: notification, isLoading, error } = useSubscription('notifications', {
    input: currentUser.id,
  });

  return (
    <div className="notifications">
      <h3>实时通知</h3>
      {isLoading && <p>连接中...</p>}
      {error && <p className="error">错误: {error.message}</p>}
      {notification && (
        <div className="notification">
          <h4>{notification.title}</h4>
          <p>{notification.content}</p>
          <time>{new Date(notification.timestamp).toLocaleString()}</time>
        </div>
      )}
    </div>
  );
};

错误处理：优雅处理异常情况

rspc提供了统一的错误处理机制，允许你定义自定义错误类型，并自动将其序列化为客户端可理解的格式。

// 定义自定义错误类型
#[derive(Debug, Serialize, specta::Type)]
enum AppError {
    UserNotFound(u64),
    InsufficientPermissions {
        user_id: u64,
        required_permission: String,
    },
    ValidationError(String),
}

impl ProcedureError for AppError {
    fn code(&self) -> &'static str {
        match self {
            AppError::UserNotFound(_) => "USER_NOT_FOUND",
            AppError::InsufficientPermissions { .. } => "INSUFFICIENT_PERMISSIONS",
            AppError::ValidationError(_) => "VALIDATION_ERROR",
        }
    }
}

// 在过程中使用自定义错误
.router.query("user.get", |t| {
    t(|ctx, user_id: u64| async move {
        let user = find_user(user_id).await?;
        
        if user.is_none() {
            return Err(AppError::UserNotFound(user_id).into());
        }
        
        Ok(user.unwrap())
    })
})

客户端将收到包含错误代码和详细信息的响应：

{
  "error": {
    "code": "USER_NOT_FOUND",
    "message": "UserNotFound(42)",
    "data": 42
  }
}

生产环境最佳实践：构建健壮的rspc应用

将rspc应用部署到生产环境需要考虑性能、安全性、可观测性等多方面因素。本节将介绍一些关键的最佳实践，帮助你构建健壮可靠的rspc应用。

性能优化策略

1. 连接池管理：为数据库连接、缓存等资源使用连接池，避免频繁创建和销毁连接

// 使用sqlx的连接池作为上下文
#[derive(Debug, Clone)]
struct Ctx {
    db: sqlx::PgPool,
    cache: Arc<RedisPool>,
}

// 在应用启动时创建连接池
let db_pool = sqlx::PgPool::connect(&env("DATABASE_URL")).await.unwrap();
let redis_pool = RedisPool::new(&env("REDIS_URL")).unwrap();

// 将连接池放入上下文
let router = Router::new()
    .with_context(Ctx {
        db: db_pool.clone(),
        cache: Arc::new(redis_pool),
    })
    // ...定义路由

2. 请求批处理：利用rspc的批量请求功能，减少网络往返

// 客户端：批量发送多个请求
const result = await client.batch([
  { procedure: 'user.get', input: 1 },
  { procedure: 'posts.list', input: { page: 1, limit: 10 } },
  { procedure: 'notifications.count', input: null },
]);

// 结果将按请求顺序返回
const [user, posts, notificationCount] = result;

3. 响应缓存：使用中间件实现查询结果缓存，减轻数据库负担

// 缓存中间件示例
fn cache_middleware<TCtx, TMeta>(
    cache: Arc<RedisPool>,
    ttl: Duration,
) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(move |ctx, next| {
        let cache = cache.clone();
        let ttl = ttl;
        async move {
            let procedure_name = next.procedure_name().to_string();
            
            // 只缓存查询类型的请求
            if !procedure_name.starts_with("query.") {
                return next.run(ctx).await;
            }
            
            // 生成缓存键（包含输入数据的哈希）
            let input_hash = hash_input(&next.input());
            let cache_key = format!("rspc:cache:{}:{}", procedure_name, input_hash);
            
            // 尝试从缓存获取
            if let Some(cached) = get_from_cache(&cache, &cache_key).await {
                return Ok(serde_json::from_slice(&cached).unwrap());
            }
            
            // 缓存未命中，执行原始请求
            let result = next.run(ctx).await;
            
            // 将结果存入缓存
            if let Ok(data) = &result {
                let serialized = serde_json::to_vec(data).unwrap();
                set_to_cache(&cache, &cache_key, serialized, ttl).await;
            }
            
            result
        }
    })
}

安全性强化措施

1. 严格的CORS策略：生产环境中应限制允许的源，避免使用通配符

// 生产环境CORS配置
let cors = CorsLayer::new()
    .allow_origin(Origin::exact("https://your-frontend-domain.com".parse().unwrap()))
    .allow_methods([Method::GET, Method::POST, Method::OPTIONS])
    .allow_headers([header::CONTENT_TYPE, header::AUTHORIZATION])
    .max_age(Duration::from_secs(86400)); // 24小时缓存预检请求

2. 请求验证与净化：对所有用户输入进行严格验证，防止注入攻击

// 使用validator验证输入数据
#[derive(Debug, Deserialize, Validate, specta::Type)]
struct CreateUserInput {
    #[validate(email)]
    email: String,
    
    #[validate(length(min = 8, max = 64))]
    password: String,
    
    #[validate(length(min = 1, max = 100))]
    name: String,
}

// 在过程中验证输入
.router.mutation("user.create", |t| {
    t(|ctx, input: CreateUserInput| async move {
        // 验证输入数据
        input.validate()
            .map_err(|e| AppError::ValidationError(format!("Invalid input: {}", e)))?;
            
        // 安全处理密码（哈希、加盐）
        let hashed_password = hash_password(&input.password);
        
        // 创建用户
        let user = sqlx::query_as!(
            User,
            "INSERT INTO users (email, password_hash, name) VALUES ($1, $2, $3) RETURNING *",
            input.email,
            hashed_password,
            input.name
        )
        .fetch_one(&ctx.db)
        .await?;
        
        Ok(user)
    })
})

3. 权限精细控制：实现基于角色的访问控制（RBAC）

// 权限检查中间件
fn require_permission<TCtx, TMeta>(permission: &'static str) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(move |ctx, next| {
        let required_permission = permission;
        async move {
            // 检查用户是否有足够权限
            if !ctx.user.has_permission(required_permission) {
                return Err(ProcedureError::new(
                    "INSUFFICIENT_PERMISSIONS",
                    format!("Required permission: {}", required_permission),
                ));
            }
            
            next.run(ctx).await
        }
    })
}

// 应用到特定路由
.router.mutation("admin.deleteUser", |t| {
    t.middleware(require_permission("admin:delete_user"))
     .handler(|ctx, user_id: u64| async move {
         // 只有管理员可以执行此操作
         delete_user(&ctx.db, user_id).await?;
         Ok(())
     })
})

可观测性与监控

1. 结构化日志：使用tracing库实现结构化日志，便于问题排查

// 使用tracing记录请求信息
fn tracing_middleware<TCtx, TMeta>(
) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(|ctx, next| async move {
        let span = tracing::info_span!(
            "rspc_request",
            procedure = %next.procedure_name(),
            user_id = %ctx.user.id(),
        );
        
        let _enter = span.enter();
        tracing::info!("Starting request");
        
        let result = next.run(ctx).await;
        
        match &result {
            Ok(_) => tracing::info!("Request completed successfully"),
            Err(e) => tracing::error!("Request failed: {}", e),
        }
        
        result
    })
}

2. 性能指标收集：集成Prometheus等监控工具，跟踪关键指标

// 使用metrics库收集性能指标
fn metrics_middleware<TCtx, TMeta>(
) -> impl Middleware<TCtx, TMeta>
where
    TCtx: Clone + Send + Sync + 'static,
    TMeta: Clone + Send + Sync + 'static,
{
    Middleware::new(|ctx, next| async move {
        let procedure_name = next.procedure_name().to_string();
        let start = Instant::now();
        
        // 增加请求计数器
        metrics::counter!("rspc_requests_total", "procedure" => procedure_name.clone())
            .increment(1);
        
        let result = next.run(ctx).await;
        
        // 记录请求耗时
        let duration = start.elapsed().as_secs_f64();
        metrics::histogram!("rspc_request_duration_seconds", "procedure" => procedure_name)
            .record(duration);
        
        // 记录错误数
        if result.is_err() {
            metrics::counter!("rspc_errors_total", "procedure" => procedure_name)
                .increment(1);
        }
        
        result
    })
}

结语：rspc开创Rust API开发新纪元

rspc通过将Rust的类型安全特性与现代API开发需求相结合，开创了一种全新的API开发范式。它不仅解决了传统API开发中的类型不一致、文档维护困难等痛点，还通过简洁的API设计和强大的功能集，大幅提升了开发效率和代码质量。

rspc适用场景

• 全栈Rust应用：结合Rust后端和前端（如Yew、Dioxus），实现端到端类型安全
• Tauri桌面应用：利用rspc在Rust后端和Web前端之间建立高效通信
• 实时协作系统：通过订阅功能构建低延迟的实时数据同步
• API服务：为前端、移动应用等提供类型安全的API接口

未来展望

尽管rspc目前已停止维护，但它开创的理念和设计模式对Rust API开发产生了深远影响。社区正在积极探索和发展类似的解决方案，如tRPC的Rust实现、Specta等类型生成工具。

无论如何，rspc展示的类型驱动API开发方向无疑是未来的趋势。通过在编译时捕获类型错误，自动化类型同步和文档生成，我们可以构建更健壮、更易于维护的软件系统。

下一步学习资源

• rspc官方文档：虽然项目停止维护，但文档仍有参考价值
• tRPC官方文档：了解rspc的灵感来源
• Specta库：rspc使用的类型生成核心
• Axum、Tauri等集成框架的官方文档

现在，你已经掌握了使用rspc构建类型安全API的核心知识。是时候开始实践，将这些理念应用到你的项目中，体验类型安全API开发带来的革命性变化了！

祝你编码愉快，构建出令人惊叹的应用！

【免费下载链接】rspc A blazingly fast and easy to use tRPC-like server for Rust. 项目地址: https://gitcode.com/gh_mirrors/rs/rspc