koa相关用法

koa框架

现在很多项目都是基于koa框架实现的，主要是因为koa小巧轻便，采用插件式扩展，可以根据需要的功能来选用不同的插件，开发起来更加的方便快捷。所以了解koa的实现原理是十分、十分、十分有必要的。

const Koa = require(‘koa’);
let app = new Koa();//Koa是一个类，通过new生成一个实例

//koa的原型上有use方法，来注册中间件
app.use((ctx,next)=>{
//koa拥有ctx属性，上面挂载了很多属性
console.log(ctx.req.path);
console.log(ctx.request.req.path);
console.log(ctx.request.path);
console.log(ctx.path);
next();//洋葱模型，中间件组合
})

app.listen(3000);//Koa的原型上拥有监听listen
洋葱模型和中间件组合

koa洋葱模型的实现，其实就是通过use将函数存放在一个middlewares队列中，然后通过函数dispatch派发中间件。

dispatch组合中间件：
let app = {
middlewares:[]; //缓存队列
use(fn){ //注册中间件
this.middlewares.push(fn);
}
}
app.use(next=>{
console.log(1)
next();
console.log(2)
});
app.use(next => {
console.log(3)
next();
console.log(4)
})
app.use(next => {
console.log(5)
next();
console.log(6)
})
dispatch(0)
function dispatch(index){ //派发执行中间件
if(index===app.middlewares.length) retrun ;
let middleware = app.middlewares[index];
middleware(()=>{
dispatch(index+1);
})
}
Array.prototype.reduceRight组合中间件：

application：koa的主要逻辑，包含了中间件处理过程
context：koa关于ctx的封装
request：koa请求对象的封装
response：koa响应对象封装

Koa是一个类，拥有middleware、ctx、request、response
Koa.prototype拥有use注册中间件
Koa.prototype拥有listen监听网络请求，其内部是对http模块的封装
Koa中handleRquest处理上下文ctx和中间件middleware

//application.js

const http = require(‘http’);
let context = require(’./context’);
let request = require(’./request’);
let response = require(’./response’);
class Koa {
constructor(){
this.middlewares = [];
// 原型继承，防止引用空间的问题使后加的属性也会加在这个对象上
//this.context和引入的context不是同一个对象
this.context = Object.create(context);
this.request = Object.create(request);
this.response = Object.create(response);
}
use(fn){
this.middlewares.push(fn) ;
}
//挂载封装处理ctx
createContext(req,res){
let ctx = this.context;
ctx.request = this.request;
ctx.response = this.response;
ctx.req=ctx.request.req =req;
ctx.res=ctx.response.res=res;
return ctx;
}
//组合中间件
compose(ctx,middles){
function dispatch(index){
if(index === middle.length) return;
let middle = middles[index];
middle(ctx,()=>dispatch(index+1));
}
dispatch(0);
}
//网络请求监听回调
handleRequest(req,res){
let ctx = createContext(req,res);
this.compose(ctx,this.middlewares);
}
listen(…args){
let server = http.createServer(this.handleRquest);
server.listen(…args)
}
}
module.exports = Koa
request封装

request上扩展url、path等属性

//request.js

let request = {
//类似Object.defineProperty(request,‘url’){get(){}}
get url(){
//this.req => ctx.request.req = req，调用时ctx.request.url
this.req.url;
}
get path(){
let url = require(‘url’);
return url.parse(this.req.url).pathname;
}
}
module.exports = request;
response封装

request上扩展body等属性

//response.js

let response = {
get body(){
return this._body;
}
set body(val){ //设置内置的_body来存储
this._body=val
}
}
module.exports = response;
ctx封装

ctx属性代理了一些ctx.request、ctx.response上的属性，使得ctx.xx能够访问ctx.request.xx或ctx.response.xx

//context.js

let proto = {
};
function defineGetter(property,key){
proto.__defineGetter(key,function(){
return this[property][key];
})
}
function defineSetter(property,key){
proto.__defineSetter(key,function(val){
this[property][key] = val;
})
}
defineGetter(‘request’,‘url’); //ctx代理了ctx.request.url的get
defineGetter(‘request’,‘path’); //ctx代理了ctx.request.path的get
defineGetter(‘response’,‘body’); //ctx代理了ctx.response.body的get
defineSetter(‘response’,‘body’); //ctx代理了ctx.response.body的set
module.exports = proto;
处理异步和错误

上面的功能都是基于同步函数，但是在node中大多数都是异步函数，所以这里面中间件的处理函数需要兼容异步函数。因为async+awit等于generator+co(koa1.0),而co中实现generator自动化是基于Promise实现的，所以这里必须函数promise化。如果不了解Promise、generator、async可以看看另一篇文章promise原理就是这么简单

//application.js

const http = require(‘http’);
let context = require(’./context’);
let request = require(’./request’);
let response = require(’./response’);
let Stream = require(‘stream’);
let EventEmitter = require(‘events’);
class Koa extends EventEmitter { //继承EE，处理错误
constructor(){
this.middlewares = [];
this.context = Object.create(context);
this.request = Object.create(request);
this.response = Object.create(response);
}
use(fn){
this.middlewares.push(fn) ;
}
createContext(req,res){
let ctx = this.context;
ctx.request = this.request;
ctx.response = this.response;
ctx.req=ctx.request.req =req;
ctx.res=ctx.response.res=res;
return ctx;
}
compose(ctx,middles){
function dispatch(index){
//没有注册中间件，返回一个promise
if(index === middle.length) return Promise.resolve();
let middle = middles[index];
// Promise化，next一定为promise
return Promise.resolve(middle(ctx,()=>dispatch(index+1)));
}
return dispatch(0);
}
handleRequest(req,res){
res.statusCode = 404;
let ctx = createContext(req,res);
//所有的中间件执行时候，可以执行内置逻辑，处理错误等
let p = this.compose(ctx,this.middlewares);
p.then(()=>{
//统一处理res.body的不同情况
let body = ctx.body;
if (Buffer.isBuffer(body) || typeof body === ‘string’){
res.setHeader(‘Content-Type’,‘text/plain;charset=utf8’)
res.end(body);
} else if (body instanceof Stream){
body.pipe(res);
}else if(typeof body == ‘object’){
res.setHeader(‘Content-Type’,‘application/json;charset=utf8’)
res.end(JSON.stringify(body));
}else{
res.end(‘Not Found’);
}
}).catch(e=>{ //处理错误
this.emit(‘error’,e);
res.statusCode = 500;
//_http_server可以根据状态码找到对应的类型字段
res.end(require(’_http_server’).STATUS_CODES[res.statusCode]);
})
}
listen(…args){
let server = http.createServer(this.handleRquest);
server.listen(…args)
}
}
module.exports = Koa
结语

koa的原理基本就介绍完了，koa还有一个重要的部分就是中间件，很多功能都是中间件实现的，后面一起学习kao的中间件：

koa框架会用也会写—(koa-router)

转载：https://juejin.im/post/5bab0c415188255c8473b123

猜你喜欢