Node 系列（三）连接数据库

字数统计: 2.8k字   |   阅读时长≈ 12分

前言

上一篇文章，我们启动了 MySQL ，那么接下来，我们就该连接数据库，进行增删改查的操作了。

TypeORM

【 TypeORM 】 是 node.js 现有社区最成熟的对象关系映射器（ORM ）。 Midway 和 TypeORM 搭配，使开发更简单。那就开始吧！

安装

1
$ npm i @midwayjs/orm@3 typeorm --save

引入组件

我们在入口文件去引入组件，这里为了更清晰的了解怎么去引入 orm ，我们只写了需要新加的 orm 的内容。

1
2
3
4
5
6
7
 // src/configuration.ts
import * as orm from '@midwayjs/orm';
@Configuration({
  imports: [
    orm,
  ],
})

安装数据库

我们使用的是 MySQL ，所以我们安装 MySQL 的数据库就可以了。

1
$ npm install mysql2 --save

目录结构

一般情况下，我们数据库的实体会放到 entity 目录下，所以我们自行创建一个 entity 目录，（这里我们之后会详细介绍）结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
.
├── src                            ## midway 项目源码
│   └── controller                 ## Web Controller 目录
│       └── user.controller.ts
│   └── middleware                 ## 中间件目录
│       └── user.middleware.ts
│   └── service                    ## 服务逻辑目录
│       └── user.service.ts
│   └── entity                 ## 数据库实体
│       └── user.entity.ts
├── test
├── package.json
└── tsconfig.json

配置连接信息

准备工作都已经完成了，接下来我们就可以创建连接信息了，这里先简单的去配置数据库的连接，之后会在介绍分环境配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// src/config/config.default.ts
export default {
  // ...
  orm: {
    /**
     * 单数据库实例
     */
    type: 'mysql',
    host: 'localhost',
    port: 3306,
    username: 'root',
    password: 'root123',
    database: 'demo',
    synchronize: false, // 如果第一次使用，不存在表，有同步的需求可以写 true
    logging: true,
  },
}

说明：

  • type: 我们使用的数据库，这里我们安装的是 MySQL
  • host: 数据库地址
  • port: 数据库端口号
  • username：连接数据库的用户名，默认是 root ，
  • password: 连接数据库密码，我们使用命令行启动 MySQL 时，设置的密码
  • database: 数据库名称，之前我们创建数据库时创建的名字

插入数据库数据

以上基本工作完成之后，我们就和数据库做了连接，接下来就可以向数据库中添加数据了。

创建 Model

我们通过模型和数据库关联，在应用中的模型就是数据库表，在 TypeORM 中，模型是和实体绑定的，每一个实体（Entity) 文件，即是 Model，也是实体（Entity）。
我们拿 user 来做例子，之前我们创建了 entity 目录，在其添加实体文件 user.entity.ts

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
// src/entity/user.entity.ts
import { EntityModel } from '@midwayjs/orm';
import { Column, PrimaryGeneratedColumn } from 'typeorm';

@EntityModel('user')
export class UserEntity {
  /**
   * 自增主键列
   */
  @PrimaryGeneratedColumn()
  id: number;

  /**
   * 用户名
   */
  @Column({ name: 'name' })
  name: string;

  /**
   * 密码
   */
  @Column({ name: 'password' })
  password: string;
}

接下来，我们详细介绍一下这个 Model

添加实体模型装饰器

  • EntityModel：我们使用 EntityModel 来定义一个实体模型类。
  • @EntityModel() 参数是我们创建的表的名称，上一篇中，我们创建的用户表的名称为 user ，所以我们这里是 user 。
    1
    2
    import { EntityModel } from '@midwayjs/orm';
    @EntityModel('user')

    添加数据库列

  • Column：通过 typeorm 提供的 @Column 装饰器来修饰属性，每一个属性对应一个列。

我们可以通过 @Column 调整数据类型，如下：

1
2
3
4
5
@Column({
  length: 100, // 字段长度
  name: 'custom_name' // 列的名称
})
name: string; // 数据类型

这里简单的介绍， @Column 还有很多属性，如 type 、readonly 等，大家需要可以自行去源码查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { Column } from 'typeorm';

export class UserEntity {
  /**
   * 用户名
   */
  @Column({ name: 'name' })
  name: string;

  /**
   * 密码
   */
  @Column({ name: 'password' })
  password: string;
}

至此，我们生成了带有列的数据库表，但是还剩下一件事。每个数据库表必须具有带主键的列。

创建自增主键列

因为我们的数据库的 id ，我们希望的是自增的，所以我们可以直接创建自增主键列，当然还有普通模式的主键列，大家可以根据需求，看是否需要的是自增主键列。

每个实体必须至少具有一个主键列。要使列成为主键，需要使用 @PrimaryColumn 装饰器，若想使用自增主键列，则需要使用 @PrimaryGeneratedColumn 装饰器

1
2
3
4
5
6
7
8
9
import { PrimaryGeneratedColumn } from 'typeorm';

export class UserEntity {
  /**
   * 自增主键列
   */
  @PrimaryGeneratedColumn()
  id: number;
}

现在，Model 创建好了，接下来我们就该使用 Model 插入数据库数据了。

使用 Model 插入数据库数据

  1. 创建实体对象
  2. 执行 save()

所以这里，我们就需要先了解一下 Service 了。
在业务中，只有控制器（ Controller ）的代码是不够的，一般来说会有一些业务逻辑被抽象到一个特定的逻辑单元中，我们一般称为服务（Service）。

这样的好处是：

  • 保持 Controller 中的逻辑更简洁
  • 保持业务逻辑的独立性，一个 Service 可以被多个 Controller 引用
  • 将逻辑和展现分离

之前我们介绍目录结构的时候，里边有个 service 目录，那么接下来我们来添加一个 user 服务吧。

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
// src/service/user.service.ts
import { Inject, Provide } from '@midwayjs/decorator';
import { InjectEntityModel } from '@midwayjs/orm';
// 引入 user 实体
import { UserEntity } from '../entity/user.entity';
import { Repository } from 'typeorm';
import { ILogger } from '@midwayjs/logger';

@Provide('')
export class UserService {
  @Inject()
  logger: ILogger;

  // 注入实体对象，这里我们把添加的 user 注入进来
  @InjectEntityModel(UserEntity)
  userModel: Repository<UserEntity>;

  // 我们的需求是接收路由中的用户名和密码，保存到数据库中，所以我们写一个 saveUser 的方法用来实现这个功能
  async saveUser(name, pwd) {
    // create a entity object
    const user = new UserEntity();
    user.name = name;
    user.password = pwd;

    // save entity
    // 调用 save 方法，实现向数据库插入数据的功能
    const userResult = await this.userModel.save(user);

  }
}

以上，我们创建了 user 实体，接下来就是在对应的路由中去调用该方法了。

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
import { Inject, Controller, Body, Post } from '@midwayjs/decorator';
import { Context } from '@midwayjs/koa';
import { JwtService } from '@midwayjs/jwt';
import { User } from '../interface';
import { ResultRtn } from '../constent/result';
import { ILogger } from '@midwayjs/logger';
import { UserService } from '../service/user.service';

@Controller('/user')
export class APIController {
  @Inject()
  jwt: JwtService;
  @Inject()
  logger: ILogger;
  @Inject()
  ctx: Context;
  // 把 user 实体注入进来，就可以使用了
  @Inject()
  user: UserService;

  /** 
   * 我们在注册这个路由中，需要把用户输入的用户名和密码保存到数据库中，
   * （正常会先查库，看有没有注册过，注册过提示该用户已注册，这里我们只做简单的保存数据到 MySQL ，先不做查库的操作）
   * 这里我们使用 Post 方式进行接口请求
   * @Body 可以接收请求中的参数
   */
  @Post('/register')
  async getUser(@Body() user: User): Promise<ResultRtn<string>> {
    const token = await this.jwt.sign({
      username: user.name,
      password: user.password,
    });
    this.logger.info('token:[%s]', token);
    // 调用实体中保存用户名的接口，把数据存储到数据库
    await this.user.saveUser(user.name, user.password);
    // 这里是我们之前封装的一个统一数据格式的方法
    return ResultRtn.ofSuccess(token);
  }
}

到此，我们就可以成功的把数据添加到数据库了，如下：

查询数据库数据

我们上边已经成功把用户名和密码插入到数据库了，接下来，我们开始查询数据库
同样，我们在创建的 user Service 中，在添加一个查询的方法，查询数据库数据，我们可以使用 find()，等同于 SELECT * FROM user
所以，我们既可以使用 find() 方法，也可以使用 Sql 语句去查询数据，使用 Sql 语句的话，我们就需要使用 query() 方法
如下的 findUser() 方法，是我们添加的查询方法，之后同样去对应的路由中使用

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
// src/service/user.service.ts
import { Inject, Provide } from '@midwayjs/decorator';
import { InjectEntityModel } from '@midwayjs/orm';
import { UserEntity } from '../entity/user.entity';
import { Repository } from 'typeorm';
import { ILogger } from '@midwayjs/logger';

@Provide('')
export class UserService {
  @Inject()
  logger: ILogger;
  
  // 注入实体对象，这里我们把添加的 user 注入进来
  @InjectEntityModel(UserEntity)
  userModel: Repository<UserEntity>;

  // 我们的需求是接收路由中的用户名和密码，保存到数据库中，所以我们写一个 saveUser 的方法用来实现这个功能
  async saveUser(name, pwd) {
    // create a entity object
    const user = new UserEntity();
    user.name = name;
    user.password = pwd;

    // save entity
    // 调用 save 方法，实现向数据库插入数据的功能
    const userResult = await this.userModel.save(user);

  }

  // 查询数据库数据
  async findUser(){
    return await this.userModel.find();
    // 或者使用 query() 方法
    // return await this.userModel.query(`SELECT * FROM user`);
  }
}
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
// src/controller/user.controller.ts
import { Inject, Controller, Get, Body, Post } from '@midwayjs/decorator';
import { Context } from '@midwayjs/koa';
import { JwtService } from '@midwayjs/jwt';
import { User } from '../interface';
import { ResultRtn } from '../constent/result';
import { ILogger } from '@midwayjs/logger';
import { UserService } from '../service/user.service';

@Controller('/user')
export class APIController {
  @Inject()
  jwt: JwtService;
  @Inject()
  logger: ILogger;
  @Inject()
  ctx: Context;

  @Inject()
  user: UserService;
  
  /** 
   * 我们在注册这个路由中，需要把用户输入的用户名和密码保存到数据库中
   * 这里我们使用 Post 方式进行接口请求
   * @Body 可以接收请求中的参数
   */
  @Post('/register')
  async getUser(@Body() user: User): Promise<ResultRtn<string>> {
    const token = await this.jwt.sign({
      username: user.name,
      password: user.password,
    });
    this.logger.info('token:[%s]', token);
    // 调用实体中保存用户名的接口，把数据存储到数据库
    await this.user.saveUser(user.name, user.password);
    // 这里是我们之前封装的一个统一数据格式的方法
    return ResultRtn.ofSuccess(token);
  }

  @Get('/list')
  async userList() {
    const result = await this.user.findUser();
    return ResultRtn.ofSuccess(result);
  }
}

需要注意的一点是，我们之前使用了 Jwt 鉴权，所以之后调用的接口，都需要在 header 中加入 token

结果如下图：

删除数据库数据

删除数据，我们可以使用 remove() 方法，同样也可以使用 Sql 语句的方式

1
2
3
4
5
6
7
8
// src/service/user.service.ts
// 删除数据
async deleteUser(nameDel) {
  const user = await this.userModel.query(
    `SELECT * FROM user WHERE name='${nameDel}'`
  );
  await this.userModel.remove(user);
}
1
2
3
4
5
6
7
8
// src/controller/user.controller.ts

// 这里使用 @Query 方法，拿到接口里的参数，传入到删除的方法中
@Get('/del')
async userDel(@Query('name') name: string) {
  const result = await this.user.deleteUser(name);
  return ResultRtn.ofSuccess(result);
}

更新数据库

同样的，在 user.service.ts 中添加一个更新数据的方法

  • 先查到要更新的数据
  • 修改这条数据的值
  • 使用 save() 保存到数据库
1
2
3
4
5
6
7
// src/service/user.service.ts
// 更新数据
  async updateUser(oldName, newName) {
    await this.userModel.query(
      `UPDATE user SET name = '${newName}' WHERE name = '${oldName}'`
    );
  }
1
2
3
4
5
6
7
8
9
// src/controller/user.controller.ts
@Post('/update')
async userUpdate(@Body() updateUser: UpdateUser) {
  const result = await this.user.updateUser(
    updateUser.oldName,
    updateUser.NewName
  );
  return ResultRtn.ofSuccess(result);
}

到这里，简单的增删改查就已经完成了。完整的代码已上传到 【 GitHub 】

总结一下，大家也发现了，我们的增删改查，不仅可以使用 Sql 语句，也可以使用其封装好的方法，（具体有哪些方法，可以查看 Midway 的文档或者去看源码都可以）具体使用哪种方法，就看自己的习惯了。

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true