Express: Wie übergebe ich eine App-Instanz an Routen aus einer anderen Datei?

Ich möchte meine Routen in verschiedene Dateien aufteilen, wobei eine Datei alle Routen und die andere die entsprechenden Aktionen enthält. Ich habe derzeit eine Lösung, um dies zu erreichen. Ich muss jedoch die App-Instanz global machen, um in den Aktionen darauf zugreifen zu können. Mein aktuelles Setup sieht folgendermaßen aus:

app.js:

var express   = require('express');
var app       = express.createServer();
var routes    = require('./routes');

var controllers = require('./controllers');
routes.setup(app, controllers);

app.listen(3000, function() {
  console.log('Application is listening on port 3000');
});

route.js:

exports.setup = function(app, controllers) {

  app.get('/', controllers.index);
  app.get('/posts', controllers.posts.index);
  app.get('/posts/:post', controllers.posts.show);
  // etc.

};

controller / index.js:

exports.posts = require('./posts');

exports.index = function(req, res) {
  // code
};

controller / posts.js:

exports.index = function(req, res) {
  // code
};

exports.show = function(req, res) {
  // code
};

Dieses Setup hat jedoch ein großes Problem: Ich habe eine Datenbank- und eine App-Instanz, die ich an die Aktionen übergeben muss (Controller / *. Js). Die einzige Option, die ich mir vorstellen kann, besteht darin, beide Variablen global zu machen, was eigentlich keine Lösung ist. Ich möchte Routen von den Aktionen trennen, weil ich viele Routen habe und sie an einem zentralen Ort haben möchte.

Was ist der beste Weg, um Variablen an die Aktionen zu übergeben, aber die Aktionen von den Routen zu trennen?

Verwenden Sie req.app,req.app.get('somekey')

Die durch Aufrufen erstellte Anwendungsvariable express()wird für die Anforderungs- und Antwortobjekte festgelegt.

Siehe: https://github.com/visionmedia/express/blob/76147c78a15904d4e4e469095a29d1bec9775ab6/lib/express.js#L34-L35

Node.js unterstützt zirkuläre Abhängigkeiten.
Durch die Verwendung von zirkulären Abhängigkeiten anstelle von require ('./ route') (App) wird viel Code bereinigt und jedes Modul ist weniger abhängig von seiner Ladedatei:

var app = module.exports = express(); //now app.js can be required to bring app into any file

//some app/middleware setup, etc, including 
app.use(app.router);

require('./routes'); //module.exports must be defined before this line

var app = require('../app');

app.get('/', function(req, res, next) {
  res.render('index');
});

//require in some other route files...each of which requires app independently
require('./user');
require('./blog');

Beispiel aus ihrem neuen Generator:
Schreiben der Route:
https://github.com/expressjs/generator/blob/master/templates/js/routes/index.js
Hinzufügen / Namespace der App: https://github.com /expressjs/generator/blob/master/templates/js/app.js#L24

Es gibt immer noch Anwendungsfälle für den Zugriff auf Apps von anderen Ressourcen aus, sodass zirkuläre Abhängigkeiten immer noch eine gültige Lösung sind.

Wie ich in den Kommentaren sagte, können Sie eine Funktion als module.exports verwenden. Eine Funktion ist auch ein Objekt, sodass Sie Ihre Syntax nicht ändern müssen.

app.js.

var controllers = require('./controllers')({app: app});

controller.js

module.exports = function(params)
{
    return require('controllers/index')(params);
}

controller / index.js

function controllers(params)
{
  var app = params.app;

  controllers.posts = require('./posts');

  controllers.index = function(req, res) {
    // code
  };
}

module.exports = controllers;

Oder mach das einfach:

var app = req.app

in der Middleware, die Sie für diese Routen verwenden. So wie das:

router.use( (req,res,next) => {
    app = req.app;
    next();
});

Angenommen, Sie haben einen Ordner mit dem Namen "contollers".

In Ihre app.js können Sie diesen Code einfügen:

console.log("Loading controllers....");
var controllers = {};

var controllers_path = process.cwd() + '/controllers'

fs.readdirSync(controllers_path).forEach(function (file) {
    if (file.indexOf('.js') != -1) {
        controllers[file.split('.')[0]] = require(controllers_path + '/' + file)
    }
});

console.log("Controllers loaded..............[ok]");

... und ...

router.get('/ping', controllers.ping.pinging);

In Ihrem Controller-Forlder befindet sich die Datei "ping.js" mit folgendem Code:

exports.pinging = function(req, res, next){
    console.log("ping ...");
}

Und das ist es....

1. So machen Sie Ihr DB-Objekt für alle Controller zugänglich, ohne es überall zu übergeben: Erstellen Sie eine Middleware auf Anwendungsebene, die das DB-Objekt an jedes erforderliche Objekt anfügt, und greifen Sie dann in jedem Controller darauf zu.

// app.js
let db = ...;  // your db object initialized
const contextMiddleware = (req, res, next) => {
  req.db=db;
  next();
};
app.use(contextMiddleware);

2. Um zu vermeiden, dass die App-Instanz überall übergeben wird, müssen Routen an den Ort übergeben werden, an dem sich die App befindet

// routes.js  It's just a mapping.
exports.routes = [
  ['/', controllers.index],
  ['/posts', controllers.posts.index],
  ['/posts/:post', controllers.posts.show]
];

// app.js
var { routes }    = require('./routes');
routes.forEach(route => app.get(...route));
// You can customize this according to your own needs, like adding post request

Die endgültige app.js:

// app.js
var express   = require('express');
var app       = express.createServer();

let db = ...;  // your db object initialized
const contextMiddleware = (req, res, next) => {
  req.db=db;
  next();
};
app.use(contextMiddleware);

var { routes }    = require('./routes');
routes.forEach(route => app.get(...route));

app.listen(3000, function() {
  console.log('Application is listening on port 3000');
});

Eine andere Version: Sie können dies an Ihre eigenen Bedürfnisse anpassen, z. B. das Hinzufügen einer Post-Anfrage

// routes.js  It's just a mapping.
let get = ({path, callback}) => ({app})=>{
  app.get(path, callback);
}
let post = ({path, callback}) => ({app})=>{
  app.post(path, callback);
}
let someFn = ({path, callback}) => ({app})=>{
  // ...custom logic
  app.get(path, callback);
}
exports.routes = [
  get({path: '/', callback: controllers.index}),
  post({path: '/posts', callback: controllers.posts.index}),
  someFn({path: '/posts/:post', callback: controllers.posts.show}),
];

// app.js
var { routes }    = require('./routes');
routes.forEach(route => route({app}));

Für die Datenbank trennen Sie den Datenzugriffsdienst, der die gesamte Datenbank mit einer einfachen API ausführt und den gemeinsamen Status vermeidet.

Das Trennen von route.setup sieht nach Overhead aus. Ich würde stattdessen lieber ein konfigurationsbasiertes Routing platzieren. Und konfigurieren Sie Routen in .json oder mit Anmerkungen.