So erstellen Sie Ihre erste REST -API mit Fastify

Key Takeaways

• Fastify bietet eine leichte und schnelle Alternative zum Erstellen von REST -APIs und übertrifft andere Node.js -Frameworks wie Express und Hapi.
• Einrichten einer Fastify -API beinhaltet einfache Schritte wie das Initialisieren eines Projekts, die Installation von Fasten und das Erstellen von Basisserver- und Routen -Setups.
• Fastify's robustes Plugin -Ökosystem ermöglicht eine einfache Integration und Erweiterung der Funktionen, wodurch die Entwicklererfahrung verbessert wird, ohne das Rad neu zu erfinden.
• Hinzufügen von Schema -Validierung in Fastify stellt sicher, dass API -Anforderungen und Antworten an vordefinierte Formate einhalten und die Zuverlässigkeit und Fehlerbehandlung verbessern.
• Die Verwendung von Fastify -Haken ermöglicht es Entwicklern, verschiedene Lebenszyklusereignisse abzufangen und eine bessere Kontrolle über den Anwendungsfluss und das Verhalten zu bieten.

Fastify ist ein Framework für die Back-End-Webentwicklung. Es bietet eine leichtere Alternative zu schwereren Node.js -API -Frameworks wie Hapi und Express. Ab Juli 2020 hat Fastify seine dritte Version des Frameworks veröffentlicht.

Diese dritte Version verfügt über verbesserte Validierungsfähigkeiten, um eingehende und ausgehende Anforderungen als Anforderungsparameter zu überprüfen. Darüber hinaus konsolidiert die dritte Version des Framework seine Durchsatzansprüche, das schnellste Knoten.js -Framework im Vergleich zu KOA, Resitfy, Hapi und Express zu sein. Weitere Informationen finden Sie auf der Seite Benchmarks.

Fastify hat aufgrund seines leichten Designs viel Popularität gewonnen. Auf sein Plugin -Ökosystem geht jedoch viel Aufmerksamkeit auf sich. Fastify hat die Idee übernommen, dass alles ein Plugin ist, während mit JavaScript alles ein Objekt ist. Auf diese Weise können Sie die Funktionalität für Ihr Projekt schnell als Plugin zusammenfassen und sie verteilen, damit andere Projekte Ihren Code verwenden können.

Beginnen wir mit diesem Tutorial. Sie lernen die folgenden Aspekte von Fastify:

• So richten Sie Ihre erste Fastify -API
ein
• So definieren Sie Fastify -API -Routen
• So fügen Sie die Schema -Validierung zu Anforderungen
hinzu
• So laden und verwenden Sie Fastify -Plugins
• So definieren Sie Fastify Hooks

Anforderungen und Installation

, um diesem Tutorial zu folgen, benötigen Sie:

1. Die neueste Node.js -Version
2. Ein Tool zum Senden von Anfragen wie Locken oder Postman

Erstellen Sie als nächstes ein leeres Node.js -Projekt. Wenn Sie noch keinen haben, können Sie den folgenden Befehl verwenden, um Ihr Projekt einzurichten:

<span>npm init -y
</span>

Schließlich möchten wir unserem Projekt diese Fastify -Abhängigkeit hinzufügen:

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

Alles gut? Erstellen wir im nächsten Schritt unser grundlegendes API -Setup.

Schritt 1: Basic API -Setup

Erstellen wir zuerst unser grundlegendes API -Setup. Um loszulegen, müssen wir eine neue Datei namens Index.js in unserem Projektroot erstellen:

<span>touch index.js
</span>

Fügen Sie als nächstes das grundlegende Server -Setup hinzu. Kopieren Sie den folgenden Code:

<span>npm init -y
</span>

Es passieren hier ein paar Dinge. Wir laden zuerst das Fastify -Anwendungsobjekt und aktivieren die Protokollierung. Als nächstes deklarieren wir eine Stammroute, die mit einer JSON -Antwort antwortet. Der letzte Teil des Code -Snippets zeigt, dass wir auf Port 3000 zuhören, damit die Bewerbung Anfragen erhalten kann.

Lassen Sie uns validieren, wenn Ihr grundlegender Server -Setup funktioniert. Zunächst müssen wir den Server starten, indem wir die Index.js -Datei ausführen:

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

Navigieren Sie danach zu http: // localhost: 3000 in Ihrem Browser. Sie sollten die folgende Antwort sehen:

<span>touch index.js
</span>

Erfolg? Gehen wir zu Schritt 2, um verschiedene CRUD -Routen zu definieren.

Schritt 2: Definieren Sie CRUD -Routen

Eine API ist nutzlos, wenn Sie nur Routen erhalten. Definieren wir mehr Routen für die Behandlung von Blogs. Erstellen wir daher die folgenden Routen:

• Holen Sie sich alle Blogs at /api /Blogs
• Holen Sie sich einen Blog at/api/blogs/: id
• Beitrag hinzufügen Blog at /api /Blogs
• Update -Blog AT/API/Blogs/: ID
• löschen Blog at/api/blogs/: id

Das erste, was zu tun ist, ist ein Blog -Controller zu erstellen.

Schritt 2.1: Erstellen von Blogs Controller

Um unseren Code sauber zu halten, definieren wir einen Controller -Ordner im Projektroot. Hier erstellen wir eine Datei namens blogs.js.

Diese Datei enthält einige Demo -Daten, um das Tutorial mit einer Datenbankintegration zu vermeiden. Daher verwenden wir ein Array mit Blog -Objekten, die jeweils ein ID- und Titelfeld enthalten.

Darüber hinaus definieren wir die verschiedenen Handler für alle oben genannten Routen in dieser Datei. Ein Handler akzeptiert immer einen REQ (Anfrage) und einen Antwortparameter. Der Anforderungsparameter ist nützlich, um auf Anforderungsparameter oder Anforderungskörperdaten zuzugreifen.

Fügen Sie den folgenden Code zu Ihrer Datei /controller/blogs.js -Datei hinzu:

<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>

Beachten Sie, wie wir auf den Anforderungsparameter für Routen wie/api/blogs zugreifen können/: ID über req.params.id. Für Post- und Put -Routen können wir über Req.body auf den Körper der Anfrage zugreifen.

In Schritt 2.2 verbinden wir die Routenhandler mit den Routenobjekten.

Schritt 2.2: Blog -Routen und Paarblogs Controller

Definieren Sie

Definieren Sie, um unseren Code sauber zu halten, einen Routesordner im Projektroot. Hier erstellen wir eine Datei namens Blogs.js. Diese Datei enthält das Routes -Objekt für unsere Blog -Routen:

<span>node index.js
</span>

Zum Glück ermöglicht Fastify es uns, ein Array mit Routenobjekten zu definieren. Hier können wir die Handler koppeln, die wir zuvor auf den verschiedenen Routen definiert haben. Vergessen Sie nicht, den Blogs Controller zu verlangen. Schauen wir uns an:

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

Jetzt haben wir alle Routen definiert. Fastify weiß jedoch nichts über diese Routen. Der nächste Schritt zeigt, wie Sie Routen mit Ihrem Fastify -Anwendungsobjekt registrieren können.

Schritt 2.3: Fastify Routen registrieren

In diesem Schritt registrieren wir Fastify -Routen zum App -Objekt. Zunächst laden wir alle Blog -Routen. Als nächstes werden wir alle Routen überschreiten, um sie nacheinander zu registrieren:

<span>npm init -y
</span>

fertig? Es ist Zeit zu validieren, ob die Blog -Routen funktionieren. Drehen Sie den Server mit node index.js und besuchen Sie http: // localhost: 3000/blogs/1, um das erste Blog aus den Demo -Daten zu erhalten. Sie sollten das folgende Ergebnis sehen:

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

Alles gut? Lassen Sie uns in Schritt 3 lernen, wie Sie Anforderungen und Antworten Schema -Validierung hinzufügen.

Schritt 3: Hinzufügen von Schema -Validierung

Dieser Schritt lehrt Ihnen, wie Sie Ihrem Projekt Schema -Validierung hinzufügen. Wir können den Schemaschlüssel in unserer Routendefinition verwenden, um ein Validierungsschema an einen bestimmten Weg zu übergeben.

Beginnen wir mit der Definition eines Schemas für die Route/API/Blogs/: ID, um den Anforderungsparameter und die Antwort zu validieren. Anforderungen?

1. : Der ID -Parameter muss vom Typ String
sein
2. Antwort muss ein Objekt mit zwei Eigenschaften -ID (Integer) und Title (String)
enthalten

Fügen Sie das folgende Validierungsobjekt zu Ihren Routen/Blogs.js Datei:

hinzu:

<span>touch index.js
</span>

Um das Validierungsobjekt mit unserer Route zu verbinden, müssen wir den Schemaschlüssel definieren. Suchen Sie nach der Route/API/Blogs/: ID im Routes -Array und ändern Sie das Objekt entsprechend:

<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>

Lassen Sie uns dasselbe zum Hinzufügen eines Blog -Beitrags /API /Blogs tun. Hier möchten wir überprüfen, ob das REQ.Body -Objekt einen Titelparameter enthält. Schauen wir uns an:

<span>node index.js
</span>

Als nächstes müssen wir das Validierungsobjekt erneut mit der richtigen Route verbinden:

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

Um unsere Validierung zu überprüfen, lassen Sie uns das Blog mit ID abrufen. 3. Öffnen Sie Ihren Browser unter http: // localhost: 3000/api/blogs/3. Sie sollten die folgende Antwort sehen:

<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>

Machen wir nun einen Fehler und ändern Sie die Params -Validierung für das ID -Feld von Sting zu Objekt wie SO:

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

Wenn Sie dieselbe Ressource aus Ihrer API anfordern, erhalten Sie die folgende Fehlermeldung.

<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>

sehen Sie den Fehler? Gut! Lassen Sie uns die Änderung in die Zeichenfolge zurückkehren, um zukünftige Fehler zu vermeiden und zum nächsten Schritt zu wechseln.

Schritt 4: Fastify -Plugins

laden

Nutzen wir hier das reichhaltige Plugin -Ökosystem von Fastify. Sie können Plugins finden, die Ihnen bei verschiedenen Aufgaben helfen, z. B. Datenbankintegrationen oder Autorisierungsaufbauten. Warum sollten Sie Zeit damit verbringen, Autorisierung von Grund auf neu zu schreiben, während Sie Fastify -Plugins verwenden können? Oft möchten Sie nach Paketen außerhalb des Ökosystems von Fastify suchen, die Ihnen bei bestimmten Problemen oder Aufgaben helfen. Durch die Bereitstellung eines reichhaltigen Plugin-Ökosystems wird Fastify jedoch zu einer One-Stop-Lösung, die das Entwicklererlebnis definitiv verbessert!

Ein kurzer Hinweis zu Plugins: Sie können Ihre eigenen Plugins erstellen, um die Funktionalität zu verkapulieren. Darüber hinaus können Sie diese Plugins in Ihr Fastify -Anwendungsobjekt laden. Standardmäßig lädt Fastify Plugins zuerst aus dem Fastify -Ökosystem. Danach werden benutzerdefinierte Plugins geladen.

ok, lass uns praktisch werden! Ich möchte das Fastify-Env-Plugin verwenden, mit dem Sie bei der Ladeumgebungsvariablen und bei der Einstellung von Standardeinstellungen für jede Variable helfen. Fügen wir daher diese Abhängigkeit zu unserem Projekt hinzu:

<span>npm init -y
</span>

Als nächstes können wir die Abhängigkeit nach dem Laden des Fastify -Anwendungsobjekts in die Datei ideen.js laden. Ihre Index.js -Datei sieht folgt aus:

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

Beachten Sie, dass wir ein Optionsobjekt definieren müssen, das dem Fastify-ENV-Plugin mitteilt, nach welchen Umweltvariablen Sie suchen müssen und welche Standardeinstellungen festgelegt sind. Hier möchte ich eine Portvariable mit einem Standardwert von 1000 laden.

standardmäßig macht das Fastify-Env-Plugin alle Umgebungsvariablen über das Fastify-App-Objekt wie SO: app.config.port verfügbar. Warum? Das Fastify-Env-Plugin hängt die geladenen Konfigurationen an den KonFkey an, der standardmäßig auf die Konfiguration gesetzt ist. Wenn Sie jedoch möchten, können Sie dies in einen anderen Schlüssel ändern.

Starten Sie das Projekt mit Node Index.js und überwachen Sie die Ausgabe. Sie sollten sehen, wie die Portvariable in Ihrem Terminal gedruckt wird.

andere interessante Plugins zu verwenden?

1. Fastify-Auth: Führen Sie mehrere Auth-Funktionen in Fastify
aus
2. Fastify-Träger-Auth: Trägerauth-Plugin für Fastify
3. Fastify-Caching: Allgemeiner serverseitiger Cache und ETAG-Support
4. Fastify-Cors: Ermöglicht die Verwendung von CORs in einer Fastify-Anwendung

Schritt 5: Haken

definieren

definieren wir schließlich einige Haken. Aus der Dokumentation von Fastify Hooks können wir Folgendes lesen. „Hooks sind bei der Methode Fastify.addhook registriert und ermöglichen es Ihnen, bestimmte Ereignisse in der Anwendung oder in der Anforderung/Antwort des Lebenszyklus anzuhören. Sie müssen einen Haken registrieren, bevor das Ereignis ausgelöst wird, andernfalls geht das Ereignis verloren. “

Stellen Sie sicher, dass Sie Haken definieren, bevor Sie alle Routen definieren:

<span>touch index.js
</span>

Wie Sie sehen, akzeptiert die Funktion addhook zuerst den Haken, auf den Sie sich anhören möchten. In unserem Beispiel möchten wir auf neue Routen hören, die bei der Anwendung registriert werden. Als nächstes akzeptiert die Rückruffunktion ein Argument für Routenoptionen, das viele Informationen enthält, z. B. die Routen -URL oder die Routenmethode.

spezifische Details für den Onroute -Hook finden Sie in der Dokumentation.

Beginnen wir die API mit Node Index.js, um festzustellen, welche Routen registriert wurden. Ihre Terminalausgabe sollte so aussehen:

<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>

haben die gleiche Ausgabe? Erfolg! Gleichzeitig war dies das Ende des Fastify -Tutorials. Lassen Sie uns dieses Projekt mit einer kurzen Schlussfolgerung abschließen.

einpacken

Fastify ist ein großartiges, leichtes Projekt, mit dem Sie sein reiches Plugin-Ökosystem verwenden können. Anstatt Funktionalität von Grund auf neu zu erstellen, können Sie vorhandene Plugins verwenden. Mit anderen Worten, Fastify fungiert als One-Stop-Shop für Entwickler und verbessert definitiv die Entwicklererfahrung.

Persönlich mag ich die Fastify -Hooks -Funktionalität, da Sie auf verschiedene Lebenszyklusereignisse in Ihrer Anwendung zuhören können.

Um mehr über Fastify zu erfahren, lesen Sie die folgenden Dokumentationsseiten:

• Wie erstelle ich ein benutzerdefiniertes Plugin?
• Wie füge ich Typscript -Unterstützung hinzu?
• Wie verwendet ich Middleware wie CORS?

Sie können auch das Repo für diese Einführung zu Github überprüfen.

häufig gestellte Fragen (FAQs) zum Erstellen einer REST -API mit Fastify

Was sind die Voraussetzungen, um eine REST -API mit Fastify zu erstellen? Sie sollten auch über Node.js und NPM auf Ihrem Computer installiert sein. Node.js ist eine JavaScript -Laufzeit, mit der Sie JavaScript auf Ihrem Server ausführen können, während NPM ein Paket -Manager für node.js ist, mit dem Sie Pakete installieren und verwalten können, von denen Ihr Projekt abhängt. FASTIFY INSTALLIERT? Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus: NPM Installieren Sie Fastify. Dies wird Fastify in Ihrem aktuellen Projektverzeichnis installieren. Stellen Sie sicher, dass Sie im richtigen Verzeichnis sind, bevor Sie den Befehl ausführen. Ihre Bewerbung. Dann können Sie eine neue Fastify -Instanz erstellen. Hier ist ein grundlegendes Beispiel:

const fastify = Request ('Fastify') ({logger: true})

fastify.listen (3000, (Err, Adresse) => {

if (err) throw err

fastify.log.info (`server zuhören $ {adress}`)

})

Wie definiere ich Routen in Fastify?

In Fastify definieren Sie Routen mithilfe der Routenmethode. Diese Methode nimmt ein Objekt als Argument an, das die Eigenschaften der Route definiert. Hier ist ein Beispiel:

fastify.route ({
Methode: 'get',
url: '/',
Handler: Funktion (Anfrage, Antwort) {
Antwort .Send ({Hallo: 'World'})

}

})

Wie gehe ich mit Fehlern mit Fastify um? Sie können den Code des Antwortobjekts verwenden und Methoden senden, um eine Fehlerantwort zu senden. Hier ist ein Beispiel:

fastify.get ('/error', Funktion (Anfrage, Antwort) {
Antwort.Code (500) .Send (neuer Fehler ('interner Server -Fehler')
})

Wie verwende ich Plugins in Fastify? Sie können die Registermethode verwenden, um ein Plugin zu registrieren. Hier ist ein Beispiel:

fastify.register (fordert ('Fastify-Cors'), {

Ursprung: True

})

Wie validiere ich Anfragen in Fastify? Sie können diese Bibliothek verwenden, um eingehende Anforderungen zu validieren und ausgehende Antworten zu serialisieren. Hier ist ein Beispiel:

fastify.route ({
Methode: 'post',
url: '/validate',
Schema: {
Körper: {
Typ: 'Objekt',
Erforderlich: ['Name', 'E -Mail'],
Eigenschaften: {
Name: {Typ: 'String'},
E -Mail: {Typ: 'String:' String '}
}
}
},
Handler: Funktion (Anfrage, Antwort) {
Antwort.Send ({Hello:' World '})
}
} )

Wie teste ich meine Fastify -Anwendung? Hier ist ein Beispiel:

fastify.inject ({

Methode: 'get',

url: '/',
}, (err, reaktion) => {
console.log (response.payload)
})

Wie bereitete ich meine Fastify -Anwendung bereit? Sie können Plattformen wie Heroku, AWS oder Google Cloud Platform verwenden. Stellen Sie sicher, dass die Variable der node_env -Umgebungsvariable bei der Bereitstellung Ihrer Anwendung auf die Produktion festgelegt wird. Sie können die Async/Awed -Syntax in Ihren Routenhandlern verwenden, um asynchrone Code auf lesbare Weise zu schreiben. Hier ist ein Beispiel:

fastify.get ('/async', async -Funktion (Anfrage, Antwort) {

const result = erwarten >

Das obige ist der detaillierte Inhalt vonSo erstellen Sie Ihre erste REST -API mit Fastify. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!