概述nodeJS企业级框架egg

https://eggjs.org/ 官方文档，应付日常开发足够了。本篇还是来分析下egg

回顾express和koa

使用express.js启动一个简单的服务器

const express = require('express')
const app = express()
const router = express.Router()
app.use(async (req, res, next) => {
  console.log('I am the first middleware')
  next()
  console.log('first middleware end calling')
})
app.use((req, res, next) => {
 if (err) {
    console.log('second middleware catch error', err)
    res.status(500).send('server Error')
    return
  }
  console.log('I am the second middleware')
  next()
  console.log('second middleware end calling')
})
router.get('/api/test1', async(req, res, next) => {
  console.log('I am the router middleware => /api/test1')
  res.status(200).send('hello')
})
app.use('/', router)
app.listen(3000)

换算成等价的koa2

const koa = require('koa')
const Router = require('koa-router')
const app = new koa()
const router = Router()
app.use(async(ctx, next) => {
  console.log('I am the first middleware')
  await next()
  console.log('first middleware end calling')
})

app.use(async (ctx, next) => {
  console.log('I am the second middleware')
  await next()
  console.log('second middleware end calling')
})
router.get('/api/test1', async(ctx, next) => {
  console.log('I am the router middleware => /api/test1')
  ctx.body = 'hello'
})
app.use(router.routes())
app.listen(3000)

二者的使用区别通过表格展示如

日常一些简单的开发需求，两个框架都能应付，但是中间，让我头痛

koa简化了，但是还是没有egg理想

//- router.js
module.exports = app => {
  const { router, controller } = app;
  router.get('/', controller.home.index);
};

//- app/controller/home.js
const { Controller } = require('egg');
class HomeController extends Controller {
  async index() {
    this.ctx.body = 'Hello world';
  }
}

module.exports = HomeController;

整体上，简洁干练

egg 简介

egg 是阿里开源的一个强约束的Node框架，为企业级框架和应用而生，相较于 express 和 koa ，有更加严格的目录结构和规范，使得团队可以在基于 egg 定制化自己的需求或者根据 egg 封装出适合自己团队业务的更上层框架

可以看到 egg 处于的是一个中间层的角色，基于 koa ，不同于 koa 以 middleware 为主要生态，egg 根据不同的业务需求和场景，加入了 plugin , extends 等这些功能，可以让开发者摆脱在使用 middleware 功能时无法控制使用顺序的被动状态，而且还可以增加一些请求无关的一些功能。

egg 中内置插件系列:

• onerror 统一异常处理

• Session Session 实现

• i18n 多语言

• watcher 文件和文件夹监控

• multipart 文件流式上传

• security 安全

• development 开发环境配置

• logrotator 日志切分

• schedule 定时任务

• static 静态服务器

• jsonp jsonp 支持

• view 模板引擎

加载插件的逻辑是在 egg-core 里面的 plugin.js 文件

扩展内置对象

在对内置对象进行扩展的时候，实质上执行的是 extend.js 文件，扩展的对象包括如下几个：

• Application

• Context

• Request

• Response

• Helper

通过阅读 extend.js 文件可以知道，其实最后每个对象的扩展都是直接调用的 loadExtends 这个函数。

egg功能加载

• 加载中间件：对中间件的加载主要是执行的 egg-core 中的 middleware.js 文件，里面的代码思想也是和上面加载内置对象是一样的，也是将插件中的中间件和应用中的中间件路径全部获取到，然后进行遍历。

  遍历完成之后执行中间件就和 koa 一样了，调用 co 进行包裹遍历。

• 加载控制器 ：对控制器的加载主要是执行的 egg-core 中的 controller.js 文件

  egg 的官方文档中，插件的开发这一节提到：

  插件没有独立的 router 和 controller

  所以在加载 controller 的时候，主要是 load 应用里面的 controller 即可。

• 加载 service：加载 service 的逻辑是 egg-core 中的 service.js 

• 加载路由 :加载路由的逻辑主要是 egg-core 中的 router.js 文件

• 加载配置：直接加载配置文件并提供可配置的方法。

框架结构概述

• app：核心目录，app目录下又按照设计模式分为了数个更细粒度的子目录。

• controller：存放controller层的处理文件的位置

• extend：存放继承一些自定义公共方法的位置，这个在本节的下面详细说下

• middleware：存放自定义中间件文件，所谓的appMiddleware

• public：存放项目静态资源的位置

• service：Egg框架抽象出来的一个概念，可以认为是带有逻辑处理的model层

• view：存放页面模板文件的位置

• router.js：编写路由的位置

• config：核心目录，配置文件相关，其中config.default.js中存放的是和当前Node环境无关的配置；config.[env].js文件则存放和Node执行环境相关的配置；plugin.js存放的则是各个插件的package名称和是否开启的配置。这里的Node执行环境，后面会说明。

• logs：日志文件输出的目录。

• index.js：项目的入口文件。

egg开发

用比较简单的伪代码表示如下

const app = express();

// nodejs启动时，app函数内部被express增加了能力，如中间件的调用 
app.use(middleware)； // 中间件 
app.use(router)； // 路由 
app.engine('ejs'); // 模板引擎 
app.statifc('public') // 静态文件服务 
// ... 还有代理以及其他许多属性与方法

const server = http.createServer(
      function app(req, res){  // 此app函数即为express所构造
           // http请求时，req， res被混入许多属性与方法，做了很多处理
           // 串行匹配运行按顺序注册的各注册的中间件如：
           // 1、日志、cookie、bodyparser等开发者自己注册的中间件
           // 2、router中间件
           // 3、静态文件服务
           // 4、模板引擎处理
           // 经过匹配的中间件处理后输出返回
      }
);

server.listen(8000);

上面的1、2、3、4顺序即为开发者注册时的顺序（故我们平时在开发时express注册中间件时是有先后顺序的）。express最主管理与运行中间件的能力，接下来深入内部看看connect这个中间件机制是怎么实现的。

最为核心的中间件框架

//connect.js 的简要内容

function createServer(){
    // app是用于http.createServer的回调函数
    function app(req, res, next){
        // 运行时调用handle函数
        app.handle(req, res, next);
    }
    mixin(app, proto, false);
    // 初始化一个stack数组
    app.stack = []; 
    return app;
}
// use调用时往app的stack数组中push一个对象（中间件），标识path与回调函数
proto.use = function(route, fn){
    var path = route, 
    handle = fn;
    //...  省略其他
    this.stack.push({
        route: path,
        handle
    });
};

// handle方法，串行取出stack数组中的中间件，逐个运行
proto.handle = function(req, res, out){
    var index = 0;
    var stack = this.stack;
    var done = out || finalhandler(req, res, { onerror: logerror });

    // 遍历stack，逐个取出中间件运行
    function next(err){
        var layer = stack[index++];
        // 遍历完成为止
        if(layer === undefined){
            return done();
        }

        var route = pathFormat(layer.route);
        var pathname = pathFormat(urlParser(req.url).pathname || '/');

        // 匹配中间件，不匹配的不运行
        if(route !== '' && pathname !== route){
            next(err);
            return;
        }

        // 调用中间件
        call(layer.handle, err, req, res, next);
    }

    next();
};

不难看出，app.use中间件时，只是把它放入一个数组中。当http请求时，app会从数组中逐个取出，进行匹配过滤，逐个运行。遍历完成后，运行finalhandler，结束一个http请求。可以从http请求的角度思考，一次请求它经历经历了多少东西。express的这个中间件架构就是负责管理与调用这些注册的中间件。中间件顺序执行，通过next来继续下一个，一旦没有继续next，则流程结束。

异步串行流程控制

为了用串行化流程控制让几个异步任务按顺序执行，需要先把这些任务按预期的执行顺序放 到一个数组中。如图，所示，这个数组将起到队列的作用:完成一个任务后按顺序从数组中取 出下一个

数组中的每个任务都是一个函数。任务完成后应该调用一个处理器函数，告诉它错误状态和 结果。如果有错误，处理器函数会终止执行;如果没有错误，处理器就从队列中取出下一个任务 执行它

Router是一个内置在app函数上的中间件

来看下简化后的router.js

//express创建时运行
app.init = function(){
    // ... 省略其它代码
    this._router = new Router();
    this.usedRouter = false;
    
    // app调用router时初始化router中间件
    Object.defineProperty(this, 'router', {
        configurable : true,
        enumerable : true,
        get: function () {
            this.usedRouter = true;
            return this._router.middlewareInit.bind(this._router);
        }
    })
};

// methods是一个数组，['get','post','put','delete',...]
methods.forEach(method => {
    app[method] = function (path) {
        // 如果首次调用则放入路由中间价
        if(!this.usedRouter){
            this.use(this.router);
        }

        // 加入stack
        this._router.addRoute(method, path, Array.prototype.slice.call(arguments, 1))
    }
});

usedRouter是个开关，未开启则不加入router中间件，因为应用理论上也是可能不用到router的。当app[method] 如app.get('/user', fn)调用后，则触发this.use(this.router) 使用router中间件，同时把usedRouter设置为true。之后往router对象中加入fn回调函数。

router实际上也是一个异步串行流程控制，简化版的代码如下

Router.prototype.addRoute = function(method, path, handles){
    let layer = {
      path,
      handles
    };
    this.map[method] = this.map[method] || [];
    this.map[method].push(layer);
};

Router.prototype.middlewareInit = function(req, res, out){
    let index = 0;
    let method = req.method.toLowerCase() || 'get';
    let stack = this.map[method];

    function next(err) {
        let layer = stack[index++];
        let hasError = Boolean(err);

        // 如果没有了则结束中间件，走下一个中间件
        if(!layer){
            return hasError ? out(err) : out();
        }

        let route = utils.pathFormat(layer.path);
        let pathname = utils.pathFormat(urlParser(req.url).pathname || '/');

        // 进行过滤
        if(route!== '' && route !== pathname){
            return next(err);
        }

        executeHandles(layer.handles, err, req, res, next);
    }

    next();
};

router跟connect非常类似，上述理解了connect，router就很清晰了。一图以蔽之：

实际上router还有细分，某个router还是可以继续做类似的串行流程控制；与中间件相同，每个router一旦停止了next，流程就结束了。

request经过router可以请求一个数据，或者一个网页；网页的话是怎么返回的呢，接下来看下view的render；

参考内容：

NodeJS express框架核心原理全揭秘 https://zhuanlan.zhihu.com/p/56947560

结合源码解密 egg 运行原理 https://zhuanlan.zhihu.com/p/29102746

深夜放毒——阿里开源的企业级Node框架Egg使用指南 https://cnodejs.org/topic/580a6a7e541dfb7b50f40a60

再也不怕面试官问你express和koa的区别了 https://zhuanlan.zhihu.com/p/87079561

转载本站文章《概述nodeJS企业级框架egg》,
请注明出处：https://www.zhoulujun.cn/html/webfront/ECMAScript/JS-Server/8527.html