Dependency injection hoạt động như thế nào trong NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** là một pattern cốt lõi của NestJS, trong đó framework **tự động tạo và cung cấp** các dependency mà một class cần, thay vì class tự khởi tạo chúng. Bạn khai báo những gì bạn cần trong constructor, và NestJS cung cấp chúng — dẫn đến code lỏng lẻo, dễ test.

## Cách hoạt động: khai báo trong constructor

```ts
@Injectable()
export class UsersService {
  // khai báo dependency như các tham số constructor — Nest inject chúng
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // bạn KHÔNG BAO GIỜ viết `new DatabaseService()` — Nest tạo và cung cấp nó
}
```

Nest đọc các kiểu tham số của constructor, tra cứu các provider đã đăng ký tương ứng, tạo chúng (nếu chưa có), và truyền chúng vào — tự động resolve toàn bộ đồ thị dependency.

## Luồng DI

```text
1. Một class được đánh dấu @Injectable() → nó là một provider
2. Provider được đăng ký trong mảng `providers` của một module
3. Một class khác khai báo nó như một tham số constructor
4. IoC container của NestJS resolve và INJECT instance tự động
```

## Đăng ký và resolve

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // đăng ký tất cả provider
  controllers: [UsersController],
})
export class UsersModule {}
// container của Nest giờ biết cách dựng từng cái và inject chúng vào nơi cần
```

## Tại sao DI có giá trị

```text
✓ Lỏng lẻo — class phụ thuộc vào TRỪU TƯỢNG, không phải tự dựng dependency cụ thể
✓ Dễ test — inject các dependency GIẢ (mock) trong test dễ dàng (không cần DB thật)
✓ Tái sử dụng — một instance dùng chung (singleton) cho cả ứng dụng
✓ Dễ bảo trì — thay đổi một cài đặt ở một nơi (đăng ký trong module)
```

## Khả năng test — lợi ích then chốt

```ts
// trong test, cung cấp một DatabaseService giả — không cần database thật
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject một mock
  ],
}).compile();
```

Vì class không tự dựng các dependency của nó, bạn có thể thay bằng mock để test — DI làm cho các ứng dụng NestJS rất dễ test.

## Inject các giá trị không phải class

```ts
// dùng injection token cho config/giá trị, không chỉ class
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## Tại sao điều này quan trọng

Dependency injection là pattern nền tảng làm nền cho toàn bộ kiến trúc NestJS — đó là cách controller lấy service, service lấy repository và các service khác, và toàn bộ ứng dụng được kết nối với nhau.

Hiểu nó là thiết yếu vì gần như mọi class NestJS đều tham gia vào DI: bạn khai báo dependency trong constructor và IoC container của framework resolve và cung cấp chúng tự động, loại bỏ việc khởi tạo thủ công và sự phụ thuộc chặt.

Các lợi ích là đáng kể và trung tâm với lý do NestJS được coi trọng: **lỏng lẻo** (phụ thuộc vào trừu tượng), **khả năng test** (inject mock thay vì dependency thật — làm cho unit testing kỹ lưỡng trở nên dễ dàng), tái sử dụng (singleton dùng chung), và dễ bảo trì.

DI được mượn từ các framework như Angular và Spring, và nắm vững nó — cách khai báo, đăng ký, inject, và mock dependency — là cần thiết để xây dựng các ứng dụng NestJS có cấu trúc tốt, dễ test và là một trong những khái niệm quan trọng nhất cần hiểu sâu trong framework.