nestjs typeorm多数据源配置，实测通过

本文目录

[隐藏]

一、背景

因为nestjs项目需要用多数据源配置，但是在按照文档配置多数据源的时候却总是报错。

这个问题困扰了我好久，找遍网络也没有发现解决方案，而且官方文档也不详细，报错说明也不明晰，只好自己摸索，最终成功解决，在此记录下正确的配置方法。

二、正确的配置方案

我单独建了一个mysql.module.ts ，用来管理mysql连接配置。

利用dotenv管理配置。

mysql.module.ts 如下：

import {AppService} from '../app.service';
import {TypeOrmModule} from '@nestjs/typeorm';
import {AppController} from '../app.controller';
import {Module} from '@nestjs/common';
import {ConfigService} from './config.service';
import {ConfigModule} from './config.module';

@Module({
    imports: [
        // 工厂方法，负责将MySQL配置引入，并建立数据库链接
        TypeOrmModule.forRootAsync({
            name: 'uniteConnection',
            imports: [ConfigModule],
            useFactory: (configService: ConfigService) => ({
                type: 'mysql',
                host: configService.getString('UNITE_MYSQL_HOST'),
                port: configService.getNumber('UNITE_MYSQL_PORT'),
                username: configService.getString('UNITE_MYSQL_USER'),
                password: configService.getString('UNITE_MYSQL_PASS'),
                database: configService.getString('UNITE_MYSQL_DB'),
                // 因为此文件部署在项目 /src/config/ 路径下，所以__dirname是 /src/config/ , 需要回溯两层目录
                entities: [__dirname + '../../**/*.entity{.ts,.js}'],
                synchronize: true,
            }),
            inject: [ConfigService],
        }),
        // 第二个数据源配置
        TypeOrmModule.forRootAsync({
            name: 'batonConnection',
            imports: [ConfigModule],
            useFactory: (configService: ConfigService) => ({
                type: 'mysql',
                host: configService.getString('BATON_MYSQL_HOST'),
                port: configService.getNumber('BATON_MYSQL_PORT'),
                username: configService.getString('BATON_MYSQL_USER'),
                password: configService.getString('BATON_MYSQL_PASS'),
                database: configService.getString('BATON_MYSQL_DB'),
                // 因为此文件部署在项目 /src/config/ 路径下，所以__dirname是 /src/config/ , 需要回溯两层目录
                entities: [__dirname + '../../**/*.entity{.ts,.js}'],
                synchronize: true,
            }),
            inject: [ConfigService],
        }),
    ],
    controllers: [AppController],
    providers: [AppService, ConfigModule, ConfigService],
})
export default class MysqlOrmConfigModule {}

然后，在主module中引入这个文件：

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import modules from './modules';
import MysqlModule from './config/mysql.module';

@Module({
  imports: [
    // 引入MySQL连接
    MysqlModule,
    // 引入module目录下所有的module
    ...modules,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

使用时，首先在使用的module的中，声明需要使用的库：

import ExampleController from './example.controller';
import {ExampleService} from './example.service';
import {HttpModule, MiddlewareConsumer, Module, NestModule} from '@nestjs/common';
import {LoggerMiddleware} from './example.middlewares';
import {TypeOrmModule} from '@nestjs/typeorm';
import {ConfigModule} from '../../config/config.module';
import HttpConfigService from '../../config/http.config.service';
import { ExampleEntity } from './example.entity';
@Module({
    imports: [
        // 此模块使用 forFeature() 方法定义在当前范围中注册哪些存储库。
        // 这样，我们就可以使用 @InjectRepository()装饰器将 ExampleRepository 注入到 ExampleService 中
        TypeOrmModule.forFeature([ExampleEntity], 'batonConnection'),
        HttpModule.registerAsync({
            imports: [ConfigModule],
            useExisting: HttpConfigService,
        }),
    ],
    controllers: [ExampleController],
    providers: [ExampleService],
})
// 注入中间件，需要实现NestModule方法
export default class ExampleModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer.apply(LoggerMiddleware).forRoutes(ExampleController);
    }
}

然后在service文件中定义entity所使用的库：

@Injectable()
export class ExampleService {
    constructor(
                @InjectRepository(ExampleEntity, 'batonConnection')
                private readonly exampleRepository: Repository<ExampleEntity>,
                private readonly httpService: HttpService,
                ) {
    }
}

这样，就可以在service中直接使用定义的库了！