express router路由管理中间件

在使用express管理url时，我们希望能有一种更方便的管理方式，可以更加简化路由的管理，express router 就是完成这项功能的，。

路由器

使用router目的是中间件和路由的分离的实例。您可以将其视为“迷你应用程序”，只能执行中间件和路由功能。每个Express应用程序都有一个内置的应用程序路由器。

路由器的行为类似于中间件本身，因此您可以将其用作 app.use（）的参数或作为另一个路由器的use（）方法的参数。

顶级express对象具有一个用于创建新对象的Router（）方法router。

一旦你创建了一个路由器的对象，你可以添加中间件和HTTP方法路由（如get，put，post，等），以它就像一个应用程序。例如：

var express = require('express');
var app = express();
var router = express.Router();
// invoked for any requests passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});

// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', function(req, res, next) {
  // ..
});
n punctuation">){
  res.send('hello world');
});
1
2
3

您还可以使用正则表达式 - 如果您具有非常特定的约束，则有用，例如，以下内容将匹配“GET / commits / 71dbb9c”以及“GET /commits/71dbb9c…4c084f9”。

router.get(/^\/commits\/(\w+)(?:\.\.(\w+))?$/, function(req, res){
  var from = req.params[0];
  var to = req.params[1] || 'HEAD';
  res.send('commit range ' + from + '..' + to);
});
1
2
3
4
5

router.param（名称，回调）

添加回调触发器以路由参数，其中name是参数的名称，并且callback是回调函数。虽然name从技术上讲是可选的，但从Express v4.11.0开始不推荐使用不带它的方法（见下文）。

回调函数的参数是：

• req，请求对象。
• res，响应对象。
• next，表明下一个中间件功能。
• name参数的值。
• 参数的名称。

不同app.param()，router.param()不接受一系列路由参数。

例如，当:user路径路径中存在时，您可以映射用户加载逻辑以自动提供req.user给路径，或者对参数输入执行验证。

router.param('user', function(req, res, next, id) {

  // try to get the user details from the User model and attach it to the request object
  User.find(id, function(err, user) {
    if (err) {
      next(err);
    } else if (user) {
      req.user = user;
      next();
    } else {
      next(new Error('failed to load user'));
    }
  });
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Param回调函数是定义它们的路由器的本地函数。它们不是由已安装的应用程序或路由器继承的。因此，定义的param回调router只能由路由上定义的路由参数触发router。

即使参数在多个路由中匹配，参数回调也只会在请求 - 响应周期中调用一次，如以下示例所示。

router.param('id', function (req, res, next, id) {
  console.log('CALLED ONLY ONCE');
  next();
});

router.get('/user/:id', function (req, res, next) {
  console.log('although this matches');
  next();
});

router.get('/user/:id', function (req, res) {
  console.log('and this matches too');
  res.end();
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在GET /user/42，打印以下内容：

CALLED ONLY ONCE
although this matches
and this matches too
1
2
3

以下部分介绍router.param(callback)了自v4.11.0起不推荐使用的内容。

router.param(name, callback)通过仅传递函数可以完全改变方法的行为router.param()。这个函数是如何自定义实现的router.param(name, callback)应该表现 - 它接受两个参数并且必须返回一个中间件。

此函数的第一个参数是应捕获的URL参数的名称，第二个参数可以是可用于返回中间件实现的任何JavaScript对象。

函数返回的中间件决定捕获URL参数时发生的行为。

在此示例中，router.param(name, callback)签名被修改为router.param(name, accessId)。router.param()现在接受姓名和号码，而不是接受姓名和回调。

var express = require('express');
var app = express();
var router = express.Router();

// customizing the behavior of router.param()
router.param(function(param, option) {
  return function (req, res, next, val) {
    if (val == option) {
      next();
    }
    else {
      res.sendStatus(403);
    }
  }
});

// using the customized router.param()
router.param('id', 1337);

// route to trigger the capture
router.get('/user/:id', function (req, res) {
  res.send('OK');
});

app.use(router);

app.listen(3000, function () {
  console.log('Ready');
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在此示例中，router.param(name, callback)签名保持不变，但是代替中间件回调，已定义自定义数据类型检查功能以验证用户标识的数据类型。

router.param(function(param, validator) {
  return function (req, res, next, val) {
    if (validator(val)) {
      next();
    }
    else {
      res.sendStatus(403);
    }
  }
});

router.param('id', function (candidate) {
  return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14

router.route（路径）

返回单个路由的实例，然后您可以使用该实例来处理带有可选中间件的HTTP谓词。使用router.route()以避免重复路线的命名，因此输入错误。

基于上面的router.param()示例，以下代码显示了如何使用它 router.route()来指定各种HTTP方法处理程序。

var router = express.Router();

router.param('user_id', function(req, res, next, id) {
  // sample user, would actually fetch from DB, etc...
  req.user = {
    id: id,
    name: 'TJ'
  };
  next();
});

router.route('/users/:user_id')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
  next();
})
.get(function(req, res, next) {
  res.json(req.user);
})
.put(function(req, res, next) {
  // just an example of maybe updating the user
  req.user.name = req.params.name;
  // save user ... etc
  res.json(req.user);
})
.post(function(req, res, next) {
  next(new Error('not implemented'));
})
.delete(function(req, res, next) {
  next(new Error('not implemented'));
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

此方法重用单个/users/:user_id路径并为各种HTTP方法添加处理程序。

注意：使用时router.route()，中间件排序基于创建路径的时间，而不是基于方法处理程序添加到路径时。为此，您可以将方法处理程序视为属于添加它们的路径。

router.use（[path]，[function，…] function）

使用指定的中间件函数或函数，以及可选的安装路径path，默认为“/”。

此方法类似于app.use（）。下面描述一个简单的例子和用例。有关更多信息，请参阅app.use（）。

中间件就像一个管道管道：请求从定义的第一个中间件功能开始，并按照它们匹配的每个路径“中断”中间件堆栈处理。

var express = require('express');
var app = express();
var router = express.Router();

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use(function(req, res, next) {
  console.log('%s %s %s', req.method, req.url, req.path);
  next();
});

// this will only be invoked if the path starts with /bar from the mount point
router.use('/bar', function(req, res, next) {
  // ... maybe some additional /bar logging ...
  next();
});

// always invoked
router.use(function(req, res, next) {
  res.send('Hello World');
});

app.use('/foo', router);

app.listen(3000);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

“mount”路径被剥离，中间件功能不可见。此功能的主要作用是，无论其“前缀”路径名如何，安装的中间件功能都可以在没有代码更改的情况下运行。

您定义中间件的顺序router.use()非常重要。它们按顺序调用，因此顺序定义了中间件优先级。例如，通常记录器是您将使用的第一个中间件，因此每个请求都会被记录。

var logger = require('morgan');

router.use(logger());
router.use(express.static(__dirname + '/public'));
router.use(function(req, res){
  res.send('Hello');
});
1
2
3
4
5
6
7

现在假设您想忽略静态文件的日志记录请求，但是要继续记录之后定义的路由和中间件logger()。express.static()在添加记录器中间件之前，您只需将调用移至顶部：

router.use(express.static(__dirname + '/public'));
router.use(logger());
router.use(function(req, res){
  res.send('Hello');
});
1
2
3
4
5

另一个例子是提供来自多个目录的文件，优先于“./public”而不是其他目录：

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));
1
2
3

该router.use()方法还支持命名参数，以便其他路由器的挂载点可以从使用命名参数的预加载中受益。

注意：虽然这些中间件功能是通过一个特定的路由器加入，当 它们运行是由它们所连接到路径（而不是路由器）中所定义。因此，如果路由匹配，则通过一个路由器添加的中间件可以运行其他路由器。例如，此代码显示安装在同一路径上的两个不同的路由器：

var authRouter = express.Router();
var openRouter = express.Router();

authRouter.use(require('./authenticate').basic(usersdb));

authRouter.get('/:user_id/edit', function(req, res, next) { 
  // ... Edit user UI ...  
});
openRouter.get('/', function(req, res, next) { 
  // ... List users ... 
})
openRouter.get('/:user_id', function(req, res, next) { 
  // ... View user ... 
})

app.use('/users', authRouter);
app.use('/users', openRouter);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

即使通过authRouter它添加了身份验证中间件，它也将在由openRouter两个路由器安装的路由上运行/users。要避免此行为，请为每个路由器使用不同的路径。