paypal之nodejs 框架 Kraken-js 源碼分析

時間 2019-11-06

標籤 paypal nodejs 框架 kraken 源碼分析欄目 JavaScript 简体版

原文原文鏈接

本文是基於 kraken-js 0.6.1 版本的node

關於如何使用kraken-js 能夠去看看官網的使用文檔點擊這裏。kraken-js 是基於express之上的，目的在於讓工程師更多的去關注代碼邏輯，少關注自身的開發環境，因此他將express全部的一些公用的配置都寫在了配置文件裏面了。暴露給開發者的不多。下面來看看kraken-js 源碼，分析是如何建立nodejs應用程序的。若是對express 不太理解的，能夠看看我以前博客寫的express框架解密序列。express

按照kraken-js 官網上的步驟，咱們建立了一個新項目，而後生成了代碼是這個樣子的：json

對這個結構說明下：promise

/config ---應用程序和中間件的配置
/controllers ---路由和邏輯
/lib ---用戶開發的第三方庫
/locales ---語言包
/models ---模型
/public ---公共資源
/public/templates ---模板
/tests ---一些測試用例
index.js ---應用程序入口

咱們看看入口文件 index.js 和路由文件controllers/index.jscookie

'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 的巧妙之處。session

具體作法是：app

　　首先建立一個app，給app添加一些方法（configure,requestStart,requestBeforeRoute,requestAfterRoute)，再將app做爲kraken的create方法參數框架

傳進去，kraken.create(app)，而後在調用listen方法（主要是調用http的createServer建立一個服務）。其實這裏的app是一些鉤子，做爲代理的方式給express框架使用，這些方法的參數server 就是express 框架建立的實例。咱們在使用的時候，都是經過express的use方法來調用中間件的。這個後面會有詳細的解釋。ide

既然調用了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 的妙處。