So erstellen und strukturieren Sie eine Node.js -MVC -Anwendung

beim Erstellen komplexer Anwendungen ist das Architekturdesign genauso wichtig wie die Codequalität. Auch wenn der Code gut geschrieben ist, aber eine gute Organisationsstruktur fehlt, wird die Aufrechterhaltung und Skalierung mit zunehmender Komplexität äußerst schwierig. Daher besteht die beste Praxis darin, die Architektur vor Beginn des Projekts zu planen, die Projektziele zu leiten und fundierte Entscheidungen zu treffen.

Im Gegensatz zu Frameworks wie Ruby on Rails verfügt Node.js über einen De -facto -Standard -Framework, um bestimmte Architekturen und Codeorganisationen durchzusetzen. Dies macht die Auswahl der Architektur relativ kostenlos, wenn eine vollständige Webanwendung von Node.js erstellt wird, fügt jedoch auch Herausforderungen hinzu.

Mit diesem Tutorial wird die MVC-Architektur verwendet, um eine grundlegende Notizanwendung zu erstellen, in der nachgewiesen wird Entwicklung.

Kernpunkte:

• organisieren effizient Node.js-Anwendungen mithilfe der MVC-Architektur (Modell-View-Controller), um die Wartbarkeit und Skalierbarkeit zu verbessern.
• Initialisieren Sie das Projekt mit NPM und erstellen Sie package.json Dateien, um Abhängigkeiten zu verwalten.
• Erstellen Sie einen Server mithilfe des Frameworks von Hapi.js und verwalten Sie Daten mithilfe der SQLite -Datenbank und der sequelize.js.
• node.js Routen definieren, klären Sie die Funktionalität der Anwendung und stellen Sie sicher, dass jede Route mit der richtigen HTTP -Methode und dem richtigen Handler verbunden ist.
• Definieren Sie das Modell mit sequelize.js, um die Datenintegrität zu gewährleisten und eine Abstraktionsschicht bereitzustellen.
• Implementieren Sie den Controller, um Geschäftslogik zu verarbeiten, Modelle und Ansichten zu verbinden, Daten zu erhalten und das Ausgabeformat zu bestimmen.
• Erstellen Sie Ansichten mit der PUG -Template -Engine, um HTTP -Antworten lesbarer und strukturierter zu gestalten.
• Verwenden Sie das inerte Plugin von hapi.js, um statische Dateidienste bereitzustellen und CSS- und JavaScript -Dateien effizient zu verwalten.

Was ist MVC?

Modell-View-Controller (MVC) ist wahrscheinlich eine der beliebtesten Anwendungsarchitekturen. Das MVC -Muster wurde ursprünglich in PARC für die SmallTalk -Sprache entwickelt, um die organisatorischen Probleme grafischer Benutzeroberflächenanwendungen zu lösen. Obwohl ursprünglich in Desktop -Anwendungen verwendet, wurde das Konzept erfolgreich auf die Webentwicklung angewendet.

Einfach ausgedrückt, die MVC -Architektur umfasst:

• Modell: Teile der Verarbeitungsdatenbank oder alle datenbezogenen Funktionen.
• Ansicht (Ansicht): Alles, was der Benutzer sieht - die an den Client gesendete Seite.
• Controller: Die Logik der Website und die Brücke zwischen dem Modell und der Ansicht. Der Controller ruft das Modell auf, um die Daten zu erhalten, übergeben die Daten dann an die Ansicht und sendet es schließlich an den Benutzer.

Diese Anwendung ermöglicht die Erstellung, Anzeige, Bearbeitung und Löschung von Klartextnotizen. Die Funktionen sind zwar einfach, aber die solide Architektur erleichtert es einfach, in Zukunft neue Funktionen hinzuzufügen.

In diesem Tutorial geht davon aus, dass Sie die neueste Version von node.js auf Ihrem Computer installiert haben. Wenn nicht, lesen Sie bitte das entsprechende Tutorial für die Installation.

Der endgültige Anwendungscode wurde in das GitHub -Repository hochgeladen und Sie können die vollständige Projektstruktur anzeigen.

landen Sie das Fundament

Der erste Schritt zum Erstellen einer Node.js -Anwendung besteht darin, eine package.json -Datei mit allen Abhängigkeiten und Skripten zu erstellen. Diese Datei kann automatisch mit dem Befehl npm erzeugt werden: init

Sobald

<code class="language-bash">mkdir notes-board
cd notes-board
npm init -y</code>

fertig ist, haben Sie eine verfügbare

Datei. package.json

Hinweis: Wenn Sie mit diesen Befehlen nicht vertraut sind, lesen Sie bitte unseren NPM -Erste -Leitfaden.

Installieren Sie als nächstes das Framework Hapi.js:

<code class="language-bash">npm install @hapi/hapi@18.4.0</code>

Dieser Befehl lädt Hapi.js herunter und fügt ihn den Abhängigkeiten in der Datei

hinzu. package.json

Hinweis: Wir haben die V18.4.0 -Version von hapi.js angegeben, da sie mit Knoten 8, 10 und 12 kompatibel ist. Wenn Sie Knoten 12 verwenden, können Sie die neueste Version (HAPI v19.1.0) installieren.

Erstellen Sie nun die Eintragsdatei - Starten Sie den Webserver mit allem. Erstellen Sie eine

-Datei im Anwendungsverzeichnis und fügen Sie den folgenden Code hinzu: server.js

<code class="language-javascript">"use strict";

const Hapi = require("@hapi/hapi");
const Settings = require("./settings");

const init = async () => {
  const server = new Hapi.Server({ port: Settings.port });

  server.route({
    method: "GET",
    path: "/",
    handler: (request, h) => {
      return "Hello, world!";
    }
  });

  await server.start();
  console.log(`Server running at: ${server.info.uri}`);
};

process.on("unhandledRejection", err => {
  console.log(err);
  process.exit(1);
});

init();</code>

Dies ist die Grundlage der Anwendung. Zunächst verwenden wir den strengen Modus. World! "Die Nachricht ist ausreichend. Schließlich starten wir den Server mit der

-Methode. server.start()

Speichereinstellungen

Best Practice besteht darin, Konfigurationsvariablen in einer dedizierten Datei zu speichern. Diese Datei exportiert ein JSON -Objekt, das Daten enthält, wobei jedem Schlüssel eine unabhängige Umgebungsvariable zugewiesen wird, die alternativen Werte jedoch nicht vergessen.

In dieser Datei können wir je nach Umgebung (wie Entwicklung oder Produktion) auch unterschiedliche Einstellungen haben. Zum Beispiel können wir Speicherinstanzen von SQLite für Entwicklungszwecke verwenden, aber reale SQLite -Datenbankdateien in Produktionsumgebungen verwenden.

Auswahleinstellungen basierend auf der aktuellen Umgebung ist sehr einfach. Da wir auch eine Env -Variable in der Datei haben, die Entwicklung oder Produktion enthält, können wir Folgendes tun, um die Datenbankeinstellungen zu erhalten:

<code class="language-javascript">const dbSettings = Settings[Settings.env].db;</code>

Wenn die Env-Variable Entwicklung ist, enthält DBSettings die Einstellungen der In-Memory-Datenbank, wenn die Env-Variable die Produktion ist, der Pfad zur Datenbankdatei wird enthalten.

Zusätzlich können wir Unterstützung für

Dateien hinzufügen, in denen lokale Umgebungsvariablen für Entwicklungszwecke gespeichert werden können. Dies kann über ein Node.js -Paket wie DOTenV erfolgen, in dem die .env -Datei im Stamm des Projekts gelesen wird und die gefundenen Werte automatisch zur Umgebung hinzugefügt werden. .env

Hinweis: Wenn Sie sich auch für die -Datei entscheiden, sollten Sie das Paket mit .env installieren und zu npm install dotenv hinzufügen, um die Veröffentlichung sensibler Informationen zu vermeiden. .gitignore

unsere

Datei lautet wie folgt: settings.js

<code class="language-javascript">// This will load our .env file and add the values to process.env,
// IMPORTANT: Omit this line if you don't want to use this functionality
require("dotenv").config({ silent: true });

module.exports = {
  port: process.env.PORT || 3000,
  env: process.env.NODE_ENV || "development",

  // Environment-dependent settings
  development: {
    db: {
      dialect: "sqlite",
      storage: ":memory:"
    }
  },
  production: {
    db: {
      dialect: "sqlite",
      storage: "db/database.sqlite"
    }
  }
};</code>

Jetzt können wir die Anwendung starten, indem wir den folgenden Befehl ausführen und in unserem Webbrowser zu

navigieren: http://localhost:3000

<code class="language-bash">mkdir notes-board
cd notes-board
npm init -y</code>

Hinweis: Dieses Projekt wurde auf dem Knoten v12.15.0 getestet. Wenn Sie auf Fehler stoßen, stellen Sie sicher, dass eine aktualisierte Version installiert ist.

(Die folgenden Schritte aufgrund von Platzbeschränkungen werden der folgende Inhalt kurz zusammengefasst. Weitere Informationen finden Sie im Originaltext für bestimmte Implementierungsdetails)

Routen definieren: Routen für Anwendungen in lib/routes.js Dateien definieren, einschließlich Methoden GET, Post, Put und Löschen, um die Erstellung, das Lesen, Aktualisieren und Löschen von Notizen zu verarbeiten.

Erstellen Sie ein Modell: Erstellen Sie ein Note Verwenden von sequelize.js und sqlite, um die Datenstruktur der Notizen (Datum, Titel, Inhalt usw.) zu definieren. Definieren Sie das Modell in lib/models/note.js.

Erstellen Sie den Controller: Erstellen Sie den Controller, um Routing -Anforderungen zu verarbeiten. lib/controllers/home.js Homepage verarbeiten, lib/controllers/note.js CRUD -Operationen in Bezug auf Notizen bearbeiten.

Erstellen Sie Ansichten: Erstellen Sie Ansichten mit der PUG -Template -Engine. lib/views/home.pug Zeigen Sie die Liste der Notizen an, lib/views/note.pug Zeigen Sie einzelne Notizen -Details. lib/views/components/note.pug Definieren Sie die Notizkomponente.

Service Statische Dateien: Verwenden Sie das Inerte -Plugin von Hapi.js, um statische Dateien (JavaScript und CSS) zu servieren. Registrieren Sie das inerte Plugin in server.js und fügen Sie statische Dateirouten in routes.js hinzu.

Client JavaScript: Schreiben Sie den Client -JavaScript -Code, um modale Windows Anzeige/ausblenden und Formulare mit AJAX senden.

Zusammenfassung

Dieses Tutorial erstellt eine grundlegende Notizanwendung, die auf HAPI.JS- und MVC-Architektur basiert. Obwohl noch viele Details verfeinert werden müssen (z. B. Eingabevalidierung, Fehlerbehandlung usw.), bildet dies eine Grundlage für das Lernen und das Erstellen von Node.js -Anwendungen. Sie können die Benutzerauthentifizierung, eine komplexere Benutzeroberfläche und andere Funktionen auf dieser Grundlage hinzufügen.

Das obige ist der detaillierte Inhalt vonSo erstellen und strukturieren Sie eine Node.js -MVC -Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!