我们经常会见到一些多级分类的场景：

比如京东的商品分类：

新闻网站的新闻分类：

这种多层级的数据怎么存储呢？

有同学会说，很简单啊，这不就是一对多么，二级分类就用两个表，三级分类就用三个表。

这样是可以，但是都是分类，表结构是一样的，分到多个表里是不是有点冗余。

更重要的是，如果层级关系经常调整呢？

比如有的时候会变成二级分类，有的时候会更多级分类呢？

这时候用普通的多表之间的一对多就不行了。

一般这种多级分类的业务，我们都会在一个表里存储，然后通过 parentId 进行子关联来实现。

在 TypeORM 里也对这种场景做了支持。

我们新建个项目：

nest new typeorm-tree-entity-test

进入项目目录，创建一个 CRUD 模块：

nest g resource city --no-spec

然后安装 TypeORM 的包：

npm install --save @nestjs/typeorm typeorm mysql2

在 app.module.ts 引入下 TypeOrmModule：

import { Module } from "@nestjs/common";
import { AppController } from "./app.controller";
import { AppService } from "./app.service";
import { CityModule } from "./city/city.module";
import { TypeOrmModule } from "@nestjs/typeorm";

@Module({
  imports: [
    CityModule,
    TypeOrmModule.forRoot({
      type: "mysql",
      host: "localhost",
      port: 3306,
      username: "root",
      password: "guang",
      database: "tree_test",
      synchronize: true,
      logging: true,
      entities: [City],
      poolSize: 10,
      connectorPackage: "mysql2",
      extra: {
        authPlugin: "sha256_password",
      },
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

在 mysql workbench 里创建这个 database：

指定字符集为 utf8mb4，点击 apply。

然后改下 city.entity.ts

import {
  Column,
  CreateDateColumn,
  Entity,
  PrimaryGeneratedColumn,
  Tree,
  TreeChildren,
  TreeParent,
  UpdateDateColumn,
} from "typeorm";

@Entity()
@Tree("closure-table")
export class City {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ default: 0 })
  status: number;

  @CreateDateColumn()
  createDate: Date;

  @UpdateDateColumn()
  updateDate: Date;

  @Column()
  name: string;

  @TreeChildren()
  children: City[];

  @TreeParent()
  parent: City;
}

把服务跑起来：

npm run start:dev

可以看到，自动创建了 2 个表：

我们在 mysql workbench 里看下：

可以看到 parentId 引用了自身的 id。

并且还有个 city_closure 表：

两个外键都引用了 city 表的 id。

先不着急解释为什么是这样的，我们插入一些数据试试：

在 CityService 的 findAll 方法里插入数据，然后再查出来。

@InjectEntityManager()
entityManager: EntityManager;

async findAll() {
    const city = new City();
    city.name = '华北';
    await this.entityManager.save(city);

    const cityChild = new City()
    cityChild.name = '山东'
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '华北'
      }
    });
    if(parent){
      cityChild.parent = parent
    }
    await this.entityManager.save(City, cityChild)

    return this.entityManager.getTreeRepository(City).findTrees();
}

这里创建了两个 city 的 entity，第二个的 parent 指定为第一个。

用 save 保存。

然后再 getTreeRepository 调用 findTrees 把数据查出来。

浏览器访问下：

可以看到数据插入成功了，并且返回了树形结构的结果。

在 mysql workbench 里看下：

在 city 表里保存着 city 记录之间的父子关系，通过 parentId 关联。

在 city_closure 表里记录了也记录了父子关系。

把插入数据的代码注释掉：

重新插入数据：

async findAll() {
    const city = new City();
    city.name = '华南';
    await this.entityManager.save(city);

    const cityChild1 = new City()
    cityChild1.name = '云南'
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '华南'
      }
    });
    if(parent){
      cityChild1.parent = parent
    }
    await this.entityManager.save(City, cityChild1)

    const cityChild2 = new City()
    cityChild2.name = '昆明'

    const parent2 = await this.entityManager.findOne(City, {
      where: {
        name: '云南'
      }
    });
    if(parent){
      cityChild2.parent = parent2
    }
    await this.entityManager.save(City, cityChild2)

return this.entityManager.getTreeRepository(City).findTrees();
}

跑一下：

可以看到，二层和三层的关系都可以正常的存储和查询。

把插入数据的代码注释掉，我们测试下其他方法：

findRoots 查询的是所有根节点：

async findAll() {
    return this.entityManager.getTreeRepository(City).findRoots()
}

async findAll() {
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '云南'
      }
    });
    return this.entityManager.getTreeRepository(City).findDescendantsTree(parent)
}

findDescendantsTree 是查询某个节点的所有后代节点。

async findAll() {
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '云南'
      }
    });
    return this.entityManager.getTreeRepository(City).findAncestorsTree(parent)
}

findAncestorsTree 是查询某个节点的所有祖先节点。

这里换成 findAncestors、findDescendants 就是用扁平结构返回：

把 findTrees 换成 find 也是会返回扁平的结构：

还可以调用 countAncestors 和 countDescendants 来计数：

async findAll() {
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '云南'
      }
    });
    return this.entityManager.getTreeRepository(City).countAncestors(parent)
}

这些 api 都是很实用的。

回过头来，再看下 @Tree 的 entity：

通过 @TreeChildren 声明的属性里存储着它的 children 节点，通过 @TreeParent 声明的属性里存储着它的 parent 节点。

并且这个 entity 要用 @Tree 声明。

参数可以指定 4 中存储模式：

我们一般都是用 closure-table，或者 materialized-path。

其余两种有点问题：

把两个表删掉：

改成 materialized-path 重新跑：

可以看到，现在只生成了一个表：

只是这个表多了一个 mpath 字段。

我们添加点数据：

async findAll() {
    const city = new City();
    city.name = '华北';
    await this.entityManager.save(city);

    const cityChild = new City()
    cityChild.name = '山东'
    const parent = await this.entityManager.findOne(City, {
      where: {
        name: '华北'
      }
    });
    if(parent){
      cityChild.parent = parent
    }
    await this.entityManager.save(City, cityChild)

    return this.entityManager.getTreeRepository(City).findTrees();
}

可以看到，它通过 mpath 路径存储了当前节点的访问路径，从而实现了父子关系的记录：

其实这些存储细节我们不用关心，不管是 closure-table 用两个表存储也好，或者 materialized-path 用一个表多加一个 mpath 字段存储也好，都能完成同样的功能。

案例代码在小册仓库 (opens new window)。

总结

这节我们基于 TyepORM 实现了任意层级的关系的存储。

在 entity 上使用 @Tree 标识，然后通过 @TreeParent 和 @TreeChildren 标识存储父子节点的属性。

之后可以用 getTreeRepository 的 find、findTrees、findRoots、findAncestorsTree、findAncestors、findDescendantsTree、findDescendants、countDescendants、countAncestors 等 api 来实现各种关系的查询。

存储方式可以指定 closure-table 或者 materialized-path，这两种方式一个用单表存储，一个用两个表，但实现的效果是一样的。

以后遇到任意层级的数据的存储，就是用 Tree Entity 吧。