NodeJS est dans l'industrie depuis un moment maintenant. En raison de sa nature asynchrone et de la prise en charge du moteur Chrome V8, il est devenu très populaire.
NodeJS propose un certain nombre de frameworks fournis avec différentes bibliothèques, outils et modèles pour aider les développeurs à contourner les obstacles lors de la création d'applications.
Nodejs est probablement l'un des meilleurs frameworks JavaScript pour développer une application full-stack. Une fois que vous avez décidé d'aller avec Nodejs, le cadres suivants et les plugins seront utiles pour développer des services backend et API.
Express
Express est l'un des frameworks de développement Web et API les plus populaires pour NodeJS. Il a été si largement utilisé que presque tous les projets de développement Web commencent par l'intégration d'Express JS.
Il y a un tas de raisons pour choisir ExpressJS comme premier plugin.
- Large éventail de fonctionnalités pour prendre en charge tout ce dont vous avez besoin dans vos tâches de développement
- Facilité de routage facile pour acheminer vos requêtes Web vers la fonction
- Fournit une plate-forme organisée pour le codage des API
- Pris en charge avec la plupart des autres bibliothèques et plugins pris en charge
- Sécurisé et entretenu de manière cohérente pour répondre aux normes
- Excellent soutien communautaire
En plus de ces avantages, les développeurs du plugin ont également créé un générateur de projet facile à utiliser. Ce générateur peut créer un projet de modèle pour vous permettre de démarrer plus rapidement.
Projet de configuration
Montons un projet pour apprendre les bases de l'express. Assurez-vous d'avoir installé le nœud sur votre système. Vous pouvez vous référer à ce guide définitif pour le processus d'installation du nœud.
- Créez un dossier de projet.
- Ouvrez-le dans le terminal.
- Installez l'
express,body-parser,cookie-parser,corsetnodemon. - Ajoutez le fichier index.js au projet.
- Ajoutez le script de démarrage de l'application dans le
packages.jsonfichier avecnodemon index.jscommander.
Forfait(s)
- express: il s'agit du package principal de notre application qui nous aide à créer des API.
- analyseur de corps: il s'agit d'un middleware qui analyse les données entrantes de l'API et les ajoute au
req.body. - analyseur de cookies : il s'agit d'un middleware qui analyse l'en-tête Cookie et l'ajoute au
req.cookie. - cors : il s'agit d'un middleware utilisé pour activer le CORS.
- nodemon : ceci est utilisé pour exécuter notre application qui redémarrera le serveur chaque fois qu'un fichier changera.
Ce sont les packages de base nécessaires à l'application express pour nous faciliter la vie. Vous aurez peut-être besoin de plus de packages en fonction de votre projet. Ne vous inquiétez pas maintenant, l'ajout de packages n'est qu'à une commande.
Application Express
Voyons l'application de base avec différentes API
const express = require("express");
const bodyParser = require("body-parser");
const cookieParser = require("cookie-parser");
const cors = require("cors");
// initializing the express
const app = express();
const port = 3000;
// adding the middlewares to the app
app.use(bodyParser.json());
app.use(cookieParser());
app.use(cors());
// req: we will use this paramter to get API request details
// res: we will use
app.get("/", (req, res) => {
return res.send("Hello, World!");
});
app.get("/json", (req, res) => {
return res.json({ greetings: "Hello, World!" }); // you can also use res.send({})
});
app.get("/path-params/:name", (req, res) => {
// all the path params will present in req.params object
const { name } = req.params;
return res.json({ greetings: `Hello, ${name}!` });
});
app.get("/query-params", (req, res) => {
// all the query params will present in req.query object
const { name } = req.query;
return res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});
app.post("/post", (req, res) => {
// data will present in req.body
const { name } = req.body;
console.log(req.body);
return res.json({ greetings: `Hello, ${name ? name : 'Geekflare'}!` });
});
app.listen(port, () => {
console.log(`App listening on port ${port}`);
});Démarrez l'application avec npm start et essayez toutes les API que nous avons écrites. Lis le Documentation pour en savoir plus sur chaque concept.
Sails
Voiles est un framework d'architecture MVC à part entière. Il utilise ExpressJS et SocketIO à sa base. Sails.js est devenu populaire pour son architecture d'entreprise qui permettait une intégration plus rapide avec la base de données à l'aide d'objets de modèle.
Certains des avantages sont:
- Sails.JS est livré avec un projet pour générer immédiatement un modèle de projet
- La structure des dossiers dans Sails.JS est extrêmement bien organisée
- Le développement de modèles d'objets et leur exposition à l'aide du frontend est rapide
- Permet une intégration facile du middleware pour l'autorisation, l'authentification et le prétraitement
- Livré avec une prise en charge intégrée pour AWS S3 et GridFS
Configuration du projet
Créer un sailsjs projet, nous avons besoin d'un package npm appelé sail. Installons-le globalement avec la commande suivante.
npm install sails -gAllez dans le répertoire où vous voulez créer votre projet. Maintenant, exécutez la commande suivante pour créer sailsjs app.
sails new basic-appUne invite apparaîtra pour sélectionner le modèle. Sélectionnez le Vide option. Attendez que la création du projet soit terminée.
Ouvrez le projet dans votre éditeur de code préféré. Exécutez le sails lift commande pour exécuter l'application. Ouvert http://localhost:1337/ URL dans votre navigateur pour voir l'application.
Si vous voyez l'application dans l'éditeur de code, vous trouverez de nombreux dossiers et fichiers. Vous pouvez trouver une explication détaillée de chaque dossier et fichier, sur Documentation des voiles page. Dans ce tutoriel, nous en verrons un api/controllers et config/routes.js.
Application SailsJS
Voyons comment créer des API dans l'application sailsjs. Vérifiez les étapes ci-dessous pour créer une API dans l'application sailsjs.
- Ajouter un point de terminaison d'API au
config/routes.jsfichier. - Créer une action pour le point de terminaison de l'API à l'aide de la commande
sails generate action sample --no-actions2. - Ajoutez votre code API dans le fichier d'action généré à l'étape 2.
Routes
La solution routes.js Le fichier ressemblera au code suivant après avoir ajouté des points de terminaison d'API.
module.exports.routes = {
"GET /": { action: "home" },
"GET /json": { action: "json" },
"GET /path-params/:name": { action: "path-params" },
"GET /query-params": { action: "query-params" },
"POST /post": { action: "post" },
};Chaque point de terminaison d'API pointe vers une action. Nous devons générer ces fichiers d'action avec la commande mentionnée dans la section précédente. Générons tous les fichiers d'action pour les points de terminaison ci-dessus.
Actions
Nous avons ajouté 5 points de terminaison. Vérifions le code respectif pour chaque point de terminaison.
home.js
module.exports = async function home(req, res) {
return res.send("Hello, World!");
};json.js
module.exports = async function json(req, res) {
return res.json({ greetings: "Hello, World!" });
};path-params.js
module.exports = async function pathParams(req, res) {
const { name } = req.params;
return res.json({ greetings: `Hello, ${name}!` });
};post.js
module.exports = async function post(req, res) {
const { name } = req.body;
console.log(req.body);
return res.json({ greetings: `Hello, ${name ? name : 'Geekflare'}!` });
};query-params.js
module.exports = async function queryParams(req, res) {
const { name } = req.query;
return res.json({ greetins: `Hello, ${name ? name : "Geekflare"}!` });
};Il existe une autre manière d'écrire les actions. Lisez la documentation pour en savoir plus sur le framework.
Hapi
Hapi framework a été initialement conçu pour surmonter les inconvénients du framework ExpressJS. Walmart a relevé ces inconvénients alors qu'ils se préparaient à un événement à fort trafic.
Hapi.JS est un framework robuste pour créer des services et des API. Il est connu pour sa stabilité et sa fiabilité.
Configuration du projet
Créons un projet pour toucher les bases de Hapi.JS. Nous pouvons configurer le projet Hapi de manière similaire au projet NodeJS normal. Exécutez les commandes ci-dessous pour configurer le projet.
cd your_project_floder_path
npm init -y ## to init node project
npm install @hapi/hapi ## installing core package to work with Hapi.JS
npm install nodemon ## to run our applicationCréation index.js fichier dans le projet. Ajoutez le script de démarrage dans le package.json fichier avec nodemon index.js commander.
Application HapiJS
Vérifiez les API de base dans Hapi ci-dessous.
const hapi = require("@hapi/hapi");
const app = async () => {
// initializing the hapi server
const server = hapi.server({
port: 3000,
host: "localhost",
});
server.route({
method: "GET",
path: "/",
handler: (request, h) => {
return "Hello, World!";
},
});
server.route({
method: "GET",
path: "/json",
handler: (request, h) => {
return { greetings: "Hello, World!" };
},
});
server.route({
method: "GET",
path: "/path-params/{name}",
handler: (request, h) => {
const name = request.params.name;
return { greetings: `Hello, ${name}!` };
},
});
server.route({
method: "GET",
path: "/query-params",
handler: (request, h) => {
const name = request.query.name;
return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
},
});
server.route({
method: "POST",
path: "/post",
handler: (request, h) => {
const data = request.payload;
console.log(data);
return { greetings: `Hello, ${data.name ? data.name : "Geekflare"}!` };
},
});
// starting the server
await server.start();
console.log(`App is running on ${server.info.uri}`);
};
app();Nous avons ajouté différentes API pour apprendre les bases de Hapi. Vous pouvez déplacer toutes les routes dans un fichier séparé pour les rendre propres. Allez à la Documentation pour en savoir plus sur Hapi.
Total
Total est une plate-forme côté serveur qui fournit une plate-forme prête à l'emploi pour créer des applications en temps réel, chatbot, IoT, eCommerce, REST. Il permet également aux utilisateurs premium de publier leurs applications sur la plate-forme pour que d'autres puissent les utiliser.
Les avantages de l'utilisation de Total.JS comme base de votre développement sont:
- Capacités de prototypage rapide
- Livré avec de nombreux composants pré-construits qui permettent un développement plus rapide
- Contient une bibliothèque d'applications qui peuvent être facilement récupérées et intégrées à votre application
- Cadre basé sur des modules qui permet de simplifier la répartition du travail dans un grand projet
- Chat communautaire
- Maintien en permanence d'un magasin d'applications prêtes à l'emploi
LoopBack
Bouclage est un cadre de développement d'API intégré à l'explorateur d'API. L'explorateur d'API peut être connecté facilement aux applications côté client à l'aide des SDK LoopbackJS facilement disponibles. Les SDK sont disponibles pour Android, AngularJS, Angular 2+ ainsi que pour les applications iOS.
LoopBack est approuvé par GoDaddy, Symantec, Bank of America et bien d'autres. Vous trouverez de nombreux exemples sur leur site pour créer une API backend, une API REST sécurisée, des données persistantes, etc. Et oui, il a un explorateur d'API intégré.
Configuration du projet
Configurons le projet de bouclage et voyons comment créer des API de base avec.
Exécutez la commande suivante pour installer la CLI de bouclage.
npm install -g @loopback/cliExécutez la commande ci-dessous pour démarrer la configuration du projet.
lb4 appRépondez à toutes les questions du terminal. Vous pouvez répondre aux questions en fonction de vos préférences.
Ouvrez l'application dans votre éditeur de code préféré et exécutez-la avec npm commande de démarrage. Aller à http://localhost/ pour vérifier l'application de bouclage.
Application LoopBack
Si vous vérifiez à l'intérieur du src dossier, il y aura un controllers. C'est l'endroit où nous ajouterons des contrôleurs qui contiendront nos API.
Nous devons utiliser la commande suivante pour créer des contrôleurs en boucle.
lb4 controllerVérifiez les différentes API ci-dessous. Nous avons ajouté plusieurs API au contrôleur.
import {get, param, post, requestBody} from '@loopback/rest';
interface Response {
greetings: string;
}
export class GeekflareController {
@get('/hello')
home(): string {
return 'Hello, World!';
}
@get('/json')
json(): Response {
return {greetings: 'Hello, World!'};
}
// accessing path param using @param decorator
@get('/path-params/{name}')
pathParams(@param.path.string('name') name: string): Response {
return {greetings: `Hello, ${name}!`};
}
@get('/query-params')
queryParams(@param.query.string('name') name: string): Response {
return {greetings: `Hello, ${name ? name : "Geekflare"}!`};
}
// accessing path param using @requestBody decorator
@post('/post')
postMethod(@requestBody() data: any): Response {
console.log(data);
const {name} = data;
return {greetings: `Hello, ${name ? name : 'Geekflare'}!`};
}
}Nous avons vu comment créer des API et accéder à différentes choses requises pour les bases des API REST. Il y a bien plus que cela dans le framework LoopBack. Leur Documentation est le bon endroit pour plonger profondément dans le cadre.
Meteor
météore est une solution complète de développement Web et de création d'API avec un design incroyable à la base. Meteor est un framework utilisé pour la création rapide d'applications. L'architecture Meteor vous permet d'exécuter du code sur le frontend ainsi que sur le backend sans avoir à réécrire le code.
Cela améliore considérablement la vitesse de développement. Les avantages importants de l'utilisation de Meteor sont:
- Framework de développement d'applications hybrides
- Avec une base de code unique, vous pouvez créer une application de bureau, une application Web ainsi qu'une application mobile
- Il est livré avec un frontend étroitement couplé qui aide à réduire votre empreinte de code
- Très extensible avec une gamme de plugins
- Prend en charge divers frameworks de modèles frontaux
- Prend en charge le push de code à chaud qui permet d'éradiquer le besoin de mettre à jour les applications mobiles
Restify
Créez un service Web RESTfull sémantiquement correct prêt pour la production avec Restifier.
Il utilise uniquement les modules Express JS pertinents qui rendent la base de code plus légère par rapport aux autres frameworks. Approuvé par Netflix, Pinterest, Joyent, etc. - vous ne vous tromperez pas en les choisissant.
Configuration du projet
Configurons le projet restify et voyons comment écrire des API de base. Exécutez les commandes suivantes pour créer un nouveau projet restify.
Avant de continuer, assurez-vous d'avoir node avec la version 11. Restify ne prend pas en charge les dernières versions de node.
cd your_project_folder
npm init -y ## initializing node project
npm i restify ## installing core package
npm i restify-plugins ## to add some parsing middlewares to our application
npm i nodemon ## to run our applicationAprès avoir installé tous les packages, ajoutez le script de démarrage dans le package.json fichier avec nodemon index.js commande. N'oubliez pas d'ajouter index.js fichier au projet.
Restifier l'application
Créons quelques API pour apprendre les bases.
const restify = require("restify");
const restifyPlugins = require("restify-plugins");
function home(req, res, next) {
res.send("Hello, World!");
next();
}
function json(req, res, next) {
res.json({ greetings: "Hello, World!" }); // you can also use req.send(JSONData)
next();
}
function pathParams(req, res, next) {
const { name } = req.params;
res.json({ greetings: `Hello, ${name}!` });
next();
}
function queryParams(req, res, next) {
const { name } = req.query;
res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
next();
}
function post(req, res, next) {
const data = req.body;
console.log(data);
res.json({ greetings: `Hello, ${data.name ? data.name : "Geekflare"}!` });
next();
}
// creating restify server
const server = restify.createServer();
// adding parsing middlewares
server.use(restifyPlugins.jsonBodyParser({ mapParams: true }));
server.use(restifyPlugins.queryParser({ mapParams: true }));
// adding routes
server.get("/", home);
server.get("/json", json);
server.get("/path-params/:name", pathParams);
server.get("/query-params", queryParams);
server.post("/post", post);
// starting the app
server.listen(3000, function () {
console.log(`App is running at ${server.url}`);
});Découvrez le reste Documentation pour en savoir plus sur le cadre.
Koa
Koa utilise principalement les générateurs de code pour permettre aux développeurs d'accélérer leur développement. Il est livré avec divers middlewares et plugins pour vous aider à gérer les sessions, les demandes, les cookies ainsi que les transactions de données.
La même équipe derrière Express conçoit koa. Il fonctionne avec Nodejs 7.6+ et a beaucoup de exemples pour que vous le commenciez.
Configuration du projet
Configurons le projet koa avec les commandes suivantes
cd your_project_folder
npm init -y ## initializing the node project
npm i koa ## core koa package
npm i koa-route ## route package for handling API routes
npm i koa-bodyparser ## parser package to parse the request body
npm i nodemon ## to run Application Koa
La création d'API avec koa est simple et similaire aux autres frameworks que nous avons vus précédemment. Regardons le code.
const koa = require("koa");
const route = require("koa-route");
const bodyParser = require("koa-bodyparser");
const app = new koa();
const home = async (ctx) => {
ctx.body = "Hello, World!";
};
const json = async (ctx) => {
ctx.body = { greetings: "Hello, World!" };
};
// all path parameters will will pased to the function with the same name that's provided in the route
const pathParams = async (ctx, name) => {
ctx.body = { greetings: `Hello, ${name}!` };
};
const queryParams = async (ctx) => {
const name = ctx.query.name;
ctx.body = { greetings: `Hello, ${name ? name : "Geekflare"}!` };
};
const post = async (ctx) => {
const {
body: { name },
} = ctx.request;
ctx.body = { greetings: `Hello, ${name ? name : "Geekflare"}!` };
};
app.use(bodyParser());
app.use(route.get("/", home));
app.use(route.get("/json", json));
app.use(route.get("/path-params/:name", pathParams));
app.use(route.get("/query-params", queryParams));
app.use(route.post("/post", post));
app.listen(3000);Vous pouvez commencer à explorer le documents koa maintenant.
Nest
Nest est un framework pour créer des applications de nœud côté serveur. Il utilise express sous le capot pour le serveur HTTP. Et nous pouvons également le configurer avec Fastify.
Il prend en charge TypeScript et est construit à l'aide des concepts OOP, de la programmation fonctionnelle et de la programmation réactive fonctionnelle. Créons-y un projet et voyons comment écrire des API de base.
Configuration du projet
Exécutez les commandes suivantes pour créer le projet.
npm i -g @nestjs/cli ## installing nest CLI globally
nest new your_project_name ## creating a project with nest CLIApplication Nest
Dans le dossier src de l'application, il y a quelques fichiers. La app.controller.ts est le fichier dans lequel nous allons maintenant inclure les API. N'oubliez pas que nous allons seulement voir comment écrire des applications de base.
Examinons différentes API de base qui montreront différents concepts d'API.
import { Body, Controller, Get, Param, Post, Query } from '@nestjs/common';
import { AppService } from './app.service';
export interface IResponse {
greetings: string;
}
@Controller()
export class AppController {
constructor(private readonly appService: AppService) {}
@Get('/')
home(): string {
return 'Hello, World!';
}
@Get('/json')
json(): IResponse {
return { greetings: 'Hello, World!' };
}
@Get('/path-params/:name')
pathParams(@Param() params): IResponse {
const { name } = params;
return { greetings: `Hello, ${name}!` };
}
@Get('/query-params')
queryParams(@Query() params): IResponse {
const { name } = params;
return { greetings: `Hello, ${name ? name : 'Geekflare'}!` };
}
@Post('/post')
post(@Body() body): IResponse {
const { name } = body;
return { greetings: `Hello, ${name ? name : 'Geekflare'}!` };
}
}Exécutez l'application et vérifiez toutes les API. Vous pouvez également écrire ces API dans la couche de service et y accéder dans le contrôleur.
Allez à docs du nid pour plus d'apprentissage et comprendre le cadre.
Fastify
Fastifier est un autre framework de la famille des frameworks NodeJS. Comme son nom l'indique, il prétend être l'un des frameworks NodeJS les plus rapides. Voyons une partie du noyau du cadre.
- Rapide et très performant. Il prétend qu'il peut traiter jusqu'à 30 XNUMX requêtes par seconde en fonction de la complexité du code.
- Compatible TypeScript.
- Convivial pour les développeurs avec une API expressive pour un développement rapide.
- Il est livré avec un enregistreur intégré. Il utilise Pino (enregistreur NodeJS).
Configuration du projet
Configurons le projet fastify pour apprendre les bases du développement d'API. L'exécution des commandes suivantes configurera un nouveau projet fastify pour vous.
npm install --global fastify-cli ## installing fastify CLI
fastify generate project_name ## creating project with fastify CLIApplication Fastify
Fastify CLI a généré un projet pour nous. Nous sommes actuellement préoccupés par l'écriture d'API uniquement. Pour écrire de nouvelles API, ouvrez routes/root.js dossier. Ajoutez les API suivantes dans le fichier.
module.exports = async function (fastify, opts) {
fastify.get("/", async function (request, reply) {
return "Hello, World!";
});
fastify.get("/json", async function (request, reply) {
return { greetings: "Hello, World!" };
});
fastify.get("/path-params/:name", async function (request, reply) {
const { name } = request.params;
return { greetings: `Hello, ${name}!` };
});
fastify.get("/query-params", async function (request, reply) {
const { name } = request.query;
return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
});
fastify.post("/post", async function (request, reply) {
const { name } = request.body;
return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
});
};Démarrez l'application et testez toutes les API. Ce sont les bases pour écrire les API. Allez à la accélérer les docs pour en savoir plus sur le cadre.
tinyhttp
minuscule http est un framework JS léger et express. Il est livré avec un enregistreur intégré, un middleware JWT et CORS. Mettons en place un petit projet et apprenons les bases de celui-ci.
Configuration du projet
Exécutez les commandes suivantes pour configurer le projet tinyhttp.
cd you_project_folder
npm init -y
npm i @tinyhttp/app ## core tinyhttp package
npm i milliparsec ## to parse the request data and add it to request object to body key
npm i nodemon ## to run our application which will restart automatically whenever files changesNous devons faire encore une chose. Ajouter type clé avec valeur module à la package.json dossier. Nous l'ajoutons car tinyhttp ne prend pas en charge require, nous devons utiliser import déclarations à la place.
Application minuscule http
L'API de tinyhttp ressemble presque à express app. Vérifions les différentes API qu'il contient.
import { App } from "@tinyhttp/app";
import { json } from "milliparsec";
const port = 3000;
const app = new App();
app.use(json());
// req: we will use this paramter to get API request details
// res: we will use
app.get("/", (req, res) => {
res.send("Hello, World!");
});
app.get("/json", (req, res) => {
res.json({ greetings: "Hello, World!" }); // you can also use res.send({})
});
app.get("/path-params/:name", (req, res) => {
// all the path params will present in req.params object
const { name } = req.params;
res.json({ greetings: `Hello, ${name}!` });
});
app.get("/query-params", (req, res) => {
// all the query params will present in req.query object
const { name } = req.query;
res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});
app.post("/post", (req, res) => {
// data will present in req.body
const { name } = req.body;
res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});
app.listen(port, () => {
console.log(`App running on port ${port}`);
});Vous pouvez en savoir plus sur le cadre dans leur petits documents.
SocketIO
SocketIO est un framework de socket Web disponible pour plusieurs langages de programmation.
Dans NodeJS, SocketIO permet de créer des applications de socket Web telles que des chatbots, des tickers de score, des API de tableau de bord et autres. SocketIO présente des avantages significatifs par rapport à la bibliothèque de sockets Web NodeJS conventionnelle.
- Prise en charge du routage d'URL personnalisé pour les sockets Web
- Identifiants générés automatiquement pour chaque socket
- Gestion facile des salles de socket pour diffuser des données
- Intégration plus facile avec Express JS
- Prend en charge le clustering avec Redis
- Prise en charge de l'authentification par socket avec un plugin supplémentaire - socketio-auth
- Gestion basée sur le protocole HTTP de secours intégré pour un serveur qui ne prend pas en charge HTTP 1.1
Conclusion
Les gens utilisent largement NodeJS dans leurs projets. En conséquence, nous avons le choix entre différents cadres. Si vous voyez les frameworks, la plupart d'entre eux ont des API similaires. Donc, si vous avez une bonne connaissance de NodeJS et de n'importe quel framework, c'est plus que suffisant pour commencer avec n'importe quel autre framework NodeJS.
Développer des applications n'est pas facile à cause de ces frameworks. Faites bon usage des frameworks que vous aimez et continuez à en explorer d'autres.
Vous pouvez également explorer certains Node.js Packages pour déboguer, écrire et gérer efficacement leur code.
Codage heureux 🙂
