Stellen Sie die NodeJS-Rest-API bereit-Front-End-Fragen und Antworten-php.cn

Im heutigen Internetzeitalter ist der Aufbau effizienter und schneller Back-End-Dienste unerlässlich. NodeJS zeichnet sich in diesem Bereich aus und ermöglicht die schnelle und einfache Erstellung effizienter Webdienste. Auch die REST-API ist in der heutigen Internetbranche eine sehr beliebte Methode zum Aufbau von Webdiensten. Es kann die Codemenge erheblich reduzieren, die Portverwaltung vereinfachen und bietet viele Vorteile. In diesem Artikel erfahren Sie, wie Sie die REST-API mithilfe von NodeJS und ExpressJS schnell bereitstellen.

Umgebungsvorbereitung

Bevor wir beginnen, müssen wir eine Umgebung einrichten:

Ein Texteditor (VS-Code wird empfohlen)
Node.js (von der offiziellen Website herunterladen und installieren)
Postman (Testtool , kann von der offiziellen Website heruntergeladen und installiert werden)

Initialisieren Sie das Projekt

Zuerst öffnen wir das Terminal und erstellen ein neues Projektverzeichnis:

mkdir project-name
cd project-name

Nach dem Login kopieren

Dann verwenden wir npm init, um Erstellen Sie ein neues Paket: npm init 创建一个新的 package：

npm init

Nach dem Login kopieren

npm init 将会要求你输入一些基本信息，例如作者名，项目名称，版本等。一些默认的设置是可以直接使用的，只需修改一些你自己的信息即可。

接下来，我们将需要安装以下几个依赖：

npm install express body-parser cors —save

Nach dem Login kopieren

Express是我们用于构建REST API的框架。
body-parser是一个中间件，用于解析POST请求和JSON数据。
Cors是一个插件，允许Web应用程序在另一个域上启用 CORS（跨域资源共享）

创建服务

现在，让我们来创建一个名为app.js的新文件，这将是我们的 NodeJS REST API 服务的起点。我们可以借助 Express 框架来构建这个服务：

const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const app = express()

const port = 3000

app.use(cors())

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

app.listen(port, () => {
  console.log(`Server running on port ${port}`)
})

Nach dem Login kopieren

在上面的代码段中，我们导入 Express，body-parser 和 cors。我们还使用了监听端口 3000 的app.listen()方法。最后，我们通过app.use()方法启用 cors 和 body-parser 的中间件。

创建路由

下一步将是创建路由，这是实现我们 REST API 服务所必需的。路由可以理解为请求进入服务后，服务应该如何响应的规则集合。

我们可以在项目根目录下创建一个routes文件夹，并在其中创建index.js文件，并添加以下内容：

const express = require('express')
const router = express.Router()

router.get('/posts', (req, res) => {
  res.status(200).send('All posts')
})

module.exports = router;

Nach dem Login kopieren

在上述代码中，我们创建了一个新的路由，并在该路由上创建了一个/posts的GET请求。该请求将返回一个状态码为200和文本“All posts”。

接下来，我们将启用该路由。我们回到app.js文件并添加以下内容：

const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const app = express()

const postRoutes = require('./routes/index');
const port = 3000

app.use(cors())

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

app.use('/api', postRoutes);

app.listen(port, () => {
  console.log(`Server running on port ${port}`)
})

Nach dem Login kopieren

在上述代码中，我们导入了定义在routes/index.js的路由，并使用app.use('/api', postRoutes)方法将路由应用于我们的 REST API 服务中。然后，在localhost:3000/api/posts呼叫GET请求时，它应该返回“All posts”。

数据库连接

当然，在真正的项目中我们需要请求和获取的数据是会被放在数据库中存储的，所以我们需要在此处讨论如何使用NodeJS连接数据库。

我们将使用 MongoDB 作为我们的数据库，同时使用mongoose来连接它。我们可以在命令行中运行以下命令来安装 mongoose：

npm install mongoose --save

Nach dem Login kopieren

接下来，让我们来创建一个models文件夹，并在其中添加一个新文件post.js，以描述一个简单的数据模型。

const mongoose = require('mongoose');

const postSchema = new mongoose.Schema({
  title: { type: String, required: true },
  content: { type: String, required: true },
  author: { type: String, required: true },
}, { timestamps: true });

module.exports = mongoose.model('Post', postSchema);

Nach dem Login kopieren

在上面的代码中，我们定义了一个名为Post的模型，以定义我们的数据，并且在创建它时使用了 timestamps 选项。

现在，我们要使用 Mongoose 连接本地 MongoDB 数据库。可以在app.js文件中添加以下内容：

const mongoose = require('mongoose');
const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')

const postRoutes = require('./routes/index');
const PORT = process.env.PORT || 3000;

const app = express();

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

mongoose.connect('mongodb://localhost/posts', { useNewUrlParser: true, useUnifiedTopology: true });
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
db.once('open', function() {
    console.log('Successfully connected to MongoDB!');
})

app.use('/api', postRoutes);

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Nach dem Login kopieren

以上代码的数据库URL设置为mongodb://localhost/posts，这表示数据库名为posts，并位于我们的本地MongoDB实例中。我们还使用了Mongoose端口的默认端口（27017）。需要注意的是，Mongoose已经被弃用的代码已经修复，所以我们必须使用useUnifiedTopology选项。

实现路由

我们已经在服务器中设置了路由，并且可以成功连接我们的数据库。接下来，我们要配置更多的路由，以处理 POST 请求并从我们的数据库中获取数据。

首先，我们在我们的路由中添加一个新的 POST 请求，并从请求体中提取出标题、内容、作者以及其他必要的信息。并将数据存储到数据库中。在这里，我们将假设在数据库中名为“posts”，并且通过Post模型本身来创建一个MongoDB文档。

const express = require('express');
const router = express.Router();
const Post = require('../models/post.js');

router.get('/posts', (req, res) => {
  Post.find()
  .then(data => res.json(data))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

router.get('/posts/:id', (req, res) => {
  Post.findById(req.params.id)
  .then(data => res.json(data))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

router.post('/posts', (req, res) => {
  const newPost = new Post(req.body);
  newPost.save()
  .then(() => res.json('Post added!'))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

module.exports = router;

Nach dem Login kopieren

顶部的代码中，我们首先导入了我们的模型文件，并创建所有需要的路由GET或POST请求。 GET请求使用Post.find()从MongoDB数据库中提取所有数据库条目，而我们的POST请求使用newPost.save()rrreee

npm init fordert Sie auf, einige grundlegende Informationen einzugeben, wie z. B. den Namen des Autors, den Namen des Projekts, die Version usw. Einige der Standardeinstellungen können direkt verwendet werden. Ändern Sie einfach einige Ihrer eigenen Informationen. 🎜🎜Als nächstes müssen wir die folgenden Abhängigkeiten installieren: 🎜rrreee

🎜Express ist das Framework, das wir zum Erstellen von REST-APIs verwenden. 🎜🎜body-parser ist eine Middleware zum Parsen von POST-Anfragen und JSON-Daten. 🎜🎜Cors ist ein Plugin, das es Webanwendungen ermöglicht, CORS (Cross-Origin Resource Sharing) auf einer anderen Domain zu aktivieren. 🎜🎜Erstellen Sie einen Dienst.🎜🎜Jetzt erstellen wir eine Datei mit dem Namen

app.js, dies wird der Ausgangspunkt für unseren NodeJS REST API-Dienst sein. Wir können diesen Dienst mithilfe des Express-Frameworks erstellen: 🎜rrreee🎜 Im obigen Codeausschnitt importieren wir Express, Body-Parser und Cors. Wir verwenden auch die Methode <code>app.listen()

, die Port 3000 überwacht. Schließlich aktivieren wir die Cors- und Body-Parser-Middleware über die Methode app.use(). 🎜🎜Routen erstellen🎜🎜Der nächste Schritt besteht darin, Routen zu erstellen, die zur Implementierung unseres REST-API-Dienstes erforderlich sind. Routing kann als eine Reihe von Regeln verstanden werden, die festlegen, wie der Dienst reagieren soll, nachdem eine Anfrage beim Dienst eingegangen ist. 🎜🎜Wir können einen Ordner routes im Stammverzeichnis des Projekts erstellen und darin die Datei index.js erstellen und den folgenden Inhalt hinzufügen: 🎜rrreee🎜Im obigen Code Wir erstellen eine neue Route und erstellen eine GET-Anfrage für /posts auf der Route. Die Anfrage gibt den Statuscode 200 und den Text „Alle Beiträge“ zurück. 🎜🎜Als nächstes aktivieren wir die Route. Wir gehen zurück zur Datei app.js und fügen Folgendes hinzu: 🎜rrreee🎜Im obigen Code importieren wir die in routes/index.js definierten Routen und verwenden app.use('/api', postRoutes) wendet Routen auf unseren REST-API-Dienst an. Wenn Sie dann eine GET-Anfrage unter localhost:3000/api/posts aufrufen, sollte diese „Alle Beiträge“ zurückgeben. 🎜🎜Datenbankverbindung🎜🎜Natürlich werden in einem realen Projekt die Daten, die wir anfordern und erhalten müssen, in der Datenbank gespeichert, daher müssen wir hier besprechen, wie NodeJS zum Herstellen einer Verbindung zur Datenbank verwendet wird. 🎜🎜Wir werden MongoDB als unsere Datenbank und mongoose verwenden, um eine Verbindung dazu herzustellen. Wir können mongoose installieren, indem wir den folgenden Befehl in der Befehlszeile ausführen: 🎜rrreee🎜 Als nächstes erstellen wir einen Ordner models und fügen darin eine neue Datei

post.js hinzu, um ihn zu beschreiben ein einfaches Datenmodell. 🎜rrreee🎜Im obigen Code haben wir ein Modell namens <code>Post

definiert, um unsere Daten zu definieren, und beim Erstellen die Option Zeitstempel verwendet. 🎜🎜Jetzt verwenden wir Mongoose, um eine Verbindung zur lokalen MongoDB-Datenbank herzustellen. Sie können der Datei app.js den folgenden Inhalt hinzufügen: 🎜rrreee🎜Die Datenbank-URL des obigen Codes ist auf mongodb://localhost/posts eingestellt, was bedeutet Der Datenbankname lautet posts und befindet sich in unserer lokalen MongoDB-Instanz. Wir haben auch den Standardport (27017) für den Mongoose-Port verwendet. Beachten Sie, dass der veraltete Code in Mongoose behoben wurde, sodass wir die Option useUnifiedTopology verwenden müssen. 🎜🎜Routing implementieren🎜🎜Wir haben das Routing auf dem Server eingerichtet und können erfolgreich eine Verbindung zu unserer Datenbank herstellen. Als Nächstes konfigurieren wir weitere Routen, um POST-Anfragen zu verarbeiten und Daten aus unserer Datenbank abzurufen. 🎜🎜Zuerst fügen wir unserer Route eine neue POST-Anfrage hinzu und extrahieren den Titel, den Inhalt, den Autor und andere notwendige Informationen aus dem Anfragetext. und speichern Sie die Daten in der Datenbank. Hier gehen wir davon aus, dass wir ein MongoDB-Dokument mit dem Namen „posts“ in der Datenbank haben und erstellen ein MongoDB-Dokument aus dem Post-Modell selbst. 🎜rrreee🎜Im Code oben importieren wir zunächst unsere Modelldatei und erstellen alle Routen, die zum Weiterleiten von GET- oder POST-Anfragen erforderlich sind. Die GET-Anfrage verwendet Post.find(), um alle Datenbankeinträge aus der MongoDB-Datenbank zu extrahieren, während unsere POST-Anfrage newPost.save() verwendet, um die neuen Daten in der zu speichern Datenbanktabelle. 🎜

Verwenden Sie Postman zum Testen

Nach Abschluss der oben genannten Schritte können Sie Postman zum Testen unserer REST-API verwenden.

Zuerst versuchen wir, Daten mithilfe einer GET-Anfrage abzurufen. Wir können alle Beiträge abrufen, indem wir auf http://localhost:3000/posts zugreifen. http://localhost:3000/posts来检索所有的文章。

接下来，我们尝试使用POST请求创建新数据，我们可以通过访问http://localhost:3000/posts并在请求的主体中添加一个新的JSON数据体来创建新文章。

最后，我们还可以使用GET请求检索单个条目，我们可以通过访问http://localhost:3000/posts/:id

Als nächstes versuchen wir, mithilfe einer POST-Anfrage neue Daten zu erstellen. Dies können wir tun, indem wir http://localhost:3000/posts besuchen und einen neuen JSON-Datenkörper im Hauptteil der Anfrage hinzufügen . Artikel.

Schließlich können wir auch einen einzelnen Eintrag mithilfe einer GET-Anfrage abrufen. Wir können einen einzelnen Beitrag abrufen, der von der ID bereitgestellt wird, indem wir auf http://localhost:3000/posts/:id zugreifen. 🎜🎜Mit diesen einfachen Schritten können wir eine einfache REST-API implementieren und eine Verbindung zur MongoDB-Datenbank herstellen. Natürlich gibt es viele andere Vorgänge, die diese API weiter verbessern können, z. B. Vorgänge wie das Aktualisieren und Löschen von Einträgen. Wir empfehlen jedoch, dass Sie versuchen, diese Funktionen selbst zu schreiben, um ein tieferes Verständnis des Prozesses zu erlangen. 🎜

Das obige ist der detaillierte Inhalt vonStellen Sie die NodeJS-Rest-API bereit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!