nodejs erstellt ein Hintergrundverwaltungssystem

1. Einleitung

Mit der kontinuierlichen Entwicklung des Internets haben alle Lebensbereiche begonnen, sich auf Digitalisierung, Informatisierung und Onlineisierung zu konzentrieren. Und die Website-Entwicklung ist ein wichtiger Aspekt davon. Ich glaube, viele Freunde haben bereits versucht, mit Sprachen wie PHP, Java und Python zu entwickeln. Aber heute möchte ich Ihnen Node.js vorstellen und wie Sie Node.js zum Aufbau eines Backend-Managementsystems verwenden.

Node.js ist eine leichte und effiziente Open-Source-JavaScript-Laufumgebung. Node.js und die Browserentwicklung haben den gleichen Zweck: Der Browser führt JavaScript aus, um die Seite zu rendern, und Node.js führt JavaScript aus, um serverseitige Codeoperationen auszuführen.

Jetzt werde ich Ihnen Schritt für Schritt vorstellen, wie Sie mit Node.js ein Backend-Managementsystem aufbauen.

2. Umgebungsvorbereitung

Zuerst müssen wir die folgende Umgebung vorbereiten:

1. Node.js: Da Node.js eine JavaScript-Laufumgebung ist, muss sie installiert werden.
2. MongoDB: MongoDB ist eine NoSQL-Datenbank, die Daten speichern muss, daher muss MongoDB installiert werden.
3. Express: Express ist ein Framework für die Entwicklung von Webanwendungen, das auf Node.js basiert.

Sobald die Umgebung fertig ist, können wir mit dem Entwurf und der Entwicklung des Backend-Managementsystems beginnen.

3. Datenbankdesign

Bevor wir mit dem Schreiben von Code beginnen, müssen wir verstehen, welche Daten unser Backend-Managementsystem speichern muss. Ein einfaches Blog-Verwaltungssystem muss beispielsweise Beiträge, Tags und Kategorien speichern. Dann können wir die folgende Datenbankstruktur entwerfen:

1. Artikeltabelle:

• id: Artikel-ID.
• Titel: Titel des Artikels.
• Inhalt: Artikelinhalt.
• createTime: Artikelerstellungszeit.
• updateTime: Zeitpunkt der letzten Änderung.
• Status: Veröffentlichungsstatus des Artikels.

2. Tag-Tabelle:

• id: Tag-ID.
• Name: Tag-Name.

3. Kategorietabelle:

• id: Kategorie-ID.
• Name: Kategoriename.

Nachdem das Datenbankdesign abgeschlossen ist, können wir mit dem Schreiben des Codes des Backend-Managementsystems beginnen.

4. Erstellen Sie ein Backend-Verwaltungssystem

Bevor wir Code schreiben, müssen wir Express und einige andere notwendige Komponenten installieren. Zur Installation können Sie den folgenden Befehl verwenden:

npm install express mongoose body-parser morgan cors --save

Als nächstes können wir den Code für das Backend-Managementsystem schreiben. Der folgende Code dient nur als Referenz. Leser können ihn entsprechend ihren eigenen Anforderungen ändern.

1. Projekt erstellen

Zuerst müssen wir ein Node.js-Projekt erstellen. Es kann mit dem folgenden Befehl erstellt werden:

mkdir blog-admin
cd blog-admin
npm init -y

2. Create Server

Als nächstes müssen wir einen Server erstellen, um auf unser Backend-Managementsystem zuzugreifen.

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

const app = express();
const port = 3000;

// 连接 MongoDB 数据库，并创建 blog-admin 数据库
mongoose.connect('mongodb://localhost/blog-admin', { useNewUrlParser: true, useUnifiedTopology: true });
const db = mongoose.connection;
db.on('error', console.error.bind(console, '连接 MongoDB 数据库失败了：'));
db.once('open', function() {
  console.log('成功连接 MongoDB 数据库了！');
  // 创建文章、标签和分类数据表
  const articleSchema = new mongoose.Schema({
    title: String,
    content: String,
    createTime: Date,
    updateTime: Date,
    status: Number
  });
  const tagSchema = new mongoose.Schema({
    name: String
  });
  const categorySchema = new mongoose.Schema({
    name: String
  });
  mongoose.model('Article', articleSchema);
  mongoose.model('Tag', tagSchema);
  mongoose.model('Category', categorySchema);
});

app.use(cors());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(morgan('dev'));

// 获取文章列表
app.get('/api/article', (req, res) => {
  const Article = mongoose.model('Article');
  Article.find({}).exec((err, data) => {
    if (err) {
      res.send('获取文章列表失败了！');
    } else {
      res.json(data);
    }
  });
});

// 添加文章
app.post('/api/article', (req, res) => {
  const Article = mongoose.model('Article');
  const article = new Article(req.body);
  article.createTime = new Date();
  article.status = 0;
  article.save((err, data) => {
    if (err) {
      res.send('添加文章失败了！');
    } else {
      res.json(data);
    }
  });
});

// 修改文章
app.put('/api/article/:id', (req, res) => {
  const Article = mongoose.model('Article');
  Article.findByIdAndUpdate(req.params.id, req.body, (err, data) => {
    if (err) {
      res.send('修改文章失败了！');
    } else {
      res.json(data);
    }
  });
});

// 删除文章
app.delete('/api/article/:id', (req, res) => {
  const Article = mongoose.model('Article');
  Article.findByIdAndRemove(req.params.id, (err, data) => {
    if (err) {
      res.send('删除文章失败了！');
    } else {
      res.json(data);
    }
  });
});

// 启动服务器
app.listen(port, () => {
  console.log(`服务器已启动，访问地址：http://localhost:${port}/`);
});

Im obigen Code haben wir einen Server erstellt und mithilfe von mongoose eine Verbindung zur MongoDB-Datenbank hergestellt. Anschließend haben wir Datentabellen für Artikel, Tags und Kategorien erstellt und APIs implementiert, um Artikellisten abzurufen, Artikel hinzuzufügen, Artikel zu ändern und Artikel zu löschen. Schließlich haben wir den Server gestartet.

5. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit Node.js ein Backend-Verwaltungssystem erstellen. Zuerst haben wir die Datenbankarchitektur entworfen, einschließlich Artikeln, Tags und Klassifizierungstabellen. Anschließend haben wir mit Express einen Server erstellt und über mongoose eine Verbindung zur MongoDB-Datenbank hergestellt. Schließlich haben wir die API zum Abrufen der Artikelliste, zum Hinzufügen von Artikeln, zum Ändern von Artikeln und zum Löschen von Artikeln auf dem Server implementiert.

Im Allgemeinen kann Node.js die Effizienz und Zuverlässigkeit unserer Webanwendungen effektiv verbessern, insbesondere wenn wir mit Situationen mit hoher Parallelität umgehen müssen. Ich glaube, dass durch die Einführung dieses Artikels jeder Node.js verwenden kann, um ein Backend-Managementsystem von Grund auf aufzubauen.

Das obige ist der detaillierte Inhalt vonnodejs erstellt ein Hintergrundverwaltungssystem. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!