Dio网络请求框架之InterceptorResultTyp

InterceptorResultType

enum InterceptorResultType {
  next,
  resolve,
  resolveCallFollowing,
  reject,
  rejectCallFollowing,
}

这段代码定义了一个枚举类型 InterceptorResultType，它包含以下成员：

next: 表示拦截器处理结果为继续执行下一个拦截器。
resolve: 表示拦截器处理结果为解决（resolve）操作，通常用于处理成功的情况。
resolveCallFollowing: 表示拦截器处理结果为解决（resolve）操作，并要求继续执行后续的拦截器。
reject: 表示拦截器处理结果为拒绝（reject）操作，通常用于处理失败的情况。
rejectCallFollowing: 表示拦截器处理结果为拒绝（reject）操作，并要求继续执行后续的拦截器。

这个枚举类型用于表示拦截器的处理结果类型，拦截器可以根据具体的业务逻辑选择合适的结果类型并返回给调用方。枚举类型的成员提供了一种清晰的方式来表达拦截器的处理结果，使代码更易读和理解。

InterceptorState

class InterceptorState<T> {
  const InterceptorState(this.data, [this.type = InterceptorResultType.next]);

  final T data;
  final InterceptorResultType type;
}

这段代码定义了一个泛型类 InterceptorState<T>，表示拦截器的状态。它有两个成员变量：

data：表示拦截器的数据，类型为泛型参数 T，用于存储拦截器的处理结果或相关数据。
type：表示拦截器的状态类型，类型为 InterceptorResultType 枚举，用于指示拦截器的处理结果类型，默认为 InterceptorResultType.next。

构造函数 InterceptorState 接收一个泛型参数 data 和一个可选的参数 type，用于创建 InterceptorState 的实例。可以根据具体的业务需求传入不同的数据和状态类型来创建相应的拦截器状态实例。

通过使用 InterceptorState 类，拦截器可以通过返回一个 InterceptorState 实例来表示其处理结果和状态。调用方可以根据拦截器返回的 InterceptorState 对象来判断拦截器的处理结果类型和获取相应的数据。这样可以更灵活地处理拦截器的状态和结果。

_BaseHandler(抽象类)

abstract class _BaseHandler {
  final _completer = Completer<InterceptorState>();
  void Function()? _processNextInQueue;

  Future<InterceptorState> get future => _completer.future;

  bool get isCompleted => _completer.isCompleted;
}

这段代码定义了一个抽象类 _BaseHandler，它包含以下成员：

_completer: 一个 Completer 对象，用于处理异步操作的完成和结果返回。它的泛型参数指定了它的返回类型为 InterceptorState。
_processNextInQueue: 一个可选的无参函数，用于处理队列中的下一个操作。
future: 通过 _completer 的 future 属性，可以获取一个 Future 对象，用于等待异步操作的完成并获取结果。
isCompleted: 通过 _completer 的 isCompleted 属性，可以判断异步操作是否已完成。

该抽象类提供了一种基础的处理器机制，用于处理拦截器的异步操作。具体的拦截器处理器可以继承这个抽象类，并根据需要实现自己的逻辑。子类可以使用 _completer 来完成异步操作并返回结果，同时可以通过 _processNextInQueue 来处理队列中的下一个操作。

需要注意的是，这段代码中的 _BaseHandler 是一个抽象类，不能直接实例化。它需要在具体的拦截器处理器中进行实现和使用。

RequestInterceptorHandler

class RequestInterceptorHandler extends _BaseHandler {
  /// Continue to call the next request interceptor.
  void next(RequestOptions requestOptions) {
    _completer.complete(InterceptorState<RequestOptions>(requestOptions));
    _processNextInQueue?.call();
  }

  /// Return the response directly! Other request interceptor(s) will not be executed,
  /// but response and error interceptor(s) may be executed, which depends on whether
  /// the value of parameter [callFollowingResponseInterceptor] is true.
  ///
  /// [response]: Response object to return.
  /// [callFollowingResponseInterceptor]: Whether to call the response interceptor(s).
  void resolve(
    Response response, [
    bool callFollowingResponseInterceptor = false,
  ]) {
    _completer.complete(
      InterceptorState<Response>(
        response,
        callFollowingResponseInterceptor
            ? InterceptorResultType.resolveCallFollowing
            : InterceptorResultType.resolve,
      ),
    );
    _processNextInQueue?.call();
  }

  /// Complete the request with an error! Other request/response interceptor(s) will not
  /// be executed, but error interceptor(s) may be executed, which depends on whether the
  /// value of parameter [callFollowingErrorInterceptor] is true.
  ///
  /// [error]: Error info to reject.
  /// [callFollowingErrorInterceptor]: Whether to call the error interceptor(s).
  void reject(DioError error, [bool callFollowingErrorInterceptor = false]) {
    _completer.completeError(
      InterceptorState<DioError>(
        error,
        callFollowingErrorInterceptor
            ? InterceptorResultType.rejectCallFollowing
            : InterceptorResultType.reject,
      ),
      error.stackTrace,
    );
    _processNextInQueue?.call();
  }
}

这段代码定义了 RequestInterceptorHandler 类，该类继承自 _BaseHandler。RequestInterceptorHandler 类用于处理请求拦截器的操作，并提供了几个方法来控制请求的处理流程。

next(RequestOptions requestOptions) 方法用于继续调用下一个请求拦截器。它接收一个 RequestOptions 参数，表示请求的选项。调用该方法会将 requestOptions 封装成 InterceptorState<RequestOptions> 对象并完成 Completer，表示请求拦截器的处理结果为继续执行下一个拦截器。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
resolve(Response response, [bool callFollowingResponseInterceptor = false]) 方法用于直接返回响应结果，不再执行其他请求拦截器。它接收一个 Response 参数表示响应对象，以及一个可选的布尔值 callFollowingResponseInterceptor，表示是否继续调用后续的响应拦截器。调用该方法会将 response 封装成 InterceptorState<Response> 对象并完成 Completer，表示请求拦截器的处理结果为直接返回响应。如果 callFollowingResponseInterceptor 为 true，则状态类型为 InterceptorResultType.resolveCallFollowing，否则为 InterceptorResultType.resolve。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
reject(DioError error, [bool callFollowingErrorInterceptor = false]) 方法用于以错误方式完成请求，不再执行其他请求和响应拦截器。它接收一个 DioError 参数表示错误信息，以及一个可选的布尔值 callFollowingErrorInterceptor，表示是否继续调用后续的错误拦截器。调用该方法会将 error 封装成 InterceptorState<DioError> 对象并完成 Completer，表示请求拦截器的处理结果为以错误方式完成请求。如果 callFollowingErrorInterceptor 为 true，则状态类型为 InterceptorResultType.rejectCallFollowing，否则为 InterceptorResultType.reject。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。

通过调用这些方法，可以控制请求拦截器的处理流程，包括继续执行下一个拦截器、直接返回响应结果或以错误方式完成请求。这样可以灵活地处理请求拦截器的逻辑和流程。

ResponseInterceptorHandler

class ResponseInterceptorHandler extends _BaseHandler {
  /// Continue to call the next response interceptor.
  void next(Response response) {
    _completer.complete(
      InterceptorState<Response>(response),
    );
    _processNextInQueue?.call();
  }

  /// Return the response directly! Other response i02
  void resolve(Response response) {
    _completer.complete(
      InterceptorState<Response>(
        response,
        InterceptorResultType.resolve,
      ),
    );
    _processNextInQueue?.call();
  }

  /// Complete the request with an error! Other response interceptor(s) will not
  /// be executed, but error interceptor(s) may be executed, which depends on whether the
  /// value of parameter [callFollowingErrorInterceptor] is true.
  ///
  /// [error]: Error info to reject.
  /// [callFollowingErrorInterceptor]: Whether to call the error interceptor(s).
  void reject(DioError error, [bool callFollowingErrorInterceptor = false]) {
    _completer.completeError(
      InterceptorState<DioError>(
        error,
        callFollowingErrorInterceptor
            ? InterceptorResultType.rejectCallFollowing
            : InterceptorResultType.reject,
      ),
      error.stackTrace,
    );
    _processNextInQueue?.call();
  }
}

这段代码定义了 ResponseInterceptorHandler 类，该类同样继承自 _BaseHandler。ResponseInterceptorHandler 类用于处理响应拦截器的操作，并提供了几个方法来控制响应的处理流程。

next(Response response) 方法用于继续调用下一个响应拦截器。它接收一个 Response 参数，表示响应对象。调用该方法会将 response 封装成 InterceptorState<Response> 对象并完成 Completer，表示响应拦截器的处理结果为继续执行下一个拦截器。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
resolve(Response response) 方法用于直接返回响应结果，不再执行其他响应拦截器。它接收一个 Response 参数表示响应对象。调用该方法会将 response 封装成 InterceptorState<Response> 对象并完成 Completer，表示响应拦截器的处理结果为直接返回响应。状态类型为 InterceptorResultType.resolve。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
reject(DioError error, [bool callFollowingErrorInterceptor = false]) 方法用于以错误方式完成响应，不再执行其他响应拦截器。它接收一个 DioError 参数表示错误信息，以及一个可选的布尔值 callFollowingErrorInterceptor，表示是否继续调用后续的错误拦截器。调用该方法会将 error 封装成 InterceptorState<DioError> 对象并完成 Completer，表示响应拦截器的处理结果为以错误方式完成响应。如果 callFollowingErrorInterceptor 为 true，则状态类型为 InterceptorResultType.rejectCallFollowing，否则为 InterceptorResultType.reject。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。

通过调用这些方法，可以控制响应拦截器的处理流程，包括继续执行下一个拦截器、直接返回响应结果或以错误方式完成响应。这样可以灵活地处理响应拦截器的逻辑和流程。

ErrorInterceptorHandler

class ErrorInterceptorHandler extends _BaseHandler {
  /// Continue to call the next error interceptor.
  void next(DioError err) {
    _completer.completeError(
      InterceptorState<DioError>(err),
      err.stackTrace,
    );
    _processNextInQueue?.call();
  }

  /// Complete the request with Response object and other error interceptor(s) will not be executed.
  /// This will be considered a successful request!
  ///
  /// [response]: Response object to return.
  void resolve(Response response) {
    _completer.complete(
      InterceptorState<Response>(
        response,
        InterceptorResultType.resolve,
      ),
    );
    _processNextInQueue?.call();
  }

  /// Complete the request with a error directly! Other error interceptor(s) will not be executed.
  void reject(DioError error) {
    _completer.completeError(
      InterceptorState<DioError>(
        error,
        InterceptorResultType.reject,
      ),
      error.stackTrace,
    );
    _processNextInQueue?.call();
  }
}

这段代码定义了 ErrorInterceptorHandler 类，该类同样继承自 _BaseHandler。ErrorInterceptorHandler 类用于处理错误拦截器的操作，并提供了几个方法来控制错误的处理流程。

next(DioError err) 方法用于继续调用下一个错误拦截器。它接收一个 DioError 参数，表示错误信息。调用该方法会将 err 封装成 InterceptorState<DioError> 对象并以错误方式完成 Completer，表示错误拦截器的处理结果为继续执行下一个拦截器。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
resolve(Response response) 方法用于以响应对象的方式完成请求，且不再执行其他错误拦截器。它接收一个 Response 参数表示响应对象。调用该方法会将 response 封装成 InterceptorState<Response> 对象并完成 Completer，表示错误拦截器的处理结果为以响应对象的方式完成请求。状态类型为 InterceptorResultType.resolve。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。
reject(DioError error) 方法用于直接以错误方式完成请求，且不再执行其他错误拦截器。它接收一个 DioError 参数表示错误信息。调用该方法会将 error 封装成 InterceptorState<DioError> 对象并以错误方式完成 Completer，表示错误拦截器的处理结果为以错误方式完成请求。状态类型为 InterceptorResultType.reject。同时，它会调用 _processNextInQueue 函数来触发执行下一个拦截器。