rust··约 9 分钟读完·749 次观看

使用宏实现高效的分页查询功能

本文介绍了使用Rust过程宏实现高效分页查询的解决方案。核心是通过宏自动生成统一的分页接口,包括分页参数处理、数据库查询和错误处理逻辑。该方法支持基本分页、排序和过滤功能,同时考虑性能优化和错误处理,适用于处理大量数据的Web应用场景。相比手动实现,宏驱动的方式显著提高了开发效率,并保证了代码一致性和可维护性,特别适合需要频繁进行分页查询的管理后台和移动应用。
服务器rust后端

使用宏实现高效的分页查询功能

批量数据查询:基于宏的分页列表查询解决方案

在现代Web应用中,分页查询是处理大量数据的标准方式。本文将介绍如何使用Rust过程宏自动化分页查询的实现,提供统一的分页接口和灵活的查询选项。

分页查询的复杂性

传统的手动分页实现:

rust
      
        
          1
          
          pub async fn list_categories(
        
          2
          
              db: &DatabaseConnection,
        
          3
          
              page: u64,
        
          4
          
              limit: u64,
        
          5
          
          ) -> Result<Vec<category::Model>, AppError> {
        
          6
          
              let categories = category::Entity::find()
        
          7
          
                  .limit(limit)
        
          8
          
                  .offset((page - 1) * limit)
        
          9
          
                  .all(db)
        
          10
          
                  .await
        
          11
          
                  .map_err(|e| AppError::DatabaseError(e.to_string()))?;
        
          12
          
              
        
          13
          
              Ok(categories)
        
          14
          
          }
        
      
    

每个实体都需要重复实现相似的分页逻辑。

宏驱动的分页解决方案

rust
      
        
          1
          
          crud_entity!({
        
          2
          
              entity: categories,
        
          3
          
              route_prefix: "/api/categories",
        
          4
          
              permission_prefix: "categories",
        
          5
          
              operations: ["list"]
        
          6
          
          });
        
      
    

核心实现

1. 分页查询函数生成

rust
      
        
          1
          
          fn generate_list_code(
        
          2
          
              entity: &Ident,
        
          3
          
              route_prefix: &LitStr,
        
          4
          
              permission_prefix: &LitStr,
        
          5
          
          ) -> proc_macro2::TokenStream {
        
          6
          
              let get_fn = format_ident!("get_{}_all", entity.to_string().to_lowercase());
        
          7
          
              let get_handler = format_ident!("get_{}_all_handler", entity.to_string().to_lowercase());
        
          8
          
              
        
          9
          
              quote! {
        
          10
          
                  pub async fn #get_fn(
        
          11
          
                      db_pool: &DatabaseConnection,
        
          12
          
                      page: u64,
        
          13
          
                      limit: u64,
        
          14
          
                  ) -> Result<HttpResponse, AppError> {
        
          15
          
                      match #entity::Entity::find()
        
          16
          
                              .limit(limit)
        
          17
          
                              .offset((page - 1) * limit)
        
          18
          
                              .all(db_pool)
        
      
    

2. 分页参数处理

rust
      
        
          1
          
          #[crate::route_permission(
        
          2
          
              path = #full_path,
        
          3
          
              method = "get",
        
          4
          
              permission = #full_permission
        
          5
          
          )]
        
          6
          
          pub async fn #get_handler(
        
          7
          
              db: web::Data<DatabaseConnection>,
        
          8
          
              query: web::Query<PaginationQuery>,
        
          9
          
          ) -> HttpResult {
        
          10
          
              let PaginationQuery { page, limit } = query.into_inner();
        
          11
          
              let result = #get_fn(db.as_ref(), page, limit).await?;
        
          12
          
              Ok(result)
        
          13
          
          }
        
      
    

分页参数结构

定义统一的分页查询参数:

rust
      
        
          1
          
          #[derive(Debug, Deserialize)]
        
          2
          
          pub struct PaginationQuery {
        
          3
          
              pub page: u64,
        
          4
          
              pub limit: u64,
        
          5
          
          }
        
          6
          
          
        
          7
          
          impl Default for PaginationQuery {
        
          8
          
              fn default() -> Self {
        
          9
          
                  Self {
        
          10
          
                      page: 1,
        
          11
          
                      limit: 20,
        
          12
          
                  }
        
          13
          
              }
        
          14
          
          }
        
      
    

使用示例

1. 基本分页查询

rust
      
        
          1
          
          crud_entity!({
        
          2
          
              entity: categories,
        
          3
          
              route_prefix: "/api/categories",
        
          4
          
              permission_prefix: "categories",
        
          5
          
              operations: ["list"]
        
          6
          
          });
        
      
    

2. 前端调用

http
      
        
          1
          
          GET /api/categories?page=1&limit=10
        
          2
          
          GET /api/categories?page=2&limit=20
        
      
    

3. 响应格式

json
      
        
          1
          
          [
        
          2
          
            {
        
          3
          
              "id": 1,
        
          4
          
              "name": "Technology",
        
          5
          
              "slug": "tech"
        
          6
          
            },
        
          7
          
            {
        
          8
          
              "id": 2, 
        
          9
          
              "name": "Science",
        
          10
          
              "slug": "science"
        
          11
          
            }
        
          12
          
          ]
        
      
    

高级功能

1. 排序支持

扩展分页参数支持排序:

rust
      
        
          1
          
          #[derive(Debug, Deserialize)]
        
          2
          
          pub struct PaginationQuery {
        
          3
          
              pub page: u64,
        
          4
          
              pub limit: u64,
        
          5
          
              pub sort_by: Option<String>,
        
          6
          
              pub sort_order: Option<String>, // "asc" or "desc"
        
          7
          
          }
        
      
    

2. 过滤条件

支持查询过滤:

rust
      
        
          1
          
          #[derive(Debug, Deserialize)]
        
          2
          
          pub struct CategoryQuery {
        
          3
          
              pub page: u64,
        
          4
          
              pub limit: u64,
        
          5
          
              pub name: Option<String>,
        
          6
          
              pub slug: Option<String>,
        
          7
          
          }
        
      
    

性能考虑

1. 数据库优化

rust
      
        
          1
          
          // 使用索引优化的查询
        
          2
          
          category::Entity::find()
        
          3
          
              .limit(limit)
        
          4
          
              .offset((page - 1) * limit)
        
          5
          
              .all(db)
        
      
    

2. 防止过度分页

rust
      
        
          1
          
          // 限制最大分页大小
        
          2
          
          let limit = limit.min(100); // 最大100条记录
        
      
    

错误处理

完善的错误处理机制:

rust
      
        
          1
          
          match category::Entity::find()
        
          2
          
              .limit(limit)
        
          3
          
              .offset((page - 1) * limit)
        
          4
          
              .all(db_pool)
        
          5
          
              .await {
        
          6
          
              Ok(data) => Ok(HttpResponse::Ok().json(data)),
        
          7
          
              Err(e) => {
        
          8
          
                  println!("Database query error: {}", e);
        
          9
          
                  Err(AppError::DatabaseConnectionError(e.to_string()))
        
          10
          
              }
        
          11
          
          }
        
      
    

实际应用场景

1. 管理后台

javascript
      
        
          1
          
          // 前端管理后台表格
        
          2
          
          const loadData = async (page, pageSize) => {
        
          3
          
            const response = await fetch(`/api/categories?page=${page}&limit=${pageSize}`);
        
          4
          
            return await response.json();
        
          5
          
          };
        
      
    

2. 移动端应用

dart
      
        
          1
          
          // Flutter应用中的分页加载
        
          2
          
          Future<List<Category>> fetchCategories(int page, int limit) async {
        
          3
          
            final response = await http.get(
        
          4
          
              Uri.parse('/api/categories?page=$page&limit=$limit')
        
          5
          
            );
        
          6
          
            return categoryFromJson(response.body);
        
          7
          
          }
        
      
    

扩展功能建议

  1. 总数返回:在响应中包含总记录数
  2. 元数据:返回分页元信息(当前页、总页数等)
  3. 缓存策略:为频繁查询的数据添加缓存
  4. 搜索集成:结合全文搜索功能

总结

通过过程宏自动化分页查询功能,我们实现了:

  • 统一的分页接口:所有实体使用相同的分页参数格式
  • 灵活的查询选项:支持排序、过滤等高级功能
  • 完善的错误处理:统一的数据库错误处理
  • 性能优化:合理的分页限制和查询优化
  • 易于扩展:支持各种定制化需求

这种方案特别适合需要处理大量数据的Web应用,能够显著提高开发效率和系统性能。


窗口居中方案技术文档:基于 Dioxus 与 Winit 的高DPI自适应实现

本文档介绍了基于Rust的Dioxus框架与Winit窗口库实现的高DPI自适应窗口居中方案。该方案通过正确处理物理像素与逻辑像素的转换,确保应用程序窗口在不同DPI显示器上都能精确定位。核心内容包括:1) 物理/逻辑像素转换原理;2) 基于系统缩放因子的居中算法;3) 完整实现代码示例;4) 多显示器支持扩展方法。方案特点包括跨平台兼容性、精确计算和框架无缝集成,解决了传统窗口定位在高DPI环境下的偏移问题,为开发者提供了开箱即用的窗口管理解决方案。

439 浏览

Windows 下隐藏命令行子进程窗口的技术方案

本文介绍了在Windows下隐藏命令行子进程窗口的技术方案。通过使用CREATE_NO_WINDOW标志(0x08000000)和CommandExt trait,可以抑制控制台窗口弹出。该方案仅影响控制台程序,GUI程序不受影响,但需注意隐藏窗口后需妥善管理子进程输出。开发阶段可选择性禁用该标志以便调试。这是Windows平台实现子进程窗口隐藏的最简洁解决方案。

266 浏览

把 Rust 的 `target` 目录搬到外挂盘——正确姿势与避坑指南

摘要: Rust项目的target/目录占用大量SSD空间,可通过配置target-dir将其迁移到外挂盘。正确方法是在.cargo/config.toml中添加[build] target-dir = &quot;绝对路径&quot;,并执行cargo clean验证。支持全局、工作区或单项目级配置,注意路径权限和绝对路径。临时可用环境变量CARGO_TARGET_DIR。迁移后系统盘空间释放,外挂盘承担存储,编译效率不变。关键点:字段名正确、路径绝对、权限可写。

540 浏览

Rust 并行压缩如何改变我的工作流程

摘要:本文分享了Rust并行压缩工具Sunrise Zip如何彻底改变作者的工作流程。通过三个真实场景展示其卓越性能:63.5万文件(45GB)仅7分钟完成压缩;中小项目压缩不到1秒;资源敏感环境下仍保持高效。技术亮点包括多线程并行架构、智能压缩策略和内存映射技术。实际影响包括促进日常备份、优化部署流程和解放系统资源。这款专注于高效压缩的工具通过深入优化核心功能,显著提升了工作效率。

706 浏览

这篇文章对你有帮助吗?