Création d'API RESTful avec Express 4

Avec la sortie d'Express 4, il est encore plus facile de créer des API RESTFULS. Si vous créez une application d'une seule page, vous aurez certainement besoin d'un service Web RESTful qui prend en charge les opérations CUD. Mon dernier tutoriel s'est concentré sur la création d'une seule application CRUD avec la ressource $ Angular. Ce tutoriel explique comment concevoir l'API backend pour une telle application crud en utilisant Express 4.

Notez simplement que beaucoup de choses ont été modifiées depuis Express 3. Ce tutoriel n'explique pas comment mettre à niveau votre application d'Express 3 à Express 4. Il couvrira plutôt comment créer l'API avec Express 4 directement. Alors, commençons.

Les plats clés

• Express 4 simplifie la création d'API RESTful, ce qui facilite la conception d'API backend pour les applications CRUD.
• Express 4 nécessite que le carrosserie est téléchargé séparément car il ne fait plus partie du noyau express. Ce module est utilisé pour analyser les corps de demande entrants, permettant l'accès à l'organisme d'une demande de poste via req.body.
• La méthode Express 4 Express.Router () crée une nouvelle instance de routeur qui peut définir les moyennes et les itinéraires. Cette instance de routeur peut ensuite être utilisée dans l'application principale comme n'importe quel autre middleware en appelant app.use ().
• Express 4 prend en charge les méthodes HTTP standard, telles que GET, Publier, Put, and Delete, pour effectuer des opérations CRUD sur une base de données, dans ce cas, une base de données de films. Cela se fait en créant des itinéraires qui gèrent ces demandes HTTP.

Création de l'API pour l'application cinématographique

Notre application sera une simple base de données de films qui prend en charge les opérations de base CRUD. Nous utiliserons Express 4 comme framework Web et MongooseJS comme outil de modélisation d'objets. Pour stocker les entrées de film, nous utiliserons MongoDB.

Avant d'aller plus loin, jetons un coup d'œil à quoi ressemblera l'API:

Structure du répertoire

Nous utiliserons la structure du répertoire suivant dans notre application:

Voici quelques points sur la structure du répertoire ci-dessus:

1. Le bin / www.js est utilisé pour amorcer notre application.
2. Le répertoire des modèles stocke nos modèles de mangouste. Pour cette application, nous n'aurons qu'un seul fichier appelé film.js.
3. Le répertoire des routes stockera toutes les routes express.
4. L'application.js détient les configurations de notre application express.

Enfin, Node_Modules et Package.json sont les composants habituels d'une application Node.js.

Obtention des dépendances nécessaires

Pour créer l'API, nous utiliserons les modules suivants:

1. Express
2. Parser Body
3. Mongoose

Remarque - Body-Parser ne fait plus partie du noyau express. Vous devez télécharger le module séparément. Nous l'avons donc répertorié dans le package.json.

Pour obtenir ces packages, nous les répertorions sous forme de dépendances dans notre package.json. Voici notre fichier package.json:

<span>{
</span>  <span>"name": "Movie CRUD API",
</span>  <span>"version": "0.0.1",
</span>  <span>"private": true,
</span>  <span>"scripts": {
</span>    <span>"start": "node ./bin/www"
</span>  <span>},
</span>  <span>"main":"./bin/www",
</span>  <span>"engines": {
</span>     <span>"node": "0.10.x"
</span>   <span>},
</span>  <span>"dependencies": {
</span>    <span>"express": "~4.2.0",
</span>    <span>"body-parser": "~1.0.0",
</span>    <span>"mongoose": "~3.8.11"
</span>  <span>}
</span><span>}</span>

Il suffit d'exécuter l'installation de NPM et toutes les dépendances seront téléchargées et placées sous le répertoire Node_Modules.

Création du modèle

Puisque nous construisons une API pour une base de données de film, nous créerons un modèle de film. Créez un fichier nommé film.js et placez-le dans le répertoire des modèles. Le contenu de ce fichier, illustré ci-dessous, crée un modèle de mangouste.

<span>var mongoose=require('mongoose');
</span><span>var Schema=mongoose.<span>Schema</span>;
</span>
<span>var movieSchema = new Schema({
</span>  <span>title: String,
</span>  <span>releaseYear: String,
</span>  <span>director: String,
</span>  <span>genre: String
</span><span>});
</span>
module<span>.exports = mongoose.model('Movie', movieSchema);</span>

Dans l'extrait précédent, nous créons un nouveau modèle, film. Chaque film a quatre propriétés qui y sont associées - titre, année de sortie, réalisateur et genre. Enfin, nous mettons le modèle dans le module.exports afin que nous puissions y accéder depuis l'extérieur.

Création des routes

Tous nos itinéraires sont disponibles dans les itinéraires / films.js. Pour commencer, ajoutez ce qui suit à votre fichier film.js:

<span>var Movie = require('../models/movie');
</span><span>var express = require('express');
</span><span>var router = express.<span>Router</span>();</span>

Express 4 a une nouvelle méthode appelée Express.Router () qui nous donne une nouvelle instance de routeur. Il peut être utilisé pour définir les moyens et les routes intermédiaires. Le point intéressant sur le routeur Express est que c'est comme une mini application. Vous pouvez définir les moyennes et les itinéraires à l'aide de ce routeur, puis l'utiliser dans votre application principale comme n'importe quel autre middleware en appelant app.use ().

Obtenir tous les films

Lorsque les utilisateurs envoient une demande de GET à / API / Films, nous devons leur envoyer une réponse contenant tous les films. Voici l'extrait qui crée un itinéraire pour cela.

router<span>.route('/movies').get(function(req<span>, res</span>) {
</span>  <span>Movie.find(function(err<span>, movies</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movies);
</span>  <span>});
</span><span>});</span>

router.Route () renvoie une seule instance d'itinéraire qui peut être utilisée pour configurer un ou plusieurs verbes HTTP. Ici, nous voulons prendre en charge une demande GET. Ainsi, nous appelons get () et passons un rappel qui sera appelé lorsqu'une demande arrivera. À l'intérieur du rappel, nous récupérons tous les films à l'aide de Mongoose et les renvoyons au client en tant que JSON.

Création d'un nouveau film

Notre API devrait créer un nouveau film dans la base de données lorsqu'une demande de publication est faite à / API / Films. Une chaîne JSON doit être envoyée comme corps de demande. Nous utiliserons la même route, / films, mais utiliserons la méthode post () au lieu de get ().

Voici le code:

router<span>.route('/movies').post(function(req<span>, res</span>) {
</span>  <span>var movie = new Movie(req.body);
</span>
  movie<span>.save(function(err) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.send({ message: 'Movie Added' });
</span>  <span>});
</span><span>});</span>

Ici, nous créons une nouvelle instance de film à partir du corps de la demande. C'est là que Body-Parser est utilisé. Ensuite, nous enregistrons simplement le nouveau film et envoyons une réponse indiquant que l'opération est réussie.

Notez que les méthodes get (), post (), etc. renvoient la même instance d'itinéraire. Ainsi, vous pouvez en fait chaîner les deux appels précédents comme indiqué ci-dessous.

router<span>.route('/movies')
</span>  <span>.get(function(req<span>, res</span>) {
</span>    <span>Movie.find(function(err<span>, movies</span>) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json(movies);
</span>    <span>});
</span>  <span>})
</span>  <span>.post(function(req<span>, res</span>) {
</span>    <span>var movie = new Movie(req.body);
</span>
    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.send({ message: 'Movie Added' });
</span>    <span>});
</span>  <span>});</span>

Mise à jour d'un film

Si les utilisateurs souhaitent mettre à jour un film, ils doivent envoyer une demande de vente à / API / Films /: ID avec une chaîne JSON comme corps de demande. Nous utilisons le paramètre nommé: ID pour accéder à un film existant. Comme nous utilisons MongoDB, tous nos films ont un identifiant unique appelé _ID. Donc, nous avons juste besoin de récupérer le paramètre: ID et l'utiliser pour trouver un film particulier. Le code pour ce faire est illustré ci-dessous.

<span>{
</span>  <span>"name": "Movie CRUD API",
</span>  <span>"version": "0.0.1",
</span>  <span>"private": true,
</span>  <span>"scripts": {
</span>    <span>"start": "node ./bin/www"
</span>  <span>},
</span>  <span>"main":"./bin/www",
</span>  <span>"engines": {
</span>     <span>"node": "0.10.x"
</span>   <span>},
</span>  <span>"dependencies": {
</span>    <span>"express": "~4.2.0",
</span>    <span>"body-parser": "~1.0.0",
</span>    <span>"mongoose": "~3.8.11"
</span>  <span>}
</span><span>}</span>

Ici, nous créons une nouvelle route / films /: id et utilisons la méthode put (). L'appel de film.findone ({_id: req.params.id}) est utilisé pour trouver le film dont l'ID est passé dans l'URL. Une fois que nous avons l'instance de film, nous le mettons à jour en fonction du JSON passé dans le corps de la demande. Enfin, nous enregistrons ce film et envoyons une réponse au client.

récupérer un film

Pour lire un seul film, les utilisateurs doivent envoyer une demande GET à la route / api / films /: id. Nous utiliserons le même itinéraire que ci-dessus, mais utiliser Get () cette fois.

<span>var mongoose=require('mongoose');
</span><span>var Schema=mongoose.<span>Schema</span>;
</span>
<span>var movieSchema = new Schema({
</span>  <span>title: String,
</span>  <span>releaseYear: String,
</span>  <span>director: String,
</span>  <span>genre: String
</span><span>});
</span>
module<span>.exports = mongoose.model('Movie', movieSchema);</span>

Le reste du code est assez simple. Nous récupérons un film basé sur l'ID passé et l'envoyons à l'utilisateur.

Suppression d'un film

Pour supprimer un film, les utilisateurs doivent envoyer une demande de suppression à / api / films /: id. Encore une fois, l'itinéraire est le même que ci-dessus, mais la méthode est différente (c'est-à-dire delete ()).

<span>var Movie = require('../models/movie');
</span><span>var express = require('express');
</span><span>var router = express.<span>Router</span>();</span>

la méthode film.remove () supprime un film de la base de données, et nous envoyons un message à l'utilisateur indiquant le succès.

Maintenant, nous sommes tous définis. Mais attendez! Nous devons mettre l'instance de routeur dans le module.exports afin que nous puissions l'utiliser dans notre application en tant que Middlewaree. Donc, c'est la dernière ligne du fichier film.js:

router<span>.route('/movies').get(function(req<span>, res</span>) {
</span>  <span>Movie.find(function(err<span>, movies</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movies);
</span>  <span>});
</span><span>});</span>

Configuration de l'application

Toutes nos configurations vont dans app.js. Nous commençons par nécessiter les modules nécessaires:

router<span>.route('/movies').post(function(req<span>, res</span>) {
</span>  <span>var movie = new Movie(req.body);
</span>
  movie<span>.save(function(err) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.send({ message: 'Movie Added' });
</span>  <span>});
</span><span>});</span>

L'étape suivante consiste à se connecter à MongoDB via Mongoose:

router<span>.route('/movies')
</span>  <span>.get(function(req<span>, res</span>) {
</span>    <span>Movie.find(function(err<span>, movies</span>) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json(movies);
</span>    <span>});
</span>  <span>})
</span>  <span>.post(function(req<span>, res</span>) {
</span>    <span>var movie = new Movie(req.body);
</span>
    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.send({ message: 'Movie Added' });
</span>    <span>});
</span>  <span>});</span>

Enfin, nous configurons le middleware:

router<span>.route('/movies/:id').put(function(req<span>,res</span>){
</span>  <span>Movie.findOne({ _id: req.params.id }, function(err<span>, movie</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    <span>for (prop in req.body) {
</span>      movie<span>[prop] = req.body[prop];
</span>    <span>}
</span>
    <span>// save the movie
</span>    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json({ message: 'Movie updated!' });
</span>    <span>});
</span>  <span>});
</span><span>});</span>

Comme vous pouvez le voir, j'ai utilisé le routeur comme tout autre middleware. J'ai passé / API comme premier argument à app.use () afin que le middleware de route soit mappé vers / API. Ainsi, à la fin, nos URL API deviennent:

• / api / films
• / api / films /: id

bootstrap

Le code suivant va dans bin / www.js, qui bootstraps notre application:

router<span>.route('/movies/:id').get(function(req<span>, res</span>) {
</span>  <span>Movie.findOne({ _id: req.params.id}, function(err<span>, movie</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movie);
</span>  <span>});
</span><span>});</span>

En exécutant Node Bin / www.js, votre API devrait être en place!

tester l'API

Maintenant que nous avons créé l'API, nous devons le tester pour nous assurer que tout fonctionne comme prévu. Vous pouvez utiliser Postman, une extension Chrome, pour tester tous vos points de terminaison. Voici quelques captures d'écran qui affichent le poste et obtiennent des demandes testées dans Postman.

Conclusion

Il s'agissait d'un aperçu de base de la façon dont vous pouvez créer facilement des API RESTful avec Node et Express. Si vous souhaitez approfondir Express, assurez-vous de consulter leurs documents. Si vous souhaitez ajouter ou demander quelque chose, n'hésitez pas à commenter.

Le code source de l'application est disponible en téléchargement sur github.

Questions fréquemment posées (FAQ) sur la création d'API RESTful avec Express 4

Quelle est la différence entre les API reposantes et d'autres types d'API?

API RESTFULS, ou API de transfert d'état de représentation, sont un type d'API qui adhèrent aux principes du style architectural REST. Ils sont apatrides, ce qui signifie que chaque demande d'un client à un serveur doit contenir toutes les informations nécessaires pour comprendre et traiter la demande. Ceci est différent des autres types d'API, tels que SOAP, qui peuvent maintenir l'état entre les demandes. Les API RESTfules utilisent également des méthodes HTTP standard, comme Get, Post, Post, Supprimer, les rendant faciles à comprendre et 4, vous pouvez créer un itinéraire de base à l'aide de la méthode app.get (). Cette méthode prend deux arguments: le chemin d'accès et une fonction de rappel. La fonction de rappel est exécutée chaque fois qu'une demande GET est effectuée sur le chemin spécifié. Voici un exemple:

app.get ('/', fonction (req, res) {

res.send ('Hello world!');

});

dans cet exemple, quand Une demande de GET est faite sur le chemin racine ('/'), le serveur répondra avec 'Hello World!'. Poster les demandes dans Express 4, vous pouvez utiliser la méthode app.post (). Cette méthode fonctionne de manière similaire avec app.get (), mais elle est utilisée pour les demandes de publication au lieu des demandes d'obtention. Voici un exemple:
app.post ('/', fonction (req, res) {
res.send ('post requête reçue');
});
dans cet exemple, lorsque Une demande de poste est faite sur le chemin racine ('/'), le serveur répondra avec 'Post Demande reçu'.

Qu'est-ce que le middleware dans Express 4 et comment l'utiliser?

Middleware Les fonctions sont des fonctions qui ont accès à l'objet de demande (REQ), à l'objet de réponse (RES) et à la fonction suivante dans le cycle de demande de demande de l'application. La fonction suivante est une fonction dans le routeur express qui, lorsqu'elle est invoquée, exécute le middleware succédant au middleware actuel. Les fonctions middleware peuvent effectuer les tâches suivantes: exécuter n'importe quel code, apporter des modifications à la demande et aux objets de réponse, à la fin du cycle de demande de réponse, appelez le middleware suivant dans la pile.

Comment gérer les erreurs dans Express 4?

Express 4 fournit un gestionnaire d'erreurs intégré, qui s'occupe des erreurs qui pourraient se produire dans l'application. Si vous avez besoin de gérer des erreurs spécifiques, vous pouvez créer votre propre fonction de middleware d'erreur. Voici un exemple:

app.use (fonction (err, req, res, suivant) {

console.error (err.stack);

res.status (500) .Send ('quelque chose est rompu! ');

});

Dans cet exemple, si une erreur se produit dans l'application, elle sera enregistrée à la console et que le serveur répondra avec un code d'état de 500 et un message de "Quelque chose s'est cassé!".

Comment utiliser les paramètres dans les routes Express 4?

Vous pouvez utiliser les paramètres de route pour capturer les valeurs dynamiques dans l'URL. Ces valeurs peuvent ensuite être utilisées par vos gestionnaires de route. Voici un exemple:
app.get ('/ users /: userid', function (req, res) {
res.send ('user id est:' req.params.userid);
} . Express 4?

Express 4 fournit une fonction middleware intégrée, express.static (), pour servir des fichiers statiques. Vous pouvez l'utiliser pour servir des fichiers à partir d'un répertoire de votre serveur. Voici un exemple:

app.use (express.static ('public'));

Dans cet exemple, les fichiers du répertoire «public» sont accessibles directement à partir de l'URL racine ('/').

Comment utiliser le middleware de carrosserie dans Express 4?

Le middleware de carrosserie est utilisé pour analyser les corps de demande entrants. Cela vous permet d'accéder au corps d'une demande de poste via req.body. Voici un exemple:

var bodyParser = require ('body-parser');

app.use (bodyParser.json ());

app.use (bodyParser.urlencoded ({étendue: true}) . Gérer 404 erreurs dans Express 4?

Vous pouvez gérer 404 erreurs en ajoutant une fonction middleware à la fin de votre pile de middleware. Cette fonction sera exécutée si aucun autre gestionnaire d'itinéraire ou des fonctions middleware n'a traité la demande. Voici un exemple:
app.use (fonction (req, res, suivant) {
res.status (404) .Send ('Désolé, nous ne trouvons pas cela!');

});

Dans cet exemple, si une demande est faite sur un chemin qui n'existe pas, le serveur répondra avec un code d'état de 404 et un message de 'Désolé, nous ne pouvons pas trouver cela!'.

Comment utiliser Express Routeur dans Express 4?

Le routeur Express est une mini-application dans Express 4 qui vous permet d'organiser vos itinéraires de manière modulaire. Vous pouvez créer un nouveau routeur avec express.router (), ajouter des middleware et des itinéraires, puis l'utiliser dans votre application avec app.use (). Voici un exemple:
var router = express.router ();
router.get ('/', fonction (req, res) {

res.send ('bonjour du routeur!');

});

app.use ('/ routeur', routeur);

Dans cet exemple, lorsqu'une demande de get est faite à '/ routeur', le serveur Répondez avec «Bonjour du routeur!».

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!