nodejs implementiert mvc

Node.js ist eine plattformübergreifende Open-Source-JavaScript-Laufzeitumgebung. Es ermöglicht uns, serverseitige Anwendungen mit JavaScript zu schreiben. Mit Node.js ist es einfach, leistungsstarke serverseitige Anwendungen zu entwickeln. In diesem Artikel erfahren Sie, wie Sie eine MVC-Architektur mithilfe von Node.js implementieren.

1. Was ist MVC?

MVC ist die Abkürzung für Model-View-Controller. Es handelt sich um ein Entwurfsmuster, das Code so organisiert, dass die Anwendung getrennt wird und die Anwendung einfach zu warten und zu erweitern ist.

• Modell: Enthält alle Anwendungsdaten und die zugehörige Geschäftslogik.
• Ansicht: Benutzeroberfläche, die Daten vom Modell abruft und sie dem Benutzer präsentiert.
• Controller: Verwaltet die Interaktion zwischen der Benutzeroberfläche und der Geschäftslogik und gibt die Ergebnisse an die Benutzeroberfläche zurück. Es kann als Middleware wie Routing, Middleware und Controller fungieren.

MVC macht den Code sehr modular und erleichtert so die Umgestaltung und Wartung verschiedener Teile der Anwendung. In Node.js können wir verschiedene Frameworks verwenden, um MVC-Anwendungen zu erstellen. In diesem Artikel besprechen wir, wie man die MVC-Architektur mithilfe des Express-Frameworks implementiert.

2. Wie implementiert man MVC mit dem Express-Framework?

Express ist ein beliebtes Framework für Node.js, das Tools und Middleware für die schnelle Erstellung von Webanwendungen bereitstellt. Wir können MVC mithilfe des Express-Frameworks implementieren.

Zuerst müssen wir das Express-Framework installieren. Verwenden Sie den folgenden Befehl in der Befehlszeile:

npm install express --save

Als nächstes müssen wir die Template-Engine installieren. In diesem Artikel verwenden wir EJS als Template-Engine. Verwenden Sie den folgenden Befehl in der Befehlszeile:

npm install ejs --save

Hier ist eine grundlegende Verzeichnisstruktur:

- app/
    - controllers/
    - models/
    - views/
- public/
- routes/
- app.js

Wir unterteilen die Anwendung in drei Komponenten: Controller, Modell und Ansicht.

3. Controller

Im Controller-Ordner definieren wir unsere Controller-Logik. Beispielsweise können wir eine Datei namens userController.js haben, die benutzerbezogene Anfragen verarbeitet.

In der Datei userController.js können wir verschiedene Objekte und Methoden exportieren, um sie in der Anwendung zu verwenden. Hier ist ein Beispiel:

const User = require('../models/user');

const UserController = {};

UserController.index = (req, res) => {
    // 获取所有用户
    User.getAll((err, users) => {
        if (err) {
            console.log(err);
            return;
        }
        // 渲染视图
        res.render('users/index', { users });
    });
};

UserController.show = (req, res) => {
    // 获取单个用户
    User.getById(req.params.id, (err, user) => {
        if (err) {
            console.log(err);
            return;
        }
        // 渲染视图
        res.render('users/show', { user });
    });
};

module.exports = UserController;

Im obigen Code definieren wir ein Objekt namens UserController und exportieren zwei Methoden: index und show. Diese Methoden rufen die Benutzerdaten ab und übergeben sie zum Rendern an die EJS-Vorlagen-Engine. Wir können diese Methoden in den Routen unserer Anwendung verwenden, um Benutzeranfragen zu bearbeiten.

4. Modell

Im Modellordner definieren wir die Logik der Modellebene. Beispielsweise können wir eine Datei namens user.js haben, die benutzerbezogene Daten und Geschäftslogik definiert.

In der Datei user.js können wir das ORM-Framework (Object Relational Mapping) von Node.js verwenden, um das Modell zu definieren. Hier ist ein Beispiel:

const sql = require('../config/db').pool;

const User = {};

User.getAll = (callback) => {
    sql.query('SELECT * FROM users', (err, users) => {
        if (err) {
            callback(err, null);
            return;
        }
        callback(null, users);
    });
};

User.getById = (id, callback) => {
    sql.query('SELECT * FROM users WHERE id = ?', [id], (err, user) => {
        if (err) {
            callback(err, null);
            return;
        }
        callback(null, user[0]);
    });
};

module.exports = User;

Im obigen Code exportieren wir ein Objekt namens User und definieren zwei Methoden: getAll und getById. Diese Methoden führen die SQL-Abfrage aus und geben die Ergebnisse an den Controller zurück.

5. Ansichten

Im Ordner „Ansichten“ definieren wir unsere EJS-Ansichtsdateien. Wir könnten beispielsweise eine Datei namens index.ejs haben, die Daten für alle Benutzer rendert.

Hier ist ein Beispiel:

<h1>All Users</h1>

<% if (users && users.length > 0) { %>
  <ul>
    <% users.forEach(function(user) { %>
      <li><a href="/users/<%= user.id %>"><%= user.name %></a></li>
    <% }); %>
  </ul>
<% } else { %>
  <p>No users found.</p>
<% } %>

Im obigen Code verwenden wir die EJS-Syntax, um alle Benutzer darzustellen und die Liste zu erstellen. Wir übergeben Benutzerdaten im Controller und rendern sie in der Ansicht.

6. Routing

Im Routenordner definieren wir die Routen für unsere Anwendung. In der Datei app.js konfigurieren wir unsere Middleware. Hier ist ein Beispiel:

const express = require('express');
const app = express();
const router = express.Router();
const UserController = require('./app/controllers/userController');

// 路由
router.get('/', UserController.index);
router.get('/users/:id', UserController.show);

// 中间件
app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }));
app.set('view engine', 'ejs');
app.set('views', __dirname + '/app/views');
app.use(router);

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server listening on port ${PORT}.`);
});

Im obigen Code haben wir zwei Routen definiert: eine zum Rendern von Daten für alle Benutzer und eine andere zum Rendern von Daten für einen einzelnen Benutzer. Wir haben auch Middleware konfiguriert, die es uns ermöglicht, die EJS-Vorlagen-Engine zu verwenden und statische Dateien zu nutzen. Schließlich haben wir den Server gestartet.

7. Zusammenfassung

In diesem Artikel haben wir die MVC-Architektur mithilfe des Express-Frameworks implementiert. Wir unterteilen die Anwendung in drei Komponenten: Controller, Modell und Ansicht. Wir haben auch das Node.js ORM-Framework zum Definieren der Modelle und die EJS-Vorlagen-Engine zum Rendern der Ansichten verwendet. Schließlich verwenden wir Routing, um Benutzeranfragen zu bearbeiten und Daten an Controller und Ansichten zurückzugeben. Die MVC-Architektur von

Node.js trägt dazu bei, die Wartung und Skalierung von Anwendungen erheblich zu vereinfachen. Darüber hinaus bietet das Express-Framework viele nützliche Tools und Middleware, die uns helfen können, Webanwendungen schneller zu erstellen.

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