Koa + Sequelize

時間  2019-11-05
標籤 koa sequelize 简体版
原文   原文鏈接

Sequelize你會用麼？node

Mysql 與 Sequelize 的關係

開始以前，咱們先要對 ORM 有個大體的瞭解!何爲 ORMmysql

ORM（Object Relational Mapping），稱爲對象關係映射，用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換。 對象關係映射（Object Relational Mapping，簡稱ORM，或O/RM，或O/R mapping），是一種程序設計技術，用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換。 Sequelize 呢！是一個基於 Promise 的 NodeJs ORM 庫，目前支持 ostgres, MySQL, SQLite 和 Microsoft SQL Server 等數據庫程序。Sequelize 至關一箇中間人負責二者，誰呢？js 和 mysql 之間的交流。 讓咱們看一下Sequelize中各部分於Mysql概念上的對應關係正則表達式

  • 實例化 Sequelize 鏈接到 Database： 經過實例化 Sequelize 類，鏈接到數據庫程序指定的數據庫。
  • 定義 Model 映射 Table： 經過模型映射數據表的定義並代理操做方法
  • 指定 DataTypes 聲明 Data Types： 把數據庫的數據類型變成在 js 上下文中更合適的用法。
  • 使用 Op 生成 Where 子句 Operators： 爲選項對象提供強大的解耦和安全檢測。
  • 關聯 Association 替代複雜的 Foreign Key 和 多表查詢： 用一套簡單的方法管理複雜的多表查詢。
  • 調用 Transcation 封裝 Transation ： 對事務一層簡單而必要的封裝。

從一個小項目開始

開始以前，千萬別忘了先把 Sequelize 以及依賴包安裝到本地sql

npm i sequelize mysql2 -D

複製代碼

第一步，鏈接到數據庫

Sequelize 是庫的入口類，可作兩件事情：數據庫

  1. 鏈接到數據庫
  2. 設置數據表的全局配置。 因此暫且可把 Sequelize 的實例 看作 Mysql 中的 Database（數據庫）
// app/config/databse.config.js
export default {
  // 打開哪一個數據庫
  database: 'test',
  // 用戶名
  username: 'root',
  // 密碼
  password: '1234',
  // 使用哪一個數據庫程序
  dialect: 'mysql',
  // 地址
  host: 'localhost',
  // 端口
  port: 3306,
  // 鏈接池
  pool: {
    max: 5,
    min: 0,
    acquire: 30000,
    idle: 10000
  },
  // 數據表相關的全局配置
  define: {
    // 是否凍結表名
    // 默認狀況下，表名會轉換爲複數形式
    freezeTableName: true,
    // 是否爲表添加 createdAt 和 updatedAt 字段
    // createdAt 記錄表的建立時間
    // updatedAt 記錄字段更新時間
    timestamps: true,
    // 是否爲表添加 deletedAt 字段
    // 默認狀況下, destroy() 方法會刪除數據，
    // 設置 paranoid 爲 true 時，將會更新 deletedAt 字段，並不會真實刪除數據。
    paranoid: false
  }
}
複製代碼

導入配置文件，並實例化 Sequelize。npm

// app/models/test/index.js
import Sequelize from 'sequelize'
import config from '../../config/database.config'
// 實例化，並指定配置
export const sequelize = new Sequelize(config)
// 測試鏈接
sequelize
  .authenticate()
  .then(() => {
    console.log('Connection has been established successfully.')
  })
  .catch(err => {
    console.error('Unable to connect to the database:', err)
  })
複製代碼

劃重點：models 目錄用於存放 Sequelize 庫相關文件，下層目錄對應 Sequelize 打開 Mysql 中的 Database，每一個下層目錄中的 index.js 主文件用於整合 Model，而其餘 .js 文件對應當前 Database 中的一張 Table。編程

第二步，創建模型

Model 是由 sequelize.define()（sequelize 就是上小節中的實例） 方法定義用於映射數據模型和數據表之間的關係的對象模型,其實就是 Mysql 中的一張數據表 新建一個文件 User.js 存放用戶表的模型定義，以下：api

// /models/test/User.js
export default (sequelize, DataTypes) =>
  // define() 方法接受三個參數
  // 表名，表字段的定義和表的配置信息
  sequelize.define('user', {
    id: {
      // Sequelize 庫由 DataTypes 對象爲字段定義類型
      type: DataTypes.INTEGER(11),
      // 容許爲空
      allowNull: false,
      // 主鍵
      primaryKey: true,
      // 自增
      autoIncrement: true,
    },
    username: {
      type: DataTypes.STRING,
      allowNull: false,
      // 惟一
      unique: true
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false
    },
  })
複製代碼

而後，導入並同步到 Mysql 中。數組

// /test/index.js
import Sequelize from 'sequelize'
import config from '../../config/database.config'
export const sequelize = new Sequelize(config)
// 導入
export const User = sequelize.import(__dirname + '/User')
// 同步到 Mysql 中
// 也就是將咱們用 js 對象聲明的模型經過 sequelize 轉換成 mysql 中真正的一張數據表
sequelize.sync()
// ...
複製代碼

劃重點：推薦將全部的模型定義在 單文件 中以實現模塊化，並經過 sequelize.import() 方法把模塊導入到 index.js 中統一管理。 Sequelize 庫會爲咱們執行如下 Mysql 原生命令在 test 中建立一張名爲 user 的數據表。安全

CREATE TABLE IF NOT EXISTS `user` (`id` INTEGER(11) NOT NULL auto_increment UNIQUE , `username` VARCHAR(255) NOT NULL UNIQUE, `password` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
複製代碼

sequelize.sync() 將模型同步到數據庫的三種方法和區別？

// 標準同步
// 只有當數據庫中不存在與模型同名的數據表時，纔會同步
sequelize.sync()
// 動態同步
// 修改同名數據表結構，以適用模型。
sequelize.sync({alter: true})
// 強制同步
// 刪除同名數據表後同步，謹慎使用，會致使數據丟失
sequelize.sync({force: true})
// 另外，當你指定表與表之間的關聯後，修改被關聯的表結構時會拋出異常。
// 須要先註釋掉關聯代碼，而後更新同步模型後，再取消掉註釋便可。
// 再另外，當你有新的關聯時必須使用動態同步纔會生效。

複製代碼

同步成功後，咱們把 sequelize.synce 註釋掉。由於，咱們再次重啓應用後不須要再從新同步。

// sequelize.sync()
複製代碼

而後，在 controllers 中建立同名 User.js 文件，存放用戶相關的接口邏輯（註冊，登陸，登出，查詢和刪除等）

// /controllers/User.js
import { User } from '../models/test/'

export default class {
  static async register (ctx) {
    const post = ctx.request.body
    let result
    try {
      // 調用模型的 create()  方法插入一行數據
      result = await User.create(post)
    } catch (error) {
      return ctx.body = {success: false, error}
    }
    ctx.body = {success: true, data: result}
  }
  // ...
}
複製代碼

這裏你可能會有個疑問，就是控制器（controllers）中的邏輯分類應該是對應模型（model）仍是路由（router）？其實這個問題很好回答，controllers 本來就是爲了更好的管理 router 而分離出來的，而 router 的接口路徑也應該剛好可以自我解釋控制器邏輯的做用，因此控制器中的邏輯分類應該按照路由區別。 最後，掛載至路由。

// /router.js
import Router from 'koa-router'
const router = new Router
router.prefix('/api/v1')
import User from './controllers/User'
router
  .post('/register', User.register)
  // ...
export default router
複製代碼

打開 postman（或者其餘接口調試工具）發起請求。請求成功後查看 Mysql。看是否有新的內容插入

User.create() 方法返回的是一個由 Sequelize 庫定義的結果集類（模型上大部分直接操做數據庫的方法都返回這一結果集類）。

result = await User.create(post)
// 可直接獲取結果集中的字段值
result.username
// 或者使用結果集對象提供的方法
result.getDataValue('username')
// 或者將結果集解析爲一個 JSON 對象
result.toJSON()
// 踩坑必備
// 直接在結果集類上添加自定義數據是無效的
result.newAttr = 'newValue'
// 調用 setDataValue 方法或者調用 toJSON() 將它轉換爲一個對象
result.setDataValue('newAttr', 'newValue')
複製代碼

模型方法

除了用戶模型外，咱們還需定義文章模型（article）、文章的點贊模型（article_like）、文章的收藏模型（article_star）和文章的評論模型（article_comment）。 這裏列出了模型上一些操做數據庫經常使用的方法。 [官方文檔][12]

findOne()
findAll()
findById()
findOrCreate()
findOrBuild()
findAndCountAll()
create()
bulkCreate()
update()
upsert()
destroy()
increment()
decrement()
count()
max()
min()
sun()
複製代碼

數據類型

DataTypes 對象爲模型的字段指定數據類型。 如下列出了部分 DataTypes 類型 對應的 Mysql 數據類型。

// 字符串
STRING(N=255)               // varchar(0~65535)
CHAR(N=255)                 // char(0~255)
TEXT(S=tiny/medium/long)    // s + text
// 數字
// 整數
TINYINT(N?)         // tinyint(1-byte)
SMALLINT(N?)        // smallint(2-byte)
MEDIUMINT(N?)       // mediumint(3-byte)
INTEGER(N=255?)     // integer(6-byte)
BIGINT(N?)          // bigint(8-byte)
// 浮點數
FLOAT(n, n)         // float(4-byte)
DOUBLE(n, n)        // double(8-byte)
// 布爾值
BOOLEAN             // tinyint(1)
// 日期
DATE(n?)            // datetime(8-byte)
TIME                // timestamp(4-byte)
NOW                 // 默認值爲 current timestamp
// 其餘
ENUM( any，...)      // ENUM('value1', ...) length > 65535 
JSON                 // JSON
複製代碼

integer，bigint，float 和 double 都支持 unsigned 和 zerofill 屬性

Sequelize.INTEGER(11).UNSIGNED.ZEROFILL
複製代碼

驗證器

Model 爲每一個字段都提供了驗證選項。

export default (sequelize, DataTypes) =>
  sequelize.define('user', {
    // ...
    email: {
      type: DataTypes.STRING(255),
      allowNull: true,
      validate: {
        isEmail: true
      }
    }
  })
複製代碼

另外，可指定 args 和 msg 自定義參數和錯誤消息。

isEmail: {
    args: true, // 可省略，默認爲 true
    msg: "郵箱格式不合法！"
}
複製代碼

只有當建立（好比，調用 create() 方法）或更新（好比，調用 update() 方法）模型數據時，纔會觸發驗證器，另外當設置 allowNull: true，且字段值爲 null 時，也不會觸發驗證器。僅當驗證器驗證經過時纔會真實將操做同步到數據庫中。當驗證未經過時，會拋出一個 SequelizeValidationError 異常對象（這也是爲何，須要在數據庫操做的地方用 try catch 語句捕獲錯誤，防止 nodeJs 進程退出）。

validate: {
    is: ["^[a-z]+$",'i'],     // 只容許字母
    is: /^[a-z]+$/i,          // 與上一個示例相同,使用了真正的正則表達式
    not: ["[a-z]",'i'],       // 不容許字母
    isEmail: true,            // 檢查郵件格式 (foo@bar.com)
    isUrl: true,              // 檢查鏈接格式 (http://foo.com)
    isIP: true,               // 檢查 IPv4 (129.89.23.1) 或 IPv6 格式
    isIPv4: true,             // 檢查 IPv4 (129.89.23.1) 格式
    isIPv6: true,             // 檢查 IPv6 格式
    isAlpha: true,            // 只容許字母
    isAlphanumeric: true,     // 只容許使用字母數字
    isNumeric: true,          // 只容許數字
    isInt: true,              // 檢查是否爲有效整數
    isFloat: true,            // 檢查是否爲有效浮點數
    isDecimal: true,          // 檢查是否爲任意數字
    isLowercase: true,        // 檢查是否爲小寫
    isUppercase: true,        // 檢查是否爲大寫
    notNull: true,            // 不容許爲空
    isNull: true,             // 只容許爲空
    notEmpty: true,           // 不容許空字符串
    equals: 'specific value', // 只容許一個特定值
    contains: 'foo',          // 檢查是否包含特定的子字符串
    notIn: [['foo', 'bar']],  // 檢查是否值不是其中之一
    isIn: [['foo', 'bar']],   // 檢查是否值是其中之一
    notContains: 'bar',       // 不容許包含特定的子字符串
    len: [2,10],              // 只容許長度在2到10之間的值
    isUUID: 4,                // 只容許uuids
    isDate: true,             // 只容許日期字符串
    isAfter: "2011-11-05",    // 只容許在特定日期以後的日期字符串
    isBefore: "2011-11-05",   // 只容許在特定日期以前的日期字符串
    max: 23,                  // 只容許值 <= 23
    min: 23,                  // 只容許值 >= 23
    isCreditCard: true,       // 檢查有效的信用卡號碼
}
複製代碼

Getters & Setters

Getters 和 Setters 可讓你在獲取和設置模型數據時作一些處理。

export default (sequelize, DataTypes) =>
  sequelize.define('user', {
    // ...
    sex: {
      type: DataTypes.BOLLEAN,
      allowNull: true,
      get () {
        const sex = this.getDataValue('sex')
        return sex ? '男' : '女'
      },
      set (val) {
        this.setDataValue('title', val === '男')
      }
    }
  })
複製代碼

第三步，關聯

// models/test/index.js
// 導入
export const User = sequelize.import(__dirname + '/User')
export const Article = sequelize.import(__dirname + '/Article')
export const ArticleLike = sequelize.import(__dirname + '/Article_like')
export const ArticleStar = sequelize.import(__dirname + '/Article_star')
export const ArticleComment = sequelize.import(__dirname + '/Article_comment')
複製代碼

關聯知識點簡要一覽

// models/test/index.js
// 在 source 上存在一對一關係的外鍵關聯
source.belongsTo(target， {
    as: 'role'  // 使用別名（可代替目標模型）,
    foreignKey: 'user_id'   // 外鍵名,
    targetKey:  'id'        // 目標健，默認主鍵
})
// 在 target 上存在一對一關係的外鍵關聯
source.hasOne(target)
// 在 target 上存在一對多 source 的外鍵關聯
source.hasMany(target)
// 在 target 上存在多對多的外鍵關係（必須經過另一張數據表保存關聯數據）
source.belongsToMany(target, {through: 'UserProject'})
target.belongsToMany(source, {through: 'UserProject'})
複製代碼

接下來，咱們來創建表與表之間的關聯。顯而易見，User 和 Article 之間存在一對多的關係，每一個用戶可先制定個小目標，先發它一億篇文章（User 到 Article 爲一對多，即用 hasMany 方法），反過來，一篇文章僅屬於某個用戶的私有財產（Article 到 User 爲一對一，即用 belongsTo 方法）。

// models/test/index.js
// 外鍵 uid 將會放到 Article 上
User.hasMany(Article, {foreignKey: 'uid'})
// 一樣，仍是把外鍵放到 Article 上
Article.belongsTo(User, {foreignKey: 'uid'})
複製代碼

同步後，查看數據表 Article 時,多出了一個字段， 正是uid，這個就是外鍵。

那麼，問題就來了，爲何須要創建表與表之間的關聯？它有何用？由於方便，若是你想要經過一次查詢就把文章數據和文章全部關的點贊、收藏和評論數據一塊兒找出來，而且放在一個數據結構中，那麼關聯是不可被替代的。在你 sequelize 一次查詢多個表的關聯數據時，它本質上是生成了一個複雜的 mysql 鏈表查詢語句。而在 sequeliz 中你僅僅在須要時，指定便可。 User 與 ArticleLike，ArticleStar 和 ArticleComment 都存在與上述同樣的關聯關係,複製粘貼便可

// models/test/index.js
User.hasMany(ArticleLike, {foreignKey: 'uid'})
ArticleLike.belongsTo(User, {foreignKey: 'uid'})
User.hasMany(ArticleStar, {foreignKey: 'uid'})
ArticleStar.belongsTo(User, {foreignKey: 'uid'})
User.hasMany(ArticleComment, {foreignKey: 'uid'})
ArticleComment.belongsTo(User, {foreignKey: 'uid'})
複製代碼

另外， Article 與 ArticleLike，ArticleStar 和 ArticleComment 之間也存在關聯關係，好比一條評論，你既要知道誰寫的評論（uid），還有知道評論了哪篇文章 (aid)

// models/test/index.js
Article.hasMany(ArticleLike, {foreignKey: 'aid'})
ArticleLike.belongsTo(Article, {foreignKey: 'aid'})
Article.hasMany(ArticleStar, {foreignKey: 'aid'})
ArticleStar.belongsTo(Article, {foreignKey: 'aid'})
Article.hasMany(ArticleComment, {foreignKey: 'aid'})
ArticleComment.belongsTo(Article, {foreignKey: 'aid'})
複製代碼

同步後，看查看數據表 ArticleComment時，正如所料，它多出兩個外鍵字段 uid 和 aid。

關聯使用

// 查詢文章數據，同時關聯評論數據
Article.findAll({
  // 經過 include 字段，把須要關聯的模型指定便可。
  // 就辣麼簡單！
  include: [ArticleComment]
})
// 返回數據
{
    "id": 4,
    "title": "我是標題",
    "content": "我是內容",
    "createdAt": "2018-10-11T03:42:01.000Z",
    "updatedAt": "2018-10-11T03:42:01.000Z",
    "uid": 1,
    // 評論
    "article_comments": [/* */]
}
複製代碼
// 帶上全部已創建關聯表的數據
Article.findAll({
  include: [{
    all: true  
  }]
})

// 返回數據
}
    "id": 4,
    "title": "我是標題",
    "content": "我是內容",
    "createdAt": "2018-10-11T03:42:01.000Z",
    "updatedAt": "2018-10-11T03:42:01.000Z",
    "uid": 1,
    // 用戶
    "user": {
        "id": 1,
        "username": "sunny",
        "password": "1234",
        "createdAt": "2018-10-11T03:38:54.000Z",
        "updatedAt": "2018-10-11T03:38:54.000Z"
    },
    // 點贊
    "article_likes": [/* */]],
    // 收藏
    "article_stars": [/* */]],
    // 評論
    "article_comments": [/* */]]
}

複製代碼
// 甚至你還能夠深度遞歸（當心死循環）
Article.findAll({
  include: [{
    all: true,
    nested: true
  }]
})
複製代碼

第四步，接口邏輯

接口呢！也就是增刪改查

// app/controllers/Article.js
import {Article} from "../models/test"
export default class {
  // 增
  static async add (ctx) {
    const post = ctx.request.body
    let result
    try {
      // 簡單直了
      result = await Article.create(post)
    } catch (error) {
      return ctx.body = {success: false, error}
    }
    ctx.body = {success: true, data: result}
  }
  
   // 刪
  static async remove (ctx) {
    const {id, uid} = ctx.request.body
    let result
    try {
      // 必須同時指定 id 和 uid 才能刪除
      result = await Article.destroy({
        where: { id, uid }
      })
    } catch (error) {
      return ctx.body = {success: false, error}
    }
    ctx.body = {success: true, data: result}
  }
  // 改    
  static async update (ctx) {
    const post = ctx.request.body
    // 纔不讓你改所屬的用戶呢
    delete post.uid
    let result
      // 改呢，必須經過 where 指定主鍵
      result = await Article.update(post, {where: {id: post.id}})
    ctx.body = {success: true, data: result}
  }
  // 查
  static async find (ctx) {
    const {id, uid} = ctx.query
    let result
    try {
      result = await Article.findAll({
        // 可選的 id（查詢指定文章數據） 和 uid（查詢指定用戶全部的文章數據）
        where: Object.assign({}, id && {id}, uid && {uid}),
        // 帶上全部的關聯數據
        include: [{
          all: true,
        }]
      })
    } catch (error) {
      return ctx.body = {success: false, error}
    }
    ctx.body = {success: true, data: result}
  }
}
複製代碼

最後記得掛載到路由。

// app/router.js
import Article from './controllers/Article'
router
  .get('/article/find', Article.find)
  .post('/article/add', Article.add)
  .post('/article/update', Article.update)
  .post('/article/remove', Article.remove)
複製代碼

Op（查詢條件）

Op 對象集內置了一系列適用於 where 子句 查詢的操做符（查詢條件）。

// /models/test/index.js
//  導出 Op
export const Op = Sequelize.Op
複製代碼
// /models/controllers/User.js
import {User, Op} from '../models/test/'

export default class {
  static async findTest (ctx) {
    let result
    try {
      result = await User.findAll({
        // 查詢全部 id > 2 的用戶
        where: {
          id: {
            [Op.gt]: 2
          }
        }
      })
    } catch (error) {
      return ctx.body = {success: false, error}
    }
    ctx.body = {success: true, data: result}
  }
}
複製代碼

如下列出了全部內置的 Op 操做符

[Op.and]: {a: 5}           // 且 (a = 5)
[Op.or]: [{a: 5}, {a: 6}]  // (a = 5 或 a = 6)
[Op.gt]: 6,                // id > 6
[Op.gte]: 6,               // id >= 6
[Op.lt]: 10,               // id < 10
[Op.lte]: 10,              // id <= 10
[Op.ne]: 20,               // id != 20
[Op.eq]: 3,                // = 3
[Op.not]: true,            // 不是 TRUE
[Op.between]: [6, 10],     // 在 6 和 10 之間
[Op.notBetween]: [11, 15], // 不在 11 和 15 之間
[Op.in]: [1, 2],           // 在 [1, 2] 之中
[Op.notIn]: [1, 2],        // 不在 [1, 2] 之中
[Op.like]: '%hat',         // 包含 '%hat'
[Op.notLike]: '%hat'       // 不包含 '%hat'
[Op.iLike]: '%hat'         // 包含 '%hat' (不區分大小寫)  (僅限 PG)
[Op.notILike]: '%hat'      // 不包含 '%hat'  (僅限 PG)
[Op.regexp]: '^[h|a|t]'    // 匹配正則表達式/~ '^[h|a|t]' (僅限 MySQL/PG)
[Op.notRegexp]: '^[h|a|t]' // 不匹配正則表達式/!~ '^[h|a|t]' (僅限 MySQL/PG)
[Op.iRegexp]: '^[h|a|t]'    // ~* '^[h|a|t]' (僅限 PG)
[Op.notIRegexp]: '^[h|a|t]' // !~* '^[h|a|t]' (僅限 PG)
[Op.like]: { [Op.any]: ['cat', 'hat']} // 包含任何數組['cat', 'hat'] - 一樣適用於 iLike 和 notLike
[Op.overlap]: [1, 2]       // && [1, 2] (PG數組重疊運算符)
[Op.contains]: [1, 2]      // @> [1, 2] (PG數組包含運算符)
[Op.contained]: [1, 2]     // <@ [1, 2] (PG數組包含於運算符)
[Op.any]: [2,3]            // 任何數組[2, 3]::INTEGER (僅限PG)
[Op.col]: 'user.organization_id' // = 'user'.'organization_id', 使用數據庫語言特定的列標識符, 本例使用 PG
複製代碼

爲何不直接使用符號而是使用額外的封裝層 Op，據官方說法是爲了防止 SQL 注入和其餘一些安全檢測。另外，Op 對象集實際上是一系列 Symbol 的集合。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程