Node.js est un runtime JavaScript open source construit sur le moteur v8 de chrome qui vous permet d'exécuter du code JavaScript en dehors d'un navigateur.
Son modèle d'événement, son écosystème et sa vitesse ont fait de Node.js l'un des runtimes les plus recherchés et les plus utilisés pour les applications côté serveur.
La plupart des serveurs d'API Node.js utilisent Express ou un autre framework. Cependant, vous pouvez également créer une simple API Node.js sans framework en quelques étapes seulement.
Étape 1: Configuration de votre environnement de développement
Créez un répertoire de projet et CD en exécutant:
mkdir nodejs-api
CD nodejs-api
Ensuite, initialisez npm dans votre projet en exécutant :
npm init -y
Cette API CRUD comportera l'utilisation de MongoDB, une base de données NoSQL, et son ODM populaire, la mangouste.
Exécutez la commande suivante pour installer mangouste:
npm installer mangouste
Ensuite, créez un serveur.js dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous pour créer un serveur :
constante http = exiger("http");
constante serveur = http.createServer((req, res) => {});
serveur.écoute (3000, () => {
console.Journal(`Le serveur est en cours d'exécution`);
});
Ce bloc de code importe le module http, un module Node.js principal. Le module http permet à Node.js de transférer des données via HTTP. Ce module contient les méthodes nécessaires pour créer un serveur.
Ensuite, il appelle le module http créer un serveur méthode qui crée et retourne une instance d'un serveur. La créer un serveur La méthode prend une fonction de rappel avec un objet de requête et de réponse comme paramètres.
Ensuite, le code appelle le Ecoutez méthode sur l'instance de serveur renvoyée. Cela permet au serveur de commencer à écouter le trafic sur le port donné. La Ecoutez La méthode déclenche un rappel (le deuxième argument) lorsqu'elle réussit.
Enfin, créez deux répertoires nommés itinéraires et des modèles dans le répertoire racine de votre projet. La itinéraires dossier contiendra la logique de routage de votre API, tandis que maquette contiendra tout ce qui concerne la base de données.
Étape 2: Connecter votre application à une base de données
Dans serveur.js, importer mangouste:
constante mangouste = exiger("mangouste");
Appeler le relier méthode sur mangouste et passez votre URI MongoDB en argument :
mangouste.connect("MongoDB_URI")
Étape 3: Créer un modèle d'API
Créez une API CRUD pour une simple application de blog. Dans ton des modèles dossier, créez un blogModel.js fichier et ajoutez le code suivant à votre fichier :
constante mangouste = exiger("mangouste");
constante blogSchema = mangouste. Schéma({
Titre: {
taper: Chaîne de caractères,
requis: [vrai, "Le blog doit avoir un titre"],
},
corps: {
taper: Chaîne de caractères,
requis: [vrai, "Le blog doit avoir un corps"],
},
});
module.exportations = mangouste.model("Blog", blogSchema);
Le bloc de code ci-dessus crée un modèle de mangouste avec deux propriétés et les mappe à une base de données MongoDB.
Les deux propriétés de ce modèle ont une Chaîne de caractères taper avec obligatoire mis à vrai. Les messages d'erreur qui l'accompagnent s'afficheront si un corps de demande ne contient aucune des propriétés.
La dernière ligne crée et exporte un modèle de mangouste en appelant le maquette méthode sur mangouste. Passez le nom du modèle (Blog) comme premier argument et un schéma (blogSchéma) comme deuxième argument.
Étape 4: Implémenter le routage dans votre application
Sans l'aide de frameworks comme Express, vous devrez créer manuellement la logique pour gérer chaque requête adressée à votre API.
Tout d'abord, créez un blogRoutes.js fichier dans votre itinéraires dossier, puis importez le modèle de blog :
constante Blogue = exiger(""../models/blogModel");
Ensuite, créez un asynchrone routeur fonction, passer demande et res en tant que paramètres, et exportez la fonction :
constante routeur = asynchronefonction (demande, résolution) {};
module.exportations = routeur ;
Cette fonction contiendra toute votre logique de routage.
Ensuite, vous implémenterez la logique de routage route par route.
OBTENIR des itinéraires
Ajoutez le bloc de code ci-dessous à votre routeur fonction de mettre en œuvre le OBTENIR gestionnaire de route pour les requêtes adressées à /api/blogs:
// OBTENIR: /api/blogs
si (URL requise "/api/blogs"&& req.méthode "OBTENIR") {
// récupère tous les blogs
constante blogs = attendre Blog.trouver();// Positionner la statut code etcontenu-taper
res.writeHead (200, { "Type de contenu": "application/json" });
// envoyer des données
res.fin(JSON.stringifier(blogs));
}
Le bloc de code ci-dessus vérifie le URL et méthode propriétés de l'objet de requête. Il récupère ensuite tous les blogs de la base de données via le trouver méthode sur le modèle de la mangouste (Blog).
Ensuite, il appelle le tête d'écriture méthode sur res, l'objet de réponse. Cette méthode envoie un en-tête de réponse avec trois arguments: un code d'état, un message d'état facultatif et des en-têtes. La 200 le code d'état représente une réponse réussie et le type de contenu pour cet appel d'API est défini sur application/json.
Enfin, fermez la requête pour vous assurer que le serveur ne se bloque pas en appelant le fin méthode sur res. L'appel à JSON.stringify convertit le blogs objet à une chaîne JSON et en le transmettant au fin La méthode le renvoie comme corps de réponse.
Ajoutez le bloc de code ci-dessous à votre routeur fonction de mettre en œuvre le OBTENIR gestionnaire de route pour une seule ressource :
// OBTENIR: /api/blogs/:id
si (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.méthode "OBTENIR") {
essayer {
// extrait l'identifiant de l'url
id const = req.url.split("/")[3];// récupère le blog de la base de données
constante blog = attendre Blog.findById (id);
si (blog) {
res.writeHead (200, { "Type de contenu": "application/json" });
res.fin(JSON.stringifier(Blog));
} autre {
jeterNouveauErreur("Le blog n'existe pas");
}
} attraper (Erreur) {
res.writeHead (404, { "Type de contenu": "application/json" });
res.fin(JSON.stringifier({ message: Erreur }));
}
}
Ce code utilise le match méthode, qui prend une expression regex comme argument, pour vérifier si l'url correspond au format: /api/blogs/.
Ensuite, extrayez le identifiant propriété de la URL chaîne en appelant son diviser méthode. Cette méthode prend un motif comme argument (/), divise la chaîne en fonction du modèle et renvoie un tableau. Le troisième élément de ce tableau est le identifiant.
Enfin, récupérez le document avec la correspondance identifiant de votre base de données. S'il existe, envoyez un code de réponse de 200, fermez la demande et envoyez le blog récupéré. S'il n'existe pas, lancez une erreur et envoyez-la comme réponse dans le bloc catch.
Acheminement POST
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter le PUBLIER gestionnaire d'itinéraire :
// POST: /api/blogs/
si (URL requise "/api/blogs"&& req.méthode "PUBLIER") {
essayer {
laisser corps = "";// Écouter l'événement de données
demande("Les données", (morceau) => {
corps += morceau.toString();
});// Écouter finun événement
demande("fin", asynchrone () => {
// Créer un blog
laisser blog = Nouveau Blog(JSON.parse (corps));
// Enregistrer dans la BD
attendre blog.save();
res.writeHead (200, { "Type de contenu": "application/json" });
res.fin(JSON.stringifier(Blog));
});
} attraper (Erreur) {
console.log (erreur);
}
}
L'objet de requête implémente la Node.js ReadableStream interface. Ce flux émet un Les données Et un fin événement qui vous donne accès aux données du corps de la requête.
Ce code écoute l'événement de données et le gère en le convertissant en une chaîne et en le concaténant avec le corps variable. Dans le fin gestionnaire d'événements, il crée un Blog instance avec la chaîne de corps analysée. Il enregistre ensuite le nouveau blog, envoie le code d'état et l'en-tête de contenu, puis ferme la demande.
METTRE l'itinéraire
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter le METTRE gestionnaire d'itinéraire :
// METTRE: /api/blogs/:id
si (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.méthode "METTRE") {
essayer {
// extrait l'identifiant de l'url
id const = req.url.split("/")[3];
laisser corps = "";demande("Les données", (morceau) => {
corps += morceau.toString();
});
demande("fin", asynchrone () => {
// Trouve et mettre à jourdocument
laisser blog mis à jour = attendre Blog.findByIdAndUpdate (identifiant, JSON.parse (corps), {
Nouveau: vrai,
});
res.writeHead (200, { "Type de contenu": "application/json" });
res.fin(JSON.stringifier(mis à jourBlog));
});
} attraper (Erreur) {
console.log (erreur);
}
}
Le gestionnaire de requêtes PUT est presque identique au PUBLIER gestionnaire de requêtes, sauf qu'il extrait le identifiant propriété de la URL pour mettre à jour le blog concerné.
SUPPRIMER l'itinéraire
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter votre EFFACER gestionnaire d'itinéraire :
// EFFACER: /api/blogs/ :identifiant
si (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.méthode "EFFACER") {
essayer {
id const = req.url.split("/")[3];
// Effacer Blog de BD
attendre Blog.findByIdAndDelete (id);
res.writeHead (200, { "Type de contenu": "application/json" });
res.end (JSON.stringify({ message: "Blog supprimé avec succès" }));
} attraper (Erreur) {
res.writeHead (404, { "Type de contenu": "application/json" });
res.fin(JSON.stringifier({ message: Erreur }));
}
}
Ce bloc de code extrait le identifiant du URL, supprime le document avec la correspondance identifiant, envoie le code d'état et les en-têtes, puis ferme la demande.
Enfin, importez routeur dans ton serveur.js déposer et appeler votre routeur fonction, passage demande et res comme argument :
constante routeur = exiger(""./routes/blogRoutes");
constante serveur = http.createServer((req, res) => {
routeur (req, res);
});
Cela permet à votre serveur d'intercepter et de gérer les demandes de manière appropriée.
Vous pouvez trouver le projet terminé dans ce Référentiel GitHub.
Utilisation d'un framework Node.js
Même s'il est possible de créer une API Web à la main, cela peut être une tâche difficile. Vous devrez vous assurer que vous avez couvert de nombreux cas extrêmes et que votre code a intérêt à être exempt de bogues.
Au fil des ans, les développeurs ont construit des frameworks comme ExpressJS, NestJS, Fastify, etc., pour le rendre beaucoup plus facile.
