.2-浅析express源码之applicaiton模块(1)-咸鱼方…

app.init = function init() {
    // 在render时缓存对应的view
    this.cache = {};
    // 保存对应ext的解析引擎
    this.engines = {};
    // 本地配置
    this.settings = {};

    this.defaultConfiguration();
};

app.set = function set(setting, val) {
    // 如果只传一个参数相当于get
    if (arguments.length === 1) return this.settings[setting];
    // 打印日志
    debug('set "%s" to %o', setting, val);
    // set value
    this.settings[setting] = val;
    // 特殊键的设置会触发一些方法
    switch (setting) {
        case 'etag':
        this.set('etag fn', compileETag(val));
        break;
        case 'query parser':
        this.set('query parser fn', compileQueryParser(val));
        break;
        case 'trust proxy':
        this.set('trust proxy fn', compileTrust(val));

        // trust proxy inherit back-compat
        Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
            configurable: true,
            value: false
        });
        break;
    }
    return this;
};

var debug = require('debug')('express:application');

app.defaultConfiguration = function defaultConfiguration() {
    // 获取环境变量
    var env = process.env.NODE_ENV || 'development';

    // 相当于this.set(setting, true);
    this.enable('x-powered-by');
    this.set('etag', 'weak');
    this.set('env', env);
    this.set('query parser', 'extended');
    this.set('subdomain offset', 2);
    this.set('trust proxy', false);
    this.set('view', View);
    this.set('views', resolve('views'));
    this.set('jsonp callback name', 'callback');

    this.locals = Object.create(null);
    this.mountpath = '/';
    this.locals.settings = this.settings;

    // 兼容处理
    // var trustProxyDefaultSymbol = '@@symbol:trust_proxy_default';
    Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
        configurable: true,
        value: true
    });

    debug('booting in %s mode', env);
    // 监听mount方法
    this.on('mount', function onmount(parent) {
        // ...
    });

    // 生产模式打开view cache属性
    if (env === 'production') {
        this.enable('view cache');
    }

    // 4.x移除app.router方法
    Object.defineProperty(this, 'router', {
        get: function() {
        throw new Error('\'app.router\' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.');
        }
    });
};

var admin = express();
admin.on('mount', function (parent) {
  console.log('Admin Mounted');
  console.log(parent); // refers to the parent app
});
admin.get('/', function (req, res) {
  res.send('Admin Homepage');
});
app.use('/admin', admin);

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

app.use = function use(fn) {
    // 参数的偏移
    // 如果传了path就是1
    var offset = 0;
    // 默认path
    var path = '/';

    // 参数修正
    if (typeof fn !== 'function') {
        var arg = fn;
        // 当path为数组时
        while (Array.isArray(arg) && arg.length !== 0) {
            arg = arg[0];
        }
        // 直接判断数组中第一个元素是否不为函数
        if (typeof arg !== 'function') {
            offset = 1;
            path = fn;
        }
    }
    // 扁平化参数数组 获取所有的中间件
    // 处理形如app.use(path,[middlewarefn1,middlewarefn2],subApp)的参数组合
    var fns = flatten(slice.call(arguments, offset));

    if (fns.length === 0) {
        throw new TypeError('app.use() requires a middleware function')
    }

    // 懒加载路由
    // 该方法只有第一次调用是有效的 单例模式
    this.lazyrouter();
    var router = this._router;

    fns.forEach(function(fn) {
        // quack quack 哈哈
        // 当该中间件不是express应用时直接调用router.use
        if (!fn || !fn.handle || !fn.set) {
            return router.use(path, fn);
        }
        // 设置子应用的mountpath、parent
        debug('.use app under %s', path);
        fn.mountpath = path;
        fn.parent = this;

        // 这个涉及router模块 暂时不深入
        router.use(path, function mounted_app(req, res, next) {
            var orig = req.app;
            fn.handle(req, res, function(err) {
                setPrototypeOf(req, orig.request)
                setPrototypeOf(res, orig.response)
                next(err);
            });
        });

        // 触发mount事件
        fn.emit('mount', this);
    }, this);

    return this;
};

app.engine = function engine(ext, fn) {
    // 这个应该叫模板解析函数？
    if (typeof fn !== 'function') {
        throw new Error('callback function required');
    }
    // 获取指定文件的扩展名
    var extension = ext[0] !== '.' ?
        '.' + ext :
        ext;
    // 将后缀与对应解析方式保存到engines对象上
    this.engines[extension] = fn;

    return this;
};

methods.forEach(function(method) {
    app[method] = function(path) {
        // app.get传一个参数时指向获取本地参数的app.set方法
        if (method === 'get' && arguments.length === 1) {
            // app.get(setting)
            return this.set(path);
        }
        this.lazyrouter();
        var route = this._router.route(path);
        // 调用route.METHOD(path,callback)
        route[method].apply(route, slice.call(arguments, 1));
        return this;
    };
});

module.exports = getCurrentNodeMethods() || getBasicNodeMethods();

function getCurrentNodeMethods() {
    // http.METHODS => 返回解析器支持的 HTTP 方法的列表
    return http.METHODS && http.METHODS.map(function lowerCaseMethod(method) {
        return method.toLowerCase();
    });
}

// 默认的请求方式集合
function getBasicNodeMethods() {
    return [
        'get', 'post', 'put', 'head', 'delete', 'options', 'trace', 'copy', 'lock', 'mkcol', 'move',
        'purge', 'propfind', 'proppatch', 'unlock', 'report', 'mkactivity', 'checkout', 'merge',
        'm-search', 'notify', 'subscribe', 'unsubscribe', 'patch', 'search', 'connect'
    ];
}

[
    'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK',
    'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS',
    'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH',
    'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'
]

app.all = function all(path) {
    this.lazyrouter();

    var route = this._router.route(path);
    var args = slice.call(arguments, 1);
    // 遍历所有的方法 依次调用route进行处理
    for (var i = 0; i < methods.length; i++) {
        route[methods[i]].apply(route, args);
    }

    return this;
};

app.listen = function listen() {
    var server = http.createServer(this);
    return server.listen.apply(server, arguments);
};