koa源码分析

最近项目要使用koa,所以提前学习一下,顺便看了koa框架的源码.

注:源码是koa2.x

koa的源码很简洁,关键代码只有4个文件,当然还包括一些依赖npm包

const Koa = require(‘koa‘);                                                        

const app = new Koa();                                                             

app.use(async (ctx, next) => {
  await next();
  ctx.type = ‘text/html‘;
  ctx.body = ‘<h1>Hello, koa2!</h2>‘;
});                                                                              

app.listen(3000);
console.log(‘app started at port 3000....‘);

我们由上面的代码开始深入到koa的源码:

application.js文件:

上面代码的开头引入koa框架,接着const app = new Koa();创建koa实例app,koa的构造函数很简单,如下:

  constructor() {
    super();                                                                        

    this.proxy = false;
    this.middleware = [];      //用来存放中间件
    this.subdomainOffset = 2;
    this.env = process.env.NODE_ENV || ‘development‘;   //运行环境
    this.context = Object.create(context);           //创建context对象
    this.request = Object.create(request);           //创建request对象
    this.response = Object.create(response);         //创建response对象
  }
use函数:
use(fn) {
    if (typeof fn !== ‘function‘) throw new TypeError(‘middleware must be a function!‘);
    if (isGeneratorFunction(fn)) {
      deprecate(‘Support for generators will be removed in v3. ‘ +
                ‘See the documentation for examples of how to convert old middleware ‘ +
                ‘https://github.com/koajs/koa/blob/master/docs/migration.md‘);
      fn = convert(fn);
    }
    debug(‘use %s‘, fn._name || fn.name || ‘-‘);
    this.middleware.push(fn);
    return this;
  } 

use函数首先判断参数是否是函数,不是就报错,然后判断这个函数是否是generator函数,如果是generator则需要转换一下,通过两个判断后,将这个函数push到middleware数组中保存.最后返回this(也是app实例)

listen函数:
isten() {
    debug(‘listen‘);
    const server = http.createServer(this.callback());
    return server.listen.apply(server, arguments);
  }

listen函数里面调用http.createServe()创建http服务,关键是参数this.callback(),看一下代码:

callback() {
    const fn = compose(this.middleware);                                         

    if (!this.listeners(‘error‘).length) this.on(‘error‘, this.onerror);         

    const handleRequest = (req, res) => {
      res.statusCode = 404;
      const ctx = this.createContext(req, res);
      const onerror = err => ctx.onerror(err);
      const handleResponse = () => respond(ctx);
      onFinished(res, onerror);
      return fn(ctx).then(handleResponse).catch(onerror);
    };                                                                           

    return handleRequest;
  }

首先,把所有middleware进行了组合,使用了koa-compose,我们也不用去管他的内部实现,简单来说就是返回了一个promise数组的递归调用。

这里的 const fn = compose(this.middleware);对应的调用代码如下:(查看koa-compose源码):

 return function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      if (i <= index) return Promise.reject(new Error(‘next() called multiple times‘))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, function next () {
          return dispatch(i + 1)
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}

return前面的作用是做参数检测,return后面也就是上面贴出来的代码才是我们要关注的:

运行流程:

i = 0 ==> index = 0 ==> fn = middleware[0] ==> return Promise.resolve(//如果fn里面存在await,则functions next()函数会被掉用, 则运行return dispatch(i + 1),以此类推)
知道中间件(当然一般指最后一个中间件)中不存在await或者所有的中间件都加载完毕(i === middleware.length) ,compose函数则最终返回.

例如:

const Koa = require(‘koa‘)
const app = new Koa()
app.use(async function (ctx, next) {
  		console.log(‘>> one‘);
  		await next();
 		 console.log(‘<< one‘);
});
app.use(ctx => {
 		ctx.body=‘hello world gcy‘;
})

上面代码注册了两个中间件,经过const fn = compose(this.middleware)后返回:

fn的形式如下:

Promise.resolve(function(ctx) {
console.log(‘>> one‘);
return Promose.resolve(function(ctx){
ctx.body=‘hello world gcy‘;
}).then(() => {
 console.log(‘<< one‘);
})
})

执行结果: 后台输出:>> one  -- > 页面输出:hello world gcy --> 后台输出:<< one

接下来:

 if (!this.listeners(‘error‘).length) this.on(‘error‘, this.onerror);

在处理http请求之前,koa会注册一个默认的错误处理函数,但我们每次http请求错误实际上是由ctx.onerror处理的:

const onerror = err => ctx.onerror(err);
onFinished(res, onerror);
fn(ctx).then(() => respond(ctx)).catch(onerror)

ctx.onFinished 是确保一个流在关闭、完成和报错时都会执行相应的回调函数。onerror 就是我们http请求错误处理函数.
我们看看这个匿名函数,把http code默认设置为404,接着利用createContext函数把node返回的req和res进行了组合创建出context
来看下createContext函数:

createContext(req, res) {
  const context = Object.create(this.context);
  const request = context.request = Object.create(this.request);
  const response = context.response = Object.create(this.response);
  context.app = request.app = response.app = this;
  context.req = request.req = response.req = req;
  context.res = request.res = response.res = res;
  request.ctx = response.ctx = context;
  request.response = response;
  response.request = request;
  context.originalUrl = request.originalUrl = req.url;
  context.cookies = new Cookies(req, res, {
    keys: this.keys,
    secure: request.secure
  });
  request.ip = request.ips[0] || req.socket.remoteAddress || ‘‘;
  context.accept = request.accept = accepts(req);
  context.state = {};
  return context;
}

这里面都是一堆的组合和赋值,context,request, response相互挂载
值得注意的是:context.req/context.res 和context.request/context.response的区别,context.req/context.res代表nodejs的req和res对象,而context.request/context.response是koa的request和response对象
这个函数最后返回context,然后传入fn函数,此时fn函数被执行.
callback()函数中调用的respond函数里面不过是一些收尾工作,例如判断http code为空如何输出啦,http method是head如何输出啦,body返回是流或json时如何输出。

context.js
delegate(proto, ‘request‘) //Request相关方法委托,从而让context作为调用入口
onerror(err) //中间件执行过程中异常处理逻辑

request.js,response.js

分别对res和req进行了抽象和封装

时间: 2024-10-14 07:34:05

koa源码分析的相关文章

koa2中间件koa和koa-compose源码分析原理(一)

koa是基于nodejs平台的下一代web开发框架,它是使用generator和promise,koa的中间件是一系列generator函数的对象.当对象被请求过来的时候,会依次经过各个中间件进行处理,当有yield next就跳到下一个中间件,当中间件没有 yield next执行的时候,然后就会逆序执行前面那些中间件剩下的逻辑代码,比如看如下的demo: const Koa = require('koa'); const app = new Koa(); app.use(async (ctx

十分钟带你看完 KOA 源码

前段时间看了 koa 源码,得益于 koa 良好抽象,不仅提供了简洁的 api ,同时也使得源码相当的简洁和优雅.今天花点时间画了一张 koa 源码的结构图来分析其源码,在总结的同时,希望能够帮到相关的同学. 注:源码是基于 2.x 版本,源码结构与 1.x 完全一致,代码更加简洁直观一点. 基础知识 任何用过 node 的人对下面的代码都不会陌生,如下: const http = require('http'); const server = http.createServer((req, r

TeamTalk源码分析之login_server

login_server是TeamTalk的登录服务器,负责分配一个负载较小的MsgServer给客户端使用,按照新版TeamTalk完整部署教程来配置的话,login_server的服务端口就是8080,客户端登录服务器地址配置如下(这里是win版本客户端): 1.login_server启动流程 login_server的启动是从login_server.cpp中的main函数开始的,login_server.cpp所在工程路径为server\src\login_server.下表是logi

Android触摸屏事件派发机制详解与源码分析二(ViewGroup篇)

1 背景 还记得前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>中关于透过源码继续进阶实例验证模块中存在的点击Button却触发了LinearLayout的事件疑惑吗?当时说了,在那一篇咱们只讨论View的触摸事件派发机制,这个疑惑留在了这一篇解释,也就是ViewGroup的事件派发机制. PS:阅读本篇前建议先查看前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>,这一篇承接上一篇. 关于View与ViewGroup的区别在前一篇的A

HashMap与TreeMap源码分析

1. 引言     在红黑树--算法导论(15)中学习了红黑树的原理.本来打算自己来试着实现一下,然而在看了JDK(1.8.0)TreeMap的源码后恍然发现原来它就是利用红黑树实现的(很惭愧学了Java这么久,也写过一些小项目,也使用过TreeMap无数次,但到现在才明白它的实现原理).因此本着"不要重复造轮子"的思想,就用这篇博客来记录分析TreeMap源码的过程,也顺便瞅一瞅HashMap. 2. 继承结构 (1) 继承结构 下面是HashMap与TreeMap的继承结构: pu

Linux内核源码分析--内核启动之(5)Image内核启动(rest_init函数)(Linux-3.0 ARMv7)【转】

原文地址:Linux内核源码分析--内核启动之(5)Image内核启动(rest_init函数)(Linux-3.0 ARMv7) 作者:tekkamanninja 转自:http://blog.chinaunix.net/uid-25909619-id-4938395.html 前面粗略分析start_kernel函数,此函数中基本上是对内存管理和各子系统的数据结构初始化.在内核初始化函数start_kernel执行到最后,就是调用rest_init函数,这个函数的主要使命就是创建并启动内核线

Spark的Master和Worker集群启动的源码分析

基于spark1.3.1的源码进行分析 spark master启动源码分析 1.在start-master.sh调用master的main方法,main方法调用 def main(argStrings: Array[String]) { SignalLogger.register(log) val conf = new SparkConf val args = new MasterArguments(argStrings, conf) val (actorSystem, _, _, _) =

Solr4.8.0源码分析(22)之 SolrCloud的Recovery策略(三)

Solr4.8.0源码分析(22)之 SolrCloud的Recovery策略(三) 本文是SolrCloud的Recovery策略系列的第三篇文章,前面两篇主要介绍了Recovery的总体流程,以及PeerSync策略.本文以及后续的文章将重点介绍Replication策略.Replication策略不但可以在SolrCloud中起到leader到replica的数据同步,也可以在用多个单独的Solr来实现主从同步.本文先介绍在SolrCloud的leader到replica的数据同步,下一篇

zg手册 之 python2.7.7源码分析(4)-- pyc字节码文件

什么是字节码 python解释器在执行python脚本文件时,对文件中的python源代码进行编译,编译的结果就是byte code(字节码) python虚拟机执行编译好的字节码,完成程序的运行 python会为导入的模块创建字节码文件 字节码文件的创建过程 当a.py依赖b.py时,如在a.py中import b python先检查是否有b.pyc文件(字节码文件),如果有,并且修改时间比b.py晚,就直接调用b.pyc 否则编译b.py生成b.pyc,然后加载新生成的字节码文件 字节码对象