Le contenu partagé avec vous dans cet article explique comment implémenter une bibliothèque de requêtes HTTP via l'analyse du code source axios. Le contenu est très détaillé. Examinons ensuite le contenu spécifique. J'espère que cela pourra aider tout le monde.
Au cours du processus de développement front-end, nous rencontrons souvent des situations où nous devons envoyer des requêtes asynchrones. L'utilisation d'une bibliothèque de requêtes HTTP avec des fonctions complètes et des interfaces complètes peut réduire considérablement nos coûts de développement et améliorer notre efficacité de développement.
axios est une bibliothèque de requêtes HTTP devenue très populaire ces dernières années. Elle compte actuellement plus de 40 000 étoiles dans GitHub et a été recommandée par tout le monde.
Aujourd'hui, nous allons examiner comment axios est conçu et ce qui vaut la peine d'en tirer des leçons. Lorsque j'ai écrit cet article, la version d'axios était 0.18.0. Prenons cette version du code comme exemple pour effectuer une lecture et une analyse spécifiques du code source. Actuellement, tous les fichiers de code source d'axios se trouvent dans le dossier lib, donc les chemins que nous mentionnons ci-dessous font référence aux chemins du dossier lib.
Le contenu principal de cet article est :
Comment utiliser axios
Comment le module de base d'axios est conçu et mis en œuvre (Demandes, intercepteurs, retraits)
Ce qui vaut la peine d'être appris de la conception d'axios
axios({
method:'get',
url:'http://bit.ly/2mTM3nY',
responseType:'stream'
})
.then(function(response) {
response.data.pipe(fs.createWriteStream('ada_lovelace.jpg'))
});// 增加一个请求拦截器，注意是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);
});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.');core/dispatchReqeust.js
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);
});
};dispatchRequestEn tant que module de base, le code lié à l'envoi de requêtes axios se trouve dans le fichier config.adapter. En raison de l'espace limité, je sélectionnerai quelques codes sources clés pour une brève introduction ci-dessous :
default.jsGrâce au code et aux exemples ci-dessus, nous pouvons savoir que la méthode
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;
}adapters/xhr.jsDans le fichier
dispatchRequestModule intercepteur request
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;
};, examinons comment axios gère les fonctions d'interception de requête et de réponse. Jetons un coup d'œil à la fonction d'entrée unifiée
demandée dans axios. Cette fonction est le point d'entrée permettant à axios d'envoyer des requêtes. Parce que la mise en œuvre de la fonction est relativement longue, je vais brièvement parler des idées de conception pertinentes : .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;而在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
};
};而在adapter/xhr.js文件中，有与之相对应的取消请求的代码：
if (config.cancelToken) {
// 等待取消
config.cancelToken.promise.then(function onCanceled(cancel) {
if (!request) {
return;
}
request.abort();
reject(cancel);
// 重置请求
request = null;
});
}结合上面的取消HTTP请求的示例和这些代码，我们来简单说下相关的实现逻辑：
在可能需要取消的请求中，我们初始化时调用了source方法，这个方法返回了一个CancelToken类的实例A和一个函数cancel。
在source方法返回实例A中，初始化了一个在pending状态的promise。我们将整个实例A传递给axios后，这个promise被用于做取消请求的触发器。
当source方法返回的cancel方法被调用时，实例A中的promise状态由pending变成了fulfilled,立刻触发了then的回调函数，从而触发了axios的取消逻辑——request.abort()。
在之前的章节中有提到过，axios在处理发送请求的dispatchRequest函数时，没有当做一个特殊的函数来对待，而是采用一视同仁的方法，将其放在队列的中间位置，从而保证了队列处理的一致性，提高了代码的可阅读性。
在adapter的处理逻辑中，axios没有把http和xhr两个模块（一个用于Node.js发送请求，另一个则用于浏览器端发送请求）当成自身的模块直接在dispatchRequest中直接饮用，而是通过配置的方法在default.js文件中进行默认引入。这样既保证了两个模块间的低耦合性，同时又能够为今后用户需要自定义请求发送模块保留了余地。
在取消HTTP请求的逻辑中，axios巧妙的使用了一个Promise来作为触发器，将resolve函数通过callback中参数的形式传递到了外部。这样既能够保证内部逻辑的连贯性，也能够保证在需要进行取消请求时，不需要直接进行相关类的示例数据改动，最大程度上避免了侵入其他的模块。
本文对axios相关的使用方式、设计思路和实现方法进行了详细的介绍。读者能够通过上述文章，了解axios的设计思想，同时能够在axios的代码中，学习到关于模块封装和交互等相关的经验。
由于篇幅原因，本文仅针对axios的核心模块进行了分解和介绍，如果对其他代码有兴趣的同学，可以去GitHub进行查看。
相关推荐：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
