Comment créer votre première API REST avec FASTIFY-js tutoriel-php.cn

Comment créer votre première API REST avec FASTIFY

Les plats clés

Fastify fournit une alternative légère et rapide pour construire des API REST, surperformant d'autres cadres Node.js comme Express et Hapi.
La configuration d'une API Fastify implique des étapes simples telles que l'initialisation d'un projet, l'installation de Fintify et la création de configurations de serveur de base et de route.
Facifier l'écosystème du plugin robuste permet une intégration et une extension faciles des fonctionnalités, améliorant l'expérience du développeur sans réinventer la roue.
L'ajout de validation du schéma dans Fusttify garantit que les demandes et les réponses de l'API adhèrent aux formats prédéfinis, améliorant la fiabilité et la gestion des erreurs.
L'utilisation de crochets de Fitftify permet aux développeurs d'intercepter divers événements de cycle de vie, offrant un plus grand contrôle sur le flux et le comportement de l'application.

Fastify est un framework conçu pour le développement Web back-end. Il offre une alternative plus légère aux cadres API Node.js plus lourds, tels que HAPI et Express. À partir de juillet 2020, Fastify a publié sa troisième version du framework.

Cette troisième version est livrée avec des capacités de validation améliorées pour vérifier les demandes entrantes et sortantes, comme paramètres de demande. De plus, la troisième version du cadre consolide ses prétentions de débit d'être le cadre Node.js le plus rapide par rapport à KOA, Resitfy, HAPI et Express. Plus d'informations peuvent être trouvées sur la page Benchmarks.

Fastify a gagné en popularité en raison de sa conception légère. Cependant, beaucoup d'attention va à son écosystème de plugin. Fastify a adopté l'idée que tout est un plugin, alors qu'avec JavaScript, tout est un objet. Cela vous permet de résumer rapidement les fonctionnalités de votre projet en tant que plugin et de la distribuer afin que d'autres projets puissent utiliser votre code.

Commençons par ce tutoriel. Vous apprendrez les aspects suivants de Fintify:

Comment configurer votre première API FASCTIFIE
comment définir les routes API de tempête
Comment ajouter la validation du schéma aux demandes
Comment charger et utiliser Fintify Plugins
comment définir les crochets de stabilisation

Exigences et installation

Pour suivre ce tutoriel, vous aurez besoin:

La dernière version Node.js
Un outil pour envoyer des demandes, tels que Curl ou Postman

Ensuite, assurez-vous de créer un projet Node.js vide. Si vous n'en avez pas encore, vous pouvez utiliser la commande suivante pour configurer votre projet:

<span>npm init -y
</span>

Copier après la connexion

Enfin, nous voulons ajouter cette dépendance à Notting à notre projet:

<span>npm i fastify --save
</span>

Copier après la connexion

tout bien? Créons notre configuration de base de l'API à l'étape suivante.

Étape 1: Configuration de l'API de base

Tout d'abord, créons notre configuration de base de l'API. Pour commencer, nous devons créer un nouveau fichier appelé index.js dans notre projet Root:

<span>touch index.js
</span>

Copier après la connexion

Ensuite, ajoutons la configuration du serveur de base. Copiez le code ci-dessous:

<span>npm init -y
</span>

Copier après la connexion

Il se passe quelques choses ici. Nous chargeons d'abord l'objet d'application Fastify et activons la journalisation. Ensuite, nous déclarons une voie fondamentale qui répond avec une réponse JSON. La dernière partie de l'extrait de code montre que nous écoutons sur le port 3000 pour que l'application reçoive des demandes.

Valissons si votre configuration de serveur de base fonctionne. Tout d'abord, nous devons démarrer le serveur en exécutant le fichier index.js:

<span>npm i fastify --save
</span>

Copier après la connexion

Par la suite, accédez à http: // localhost: 3000 dans votre navigateur. Vous devriez voir la réponse suivante:

<span>touch index.js
</span>

Copier après la connexion

succès? Passons à l'étape 2 pour définir différentes routes crud.

Étape 2: Définissez les routes crud

Une API est inutile avec uniquement des itinéraires. Définissons plus d'itinéraires pour gérer les blogs. Par conséquent, créons les routes suivantes:

Obtenez tous les blogs sur / api / blogs
Obtenez un blog sur / api / blogs /: id
Publier un blog sur / API / Blogs
Mettez le blog de mise à jour sur / api / blogs /: id
Supprimer le blog Supprimer sur / api / blogs /: id

La première chose à faire est de créer un contrôleur de blog.

Étape 2.1: Créer des blogs Controller

Pour garder notre code propre, définissons un dossier de contrôleur dans la racine du projet. Ici, nous créons un fichier appelé blogs.js.

Ce fichier contient des données de démonstration pour éviter de compliquer ce tutoriel avec une intégration de base de données. Par conséquent, nous utilisons un tableau contenant des objets de blog qui contiennent chacun un champ d'identification et de titre.

De plus, nous définissons les différents gestionnaires de tous les routes ci-dessus dans ce fichier. Un gestionnaire accepte toujours un paramètre REQ (demande) et de réponse. Le paramètre de demande est utile pour accéder aux paramètres de demande ou aux données du corps de la demande.

Ajoutez le code suivant à votre fichier /Controller/blogs.js:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

Copier après la connexion

Notez comment nous pouvons accéder au paramètre de demande pour les itinéraires tels que / api / blogs /: id via req.params.id. Pour les itinéraires de publication et de pose, nous pouvons accéder au corps de la demande via req.body.

À l'étape 2.2, nous connecterons les gestionnaires de route aux objets de route.

Étape 2.2: Définir les routes de blog et le contrôleur de blogs de couple

Encore une fois, pour garder notre code propre, définissons un dossier de routes dans la racine du projet. Ici, nous créons un fichier appelé blogs.js. Ce fichier contient l'objet Routes pour nos routes de blog:

<span>node index.js
</span>

Copier après la connexion

Heureusement, Fastify nous permet de définir un tableau contenant des objets d'itinéraire. Ici, nous pouvons coupler les gestionnaires que nous avons définis précédemment sur les différentes routes. N'oubliez pas d'exiger le contrôleur des blogs. Jetons un coup d'œil:

<span>{
</span>    <span>"hello": "world"
</span><span>}
</span>

Copier après la connexion

Maintenant, nous avons défini tous les itinéraires. Cependant, Fintify ne connaît pas ces itinéraires. L'étape suivante montre comment vous pouvez enregistrer les itinéraires avec votre objet d'application Fastify.

Étape 2.3: Enregistrer les routes accumulées

Dans cette étape, nous enregistrerons les routes Stapify vers l'objet APP. Tout d'abord, nous chargeons tous les itinéraires de blog. Ensuite, nous bouclent sur tous les itinéraires pour les enregistrer un par un:

<span>npm init -y
</span>

Copier après la connexion

fait? Il est temps de valider si les routes du blog fonctionnent. Tournez le serveur à l'aide de Node index.js et visitez http: // localhost: 3000 / blogs / 1 pour obtenir le premier blog à partir des données de démonstration. Vous devriez voir le résultat suivant:

<span>npm i fastify --save
</span>

Copier après la connexion

tout bien? Apprenons à l'étape 3 comment ajouter la validation du schéma aux demandes et aux réponses.

Étape 3: Ajout de la validation du schéma

Cette étape vous apprend à ajouter une validation de schéma à votre projet. Nous pouvons utiliser la clé de schéma dans notre définition de routes pour passer un schéma de validation à une route particulière.

Commençons par définir un schéma pour la route / API / Blogs /: ID pour valider le paramètre et la réponse de la demande. Exigences?

: le paramètre ID doit être de type chaîne
La réponse doit contenir un objet avec deux propriétés ID (entier) et titre (String)

Ajoutez l'objet de validation suivant à vos itinéraires / blogs.js Fichier:

<span>touch index.js
</span>

Copier après la connexion

pour connecter l'objet de validation à notre itinéraire, nous devons définir la clé de schéma. Recherchez la route / API / Blogs /: ID dans le tableau des routes et modifiez l'objet en conséquence:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

Copier après la connexion

faisons de même pour ajouter un article de blog / API / blogs. Ici, nous voulons vérifier si l'objet req.body contient un paramètre de titre. Jetons un coup d'œil:

<span>node index.js
</span>

Copier après la connexion

Ensuite, nous devons à nouveau connecter l'objet de validation à la route correcte:

<span>{
</span>    <span>"hello": "world"
</span><span>}
</span>

Copier après la connexion

Pour vérifier notre validation, récupérons le blog avec ID 3. Ouvrez votre navigateur sur http: // localhost: 3000 / api / blogs / 3. Vous devriez voir la réponse suivante:

<span>// Demo data
</span><span>let blogs = [
</span>    <span>{
</span>        <span>id: 1,
</span>        <span>title: 'This is an experiment'
</span>    <span>},
</span>    <span>{
</span>        <span>id: 2,
</span>        <span>title: 'Fastify is pretty cool'
</span>    <span>},
</span>    <span>{
</span>        <span>id: 3,
</span>        <span>title: 'Just another blog, yea!'
</span>    <span>}
</span><span>]
</span>
<span>// Handlers
</span><span>const getAllBlogs = async (req<span>, reply</span>) => {
</span>    <span>return blogs
</span><span>}
</span>
<span>const getBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id) // blog ID
</span>    <span>const blog = blogs.find(blog => blog.id === id)
</span>    <span>return blog
</span><span>}
</span>
<span>const addBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = blogs.length + 1 // generate new ID
</span>    <span>const newBlog = {
</span>        id<span>,
</span>        <span>title: req.body.title
</span>    <span>}
</span>
    blogs<span>.push(newBlog)
</span>    <span>return newBlog
</span><span>}
</span>
<span>const updateBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id)
</span>    blogs <span>= blogs.map(blog => {
</span>        <span>if (blog.id === id) {
</span>            <span>return {
</span>                id<span>,
</span>                <span>title: req.body.title
</span>            <span>}
</span>        <span>}
</span>    <span>})
</span>
    <span>return {
</span>        id<span>,
</span>        <span>title: req.body.title
</span>    <span>}
</span><span>}
</span>
<span>const deleteBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id)
</span>
    blogs <span>= blogs.filter(blog => blog.id !== id)
</span>    <span>return { msg: <span>`Blog with ID <span>${id}</span> is deleted`</span> }
</span><span>}
</span>
module<span>.exports = {
</span>    getAllBlogs<span>,
</span>    getBlog<span>,
</span>    addBlog<span>,
</span>    updateBlog<span>,
</span>    deleteBlog
<span>}
</span>

Copier après la connexion

Maintenant, faisons une erreur et modifions la validation des paramètres pour le champ ID de Sting à l'objet comme:

<span>mkdir routes
</span><span>cd routes
</span><span>touch blogs.js
</span>

Copier après la connexion

Lorsque vous demandez la même ressource à votre API, vous recevrez le message d'erreur suivant.

<span>const blogController = require('../controller/blogs');
</span>
<span>const routes = [{
</span>        <span>method: 'GET',
</span>        <span>url: '/api/blogs',
</span>        <span>handler: blogController.getAllBlogs
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'GET',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.getBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'POST',
</span>        <span>url: '/api/blogs',
</span>        <span>handler: blogController.addBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'PUT',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.updateBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'DELETE',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.deleteBlog
</span>    <span>}
</span><span>]
</span>module<span>.exports = routes
</span>

Copier après la connexion

Voyez-vous l'erreur? Bien! Revenons le changement en chaîne pour éviter les erreurs futures et passant à l'étape suivante.

Étape 4: Chargez les plugins agités

Ici, utilisons l'écosystème du plugin riche de Facitif. Vous pouvez trouver des plugins qui vous aident avec diverses tâches, telles que les intégrations de base de données ou les configurations d'autorisation. Pourquoi passez-vous du temps à écrire l'autorisation à partir de zéro pendant que vous pouvez utiliser les plugins Stacify? Souvent, vous voulez rechercher des forfaits en dehors de l'écosystème de Fastify qui vous aident avec certains problèmes ou tâches. Cependant, en fournissant un écosystème de plugin riche, Fitftified devient une solution à guichet unique qui améliore définitivement l'expérience du développeur!

Une note rapide sur les plugins: vous pouvez créer vos propres plugins pour encapsuler les fonctionnalités. De plus, vous pouvez charger ces plugins à votre objet d'application Fintify. Par défaut, Fastify chargera d'abord les plugins à partir de l'écosystème FASCIFY. Par la suite, les plugins personnalisés sont chargés.

ok, soyons pratiques! Je voudrais utiliser le plugin FASTIFY-ENV, qui vous aide à charger des variables d'environnement et à définir les défauts par défaut pour chaque variable. Par conséquent, ajoutons cette dépendance à notre projet:

<span>npm init -y
</span>

Copier après la connexion

Ensuite, nous pouvons charger la dépendance après le chargement de l'objet d'application Fintify dans le fichier index.js. Votre fichier index.js ressemble à ceci:

<span>npm i fastify --save
</span>

Copier après la connexion

Notez que nous devons définir un objet Options qui indique au plugin Fastify-env ce que les variables enviennent et qui par défaut définissent par défaut. Ici, je souhaite charger une variable de port avec une valeur par défaut de 1000.

Par défaut, le plugin FASTIFY-ENV mettra toutes les variables d'environnement disponibles via l'objet APP FASTIFY comme: app.config.port. Pourquoi? Le plugin Fastify-env attache les configurations chargées à la confkey, qui par défaut est définie sur config. Cependant, si vous le souhaitez, vous pouvez changer cela en une autre clé.

Démarrez le projet avec Node index.js et surveillez la sortie. Vous devriez voir la variable de port imprimée dans votre terminal.

d'autres plugins intéressants à utiliser?

FASTIFY-AUTH: Exécutez plusieurs fonctions Auth dans Fastify
Fastify-Bear-Auth: Bearer Auth Plugin pour Fintify
FASTIFY-CACHING: CACHE GÉNÉRALE CACE SIDE ET ETAG SUPPORT
FASTIFY-CORS: Permet l'utilisation de COR dans une application Fastify

Étape 5: Définir les crochets

Enfin, définissons quelques crochets. À partir de la documentation Fastify Hooks, nous pouvons lire ce qui suit. «Les crochets sont enregistrés auprès de la méthode FASTIFY.AddHook et vous permettent d'écouter des événements spécifiques dans le cycle de vie de l'application ou de la demande / réponse. Vous devez enregistrer un crochet avant le déclenchement de l'événement, sinon l'événement est perdu. »

Assurez-vous de définir des crochets avant de définir les itinéraires:

<span>touch index.js
</span>

Copier après la connexion

Comme vous pouvez le voir, la fonction AddHook accepte d'abord le crochet que vous souhaitez écouter. Dans notre exemple, nous voulons écouter les nouveaux itinéraires enregistrés auprès de l'application. Ensuite, la fonction de rappel accepte un argument RouteOptions qui contient beaucoup d'informations, telles que l'URL de route ou la méthode de route.

Des détails spécifiques pour le crochet OnRoute peuvent être trouvés dans la documentation.

Commençons l'API avec Node index.js pour voir quels itinéraires ont été enregistrés. Votre sortie terminale doit ressembler à ceci:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

Copier après la connexion

Vous avez la même sortie? Succès! Dans le même temps, c'était la fin du tutoriel FASCIFY. Replissons ce projet avec une courte conclusion.

Envelopper

Fastify est un excellent projet léger qui vous permet d'utiliser son riche écosystème de plugin. Au lieu de créer des fonctionnalités à partir de zéro, vous pouvez utiliser les plugins existants. En d'autres termes, Fastify agit comme un guichet unique pour les développeurs, améliorant définitivement l'expérience des développeurs.

Personnellement, j'aime les fonctionnalités de stabilisation des crochets car vous pouvez écouter divers événements de cycle de vie au sein de votre application.

Pour en savoir plus sur Fintify, consultez les pages de documentation suivantes:

Comment créer un plugin personnalisé?
comment ajouter la prise en charge de TypeScript?
Comment utiliser les middleware comme CORS?

Vous pouvez également consulter le dépôt de cette introduction sur github.

Les questions fréquemment posées (FAQ) sur la création d'une API REST avec Fastify

Quelles sont les conditions préalables à la création d'une API REST avec FASCIFY?

Avant de commencer à créer une API REST avec Fusttifie, vous devez avoir une compréhension de base de JavaScript et Node.js. Vous devez également faire installer Node.js et NPM sur votre ordinateur. Node.js est un runtime javascript qui vous permet d'exécuter JavaScript sur votre serveur, tandis que NPM est un gestionnaire de packages pour node.js qui vous permet d'installer et de gérer les packages dont votre projet dépend.

Comment puis-je Installer Fintify?

Vous pouvez installer FASCIFY à l'aide de NPM, le gestionnaire de package Node.js. Ouvrez votre terminal et exécutez la commande suivante: NPM Install Fitchy. Cela installera Fastify dans votre répertoire de projet actuel. Assurez-vous que vous êtes dans le répertoire correct avant d'exécuter la commande.

Comment puis-je créer un serveur avec Fintify?

Pour créer un serveur avec Fastify, vous devez d'abord exiger le module Fastify votre application. Ensuite, vous pouvez créer une nouvelle instance Fastify. Voici un exemple de base:

constance fastify = require ('fastify') ({logger: true})

fastify.Listen (3000, (err, adresse) => {
if (err) lancer err
fastiftify.log.info (`serveur écoutant sur $ {adresse}`)
})

comment définir les routes dans Fastify?

Dans Fintify, vous définissez les routes à l'aide de la méthode de route. Cette méthode prend un objet comme argument, qui définit les propriétés de l'itinéraire. Voici un exemple:

FASTIFY.ROUTE ({
Méthode: 'Get',
URL: '/',
Handler: fonction (demande, réponse) {
Répondre .Send ({Hello: 'World'})
}
})

Comment gérer les erreurs dans Fastify?

FASTIFY Fournit un mécanisme de gestion des erreurs intégré. Vous pouvez utiliser le code de l'objet de réponse et envoyer des méthodes pour envoyer une réponse d'erreur. Voici un exemple:

fastify.get ('/ error', fonction (demande, réponse) {
Répondre.code (500) .Send (nouvelle erreur ('Erreur du serveur interne'))
})

Comment utiliser les plugins dans Fastify?

Fastify a une puissante architecture de plugin qui vous permet d'étendre ses fonctionnalités. Vous pouvez utiliser la méthode de registre pour enregistrer un plugin. Voici un exemple:

fastify.register (require ('Fastify-Cors'), {
Origin: true
})

Comment valider les demandes dans Fastify?

Fastify fournit une bibliothèque de validation et de sérialisation intégrée appelée Fastify-Schema. Vous pouvez utiliser cette bibliothèque pour valider les demandes entrantes et sérialiser les réponses sortantes. Voici un exemple:

FASTIFY.ROUTE ({
Méthode: 'Post',
URL: '/ valider',
schéma: {
corps: {
Type: 'Object',
Obligatoire: ['name', 'e-mail'],
Propriétés: {
name: {type: 'String'},
e-mail: {type: 'String '}
}
}
},
Handler: function (demande, réponse) {
Répondre.send ({Hello:' World '})
}
} . Voici un exemple:

fastify.inject ({

Méthode: 'get',

url: '/',
}, (err, réponse) => {
console.log (réponse.payload)
})

Comment déployer mon application Fastify?

Vous pouvez déployer votre application Fastify comme toute autre application Node.js. Vous pouvez utiliser des plates-formes comme Heroku, AWS ou Google Cloud Platform. Assurez-vous de définir la variable d'environnement Node_env sur la production lors du déploiement de votre application.

Comment gérer le code asynchrone dans Fintify?

FASCIFY PASSIE PASSE SOUTES à la fois des rappels et des promesses pour la gestion du code asynchrone. Vous pouvez utiliser la syntaxe async / attendre dans vos gestionnaires d'itinéraire pour écrire du code asynchrone de manière plus lisible. Voici un exemple: