【NestJS】08 提供者（Provider）完全指南

1
@Module({
2
  providers: [UserService], // 注册提供者
3
})
4
export class UserModule {}

1
@Module({
2
  providers: [UserService], // 简写形式
3
})
4
export class UserModule {}

1
@Module({
2
  providers: [
3
    {
4
      provide: UserService,    // token（标识符）
5
      useClass: UserService,   // 使用的具体类
6
    },
7
  ],
8
})
9
export class UserModule {}

1
// 定义抽象类作为契约
2
abstract class IUserRepository {
3
  abstract findAll(): Promise<User[]>;
4
  abstract findById(id: string): Promise<User | null>;
5
}
6

7
// 具体实现
8
@Injectable()
9
export class UserRepository implements IUserRepository {
10
  async findAll(): Promise<User[]> {
11
    // 数据库查询逻辑
12
    return [];
13
  }
14

15
  async findById(id: string): Promise<User | null> {
16
    return null;
17
  }
18
}
19

20
// 模块注册
21
@Module({
22
  providers: [
23
    {
24
      provide: IUserRepository,      // 使用抽象类作为 token
25
      useClass: UserRepository,      // 绑定具体实现
26
    },
27
  ],
28
})
29
export class UserModule {}

1
@Injectable()
2
export class UserService {
3
  constructor(
4
    @Inject(IUserRepository)  // 注入抽象类
5
    private readonly userRepository: IUserRepository,
6
  ) {}
7

8
  async getAllUsers() {
9
    return this.userRepository.findAll();
10
  }
11
}

1
@Module({
2
  providers: [
3
    {
4
      provide: 'DATABASE_CONFIG',  // 字符串 token
5
      useValue: {                  // 直接提供值
6
        host: 'localhost',
7
        port: 27017,
8
        database: 'wwzhidao',
9
      },
10
    },
11
  ],
12
})
13
export class DatabaseModule {}

1
@Injectable()
2
export class DatabaseService {
3
  constructor(
4
    @Inject('DATABASE_CONFIG')
5
    private readonly config: DatabaseConfig,
6
  ) {
7
    console.log(`连接到: ${this.config.host}:${this.config.port}`);
8
  }
9
}

1
import axios from 'axios';
2

3
@Module({
4
  providers: [
5
    {
6
      provide: 'HTTP_CLIENT',
7
      useValue: axios.create({
8
        baseURL: 'https://api.example.com',
9
        timeout: 5000,
10
      }),
11
    },
12
  ],
13
})
14
export class HttpModule {}

1
@Module({
2
  providers: [
3
    {
4
      provide: 'DATABASE_CONNECTION',
5
      useFactory: (configService: ConfigService) => {
6
        const dbUrl = configService.get('DATABASE_URL');
7
        return createConnection(dbUrl);  // 根据配置创建连接
8
      },
9
      inject: [ConfigService], // 声明依赖
10
    },
11
  ],
12
})
13
export class DatabaseModule {}

1
{
2
  provide: 'USER_REPOSITORY',
3
  useFactory: (configService: ConfigService, logger: Logger) => {
4
    const dbType = configService.get('DB_TYPE');
5

6
    if (dbType === 'mongodb') {
7
      return new MongoUserRepository(logger);
8
    } else if (dbType === 'postgres') {
9
      return new PostgresUserRepository(logger);
10
    }
11

12
    throw new Error(`不支持的数据库类型: ${dbType}`);
13
  },
14
  inject: [ConfigService, Logger], // 按顺序注入
15
}

1
{
2
  provide: 'ASYNC_CONFIG',
3
  useFactory: async (configService: ConfigService) => {
4
    const remoteConfig = await fetch('https://api.example.com/config')
5
      .then(res => res.json());
6

7
    return {
8
      ...configService.get('localConfig'),
9
      ...remoteConfig,
10
    };
11
  },
12
  inject: [ConfigService],
13
}

1
@Module({
2
  providers: [
3
    {
4
      provide: 'USER_REPOSITORY',
5
      useClass: process.env.NODE_ENV === 'test'
6
        ? MockUserRepository      // 测试环境
7
        : UserRepository,         // 生产环境
8
    },
9
  ],
10
})
11
export class UserModule {}

1
@Module({
2
  providers: [
3
    {
4
      provide: 'API_KEY',
5
      useValue: process.env.API_KEY || 'default-api-key',
6
    },
7
  ],
8
})
9
export class ConfigModule {}

1
import axios, { AxiosInstance } from 'axios';
2

3
@Module({
4
  providers: [
5
    {
6
      provide: 'HTTP_CLIENT',
7
      useFactory: (configService: ConfigService): AxiosInstance => {
8
        return axios.create({
9
          baseURL: configService.get('API_BASE_URL'),
10
          timeout: 5000,
11
          headers: {
12
            'X-API-Key': configService.get('API_KEY'),
13
          },
14
        });
15
      },
16
      inject: [ConfigService],
17
    },
18
  ],
19
  exports: ['HTTP_CLIENT'],
20
})
21
export class HttpModule {}

1
@Module({
2
  providers: [
3
    UserService,
4
    {
5
      provide: 'UserServiceAlias',  // 别名
6
      useExisting: UserService,     // 指向已存在的提供者
7
    },
8
  ],
9
})
10
export class UserModule {}

1
// ✅ 推荐：简单直接
2
@Module({
3
  providers: [UserService],
4
})
5

6
// ❌ 避免：不必要的复杂化
7
@Module({
8
  providers: [
9
    { provide: UserService, useFactory: () => new UserService() },
10
  ],
11
})

1
// ✅ 推荐：依赖抽象
2
abstract class IUserRepository {
3
  abstract findAll(): Promise<User[]>;
4
}
5

6
@Injectable()
7
export class UserService {
8
  constructor(
9
    @Inject(IUserRepository)
10
    private readonly repository: IUserRepository,
11
  ) {}
12
}

1
// ✅ 推荐：默认单例（95% 的场景）
2
@Injectable()
3
export class UserService {}
4

5
// ⚠️ 谨慎使用：请求作用域
6
@Injectable({ scope: Scope.REQUEST })
7
export class RequestLoggerService {}

1
// ✅ 推荐：使用常量
2
export const DATABASE_CONFIG = 'DATABASE_CONFIG';
3

4
@Module({
5
  providers: [
6
    { provide: DATABASE_CONFIG, useValue: { /* ... */ } },
7
  ],
8
})
9

10
// ❌ 避免：直接使用字符串（容易拼写错误）
11
@Module({
12
  providers: [
13
    { provide: 'DATABASE_CONFIG', useValue: { /* ... */ } },
14
  ],
15
})

1
@Module({
2
  providers: [SharedService],
3
  exports: [SharedService],  // 导出供其他模块使用
4
})
5
export class SharedModule {}

1
/**
2
 * 用户服务
3
 *
4
 * 提供用户相关的业务逻辑，包括：
5
 * - 用户查询
6
 * - 用户创建
7
 * - 用户更新
8
 *
9
 * @remarks 该服务使用单例模式
10
 */
11
@Injectable()
12
export class UserService {}