Fastify 和 TypeORM：实现 ORM 操作的完整指南-JavaScript中文网-JavaScript教程资源分享门户

在现代 Web 开发中，ORM（对象关系映射）是一种非常重要的技术，它可以让开发者更加方便地进行数据库操作，避免了直接操作数据库的繁琐和复杂。在 Node.js 生态系统中，有很多优秀的 ORM 库可以选择，比如 Sequelize、TypeORM 等。本文主要介绍如何使用 Fastify 和 TypeORM 实现 ORM 操作，包括数据库连接、实体定义、查询和关联等方面的内容。

准备工作

在开始之前，我们需要准备好以下工具和环境：

Node.js 运行环境（推荐版本 12+）
npm 包管理工具
MySQL 数据库

在本文中，我们将使用 Fastify 作为 Web 框架，TypeORM 作为 ORM 库，MySQL 作为数据库。如果你对这些工具还不熟悉，可以先阅读官方文档了解一下。

安装和配置

首先，我们需要创建一个新的 Node.js 项目，并安装 Fastify 和 TypeORM 两个库：

mkdir my-project
cd my-project
npm init -y
npm install --save fastify fastify-cors fastify-jwt typeorm mysql2

其中，fastify-cors 和 fastify-jwt 是 Fastify 的插件，用于处理跨域和 JWT 认证等问题。mysql2 是 MySQL 的 Node.js 驱动程序，TypeORM 依赖它来进行数据库操作。

接下来，我们需要配置 TypeORM 的连接信息。在项目根目录下创建一个 ormconfig.json 文件，内容如下：

// javascriptcn.com 代码示例
{
  "type": "mysql",
  "host": "localhost",
  "port": 3306,
  "username": "root",
  "password": "password",
  "database": "my_database",
  "synchronize": true,
  "logging": false,
  "entities": ["src/entities/**/*.ts"]
}

其中，type 是数据库类型，host 和 port 是数据库服务器的地址和端口，username 和 password 是数据库用户名和密码，database 是要连接的数据库名称，synchronize 表示是否自动同步数据库结构（仅用于开发环境），logging 表示是否启用日志输出，entities 是实体类的存放路径。

定义实体类

在 TypeORM 中，实体类是 ORM 操作的核心，它对应了数据库中的表结构。我们需要先定义好实体类，才能进行数据操作。在 src/entities 目录下创建一个 user.ts 文件，内容如下：

// javascriptcn.com 代码示例
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;

  @Column()
  password: string;
}

其中，@Entity() 表示这个类是一个 TypeORM 实体，@PrimaryGeneratedColumn() 表示这个属性是主键并自动递增，@Column() 表示这个属性对应了数据库表的一个列。

我们还可以使用其它的装饰器来指定实体类的详细信息，比如索引、关系等。这些内容超出了本文的范围，有兴趣的读者可以查阅官方文档。

连接数据库

有了实体类之后，我们就可以连接数据库了。在 src/index.ts 中，添加以下代码：

// javascriptcn.com 代码示例
import { createConnection } from 'typeorm';

createConnection()
  .then(() => {
    console.log('Connected to database');
  })
  .catch((error) => {
    console.error('Failed to connect to database', error);
  });

这段代码会读取 ormconfig.json 文件中的数据库连接信息，并尝试连接数据库。如果连接成功，就会输出 Connected to database。如果连接失败，就会输出 Failed to connect to database，并打印错误信息。

实现基本 CRUD 操作

有了连接之后，我们就可以开始实现基本的 CRUD（增删改查）操作了。在 src/index.ts 中，添加以下代码：

// javascriptcn.com 代码示例
import fastify from 'fastify';
import { getConnection } from 'typeorm';
import { User } from './entities/user';

const app = fastify();

// 查询所有用户
app.get('/users', async (request, reply) => {
  const users = await getConnection().manager.find(User);
  reply.send(users);
});

// 查询单个用户
app.get('/users/:id', async (request, reply) => {
  const user = await getConnection().manager.findOne(User, request.params.id);
  if (user) {
    reply.send(user);
  } else {
    reply.status(404).send();
  }
});

// 创建用户
app.post('/users', async (request, reply) => {
  const user = new User();
  user.name = request.body.name;
  user.email = request.body.email;
  user.password = request.body.password;
  await getConnection().manager.save(user);
  reply.status(201).send(user);
});

// 更新用户
app.put('/users/:id', async (request, reply) => {
  const user = await getConnection().manager.findOne(User, request.params.id);
  if (user) {
    user.name = request.body.name;
    user.email = request.body.email;
    user.password = request.body.password;
    await getConnection().manager.save(user);
    reply.send(user);
  } else {
    reply.status(404).send();
  }
});

// 删除用户
app.delete('/users/:id', async (request, reply) => {
  const user = await getConnection().manager.findOne(User, request.params.id);
  if (user) {
    await getConnection().manager.remove(user);
    reply.status(204).send();
  } else {
    reply.status(404).send();
  }
});

app.listen(3000, (error, address) => {
  console.log(`Server listening on ${address}`);
});

这段代码定义了五个路由，分别对应了查询所有用户、查询单个用户、创建用户、更新用户和删除用户这五个操作。其中，GET 方法使用了 TypeORM 的 find 和 findOne 方法，分别表示查询所有和查询单个；POST 方法使用了 TypeORM 的 save 方法，表示创建一个新的实体；PUT 方法也使用了 save 方法，表示更新一个已有的实体；DELETE 方法使用了 remove 方法，表示删除一个实体。

实现关联查询

除了基本的 CRUD 操作之外，TypeORM 还支持复杂的关联查询，可以轻松地查询到相关联的实体。在 src/entities 目录下创建一个 post.ts 文件，定义一个新的实体类：

// javascriptcn.com 代码示例
import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
import { User } from './user';

@Entity()
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  content: string;

  @ManyToOne(() => User, (user) => user.posts)
  author: User;
}

这个实体类和 User 实体类之间有一个 ManyToOne 的关联关系，表示一个 Post 实体对应了一个 User 实体，而一个 User 实体可以对应多个 Post 实体。在 User 实体类中，添加一个 posts 属性，表示它的所有 Post 实体。修改 User 实体类如下：

// javascriptcn.com 代码示例
import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
import { Post } from './post';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;

  @Column()
  password: string;

  @OneToMany(() => Post, (post) => post.author)
  posts: Post[];
}

有了关联关系之后，我们就可以进行关联查询了。在 src/index.ts 中，添加以下代码：

// javascriptcn.com 代码示例
// 查询用户的所有文章
app.get('/users/:id/posts', async (request, reply) => {
  const user = await getConnection().manager.findOne(User, request.params.id, {
    relations: ['posts'],
  });
  if (user) {
    reply.send(user.posts);
  } else {
    reply.status(404).send();
  }
});

// 查询文章的作者
app.get('/posts/:id/author', async (request, reply) => {
  const post = await getConnection().manager.findOne(Post, request.params.id, {
    relations: ['author'],
  });
  if (post) {
    reply.send(post.author);
  } else {
    reply.status(404).send();
  }
});

这段代码定义了两个路由，分别对应了查询用户的所有文章和查询文章的作者这两个操作。在 findOne 方法的第三个参数中，使用了 relations 属性指定了要查询的关联实体，这样就可以一次性查询到相关联的所有实体。

实现 JWT 认证

最后，我们还可以添加 JWT（JSON Web Token）认证，保护一些敏感的接口。在 src/index.ts 中，添加以下代码：

// javascriptcn.com 代码示例
import fastifyJWT from 'fastify-jwt';

app.register(fastifyJWT, {
  secret: 'my-secret-key',
});

// 登录，返回 JWT token
app.post('/auth/login', async (request, reply) => {
  const { email, password } = request.body;
  const user = await getConnection().manager.findOne(User, { email, password });
  if (user) {
    const token = app.jwt.sign({ userId: user.id });
    reply.send({ token });
  } else {
    reply.status(401).send();
  }
});

// 获取当前用户信息
app.get('/auth/me', async (request, reply) => {
  try {
    const decoded = await app.jwt.verify(request.headers.authorization);
    const user = await getConnection().manager.findOne(User, decoded.userId);
    if (user) {
      reply.send(user);
    } else {
      reply.status(404).send();
    }
  } catch (error) {
    reply.status(401).send();
  }
});

这段代码使用了 fastify-jwt 插件来实现 JWT 认证。在注册插件时，指定了一个 secret 属性，表示 JWT token 的密钥。在登录接口中，使用 findOne 方法查询用户，如果存在则生成一个 JWT token 并返回。在获取当前用户信息的接口中，首先使用 verify 方法验证 JWT token 是否正确，然后根据 userId 查询用户信息，并返回。

总结

本文介绍了如何使用 Fastify 和 TypeORM 实现 ORM 操作，包括数据库连接、实体定义、查询和关联等方面的内容。通过本文的学习，读者可以了解到如何使用 TypeORM 进行基本的 CRUD 操作和复杂的关联查询，以及如何使用 JWT 认证保护敏感的接口。当然，这只是一个简单的示例，实际的项目中还会涉及到很多其它的问题和细节，需要读者自己不断地学习和探索。

来源：JavaScript中文网，转载请注明来源本文地址：https://www.javascriptcn.com/post/657c3097d2f5e1655d6fa6d7