express中间件和路由教程

Posted 2021-02-06

一、路由
1、通常HTTP URL的格式是这样的：http://host[:port][path]

• http表示协议。
• host表示主机。
• port为端口，可选字段，不提供时默认为80。
• path指定请求资源的URI(Uniform Resource Identifier，统一资源定位符)，如果URL中没有给出path，一般会默认成“/”（通常由浏览器或其它HTTP客户端完成补充上）。

所谓路由，就是如何处理HTTP请求中的路径部分。比如“http://xxx.com:80/users/profile”
这个URL，路由将决定怎么处理/users/profile这个路径。
路由是由一个 URI、HTTP 请求（GET、POST等）和若干个句柄组成，它的结构如下： app.METHOD(path, [callback...], callback)， app 是 express对象的一个实例， METHOD 是一个 HTTP 请求方法， path 是服务器上的路径， callback 是当路由匹配时要执行的函数。

//使用express显示helloworld：
var express = require(‘express‘);
var app = express();
app.get(‘/‘, function (req, res) {
  res.send(‘Hello World!‘);
});
app.listen(8000, function () {
  console.log(‘Hello World is listening at port 8000‘);
});

上面代码里的app.get()调用，实际上就为我们的网站添加了一条路由，指定“/”这个路径，由get的第二个参数所代表的函数来处理。
express对象可以针对常见的HTTP方法指定路由，使用下面的方法：
app.METHOD(path, callback [, callback ...])

2、路由方法
路由方法源于 HTTP 请求方法，和 express 实例相关联。
下面这个例子展示了为应用跟路径定义的 GET 和 POST 请求：

// GET method route
app.get(‘/‘, function (req, res) {
  res.send(‘GET request to the homepage‘);
});
// POST method route
app.post(‘/‘, function (req, res) {
  res.send(‘POST request to the homepage‘);
});

app.all() 是一个特殊的路由方法，没有任何 HTTP 方法与其对应，它的作用是对于一个路径上的所有请求加载中间件。
在下面的例子中，来自 “/secret” 的请求，不管使用 GET、POST、PUT、DELETE 或其他任何 http 模块支持的 HTTP 请求，句柄都会得到执行。

app.all(‘/secret‘, function (req, res, next) {
  console.log(‘Accessing the secret section ...‘);
  next(); // pass control to the next handler
});

3、路由路径
路由路径和请求方法一起定义了请求的端点，它可以是字符串、字符串模式或者正则表达式。
使用字符串的路由路径示例：

// 匹配根路径的请求
app.get(‘/‘, function (req, res) {
  res.send(‘root‘);
});
// 匹配 /about 路径的请求
app.get(‘/about‘, function (req, res) {
  res.send(‘about‘);
});
// 匹配 /random.text 路径的请求
app.get(‘/random.text‘, function (req, res) {
  res.send(‘random.text‘);
});

使用字符串模式的路由路径示例：

// 匹配 acd 和 abcd
app.get(‘/ab?cd‘, function(req, res) {
  res.send(‘ab?cd‘);
});
// 匹配 abcd、abbcd、abbbcd等
app.get(‘/ab+cd‘, function(req, res) {
  res.send(‘ab+cd‘);
});
// 匹配 abcd、abxcd、abRABDOMcd、ab123cd等
app.get(‘/ab*cd‘, function(req, res) {
  res.send(‘ab*cd‘);
});
// 匹配 /abe 和 /abcde
app.get(‘/ab(cd)?e‘, function(req, res) {
 res.send(‘ab(cd)?e‘);
});

4、路由句柄
可以为请求处理，提供多个回调函数，其行为类似 中间件。唯一的区别是这些回调函数有可能调用 next(‘route‘) 方法而略过其他路由回调函数。可以利用该机制为路由定义前提条件，如果在现有路径上继续执行没有意义，则可将控制权交给剩下的路径。
路由句柄有多种形式，可以是一个函数、一个函数数组，或者是两者混合，如下所示.

//使用一个回调函数处理路由：
app.get(‘/example/a‘, function (req, res) {
  res.send(‘Hello from A!‘);
});
//使用多个回调函数处理路由（记得指定 next 对象）：
app.get(‘/example/b‘, function (req, res, next) {
  console.log(‘response will be sent by the next function ...‘);
  next();
}, function (req, res) {
  res.send(‘Hello from B!‘);
});
//使用回调函数数组处理路由：
var cb0 = function (req, res, next) {
  console.log(‘CB0‘);
  next();
}
var cb1 = function (req, res, next) {
  console.log(‘CB1‘);
  next();
}
var cb2 = function (req, res) {
  res.send(‘Hello from C!‘);
}
app.get(‘/example/c‘, [cb0, cb1, cb2]);
//混合使用函数和函数数组处理路由：
var cb0 = function (req, res, next) {
  console.log(‘CB0‘);
  next();
}
var cb1 = function (req, res, next) {
  console.log(‘CB1‘);
  next();
}
app.get(‘/example/d‘, [cb0, cb1], function (req, res, next) {
  console.log(‘response will be sent by the next function ...‘);
  next();
}, function (req, res) {
  res.send(‘Hello from D!‘);
});

METHOD可以是GET、POST等HTTP方法的小写，例如app.get，app.post。path部分呢，既可以是字符串字面量，也可以是正则表达式。最简单的例子，把前面代码里的app.get()调用的一个参数’/’修改为’*’，含义就不一样。改动之前，只有访问“http://localhost:8000”或“http://localhost:8000/”这种形式的访问才会返回“Hello World!”，而改之后呢，像“http://localhost:8000/xxx/yyyy.zz”这种访问也会返回“Hello World!”。

使用express构建Web服务器时，很重要的一部分工作就是决定怎么响应针对某个路径的请求，也即路由处理。
最直接的路由配置方法，就是调用app.get()、app.post()一条一条的配置，不过对于需要处理大量路由的网站来讲，这会搞出人命来的。所以呢，我们实际开发中需要结合路由参数（query string、正则表达式、自定义的参数、post参数）来减小工作量提高可维护性。

5、响应方法
下表中响应对象（res）的方法向客户端返回响应，终结请求响应的循环。如果在路由句柄中一个方法也不调用，来自客户端的请求会一直挂起。

• res.download() 提示下载文件。
• res.end() 终结响应处理流程。
• res.json() 发送一个 JSON 格式的响应。
• res.jsonp() 发送一个支持 JSONP 的 JSON 格式的响应。
• res.redirect() 重定向请求。
• res.render() 渲染视图模板。
• res.send() 发送各种类型的响应。
• res.sendFile 以八位字节流的形式发送文件。
• res.sendStatus() 设置响应状态代码，并将其以字符串形式作为响应体的一部分发送。

6、app.route()
可使用 app.route() 创建路由路径的链式路由句柄。由于路径在一个地方指定，这样做有助于创建模块化的路由，而且减少了代码冗余和拼写错误。请参考 Router() 文档 了解更多有关路由的信息。
下面这个示例程序使用 app.route() 定义了链式路由句柄。

app.route(‘/book‘)
  .get(function(req, res) {
    res.send(‘Get a random book‘);
  })
  .post(function(req, res) {
    res.send(‘Add a book‘);
  })
  .put(function(req, res) {
    res.send(‘Update the book‘);
  });

7、express.Router
express还提供了一个叫做Router的对象，行为很像中间件，你可以把Router直接传递给app.use，像使用中间件那样使用Router。另外你还可以使用router来处理针对GET、POST等的路由，也可以用它来添加中间件，总之你可以将Router看作一个微缩版的app。
可使用 express.Router 类创建模块化、可挂载的路由句柄。Router 实例是一个完整的中间件和路由系统，因此常称其为一个 “mini-app”。
下面的实例程序创建了一个路由模块，并加载了一个中间件，定义了一些路由，并且将它们挂载至应用的路径上。

在 app 目录下创建名为 birds.js 的文件，内容如下：

var express = require(‘express‘);
var router = express.Router();

// 该路由使用的中间件
router.use(function timeLog(req, res, next) {
  console.log(‘Time: ‘, Date.now());
  next();
});
// 定义网站主页的路由
router.get(‘/‘, function(req, res) {
  res.send(‘Birds home page‘);
});
// 定义 about 页面的路由
router.get(‘/about‘, function(req, res) {
  res.send(‘About birds‘);
});
module.exports = router;

然后在应用中加载路由模块：

var birds = require(‘./birds‘);
app.use(‘/birds‘, birds);

应用即可处理发自 /birds 和 /birds/about 的请求，并且调用为该路由指定的 timeLog 中间件。
上面这种用法，会针对URL中的“/birds”路径应用router，你在router对象上配置的各种路由策略和中间件，都会被在合适的时候应用。
8、路由模块
express工具创建的应用，有一个routes目录，下面保存了应用到网站的Router模块，index.js和user.js。这两个模块基本一样，我们研究一下index.js。

//index.js
var express = require(‘express‘);
var router = express.Router();
/* GET home page. */
router.get(‘/‘, function(req, res, next) {
  res.render(‘index‘, { title: ‘Express‘ });
});
module.exports = router;

index.js创建了一个Router实例，然后调用router.get为“/”路径应用了路由函数。最后呢使用module.exports将Router对象导出。
下面是app.js里引用到index.js的代码：

//app.js
var routes = require(‘./routes/index‘);
...
app.use(‘/‘, routes);

• 第一处，require(‘./routes/index’)将其作为模块使用，这行代码导入了index.js，并且将index.js导出的router对象保存在变量routes里以供后续使用。注意，上面代码里的routes就是index.js里的router。
• 第二处代码，把routes作为一个中间件，挂载到了“/”路径上。

9、模块
前面分析index.js时看到了module.exports的用法。module.exports用来导出一个Node.js模块内的对象，调用者使用require加载模块时，就会获得导出的对象的实例。
我们的index.js导出了Router对象。app.js使用require(‘./routes/index’)获取了一个Router实例。
module.exports还有一个辅助用法，即直接使用exports来导出。

exports.signup = function(req, res){
  //some code
}
exports.login = function(req, res){
  //some code
}

上面的代码（假定在users.js文件里）直接使用exports来导出。当使用exports来导出时，你设置给exports的属性和方法，实际上都是module.exports的。这个模块最终导出的是module.exports对象，你使用类似“exports.signup”这种形式设置的方法或属性，调用方在require后都可以直接使用。
使用users模块的代码可能是这样的：

var express = require(‘express‘);
var app = express();
...
var users = require(‘./routes/users‘);
app.post(‘/signup‘, users.signup);
app.post(‘/login‘, users.login);
...

二、中间件
1、概念
express里有个中间件（middleware）的概念。所谓中间件，就是在收到请求后和发送响应之前这个阶段执行的一些函数。
中间件（Middleware） 是一个函数，它可以访问请求对象（request object (req)）, 响应对象（response object (res)）, 和 web 应用中处于请求-响应循环流程中的中间件，一般被命名为 next 的变量。
中间件的功能包括：

• 执行任何代码。
• 修改请求和响应对象。
• 终结请求-响应循环。
• 调用堆栈中的下一个中间件。
  如果当前中间件没有终结请求-响应循环，则必须调用 next() 方法将控制权交给下一个中间件，否则请求就会挂起。
  要在一条路由的处理链上插入中间件，可以使用express对象的use方法。该方法原型如下：
  app.use([path,] function [, function...])
  当app.use没有提供path参数时，路径默认为“/”。当你为某个路径安装了中间件，则当以该路径为基础的路径被访问时，都会应用该中间件。比如你为“/abcd”设置了中间件，那么“/abcd/xxx”被访问时也会应用该中间件。
  在一个路径上挂载一个中间件之后，每当请求的路径的前缀部分匹配了这个路由路径，那么这个中间件就会被执行。 由于默认的路径为/，中间件挂载没有指定路径，那么对于每个请求，这个中间件都会被执行
  
  中间件方法是顺序处理的，所以中间件包含的顺序是很重要的
  
  调用中间件时候的路径可以是代表路径的一串字符，一个路径模式，一个匹配路径的正则表达式，或者他们的一组集合
  
  中间件方法可以是一个中间件方法，一系列中间件方法，一组中间件方法或者他们的集合。由于路由router和express实例app也实现了中间件接口，所以你可以像使用其他任一中间件方法那样使用它们
  
  对于相同的挂载路径可以挂载多个中间件，因为路径的相同，调用next的时候会自动执行下一个匹配相同路径的中间件
  
  中间件函数的原型如下：
  function (req, res, next)
  第一个参数是Request对象req。第二个参数是Response对象res。第三个则是用来驱动中间件调用链的函数next，如果你想让后面的中间件继续处理请求，就需要调用next方法。
  给某个路径应用中间件函数的典型调用是这样的：

  app.use(‘/abcd‘, function (req, res, next) {
  console.log(req.baseUrl);
  next();
  })

  Express 应用可使用如下几种中间件：

• 应用级中间件
• 路由级中间件
• 错误处理中间件
• 内置中间件
• 第三方中间件
  2、app.static中间件
  Express提供了一个static中间件，可以用来处理网站里的静态文件的GET请求，可以通过express.static访问。
  express.static的用法如下：
  express.static(root, [options])
  第一个参数root，是要处理的静态资源的根目录，可以是绝对路径，也可以是相对路径。第二个可选参数用来指定一些选项，比如maxAge、lastModified等，更多选项的介绍看这里：http://expressjs.com/guide/using-middleware.html#middleware.built-in。
  一个典型的express.static应用如下：

  var options = {
  dotfiles: ‘ignore‘,
  etag: false,
  extensions: [‘htm‘, ‘html‘],
  index: false,
  maxAge: ‘1d‘,
  redirect: false,
  setHeaders: function (res, path, stat) {
  res.set(‘x-timestamp‘, Date.now());
  }
  }
  app.use(express.static(‘public‘, options));

  上面这段代码将当前路径下的public目录作为静态文件，并且为Cache-Control头部的max-age选项为1天。还有其它一些属性，请对照express.static的文档来理解。

使用express创建的HelloExpress项目的app.js文件里有这样一行代码：

app.use(express.static(path.join(dirname, ‘public‘)));
这行代码将HelloExpress目录下的public目录作为静态文件交给static中间件来处理，对应的HTTP URI为“/”。path是一个Node.js模块，dirname是Node.js的全局变量，指向当前运行的js脚本所在的目录。path.join()则用来拼接目录。

有了上面的代码，你就可以在浏览器里访问“http://localhost:3000/stylesheets/style.css”。
我们做一点改动，把上面的代码修改成下面这样：

app.use(‘/static‘, express.static(path.join(__dirname, ‘public‘)));
上面的代码呢，针对/static路径使用static中间件处理public目录。这时你再用浏览器访问“http://localhost:3000/stylesheets/”
就会看到一个404页面，将地址成
“http://localhost:3000/static/stylesheets/style.css”
就可以了。

3、应用级中间件
应用级中间件绑定到 app 对象 使用 app.use() 和 app.METHOD()， 其中， METHOD 是需要处理的 HTTP 请求的方法，例如 GET, PUT, POST 等等，全部小写。例如：

var app = express();
// 没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use(function (req, res, next) {
  console.log(‘Time:‘, Date.now());
  next();
});
// 挂载至 /user/:id 的中间件，任何指向 /user/:id 的请求都会执行它
app.use(‘/user/:id‘, function (req, res, next) {
  console.log(‘Request Type:‘, req.method);
  next();
});
// 路由和句柄函数(中间件系统)，处理指向 /user/:id 的 GET 请求
app.get(‘/user/:id‘, function (req, res, next) {
  res.send(‘USER‘);
});

4、下面这个例子展示了在一个挂载点装载一组中间件。

// 一个中间件栈，对任何指向 /user/:id 的 HTTP 请求打印出相关信息
app.use(‘/user/:id‘, function(req, res, next) {
  console.log(‘Request URL:‘, req.originalUrl);
  next();
}, function (req, res, next) {
  console.log(‘Request Type:‘, req.method);
  next();
});

5、作为中间件系统的路由句柄，使得为路径定义多个路由成为可能。在下面的例子中，为指向 /user/:id 的 GET 请求定义了两个路由。第二个路由虽然不会带来任何问题，但却永远不会被调用，因为第一个路由已经终止了请求-响应循环。

// 一个中间件栈，处理指向 /user/:id 的 GET 请求
app.get(‘/user/:id‘, function (req, res, next) {
  console.log(‘ID:‘, req.params.id);
  next();
}, function (req, res, next) {
  res.send(‘User Info‘);
});
// 处理 /user/:id， 打印出用户 id
app.get(‘/user/:id‘, function (req, res, next) {
  res.end(req.params.id);
});

6、如果需要在中间件栈中跳过剩余中间件，调用 next(‘route‘) 方法将控制权交给下一个路由。 注意： next(‘route‘) 只对使用 app.VERB() 或 router.VERB() 加载的中间件有效。

// 一个中间件栈，处理指向 /user/:id 的 GET 请求
app.get(‘/user/:id‘, function (req, res, next) {
  // 如果 user id 为 0, 跳到下一个路由
  if (req.params.id == 0) next(‘route‘);
  // 否则将控制权交给栈中下一个中间件
  else next(); //
}, function (req, res, next) {
  // 渲染常规页面
  res.render(‘regular‘);
});

// 处理 /user/:id， 渲染一个特殊页面
app.get(‘/user/:id‘, function (req, res, next) {
  res.render(‘special‘);
});

7、路由级中间件

路由级中间件和应用级中间件一样，只是它绑定的对象为 express.Router()。

var router = express.Router();
路由级使用 router.use() 或 router.VERB() 加载。

上述在应用级创建的中间件系统，可通过如下代码改写为路由级：

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

// 没有挂载路径的中间件，通过该路由的每个请求都会执行该中间件
router.use(function (req, res, next) {
  console.log(‘Time:‘, Date.now());
  next();
});
// 一个中间件栈，显示任何指向 /user/:id 的 HTTP 请求的信息
router.use(‘/user/:id‘, function(req, res, next) {
  console.log(‘Request URL:‘, req.originalUrl);
  next();
}, function (req, res, next) {
  console.log(‘Request Type:‘, req.method);
  next();
});
// 一个中间件栈，处理指向 /user/:id 的 GET 请求
router.get(‘/user/:id‘, function (req, res, next) {
  // 如果 user id 为 0, 跳到下一个路由
  if (req.params.id == 0) next(‘route‘);
  // 负责将控制权交给栈中下一个中间件
  else next(); //
}, function (req, res, next) {
  // 渲染常规页面
  res.render(‘regular‘);
});
// 处理 /user/:id， 渲染一个特殊页面
router.get(‘/user/:id‘, function (req, res, next) {
  console.log(req.params.id);
  res.render(‘special‘);
});
// 将路由挂载至应用
app.use(‘/‘, router);

8、错误处理中间件
错误处理中间件有 4 个参数，定义错误处理中间件时必须使用这 4 个参数。即使不需要 next 对象，也必须在签名中声明它，否则中间件会被识别为一个常规中间件，不能处理错误。

错误处理中间件和其他中间件定义类似，只是要使用 4 个参数，而不是 3 个，其签名如下： (err, req, res, next)。

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send(‘Something broke!‘);
});

9、内置中间件
从 4.x 版本开始，, Express 已经不再依赖 Connect 了。除了 express.static, Express 以前内置的中间件现在已经全部单独作为模块安装使用了。

express.static(root, [options])
express.static 是 Express 唯一内置的中间件。它基于 serve-static，负责在 Express 应用中提托管静态资源。
参数 root 指提供静态资源的根目录。
可选的 options 参数拥有如下属性。

• dotfiles 是否对外输出文件名以点（.）开头的文件。可选值为 “allow”、“deny” 和 “ignore” String “ignore”
• etag 是否启用 etag 生成 Boolean true
• extensions 设置文件扩展名备份选项 Array []
• index 发送目录索引文件，设置为 false 禁用目录索引。 Mixed “index.html”
• lastModified 设置 Last-Modified 头为文件在操作系统上的最后修改日期。可能值为 true 或 false。 Boolean true
• maxAge 以毫秒或者其字符串格式设置 Cache-Control 头的 max-age 属性。 Number 0
• redirect 当路径为目录时，重定向至 “/”。 Boolean true
• setHeaders 设置 HTTP 头以提供文件的函数。 Function
  下面的例子使用了 express.static 中间件，其中的 options 对象经过了精心的设计。

  var options = {
  dotfiles: ‘ignore‘,
  etag: false,
  extensions: [‘htm‘, ‘html‘],
  index: false,
  maxAge: ‘1d‘,
  redirect: false,
  setHeaders: function (res, path, stat) {
  res.set(‘x-timestamp‘, Date.now());
  }
  }
  app.use(express.static(‘public‘, options));

  每个应用可有多个静态目录。

  app.use(express.static(‘public‘));
  app.use(express.static(‘uploads‘));
  app.use(express.static(‘files‘));

  9、第三方中间件
  通过使用第三方中间件从而为 Express 应用增加更多功能。

安装所需功能的 node 模块，并在应用中加载，可以在应用级加载，也可以在路由级加载。

下面的例子安装并加载了一个解析 cookie 的中间件： cookie-parser

$ npm install cookie-parser
var express = require(‘express‘);
var app = express();
var cookieParser = require(‘cookie-parser‘);

// 加载用于解析 cookie 的中间件
app.use(cookieParser());

三、总结
1、什么是router路径，什么是middleware？
我们输入www.baidu.com 来访问百度的主页，浏览器会自动转换为 http://www.baidu.com:80/(省略一些参数)。
http:// 代表我们同服务器连接使用的是http协议，
www.baidu.com 代表的是服务器的主机地址，会被我们的pc通过DNS解析为IP地址。
80是默认的应用层端口。
/ 即为我们访问的服务器(www.baidu.com)的路径，服务器要对我们访问的这个路径做出响应，采取一定的动作。我们可以把这一过程看做一个路由。
访问的路径‘/’即为router的路径，服务器采取的动作即为middleware，即为一个个特殊的函数。
2. router路径
www.baidu.com/test: 路径为 /test
www.baidu.com/test?name=1&number=2: 路径同样为/test, ?后面会被服务器理解传给路径的参数。
3. Middleware
express应用其实就是由一系列顺序执行的Middleware组成。
中间件其实就是一个访问express应用传入的req，res，nex参数的函数，这个函数可以访问任何通过req，res传入的资源。
如果当前中间件没有完成对网页的res响应 ，还可以通过next把router 留给下一middleware继续执行
路由的产生是通过HTTP的各种方法(GET, POST)产生的，Middleware可以跟router路径跟特定的HTTP方法绑定，也可以跟所有的方法绑定。
3.1 通过express应用的use（all），把Middleware同router路径上的所有HTTP方法绑定：

app.use(function (req, res, next) {
    console.log(‘Time: %d‘, Date.now());
    next();
})

3.2 通过express应用的http.verb，把Middleware同router路径上的特定的HTTP方法绑定：

app.get(‘/‘, function(req, res){
  res.send(‘hello world‘);
});
app.post(‘/‘, function(req, res){
  res.send(‘hello world‘);
});

4、express的Router对象
当express实例的路由越来越多的时候，最好把路由分类独立出去，express的实例(app) 能更好的处理其他逻辑流程。Express的Router对象是一个简化的 app实例，只具有路由相关的功能，包括use, http verbs等等。最后这个Router再通过app的use挂载到app的相关路径下。

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 ends in /bar
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);

router的路由必须通过app.use和app.verbs 挂载到app上才能被响应。所以上述代码，只有在app捕捉到 /foo路径上的路由时，才能router中定义的路由，虽然router中有针对 ‘/‘ 的路由，但是被app中的路由给覆盖了。

5、附：app.verbs和app.use的路由路径区别：
先看一段测试代码：

var express = require(‘express‘);
var app = express();
var router = express.Router();
app.get(‘/‘, function(req, res){
     console.log(‘test1‘);
});
app.use(‘/‘, function(req, res){
     console.log(‘test2‘);
});
router.get(‘/‘, function(req, res){
     console.log(‘test3‘);
});
app.listen(4000);

输入url： localhost:4000
输出结果：test1
输入url： localhost:4000/hello
输出结果：test2

结论：app.get挂载‘/’的路由只响应跟‘/‘精确匹配的GET请求。 而app.use挂载的‘/‘的路由响应所有以‘/‘ 为起始路由的路由，且不限制HTTP访问的方法。