欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

使用TS+Sequelize实现更简洁的CRUD

程序员文章站 2022-03-03 22:55:31
如果是经常使用Node来做服务端开发的童鞋,肯定不可避免的会操作数据库,做一些增删改查( ,`Create Read Update Delete ORM Object Relational Mapping Sequelize`就是其中比较受欢迎的一个。

如果是经常使用node来做服务端开发的童鞋,肯定不可避免的会操作数据库,做一些增删改查(crudcreate read update delete)的操作,如果是一些简单的操作,类似定时脚本什么的,可能就直接生写sql语句来实现功能了,而如果是在一些大型项目中,数十张、上百张的表,之间还会有一些(一对多,多对多)的映射关系,那么引入一个ormobject relational mapping)工具来帮助我们与数据库打交道就可以减轻一部分不必要的工作量,sequelize就是其中比较受欢迎的一个。

crud原始版 手动拼接sql

先来举例说明一下直接拼接sql语句这样比较“底层”的操作方式:

create table animal (
  id int auto_increment,
  name varchar(14) not null,
  weight int not null, 
  primary key (`id`)
);

创建这样的一张表,三个字段,自增id、name以及weight
如果使用mysql这个包来直接操作数据库大概是这样的:

const connection = mysql.createconnection({})
const tablename = 'animal'

connection.connect()

// 我们假设已经支持了promise

// 查询
const [results] = await connection.query(`
  select 
    id,
    name,
    weight
  from ${tablename}
`)

// 新增
const name = 'niko'
const weight = 70
await connection.query(`
  insert into ${tablename} (name, weight)
  values ('${name}', ${weight})
`)
// 或者通过传入一个object的方式也可以做到
await connection.query(`insert into ${tablename} set ?`, {
  name,
  weight
})

connection.end()

看起来也还算是比较清晰,但是这样带来的问题就是,开发人员需要对表结构足够的了解。
如果表中有十几个字段,对于开发人员来说这会是很大的记忆成本,你需要知道某个字段是什么类型,拼接sql时还要注意插入时的顺序及类型,where条件对应的查询参数类型,如果修改某个字段的类型,还要去处理对应的传参。
这样的项目尤其是在进行交接的时候更是一件恐怖的事情,新人又需要从头学习这些表结构。
以及还有一个问题,如果有哪天需要更换数据库了,放弃了mysql,那么所有的sql语句都要进行修改(因为各个数据库的方言可能有区别)

crud进阶版 sequelize的使用

关于记忆这件事情,机器肯定会比人脑更靠谱儿,所以就有了orm,这里就用到了在node中比较流行的sequelize

orm是干嘛的

首先可能需要解释下orm是做什么使的,可以简单地理解为,使用面向对象的方式,通过操作对象来实现与数据库之前的交流,完成crud的动作。
开发者并不需要关心数据库的类型,也不需要关心实际的表结构,而是根据当前编程语言中对象的结构与数据库中表、字段进行映射。

就好比针对上边的animal表进行操作,不再需要在代码中去拼接sql语句,而是直接调用类似animal.createanimal.find就可以完成对应的动作。

sequelize的使用方式

首先我们要先下载sequelize的依赖:

npm i sequelize
npm i mysql2    # 以及对应的我们需要的数据库驱动

然后在程序中创建一个sequelize的实例:

const sequelize = require('sequelize')
const sequelize = new sequelize('mysql://root:jarvis@127.0.0.1:3306/ts_test')
//                             dialect://username:password@host:port/db_name

// 针对上述的表,我们需要先建立对应的模型:
const animal = sequelize.define('animal', {
  id: { type: sequelize.integer, autoincrement: true },
  name: { type: sequelize.string, allownull: false },
  weight: { type: sequelize.integer, allownull: false },
}, {
  // 禁止sequelize修改表名,默认会在animal后边添加一个字母`s`表示负数
  freezetablename: true,
  // 禁止自动添加时间戳相关属性
  timestamps: false,
})

// 然后就可以开始使用咯
// 还是假设方法都已经支持了promise

// 查询
const results = await animal.findall({
  raw: true,
})

// 新增
const name = 'niko'
const weight = 70

await animal.create({
  name,
  weight,
})

sequelize定义模型相关的各种配置:docs

抛开模型定义的部分,使用sequelize无疑减轻了很多使用上的成本,因为模型的定义一般不太会去改变,一次定义多次使用,而使用手动拼接sql的方式可能就需要将一段sql改来改去的。

而且可以帮助进行字段类型的转换,避免出现类型强制转换出错nan或者数字被截断等一些粗心导致的错误。

通过定义模型的方式来告诉程序,有哪些模型,模型的字段都是什么,让程序来帮助我们记忆,而非让我们自己去记忆。
我们只需要拿到对应的模型进行操作就好了。

这还不够

but,虽说切换为orm工具已经帮助我们减少了很大一部分的记忆成本,但是依然还不够,我们仍然需要知道模型中都有哪些字段,才能在业务逻辑中进行使用,如果新人接手项目,仍然需要去翻看模型的定义才能知道有什么字段,所以就有了今天要说的真正的主角儿:

crud终极版 装饰器实现模型定义

sequelize-typescript是基于sequelize针对typescript所实现的一个增强版本,抛弃了之前繁琐的模型定义,使用装饰器直接达到我们想到的目的。

sequelize-typescript的使用方式

首先因为是用到了ts,所以环境依赖上要安装的东西会多一些:

# 这里采用ts-node来完成举例
npm i ts-node typescript
npm i sequelize reflect-metadata sequelize-typescript

其次,还需要修改ts项目对应的tsconfig.json文件,用来让ts支持装饰器的使用:

{
  "compileroptions": {
+   "experimentaldecorators": true,
+   "emitdecoratormetadata": true
  }
}

然后就可以开始编写脚本来进行开发了,与sequelize不同之处基本在于模型定义的地方:

// /modles/animal.ts
import { table, column, model } from 'sequelize-typescript'

@table({
  tablename: 'animal'
})
export class animal extends model<animal> {
  @column({
    primarykey: true,
    autoincrement: true,
  })
  id: number

  @column
  name: string

  @column
  weight: number
}

// 创建与数据库的链接、初始化模型
// app.ts
import path from 'path'
import { sequelize } from 'sequelize-typescript'
import animal from './models/animal'

const sequelize = new sequelize('mysql://root:jarvis@127.0.0.1:3306/ts_test')
sequelize.addmodels([path.resolve(__dirname, `./models/`)])

// 查询
const results = await animal.findall({
  raw: true,
})

// 新增
const name = 'niko'
const weight = 70

await animal.create({
  name,
  weight,
})

与普通的sequelize不同的有这么几点:

  1. 模型的定义采用装饰器的方式来定义
  2. 实例化sequelize对象时需要指定对应的model路径
  3. 模型相关的一系列方法都是支持promise

如果在使用过程中遇到提示xxx used before model init,可以尝试在实例化前边添加一个await操作符,等到与数据库的连接建立完成以后再进行操作

但是好像看起来这样写的代码相较于sequelize多了不少呢,而且至少需要两个文件来配合,那么这么做的意义是什么的?
答案就是oop中一个重要的理念:继承

使用sequelize-typescript实现模型的继承

因为typescript的核心开发人员中包括c#的架构师,所以typescript中可以看到很多类似c#的痕迹,在模型的这方面,我们可以尝试利用继承减少一些冗余的代码。

比如说我们基于animal表又有了两张新表,dogbird,这两者之间肯定是有区别的,所以就有了这样的定义:

create table dog (
  id int auto_increment,
  name varchar(14) not null,
  weight int not null, 
  leg int not null,
  primary key (`id`)
);

create table bird (
  id int auto_increment,
  name varchar(14) not null,
  weight int not null, 
  wing int not null,
  claw int not null,
  primary key (`id`)
);

关于dog我们有一个腿leg数量的描述,关于bird我们有了翅膀wing和爪子claw数量的描述。
特意让两者的特殊字段数量不同,省的有杠精说可以通过添加type字段区分两种不同的动物 :p

如果要用sequelize的方式,我们就要将一些相同的字段定义define三遍才能实现,或者说写得灵活一些,将define时使用的object抽出来使用object.assign的方式来实现类似继承的效果。

但是在sequelize-typescript就可以直接使用继承来实现我们想要的效果:

// 首先还是我们的animal模型定义
// /models/animal.ts
import { table, column, model } from 'sequelize-typescript'

@table({
  tablename: 'animal'
})
export default class animal extends model<animal> {
  @column({
    primarykey: true,
    autoincrement: true,
  })
  id: number

  @column
  name: string

  @column
  weight: number
}

// 接下来就是继承的使用了
// /models/dog.ts
import { table, column, model } from 'sequelize-typescript'
import animal from './animal'

@table({
  tablename: 'dog'
})
export default class dog extends animal {
  @column
  leg: number
}

// /models/bird.ts
import { table, column, model } from 'sequelize-typescript'
import animal from './animal'

@table({
  tablename: 'bird'
})
export default class bird extends animal {
  @column
  wing: number

  @column
  claw: number
}

有一点需要注意的:每一个模型需要单独占用一个文件,并且采用export default的方式来导出
也就是说目前我们的文件结构是这样的:

├── models
│   ├── animal.ts
│   ├── bird.ts
│   └── dog.ts
└── app.ts

得益于typescript的静态类型,我们能够很方便地得知这些模型之间的关系,以及都存在哪些字段。
在结合着vs code开发时可以得到很多动态提示,类似findallcreate之类的操作都会有提示:

animal.create<animal>({
  abc: 1,
// ^ abc不是animal已知的属性  
})

通过继承来复用一些行为

上述的例子也只是说明了如何复用模型,但是如果是一些封装好的方法呢?
类似的获取表中所有的数据,可能一般情况下获取json数据就够了,也就是findall({raw: true})
所以我们可以针对类似这样的操作进行一次简单的封装,不需要开发者手动去调用findall

// /models/animal.ts
import { table, column, model } from 'sequelize-typescript'

@table({
  tablename: 'animal'
})
export default class animal extends model<animal> {
  @column({
    primarykey: true,
    autoincrement: true,
  })
  id: number

  @column
  name: string

  @column
  weight: number

  static async getlist () {
    return this.findall({raw: true})
  }
}

// /app.ts
// 这样就可以直接调用`getlist`来实现类似的效果了
await animal.getlist() // 返回一个json数组

同理,因为上边我们的两个dogbird继承自animal,所以代码不用改动就可以直接使用getlist了。

const results = await dog.getlist()

results[0].leg // ts提示错误

但是如果你像上边那样使用的话,ts会提示错误的:[ts] 类型“animal”上不存在属性“leg”。
哈哈,这又是为什么呢?细心的同学可能会发现,getlist的返回值是一个animal[]类型的,所以上边并没有leg属性,bird的两个属性也是如此。

所以我们需要教ts认识我们的数据结构,这样就需要针对animal的定义进行修改了,用到了 范型
我们通过在函数上边添加一个范型的定义,并且添加限制保证传入的范型类型一定是继承自animal的,在返回值转换其类型为t,就可以实现功能了。

class animal {
  static async getlist<t extends animal>() {
    const results = await this.findall({
      raw: true,
    })
    return results as t[]
  }
}

const doglist = await dog.getlist<dog>()
// 或者不作任何修改,直接在外边手动as也可以实现类似的效果
// 但是这样还是不太灵活,因为你要预先知道返回值的具体类型结构,将预期类型传递给函数,由函数去组装返回的类型还是比较推荐的
const doglist = await dog.getlist() as dog[]

console.log(doglist[0].leg) // success

这时再使用leg属性就不会出错了,如果要使用范型,一定要记住添加extends animal的约束,不然ts会认为这里可以传入任意类型,那么很难保证可以正确的兼容animal,但是继承自animal的一定是可以兼容的。

当然如果连这里的范型或者as也不想写的话,还可以在子类中针对父类方法进行重写。
并不需要完整的实现逻辑,只需要获取返回值,然后修改为我们想要的类型即可:

class dog extends animal {
  static async getlist() {
    // 调用父类方法,然后将返回值指定为某个类型
    const results = await super.getlist()
    return results as dog[]
  }
}

// 这样就可以直接使用方法,而不用担心返回值类型了
const doglist = await dog.getlist()

console.log(doglist[0].leg) // success

小结

本文只是一个引子,一些简单的示例,只为体现出三者(sqlsequelizesequelize-typescript)之间的区别,sequelize中有更多高阶的操作,类似映射关系之类的,这些在sequelize-typescript中都有对应的体现,而且因为使用了装饰器,实现这些功能所需的代码会减少很多,看起来也会更清晰。

当然了,orm这种东西也不是说要一股脑的上,如果是初学者,从个人层面上我不建议使用,因为这样会少了一个接触sql的机会
如果项目结构也不是很复杂,或者可预期的未来也不会太复杂,那么使用orm也没有什么意义,还让项目结构变得复杂起来
以及,一定程度上来说,通用就意味着妥协,为了保证多个数据库之间的效果都一致,可能会抛弃一些数据库独有的特性,如果明确的需要使用这些特性,那么orm也不会太适合
选择最合适的,要知道使用某样东西的意义

最终的一个示例放在了github上:

参考资料: