node框架express的研究0.前言1. 从入口开始1.1入口1.2 proto1.2.1 app.init方法1.2.2 app.handle方法1.2.3 每一个method的处理1.2.4

function createApplication() {
  var app = function(req, res, next) {
    app.handle(req, res, next);
  };

//var EventEmitter = require('events').EventEmitter;
//var mixin = require('merge-descriptors');
//用了merge-descriptors这个包混合两个对象(包括set、get)，也可用assign
  mixin(app, EventEmitter.prototype, false); 
  mixin(app, proto, false);

  // expose the prototype that will get set on requests
  app.request = Object.create(req, { //在app加上一个属性，它的值是一个对象，继承于req
    app: { configurable: true, enumerable: true, writable: true, value: app }
  })

  // expose the prototype that will get set on responses
  app.response = Object.create(res, {
    app: { configurable: true, enumerable: true, writable: true, value: app }
  })

  app.init(); //初始化
  return app;
}
复制代码

var app = exports = module.exports = {};
app.init = function (){}
app.handle = function (){}
app.use = function (){}
app.route = function (){}
//此外，下面的还有listen,render,all,disable,enable,disabled,set,param,engine等方法
复制代码

app.init = function init() {
  this.cache = {};
  this.engines = {};
  this.settings = {}; //存放配置
  this.defaultConfiguration(); //默认配置
};
复制代码

app.defaultConfiguration = function defaultConfiguration() {
  // 默认设置
  this.enable('x-powered-by');
  this.set('etag', 'weak');
  this.set('env', env);
    // 让app继承父的同名属性
    setPrototypeOf(this.request, parent.request)
    setPrototypeOf(this.response, parent.response)
    setPrototypeOf(this.engines, parent.engines)
    setPrototypeOf(this.settings, parent.settings)
  });

  // setup locals
  this.locals = Object.create(null);

  // top-most app is mounted at /
  this.mountpath = '/';

  // default locals
  this.locals.settings = this.settings;

  // default configuration
  this.set('view', View);
  this.set('views', resolve('views'));
  this.set('jsonp callback name', 'callback');
};
复制代码

app.set = function set(setting, val) {
  if (arguments.length === 1) {
    // 只传一个参数直接返回结果
    return this.settings[setting];
  }

  //对settings设置值
  this.settings[setting] = val;

  // 值的匹配，具体过程略过
  switch (setting) {
    case 'etag':
      break;
    case 'query parser':
      break;
    case 'trust proxy':
      break;
  }
  return this;
};
复制代码

app.handle = function handle(req, res, callback) {
  var router = this._router;
  // 路由匹配成功触发回调
  var done = callback || finalhandler(req, res, {
    env: this.get('env'),
    onerror: logerror.bind(this)
  });
  // 没有路由
  if (!router) {
    done();
    return;
  }
  router.handle(req, res, done);
};
复制代码

//methods是常见的http请求以及其他一些方法名字的字符串数组
methods.forEach(function(method){
//app.get app.post等等我们常用的api
  app[method] = function(path){
    if (method === 'get' && arguments.length === 1) {
      // app.get(setting)
      return this.set(path);
    }

    this.lazyrouter();

    var route = this._router.route(path);
    route[method].apply(route, slice.call(arguments, 1)); //就是常用的route.get('/page',callback)
    return this;
  };
});
复制代码

app.lazyrouter = function lazyrouter() {
  if (!this._router) {
    this._router = new Router({ //新建路由
      caseSensitive: this.enabled('case sensitive routing'),
      strict: this.enabled('strict routing')
    });

    this._router.use(query(this.get('query parser fn')));
    this._router.use(middleware.init(this));
  }
};
复制代码

var proto = module.exports = function(options) {
  var opts = options || {};

  function router(req, res, next) {
    router.handle(req, res, next);
  }

  // router也获得了proto 的方法了
  setPrototypeOf(router, proto)

  router.params = {};
  router._params = [];
  router.caseSensitive = opts.caseSensitive;
  router.mergeParams = opts.mergeParams;
  router.strict = opts.strict;
  router.stack = []; //栈存放中间件

  return router;
};
//接下来是proto的一些方法：proto.param 、proto.handle 、proto.process_params、proto.use、proto.route
//后面是对于methods加上一个all方法，进行和上面methods类似的操作
methods.concat('all').forEach(function(method){
  proto[method] = function(path){ //route.all, route.get, router.post
    var route = this.route(path)
    route[method].apply(route, slice.call(arguments, 1));
    return this;
  };
});
复制代码

proto.route = function route(path) {
  var route = new Route(path);
  var layer = new Layer(path, { //layer是中间件实体
    sensitive: this.caseSensitive,
    strict: this.strict,
    end: true
  }, route.dispatch.bind(route));

  layer.route = route; //注意这里

  this.stack.push(layer); //中间件实体压入Router路由栈
  return route;
};
复制代码

function Layer(path, options, fn) {
  if (!(this instanceof Layer)) {
    return new Layer(path, options, fn);//无new调用
  }

  var opts = options || {};
  this.handle = fn;
  this.name = fn.name || '<anonymous>';
  this.params = undefined;
  this.path = undefined;
  this.regexp = pathRegexp(path, this.keys = [], opts);

  // 路径匹配相关设置
  this.regexp.fast_star = path === '*'
  this.regexp.fast_slash = path === '/' && opts.end === false
}

Layer.prototype.handle_request = function handle(req, res, next) {
  var fn = this.handle;

  if (fn.length > 3) {//参数是req,res,next，长度是3,这时候有next了
    return next();
  }
  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};
复制代码

app.use((req,res,next)=>{
  //做一些事情
  //next() 无next或者res.end，将会一直处于挂起状态
});
app.use(middlewareB);
app.use(middlewareC);
复制代码

proto.use = function use(fn) {
  var offset = 0; //表示从第几个开始
  var path = '/';//默认是/

//如果第一个参数不是函数，app.use('/page',(req,res,next)=>{})
  if (typeof fn !== 'function') {
    var arg = fn;

//考虑到第一个参数是数组
    while (Array.isArray(arg) && arg.length !== 0) { //一直遍历，直到arg不是数组
      arg = arg[0];
    }

    // first arg is the path
    if (typeof arg !== 'function') {
      offset = 1; //如果第一个参数不是函数，从第二个开始
      path = fn; //app.use('/page',(req,res,next)=>{}),第一个参数是路径
    }
  }

  var callbacks = flatten(slice.call(arguments, offset)); //数组扁平化与回调函数集合
  for (var i = 0; i < callbacks.length; i++) {
    var fn = callbacks[i];
    // 增加中间件
    var layer = new Layer(path, {
      sensitive: this.caseSensitive,
      strict: false,
      end: false
    }, fn);

    layer.route = undefined;  //如果是路由中间件就是一个Route对象，否则就是undefined。
//如果是路由中间件，在index.js的proto.route方法里面，给layer实例定义layer.route = route 
    this.stack.push(layer);//压入Router对象的栈中
  }
  return this;
};
复制代码

methods.forEach(function(method){
  Route.prototype[method] = function(){    //app.get('/page',(req,res,next)=>{})就这样子来的
    var handles = flatten(slice.call(arguments));
    for (var i = 0; i < handles.length; i++) {
      var handle = handles[i];
      var layer = Layer('/', {}, handle);
      layer.method = method;

      this.methods[method] = true;
      this.stack.push(layer);
    }


    return this;
  };
});
复制代码

app.set('views', path.join(__dirname, 'views')); //设置视图文件夹
app.set('view engine', 'jade'); //使用什么模板引擎

//在某个请求里面，使用render
res.render('index');  //因为设置了app.set('view engine', 'jade'); ，所以我们不用res.render('index.jade');
复制代码

res.render = function render(view, options, callback) {
  var app = this.req.app;
  var done = callback;
  var opts = options || {};
  var req = this.req;
  var self = this;
  if (typeof options === 'function') {
    done = options;
    opts = {};
  }

  opts._locals = self.locals;
  done = done || function (err, str) { //我们不写callback的时候，如res.render('index',{key:1}); 
    if (err) return req.next(err);
    self.send(str); //把对象转字符串发送
  };
  app.render(view, opts, done);
};
复制代码

app.render = function render(name, options, callback) {
  var cache = this.cache;
  var done = callback;
  var engines = this.engines;
  var opts = options;
  var renderOptions = {};
  var view;
//对renderOptions混合 this.locals、opts._locals、opts
  merge(renderOptions, this.locals);
  if (opts._locals) {
    merge(renderOptions, opts._locals);
  }
  merge(renderOptions, opts);

  if (!view) {//第一次进，如果没有设置视图
    var View = this.get('view');
    view = new View(name, { //引用了view.js的View类
      defaultEngine: this.get('view engine'),
      root: this.get('views'),
      engines: engines
    });

  tryRender(view, renderOptions, done); //渲染函数，内部调用view.render(options, callback);
};
复制代码

function View(name, options) {
  var opts = options || {};
  this.defaultEngine = opts.defaultEngine;
  this.ext = extname(name);
  this.name = name;
  this.root = opts.root;
  var fileName = name;
  if (!this.ext) {
    this.ext = this.defaultEngine[0] !== '.'
      ? '.' + this.defaultEngine
      : this.defaultEngine;
    fileName += this.ext;
  }

  if (!opts.engines[this.ext]) {
    var mod = this.ext.substr(1) //获取后缀 ejs、jade
 // 模板引擎对应express的处理函数，具体内容大概是把模板转为正常的html，这里不研究了
    var fn = require(mod).__express 

    if (typeof fn !== 'function') { //如果模板引擎不支持express就报错
      throw new Error('Module "' + mod + '" does not provide a view engine.')
    }
    opts.engines[this.ext] = fn 
    
    //当然，application.js也有类似的设置，现在是无opts.engines[this.ext]的情况下的设置
    //若app.engine设置过了就不会来到这里了
  }

  this.engine = opts.engines[this.ext];  // 设置模板引擎对应于express的编译函数
  this.path = this.lookup(fileName);// 寻找路径
}
复制代码