阿西河

所有教程

公众号
🌙
阿西河前端的公众号

我的收藏

    最近访问  (文章)

      教程列表

      抓包专区
      测试专区

      Egg.js 插件开发

      插件机制是我们框架的一大特色。它不但可以保证框架核心的足够精简、稳定、高效,还可以促进业务逻辑的复用,生态圈的形成。有人可能会问了:

      • Koa 已经有了中间件的机制,为啥还要插件呢?
      • 中间件、插件、应用它们之间是什么关系,有什么区别?
      • 我该怎么使用一个插件?
      • 如何编写一个插件?

      使用插件章节我们已经讨论过前几点,接下来我们来看看如何开发一个插件。

      插件开发

      使用脚手架快速开发

      你可以直接使用 egg-boilerplate-plugin 脚手架来快速上手。

      $ mkdir egg-hello && cd egg-hello
      $ npm init egg --type=plugin
      $ npm i
      $ npm test
      

      插件的目录结构

      一个插件其实就是一个『迷你的应用』,下面展示的是一个插件的目录结构,和应用(app)几乎一样。

      . egg-hello
      ├── package.json
      ├── app.js (可选)
      ├── agent.js (可选)
      ├── app
      │   ├── extend (可选)
      │   |   ├── helper.js (可选)
      │   |   ├── request.js (可选)
      │   |   ├── response.js (可选)
      │   |   ├── context.js (可选)
      │   |   ├── application.js (可选)
      │   |   └── agent.js (可选)
      │   ├── service (可选)
      │   └── middleware (可选)
      │       └── mw.js
      ├── config
      |   ├── config.default.js
      │   ├── config.prod.js
      |   ├── config.test.js (可选)
      |   ├── config.local.js (可选)
      |   └── config.unittest.js (可选)
      └── test
          └── middleware
              └── mw.test.js
      

      那区别在哪儿呢?

      1. 插件没有独立的 router 和 controller。这主要出于几点考虑:

        • 路由一般和应用强绑定的,不具备通用性。
        • 一个应用可能依赖很多个插件,如果插件支持路由可能导致路由冲突。
        • 如果确实有统一路由的需求,可以考虑在插件里通过中间件来实现。
      2. 插件需要在 package.json 中的 eggPlugin 节点指定插件特有的信息:

        • {String} name - 插件名(必须配置),具有唯一性,配置依赖关系时会指定依赖插件的 name。
        • {Array} dependencies - 当前插件强依赖的插件列表(如果依赖的插件没找到,应用启动失败)。
        • {Array} optionalDependencies - 当前插件的可选依赖插件列表(如果依赖的插件未开启,只会 warning,不会影响应用启动)。
        • {Array} env - 只有在指定运行环境才能开启,具体有哪些环境可以参考运行环境。此配置是可选的,一般情况下都不需要配置。

          {
          "name": "egg-rpc",
          "eggPlugin": {
            "name": "rpc",
            "dependencies": [ "registry" ],
            "optionalDependencies": [ "vip" ],
            "env": [ "local", "test", "unittest", "prod" ]
          }
          }
          
        1. 插件没有 plugin.js

          • eggPlugin.dependencies 只是用于声明依赖关系,而不是引入插件或开启插件。
          • 如果期望统一管理多个插件的开启和配置,可以在上层框架处理。

      插件的依赖管理

      和中间件不同,插件是自己管理依赖的。应用在加载所有插件前会预先从它们的 package.json 中读取 eggPlugin > dependencieseggPlugin > optionalDependencies 节点,然后根据依赖关系计算出加载顺序,举个例子,下面三个插件的加载顺序就应该是 c => b => a

      // plugin a
      {
        "name": "egg-plugin-a",
        "eggPlugin": {
          "name": "a",
          "dependencies": [ "b" ]
        }
      }
      
      // plugin b
      {
        "name": "egg-plugin-b",
        "eggPlugin": {
          "name": "b",
          "optionalDependencies": [ "c" ]
        }
      }
      
      // plugin c
      {
        "name": "egg-plugin-c",
        "eggPlugin": {
          "name": "c"
        }
      }
      

      注意:dependenciesoptionalDependencies 的取值是另一个插件的 eggPlugin.name,而不是 package name

      dependenciesoptionalDependencies 是从 npm 借鉴来的概念,大多数情况下我们都使用 dependencies,这也是我们最推荐的依赖方式。那什么时候可以用 optionalDependencies 呢?大致就两种:

      • 只在某些环境下才依赖,比如:一个鉴权插件,只在开发环境依赖一个 mock 数据的插件
      • 弱依赖,比如:A 依赖 B,但是如果没有 B,A 有相应的降级方案

      需要特别强调的是:如果采用 optionalDependencies 那么框架不会校验依赖的插件是否开启,它的作用仅仅是计算加载顺序。所以,这时候依赖方需要通过『接口探测』等方式来决定相应的处理逻辑。

      插件能做什么?

      上面给出了插件的定义,那插件到底能做什么?

      扩展内置对象的接口

      在插件相应的文件内对框架内置对象进行扩展,和应用一样

      • app/extend/request.js - 扩展 Koa#Request 类
      • app/extend/response.js - 扩展 Koa#Response 类
      • app/extend/context.js - 扩展 Koa#Context 类
      • app/extend/helper.js - 扩展 Helper 类
      • app/extend/application.js - 扩展 Application 类
      • app/extend/agent.js - 扩展 Agent 类

      插入自定义中间件

      1. 首先在 app/middleware 目录下定义好中间件实现

        'use strict';
        
        const staticCache = require('koa-static-cache');
        const assert = require('assert');
        const mkdirp = require('mkdirp');
        
        module.exports = (options, app) => {
          assert.strictEqual(typeof options.dir, 'string', 'Must set `app.config.static.dir` when static plugin enable');
        
          // ensure directory exists
          mkdirp.sync(options.dir);
        
          app.loggers.coreLogger.info('[egg-static] starting static serve %s -> %s', options.prefix, options.dir);
        
          return staticCache(options);
        };
        
      2. app.js 中将中间件插入到合适的位置(例如:下面将 static 中间件放到 bodyParser 之前)

        const assert = require('assert');
        
        module.exports = app => {
          // 将 static 中间件放到 bodyParser 之前
          const index = app.config.coreMiddleware.indexOf('bodyParser');
          assert(index >= 0, 'bodyParser 中间件必须存在');
        
          app.config.coreMiddleware.splice(index, 0, 'static');
        };
        

      在应用启动时做一些初始化工作

      • 我在启动前想读取一些本地配置

        // ${plugin_root}/app.js
        const fs = require('fs');
        const path = require('path');
        
        module.exports = app => {
          app.customData = fs.readFileSync(path.join(app.config.baseDir, 'data.bin'));
        
          app.coreLogger.info('read data ok');
        };
        
      • 如果有异步启动逻辑,可以使用 app.beforeStart API

        // ${plugin_root}/app.js
        const MyClient = require('my-client');
        
        module.exports = app => {
          app.myClient = new MyClient();
          app.myClient.on('error', err => {
            app.coreLogger.error(err);
          });
          app.beforeStart(async () => {
            await app.myClient.ready();
            app.coreLogger.info('my client is ready');
          });
        };
        
      • 也可以添加 agent 启动逻辑,使用 agent.beforeStart API

        // ${plugin_root}/agent.js
        const MyClient = require('my-client');
        
        module.exports = agent => {
          agent.myClient = new MyClient();
          agent.myClient.on('error', err => {
            agent.coreLogger.error(err);
          });
          agent.beforeStart(async () => {
            await agent.myClient.ready();
            agent.coreLogger.info('my client is ready');
          });
        };
        

      设置定时任务

      1. package.json 里设置依赖 schedule 插件

        {
          "name": "your-plugin",
          "eggPlugin": {
            "name": "your-plugin",
            "dependencies": [ "schedule" ]
          }
        }
        
      2. ${plugin_root}/app/schedule/ 目录下新建文件,编写你的定时任务

        exports.schedule = {
          type: 'worker',
          cron: '0 0 3 * * *',
          // interval: '1h',
          // immediate: true,
        };
        
        exports.task = async ctx => {
          // your logic code
        };
        

      全局实例插件的最佳实践

      许多插件的目的都是将一些已有的服务引入到框架中,如 egg-mysql, egg-oss。他们都需要在 app 上创建对应的实例。而在开发这一类的插件时,我们发现存在一些普遍性的问题:

      • 在一个应用中同时使用同一个服务的不同实例(连接到两个不同的 MySQL 数据库)。
      • 从其他服务获取配置后动态初始化连接(从配置中心获取到 MySQL 服务地址后再建立连接)。

      如果让插件各自实现,可能会出现各种奇怪的配置方式和初始化方式,所以框架提供了 app.addSingleton(name, creator) 方法来统一这一类服务的创建。需要注意的是在使用 app.addSingleton(name, creator) 方法时,配置文件中一定要有 client 或者 clients 为 key 的配置作为传入 creator 函数 的 config

      插件写法

      我们将 egg-mysql 的实现简化之后来看看如何编写此类插件:

      // egg-mysql/app.js
      module.exports = app => {
        // 第一个参数 mysql 指定了挂载到 app 上的字段,我们可以通过 `app.mysql` 访问到 MySQL singleton 实例
        // 第二个参数 createMysql 接受两个参数(config, app),并返回一个 MySQL 的实例
        app.addSingleton('mysql', createMysql);
      }
      
      /**
       * @param  {Object} config   框架处理之后的配置项,如果应用配置了多个 MySQL 实例,会将每一个配置项分别传入并调用多次 createMysql
       * @param  {Application} app 当前的应用
       * @return {Object}          返回创建的 MySQL 实例
       */
      function createMysql(config, app) {
        assert(config.host && config.port && config.user && config.database);
        // 创建实例
        const client = new Mysql(config);
      
        // 做启动应用前的检查
        app.beforeStart(async () => {
          const rows = await client.query('select now() as currentTime;');
          app.coreLogger.info(`[egg-mysql] init instance success, rds currentTime: ${rows[0].currentTime}`);
        });
      
        return client;
      }
      

      初始化方法也支持 Async function,便于有些特殊的插件需要异步化获取一些配置文件:

      async function createMysql(config, app) {
        // 异步获取 mysql 配置
        const mysqlConfig = await app.configManager.getMysqlConfig(config.mysql);
        assert(mysqlConfig.host && mysqlConfig.port && mysqlConfig.user && mysqlConfig.database);
        // 创建实例
        const client = new Mysql(mysqlConfig);
      
        // 做启动应用前的检查
        const rows = await client.query('select now() as currentTime;');
        app.coreLogger.info(`[egg-mysql] init instance success, rds currentTime: ${rows[0].currentTime}`);
      
        return client;
      }
      

      可以看到,插件中我们只需要提供要挂载的字段以及对应服务的初始化方法,所有的配置管理、实例获取方式都由框架封装并统一提供了。

      应用层使用方案

      单实例
      1. 在配置文件中声明 MySQL 的配置。

        // config/config.default.js
        module.exports = {
          mysql: {
            client: {
              host: 'mysql.com',
              port: '3306',
              user: 'test_user',
              password: 'test_password',
              database: 'test',
            },
          },
        };
        
      2. 直接通过 app.mysql 访问数据库。

        // app/controller/post.js
        class PostController extends Controller {
          async list() {
            const posts = await this.app.mysql.query(sql, values);
          },
        }
        
      多实例
      1. 同样需要在配置文件中声明 MySQL 的配置,不过和单实例时不同,配置项中需要有一个 clients 字段,分别申明不同实例的配置,同时可以通过 default 字段来配置多个实例中共享的配置(如 host 和 port)。需要注意的是在这种情况下要用 get 方法指定相应的实例。(例如:使用 app.mysql.get('db1').query(),而不是直接使用 app.mysql.query() 得到一个 undefined)。

        // config/config.default.js
        exports.mysql = {
          clients: {
            // clientId, access the client instance by app.mysql.get('clientId')
            db1: {
              user: 'user1',
              password: 'upassword1',
              database: 'db1',
            },
            db2: {
              user: 'user2',
              password: 'upassword2',
              database: 'db2',
            },
          },
          // default configuration for all databases
          default: {
            host: 'mysql.com',
            port: '3306',
          },
        };
        
      2. 通过 app.mysql.get('db1') 来获取对应的实例并使用。

        // app/controller/post.js
        class PostController extends Controller {
          async list() {
            const posts = await this.app.mysql.get('db1').query(sql, values);
          },
        }
        
      动态创建实例

      我们可以不需要将配置提前申明在配置文件中,而是在应用运行时动态的初始化一个实例。

      // app.js
      module.exports = app => {
        app.beforeStart(async () => {
          // 从配置中心获取 MySQL 的配置 { host, post, password, ... }
          const mysqlConfig = await app.configCenter.fetch('mysql');
          // 动态创建 MySQL 实例
          app.database = await app.mysql.createInstanceAsync(mysqlConfig);
        });
      };
      

      通过 app.database 来使用这个实例。

      // app/controller/post.js
      class PostController extends Controller {
        async list() {
          const posts = await this.app.database.query(sql, values);
        },
      }
      

      注意,在动态创建实例的时候,框架也会读取配置中 default 字段内的配置项作为默认配置。

      插件的寻址规则

      框架在加载插件的时候,遵循下面的寻址规则:

      • 如果配置了 path,直接按照 path 加载。
      • 没有 path 根据 package 名去查找,查找的顺序依次是:

        1. 应用根目录下的 node_modules
        2. 应用依赖框架路径下的 node_modules
        3. 当前路径下的 node_modules (主要是兼容单元测试场景)

      插件规范

      我们非常欢迎您贡献新的插件,同时也希望您遵守下面一些规范:

      • 命名规范
        • npm 包名以 egg- 开头,且为全小写,例如:egg-xx。比较长的词组用中划线:egg-foo-bar
        • 对应的插件名使用小驼峰,小驼峰转换规则以 npm 包名的中划线为准 egg-foo-bar => fooBar
        • 对于可以中划线也可以不用的情况,不做强制约定,例如:userservice(egg-userservice) 还是 user-service(egg-user-service) 都可以
      • package.json 书写规范

        • 按照上面的文档添加 eggPlugin 节点
        • keywords 里加上 eggegg-plugineggPlugin 等关键字,便于索引

          {
          "name": "egg-view-nunjucks",
          "version": "1.0.0",
          "description": "view plugin for egg",
          "eggPlugin": {
          "name": "nunjucks",
          "dep": [
            "security"
          ]
          },
          "keywords": [
          "egg",
          "egg-plugin",
          "eggPlugin",
          "egg-plugin-view",
          "egg-view",
          "nunjucks"
          ],
          }
          

      为何不使用 npm 包名来做插件名?

      Egg 是通过 eggPlugin.name 来定义插件名的,只在应用或框架具备唯一性,也就是说多个 npm 包可能有相同的插件名,为什么这么设计呢?

      首先 Egg 插件不仅仅支持 npm 包,还支持通过目录来找插件。在渐进式开发章节提到如何使用这两个配置来进行代码演进。目录对单元测试也比较友好。所以 Egg 无法通过 npm 的包名来做唯一性。

      更重要的是 Egg 可以使用这种特性来做适配器。比如模板开发规范定义的插件名为 view,而存在 egg-view-nunjucksegg-view-react 等插件,使用者只需要更换插件和修改模板,不需要动 Controller, 因为所有的模板插件都实现了相同的 API。

      将相同功能的插件赋予相同的插件名,具备相同的 API,可以快速切换。这在模板、数据库等领域非常适用。

      卖前端学习教程

      只需几十元,就能买到培训班的内部教程!开启高薪之路!

      零基础小白阿里P7的教程都有!

      同时长期收购所有培训班的前端教程

      目录
      目录