Các design pattern phổ biến trong Node.js là gì?

Question

IT Interview Practice · Accepted Answer

Node.js dựa vào một số ít design pattern hợp với hệ thống module, mô hình bất đồng bộ và I/O dạng stream của nó. Những pattern phổ biến nhất mà mọi lập trình viên backend nên nhận ra:

## Nhóm khởi tạo (Creational)

- **Module pattern** — mỗi file là một scope riêng; bạn phơi bày API công khai qua `module.exports` / `export`, giữ phần nội bộ private. Đây là nền tảng tổ chức code trong Node.
- **Singleton** — export của một module được **cache**, nên export một instance sẽ cho mọi nơi import cùng một object. Hoàn hảo cho một DB pool hoặc config.

```js
// db.js — mọi `require("./db")` đều nhận cùng pool này (singleton qua module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — một hàm tạo và trả về object, giấu logic khởi tạo và cho phép hoán đổi cài đặt.

```js
function createLogger(kind) {
  return kind === "json" ? new JsonLogger() : new TextLogger();
}
```

## Nhóm hành vi (Behavioral)

- **Observer / EventEmitter** — pattern bất đồng bộ cốt lõi của Node: phát các event có tên, gắn listener. `EventEmitter`, streams, và hầu hết module core dùng nó.

```js
const { EventEmitter } = require("node:events");
const bus = new EventEmitter();
bus.on("order:paid", (o) => sendReceipt(o));
bus.emit("order:paid", order);
```

- **Middleware** — một pipeline các hàm, mỗi hàm nhận `(ctx, next)`, được Express/Koa phổ biến hóa. Rất hợp cho các mối quan tâm xuyên suốt (auth, logging, validation).

```js
app.use((req, res, next) => { req.startedAt = Date.now(); next(); });
```

- **Strategy** — chọn thuật toán lúc runtime (vd. chọn nhà cung cấp thanh toán hoặc một chiến lược hashing sau cùng một interface).

## Nhóm cấu trúc (Structural)

- **Adapter** — bọc một API bên thứ ba trong interface của riêng bạn để đổi nhà cung cấp mà không đụng nơi gọi.
- **Streams (pipeline)** — ghép các stage readable → transform → writable để xử lý dữ liệu tăng dần kèm backpressure, thay vì buffer tất cả trong bộ nhớ.

```js
const { pipeline } = require("node:stream/promises");
await pipeline(fs.createReadStream("in"), gzip(), fs.createWriteStream("out.gz"));
```

- **Dependency Injection** — truyền các cộng tác viên (db, logger, client) vào một module thay vì import trực tiếp; giúp code dễ test và tách rời. Framework như **NestJS** tích hợp sẵn DI; bạn cũng có thể làm thủ công qua tham số hàm/constructor.

## Nguyên tắc chọn

| Nhu cầu | Pattern |
|---|---|
| Một tài nguyên dùng chung | Singleton (module cache) |
| Tạo object, giấu `new` | Factory |
| Phản ứng với event bất đồng bộ | Observer / EventEmitter |
| Logic request xuyên suốt | Middleware |
| Xử lý dữ liệu lớn an toàn | Streams / pipeline |
| Phụ thuộc dễ test, tách rời | Dependency Injection |

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

Pattern là một vốn từ chung: nói "config là singleton cache theo module" hay "auth là middleware" truyền đạt một thiết kế chỉ trong vài từ. Bản thân core của Node (EventEmitter, streams, hệ thống module) được xây từ những pattern này, nên nhận ra chúng giúp bạn đọc framework và cấu trúc service của mình. Người phỏng vấn dùng câu này để kiểm tra bạn không chỉ nối callback tùy tiện, mà chọn đúng pattern phù hợp — và hiểu đánh đổi của nó, như singleton làm state toàn cục khó test hơn.

Nhu cầu	Pattern
Một tài nguyên dùng chung	Singleton (module cache)
Tạo object, giấu `new`	Factory
Phản ứng với event bất đồng bộ	Observer / EventEmitter
Logic request xuyên suốt	Middleware
Xử lý dữ liệu lớn an toàn	Streams / pipeline
Phụ thuộc dễ test, tách rời	Dependency Injection

Nhóm khởi tạo (Creational)

Nhóm hành vi (Behavioral)

Nhóm cấu trúc (Structural)

Nguyên tắc chọn

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

Câu hỏi liên quan