Erstellen eines RESTful-Backends mit Node.js

REST (repräsentative Zustandsübertragung) ist ein Architekturstil für die Entwicklung von Webdiensten, der die Verwendung der HTTP-Anforderungstypen so befürwortet, wie sie ursprünglich beabsichtigt waren. ERHALTEN Anfragen sind für Suchen, STELLEN Anfragen sind für Mutation, POST Anfragen sind für die Erstellung, und LÖSCHEN Anträge auf Löschung. REST erfordert auch, dass der Client nichts über die Struktur der API wissen muss, damit sie verwendet werden kann.

In diesem Artikel betrachten wir den Prozess zum Erstellen eines modernen Backends für eine Notizanwendung in Node.js, die den RESTful-Prinzipien entspricht.

Führen Sie zunächst den folgenden Befehl im Stammverzeichnis des Projekts aus, um die Datei „package.json“ zu initialisieren:

npm init

Installieren Sie dann die erforderlichen Abhängigkeiten:

npm i --save express mongoose
npm i --save-dev babel-cli babel-preset-env nodemon

Eine kurze Erklärung für jedes dieser Module:

  • Äußern verwenden wir, um den Webserver zu booten
  • Mungo interagiert mit der MongoDB-Datenbank
  • Babel kompiliert ES6+ Javascript in ein browserlesbares Format
  • Nodemon startet die Anwendung automatisch neu, wenn Dateiänderungen erkannt werden

Babel

Erstellen Sie eine neue Datei namens .babelrc und füllen Sie sie mit Folgendem:

{ 
  "presets": ["env"]
}

Dies weist Bable an, die zu verwenden “env” Plugin, das speziell zum Transpilieren von ES6-Code dient.

Gehen Sie danach zu package.json und richten Sie die “Skripte” Abschnitt wie folgt:

{ 
... 
"scripts": { 
  "start": "nodemon server.js --exec babel-node --presets env", 
  "release": "npm run clean && npm run build && npm run serve", 
  "clean": "rm -rf dist && mkdir dist", "build": "babel . -s -D -d dist --presets env --ignore node_modules", 
  "serve": "node dist/server.js" 
}, 
...
}

Mit dieser Konfiguration können Sie npm start während der aktiven Entwicklung ausführen, um das Live-Neuladen zu aktivieren, und npm run release, um die Anwendung für den Produktionseinsatz bereitzustellen.

Äußern

Nachdem die Anwendung nun für die Verwendung von ES6 eingerichtet ist, fahren wir mit der Einrichtung des Servers fort.

Beginnen Sie mit der Erstellung der Verzeichnisstruktur für unsere Projektdateien:

notes-app/
├── controllers/
│ └── notebookController.js
│ └── notebookModel.js
├── models/ 
├── routes/
│ └── index.js
├── app.js
├── server.js
└── package.json

Server

Nachdem Sie nun die Barebone-Struktur der Anwendung erstellt haben, gehen Sie zur Datei server.js und füllen Sie sie mit diesem grundlegenden Servercode:

import app from './app';

const port = process.env.PORT || '3000'; app.listen(port); 

console.log(`Listening on port ${port}`);

Modelle

Wir müssen dem Server mitteilen, welche Informationen unsere Notizobjekte enthalten werden. Dazu richten wir ein Datenbankschema wie folgt in notebookModel.js:

import mongoose, {
    Schema
} from 'mongoose';

/**
 * Create database scheme for notes
 */
const NoteScheme = new Schema({
    title: {
        type: String,
        required: "What is the note's title?"
    },
    text: {
        type: String,
        required: "What is the note?"
    },
    date: {
        type: Date,
        default: new Date
    }
});

export default mongoose.model('Note', NoteScheme);

Routen

Nachdem wir unser Note-Modell eingerichtet haben, fahren wir mit unseren Routen fort. Jede Route bestimmt, welche Methode ausgeführt werden soll, wenn sie von einem Client aufgerufen wird, je nachdem, welche HTTP-Methode angegeben ist.

In unserer App werden wir Routen haben, die Folgendes tun:

  • Holen Sie sich alle Notizen
  • Holen Sie sich eine bestimmte Notiz
  • Erstellen Sie eine Notiz
  • Aktualisieren Sie eine vorhandene Notiz
  • Löschen Sie eine Notiz

In der Datei index.js definieren wir die Routen wie folgt:

import notebook from '../controllers/notebookController';

export default (app) => {
    app.route('/notes')
        .get(notebook.getAllNotes)
        .post(notebook.createNote);

    app.route('/notes/:noteId')
        .get(notebook.getNote)
        .put(notebook.updateNote)
        .delete(notebook.deleteNote);
};

Controller

Nachdem unsere Routen definiert sind, können wir damit fortfahren, die Funktionen zu schreiben, die jede Route in notebookController.js aufruft:

import mongoose from 'mongoose'; 
import note from '../models/notebookModel.js';

exports.getNote = (req, res) => {
    note.findById(req.params.noteId, (err, note) => {
        if (err) {
            res.send(err);
        }

        res.json(note);
    });
};

exports.getAllNotes = (req, res) => {
    note.find({}, (err, notes) => {
        if (err) {
            res.send(err);
        }

        res.json(notes);
    });
};

exports.createNote = (req, res) => {
    const newNote = new note(req.body);

    newNote.save((err, note) => {
        if (err) {
            res.send(err);
        }

        res.json(note);
    });
};

exports.updateNote = (req, res) => {
    note.findOneAndUpdate({
        _id: req.params.noteId
    }, req.body,
        (err, note) => {
            if (err) {
                res.send(err);
            }

            res.json(note);
        });
};

exports.deleteNote = (req, res) => {
    note.remove({
        _id: req.params.noteId
    }, (err) => {
        if (err) {
            res.send(err);
        }

        res.json({
            message: `note ${req.params.noteId} successfully deleted`
        });
    });
};

App

Um alles miteinander zu verknüpfen, schreiben wir unsere app.js-Datei, die dem Server mitteilt, wo und was die Routen sind Middleware-Funktionen benutzen. Dies sind Funktionen, die Zugriff auf die Anforderungs- und Antwortobjekte haben, sodass sie verwendet werden können, um Fehler zu behandeln und Anforderungsdaten zu parsen.

Unsere app.js-Datei sollte in etwa so aussehen:

import express from 'express';
import mongoose from 'mongoose';
import bodyParser from 'body-parser';

import routes from './routes/index.js';

const app = express();

/**
    * Connect to the database
    */

mongoose.connect('mongodb://localhost');

/**
    * Middleware
    */

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

// catch 400
app.use((err, req, res, next) => {
    console.log(err.stack);
    res.status(400).send(`Error: ${res.originUrl} not found`);
    next();
});

// catch 500
app.use((err, req, res, next) => {
    console.log(err.stack)
    res.status(500).send(`Error: ${err}`);
    next();
});

/**
    * Register the routes
    */

routes(app);

export default app;

Verwendungszweck

Unsere App ist jetzt fertig und wir können mit REST-Aufrufen fortfahren, um Notizen zu erstellen, zu aktualisieren, abzurufen und zu löschen.

REST-Aufrufe können mit einer Reihe von Programmen durchgeführt werden, aber ich persönlich schlage vor Schlaflosigkeit. Eine einfache Bedienungsanleitung finden Sie auf ihrer “Einstieg” Seite.

Um zunächst eine Liste aller Notizen in der Datenbank zu erhalten, führen Sie eine GET-Anfrage unter aus localhost:3000/notes :

Die Antwort sollte ein leeres Array sein, da wir noch keine Notizen erstellt haben.

Um eine Notiz zu erstellen, ändern Sie den Datentyp (das Dropdown-Menü direkt unter dem URL-Feld) in „Form URL Encoded“, falls dies noch nicht geschehen ist, geben Sie „Titel“ und „Text“ an und führen Sie eine POST-Anfrage unter derselben URL aus:

Sie werden feststellen, dass mehrere Informationen zurückgegeben werden: Der „_id“-Parameter ist eine eindeutige Zahl, die definiert wird, wenn die POST-Anforderung ausgeführt wird, und wir können sie verwenden, um dem Server mitzuteilen, mit welcher Notiz wir interagieren möchten.

Wenn wir beispielsweise den Text dieser Notiz ändern möchten, können wir eine PUT-Anfrage ausführen, wobei die ID der Notiz an die URL angehängt wird, nachdem wir den neuen Text angegeben haben:

Standardmäßig gibt die „findOneAndUpdate“-Methode von Mongoose das unveränderte Objekt zurück, sodass die Antwort immer noch den alten Notiztext anzeigt. Wenn Sie dann jedoch den Anfragetyp auf “GET” ändern, sehen Sie das aktualisierte Objekt:

Um schließlich eine Notiz zu löschen, ändern Sie den Anfragetyp in „LÖSCHEN“ und führen Sie eine Anfrage unter der entsprechenden URL aus:

Similar Posts

Leave a Reply

Your email address will not be published.