Mẫu Template Method (Template Method pattern) giải thích kèm ví dụ

Mục đích và vấn đề cần giải quyết

Mục đích: định nghĩa bộ khung của một thuật toán trong một thao tác, hoãn một số bước cho các lớp con. Mẫu Template Method cho phép lớp con định nghĩa lại một số bước của thuật toán mà không thay đổi cấu trúc của nó. Đây là một trong các mẫu hành vi trong cuốn sách của nhóm Gang of Four (GoF).

Hãy hình dung một công cụ báo cáo xuất dữ liệu ra CSV và JSON. Cả hai bộ xuất làm cùng những việc theo cùng thứ tự: tải các dòng dữ liệu, kiểm tra xem có dòng nào không, định dạng chúng và thêm phần chân trang với số dòng. Chỉ phần định dạng là khác nhau. Nếu viết riêng từng bộ xuất, các bước chung bị sao chép, và một lần sửa ở bộ này (ví dụ xử lý tốt hơn kết quả rỗng) rất dễ bị quên ở bộ kia.

Với mẫu Template Method, lớp cơ sở Exporter chứa phương thức export với chuỗi bước cố định. Các bước thay đổi là phương thức trừu tượng. CsvExporter và JsonExporter chỉ cần triển khai những bước đó.

Cấu trúc và các thành phần tham gia

Thiết kế này đảo ngược quyền điều khiển: lớp cơ sở gọi các phương thức của lớp con, chứ không phải ngược lại. Đôi khi người ta gọi đây là nguyên lý Hollywood: "đừng gọi chúng tôi, chúng tôi sẽ gọi bạn".

Triển khai bằng TypeScript

export là template method. format là một thao tác nguyên thủy mà lớp con phải triển khai, còn header là một hook có mặc định để trống.

type Row = { name: string; score: number };

abstract class Exporter {
  // The template method: fixed order of steps
  export(rows: Row[]): string {
    if (rows.length === 0) return "no data";
    const lines = [this.header(), this.format(rows), "rows: " + rows.length];
    return lines.filter((line) => line !== "").join("\n");
  }

  protected abstract format(rows: Row[]): string; // required step
  protected header(): string { return ""; }       // hook: optional step
}

class CsvExporter extends Exporter {
  protected header() { return "name,score"; }
  protected format(rows: Row[]) {
    return rows.map((r) => r.name + "," + r.score).join("\n");
  }
}

class JsonExporter extends Exporter {
  protected format(rows: Row[]) {
    return JSON.stringify(rows);
  }
}

const rows = [{ name: "Ana", score: 9 }, { name: "Ben", score: 7 }];
console.log(new CsvExporter().export(rows));
// name,score
// Ana,9
// Ben,7
// rows: 2
console.log(new JsonExporter().export(rows));
// [{"name":"Ana","score":9},{"name":"Ben","score":7}]
// rows: 2
console.log(new JsonExporter().export([])); // no data

Việc kiểm tra dữ liệu rỗng và phần chân trang nằm ở một chỗ duy nhất. Một bộ xuất XML mới chỉ cần triển khai format là có sẵn phần còn lại.

Cùng ý tưởng bằng kết hợp (composition)

Kế thừa không phải là cách duy nhất. Bạn có thể truyền các bước thay đổi dưới dạng hàm, khiến mẫu này trở thành họ hàng gần của mẫu Strategy và tránh được cây phân cấp lớp:

type Row = { name: string; score: number };
type Steps = { format: (rows: Row[]) => string; header?: () => string };

function exportRows(rows: Row[], steps: Steps): string {
  if (rows.length === 0) return "no data";
  const lines = [steps.header?.() ?? "", steps.format(rows), "rows: " + rows.length];
  return lines.filter((line) => line !== "").join("\n");
}

console.log(exportRows([{ name: "Ana", score: 9 }], { format: (r) => r[0].name }));
// Ana
// rows: 1

Nên dùng dạng này khi các bước nhỏ và bạn không cần trạng thái dùng chung trong lớp cơ sở, hoặc khi một bộ xuất cần kết hợp các bước từ nhiều nguồn.

Khi nào nên dùng và khi nào không

• Nên dùng khi nhiều lớp chạy cùng một thuật toán và chỉ khác nhau ở vài bước, và bạn muốn loại bỏ phần mã trùng lặp.
• Nên dùng trong các framework cần kiểm soát thứ tự thao tác nhưng vẫn cho người dùng tùy biến từng bước, như setup và teardown trong kiểm thử.
• Nên dùng hook để cung cấp các điểm mở rộng tùy chọn mà không bắt mọi lớp con phải triển khai.
• Không nên dùng khi các biến thể lớn hoặc cần thay đổi lúc chạy. Mẫu Strategy, dùng kết hợp, linh hoạt hơn.
• Tránh cây phân cấp template method quá sâu. Khi lớp con ghi đè các bước của lớp con của lớp con, luồng chạy trở nên khó theo dõi.

Ứng dụng trong thực tế

• AbstractList của Java: bạn triển khai get(int) và size(), còn lớp cơ sở cung cấp việc duyệt, indexOf, contains và nhiều phương thức khác xây dựng trên hai phương thức đó.
• InputStream của Java: lớp con triển khai read() đọc từng byte, còn lớp cơ sở triển khai read(byte[], int, int) bằng cách gọi nó (lớp con có thể ghi đè để chạy nhanh hơn).
• Các framework kiểm thử: JUnit, unittest của Python và những framework khác gọi setUp, phương thức kiểm thử và tearDown theo thứ tự cố định, và bạn ghi đè những bước mình cần.
• Các framework giao diện có phương thức vòng đời, như componentDidMount trong lớp component của React, gọi các phương thức của bạn tại những thời điểm cố định trong thuật toán của chúng.

Các mẫu liên quan