拦截器
/// Dio instance may have one or more interceptors by which you can intercept
/// requests/responses/errors before they are handled by `then` or `catchError`.
///
/// Interceptors are called once per request and response. That means that redirects
/// aren't triggering interceptors.
///
/// See also:
/// - [InterceptorsWrapper] A helper class to create Interceptor(s).
/// - [QueuedInterceptor] Serialize the request/response/error before they enter the interceptor.
/// - [QueuedInterceptorsWrapper] A helper class to create QueuedInterceptor(s).
Dio 实例可能具有一个或多个拦截器，通过这些拦截器，您可以在请求/响应/错误被 then 或 catchError 处理之前拦截它们。
拦截器在每次请求和响应时被调用，这意味着重定向不会触发拦截器。
在 Dio 中，拦截器是一种强大的机制，它允许您在发出请求或处理响应时执行一些通用的逻辑，例如添加请求头、记录请求和响应日志、对响应进行统一处理等。拦截器可以在请求发送前（请求拦截器）、请求响应后（响应拦截器）和处理错误时（错误拦截器）执行。
Dio 中的拦截器可以通过 Interceptors 字段来管理，它包含了一个 Interceptors 实例，该实例中包含了所有的拦截器。您可以向 Interceptors 实例中添加自定义的拦截器，每个拦截器都需要实现相应的回调方法来处理请求、响应和错误。
除了普通拦截器外，还有一种叫做 QueuedInterceptor 的特殊拦截器，它可以序列化请求、响应或错误，确保它们在进入拦截器之前按照添加的顺序依次执行。
如果您想要创建和使用拦截器，可以使用 InterceptorsWrapper 和 QueuedInterceptorsWrapper 这两个辅助类。这些辅助类可以帮助您创建拦截器，并将它们添加到 Dio 实例中，使得拦截器的管理更加简便。
总之，拦截器是 Dio 中的重要特性，它们提供了一种灵活和可扩展的方式来处理请求、响应和错误，使得网络请求的处理更加方便和高效
Interceptor
class Interceptor {
const Interceptor();
/// The callback will be executed before the request is initiated.
///
/// If you want to continue the request, call [handler.next].
///
/// If you want to complete the request with some custom data，
/// you can resolve a [Response] object with [handler.resolve].
///
/// If you want to complete the request with an error message,
/// you can reject a [DioError] object with [handler.reject].
void onRequest(
RequestOptions options,
RequestInterceptorHandler handler,
) {
handler.next(options);
}
/// The callback will be executed on success.
/// If you want to continue the response, call [handler.next].
///
/// If you want to complete the response with some custom data directly,
/// you can resolve a [Response] object with [handler.resolve] and other
/// response interceptor(s) will not be executed.
///
/// If you want to complete the response with an error message,
/// you can reject a [DioError] object with [handler.reject].
void onResponse(
Response response,
ResponseInterceptorHandler handler,
) {
handler.next(response);
}
/// The callback will be executed on error.
///
/// If you want to continue the error , call [handler.next].
///
/// If you want to complete the response with some custom data directly,
/// you can resolve a [Response] object with [handler.resolve] and other
/// error interceptor(s) will be skipped.
///
/// If you want to complete the response with an error message directly,
/// you can reject a [DioError] object with [handler.reject], and other
/// error interceptor(s) will be skipped.
void onError(
DioError err,
ErrorInterceptorHandler handler,
) {
handler.next(err);
}
}
这是一个抽象的 Interceptor 类，用于定义拦截器的回调方法。拦截器是 Dio 中用于拦截请求、响应和错误的回调函数，您可以在这些回调函数中执行自定义的逻辑，并决定是否继续请求/响应或者完成请求/响应。
拦截器提供了三个回调方法：
onRequest: 这个回调方法在请求发起之前执行，允许您在请求被发送之前处理请求选项。如果您想要继续请求，可以调用handler.next(options)；如果您想要在这里就完成请求，可以使用handler.resolve(response)来返回一个自定义的响应；如果请求出现错误，可以使用handler.reject(error)来返回一个自定义的错误。onResponse: 这个回调方法在请求成功后执行，允许您在处理响应之前执行一些操作。如果您想要继续响应处理，可以调用handler.next(response)；如果您想要在这里就完成响应，可以使用handler.resolve(response)来返回一个自定义的响应，其他的响应拦截器将不再执行；如果响应出现错误，可以使用handler.reject(error)来返回一个自定义的错误，其他的响应拦截器将不再执行。onError: 这个回调方法在请求或响应发生错误时执行，允许您在处理错误之前执行一些操作。如果您想要继续处理错误，可以调用handler.next(err)；如果您想要在这里就完成错误处理，可以使用handler.resolve(response)来返回一个自定义的响应，其他的错误拦截器将不再执行；如果错误需要终止请求或响应处理，可以使用handler.reject(error)来返回一个自定义的错误，其他的错误拦截器将不再执行。
在这些回调方法中，您可以根据具体的业务需求，执行各种操作，例如添加请求头、记录请求和响应日志、对响应进行统一处理、处理特定的错误等。
此处的 Interceptor 类是一个抽象类，它定义了这些回调方法的签名，您可以根据自己的需求继承这个类并实现相应的回调方法，然后将其添加到 Dio 实例的拦截器列表中，从而实现拦截器的功能。
InterceptorSendCallback
typedef InterceptorSendCallback = void Function(
RequestOptions options,
RequestInterceptorHandler handler,
);
InterceptorSuccessCallback
typedef InterceptorSuccessCallback = void Function(
Response<dynamic> e,
ResponseInterceptorHandler handler,
);
InterceptorErrorCallback
typedef InterceptorErrorCallback = void Function(
DioError e,
ErrorInterceptorHandler handler,
);
_InterceptorWrapperMixin
mixin _InterceptorWrapperMixin on Interceptor {
InterceptorSendCallback? _onRequest;
InterceptorSuccessCallback? _onResponse;
InterceptorErrorCallback? _onError;
@override
void onRequest(
RequestOptions options,
RequestInterceptorHandler handler,
) {
if (_onRequest != null) {
_onRequest!(options, handler);
} else {
handler.next(options);
}
}
@override
void onResponse(
Response<dynamic> response,
ResponseInterceptorHandler handler,
) {
if (_onResponse != null) {
_onResponse!(response, handler);
} else {
handler.next(response);
}
}
@override
void onError(
DioError err,
ErrorInterceptorHandler handler,
) {
if (_onError != null) {
_onError!(err, handler);
} else {
handler.next(err);
}
}
}
这是一个 _InterceptorWrapperMixin，它是一个 mixin（混入），用于在现有的 Interceptor 类上添加一些额外的功能。通过使用 mixin，我们可以将一些通用的逻辑封装在 mixin 中，然后通过混入到其他类中，使其具有这些功能。
在这个 _InterceptorWrapperMixin 中，定义了三个可选的回调属性 _onRequest、_onResponse 和 _onError，它们分别对应 onRequest、onResponse 和 onError 这三个回调方法。当这些回调方法被触发时，会先检查是否有对应的回调属性，如果有的话，就执行相应的回调方法；如果没有，则调用 super 关键字来执行原来 Interceptor 类中定义的回调方法。
这个 mixin 的作用是允许您在 Interceptor 类的基础上添加一些特定的回调逻辑，而不需要重新实现整个 Interceptor 类。通过使用 mixin，可以使代码更具可组合性和可维护性，使得在不同的场景下可以很方便地定制拦截器的行为。
InterceptorsWrapper
/// [InterceptorsWrapper] is a helper class, which is used to conveniently
/// create interceptor(s).
/// See also:
/// - [Interceptor]
/// - [QueuedInterceptor] Serialize the request/response/error before they enter the interceptor.
/// - [QueuedInterceptorsWrapper] A helper class to create QueuedInterceptor(s).
class InterceptorsWrapper extends Interceptor with _InterceptorWrapperMixin {
InterceptorsWrapper({
InterceptorSendCallback? onRequest,
InterceptorSuccessCallback? onResponse,
InterceptorErrorCallback? onError,
}) : __onRequest = onRequest,
__onResponse = onResponse,
__onError = onError;
@override
InterceptorSendCallback? get _onRequest => __onRequest;
final InterceptorSendCallback? __onRequest;
@override
InterceptorSuccessCallback? get _onResponse => __onResponse;
final InterceptorSuccessCallback? __onResponse;
@override
InterceptorErrorCallback? get _onError => __onError;
final InterceptorErrorCallback? __onError;
}
InterceptorsWrapper 是一个帮助类，用于方便地创建拦截器（Interceptor）。它继承自 Interceptor 并混入了 _InterceptorWrapperMixin，通过使用 _InterceptorWrapperMixin 可以方便地在 InterceptorsWrapper 上添加自定义的拦截逻辑。
在构造函数中，InterceptorsWrapper 接受三个可选的回调参数 onRequest、onResponse 和 onError，它们分别对应 Interceptor 的 onRequest、onResponse 和 onError 回调方法。通过传入这些回调参数，可以在创建 InterceptorsWrapper 实例时，定制它的拦截行为。
在 InterceptorsWrapper 类中，通过三个私有属性 __onRequest、__onResponse 和 __onError 来存储传入的回调参数。然后，在 _onRequest、_onResponse 和 _onError 这三个方法中，分别返回对应的私有属性值，以实现在 Interceptor 中添加自定义的拦截逻辑。
