request method

  1. @override
Future<AdapterResponse> request(
  1. AdapterRequest request
)
override

Executes an HTTP request.

This is the core method that performs the actual HTTP request using the underlying HTTP client library.

Parameters:

  • request: The request configuration containing URL, method, headers, body, etc.

Returns a Future that completes with an AdapterResponse containing the response data, status code, headers, etc.

Throws AdapterException if the request fails due to timeout, network error, or other issues.

Example:

final request = AdapterRequest(
  baseUrl: 'https://api.example.com',
  path: '/users/123',
  method: HttpMethod.get,
);
final response = await adapter.request(request);
print('Status: ${response.statusCode}');
print('Data: ${response.data}');

Implementation

@override
Future<AdapterResponse> request(AdapterRequest request) async {
  // 创建 Completer 用于取消 / Create Completer for cancellation
  final completer = Completer<AdapterResponse>();

  // 如果有 cancelToken，注册取消回调
  if (request.cancelToken != null) {
    _registerCancelToken(request.cancelToken!, completer);

    // 如果已经取消，立即抛出异常
    if (request.cancelToken!.isCancelled) {
      throw AdapterException(
        type: AdapterExceptionType.cancel,
        message: request.cancelToken!.cancelReason ?? 'Request cancelled',
      );
    }
  }

  try {
    // 执行请求拦截器
    var modifiedRequest = request;
    for (final interceptor in _interceptors) {
      final handler = RequestInterceptorHandler();
       interceptor.onRequest(modifiedRequest, handler);

      if (handler.resolvedResponse != null) {
        _unregisterCancelToken(request.cancelToken, completer);
        return handler.resolvedResponse!;
      }
      if (handler.rejectedError != null) {
        _unregisterCancelToken(request.cancelToken, completer);
        throw handler.rejectedError!;
      }
      if (handler.modifiedRequest != null) {
        modifiedRequest = handler.modifiedRequest!;
      }
    }

    // 构建 URI
    final uri = _buildUri(modifiedRequest);

    // 构建头部
    final headers = _buildHeaders(modifiedRequest);

    // 构建请求体
    final body = _buildBody(modifiedRequest);

    // 执行 HTTP 请求（使用 Future.any 支持取消）
    http.Response httpResponse;
    final requestFuture = _executeRequest(modifiedRequest.method, uri, headers, body);

    if (request.cancelToken != null) {
      httpResponse = await Future.any([
        requestFuture,
        completer.future.then((_) => throw AdapterException(
          type: AdapterExceptionType.cancel,
          message: request.cancelToken!.cancelReason ?? 'Request cancelled',
        )),
      ]);
    } else {
      httpResponse = await requestFuture;
    }

    // 转换响应
    var response = _convertFromHttpResponse(httpResponse, modifiedRequest);

    // 检查是否是错误响应
    if (!response.isSuccess) {
      final exception = AdapterException(
        message: 'HTTP ${response.statusCode}: ${response.statusMessage ?? ""}',
        type: AdapterExceptionType.response,
        statusCode: response.statusCode,
        response: response,
      );

      // 执行错误拦截器
      var modifiedException = exception;
      for (final interceptor in _interceptors) {
        final handler = ErrorInterceptorHandler();
         interceptor.onError(modifiedException, handler);

        if (handler.resolvedResponse != null) {
          _unregisterCancelToken(request.cancelToken, completer);
          return handler.resolvedResponse!;
        }
        if (handler.modifiedError != null) {
          modifiedException = handler.modifiedError!;
        }
      }

      _unregisterCancelToken(request.cancelToken, completer);
      throw modifiedException;
    }

    // 执行响应拦截器
    for (final interceptor in _interceptors) {
      final handler = ResponseInterceptorHandler();
       interceptor.onResponse(response, handler);

      if (handler.rejectedError != null) {
        _unregisterCancelToken(request.cancelToken, completer);
        throw handler.rejectedError!;
      }
      if (handler.modifiedResponse != null) {
        response = handler.modifiedResponse!;
      }
    }

    _unregisterCancelToken(request.cancelToken, completer);
    return response;
  } on AdapterException {
    _unregisterCancelToken(request.cancelToken, completer);
    rethrow;
  } catch (e, stackTrace) {
    _unregisterCancelToken(request.cancelToken, completer);
    var exception = _convertException(e, stackTrace);

    // 执行错误拦截器
    for (final interceptor in _interceptors) {
      final handler = ErrorInterceptorHandler();
       interceptor.onError(exception, handler);

      if (handler.resolvedResponse != null) {
        return handler.resolvedResponse!;
      }
      if (handler.modifiedError != null) {
        exception = handler.modifiedError!;
      }
    }

    throw exception;
  }
}