快速路由器中间件被多次调用

Question

使用Express和Express Router。我在一个目录中只有少数几个文件，它们都实现了Express.Router。我动态地要求他们，添加一些中间件，然后将它们附加到“元”路由器，最后调用app.use("/",MetaRouter)。

我的问题是，对于每个路由，中间件都被多次调用。

这里是/index.js：

const express = require('express')
const bodyParser = require('body-parser');
const app = express();
const port = 4000;
var cors = require('cors')
var routes = require('./routes');

app.use(cors());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));

app.use(routes);

app.listen(port, '0.0.0.0', () => console.log(`Example app listening on port ${port}!`))

需要/routes/index.js：

const fs = require('fs');
const path = require('path');
var express = require('express');
var MetaRouter = express.Router();
var passport = require('passport');

const files = fs.readdirSync(__dirname).filter(file => file !== 'index.js');      

const fileModules = {};

var middleware = function(req, res, next) {
    console.log('In The Middleware');
    next();
  }


files.forEach(file => {
    const { name } = path.parse(file); 
    fileModules[name] = require(`./${name}`);
});

Object.entries(fileModules).forEach(([key, _router]) => {
    _router.use(middleware);
    MetaRouter.use(_router);

});

module.exports = MetaRouter;

这是目录中路由器文件之一的示例：

const BoxRequestService = require("../services/request/box_request_service.js");
var express = require('express');
var router = express.Router();

router.get('/box',
  async function (req, res) {
      res.json(await BoxRequestService.getAll(req, res));
  });

router.get('/box/:id',
  async function (req, res) {
    res.json(await BoxRequestService.findById(req, res));
  }
);

router.put('/box/:id',
  async function (req, res) {
    res.json(await BoxRequestService.update(req, res));
  });

router.post('/box', async function (req, res) {
  res.json(await BoxRequestService.create(req, res));
});

module.exports = router;

预期结果

因此，当请求http://localhost/box时，我希望在控制台中仅看到一次“在中间件中”。

实际结果

相反，我看到“在中间件中”多次记录。它还取决于所需文件的顺序。因此，鉴于此文件列表（按此顺序要求）：

• /routes/A.js
• /routes/B.js
• /routes/C.js
• /routes/D.js

如果请求A.js中的路由，则中间件将被调用一次。 如果请求B.js中的路由，则调用中间件两次。 如果请求C.js中的路由，则调用中间件3次。 等等 等

Answer 1

Express中间件不是按路由器实例而是按路径附加的。由于未指定路径，因此我对_router.use(middleware);的调用将中间件附加到所有路径。而且由于我是在循环中调用它的，所以我只是多次向所有路径添加相同的中间件。

为解决此问题，并仍然获得动态需要单个路由器文件的好处，我对代码进行了一些更改。

首先，我向每个路由器文件添加了一个小的“元数据”对象。它有两个字段。一个拥有路由“前缀”（文件中每个路由将以其开头的路径），还有一个内容表明该文件中的路由是否需要授权（我的中间件正在授权）。

然后我同时从该路由器文件中导出路由器和元数据。

现在回到我的`/routes/index.js'文件...

在这里，我仍然动态地要求所有单独的路由，并附加中间件。但是，我使用路由器的元数据来使用路由器的前缀附加路由器，因此我不会将中间件一遍又一遍地应用于相同的路由路径。

/routes/index.js

const fs = require('fs');
const path = require('path');
const auth_service = require('./../utils/auth_service');
var express = require('express');
var MetaRouter = express.Router();

// collect all of the legitimate router files
const files = fs.readdirSync(__dirname).filter(file => file !== 'index.js');

// pull in each "child" router, attach it to the "meta router" and apply middleware
files.forEach(file => {
    const { name } = path.parse(file);
    _router = require(`./${name}`);
    MetaRouter.use(_router.router_metadata.endpoint_prefix, auth_service.auth_middleware(_router.router_metadata), _router.router);
});

module.exports = MetaRouter;

我的一个路由器文件

const BoxRequestService = require("../services/request/box_request_service.js");
var express = require('express');
var router = express.Router();

const router_metadata = {
  endpoint_prefix: '/box',
  requires_auth: true
}

router.get('/:id',
  async function (req, res) {
    res.json(await BoxRequestService.findById(req, res));
  }
);

router.put('/:id',
  async function (req, res) {
    res.json(await BoxRequestService.update(req, res));
  });

router.post('/', async function (req, res) {
  res.json(await BoxRequestService.create(req, res));
});

router.get('/',
  async function (req, res) {
    res.json(await BoxRequestService.getAll(req, res));
  });

module.exports = { router, router_metadata }; 

而且，这是我定义中间件的地方

在这里，我使用路由器的元数据来确定中间件是否应应用于其路径。

var passport = require('passport');
require('../config/passport')(passport);

let self = module.exports = {

    auth_middleware: function(router_metadata){
        return function (req, res, next) {
            if (router_metadata.requires_auth) {
                passport.authenticate('jwt', { session: false }, function (err, user, info) {
                    if (err) { return next(err); }
                    if (!user) {
                        res.status("401");
                        return res.send("Unauthorized").end();
                    }
                    req.user = user;
                    next();
                })(req, res, next);
            } else {
                next();
            }
        }
    }

}