路由

通常HTTP URL的格式是這樣的：

http://host[:port][path]

http表示協(xié)議。

host表示主機。

port為端口，可選字段，不提供時默認為80。

path指定請求資源的URI(Uniform Resource Identifier，統(tǒng)一資源定位符)，如果URL中沒有給出path，一般會默認成“/”（通常由瀏覽器或其它HTTP客戶端完成補充上）。

所謂路由，就是如何處理HTTP請求中的路徑部分。比如“http://xxx.com/users/profile”這個URL，路由將決定怎么處理/users/profile這個路徑。

來回顧我們在Node.js開發(fā)入門——Express安裝與使用中提供的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()調(diào)用，實際上就為我們的網(wǎng)站添加了一條路由，指定“/”這個路徑由get的第二個參數(shù)所代表的函數(shù)來處理。

express對象可以針對常見的HTTP方法指定路由，使用下面的方法：

app.METHOD(path, callback [, callback ...])

路由路徑

使用字符串的路由路徑示例：

// 匹配根路徑的請求

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

});

字符 ?、+、* 和 () 是正則表達式的子集，- 和 . 在基于字符串的路徑中按照字面值解釋。

使用正則表達式的路由路徑示例：

// 匹配任何路徑中含有 a 的路徑：

app.get(/a/, function(req, res) {

 res.send('/a/');

});

// 匹配 butterfly、dragonfly，不匹配 butterflyman、dragonfly man等

app.get(/.*fly$/, function(req, res) {

 res.send('/.*fly$/');

});

路由句柄

可以為請求處理提供多個回調(diào)函數(shù)，其行為類似 中間件。唯一的區(qū)別是這些回調(diào)函數(shù)有可能調(diào)用 next('route') 方法而略過其他路由回調(diào)函數(shù)?？梢岳迷摍C制為路由定義前提條件，如果在現(xiàn)有路徑上繼續(xù)執(zhí)行沒有意義，則可將控制權(quán)交給剩下的路徑。

路由句柄有多種形式，可以是一個函數(shù)、一個函數(shù)數(shù)組，或者是兩者混合，如下所示.

使用一個回調(diào)函數(shù)處理路由：

app.get('/example/a', function (req, res) {

 res.send('Hello from A!');

});

使用多個回調(diào)函數(shù)處理路由（記得指定 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!');

});

使用回調(diào)函數(shù)數(shù)組處理路由：

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

混合使用函數(shù)和函數(shù)數(shù)組處理路由：

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()調(diào)用的一個參數(shù)'/'修改為'*'，含義就不一樣。改動之前，只有訪問“http://localhost:8000”或“http://localhost:8000/”這種形式的訪問才會返回“Hello World!”，而改之后呢，像“http://localhost:8000/xxx/yyyy.zz”這種訪問也會返回“Hello World!”。

使用express構(gòu)建Web服務(wù)器時，很重要的一部分工作就是決定怎么響應(yīng)針對某個路徑的請求，也即路由處理。

最直接的路由配置方法，就是調(diào)用app.get()、app.post()一條一條的配置，不過對于需要處理大量路由的網(wǎng)站來講，這會搞出人命來的。所以呢，我們實際開發(fā)中需要結(jié)合路由參數(shù)（query string、正則表達式、自定義的參數(shù)、post參數(shù)）來減小工作量提高可維護性。更詳細的信息，參考http://expressjs.com/guide/routing.html。

中間件

Express里有個中間件（middleware）的概念。所謂中間件，就是在收到請求后和發(fā)送響應(yīng)之前這個階段執(zhí)行的一些函數(shù)。

要在一條路由的處理鏈上插入中間件，可以使用express對象的use方法。該方法原型如下：

app.use([path,] function [, function...])

當(dāng)app.use沒有提供path參數(shù)時，路徑默認為“/”。當(dāng)你為某個路徑安裝了中間件，則當(dāng)以該路徑為基礎(chǔ)的路徑被訪問時，都會應(yīng)用該中間件。比如你為“/abcd”設(shè)置了中間件，那么“/abcd/xxx”被訪問時也會應(yīng)用該中間件。

中間件函數(shù)的原型如下：

function (req, res, next)

第一個參數(shù)是Request對象req。第二個參數(shù)是Response對象res。第三個則是用來驅(qū)動中間件調(diào)用鏈的函數(shù)next，如果你想讓后面的中間件繼續(xù)處理請求，就需要調(diào)用next方法。

給某個路徑應(yīng)用中間件函數(shù)的典型調(diào)用是這樣的：

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

app.static中間件

Express提供了一個static中間件，可以用來處理網(wǎng)站里的靜態(tài)文件的GET請求，可以通過express.static訪問。

express.static的用法如下：

express.static(root, [options])

第一個參數(shù)root，是要處理的靜態(tài)資源的根目錄，可以是絕對路徑，也可以是相對路徑。第二個可選參數(shù)用來指定一些選項，比如maxAge、lastModified等，更多選項的介紹看這里：http://expressjs.com/guide/using-middleware.html#middleware.built-in。

一個典型的express.static應(yīng)用如下：

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

上面這段代碼將當(dāng)前路徑下的public目錄作為靜態(tài)文件，并且為Cache-Control頭部的max-age選項為1天。還有其它一些屬性，請對照express.static的文檔來理解。

使用express創(chuàng)建的HelloExpress項目的app.js文件里有這樣一行代碼：

app.use(express.static(path.join(__dirname, 'public')));

這行代碼將HelloExpress目錄下的public目錄作為靜態(tài)文件交給static中間件來處理，對應(yīng)的HTTP URI為“/”。path是一個Node.js模塊，__dirname是Node.js的全局變量，指向當(dāng)前運行的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”就可以了。

Router

Express還提供了一個叫做Router的對象，行為很像中間件，你可以把Router直接傳遞給app.use，像使用中間件那樣使用Router。另外你還可以使用router來處理針對GET、POST等的路由，也可以用它來添加中間件，總之你可以將Router看作一個微縮版的app。

下面的代碼創(chuàng)建一個Router實例：

var router = express.Router([options]);

然后你就可以像使用app一樣使用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) {
 // ..
});

定義了router后，也可以將其作為中間件傳遞給app.use：

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

上面這種用法，會針對URL中的“/events”路徑應(yīng)用router，你在router對象上配置的各種路由策略和中間件，都會被在合適的時候應(yīng)用。

路由模塊

express工具創(chuàng)建的應(yīng)用，有一個routes目錄，下面保存了應(yīng)用到網(wǎng)站的Router模塊，index.js和user.js。這兩個模塊基本一樣，我們研究一下index.js。

下面是index.js的內(nèi)容：

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創(chuàng)建了一個Router實例，然后調(diào)用router.get為“/”路徑應(yīng)用了路由函數(shù)。最后呢使用module.exports將Router對象導(dǎo)出。

下面是app.js里引用到index.js的代碼：

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

第一處，require(‘./routes/index')將其作為模塊使用，這行代碼導(dǎo)入了index.js，并且將index.js導(dǎo)出的router對象保存在變量routes里以供后續(xù)使用。注意，上面代碼里的routes就是index.js里的router。

第二處代碼，把routes作為一個中間件，掛載到了“/”路徑上。

模塊

前面分析index.js時看到了module.exports的用法。module.exports用來導(dǎo)出一個Node.js模塊內(nèi)的對象，調(diào)用者使用require加載模塊時，就會獲得導(dǎo)出的對象的實例。

我們的index.js導(dǎo)出了Router對象。app.js使用require(‘./routes/index')獲取了一個Router實例。

module.exports還有一個輔助用法，即直接使用exports來導(dǎo)出。

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

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

上面的代碼（假定在users.js文件里）直接使用exports來導(dǎo)出。當(dāng)使用exports來導(dǎo)出時，你設(shè)置給exports的屬性和方法，實際上都是module.exports的。這個模塊最終導(dǎo)出的是module.exports對象，你使用類似“exports.signup”這種形式設(shè)置的方法或?qū)傩裕{(diào)用方在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.  什么是router路徑，什么是middleware？

我們輸入www.baidu.com 來訪問百度的主頁，瀏覽器會自動轉(zhuǎn)換為 http://www.baidu.com:80/(省略一些參數(shù))。 http://代表我們同服務(wù)器連接使用的是http協(xié)議，www.baidu.com 代表的是服務(wù)器的主機地址，會被我們的pc通過DNS解析為IP地址。80是默認的應(yīng)用層端口。/ 即為我們訪問的服務(wù)器(www.baidu.com)的路徑，服務(wù)器要對我們訪問的這個路徑做出響應(yīng)，采取一定的動作。我們可以把這一過程看做一個路由。

 訪問的路徑‘/'即為router的路徑，服務(wù)器采取的動作即為middleware，即為一個個特殊的函數(shù)。

2. router路徑

www.baidu.com/test: 路徑為 /test

www.baidu.com/test?name=1&number=2: 路徑同樣為/test, ?后面會被服務(wù)器理解傳給路徑的參數(shù)。

3. Middleware

An Express application is essentially a stack of middleware which are executed serially.(express應(yīng)用其實就是由一系列順序執(zhí)行的Middleware組成。)

A middleware is a function with access to the request object (req), the response object (res), and the next middleware in line in the request-response cycle of an Express application. It is commonly denoted by a variable named next. Each middleware has the capacity to execute any code, make changes to the request and the reponse object, end the request-response cycle, and call the next middleware in the stack. Since middleware are execute serially, their order of inclusion is important.(中間件其實就是一個訪問express應(yīng)用串入的req，res，nex參數(shù)的函數(shù)，這個函數(shù)可以訪問任何通過req，res傳入的資源。)

If the current middleware is not ending the request-response cycle, it is important to call next() to pass on the control to the next middleware, else the request will be left hanging.(如果當(dāng)前中間件沒有完成對網(wǎng)頁的res響應(yīng) ，還可以通過next把router 留給下一個middleware繼續(xù)執(zhí)行)

With an optional mount path, middleware can be loaded at the application level or at the router level. Also, a series of middleware functions can be loaded together, creating a sub-stack of middleware system at a mount point.

路由的產(chǎn)生是通過HTTP的各種方法(GET, POST)產(chǎn)生的，Middleware可以跟router路徑跟特定的HTTP方法綁定，也可以跟所有的方法綁定。

3.1 通過express應(yīng)用的use（all），把Middleware同router路徑上的所有HTTP方法綁定：

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

3.2 通過express應(yīng)用的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對象

當(dāng)express實例的路由越來越多的時候，最好把路由分類獨立出去，express的實例(app) 能更好的處理其他邏輯流程。Express的Router對象是一個簡化的 app實例，只具有路由相關(guān)的功能，包括use, http verbs等等。最后這個Router再通過app的use掛載到app的相關(guān)路徑下。

 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上才能被響應(yīng)。所以上述代碼，只有在app捕捉到 /foo路徑上的路由時，才能router中定義的路由，雖然router中有針對 '/' 的路由，但是被app中的路由給覆蓋了。

附：app.verbs和app.use的路由路徑區(qū)別：

先看一段測試代碼：

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

輸出結(jié)果：test1 

輸入url： localhost:4000/hello

輸出結(jié)果：test2

結(jié)論：app.get掛載‘/'的路由只響應(yīng)跟'/'精確匹配的GET請求。 而app.use掛載的'/'的路由響應(yīng)所有以'/' 為起始路由的路由，且不限制HTTP訪問的方法。以下說明：Mounting a middleware at a path will cause the middleware function to be executed whenever the base of the requested path matches the path.

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。