Axios 源码笔记 | 深入剖析 Adapters 适配器源码，揭开请求处理的神秘面纱

import utils from '../utils.js';
import httpAdapter from './http.js';
import xhrAdapter from './xhr.js';
import fetchAdapter from './fetch.js';
import AxiosError from "../core/AxiosError.js";

const knownAdapters = {
  http: httpAdapter,
  xhr: xhrAdapter,
  fetch: fetchAdapter
}

utils.forEach(knownAdapters, (fn, value) => {
  if (fn) {
    try {
      Object.defineProperty(fn, 'name', {value});
    } catch (e) {
      // eslint-disable-next-line no-empty
    }
    Object.defineProperty(fn, 'adapterName', {value});
  }
});

export default {
  getAdapter: (adapters) => {
    adapters = utils.isArray(adapters) ? adapters : [adapters];
    const {length} = adapters;
    let nameOrAdapter;
    let adapter;
    const rejectedReasons = {};

    for (let i = 0; i < length; i++) {
      nameOrAdapter = adapters[i];
      let id;
      adapter = nameOrAdapter;

      if (!isResolvedHandle(nameOrAdapter)) {
        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
        if (adapter === undefined) {
          throw new AxiosError(`Unknown adapter '${id}'`);
        }
      }

      if (adapter) {
        break;
      }

      rejectedReasons[id || '#' + i] = adapter;
    }

    if (!adapter) {
      const reasons = Object.entries(rejectedReasons)
        .map(([id, state]) => `adapter ${id} ` +
          (state === false ? 'is not supported by the environment' : 'is not available in the build')
        );
      let s = length ?
        (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
        'as no adapter specified';

      throw new AxiosError(
        `There is no suitable adapter to dispatch the request ` + s,
        'ERR_NOT_SUPPORT'
      );
    }

    return adapter;
  },
  adapters: knownAdapters
}

export default function fetchAdapter(config) {
  return new Promise((resolve, reject) => {
    const {
      url,
      method,
      data,
      headers,
      responseType,
      timeout,
      signal
    } = config;

    const requestConfig = {
      method: method.toUpperCase(),
      headers: new Headers(headers),
      body: data,
      signal
    };

    if (timeout) {
      const controller = new AbortController();
      requestConfig.signal = controller.signal;
      setTimeout(() => controller.abort(), timeout);
    }

    fetch(url, requestConfig)
      .then(response => {
        const responseData = {};
        responseData.status = response.status;
        responseData.statusText = response.statusText;
        responseData.headers = response.headers;

        const responseBody = responseType === 'text' ? response.text() : response[responseType]();
        return responseBody.then(data => {
          responseData.data = data;
          resolve(responseData);
        });
      })
      .catch(error => {
        reject(error);
      });
  });
}

import http from 'http';
import https from 'https';
import url from 'url';

export default function httpAdapter(config) {
  return new Promise((resolve, reject) => {
    const parsedUrl = url.parse(config.url);
    const protocol = parsedUrl.protocol === 'https:' ? https : http;

    const options = {
      hostname: parsedUrl.hostname,
      port: parsedUrl.port,
      path: parsedUrl.path,
      method: config.method.toUpperCase(),
      headers: config.headers
    };

    const req = protocol.request(options, res => {
      const responseData = {};
      responseData.status = res.statusCode;
      responseData.statusText = res.statusMessage;
      responseData.headers = res.headers;

      let responseBuffer = [];
      res.on('data', chunk => {
        responseBuffer.push(chunk);
      });

      res.on('end', () => {
        const responseBody = Buffer.concat(responseBuffer);
        responseData.data = config.responseType === 'buffer' ? responseBody : responseBody.toString();
        resolve(responseData);
      });
    });

    req.on('error', error => {
      reject(error);
    });

    if (config.data) {
      req.write(config.data);
    }

    req.end();
  });
}

export default function xhrAdapter(config) {
  return new Promise((resolve, reject) => {
    const request = new XMLHttpRequest();
    request.open(config.method.toUpperCase(), config.url, true);

    Object.keys(config.headers).forEach(name => {
      if (config.headers[name] !== undefined) {
        request.setRequestHeader(name, config.headers[name]);
      }
    });

    if (config.timeout) {
      request.timeout = config.timeout;
    }

    request.onreadystatechange = function() {
      if (request.readyState === 4) {
        if (request.status >= 200 && request.status < 300) {
          const responseData = {};
          responseData.status = request.status;
          responseData.statusText = request.statusText;
          responseData.headers = parseHeaders(request.getAllResponseHeaders());
          responseData.data = request.response;
          resolve(responseData);
        } else {
          reject(new Error(`Request failed with status code ${request.status}`));
        }
      }
    };

    request.onerror = function() {
      reject(new Error('Network Error'));
    };

    request.ontimeout = function() {
      reject(new Error(`timeout of ${config.timeout}ms exceeded`));
    };

    request.send(config.data);
  });
}