在flatterhttp请求中为所有请求设置默认头的最佳方法

很抱歉，如果这个问题这么简单，但是我是一个新手，最近找不到一个在HTTP请求中设置默认头的好方法。我可以扩展这个类或将一个函数包装到它，但不应该有一个简单的方法内置，但我在文档中找不到它

这可以通过Dio软件包轻松实现

更新

基于新的Dio API：

var dio = Dio();
dio.interceptors.add(InterceptorsWrapper(onRequest: (RequestOptions options) async {
  var customHeaders = {
    'content-type': 'application/json'
    // other headers
  };
  options.headers.addAll(customHeaders);
  return options;
}));

Response response = await dio.get("url");
print(response.data.toString());

有关更多详细信息，请参阅。

注册自定义HttpClientFactory Dart允许注册工厂以创建

HttpClient

class MyHttpOverrides extends HttpOverrides {
  @override
  HttpClient createHttpClient(SecurityContext context) {
    return new MyHttpClient(super.createHttpClient(context));
  }
}

void main() {
  HttpOverrides.global = new MyHttpOverrides();
  runApp(MyApp());
}

实现自定义HttpClient 实现这样一个定制的

HttpClient

似乎过于复杂，但也许有更好的方法

该类从

dart:io

及其所有抽象类实现

HttpClient

方法

get（…）

和

getUrl（…）

被定制为使用

\u updateHeaders（…）

添加自定义头。您需要将其扩展到所有其他方法，如

head

，

headUrl

，

open

，

post

import 'dart:io';

class MyHttpClient implements HttpClient {
  HttpClient _realClient;

  MyHttpClient(this._realClient);

  @override
  bool get autoUncompress => _realClient.autoUncompress;

  @override
  set autoUncompress(bool value) => _realClient.autoUncompress = value;

  @override
  Duration get connectionTimeout => _realClient.connectionTimeout;

  @override
  set connectionTimeout(Duration value) =>
      _realClient.connectionTimeout = value;

  @override
  Duration get idleTimeout => _realClient.idleTimeout;

  @override
  set idleTimeout(Duration value) => _realClient.idleTimeout = value;

  @override
  int get maxConnectionsPerHost => _realClient.maxConnectionsPerHost;

  @override
  set maxConnectionsPerHost(int value) =>
      _realClient.maxConnectionsPerHost = value;

  @override
  String get userAgent => _realClient.userAgent;

  @override
  set userAgent(String value) => _realClient.userAgent = value;

  @override
  void addCredentials(
          Uri url, String realm, HttpClientCredentials credentials) =>
      _realClient.addCredentials(url, realm, credentials);

  @override
  void addProxyCredentials(String host, int port, String realm,
          HttpClientCredentials credentials) =>
      _realClient.addProxyCredentials(host, port, realm, credentials);

  @override
  void set authenticate(
          Future<bool> Function(Uri url, String scheme, String realm) f) =>
      _realClient.authenticate = f;

  @override
  void set authenticateProxy(
          Future<bool> Function(
                  String host, int port, String scheme, String realm)
              f) =>
      _realClient.authenticateProxy = f;

  @override
  void set badCertificateCallback(
          bool Function(X509Certificate cert, String host, int port)
              callback) =>
      _realClient.badCertificateCallback = callback;

  @override
  void close({bool force = false}) => _realClient.close(force: force);

  @override
  Future<HttpClientRequest> delete(String host, int port, String path) =>
      _realClient.delete(host, port, path);

  @override
  Future<HttpClientRequest> deleteUrl(Uri url) => _realClient.deleteUrl(url);

  @override
  void set findProxy(String Function(Uri url) f) => _realClient.findProxy = f;

  @override
  Future<HttpClientRequest> get(String host, int port, String path) =>
      _updateHeaders(_realClient.get(host, port, path));

  Future<HttpClientRequest> _updateHeaders(
      Future<HttpClientRequest> httpClientRequest) async {
    return (await httpClientRequest)..headers.add('foo', 'bar');
  }

  @override
  Future<HttpClientRequest> getUrl(Uri url) =>
      _updateHeaders(_realClient.getUrl(url.replace(path: url.path)));

  @override
  Future<HttpClientRequest> head(String host, int port, String path) =>
      _realClient.head(host, port, path);

  @override
  Future<HttpClientRequest> headUrl(Uri url) => _realClient.headUrl(url);

  @override
  Future<HttpClientRequest> open(
          String method, String host, int port, String path) =>
      _realClient.open(method, host, port, path);

  @override
  Future<HttpClientRequest> openUrl(String method, Uri url) =>
      _realClient.openUrl(method, url);

  @override
  Future<HttpClientRequest> patch(String host, int port, String path) =>
      _realClient.patch(host, port, path);

  @override
  Future<HttpClientRequest> patchUrl(Uri url) => _realClient.patchUrl(url);

  @override
  Future<HttpClientRequest> post(String host, int port, String path) =>
      _realClient.post(host, port, path);

  @override
  Future<HttpClientRequest> postUrl(Uri url) => _realClient.postUrl(url);

  @override
  Future<HttpClientRequest> put(String host, int port, String path) =>
      _realClient.put(host, port, path);

  @override
  Future<HttpClientRequest> putUrl(Uri url) => _realClient.putUrl(url);
}

导入'dart:io'；
类MyHttpClient实现HttpClient{
HttpClient\u realClient；
MyHttpClient（此.\u realClient）；
@凌驾
bool get autoUncompress=>\u realClient.autoUncompress；
@凌驾
设置自动解压缩（bool值）=>\u realClient.autoUncompress=value；
@凌驾
持续时间get-connectionTimeout=>\u realClient.connectionTimeout；
@凌驾
设置connectionTimeout（持续时间值）=>
_realClient.connectionTimeout=值；
@凌驾
Duration get idleTimeout=>\u realClient.idleTimeout；
@凌驾
设置idleTimeout（持续时间值）=>\u realClient.idleTimeout=value；
@凌驾
int get maxConnectionsPerHost=>\u realClient.maxConnectionsPerHost；
@凌驾
设置maxConnectionsPerHost（int值）=>
_realClient.maxConnectionsPerHost=值；
@凌驾
字符串get userAgent=>\u realClient.userAgent；
@凌驾
设置userAgent（字符串值）=>\u realClient.userAgent=value；
@凌驾
无效添加凭据(
Uri url、字符串域、HttpClientCredentials凭据）=>
_addCredentials（url、领域、凭据）；
@凌驾
void addProxyCredentials（字符串主机、int端口、字符串域、，
HttpClientCredentials凭据）=>
_addProxyCredentials（主机、端口、领域、凭据）；
@凌驾
无效集验证(
未来函数（Uri url、字符串方案、字符串域）f）=>
_realClient.authenticate=f；
@凌驾
无效集authenticateProxy(
未来功能(
字符串主机、int端口、字符串方案、字符串域）
f） =>
_realClient.authenticateProxy=f；
@凌驾
无效设置坏证书回拨(
bool函数（X509证书证书证书、字符串主机、int端口）
回调）=>
_realClient.badCertificateCallback=回调；
@凌驾
void close（{bool force=false}）=>\u realClient.close（force:force）；
@凌驾
未来删除（字符串主机、int端口、字符串路径）=>
_删除（主机、端口、路径）；
@凌驾
未来删除url（Uri url）=>\u realClient.deleteUrl（url）；
@凌驾
void set findProxy（字符串函数（Uri url）f）=>\u realClient.findProxy=f；
@凌驾
未来获取（字符串主机、int端口、字符串路径）=>
_updateHeaders（_realClient.get（主机、端口、路径））；
未来的更新负责人(
未来httpClientRequest）异步{
返回（等待httpClientRequest）…标题。添加（'foo'，'bar'）；
}
@凌驾
未来的getUrl（Uri url）=>
_updateHeaders（_realClient.getUrl（url.replace（path:url.path））；
@凌驾
未来头（字符串主机、int端口、字符串路径）=>
_realClient.head（主机、端口、路径）；
@凌驾
未来的头url（Uri url）=>\u realClient.headUrl（url）；
@凌驾
未来开放(
字符串方法、字符串主机、int端口、字符串路径）=>
_open（方法、主机、端口、路径）；
@凌驾
未来的openUrl（字符串方法，Uri url）=>
_openUrl（方法，url）；
@凌驾
未来补丁（字符串主机、int端口、字符串路径）=>
_补丁（主机、端口、路径）；
@凌驾
未来的补丁url（Uri url）=>\u realClient.patchUrl（url）；
@凌驾
未来post（字符串主机、int端口、字符串路径）=>
_post（主机、端口、路径）；
@凌驾
Future postrl（uriurl）=>\u realClient.postrl（url）；
@凌驾
未来put（字符串主机、int端口、字符串路径）=>
_realClient.put（主机、端口、路径）；
@凌驾
未来putUrl（Uri url）=>\u realClient.putUrl（url）；
}

导入“包：http/http.dart”作为http；
类MyClient扩展了http.BaseClient{
http.Client _httpClient=新的http.Client（）；
MyClient（映射defaultHeaders）；
@凌驾
未来发送（http.BaseRequest）{
request.headers.addAll（defaultHeaders）；
返回\u httpClient.send（请求）；
}
}

仅扩展@Radek Manasek自定义

客户端的概念，我将覆盖所有方法，这样您就不必再次编写它们

import 'dart:convert';

import 'package:http/http.dart' as http;
import 'package:http/http.dart';

class MyClient extends http.BaseClient {
  final Map<String, String> _defaultHeaders;
  http.Client _httpClient = http.Client();

  MyClient(this._defaultHeaders);

  @override
  Future<http.StreamedResponse> send(http.BaseRequest request) {
    return _httpClient.send(request);
  }

  @override
  Future<Response> get(url, {Map<String, String> headers}) {
    return _httpClient.get(url, headers: _mergedHeaders(headers));
  }

  @override
  Future<Response> post(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.post(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> patch(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.patch(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> put(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.put(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> head(url, {Map<String, String> headers}) {
    return _httpClient.head(url, headers: _mergedHeaders(headers));
  }

  @override
  Future<Response> delete(url, {Map<String, String> headers}) {
    return _httpClient.delete(url, headers: _mergedHeaders(headers));
  }

  Map<String, String> _mergedHeaders(Map<String, String> headers) =>
      {...?_defaultHeaders, ...?headers};
}

导入'dart:convert'；
将“package:http/http.dart”导入为http；
导入“包：http/http.dart”；
类MyClient扩展了http.BaseClient{
最终地图_defaultHeaders；
http.Client _httpClient=http.Client（）；
MyClient（此.\u defaultHeaders）；
@凌驾
未来发送（http.BaseRequest）{
返回\u httpClient.send（请求）；
}
@凌驾
未来获取（url，{Map headers}）{
返回httpClient.get（url，头：mergedHeaders（头））；
}
@凌驾
未来帖子（url，{映射头，动态正文，编码}）{
返回_httpClient.post（url，标题：_mergedHeaders（标题），正文：正文，编码：编码）；
}
@凌驾
未来补丁（url，{映射头，动态体，编码}）{
返回_httpClient.patch（url，头：_mergedHeaders（头），正文：正文，编码：编码）；
}
@凌驾
期货看跌期权(
import 'dart:convert';

import 'package:http/http.dart' as http;
import 'package:http/http.dart';

class MyClient extends http.BaseClient {
  final Map<String, String> _defaultHeaders;
  http.Client _httpClient = http.Client();

  MyClient(this._defaultHeaders);

  @override
  Future<http.StreamedResponse> send(http.BaseRequest request) {
    return _httpClient.send(request);
  }

  @override
  Future<Response> get(url, {Map<String, String> headers}) {
    return _httpClient.get(url, headers: _mergedHeaders(headers));
  }

  @override
  Future<Response> post(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.post(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> patch(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.patch(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> put(url, {Map<String, String> headers, dynamic body, Encoding encoding}) {
    return _httpClient.put(url, headers: _mergedHeaders(headers), body: body, encoding: encoding);
  }

  @override
  Future<Response> head(url, {Map<String, String> headers}) {
    return _httpClient.head(url, headers: _mergedHeaders(headers));
  }

  @override
  Future<Response> delete(url, {Map<String, String> headers}) {
    return _httpClient.delete(url, headers: _mergedHeaders(headers));
  }

  Map<String, String> _mergedHeaders(Map<String, String> headers) =>
      {...?_defaultHeaders, ...?headers};
}

var _dio = Dio();
_dio.options.headers= {"Authorization" : token};