Salut les développeurs ! Aujourd'hui, nous allons plonger au cœur de la création d'API en utilisant Node.js, Express et Axios. Que vous soyez un programmeur chevronné ou débutant, cet article vous guidera dans la création d'API robustes et efficaces. De plus, je vais vous présenter un outil incroyable, Apidog, qui simplifiera votre processus de test et de documentation d'API.
Introduction
Les API (Interfaces de Programmation d'Applications) sont devenues l'épine dorsale des applications web modernes. Elles permettent à différents systèmes logiciels de communiquer et de partager des données de manière transparente. Que vous développiez une application web, une application mobile ou même une application de bureau, les API sont essentielles.
Pourquoi Node.js, Express et Axios ?
Node.js, Express et Axios forment un trio dynamique pour la création et la consommation d'API. Voici pourquoi :
- Node.js : Connu pour son architecture non bloquante et basée sur les événements, Node.js est parfait pour créer des applications réseau évolutives.
- Express : Ce framework d'application web Node.js minimal et flexible offre un ensemble robuste de fonctionnalités pour développer des applications web et mobiles.
- Axios : Un client HTTP basé sur les promesses pour le navigateur et Node.js, Axios facilite l'envoi de requêtes HTTP asynchrones aux points de terminaison REST et l'exécution d'opérations CRUD.
En combinant ces trois outils puissants, vous pouvez créer des API efficaces, évolutives et faciles à maintenir.
Configuration de votre environnement
Avant de plonger dans le code, configurons notre environnement. Vous aurez besoin de Node.js et de npm (Node Package Manager) installés sur votre machine.
- Installer Node.js et npm : Rendez-vous sur le site web de Node.js et téléchargez la dernière version. npm est fourni avec Node.js.
- Initialiser un nouveau projet : Ouvrez votre terminal et exécutez :
mkdir nodejs-express-axios-api
cd nodejs-express-axios-api
npm init -y
Cela créera un nouveau répertoire et initialisera un nouveau projet Node.js avec un fichier package.json par défaut.
- Installer Express et Axios :
npm install express axios
Création de votre première API avec Node.js et Express
Maintenant que notre environnement est configuré, créons une API simple.
Configuration d'Express
Tout d'abord, nous devons configurer notre serveur Express. Créez un fichier nommé server.js et ajoutez le code suivant :
const express = require('express');
const app = express();
const PORT = 3000;
// Middleware to parse JSON
app.use(express.json());
// Start the server
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
Définition des points de terminaison API
Ensuite, définissons quelques points de terminaison API. Nous allons créer des points de terminaison pour une application CRUD simple qui gère une liste de livres.
- Créer un livre : Ce point de terminaison permettra aux utilisateurs d'ajouter un nouveau livre à la liste.
- Lire les livres : Ce point de terminaison renverra la liste de tous les livres.
- Mettre à jour un livre : Ce point de terminaison permettra aux utilisateurs de mettre à jour les détails d'un livre existant.
- Supprimer un livre : Ce point de terminaison permettra aux utilisateurs de supprimer un livre de la liste.
Ajoutez le code suivant à server.js :
let books = [];
// Create a Book
app.post('/books', (req, res) => {
const book = req.body;
books.push(book);
res.status(201).send('Book added successfully');
});
// Read Books
app.get('/books', (req, res) => {
res.json(books);
});
// Update a Book
app.put('/books/:id', (req, res) => {
const bookId = req.params.id;
const updatedBook = req.body;
books = books.map(book => book.id === bookId ? updatedBook : book);
res.send('Book updated successfully');
});
// Delete a Book
app.delete('/books/:id', (req, res) => {
const bookId = req.params.id;
books = books.filter(book => book.id !== bookId);
res.send('Book deleted successfully');
});
Exécution de votre API
Pour exécuter votre API, utilisez simplement la commande suivante dans votre terminal :
node server.js
Vous devriez voir le message : Server is running on http://localhost:3000.
Consommation d'API avec Axios
Maintenant que notre API est opérationnelle, apprenons à la consommer en utilisant Axios.
Effectuer des requêtes HTTP avec Axios
Axios facilite l'envoi de requêtes HTTP asynchrones aux points de terminaison REST et l'exécution d'opérations CRUD. Nous allons démontrer comment effectuer chaque opération (Créer, Lire, Mettre à jour, Supprimer) en utilisant Axios.
Tout d'abord, installez Axios dans votre projet si vous ne l'avez pas déjà fait :
npm install axios
Exemple : Utilisation d'Axios pour interagir avec notre API de livres
Créez un nouveau fichier nommé client.js et ajoutez le code suivant :
const axios = require('axios');
const API_URL = 'http://localhost:3000/books';
// Create a new book
const createBook = async (book) => {
try {
const response = await axios.post(API_URL, book);
console.log(response.data);
} catch (error) {
console.error(error);
}
};
// Read all books
const getBooks = async () => {
try {
const response = await axios.get(API_URL);
console.log(response.data);
} catch (error) {
console.error(error);
}
};
// Update a book
const updateBook = async (bookId, updatedBook) => {
try {
const response = await axios.put(`${API_URL}/${bookId}`, updatedBook);
console.log(response.data);
} catch (error) {
console.error(error);
}
};
// Delete a book
const deleteBook = async (bookId) => {
try {
const response = await axios.delete(`${API_URL}/${bookId}`);
console.log(response.data);
} catch (error) {
console.error(error);
}
};
// Usage examples
const newBook = { id: '1', title: 'Node.js for Beginners', author: 'John Doe' };
createBook(newBook);
getBooks();
updateBook('1', { id: '1', title: 'Advanced Node.js', author: 'John Doe' });
deleteBook('1');
Explication
- createBook : Envoie une requête POST pour ajouter un nouveau livre.
- getBooks : Envoie une requête GET pour récupérer tous les livres.
- updateBook : Envoie une requête PUT pour mettre à jour un livre existant.
- deleteBook : Envoie une requête DELETE pour supprimer un livre.
Utilisation avancée d'Axios et gestion des erreurs
La gestion des erreurs est cruciale lors de l'utilisation de requêtes HTTP. Axios offre plusieurs façons de gérer efficacement les erreurs.
Gestion des erreurs
Modifiez le fichier client.js pour gérer les erreurs de manière plus élégante :
const axios = require('axios');
const API_URL = 'http://localhost:3000/books';
// Create a new book
const createBook = async (book) => {
try {
const response = await axios.post(API_URL, book);
console.log(response.data);
} catch (error) {
handleError(error);
}
};
// Read all books
const getBooks = async () => {
try {
const response = await axios.get(API_URL);
console.log(response.data);
} catch (error) {
handleError(error);
}
};
// Update a book
const updateBook = async (bookId, updatedBook) => {
try {
const response = await axios.put(`${API_URL}/${bookId}`, updatedBook);
console.log(response.data);
} catch (error) {
handleError(error);
}
};
// Delete a book
const deleteBook = async (bookId) => {
try {
const response = await axios.delete(`${API_URL}/${bookId}`);
console.log(response.data);
} catch (error) {
handleError(error);
}
};
// Error handling function
const handleError = (error) => {
if (error.response) {
// The request was made and the server responded with a status code
console.error('Error:', error.response.data);
console.error('Status:', error.response.status);
console.error('Headers:', error.response.headers);
} else if (error.request) {
// The request was made but no response was received
console.error('Error: No response received', error.request);
} else {
// Something happened in setting up the request
console.error('Error:', error.message);
}
};
Définition d'en-têtes personnalisés et d'intercepteurs
Axios vous permet de définir des en-têtes personnalisés et d'intercepter les requêtes ou les réponses. Cela peut être utile pour ajouter des jetons d'authentification ou pour la journalisation.
const axios = require('axios');
const API_URL = 'http://localhost:3000/books';
// Axios instance with custom headers
const axiosInstance = axios.create({
baseURL: API_URL,
headers: { 'Authorization': 'Bearer YOUR_TOKEN_HERE' }
});
// Request interceptor
axiosInstance.interceptors.request.use(config => {
console.log('Request sent at:', new Date().toISOString());
return config;
}, error => {
return Promise.reject(error);
});
// Response interceptor
axiosInstance.interceptors.response.use(response => {
console.log('Response received at:', new Date().toISOString());
return response;
}, error => {
return Promise.reject(error);
});
// Example usage with interceptors
const getBooks = async () => {
try {
const response = await axiosInstance.get('/');
console.log(response.data);
} catch (error) {
console.error(error);
}
};
getBooks
();
Tester et documenter votre API avec APIdog
Tester et documenter vos API est crucial pour s'assurer qu'elles fonctionnent comme prévu et qu'elles sont faciles à utiliser pour les autres développeurs. C'est là qu'APIdog entre en jeu.
Qu'est-ce qu'Apidog ?
APIdog est un outil puissant qui vous aide à tester et à documenter vos API sans effort. Avec APIdog, vous pouvez créer une documentation API complète, effectuer des tests automatisés et partager vos API avec votre équipe.
Tester l'API avec Apidog
Passons en revue un bref tutoriel sur la façon d'utiliser Apidog pour effectuer une requête [post].
Étape 1 : Ouvrez Apidog et créez une nouvelle requête.
- Démarrez Apidog et sélectionnez Nouvelle requête
Étape 2 : Entrez l'API
- Trouvez ou entrez manuellement les détails de l'API pour la requête POST que vous souhaitez effectuer.
Étape 3 : Entrez les paramètres
- Remplissez les paramètres requis et toutes les données que vous souhaitez inclure dans le corps de la requête.
L'utilisation d'Apidog peut vous faire gagner du temps et des efforts lorsque vous travaillez avec des requêtes POST.
Documenter notre API avec Apidog
Pour générer facilement une documentation API, suivez simplement ces guides étape par étape :
Étape 1 : Inscrivez-vous à Apidog
Pour commencer à utiliser Apidog pour la documentation de l'API, créez un compte et connectez-vous. Après vous être connecté, vous serez redirigé vers le Centre de projets, où vous pourrez sélectionner le projet par défaut ou en créer un nouveau.
Étape 2 : Créez une nouvelle API
Votre projet d'API se composera de plusieurs points de terminaison. Ajoutez un point de terminaison en cliquant sur le bouton « + » ou « Ajouter un point de terminaison » dans votre projet.
Étape 3 : Remplissez les informations de l'API
Fournissez des détails tels que l'URL du point de terminaison, la description et les spécificités de la requête/réponse. La documentation des points de terminaison comprend :
- Spécification de la méthode HTTP (GET, POST, PUT, DELETE, etc.) et du chemin de la requête API
- Définition des paramètres de requête (noms, types, descriptions)
- Description des réponses attendues (codes d'état, formats, exemples de réponses)
Étape 4 : Enregistrez la documentation de l'API
Après avoir saisi les informations nécessaires, cliquez sur « Enregistrer » pour enregistrer la documentation de l'API.
Étape 5 : Testez l'API directement à partir du document API en ligne
Une fois que vous avez enregistré la documentation de l'API, il y aura une option pour « Exécuter » votre API. Cliquer sur le bouton « Exécuter » enverra une requête API et récupérera la réponse pour que vous puissiez tester les points de terminaison. Au cours de ce processus, vous pouvez identifier les erreurs et les problèmes qui doivent être résolus.
Une fois que la documentation de l'API répond aux besoins de l'entreprise, vous pouvez la partager avec d'autres via un seul lien.
Avantages de la génération de documentation API en ligne à l'aide d'Apidog
- Débogage en ligne : Déboguez facilement les API directement dans la documentation en cliquant sur le bouton « Exécuter », ce qui permet des tests rapides et efficaces.
- Génération automatique de documentation : Générez automatiquement une documentation API complète en remplissant les informations nécessaires, ce qui élimine le besoin d'une configuration manuelle importante.
- Génération de code : Générez instantanément du code de modèle de requête et de réponse dans diverses langues, telles que JavaScript, avec des options pour Fetch, Axios et JQuery, etc., simplifiant ainsi le processus de développement.
- Cloud Mock : Utilisez Cloud Mock pour simuler les services backend et créer des serveurs virtuels pour les tests sans restrictions, améliorant ainsi la flexibilité et réduisant la dépendance aux services backend réels.
Conclusion
Félicitations ! Vous avez réussi à créer une API robuste en utilisant Node.js, Express et Axios. Vous avez également appris à consommer des API avec Axios, à gérer efficacement les erreurs et à améliorer vos tests et votre documentation API avec APIdog.
Les API sont l'épine dorsale du développement web moderne, et la maîtrise de ces outils vous mettra sur la voie de la création d'applications puissantes et évolutives. N'oubliez pas de télécharger APIdog gratuitement pour rationaliser votre processus de développement et de test d'API.
