The content shared with you in this article is about how to implement an HTTP request library through axios source code analysis. The content is very detailed. Next, let’s take a look at the specific content. I hope it can help everyone.

Overview

During the front-end development process, we often encounter situations where we need to send asynchronous requests. Using a HTTP request library with complete functions and complete interfaces can reduce our development costs to a great extent and improve our development efficiency.

axios is an HTTP request library that has become very popular in recent years. It currently has more than 40K stars in GitHub and has been recommended by everyone.

Today, let’s take a look at how axios is designed and what is worth learning from it. When I wrote this article, the version of axios was 0.18.0. Let’s take this version of the code as an example to conduct specific source code reading and analysis. Currently all axios source code files are in thelibfolder, so the paths we mention below refer to the paths in thelibfolder.

The main contents of this article are:

How to use axios
How the core module of axios is designed and implemented ( Request, interceptor, withdrawal)
What is worth learning from the design of axios

How to use axios

To understand the design of axios, we first need to look at how axios is used. We introduce the following axios API through a simple example.

Send request

axios({ method:'get', url:'http://bit.ly/2mTM3nY', responseType:'stream' }) .then(function(response) { response.data.pipe(fs.createWriteStream('ada_lovelace.jpg')) });

Copy after login

This is an official API example. From the above code, we can see that the usage of axios is very similar to jQuery's ajax, both of which continue subsequent operations by returning a Promise (you can also use the success callback, but it is recommended to use Promise or await).

This code example is very simple, so I won’t go into details. Let’s take a look at how to add a filter function.

Add the Interceptors function

// 增加一个请求拦截器，注意是2个函数，一个处理成功，一个处理失败，后面会说明这种情况的原因 axios.interceptors.request.use(function (config) { // 请求发送前处理 return config; }, function (error) { // 请求错误后处理 return Promise.reject(error); }); // 增加一个响应拦截器 axios.interceptors.response.use(function (response) { // 针对响应数据进行处理 return response; }, function (error) { // 响应错误后处理 return Promise.reject(error); });

Copy after login

Through the above example we can know: before the request is sent, we can perform data processing on the config parameters of the request; After requesting a response, we can also perform specific operations on the returned data. At the same time, we can perform specific error handling when the request fails and the response fails.

Cancel HTTP request

When completing search-related functions, we often need to send frequent requests for data query. Generally speaking, when we send the next request, we need to cancel the previous request. Therefore, the ability to cancel requests is also a plus. The sample code for axios cancellation request is as follows:

const CancelToken = axios.CancelToken; const source = CancelToken.source(); axios.get('/user/12345', { cancelToken: source.token }).catch(function(thrown) { if (axios.isCancel(thrown)) { console.log('Request canceled', thrown.message); } else { // handle error } }); axios.post('/user/12345', { name: 'new name' }, { cancelToken: source.token }) // cancel the request (the message parameter is optional) source.cancel('Operation canceled by the user.');

Copy after login

From the above example, we can see that axios uses a withdrawal proposal based on CancelToken. However, the proposal has now been withdrawn. Details can be found here. We will explain the specific withdrawal implementation method in the source code analysis in the following chapters.

How the core module of axios is designed and implemented

Through the above examples, I believe everyone has a general understanding of how to use axios. Next, we will analyze the design and implementation of axios according to modules. The picture below shows the relevant axios files that we will cover in this blog. If readers are interested, they can read them through the clone related code in combination with the blog, which can deepen their understanding of the relevant modules.

HTTP request module

As the core module, the code related to axios sending requests is located in thecore/dispatchReqeust.jsfile. Due to limited space, I will select some key source codes for a brief introduction below:

module.exports = function dispatchRequest(config) { throwIfCancellationRequested(config); // 其他源码 // default adapter是一个可以判断当前环境来选择使用Node还是XHR进行请求发送的模块 var adapter = config.adapter || defaults.adapter; return adapter(config).then(function onAdapterResolution(response) { throwIfCancellationRequested(config); // 其他源码 return response; }, function onAdapterRejection(reason) { if (!isCancel(reason)) { throwIfCancellationRequested(config); // 其他源码 return Promise.reject(reason); }); };

Copy after login

From the above code and examples, we can know that thedispatchRequestmethod is to obtainconfig.adapterTo get the module that sends the request, we can also replace the native module by passing in the adapter function that conforms to the specification (although this is generally not done, it can be regarded as a loosely coupled extension point).

In thedefault.jsfile, we can see the relevant adapter selection logic, which is based on some properties and constructors unique to the current container.

function getDefaultAdapter() { var adapter; // 只有Node.js才有变量类型为process的类 if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') { // Node.js请求模块 adapter = require('./adapters/http'); } else if (typeof XMLHttpRequest !== 'undefined') { // 浏览器请求模块 adapter = require('./adapters/xhr'); } return adapter; }

Copy after login

The XHR module in axios is relatively simple. It is an encapsulation of the XMLHTTPRequest object. We will not introduce it in detail here. Interested students can read it by themselves. The code is located atadapters/xhr.jsin the file.

Interceptor module

Understanding the HTTP request sending module implemented bydispatchRequest, let’s take a look at how axios handles the request and response interception functions of. Let's take a look at the unified entryrequestfunction requested in axios.

Axios.prototype.request = function request(config) { // 其他代码 var chain = [dispatchRequest, undefined]; var promise = Promise.resolve(config); this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { chain.unshift(interceptor.fulfilled, interceptor.rejected); }); this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { chain.push(interceptor.fulfilled, interceptor.rejected); }); while (chain.length) { promise = promise.then(chain.shift(), chain.shift()); } return promise; };

Copy after login

This function is the entry point for axios to send requests. Because the function implementation is relatively long, I will briefly talk about the relevant design ideas:

chain是一个执行队列。这个队列的初始值，是一个带有config参数的Promise。
在chain执行队列中，插入了初始的发送请求的函数dispatchReqeust和与之对应的undefined。后面需要增加一个undefined是因为在Promise中，需要一个success和一个fail的回调函数，这个从代码promise = promise.then(chain.shift(), chain.shift());就能够看出来。因此，dispatchReqeust和undefined我们可以成为一对函数。
在chain执行队列中，发送请求的函数dispatchReqeust是处于中间的位置。它的前面是请求拦截器，通过unshift方法放入；它的后面是响应拦截器，通过push放入。要注意的是，这些函数都是成对的放入，也就是一次放入两个。

通过上面的request代码，我们大致知道了拦截器的使用方法。接下来，我们来看下如何取消一个HTTP请求。

取消请求模块

取消请求相关的模块在Cancel/文件夹中。让我们来看下相关的重点代码。

首先，让我们来看下元数据Cancel类。它是用来记录取消状态一个类，具体代码如下：

function Cancel(message) { this.message = message; } Cancel.prototype.toString = function toString() { return 'Cancel' + (this.message ? ': ' + this.message : ''); }; Cancel.prototype.__CANCEL__ = true;

Copy after login

而在CancelToken类中，它通过传递一个Promise的方法来实现了HTTP请求取消，然我们看下具体的代码：

function CancelToken(executor) { if (typeof executor !== 'function') { throw new TypeError('executor must be a function.'); } var resolvePromise; this.promise = new Promise(function promiseExecutor(resolve) { resolvePromise = resolve; }); var token = this; executor(function cancel(message) { if (token.reason) { // Cancellation has already been requested return; } token.reason = new Cancel(message); resolvePromise(token.reason); }); } CancelToken.source = function source() { var cancel; var token = new CancelToken(function executor(c) { cancel = c; }); return { token: token, cancel: cancel }; };

Copy after login

而在adapter/xhr.js文件中，有与之相对应的取消请求的代码：

if (config.cancelToken) { // 等待取消 config.cancelToken.promise.then(function onCanceled(cancel) { if (!request) { return; } request.abort(); reject(cancel); // 重置请求 request = null; }); }

Copy after login

结合上面的取消HTTP请求的示例和这些代码，我们来简单说下相关的实现逻辑：

在可能需要取消的请求中，我们初始化时调用了source方法，这个方法返回了一个CancelToken类的实例A和一个函数cancel。
在source方法返回实例A中，初始化了一个在pending状态的promise。我们将整个实例A传递给axios后，这个promise被用于做取消请求的触发器。
当source方法返回的cancel方法被调用时，实例A中的promise状态由pending变成了fulfilled,立刻触发了then的回调函数，从而触发了axios的取消逻辑——request.abort()。

axios的设计有什么值得借鉴的地方

发送请求函数的处理逻辑

在之前的章节中有提到过，axios在处理发送请求的dispatchRequest函数时，没有当做一个特殊的函数来对待，而是采用一视同仁的方法，将其放在队列的中间位置，从而保证了队列处理的一致性，提高了代码的可阅读性。

Adapter的处理逻辑

在adapter的处理逻辑中，axios没有把http和xhr两个模块（一个用于Node.js发送请求，另一个则用于浏览器端发送请求）当成自身的模块直接在dispatchRequest中直接饮用，而是通过配置的方法在default.js文件中进行默认引入。这样既保证了两个模块间的低耦合性，同时又能够为今后用户需要自定义请求发送模块保留了余地。