Architektura aplikacji oparta na Mongoose

Kiedy po raz pierwszy dostałem się do Node.js, Express i Mongoose, miałem problemy ze skalowaniem mojego kodu. Moją odpowiedzią jest pomoc komuś, kto pracuje nad czymś więcej niż tylko prostym blogiem, ale aby pomóc w jeszcze większym skalowalnym projekcie.

• Zawsze jestem połączony z bazą danych, nie otwieram i nie zamykam połączeń w razie potrzeby
• Używam index.js jako plik główny folderu, tak jak w innych językach
• modele są przechowywane we własnych dokumentach, a require() d do models/index.js plik.
• trasy są podobne do modeli, każdy poziom trasy ma folder, w którym znajduje się index.js plik z kolei. Więc łatwo jest zaaranżować coś takiego jak http://example.com/api/documents/:id . Ma to również większy sens, gdy przechodzi się przez strukturę plików.

Oto struktura tego, czego używam:

-- 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)

mangusta/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;

modele/blog.js

Więc dla każdego modelu, nad którym pracujesz, tworzysz plik model.js i dodaj go w models/index.js nad. Jako przykład dodałem User model, ale skomentował to.

// 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;

trasy/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
}

trasy/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
}

sugerowane użycie

• modele:do tworzenia logiki, która zajmuje się dokumentami, tj. tworzenie, aktualizacja, usuwanie i wyszukiwanie.
• trasy:minimalne kodowanie, tylko tam, gdzie muszę przeanalizować dane http, utworzyć instancje modeli, a następnie wysłać zapytania do odpowiedniego modelu.
• metody:dla bardziej złożonej logiki, która nie obejmuje bezpośrednio modeli. Jako przykład mam algorithms/ folder, w którym przechowuję wszystkie algorytmy, których używam w mojej aplikacji.

Mam nadzieję, że zapewni to większą jasność. Ta struktura działa dla mnie cuda, ponieważ łatwo ją śledzić.