TypeScript——orm框架-TypeORM

发表于 | 分类于

在nodejs中也有比较好用的ORM框架，比如TypeORM，Sequelize等等。

TypeORM 是一个 ORM 框架，它可以运行在 NodeJS、Browser、Cordova、PhoneGap、Ionic、React Native、Expo 和 Electron 平台上，可以与 TypeScript 和 JavaScript (ES5,ES6,ES7,ES8)一起使用。 它的目标是始终支持最新的 JavaScript 特性并提供额外的特性以帮助你开发任何使用数据库的（不管是只有几张表的小型应用还是拥有多数据库的大型企业应用）应用程序。

不同于现有的所有其他 JavaScript ORM 框架，TypeORM 支持 Active Record 和 Data Mapper 模式，这意味着你可以以最高效的方式编写高质量的、松耦合的、可扩展的、可维护的应用程序。

TypeORM 参考了很多其他优秀 ORM 的实现, 比如 Hibernate, Doctrine 和 Entity Framework。

TypeORM 的一些特性:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
同时支持 DataMapper 和 ActiveRecord (随你选择)
实体和列
数据库特性列类型
实体管理
存储库和自定义存储库
清晰的对象关系模型
关联（关系）
贪婪和延迟关系
单向的，双向的和自引用的关系
支持多重继承模式
级联
索引
事务
迁移和自动迁移
连接池
主从复制
使用多个数据库连接
使用多个数据库类型
跨数据库和跨模式查询
优雅的语法，灵活而强大的 QueryBuilder
左联接和内联接
使用联查查询的适当分页
查询缓存
原始结果流
日志
监听者和订阅者（钩子）
支持闭包表模式
在模型或者分离的配置文件中声明模式
json / xml / yml / env 格式的连接配置
支持 MySQL / MariaDB / Postgres / SQLite / Microsoft SQL Server / Oracle / sql.js
支持 MongoDB NoSQL 数据库
可在 NodeJS / 浏览器 / Ionic / Cordova / React Native / Expo / Electron 平台上使用
支持 TypeScript 和 JavaScript
生成高性能、灵活、清晰和可维护的代码
遵循所有可能的最佳实践
命令行工具

安装

1
2
npm install typeorm --save
npm install reflect-metadata --save

并且需要在应用程序的全局位置导入（例如在app.ts中）

1
import "reflect-metadata";

你可能还需要安装 node typings(以此来使用 Node 的智能提示):

1
npm install @types/node --save

安装数据库驱动:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MySQL 或者 MariaDB
npm install mysql --save (也可以安装 mysql2)

PostgreSQL
npm install pg --save

SQLite
npm install sqlite3 --save

Microsoft SQL Server
npm install mssql --save

sql.js
npm install sql.js --save

Oracle
npm install oracledb --save
  • TypeScript 配置 *
    此外，请确保你使用的 TypeScript 编译器版本是2.3或更高版本，并且已经在 tsconfig.json 中启用了以下设置:
    1
    2
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    除此之外，你可能还需要在编译器选项的 lib 中启用 es6，或者安装 es6-shim 的 @types。

快速开始

全局安装 TypeORM:npm install typeorm -g

然后转到要创建新项目的目录并运行命令：typeorm init –name MyProject –database mysql

其中 name 是项目的名称，database 是将使用的数据库。

数据库可以是以下值之一: mysql、 mariadb、 postgres、 sqlite、 mssql、 oracle、 mongodb、 cordova、 react-native、 expo、 nativescript.

此命令将在 MyProject 目录中生成一个包含以下文件的新项目:

1
2
3
4
5
6
7
8
9
10
11
MyProject
├── src              // TypeScript 代码
│   ├── entity       // 存储实体（数据库模型）的位置
│   │   └── User.ts  // 示例 entity
│   ├── migration    // 存储迁移的目录
│   └── index.ts     // 程序执行主文件
├── .gitignore       // gitignore文件
├── ormconfig.json   // ORM和数据库连接配置
├── package.json     // node module 依赖
├── README.md        // 简单的 readme 文件
└── tsconfig.json    // TypeScript 编译选项

或者在现有 node 项目上运行 typeorm init，但要注意，此操作可能会覆盖已有的某些文件。

1
2
D:\mydoc\NodeJs\前端-study-demo\typeorm-demo>typeorm init
Project created inside current directory.

接下来安装项目依赖项：npm install

在安装过程中，编辑 ormconfig.json 文件并在其中编辑自己的数据库连接配置选项：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//ormconfig.json
设置 synchronize 可确保每次运行应用程序时实体都将与数据库同步
{
   "type": "mysql",
   "host": "172.16.3.34",
   "port": 3306,
   "username": "root",
   "password": "root",
   "database": "root",
   "synchronize": true,
   "logging": false,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   }
}
//tsconfig.json
{
   "compilerOptions": {
      "lib": [
         "es5",
         "es6"
      ],
      "target": "es5",
      "module": "commonjs",
      "moduleResolution": "node",
      "outDir": "./build",
      "emitDecoratorMetadata": true,
      "experimentalDecorators": true,
      "sourceMap": true
   }
}
//package.json
{
   "name": "typeorm-demo",
   "version": "0.0.1",
   "description": "Awesome project developed with TypeORM.",
   "devDependencies": {
      "ts-node": "3.3.0",
      "@types/node": "^8.0.29",
      "typescript": "3.3.3333"
   },
   "dependencies": {
      "typeorm": "0.2.22",
      "reflect-metadata": "^0.1.10",
      "mysql": "^2.14.1"
   },
   "scripts": {
      "start": "ts-node src/index.ts"
   }
}

运行：

1
2
3
4
5
6
7
8
9
10
11
12
> typeorm-demo@0.0.1 start D:\mydoc\NodeJs\前端-study-demo\typeorm-demo
> ts-node src/index.ts

Inserting a new user into the database...
Saved a new user with id: 11
Loading users from the database...
Loaded users:  [ User { id: 1, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 2, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 3, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 10, firstName: 'sundial', lastName: '3434', age: 20 },
  User { id: 11, firstName: 'Timber', lastName: 'Saw', age: 25 } ]
Here you can setup and run express/koa/any other framework.

绝大多数情况下，你只需要配置 host, username, password, database 或者 port 即可。

完成配置并安装所有 node modules 后，即可运行应用程序：npm start

还可以通过运行 typeorm init –name MyProject –database mysql –express 来生成一个更高级的 Express 项目

分步指南

创建实体

1
2
3
4
5
6
7
8
9
10
11
12
13
import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;
    @Column()
    firstName: string;
    @Column()
    lastName: string;
    @Column()
    age: number;
}

每个表都必须至少有一个主键列。使用 @PrimaryColumn 修饰符。自动生成的列@PrimaryGeneratedColumn()

列数据类型

见最后

创建数据库连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
createConnection({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "root",
    password: "admin",
    database: "test",
    entities: [
        Photo//引用目录下的所有实体__dirname + "/entity/*.js"
    ],
    synchronize: true,
    logging: false
}).then(connection => {
    // 这里可以写实体操作相关的代码 
}).catch(error => console.log(error));

可以吧数据库配置信息放到ormconfig.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
{
   "name": "default",
   "type": "mysql",
   "host": "172.16.3.34",
   "port": 3306,
   "username": "root",
   "password": "root",
   "database": "sonar",
   "synchronize": true,
   "logging": false,
   "cache": true,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.{ts,js}"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import "reflect-metadata";
import {createConnection} from "typeorm";
import {User} from "./entity/User";
createConnection().then(connection => {
    // 这里可以写实体操作相关的代码
    connection.manager.find(User).then(o=>console.log("Loaded users: ", o));
}).catch(error => console.log(error));

结果：
D:\mydoc\NodeJs\前端-study-demo\typeorm-demo>ts-node src/test1
Loaded users:  [ User { id: 1, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 2, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 3, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 10, firstName: 'sundial', lastName: '3434', age: 20 },
  User { id: 11, firstName: 'Timber', lastName: 'Saw', age: 25 },
  User { id: 12, firstName: 'Timber', lastName: 'Saw', age: 25 } ]

使用async/await语法

1
2
3
4
5
6
7
8
9
import "reflect-metadata";
import {createConnection} from "typeorm";
import {User} from "./entity/User";
createConnection().then(async connection => {
    // 这里可以写实体操作相关的代码
    const users = await connection.manager.find(User);
    console.log("Loaded users: ", users);

}).catch(error => console.log(error));

使用Repositories

使用Repository来代替EntityManage。每个实体都有自己的repository，可以对这个实体进行任何操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
import "reflect-metadata";
import {createConnection} from "typeorm";
import {User} from "./entity/User";
createConnection().then(async connection => {
    // 使用repository
    const repository = await connection.getRepository(User);
    let user = await repository.findOne(2);
    user.firstName="11111111111";
    await repository.save(user);
    console.log("Loaded users: ", await repository.find());
    await repository.remove(user);
    process.exit();
}).catch(error => console.log(error));

封装一个Repository

ActiveRecord方式实现

实体：

1
2
3
4
5
6
7
8
9
10
11
12
13
import {Entity, PrimaryGeneratedColumn, Column, BaseEntity} from "typeorm";

@Entity("user")
export class Person extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number;
    @Column()
    firstName: string;
    @Column()
    lastName: string;
    @Column()
    age: number;
}

操作：

1
2
3
4
5
6
7
import "reflect-metadata";
import {createConnection} from "typeorm";
import {Person} from "./entity/Person";
createConnection().then(async connection => {
    console.log("Loaded users: ", await Person.findOne(2));
    process.exit();
}).catch(error => console.log(error));

结果：

1
2
D:\mydoc\NodeJs\前端-study-demo\typeorm-demo>ts-node src/test2
Loaded users:  Person { id: 2, firstName: 'Timber', lastName: 'Saw', age: 25 }

Caching queries (缓存查询)

它缓存的实现，主要依赖于，自己在数据库里面建立一张缓存表，用的不是内存缓存，这样有好有坏吧，和我们的业务场景其实是不太适用的。这样做的好处，就是它不会把我们的内存跑满，而且也能大幅提高查询速度。但是我们更希望的是一个内存缓存。

它的用法，就是在数据库配置的过程中，增加一个cache字段。”cache”: true,

可以在这个方法中使用：getMany, getOne, getRawMany, getRawOne and getCount find, findAndCount, findByIds, and count

使用例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache(true)
    .getMany();


const users = await connection
    .getRepository(User)
    .find({
        where: { isAdmin: true },
        cache: true
    });


const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache(60000) // 设置缓存时间 1 minute
    .getMany();

//设置缓存时间
{
    cache: {
        duration: 30000 // 30 seconds
    }
}

const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache("users_admins", 25000)//缓存名称和时间
    .getMany();

也可以用redis当作缓存模块，这样也是比较不错的做法。

1
2
3
4
5
6
7
8
9
10
11
12
{
    type: "mysql",
    host: "localhost",
    ...
    cache: {
        type: "redis",
        options: {
            host: "localhost",
            port: 6379
        }
    }
}

对应关系

一对一

要与另一个类创建一对一的关系：

其他参考：https://typeorm.io

配置

基本配置参数

1
2
3
4
5
6
type: 当前要连接的数据库类型(mysql,mssql, moongo, ...)
host: 数据库服务暴露的host
port: 数据库服务暴露的端口
username: 连接数据库服务的用户名
password: 连接数据库服务的用户名
database: 连接数据库名

额外参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
name: 设置连接名，连多个数据库的时候，需要获取连接的时候可用 getConnection('name') 的方式取得对应的数据库连接；
entities: 要加载并用于此连接的实体。写法类似：
 entities: [Post, Category, "entity/*.js", "modules/**/entity/*.js"]
entityPrefix: 表名前缀
extra: 拓展的参数值, 如设置连接池连接数量等;
logging：
查询(query):记录所有查询。
错误(error):记录所有失败的查询和错误。
模式(schema):记录模式构建过程。
警告(warn):记录内部orm警告。
记录(info):内部orm信息信息。
日志(log):记录内部orm日志消息。

如果只是简单的打印基本的数据库操作(包含错误)则设置 logging: true
如果要打印以上全部类型，则设置 logging: 'all'
如果只是打印其中的1～2个（如query, error），则可设置 logging: ['query', 'error']

logger: 可设置的类型有 advanced-console,simple-console,file, debug, 在开启 logging 的情况下，logger默认使用类型是 advanced-console, 这个模式会高亮字体和标示sql语句。
cache: 对查询的 sql 结果进行缓存。 支持数据库或者redis。看了下api，redis更为方便一点。
cache: {
        type: 'redis', // 必须参数
        options: {
            host: 'localhost',
            port: 6379,
            username: '',
            password:'',
            db: 1,
        }
    }

创建多个数据库连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
[{
   "name": "dev",
   "type": "mysql",
   "host": "172.16.3.34",
   "port": 3306,
   "username": "root",
   "password": "root",
   "database": "sonar",
   "synchronize": true,
   "logging": false,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   }
},{
   "name": "pro",
   "type": "mysql",
   "host": "172.16.3.34",
   "port": 3306,
   "username": "root",
   "password": "root",
   "database": "sonar",
   "synchronize": true,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   },
   "logging": true, // 开启所有数据库信息打印
   "logger": "advanced-console", // 高亮字体的打印信息,
   "extra": {
      "connectionLimit":  10, // 连接池最大连接数量, 查阅资料 建议是  core number  * 2 + n 
   }
}]

获取指定数据库连接：

1
2
3
4
5
6
7
8
9
10
11
方式一：
import { getConnection } from 'typeorm';

const dev_connection = getConnection('dev');
const dev_connection = getConnection('dev');

方式二：
import { getConnectionManager } from "typeorm";

const dev_connection = getConnectionManager().get('dev');
const dev_connection  = getConnectionManager().get('pro');

使用 QueryBuilder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import "reflect-metadata";
import {createConnection, getConnectionOptions,getManager} from "typeorm";
import {User} from "./entity/User";
//import {dev} from "./MyConnectionInfo";
const myConn = require("./MyConnectionInfo");

async function testConn(){
    const connectionOptions = await getConnectionOptions("dev");
    const dev = await createConnection(connectionOptions);
    let user = await dev
        .getRepository(User)
        .createQueryBuilder("user") // 第一个参数是别名
        .where("user.id = 10")
        .orderBy("user.id", "DESC")
        .skip(0)
        .take(10)
        .getMany();
    console.log(user);

    process.exit();
}
testConn();

附录：

列数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
//主键自动生成列类型，主要为整型、小数等数值类型
export type PrimaryGeneratedColumnType = "int" // mysql, mssql, oracle, sqlite
    |"int2" // postgres, sqlite
    |"int2" // postgres, sqlite
    |"int4" // postgres
    |"int8" // postgres, sqlite
    |"integer" // postgres, oracle, sqlite
    |"tinyint" // mysql, mssql, sqlite
    |"smallint" // mysql, postgres, mssql, oracle, sqlite
    |"mediumint" // mysql, sqlite
    |"bigint" // mysql, postgres, mssql, sqlite
    |"dec" // oracle, mssql
    |"decimal" // mysql, postgres, mssql, sqlite
    |"numeric" // postgres, mssql, sqlite
    |"number"; // oracle
 
//带有精度的列类型，主要为各种浮点数、小数类型
export type WithPrecisionColumnType = "float" // mysql, mssql, oracle, sqlite
    |"double" // mysql, sqlite
    |"dec" // oracle, mssql
    |"decimal" // mysql, postgres, mssql, sqlite
    |"numeric" // postgres, mssql, sqlite
    |"real" // mysql, postgres, mssql, oracle, sqlite
    |"double precision" // postgres, oracle, sqlite
    |"number" // oracle
    |"datetime" // mssql, mysql, sqlite
    |"datetime2" // mssql
    |"datetimeoffset" // mssql
    |"time" // mysql, postgres, mssql
    |"time with time zone" // postgres
    |"time without time zone" // postgres
    |"timestamp" // mysql, postgres, mssql, oracle
    |"timestamp without time zone" // postgres
    |"timestamp with time zone"; // postgres, oracle
 
//带有长度的列类型，
export type WithLengthColumnType = "int" // mysql, postgres, mssql, oracle, sqlite
    |"tinyint" // mysql, mssql, sqlite
    |"smallint" // mysql, postgres, mssql, oracle, sqlite
    |"mediumint" // mysql, sqlite
    |"bigint" // mysql, postgres, mssql, sqlite
    |"character varying" // postgres
    |"varying character" // sqlite
    |"nvarchar" // mssql
    |"character" // mysql, postgres, sqlite
    |"native character" // sqlite
    |"varchar" // mysql, postgres, mssql, sqlite
    |"char" // mysql, postgres, mssql, oracle
    |"nchar" // mssql, oracle, sqlite
    |"varchar2" // oracle
    |"nvarchar2" // oracle, sqlite
    |"binary" // mssql
    |"varbinary"; // mssql
 
//简单列类型
export type SimpleColumnType =
    //简单数组，为typeorm特有，对饮数据库中string类型
    "simple-array" // typeorm-specific, automatically mapped to string
    //string类型，对应数据库中varchar类型
    |"string" // typeorm-specific, automatically mapped to varchar depend on platform
    //数值类型
    |"bit" // mssql
    |"int2" // postgres, sqlite
    |"integer" // postgres, oracle, sqlite
    |"int4" // postgres
    |"int8" // postgres, sqlite
    |"unsigned big int" // sqlite
    |"float4" // postgres
    |"float8" // postgres
    |"smallmoney" // mssql
    |"money" // postgres, mssql
 
    //boolean类型
    |"boolean" // postgres, sqlite
    |"bool" // postgres
 
    //二进制、文本类型
    |"tinyblob" // mysql
    |"tinytext" // mysql
    |"mediumblob" // mysql
    |"mediumtext" // mysql
    |"blob" // mysql, oracle, sqlite
    |"text" // mysql, postgres, mssql, sqlite
    |"ntext" // mssql
    |"citext" // postgres
    |"longblob" // mysql
    |"longtext" // mysql
    |"bytea" // postgres
    |"long" // oracle
    |"raw" // oracle
    |"long raw" // oracle
    |"bfile" // oracle
    |"clob" // oracle, sqlite
    |"nclob" // oracle
    |"image" // mssql
 
    //日期类型
    |"timestamp with local time zone" // oracle
    |"smalldatetime" // mssql
    |"date" // mysql, postgres, mssql, oracle, sqlite
    |"interval year" // oracle
    |"interval day" // oracle
    |"interval" // postgres
    |"year" // mysql
 
    //几何类型，只有postgres支持
    |"point" // postgres
    |"line" // postgres
    |"lseg" // postgres
    |"box" // postgres
    |"circle" // postgres
    |"path" // postgres
    |"polygon" // postgres
 
    // other types
    |"enum" // mysql, postgres
    |"cidr" // postgres
    |"inet" // postgres
    |"macaddr"// postgres
    |"bit" // postgres
    |"bit varying" // postgres
    |"varbit"// postgres
    |"tsvector" // postgres
    |"tsquery" // postgres
    |"uuid" // postgres
    |"xml" // mssql, postgres
    |"json" // mysql, postgres
    |"jsonb" // postgres
    |"varbinary" // mssql
    |"cursor" // mssql
    |"hierarchyid" // mssql
    |"sql_variant" // mssql
    |"table" // mssql
    |"rowid" // oracle
    |"urowid" // oracle
    |"uniqueidentifier"; // mssql
 
//列数据类型，为联合类型，各个类型之间可能有重复
export type ColumnType = 
    //带有精度类型
    WithPrecisionColumnType
    //带有长度类型
    |WithLengthColumnType
    //简单类型
    |SimpleColumnType
    //boolean类型
    |BooleanConstructor
    //Date类型
    |DateConstructor
    //数字类型
    |NumberConstructor
    //字符串类型
    |StringConstructor;
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多