• options 参数详解
    • HttpClient 默认全局配置
    • data: Object
    • dataAsQueryString: Boolean
    • content: String|Buffer
    • files: Mixed
    • stream: ReadStream
    • writeStream: WriteStream
    • consumeWriteStream: Boolean
    • method: String
    • contentType: String
    • dataType: String
    • fixJSONCtlChars: Boolean
    • headers: Object
    • timeout: Number|Array
    • agent: HttpAgent
    • httpsAgent: HttpsAgent
    • auth: String
    • digestAuth: String
    • followRedirect: Boolean
    • maxRedirects: Number
    • formatRedirectUrl: Function(from, to)
    • beforeRequest: Function(options)
    • streaming: Boolean
    • gzip: Boolean
    • timing: Boolean
    • ca，rejectUnauthorized，pfx，key，cert，passphrase，ciphers，secureProtocol

    options 参数详解

    由于 HTTP 请求的复杂性，导致 httpclient.request(url, options) 的 options 参数会非常多。接下来将会以参数说明和代码配合一起讲解每个可选参数的实际用途。

    HttpClient 默认全局配置

    1. // config/config.default.js
    2. exports.httpclient = {
    3.   // 是否开启本地 DNS 缓存，默认关闭，开启后有两个特性
    4.   // 1. 所有的 DNS 查询都会默认优先使用缓存的，即使 DNS 查询错误也不影响应用
    5.   // 2. 对同一个域名，在 dnsCacheLookupInterval 的间隔内（默认 10s）只会查询一次
    6.   enableDNSCache: false,
    7.   // 对同一个域名进行 DNS 查询的最小间隔时间
    8.   dnsCacheLookupInterval: 10000,
    9.   // DNS 同时缓存的最大域名数量，默认 1000
    10.   dnsCacheMaxLength: 1000,
    12.   request: {
    13.     // 默认 request 超时时间
    14.     timeout: 3000,
    15.   },
    17.   httpAgent: {
    18.     // 默认开启 http KeepAlive 功能
    19.     keepAlive: true,
    20.     // 空闲的 KeepAlive socket 最长可以存活 4 秒
    21.     freeSocketTimeout: 4000,
    22.     // 当 socket 超过 30 秒都没有任何活动，就会被当作超时处理掉
    23.     timeout: 30000,
    24.     // 允许创建的最大 socket 数
    25.     maxSockets: Number.MAX_SAFE_INTEGER,
    26.     // 最大空闲 socket 数
    27.     maxFreeSockets: 256,
    28.   },
    30.   httpsAgent: {
    31.     // 默认开启 https KeepAlive 功能
    32.     keepAlive: true,
    33.     // 空闲的 KeepAlive socket 最长可以存活 4 秒
    34.     freeSocketTimeout: 4000,
    35.     // 当 socket 超过 30 秒都没有任何活动，就会被当作超时处理掉
    36.     timeout: 30000,
    37.     // 允许创建的最大 socket 数
    38.     maxSockets: Number.MAX_SAFE_INTEGER,
    39.     // 最大空闲 socket 数
    40.     maxFreeSockets: 256,
    41.   },
    42. };

    应用可以通过 config/config.default.js 覆盖此配置。

    data: Object

    需要发送的请求数据，根据 method 自动选择正确的数据处理方式。

    • GET，HEAD：通过 querystring.stringify(data) 处理后拼接到 url 的 query 参数上。
    • POST，PUT 和 DELETE 等：需要根据 contentType 做进一步判断处理。
      • contentType = json：通过 JSON.stringify(data) 处理，并设置为 body 发送。
      • 其他：通过 querystring.stringify(data) 处理，并设置为 body 发送。
    1. // GET + data
    2. ctx.curl(url, {
    3.   data: { foo: 'bar' },
    4. });
    6. // POST + data
    7. ctx.curl(url, {
    8.   method: 'POST',
    9.   data: { foo: 'bar' },
    10. });
    12. // POST + JSON + data
    13. ctx.curl(url, {
    14.   method: 'POST',
    15.   contentType: 'json',
    16.   data: { foo: 'bar' },
    17. });

    dataAsQueryString: Boolean

    如果设置了 dataAsQueryString=true，那么即使在 POST 情况下，也会强制将 options.data 以 querystring.stringify 处理之后拼接到 url 的 query 参数上。

    可以很好地解决以 stream 发送数据，且额外的请求参数以 url query 形式传递的应用场景：

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   dataAsQueryString: true,
    4.   data: {
    5.     // 一般来说都是 access token 之类的权限验证参数
    6.     accessToken: 'some access token value',
    7.   },
    8.   stream: myFileStream,
    9. });

    content: String|Buffer

    发送请求正文，如果设置了此参数，那么会直接忽略 data 参数。

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   // 直接发送原始 xml 数据，不需要 HttpClient 做特殊处理
    4.   content: '<xml><hello>world</hello></xml>',
    5.   headers: {
    6.     'content-type': 'text/html',
    7.   },
    8. });

    files: Mixed

    文件上传，支持格式： String | ReadStream | Buffer | Array | Object。

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   files: '/path/to/read',
    4.   data: {
    5.     foo: 'other fields',
    6.   },
    7. });

    多文件上传：

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   files: {
    4.     file1: '/path/to/read',
    5.     file2: fs.createReadStream(__filename),
    6.     file3: Buffer.from('mock file content'),
    7.   },
    8.   data: {
    9.     foo: 'other fields',
    10.   },
    11. });

    stream: ReadStream

    设置发送请求正文的可读数据流，默认是 null。一旦设置了此参数，HttpClient 将会忽略 data 和 content。

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   stream: fs.createReadStream('/path/to/read'),
    4. });

    writeStream: WriteStream

    设置接受响应数据的可写数据流，默认是 null。一旦设置此参数，那么返回值 result.data 将会被设置为 null，因为数据已经全部写入到 writeStream 中了。

    1. ctx.curl(url, {
    2.   writeStream: fs.createWriteStream('/path/to/store'),
    3. });

    consumeWriteStream: Boolean

    是否等待 writeStream 完全写完才算响应全部接收完毕，默认是 true。此参数不建议修改默认值，除非我们明确知道它的副作用是可接受的，否则很可能会导致 writeStream 数据不完整。

    method: String

    设置请求方法，默认是 GET。支持 GET、POST、PUT、DELETE、PATCH 等所有 HTTP 方法。

    contentType: String

    设置请求数据格式，默认是 undefined，HttpClient 会自动根据 data 和 content 参数自动设置。data 是 object 的时候默认设置的是 form。支持 json 格式。

    如需要以 JSON 格式发送 data：

    1. ctx.curl(url, {
    2.   method: 'POST',
    3.   data: {
    4.     foo: 'bar',
    5.     now: Date.now(),
    6.   },
    7.   contentType: 'json',
    8. });

    dataType: String

    设置响应数据格式，默认不对响应数据做任何处理，直接返回原始的 buffer 格式数据。支持 text 和 json 两种格式。

    注意：设置成 json 时，如果响应数据解析失败会抛 JSONResponseFormatError 异常。

    1. const jsonResult = await ctx.curl(url, {
    2.   dataType: 'json',
    3. });
    4. console.log(jsonResult.data);
    6. const htmlResult = await ctx.curl(url, {
    7.   dataType: 'text',
    8. });
    9. console.log(htmlResult.data);

    fixJSONCtlChars: Boolean

    是否自动过滤响应数据中的特殊控制字符 (U+0000 ~ U+001F)，默认是 false。通常一些 CGI 系统返回的 JSON 数据会包含这些特殊控制字符，通过此参数可以自动过滤掉它们。

    1. ctx.curl(url, {
    2.   fixJSONCtlChars: true,
    3.   dataType: 'json',
    4. });

    headers: Object

    自定义请求头。

    1. ctx.curl(url, {
    2.   headers: {
    3.     'x-foo': 'bar',
    4.   },
    5. });

    timeout: Number|Array

    请求超时时间，默认是 [ 5000, 5000 ]，即创建连接超时是 5 秒，接收响应超时是 5 秒。

    1. ctx.curl(url, {
    2.   // 创建连接超时 3 秒，接收响应超时 3 秒
    3.   timeout: 3000,
    4. });
    6. ctx.curl(url, {
    7.   // 创建连接超时 1 秒，接收响应超时 30 秒，用于响应比较大的场景
    8.   timeout: [ 1000, 30000 ],
    9. });

    agent: HttpAgent

    允许通过此参数覆盖默认的 HttpAgent，如果你不想开启 KeepAlive，可以设置此参数为 false。

    1. ctx.curl(url, {
    2.   agent: false,
    3. });

    httpsAgent: HttpsAgent

    允许通过此参数覆盖默认的 HttpsAgent，如果你不想开启 KeepAlive，可以设置此参数为 false。

    1. ctx.curl(url, {
    2.   httpsAgent: false,
    3. });

    auth: String

    简单登录授权（Basic Authentication）参数，将以明文方式将登录信息以 Authorization 请求头发送出去。

    1. ctx.curl(url, {
    2.   // 参数必须按照 `user:password` 格式设置
    3.   auth: 'foo:bar',
    4. });

    digestAuth: String

    摘要登录授权（Digest Authentication）参数，设置此参数会自动对 401 响应尝试生成 Authorization 请求头，尝试以授权方式请求一次。

    1. ctx.curl(url, {
    2.   // 参数必须按照 `user:password` 格式设置
    3.   digestAuth: 'foo:bar',
    4. });

    followRedirect: Boolean

    是否自动跟进 3xx 的跳转响应，默认是 false。

    1. ctx.curl(url, {
    2.   followRedirect: true,
    3. });

    maxRedirects: Number

    设置最大自动跳转次数，避免循环跳转无法终止，默认是 10 次。此参数不宜设置过大，它只在 followRedirect=true 情况下才会生效。

    1. ctx.curl(url, {
    2.   followRedirect: true,
    3.   // 最大只允许自动跳转 5 次。
    4.   maxRedirects: 5,
    5. });

    formatRedirectUrl: Function(from, to)

    允许我们通过 formatRedirectUrl 自定义实现 302、301 等跳转 url 拼接， 默认是 url.resolve(from, to)。

    1. ctx.curl(url, {
    2.   formatRedirectUrl: (from, to) => {
    3.     // 例如可在这里修正跳转不正确的 url
    4.     if (to === '//foo/') {
    5.       to = '/foo';
    6.     }
    7.     return url.resolve(from, to);
    8.   },
    9. });

    beforeRequest: Function(options)

    HttpClient 在请求正式发送之前，会尝试调用 beforeRequest 钩子，允许我们在这里对请求参数做最后一次修改。

    1. ctx.curl(url, {
    2.   beforeRequest: options => {
    3.     // 例如我们可以设置全局请求 id，方便日志跟踪
    4.     options.headers['x-request-id'] = uuid.v1();
    5.   },
    6. });

    streaming: Boolean

    是否直接返回响应流，默认为 false。开启 streaming 之后，HttpClient 会在拿到响应对象 res 之后马上返回，此时 result.headers 和 result.status 已经可以读取到，只是没有读取 data 数据而已。

    1. const result = await ctx.curl(url, {
    2.   streaming: true,
    3. });
    5. console.log(result.status, result.data);
    6. // result.res 是一个 ReadStream 对象
    7. ctx.body = result.res;

    注意：如果 res 不是直接传递给 body，那么我们必须消费这个 stream，并且要做好 error 事件处理。

    gzip: Boolean

    是否支持 gzip 响应格式，默认为 false。开启 gzip 之后，HttpClient 将自动设置 Accept-Encoding: gzip 请求头，并且会自动解压带 Content-Encoding: gzip 响应头的数据。

    1. ctx.curl(url, {
    2.   gzip: true,
    3. });

    timing: Boolean

    是否开启请求各阶段的时间测量，默认为 false。开启 timing 之后，可以通过 result.res.timing 拿到这次 HTTP 请求各阶段的时间测量值（单位是毫秒），通过这些测量值，我们可以非常方便地定位到这次请求最慢的环境发生在那个阶段，效果如同 Chrome network timing 的作用。

    timing 各阶段测量值解析：

    • queuing：分配 socket 耗时
    • dnslookup：DNS 查询耗时
    • connected：socket 三次握手连接成功耗时
    • requestSent：请求数据完整发送完毕耗时
    • waiting：收到第一个字节的响应数据耗时
    • contentDownload：全部响应数据接收完毕耗时
    1. const result = await ctx.curl(url, {
    2.   timing: true,
    3. });
    4. console.log(result.res.timing);
    5. // {
    6. //   "queuing":29,
    7. //   "dnslookup":37,
    8. //   "connected":370,
    9. //   "requestSent":1001,
    10. //   "waiting":1833,
    11. //   "contentDownload":3416
    12. // }

    ca，rejectUnauthorized，pfx，key，cert，passphrase，ciphers，secureProtocol

    这几个都是透传给 [HTTPS] 模块的参数，具体请查看 https.request(options, callback)。