express 路由分析

express极简的 web 开发框架。
这里创建是一个最最简单的 Express 应用

var express = require('express');
var app = express();

app.get('/', function(req, res) {
  res.send('hello, express');
});

app.listen(3000);

以上代码的意思是：生成一个 express 实例 app，挂载了一个根路由控制器，然后监听3000 端口并启动程序。运行 node index，打开浏览器访问 localhost:3000 时，页面应显示 hello, express。

路由

// 对网站首页的访问返回 "Hello World!" 字样
app.get('/', function (req, res) {
  res.send('Hello World!');
});

// 网站首页接受 POST 请求
app.post('/', function (req, res) {
  res.send('Got a POST request');
});

以上就是基本的express路由使用

express.Router

但是我们也经常看到这样的路由定义
eg:在 创建名为 birds.js 的文件，内容如下：

var express = require('express');
var router = express.Router();

// 该路由使用的中间件
router.use(function timeLog(req, res, next) {
  console.log('Time: ', Date.now());
  next();
});
// 定义网站主页的路由
router.get('/', function(req, res) {
  res.send('Birds home page');
});
// 定义 about 页面的路由
router.get('/about', function(req, res) {
  res.send('About birds');
});

module.exports = router;

然后index.js为

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

那么这两种方式有什么区别呢？

使用第一种方式的路由，每增加一个路由就会在index.js中进行修改增加。这样如果大型项目会有相当多的路由写在index.js中。这当然是不现实的。这时可以使用 express.Router 实现更优雅的路由解决方案。

那为什么index.js不能这么改呢？

var birds = require('./birds');
...
app.get('/birds', birds);

app.get 和app.use有什么区别的？

结论：
app.use(path,callback)中的callback既可以是router对象又可以是函数
app.get(path,callback)中的callback只能是函数

var express = require('express');
var app = express();

var index = require('./routes/index');

//1⃣️
app.use('/test1',function(req,res,next){
    res.send('hello test1');

});

//2⃣️
app.get('/test2',function(req,res,next){
    res.send('hello test2');

});

//3⃣️
app.get('/test3',index);

//4⃣️
app.use('/test4',index);

index是一个路由对象，结果，例1、2、4结果都能正确显示，而例3却报404。index.js很简单，如下：

var express = require('express');
var router = express.Router();

router.get('/', function(req, res, next) {
  res.send('hello world!');
});

module.exports = router;

app.use和app.get的区别
我打印router实例吗，发现也是个函数。那为什么就3不行了呢？回调的router也是个函数但却不能执行呢？
这时候就需要看源码了
express路由源码解析
express路由源码解析
express源码解析

express 源码分析

我们首先来看app.ues为什么可以是router对象。
我们的index.js为

// eg1
var express = require('express');
var app = express();
app.use('/1', require('./a.js'));
app.listen(1111);
// a.js
var express = require('express');
var router = express.Router();
router.get('/', function(req, res, next) {
    res.send('hello, cexpresss');
});
module.exports = router;

我们根据express的源码来分析index.js的执行。

目录

var express = require('express');这一句话引用的是express.js

exports = module.exports = createApplication;
function createApplication() {
  var app = function(req, res, next) {
    app.handle(req, res, next);
  };
  mixin(app, proto, false); // proto 是application.js
  app.init();
  return app;
}

所以require('express')最后返回一个createApplication函数，var app = express();的值为createApplication函数中的app函数。接着分析你写的代码。app.use()。这个方法就是proto里的方法所以去查看application.js。

app.use = function use(fn) {
 ...判断第一个参数是不是字符串，是的话赋值给path，不是的话path为'/'。fns为fn去除字符串。
  // setup router
  this.lazyrouter(); // 这是重点
  var router = this._router;
  fns.forEach(function (fn) { 
    if (!fn || !fn.handle || !fn.set) {  // 如果fn不是express。我们这里分析的fn都不是express
      return router.use(path, fn);
    }
  }, this);

  return this;
};

上面这段代码我们先执行this.lazyrouter()。预算看看lazyrouter函数是什么

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

上面代码的this为 我们实例化出来的app=express()的app。所以只有第一次调用这个函数时候才会进入if。才会new Router。所以我们的this._router也只有一个。这里的Router为Router下的index.js。

var proto = module.exports = function(options) {
  var opts = options || {};
  function router(req, res, next) {
    router.handle(req, res, next);
  }
  return router;
};

接下来我们返回到app.use里继续执行router.use(path, fn)。我们去Router下的index.js看router.use

//添加非路由中间件
proto.use = function use(fn) {
  /* 此处略去部分代码 */
  callbacks.forEach(function (fn) {
    ////实例化layer对象并进行初始化
    var layer = new Layer(path, {
      sensitive: this.caseSensitive,
      strict: false,
      end: false
    }, fn);
    //非路由中间件，该字段赋值为undefined
    layer.route = undefined;
    this.stack.push(layer);
  }, this);
  return this;
};

上述是Router添加非路由中间件。接下来我们看看Router添加路由中间件(就是我们的app.get(),app,post()之类的)

//添加路由中间件
proto.route = function(path){
  //实例化路由对象
  var route = new Route(path);
  //实例化layer对象并进行初始化
  var layer = new Layer(path, {
    sensitive: this.caseSensitive,
    strict: this.strict,
    end: true
  }, route.dispatch.bind(route));
  layer.route = route; //指向刚实例化的路由对象（非常重要），通过该字段将Router和Route关联来起来
  this.stack.push(layer);
  return route;
};

app.get和app.use主要区别在于layer.route。
接下来我们继续看看这些函数如何执行的。

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

从http.createServer(this)这句代码可以看出，一旦有请求访问3000这个端口，就会调用this,this指的是app , 程序会执行app()调用eg1里的handle 方法，这里就是整个app的函数入口了。层层跟跟踪代码，发现app.handle调用了router.handle(req, res, done);,这时候我们进入router的handle看看里面写了什么。
router的handle代码比较长主要实现的逻辑为
每当有请求到来，都会调用router的handle方法，首先直接遍历router的stack(app.use, app.get之类的都会被添加到stack)，取出每一个layer看是否有一个与请求的path匹配，如果没有匹配，调用done函数结束request请求，如果有匹配的layer查看layer的route不等于undefined，就执行layer的handle_request函数，如果layer的route等于undefined，那么就执行trim_prefix函数。我们先来看看layer的handler_request是什么，代码如下

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

  if (fn.length > 3) {
    // not a standard request handler
    return next();
  }

  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

可以看出这个方法只是单纯的执行layer的handle函数，前面已经讲到当layer的route不等于undefined时，他的handle函数是route.dispach.bind(route),这个函数会去遍历route的stack里面的layer，然后再调用layer的handle_request函数进一步执行回调函数。
trim_prefix只是执行那些没有route的layer的handle函数。
所以现在最主要的区别就是layer的handle函数。
app.use('/' ,require('./a.js'))
这个layer的handle为就是a.js的输出就是module.exports = router; 就是Router下的index.js

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

app.get('/' ,require('./a.js'))
这个前面已经讲到当layer的route不等于undefined时，他的handle函数是route.dispach.bind(route)。执行handle函数时候回发现layer的正则表达式跟当前的url不匹配。layer的正则只匹配app.get('')里的路由，那app.use的正则为什么就可以匹配当前路由呢？

function Layer(path, options, fn) {
  var opts = options || {};
  this.path = undefined;
  this.regexp = pathRegexp(path, this.keys = [], opts);
  this.regexp.fast_star = path === '*'
  this.regexp.fast_slash = path === '/' && opts.end === false
}

主要是由于第二个参数options的不同。

遇到的问题

使用supervisor index.js 启动node。更改文件可以自动刷新。但是不能在控制台开启进程后，关掉控制台，再开启。这样可能没有杀死进程，再次启动的话会报错，就是端口被占用的意思。
处理僵尸进程
ps 查看进行。
kill 进程ID
如果kill 进程ID 不行就 kill -9 进程ID
如果已经知道被占用的端口就lsof -i:“端口”查询进程ID 然后kill掉
以上问题应该supervisor的问题是换成 nodemon 来监听文件更改。
vscode中，debug的时候需要把启动的服务关了，因为debug就会启动服务。不然debug的时候会报错端口已经被占用。