dio请求优先级持久化：重启后恢复

【免费下载链接】dio 项目地址: https://gitcode.com/gh_mirrors/dio/dio

在移动应用开发中，网络请求的管理是确保用户体验的关键环节。特别是当应用需要处理多个并发请求或在不稳定网络环境下运行时，请求的优先级排序和状态持久化变得尤为重要。想象一下，用户在使用应用时发起了多个请求，其中一些是紧急的（如支付确认），而另一些是低优先级的（如数据同步）。如果应用在此时意外崩溃或重启，如何确保这些请求能够按照正确的优先级恢复并继续执行？这正是dio请求优先级持久化要解决的核心问题。

本文将详细介绍如何利用dio的拦截器机制和持久化存储方案，实现请求优先级管理及重启后状态恢复的完整解决方案。我们将通过实际代码示例和架构设计，展示如何在Flutter应用中落地这一功能，确保即使在应用重启后，请求也能按照预设的优先级顺序正确执行。

技术背景与挑战

在现代移动应用中，网络请求的管理面临着多重挑战。首先，不同类型的请求往往具有不同的紧急程度，例如用户主动触发的操作（如提交表单）应该优先于后台同步任务。其次，移动设备的网络环境复杂多变，请求可能需要在弱网或断网状态下排队等待，直到网络恢复后再继续执行。最后，应用可能会因各种原因意外终止，如何在应用重启后恢复未完成的请求并保持其优先级顺序，是确保数据一致性和用户体验的关键。

dio作为Flutter生态中最流行的HTTP客户端，提供了强大的拦截器机制和请求队列管理功能。通过自定义拦截器，我们可以实现请求的优先级排序；通过持久化存储，我们可以在应用重启后恢复请求状态。然而，dio框架本身并不直接提供请求优先级持久化的解决方案，需要开发者基于现有组件进行扩展。

以下是实现请求优先级持久化需要解决的几个关键问题：

1. 请求优先级定义：如何为不同的请求分配优先级，并在拦截器中识别这些优先级。
2. 请求队列管理：如何维护一个有序的请求队列，确保高优先级的请求先执行。
3. 持久化存储：如何将请求的元数据（如URL、方法、参数、优先级等）保存到本地存储中。
4. 重启恢复机制：如何在应用重启后从本地存储中读取未完成的请求，并按照优先级重新加入队列。

dio拦截器与请求队列

dio的拦截器机制允许开发者在请求发送前、响应接收后或发生错误时插入自定义逻辑。其中，QueuedInterceptor是一种特殊的拦截器，它可以确保请求按顺序执行，前一个请求完成后才会处理下一个请求。这为实现请求优先级队列提供了基础。

在dio的官方示例中，提供了一个使用QueuedInterceptorsWrapper的例子，展示了如何实现请求的顺序执行。以下是来自example_dart/lib/queue_interceptors.dart的核心代码：

dio.interceptors.add(
  QueuedInterceptorsWrapper(
    onRequest: (
      RequestOptions requestOptions,
      RequestInterceptorHandler handler,
    ) {
      print(requestOptions.uri);
      Future.delayed(const Duration(seconds: 2), () {
        handler.next(requestOptions);
      });
    },
  ),
);

在这个示例中，所有请求会先进入拦截器队列，每个请求会延迟2秒后再继续执行。通过这种方式，请求会按照添加到队列的顺序依次执行，而不是并发执行。这为我们实现请求优先级排序提供了可能——我们可以在拦截器中根据请求的优先级调整其在队列中的位置。

然而，标准的QueuedInterceptor只能保证请求的顺序执行，无法根据动态优先级调整队列顺序。因此，我们需要扩展这一机制，实现一个支持优先级排序的请求队列。

请求优先级实现方案

要实现支持优先级的请求队列，我们需要对dio的拦截器进行扩展，使其能够根据请求的优先级对队列中的请求进行排序。以下是一个可能的实现方案：

1. 定义优先级枚举：首先，我们需要定义请求的优先级级别，例如高、中、低。

enum RequestPriority {
  high,
  medium,
  low,
}

2. 扩展请求选项：通过dio的extra属性，我们可以为每个请求附加自定义数据，包括优先级。

dio.get(
  '/api/data',
  options: Options(
    extra: {
      'priority': RequestPriority.high,
    },
  ),
);

3. 实现优先级队列拦截器：自定义一个PriorityQueueInterceptor，继承自QueuedInterceptor，并重写其请求处理逻辑。在拦截器中，我们维护一个优先级队列，根据请求的priority属性对队列中的请求进行排序。

class PriorityQueueInterceptor extends QueuedInterceptor {
  final PriorityQueue<RequestOptions> _queue = PriorityQueue(
    (a, b) => b.extra['priority'].index.compareTo(a.extra['priority'].index),
  );

  @override
  void onRequest(
    RequestOptions options,
    RequestInterceptorHandler handler,
  ) {
    _queue.add(options);
    _processQueue(handler);
  }

  void _processQueue(RequestInterceptorHandler handler) {
    if (_queue.isNotEmpty) {
      final nextRequest = _queue.removeFirst();
      handler.next(nextRequest);
    }
  }
}

在这个示例中，我们使用了一个优先级队列（PriorityQueue）来存储请求，队列会根据请求的优先级（从高到低）进行排序。每当有新的请求进入拦截器，它会被添加到队列中，然后_processQueue方法会取出队列中优先级最高的请求并继续处理。

持久化存储方案

实现了请求优先级队列后，我们需要解决请求状态的持久化问题。当应用意外终止时，队列中未完成的请求需要被保存到本地存储中，以便在应用重启后恢复。

本地存储选择

在Flutter应用中，常用的本地存储方案包括：

• SharedPreferences：适用于存储简单的键值对数据。
• Hive：一个轻量级的键值对数据库，支持复杂对象的存储。
• SQLite：适用于存储结构化数据，支持复杂查询。

对于请求元数据的存储，Hive是一个不错的选择，因为它支持自定义对象的存储，并且性能高效。以下是如何使用Hive存储请求信息的示例：

1. 定义请求模型：首先，我们需要定义一个PersistableRequest类，用于存储请求的关键信息。

part 'persistable_request.g.dart';

@HiveType(typeId: 0)
class PersistableRequest {
  @HiveField(0)
  final String url;

  @HiveField(1)
  final String method;

  @HiveField(2)
  final Map<String, dynamic> headers;

  @HiveField(3)
  final dynamic data;

  @HiveField(4)
  final int priority;

  @HiveField(5)
  final String id;

  PersistableRequest({
    required this.url,
    required this.method,
    required this.headers,
    this.data,
    required this.priority,
    required this.id,
  });
}

2. 初始化Hive：在应用启动时，初始化Hive并注册PersistableRequest适配器。

void initHive() async {
  await Hive.initFlutter();
  Hive.registerAdapter(PersistableRequestAdapter());
  await Hive.openBox<PersistableRequest>('pending_requests');
}

3. 存储请求：当请求进入优先级队列时，将其转换为PersistableRequest对象并保存到Hive中。

void _persistRequest(RequestOptions options) {
  final box = Hive.box<PersistableRequest>('pending_requests');
  final requestId = Uuid().v4(); // 使用UUID生成唯一请求ID
  final persistableRequest = PersistableRequest(
    url: options.uri.toString(),
    method: options.method,
    headers: options.headers,
    data: options.data,
    priority: options.extra['priority'].index,
    id: requestId,
  );
  box.put(requestId, persistableRequest);
}

4. 删除请求：当请求成功完成或失败时，从Hive中删除对应的请求记录。

void _removePersistedRequest(String requestId) {
  final box = Hive.box<PersistableRequest>('pending_requests');
  box.delete(requestId);
}

重启恢复机制

实现了请求的持久化存储后，我们需要在应用重启后恢复这些请求。以下是恢复机制的实现步骤：

1. 应用启动时检查持久化请求：在应用初始化阶段，检查Hive中是否存在未完成的请求。

void _restorePendingRequests(Dio dio) {
  final box = Hive.box<PersistableRequest>('pending_requests');
  final pendingRequests = box.values.toList();
  
  // 按优先级排序请求
  pendingRequests.sort((a, b) => b.priority.compareTo(a.priority));
  
  // 将请求重新添加到dio队列
  for (final request in pendingRequests) {
    dio.request(
      request.url,
      method: request.method,
      options: Options(
        headers: request.headers,
        extra: {
          'priority': RequestPriority.values[request.priority],
          'requestId': request.id,
        },
      ),
      data: request.data,
    ).then((_) {
      _removePersistedRequest(request.id);
    });
  }
}

2. 处理请求完成事件：当一个恢复的请求成功完成或失败时，从Hive中删除对应的记录，避免重复执行。

3. 处理请求冲突：在某些情况下，同一个请求可能被多次持久化。为了避免重复执行，我们可以在请求的extra属性中添加一个唯一的请求ID，并在恢复时检查该ID是否已经处理过。

完整实现架构

综合以上各个组件，我们可以构建一个完整的请求优先级持久化解决方案。以下是该方案的架构图：

在这个架构中，应用启动时会先初始化dio和Hive存储，然后从Hive中恢复未完成的请求并按优先级排序。之后，应用正常运行，新的请求会被添加到优先级队列并持久化到Hive中。当请求完成后，对应的持久化记录会被删除；如果请求未完成而应用重启，则会重复这一过程。

代码示例与集成指南

以下是将请求优先级持久化功能集成到Flutter应用中的完整代码示例：

1. 添加依赖

在pubspec.yaml中添加dio、hive和uuid的依赖：

dependencies:
  dio: ^5.0.0
  hive: ^2.2.3
  hive_flutter: ^1.1.0
  uuid: ^3.0.6

2. 初始化Hive和dio

import 'package:dio/dio.dart';
import 'package:hive/hive.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:uuid/uuid.dart';

enum RequestPriority {
  high,
  medium,
  low,
}

part 'persistable_request.g.dart';

@HiveType(typeId: 0)
class PersistableRequest {
  @HiveField(0)
  final String url;

  @HiveField(1)
  final String method;

  @HiveField(2)
  final Map<String, dynamic> headers;

  @HiveField(3)
  final dynamic data;

  @HiveField(4)
  final int priority;

  @HiveField(5)
  final String id;

  PersistableRequest({
    required this.url,
    required this.method,
    required this.headers,
    this.data,
    required this.priority,
    required this.id,
  });
}

class PriorityQueueInterceptor extends QueuedInterceptor {
  final PriorityQueue<RequestOptions> _queue = PriorityQueue(
    (a, b) => b.extra['priority'].index.compareTo(a.extra['priority'].index),
  );

  @override
  void onRequest(
    RequestOptions options,
    RequestInterceptorHandler handler,
  ) {
    // 为请求生成唯一ID
    final requestId = options.extra['requestId'] ?? Uuid().v4();
    options.extra['requestId'] = requestId;

    // 持久化请求
    _persistRequest(options);

    // 将请求添加到优先级队列
    _queue.add(options);

    // 处理队列中的下一个请求
    _processQueue(handler);
  }

  void _processQueue(RequestInterceptorHandler handler) {
    if (_queue.isNotEmpty) {
      final nextRequest = _queue.removeFirst();
      handler.next(nextRequest);
    }
  }

  void _persistRequest(RequestOptions options) {
    final requestId = options.extra['requestId'];
    final persistableRequest = PersistableRequest(
      url: options.uri.toString(),
      method: options.method,
      headers: options.headers,
      data: options.data,
      priority: options.extra['priority'].index,
      id: requestId,
    );
    Hive.box<PersistableRequest>('pending_requests').put(requestId, persistableRequest);
  }
}

void main() async {
  // 初始化Hive
  await Hive.initFlutter();
  Hive.registerAdapter(PersistableRequestAdapter());
  await Hive.openBox<PersistableRequest>('pending_requests');

  // 初始化dio
  final dio = Dio();
  
  // 添加优先级队列拦截器
  dio.interceptors.add(PriorityQueueInterceptor());
  
  // 恢复未完成的请求
  _restorePendingRequests(dio);

  runApp(MyApp(dio: dio));
}

void _restorePendingRequests(Dio dio) {
  final box = Hive.box<PersistableRequest>('pending_requests');
  final pendingRequests = box.values.toList();
  
  // 按优先级排序
  pendingRequests.sort((a, b) => b.priority.compareTo(a.priority));
  
  // 恢复请求
  for (final request in pendingRequests) {
    dio.request(
      request.url,
      method: request.method,
      options: Options(
        headers: request.headers,
        extra: {
          'priority': RequestPriority.values[request.priority],
          'requestId': request.id,
        },
      ),
      data: request.data,
    ).then((_) {
      box.delete(request.id);
    });
  }
}

3. 使用优先级请求

// 发起高优先级请求
dio.get(
  'https://api.example.com/urgent-data',
  options: Options(
    extra: {
      'priority': RequestPriority.high,
    },
  ),
);

// 发起低优先级请求
dio.post(
  'https://api.example.com/log-data',
  options: Options(
    extra: {
      'priority': RequestPriority.low,
    },
  ),
  data: {'event': 'user_click'},
);

注意事项与最佳实践

在实现请求优先级持久化功能时，需要注意以下几点：

1. 请求幂等性：由于请求可能在应用重启后被重新执行，因此确保所有持久化的请求都是幂等的（即多次执行不会产生副作用）非常重要。

2. 存储容量管理：长期运行的应用可能会积累大量的持久化请求记录，需要定期清理过期或不再需要的请求。

3. 安全性考虑：请求数据可能包含敏感信息，因此在持久化存储时应考虑加密敏感字段，避免数据泄露。

4. 性能优化：频繁的持久化操作可能会影响应用性能，建议使用批处理或延迟写入等策略减少IO操作。

5. 错误处理：请求恢复过程中可能会遇到各种错误（如网络不可用、URL无效等），需要添加适当的错误处理机制，避免应用崩溃。

总结与展望

通过扩展dio的拦截器机制和使用Hive进行本地存储，我们可以实现请求优先级持久化的功能，确保即使在应用重启后，请求也能按照预设的优先级顺序正确执行。这一方案不仅提高了应用的健壮性，也增强了用户体验，特别是在网络环境不稳定或应用需要处理大量后台请求的场景下。

未来，我们可以进一步优化这一方案，例如：

1. 动态优先级调整：允许在请求排队后动态调整其优先级。
2. 请求依赖管理：支持定义请求之间的依赖关系，确保某些请求在其他请求完成后再执行。
3. 网络状态感知：结合网络状态监听，在网络恢复时自动触发排队请求的执行。

通过不断完善请求管理机制，我们可以构建更加健壮和用户友好的移动应用，即使在复杂的网络环境下也能提供可靠的数据同步和交互体验。

希望本文提供的方案能够帮助开发者更好地管理应用中的网络请求，解决请求优先级和持久化的问题。如果您有任何疑问或建议，欢迎在项目的GitHub仓库中提出issue或提交PR，共同完善这一功能。

【免费下载链接】dio 项目地址: https://gitcode.com/gh_mirrors/dio/dio