Erstellen Sie erholsame APIs mit Express 4

Mit der Veröffentlichung von Express 4 ist es noch einfacher geworden, erholsame APIs zu erstellen. Wenn Sie eine einzelne Seiten -App erstellen, benötigen Sie definitiv einen erholsamen Webdienst, der CRUD -Operationen unterstützt. Mein letztes Tutorial konzentrierte sich auf das Erstellen einer einzelnen CRUD -App mit Angulars $ Resource. In diesem Tutorial wird erklärt

Beachten Sie nur, dass sich seit Express viel geändert hat. In diesem Tutorial wird nicht erklärt, wie Sie Ihre App von Express 3 auf Express aufrüsten können. Also fangen wir an.

Key Takeaways

Express 4 vereinfacht die Erstellung von erholsamen APIs und erleichtert es, Backend -APIs für CRUD -Anwendungen zu entwerfen.
Express 4 muss den Körper-Parser separat herunterladen, da er nicht mehr Teil des Express-Kerns ist. Dieses Modul wird verwendet, um eingehende Anforderungskörper zu analysieren, um den Zugriff auf den Körper einer Postanforderung über Req.body zu ermöglichen.
Die Express 4 -Methode Express.router () erstellt eine neue Routerinstanz, die Middlewares und Routen definieren kann. Diese Routerinstanz kann dann in der Haupt -App wie jede andere Middleware verwendet werden, indem Sie app.use ().
• aufrufen.
Express 4 unterstützt Standard -HTTP -Methoden wie GET, Post, Put und Löschen, um Crud -Operationen in einer Datenbank durchzuführen, in diesem Fall eine Filmdatenbank. Dies geschieht durch das Erstellen von Routen, die diese HTTP -Anfragen verarbeiten.

Erstellen der API für die Film -App

Unsere App wird eine einfache Filmdatenbank sein, die grundlegende CRUD -Operationen unterstützt. Wir werden Express 4 als Web Framework und MongooseJs als Objektmodellierungs -Tool verwenden. Um die Filmeinträge zu speichern, werden wir MongoDB verwenden.

Bevor wir weiter gehen, schauen wir uns an, wie die API aussehen wird:

Verzeichnisstruktur

Wir werden die folgende Verzeichnisstruktur in unserer App verwenden:

Hier sind einige Punkte zur obigen Verzeichnisstruktur:

Der bin/www.js wird verwendet, um unsere App zu starten.
Das Models -Verzeichnis speichert unsere Mongoose -Modelle. Für diese App haben wir nur eine Datei namens Movie.js.
Das Routes -Verzeichnis speichert alle Expressrouten.
Die App.js hält die Konfigurationen für unsere Express -App.

Schließlich sind node_modules und package.json die üblichen Komponenten einer node.js -App.

notwendige Abhängigkeiten erhalten

Um die API zu erstellen, werden wir die folgenden Module verwenden:

Express
Body Parser
mongoose

Hinweis-Body-Parser ist kein Teil des Expresskerns mehr. Sie müssen das Modul separat herunterladen. Also haben wir es im Paket aufgelistet. Json.

Um diese Pakete zu erhalten, werden wir sie als Abhängigkeiten in unserem Paket.json auflisten. Hier ist unsere Package.json -Datei:

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

Führen Sie einfach die NPM -Installation aus und alle Abhängigkeiten werden heruntergeladen und unter das Verzeichnis node_modules gelegt.

Erstellen des Modells

Da wir eine API für eine Filmdatenbank erstellen, werden wir ein Filmmodell erstellen. Erstellen Sie eine Datei namens Movie.js und setzen Sie sie in das Models -Verzeichnis. Der unten gezeigte Inhalt dieser Datei erstellen ein Mongoose -Modell.

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

Im vorherigen Snippet erstellen wir ein neues Modell, Film. Jeder Film hat vier Eigenschaften, die damit verbunden sind - Titel, Veröffentlichungsjahr, Regisseur und Genre. Schließlich setzen wir das Modell in das modul.exports ein, damit wir von außen darauf zugreifen können.

Erstellen der Routen

Alle unsere Routen gehen in Routen/Filme.js. Fügen Sie zunächst Folgendes in Ihre Filme hinzu.js Datei:

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

Express 4 hat eine neue Methode namens Express.router (), die uns eine neue Routerinstanz gibt. Es kann verwendet werden, um Middlewares und Routen zu definieren. Der interessante Punkt über Express Router ist, dass es wie eine Mini -Anwendung ist. Sie können Middlewares und Routen mit diesem Router definieren und sie dann einfach in Ihrer Haupt -App verwenden, genau wie jede andere Middleware, indem Sie App.USE () aufrufen.

Alle Filme bekommen

Wenn Benutzer eine Get -Anfrage an /api /Filme senden, sollten wir ihnen eine Antwort mit allen Filmen senden. Hier ist der Ausschnitt, der dafür eine Route schafft.

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 () gibt eine einzelne Routeninstanz zurück, mit der ein oder mehrere HTTP -Verben konfiguriert werden können. Hier möchten wir eine Anfrage erhalten. Wir rufen also Get () an und geben einen Rückruf weiter, der aufgerufen wird, wenn eine Anfrage eintrifft. Im Rückruf rufen wir alle Filme mit Mongoose ab und senden sie als JSON an den Kunden zurück.

Erstellen eines neuen Films

Unsere API sollte einen neuen Film in der Datenbank erstellen, wenn eine Postanforderung an /api /filme gemacht wird. Eine JSON -Zeichenfolge muss als Anfragegremium gesendet werden. Wir werden dieselbe Route, /Filme verwenden, aber die Methode post () anstelle von GET () verwenden.

Hier ist der 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>

Hier erstellen wir eine neue Filminstanz aus der Anfrage. Hier wird Body-Parser verwendet. Dann speichern wir einfach den neuen Film und senden eine Antwort, die angibt, dass die Operation erfolgreich ist.

Beachten Sie, dass die Methoden Get (), post () usw. die gleiche Route -Instanz zurückgeben. Sie können also die beiden vorherigen Aufrufe wie unten gezeigt ketten.

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>

Aktualisieren eines Films

Wenn Benutzer einen Film aktualisieren möchten, müssen sie eine Put -Anfrage an/api/films/: id mit einer JSON -String als Anforderungsbehörde senden. Wir verwenden den benannten Parameter: ID, um auf einen vorhandenen Film zuzugreifen. Während wir MongoDB verwenden, haben alle unsere Filme eine eindeutige Kennung namens _id. Wir müssen also nur den Parameter abrufen: ID und verwenden ihn, um einen bestimmten Film zu finden. Der Code zu diesem ist unten angezeigt.

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

Hier erstellen wir eine neue Route /Filme /: ID und verwenden die Methode Put (). Der Invokation von Movie.Findone ({_id: req.params.id}) wird verwendet, um den Film zu finden, dessen ID in der URL übergeben wird. Sobald wir die Filminstanz haben, aktualisieren wir sie basierend auf dem in der Anfragekörper verabschiedeten JSON. Schließlich speichern wir diesen Film und senden eine Antwort an den Kunden.

Abrufen eines Films

Um einen einzelnen Film zu lesen, müssen Benutzer eine Get -Anfrage an die Route/API/Movies/: ID senden. Wir werden dieselbe Route wie oben verwenden, aber diesmal Get () verwenden.

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

Der Rest des Codes ist ziemlich einfach. Wir rufen einen Film basierend auf der bestandenen ID ab und senden ihn an den Benutzer.

Löschen eines Films

Um einen Film zu löschen, sollten Benutzer eine Löschenanforderung an/api/filme senden/: id. Auch hier ist die Route die gleiche wie oben, aber die Methode ist unterschiedlich (d. H. Delete ()).

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

The Method Movie.Remove () löscht einen Film aus der Datenbank, und wir senden eine Nachricht an den Benutzer, der den Erfolg anzeigt.

Jetzt sind wir alle eingestellt. Aber warte! Wir müssen die Routerinstanz in das modul.exports einstellen, damit wir sie in unserer App als Middlewaree verwenden können. Dies ist also die letzte Zeile in den Dateifilmen.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>

Konfigurieren der App

Alle unsere Konfigurationen gehen in app.js. Wir benötigen zunächst die erforderlichen Module:

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>

Der nächste Schritt ist die Verbindung zu MongoDB über 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>

Schließlich konfigurieren wir die 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>

Wie Sie sehen, habe ich den Router wie jede andere Middleware verwendet. Ich habe /API als erstes Argument an app.use () bestanden, damit die Route Middleware /API zugeordnet ist. Am Ende werden unsere API -URLs:

/api/movies
/api/filme/: id

Bootstrapping

Der folgende Code geht in bin/www.js, das unsere App startet:

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>

Wenn Sie Knoten bin/www.js ausführen, sollte Ihre API hoch sein!

Testen Sie die API

Jetzt, da wir die API erstellt haben, sollten wir sie testen, um sicherzustellen, dass alles wie erwartet funktioniert. Sie können Postman, eine Chromverlängerung, verwenden, um alle Ihre Endpunkte zu testen. Hier sind ein paar Screenshots, die Post anzeigen und Anfragen erhalten, die im Postman getestet werden.

Schlussfolgerung

Dies war ein grundlegender Überblick darüber, wie Sie mit Node und Express leicht apis erstellen können. Wenn Sie tiefer in Express eintauchen möchten, lesen Sie unbedingt ihre Dokumente. Wenn Sie etwas hinzufügen oder fragen möchten, können Sie bitte einen Kommentar abgeben.

Der Quellcode für die App steht auf GitHub zum Download zur Verfügung.

häufig gestellte Fragen (FAQs) zum Erstellen von erholsamen APIs mit Express 4

Was ist der Unterschied zwischen erholsamen APIs und andere Arten von APIs? Sie sind staatenlos, was bedeutet, dass jede Anfrage eines Clients an einen Server alle Informationen enthalten muss, die zum Verständnis und zur Verarbeitung der Anfrage erforderlich sind. Dies unterscheidet sich von anderen Arten von APIs, wie z. B. Seife, die den Zustand zwischen Anfragen aufrechterhalten können. RESTful -APIs verwenden auch Standard -HTTP -Methoden, z. 4 Sie können eine grundlegende Route mit der Methode App.get () erstellen. Diese Methode nimmt zwei Argumente an: den Pfad und eine Rückruffunktion. Die Rückruffunktion wird ausgeführt, wenn eine GET -Anforderung an den angegebenen Pfad gestellt wird. Hier ist ein Beispiel:

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

res.send ('Hallo Welt!'); Eine Get -Anfrage wird an den Root -Pfad ('/') gestellt, der Server wird mit 'Hallo Welt!' antworten. Postanfragen in Express 4, Sie können die Methode app.post () verwenden. Diese Methode funktioniert ähnlich wie app.get (), wird jedoch für Postanforderungen anstelle von GET -Anforderungen verwendet. Hier ist ein Beispiel:

app.post ('/', Funktion (req, res) {

res.send ('Post -Anforderung empfangen');

}); Eine Postanforderung wird an den Root -Pfad ('/') gestellt, der Server antwortet mit "Postanforderung empfangen".

Was ist Middleware in Express 4 und wie benutze ich sie? > Middleware Funktionen sind Funktionen, die Zugriff auf das Anforderungsobjekt (REQ), das Antwortobjekt (RES) und die nächste Funktion im Anforderungs-Wirkungs-Zyklus der Anwendung haben. Die nächste Funktion ist eine Funktion im Express -Router, die beim Aufrufen die Middleware ausführt und die aktuelle Middleware ausführt. Middleware-Funktionen können die folgenden Aufgaben ausführen: Führen Sie einen beliebigen Code aus, ändern Sie Änderungen an der Anforderung und die Antwortobjekte, beenden Sie den Anforderungs-Response-Zyklus, rufen Sie die nächste Middleware im Stapel an. 4?

Express 4 enthält einen integrierten Fehlerhandler, der alle in der App aufgetretenen Fehler kümmert. Wenn Sie bestimmte Fehler behandeln müssen, können Sie Ihre eigene Middleware-Funktion für Fehlerhandling erstellen. Hier ist ein Beispiel:
app.use (Funktion (Err, Req, Res, Next) {

console.Error (err.stack);

res.status (500) .Send ('etwas brach! '); "Etwas ist gebrochen!".

Wie verwende ich Parameter in Express -4 -Routen?

Sie können Routenparameter verwenden, um dynamische Werte in der URL zu erfassen. Diese Werte können dann von Ihren Routenhandlern verwendet werden. Hier ist ein Beispiel:
app.get ('/user/: userID', Funktion (req, res) {
res.send ('Benutzer -ID ist:' req.params.userid);
} )
In diesem Beispiel antwortet der Server mit 'Benutzer -ID: 123'. Express 4?

Express 4 bietet eine integrierte Middleware-Funktion express.static () zum Servieren statischer Dateien. Sie können es verwenden, um Dateien aus einem Verzeichnis auf Ihrem Server zu servieren. Hier ist ein Beispiel:

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

Wie verwende ich die Body-Parser Middleware in Express 4? Auf diese Weise können Sie über Req.body auf den Körper einer Postanforderung zugreifen. Hier ist ein Beispiel:
var bodyparser = required ('body-parser');
app.use (bodyparser.json ()); ); Behandle ich 404 Fehler in Express 4? Diese Funktion wird ausgeführt, wenn keine anderen Routenhandler oder Middleware -Funktionen die Anfrage bearbeitet haben. Hier ist ein Beispiel:

app.use (Funktion (req, res, next) {

res.status (404) .send ('Entschuldigung, wir können das nicht finden!');

});

In diesem Beispiel antwortet der Server mit einem Statuscode von 404 und einer Nachricht von "Entschuldigung, wir können das nicht finden!" Wie benutze ich Express Router in Express 4?

Expressrouter ist eine Mini-Anwendung in Express 4, mit der Sie Ihre Routen modular organisieren können. Sie können einen neuen Router mit Express.router () erstellen, Middleware und Routen hinzufügen und dann in Ihrer App mit App.Use () verwenden. Hier ist ein Beispiel:
var router = express.router ();
});

app.use ('/Router', Router); Antworte mit "Hallo aus dem Router!".

Das obige ist der detaillierte Inhalt vonErstellen Sie erholsame APIs mit Express 4. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!