本文是基於 kraken-js 0.6.1 版本的
關於如何使用kraken-js 可以去看看官網的使用文件 點選這裡 。kraken-js 是基於express之上的，目的在於讓工程師更多的去關注程式碼邏輯，少關注自身的開發環境，所以他將express所有的一些公用的配置都寫在了配置檔案裡面了。暴露給開發者的很少。下面來看看kraken-js 原始碼，分析是如何建立nodejs應用程式的。如果對express 不太理解的，可以看看我之前部落格寫的express框架解密序列。
按照kraken-js 官網上的步驟，我們建立了一個新專案，然後生成了程式碼是這個樣子的：
對這個結構說明下：
- /config ---應用程式和中介軟體的配置
- /controllers ---路由和邏輯
- /lib ---使用者開發的第三方庫
- /locales ---語言包
- /models ---模型
- /public ---公共資源
- /public/templates ---模板
- /tests ---一些測試用例
- index.js ---應用程式入口
我們看看入口檔案 index.js 和路由檔案controllers/index.js
'use strict'; var kraken = require('kraken-js'), app = {}; app.configure = function configure(nconf, next) { // Fired when an app configures itself next(null); }; app.requestStart = function requestStart(server) { // Fired at the beginning of an incoming request }; app.requestBeforeRoute = function requestBeforeRoute(server) { // Fired before routing occurs }; app.requestAfterRoute = function requestAfterRoute(server) { // Fired after routing occurs }; kraken.create(app).listen(function (err) { if (err) { console.error(err); } });
'use strict'; module.exports = function (server) { server.get('/', function (req, res) { var model = { name: 'helloworld' }; res.render('index', model); }); };
我們看到在index.js 檔案裡面，沒有埠設定，沒有模板引擎以及其他的中介軟體設定，只有一些鉤子，這個就是kraken-js 的巧妙之處。
具體做法是：
首先建立一個app，給app新增一些方法（configure,requestStart,requestBeforeRoute,requestAfterRoute)，再將app作為kraken的create方法引數
傳進去，kraken.create(app)，然後在呼叫listen方法（主要是呼叫http的createServer建立一個服務）。其實這裡的app是一些鉤子，作為代理的方式給express框架使用，這些方法的引數server 就是express 框架建立的例項。我們在使用的時候，都是通過express的use方法來呼叫中介軟體的。這個後面會有詳細的解釋。
既然呼叫了kraken 的create方法，我們就去看看kraken 的原始碼，看看是怎麼構造這個應用程式的。
我們看到在kraken-js/index.js 中，提供了一個對外的呼叫函式：
exports.create = function (route, delegate) { return create().use(route, delegate); };
可以看到它先呼叫了本身的create方法，然後呼叫了use方法，我們去看看create方法：
function create() { return Object.create(kraken, { _app: { enumerable: true, writable: true, value: null }, _promise: { enumerable: true, writable: true, value: null }, host: { enumerable: true, writable: true, value: undefined }, port: { enumerable: true, writable: true, value: undefined }, '☯': { // This is silly, but since a require-d app may be using // kraken, but the proto isn't a reference to the same // object, we need to have a unique identifier for the // `isKraken` check. (Non-enumerable.) value: '☯' } }); }
它建立了一個kraken的物件，然後新增了一些屬性。在use的方法中，最重要的是：
chain = create(this._app) .then(assign) .then(create) .then(mount);
首先，通過呼叫create方法傳入了一個空的app，而這個create方法是
function create(delegate) { return appcore.create(delegate, pathutil.create(resolveRoot)); }
它直接呼叫了appcore的create方法：
function create(delegate, resolver, callback) { var app, appcore; if (isExpress(delegate)) { callback(null, delegate); return; } if (typeof resolver === 'function') { callback = resolver; resolver = pathutil.create(); } app = express(); if (!delegate) { patch.apply('stream', app); callback(null, app); return; } appcore = Object.create(proto, { _app: { enumerable: true, writable: false, value: app }, _delegate: { enumerable: true, writable: false, value: delegate }, _resolver: { enumerable: true, writable: false, value: resolver }, _config: { enumerable: true, writable: true, value: undefined }, _i18n: { enumerable: true, writable: true, value: undefined } }); appcore.init(function (err) { if (err) { callback(err); return; } callback(null, app); }); }
我們知道這個這個引數的app是為空的。所以進入了這個分支：
app = express(); if (!delegate) { patch.apply('stream', app); callback(null, app); return; }
直接將express匯入進來了。patch.apply('stream', app); 是將app的response 直接改寫了。返回了express 。接著執行：
.then(assign)
.then(create)
.then(mount);
assign 是將app賦值給this._app 了，同時做了第二件事情，將應用程式的那些鉤子返回出來，直接傳遞給create函式，我們看到create函式再次呼叫了，與第一次不同的是，本次的引數不為空，
而是我們在應用程式建立的那個“app”，即為我們之前所說的鉤子。最後在掛載這個應用程式。
在第二次呼叫create方法。其實就是通過proto 建立了一個appcore的物件：
appcore = Object.create(proto, { _app: { enumerable: true, writable: false, value: app }, _delegate: { enumerable: true, writable: false, value: delegate }, _resolver: { enumerable: true, writable: false, value: resolver }, _config: { enumerable: true, writable: true, value: undefined }, _i18n: { enumerable: true, writable: true, value: undefined } });
我們看到將這個app作為appcore的_app 屬性，將delegate 其實就是作為_delagate 的一個屬性。這個就是index.js 傳入的那個引數app物件，接著呼叫了proto的init方法：
appcore.init(function (err) { if (err) { callback(err); return; } callback(null, app); });
init 是直接呼叫了 _configure 方法，在這個方法中，首先通過賦值app為 app = this._app;然後通過方法 this._config = config.create(this._resolve('.'));，讀取kraken和本應用程式config 目錄下得config檔案。最後再呼叫 next方法。在next方法中：
function next(err) { var config, settings; if (err) { callback(err); return; } config = self._config; patch.apply('config', app, config); // XXX: Special-case resolving `express:views` until we get config protocols working. config.set('express:views', self._resolve(config.get('express:views'))); config.set('express:env', config.get('env:env')); config.set('express:port', config.port); config.set('express:host', config.host); settings = config.get('express'); Object.keys(settings).forEach(function (key) { app.set(key, settings[key]); }); settings = config.get('ssl'); if (settings) { app.set('ssl', settings); tls.SLAB_BUFFER_SIZE = settings.slabBufferSize || tls.SLAB_BUFFER_SIZE; tls.CLIENT_RENEG_LIMIT = settings.clientRenegotiationLimit || tls.CLIENT_RENEG_LIMIT; tls.CLIENT_RENEG_WINDOW = settings.clientRenegotiationWindow || tls.CLIENT_RENEG_WINDOW; } self._views(); self._middleware(); callback(); }
這個方法中，首先配置了一些引數。
然後再呼叫了處理檢視的引數_views(),接著呼叫了 _middleware（）函式。
我們看到：
if (typeof this._delegate.configure === 'function') { this._delegate.configure(this._config.raw, next); return; }
如果configure 是一個函式，那麼先呼叫這個，然後再呼叫那個next方法。在前面我們說過，this._delegate 其實就是index.js 裡面建立的那個“app” 鉤子。
檢視我們省略，我們主要看看怎麼呼叫_middleware 函式這個函式都做了些什麼。還是先上原始碼：
_middleware: function () { var app, delegate, config, srcRoot, staticRoot, errorPages; app = this._app; delegate = this._delegate; config = this._config.get('middleware'); srcRoot = this._resolve(config.static.srcRoot); staticRoot = this._resolve(config.static.rootPath); app.use(express.favicon()); app.use(kraken.compiler(srcRoot, staticRoot, this._config, this._i18n)); app.use(express.static(staticRoot)); app.use(kraken.logger(config.logger)); if (typeof delegate.requestStart === 'function') { delegate.requestStart(app); } config.bodyParser && console.warn('The `middleware:bodyParser` configuration will not be honored in future versions. Use `middleware:json`, `middleware:urlencoded`, and `middleware.multipart`.'); app.use(express.json(config.bodyParser || config.json)); app.use(express.urlencoded(config.bodyParser || config.urlencoded)); console.warn('Multipart body parsing will be disabled by default in future versions. To enable, use `middleware:multipart` configuration.'); app.use(express.multipart(config.bodyParser || config.multipart || { limit: 2097152 })); // default to 2mb limit app.use(express.cookieParser(config.session.secret)); app.use(kraken.session(config.session)); app.use(kraken.appsec(config.appsec)); if (typeof delegate.requestBeforeRoute === 'function') { delegate.requestBeforeRoute(app); } enrouten(app).withRoutes({ directory: this._resolve(this._config.get('routes:routePath')) }); if (typeof delegate.requestAfterRoute === 'function') { delegate.requestAfterRoute(app); } errorPages = config.errorPages || {}; app.use(kraken.fileNotFound(errorPages['404'])); app.use(kraken.serverError(errorPages['500'])); app.use(kraken.errorHandler(config.errorHandler)); },
在這裡我們看到了很熟悉的express 的基本配置，它的一些配置都寫在這裡面了。
我們看到這些，這些就是處理我們之前的那些鉤子函式了。看到了吧，都是傳入express 構建的應用程式。
if (typeof delegate.requestStart === 'function') { delegate.requestStart(app); } if (typeof delegate.requestBeforeRoute === 'function') { delegate.requestBeforeRoute(app); } if (typeof delegate.requestAfterRoute === 'function') { delegate.requestAfterRoute(app); }
同時在這裡，有
enrouten(app).withRoutes({ directory: this._resolve(this._config.get('routes:routePath')) });
這個其實是處理路由的，它使呼叫了express-enrouten 模組，進入看看這個函式幹了寫什麼事情，可以看到
module.exports = function (app) { return { withRoutes: function (settings) { settings = settings || {}; if (settings.index) { require(resolve(settings.index))(app); return; } // Directory to scan for routes loaddir(settings.directory).forEach(function (file) { var controller = require(file); if (typeof controller === 'function' && controller.length === 1) { controller(app); } }); (settings.routes || []).forEach(function (def) { assert.ok(def.path, 'path is required'); assert.ok(typeof def.handler === 'function', 'handler is required'); var method = (def.method || 'get').toLowerCase(); app[method](def.path, def.handler); }); } }; };
可以看到，她直接將每一個controller檔案require 進來了。然後直接將他作為了一個建構函式，將app作為一個引數傳進去了。 所以在我們的controller 裡面都是這種方式：
'use strict'; module.exports = function (server) { server.get('/', function (req, res) { var model = { name: 'helloworld' }; res.render('index', model); }); };
這裡的server其實就是app，看到了把，這個就是kraken 的妙處。