Mongoose-basierte App-Architektur

Als ich zum ersten Mal mit Node.js, Express und Mongoose zu tun hatte, hatte ich Probleme mit der Skalierung meines Codes. Die Absicht meiner Antwort ist es, jemandem zu helfen, der an mehr als nur einem einfachen Blog arbeitet, sondern bei einem noch größeren skalierbaren Projekt zu helfen.

• Ich bin immer mit der Datenbank verbunden, ich öffne und schließe keine Verbindungen, wenn es nötig ist
• Ich verwende index.js als Stammdatei eines Ordners, genau wie wir es in anderen Sprachen tun würden
• Modelle werden in ihren eigenen Dokumenten aufbewahrt und require() d in die models/index.js Datei.
• Routen ähneln Modellen, jede Routenebene hat einen Ordner, der eine index.js hat Datei wiederum. Es ist also einfach, so etwas wie http://example.com/api/documents/:id zu arrangieren . Sinnvoller ist es auch, wenn man die Dateistruktur durchgeht.

Hier ist die Struktur dessen, was ich verwende:

-- app.js
-- models/
---- index.js
---- blog.js
-- mongoose/
---- index.js
-- routes/
---- index.js
---- blog/index.js
-- public/
-- views/
---- index.{your layout engine} => I use Jade.lang
-- methods/
---- index.js => use if you'd rather write all your functions here
---- blog.js => can store more complex logic here

app.js

var db = require('./mongoose'),
  express = require('express');
// note that I'm leaving out the other things like 'http' or 'path'
var app = express();

// get the routes
require('./routes')(app);
// I just require routes, without naming it as a var, & that I pass (app)

mongoose/index.js

// Mongoose connect is called once by the app.js & connection established
// No need to include it elsewhere
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/blog');

// I have just connected, and I'm not exporting anything from here

models/index.js

// Logic here is to keep a good reference of what's used

// models
Blog = require('./blog');
// User = require('./user');

// exports
exports.blogModel = Blog.blogModel;
// exports.userModel = User.userModel;

models/blog.js

Sie erstellen also für jedes Modell, an dem Sie arbeiten, eine model.js Dokument, und fügen Sie es in models/index.js hinzu Oben. Als Beispiel habe ich einen User hinzugefügt model, aber auskommentiert.

// set up mongoose
var mongoose = require('mongoose');
var Schema = mongoose.Schema,
ObjectId = Schema.ObjectId;

var BlogSchema = Schema({
  header: {type: String },
  author: {type: String },
  text: {type: String },
  _id: { type: ObjectId } // not necessary, showing use of ObjectId
});

Blog = mongoose.model('Blog', BlogSchema);
// the above is necessary as you might have embedded schemas which you don't export

exports.blogModel = Blog;

routes/index.js

module.exports = function(app) {
  app.get('/', function(req, res) {
    // do stuff
  });
  require('./blog')(app);
  // other routes entered here as require(route)(app);
  // we basically pass 'app' around to each route
}

routes/blog/index.js

module.exports = function(app) {
  app.get('/blog', function(req, res) {
    // do stuff
  });
  require('./nested')(app);
  // this is for things like http://example.com/blog/nested
  // you would follow the same logic as in 'routes/index.js' at a nested level
}

empfohlene Verwendung

• Modelle:zum Erstellen der Logik, die mit den Dokumenten umgeht, d. h. Erstellen, Aktualisieren, Löschen und Suchen.
• routes:minimale Codierung, nur dort, wo ich HTTP-Daten parsen, Instanzen von Modellen erstellen und dann Anfragen an das relevante Modell senden muss.
• Methoden:für die komplexere Logik, die nicht direkt Modelle einbezieht. Als Beispiel habe ich einen algorithms/ Ordner, in dem ich alle Algorithmen speichere, die ich in meiner App verwende.

Hoffe das bringt mehr Klarheit. Diese Struktur wirkt Wunder für mich, da ich sie leicht nachzuvollziehen finde.