建立Model

直接使用Sequelize虽然可以，但是存在一些问题。

团队开发时，有人喜欢自己加timestamp：

  1. var Pet = sequelize.define('pet', {
  2.     id: {
  3.         type: Sequelize.STRING(50),
  4.         primaryKey: true
  5.     },
  6.     name: Sequelize.STRING(100),
  7.     createdAt: Sequelize.BIGINT,
  8.     updatedAt: Sequelize.BIGINT
  9. }, {
  10.         timestamps: false
  11.     });

有人又喜欢自增主键，并且自定义表名：

  1. var Pet = sequelize.define('pet', {
  2.     id: {
  3.         type: Sequelize.INTEGER,
  4.         autoIncrement: true,
  5.         primaryKey: true
  6.     },
  7.     name: Sequelize.STRING(100)
  8. }, {
  9.         tableName: 't_pet'
  10.     });

一个大型Web App通常都有几十个映射表，一个映射表就是一个Model。如果按照各自喜好，那业务代码就不好写。Model不统一，很多代码也无法复用。

所以我们需要一个统一的模型，强迫所有Model都遵守同一个规范，这样不但实现简单，而且容易统一风格。

Model

我们首先要定义的就是Model存放的文件夹必须在models内，并且以Model名字命名，例如：Pet.js，User.js等等。

其次，每个Model必须遵守一套规范：

  1. 统一主键，名称必须是id，类型必须是STRING(50)；
  2. 主键可以自己指定，也可以由框架自动生成（如果为null或undefined）；
  3. 所有字段默认为NOT NULL，除非显式指定；
  4. 统一timestamp机制，每个Model必须有createdAt、updatedAt和version，分别记录创建时间、修改时间和版本号。其中，createdAt和updatedAt以BIGINT存储时间戳，最大的好处是无需处理时区，排序方便。version每次修改时自增。

所以，我们不要直接使用Sequelize的API，而是通过db.js间接地定义Model。例如，User.js应该定义如下：

  1. const db = require('../db');
  3. module.exports = db.defineModel('users', {
  4.     email: {
  5.         type: db.STRING(100),
  6.         unique: true
  7.     },
  8.     passwd: db.STRING(100),
  9.     name: db.STRING(100),
  10.     gender: db.BOOLEAN
  11. });

这样，User就具有email、passwd、name和gender这4个业务字段。id、createdAt、updatedAt和version应该自动加上，而不是每个Model都去重复定义。

所以，db.js的作用就是统一Model的定义：

  1. const Sequelize = require('sequelize');
  3. console.log('init sequelize...');
  5. var sequelize = new Sequelize('dbname', 'username', 'password', {
  6.     host: 'localhost',
  7.     dialect: 'mysql',
  8.     pool: {
  9.         max: 5,
  10.         min: 0,
  11.         idle: 10000
  12.     }
  13. });
  15. const ID_TYPE = Sequelize.STRING(50);
  17. function defineModel(name, attributes) {
  18.     var attrs = {};
  19.     for (let key in attributes) {
  20.         let value = attributes[key];
  21.         if (typeof value === 'object' && value['type']) {
  22.             value.allowNull = value.allowNull || false;
  23.             attrs[key] = value;
  24.         } else {
  25.             attrs[key] = {
  26.                 type: value,
  27.                 allowNull: false
  28.             };
  29.         }
  30.     }
  31.     attrs.id = {
  32.         type: ID_TYPE,
  33.         primaryKey: true
  34.     };
  35.     attrs.createdAt = {
  36.         type: Sequelize.BIGINT,
  37.         allowNull: false
  38.     };
  39.     attrs.updatedAt = {
  40.         type: Sequelize.BIGINT,
  41.         allowNull: false
  42.     };
  43.     attrs.version = {
  44.         type: Sequelize.BIGINT,
  45.         allowNull: false
  46.     };
  47.     return sequelize.define(name, attrs, {
  48.         tableName: name,
  49.         timestamps: false,
  50.         hooks: {
  51.             beforeValidate: function (obj) {
  52.                 let now = Date.now();
  53.                 if (obj.isNewRecord) {
  54.                     if (!obj.id) {
  55.                         obj.id = generateId();
  56.                     }
  57.                     obj.createdAt = now;
  58.                     obj.updatedAt = now;
  59.                     obj.version = 0;
  60.                 } else {
  61.                     obj.updatedAt = Date.now();
  62.                     obj.version++;
  63.                 }
  64.             }
  65.         }
  66.     });
  67. }

我们定义的defineModel就是为了强制实现上述规则。

Sequelize在创建、修改Entity时会调用我们指定的函数，这些函数通过hooks在定义Model时设定。我们在beforeValidate这个事件中根据是否是isNewRecord设置主键（如果主键为null或undefined）、设置时间戳和版本号。

这么一来，Model定义的时候就可以大大简化。

数据库配置

接下来，我们把简单的config.js拆成3个配置文件：

  • config-default.js：存储默认的配置；
  • config-override.js：存储特定的配置；
  • config-test.js：存储用于测试的配置。

例如，默认的config-default.js可以配置如下：

  1. var config = {
  2.     dialect: 'mysql',
  3.     database: 'nodejs',
  4.     username: 'www',
  5.     password: 'www',
  6.     host: 'localhost',
  7.     port: 3306
  8. };
  10. module.exports = config;

而config-override.js可应用实际配置：

  1. var config = {
  2.     database: 'production',
  3.     username: 'www',
  4.     password: 'secret-password',
  5.     host: '192.168.1.199'
  6. };
  8. module.exports = config;

config-test.js可应用测试环境的配置：

  1. var config = {
  2.     database: 'test'
  3. };
  5. module.exports = config;

读取配置的时候，我们用config.js实现不同环境读取不同的配置文件：

  1. const defaultConfig = './config-default.js';
  2. // 可设定为绝对路径，如 /opt/product/config-override.js
  3. const overrideConfig = './config-override.js';
  4. const testConfig = './config-test.js';
  6. const fs = require('fs');
  8. var config = null;
  10. if (process.env.NODE_ENV === 'test') {
  11.     console.log(`Load ${testConfig}...`);
  12.     config = require(testConfig);
  13. } else {
  14.     console.log(`Load ${defaultConfig}...`);
  15.     config = require(defaultConfig);
  16.     try {
  17.         if (fs.statSync(overrideConfig).isFile()) {
  18.             console.log(`Load ${overrideConfig}...`);
  19.             config = Object.assign(config, require(overrideConfig));
  20.         }
  21.     } catch (err) {
  22.         console.log(`Cannot load ${overrideConfig}.`);
  23.     }
  24. }
  26. module.exports = config;

具体的规则是：

  1. 先读取config-default.js；
  2. 如果不是测试环境，就读取config-override.js，如果文件不存在，就忽略。
  3. 如果是测试环境，就读取config-test.js。

这样做的好处是，开发环境下，团队统一使用默认的配置，并且无需config-override.js。部署到服务器时，由运维团队配置好config-override.js，以覆盖config-override.js的默认设置。测试环境下，本地和CI服务器统一使用config-test.js，测试数据库可以反复清空，不会影响开发。

配置文件表面上写起来很容易，但是，既要保证开发效率，又要避免服务器配置文件泄漏，还要能方便地执行测试，就需要一开始搭建出好的结构，才能提升工程能力。

使用Model

要使用Model，就需要引入对应的Model文件，例如：User.js。一旦Model多了起来，如何引用也是一件麻烦事。

自动化永远比手工做效率高，而且更可靠。我们写一个model.js，自动扫描并导入所有Model：

  1. const fs = require('fs');
  2. const db = require('./db');
  4. let files = fs.readdirSync(__dirname + '/models');
  6. let js_files = files.filter((f)=>{
  7.     return f.endsWith('.js');
  8. }, files);
  10. module.exports = {};
  12. for (let f of js_files) {
  13.     console.log(`import model from file ${f}...`);
  14.     let name = f.substring(0, f.length - 3);
  15.     module.exports[name] = require(__dirname + '/models/' + f);
  16. }
  18. module.exports.sync = () => {
  19.     db.sync();
  20. };

这样，需要用的时候，写起来就像这样：

  1. const model = require('./model');
  3. let
  4.     Pet = model.Pet,
  5.     User = model.User;
  7. var pet = await Pet.create({ ... });

工程结构

最终，我们创建的工程model-sequelize结构如下：

  1. model-sequelize/
  2. |
  3. +- .vscode/
  4. |  |
  5. |  +- launch.json <-- VSCode 配置文件
  6. |
  7. +- models/ <-- 存放所有Model
  8. |  |
  9. |  +- Pet.js <-- Pet
  10. |  |
  11. |  +- User.js <-- User
  12. |
  13. +- config.js <-- 配置文件入口
  14. |
  15. +- config-default.js <-- 默认配置文件
  16. |
  17. +- config-test.js <-- 测试配置文件
  18. |
  19. +- db.js <-- 如何定义Model
  20. |
  21. +- model.js <-- 如何导入Model
  22. |
  23. +- init-db.js <-- 初始化数据库
  24. |
  25. +- app.js <-- 业务代码
  26. |
  27. +- package.json <-- 项目描述文件
  28. |
  29. +- node_modules/ <-- npm安装的所有依赖包

注意到我们其实不需要创建表的SQL，因为Sequelize提供了一个sync()方法，可以自动创建数据库。这个功能在开发和生产环境中没有什么用，但是在测试环境中非常有用。测试时，我们可以用sync()方法自动创建出表结构，而不是自己维护SQL脚本。这样，可以随时修改Model的定义，并立刻运行测试。开发环境下，首次使用sync()也可以自动创建出表结构，避免了手动运行SQL的问题。

init-db.js的代码非常简单：

  1. const model = require('./model.js');
  2. model.sync();
  4. console.log('init db ok.');
  5. process.exit(0);

它最大的好处是避免了手动维护一个SQL脚本。

参考源码

model-sequelize

读后有收获可以支付宝请作者喝咖啡，读后有疑问请加微信群讨论：

建立Model - 图1 建立Model - 图2