Bạn có hai đoạn code làm gần y hệt nhau: cùng một trình tự các bước, chỉ khác nhau ở một hai chỗ ở giữa. Bạn copy đoạn thứ nhất, sửa vài dòng, thành đoạn thứ hai. Rồi trình tự chung ấy cần đổi, và bạn phải nhớ sửa ở cả hai nơi. Template Method sinh ra để dập đúng cơn đau này: giữ trình tự chung ở một chỗ duy nhất, chỉ cho phép thay phần khác biệt.
Template Method là gì
Template Method (tạm dịch: phương thức khuôn mẫu) là một mẫu thuộc nhóm hành vi (behavioral). Nó định nghĩa bộ khung của một thuật toán trong một method ở lớp cha, nhưng để cho lớp con override một số bước cụ thể mà không làm thay đổi cấu trúc chung của thuật toán.
Cái method giữ khung đó gọi là template method. Nó gọi lần lượt các bước con theo thứ tự cố định. Một số bước lớp cha cài sẵn (dùng chung cho mọi lớp con), một số bước để trống (abstract) buộc lớp con phải điền vào.
Hình dung một công thức nấu ăn. Quy trình pha đồ uống nóng luôn có khung giống nhau: đun nước, cho nguyên liệu vào, rót ra cốc, thêm topping. Cà phê và trà đi qua đúng bốn bước đó theo đúng thứ tự đó. Chỉ có bước "cho nguyên liệu" là khác: một bên là bột cà phê, một bên là lá trà. Khung là chung; chi tiết vài bước là riêng. Template Method chính là đóng gói cái khung chung ấy lại, chừa chỗ cho từng loại đồ uống điền phần của mình.
Vấn đề nó giải quyết
Giả sử bạn viết pipeline xử lý báo cáo. Bước nào cũng theo trình tự: đọc dữ liệu vào (load), xử lý (process), rồi lưu kết quả (save). Bạn có loại báo cáo tính tổng, loại báo cáo viết hoa. Nếu viết tách rời, hai class sẽ lặp lại y nguyên phần load và save, chỉ khác ở process:
# Không có Template Method: mỗi class tự lặp lại cả khung
class SumPipeline:
def run(self, raw):
data = [x.strip() for x in raw.split(",")] # lặp
result = f"Tong = {sum(int(x) for x in data)}"
return f"Da luu: {result}" # lặp
class UpperPipeline:
def run(self, raw):
data = [x.strip() for x in raw.split(",")] # lặp y hệt
result = " ".join(x.upper() for x in data)
return f"Da luu: {result}" # lặp y hệt
Phần load và save bị chép ra hai chỗ. Ngày mai bạn cần đổi định dạng save, hoặc thêm bước validate trước khi process, bạn phải sửa ở mọi class. Càng nhiều loại báo cáo, càng nhiều bản sao của cùng một khung, càng dễ quên một chỗ. Cái lặp ở đây không phải lặp một dòng, mà lặp cấu trúc của cả thuật toán.
Cách hoạt động
Template Method gom cái khung load -> process -> save vào một method run() ở lớp cha. run() gọi ba bước theo thứ tự cố định. Bước load và save lớp cha cài sẵn (dùng chung); bước process để abstract, buộc mỗi lớp con tự điền. Lớp con chỉ viết phần khác biệt, không đụng vào run():
from abc import ABC, abstractmethod
class ReportPipeline(ABC):
def run(self, raw): # KHUNG cố định: đây là template method
data = self.load(raw)
result = self.process(data)
return self.save(result)
def load(self, raw): # bước chung, mặc định
return [x.strip() for x in raw.split(",")]
@abstractmethod
def process(self, data): ... # bước riêng, lớp con bắt buộc override
def save(self, result): # bước chung, mặc định
return f"Da luu: {result}"
class SumPipeline(ReportPipeline):
def process(self, data):
return f"Tong = {sum(int(x) for x in data)}"
class UpperPipeline(ReportPipeline):
def process(self, data):
return " ".join(x.upper() for x in data)
print(SumPipeline().run("1, 2, 3, 4"))
print(UpperPipeline().run("cat, dog, fish"))
Để ý hai dòng kết quả: cả hai đều đi qua đúng khung load -> process -> save (cùng bước tách dấu phẩy, cùng tiền tố "Da luu:"), chỉ khác ở phần process. Khung được viết một lần trong run(); giờ muốn thêm bước validate hay đổi cách save, bạn sửa đúng một chỗ ở lớp cha, mọi pipeline con hưởng theo.
Đây chính là nguyên tắc Hollywood: "Don't call us, we'll call you" (đừng gọi chúng tôi, chúng tôi sẽ gọi bạn). Lớp con không chủ động điều khiển luồng; nó chỉ cung cấp các bước, còn run() ở lớp cha mới là người gọi các bước đó vào đúng lúc. Quyền điều khiển nằm ở khung, không nằm ở lớp con. Điều này ngược với cách dùng thư viện thông thường (bạn gọi hàm của thư viện); ở đây khung gọi ngược lại code của bạn.
before_save mặc định không làm gì; pipeline nào cần ghi log trước khi lưu thì override, số còn lại kệ nó. Hook giúp khung linh hoạt mà vẫn giữ thứ tự cố định.Template Method và Strategy
Hai pattern này giải cùng một loại bài toán (thay đổi một phần hành vi trong khi giữ phần còn lại) nhưng bằng hai cơ chế đối lập:
- Template Method dùng kế thừa (inheritance). Phần thay đổi là một method được override ở lớp con. Cấu trúc cố định lúc biên dịch: chọn hành vi nào là chọn tạo instance của lớp con nào. Quan hệ "is-a".
- Strategy dùng composition. Phần thay đổi là một đối tượng riêng được ghép vào và có thể tráo lúc chạy (runtime). Quan hệ "has-a". Đây đúng là mẫu tôi đã nhắc tới ở bài Program to interface & Composition over inheritance qua ví dụ con vịt ghép hành vi bay và kêu.
Nói ngắn: Template Method sửa vài bước bên trong một khung cố định bằng cách kế thừa; Strategy tráo cả một hành vi bằng cách cắm đối tượng khác vào. Nếu bạn cần đổi hành vi ngay trong lúc chương trình chạy, hoặc muốn một đối tượng đổi cách cư xử mà không đẻ ra một lớp con mới, Strategy hợp hơn. Nếu bạn có một trình tự chung rõ ràng và chỉ vài bước biến thiên cố định theo từng loại, Template Method gọn hơn.
Khi nào nên dùng, khi nào không
Nên dùng khi:
- Nhiều biến thể chia sẻ cùng một trình tự các bước, chỉ khác nhau ở một vài bước. Template Method gom trình tự chung về một chỗ, xoá code lặp cấu trúc.
- Bạn muốn khoá cứng thứ tự của thuật toán để lớp con không phá vỡ được, chỉ cho chúng điền vào các chỗ trống đã định.
Không nên dùng khi:
- Chỉ có một biến thể. Chưa có hai cài đặt khác nhau thì chưa có "phần chung" và "phần riêng" để tách. Cứ viết thẳng, đừng dựng lớp cha trừu tượng cho vui.
- Cần đổi hành vi lúc chạy. Kế thừa cố định lựa chọn từ lúc tạo đối tượng; muốn tráo hành vi động thì dùng Strategy.
run() làm vỡ trình tự mà khung cố giữ). Giữ khung nông, chỉ để abstract những bước thật sự cần biến thiên, và đừng cho lớp con động vào chính template method.Trong hệ thống thật
Chỗ tôi gặp Template Method dày đặc nhất là đám job ETL. Một hệ thống dữ liệu có vài chục job kéo số về kho, và job nào cũng đi đúng một khung: setup -> fetch -> transform -> load -> teardown. Lớp job cơ sở giữ trọn khung đó: mở kết nối, lấy dữ liệu nguồn, biến đổi, ghi vào bảng đích, đóng kết nối và ghi lại số dòng cùng thời gian chạy. Mỗi job con chỉ override đúng một bước transform, vì đó mới là chỗ thật sự khác nhau giữa job đơn hàng và job tồn kho. Hôm có yêu cầu "mọi job phải ghi log vào bảng audit", tôi sửa một chỗ ở lớp cơ sở là cả vài chục job có ngay, không phải mở từng file.
Không cần đi đâu xa, thư viện chuẩn của Python đã có một Template Method bạn dùng hằng ngày: unittest.TestCase. Bạn viết method test, còn khung setUp -> test_* -> tearDown do framework giữ và gọi:
import io
import unittest
class BaseApiTest(unittest.TestCase):
def setUp(self):
print("setUp: mo ket noi DB")
def tearDown(self):
print("tearDown: rollback va dong ket noi")
class TestUserApi(BaseApiTest):
def test_get_user(self):
print(" test_get_user: chay phan viec cua ban")
def test_create_user(self):
print(" test_create_user: chay phan viec cua ban")
suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestUserApi)
unittest.TextTestRunner(stream=io.StringIO()).run(suite)
Để ý hai điều trong output. Thứ nhất, setUp và tearDown bọc quanh từng method test chứ không chạy một lần cho cả class, và bạn không gọi chúng ở đâu cả. Thứ hai, ngay cả thứ tự hai test cũng không do bạn định đoạt: unittest mặc định sắp theo tên nên test_create_user chạy trước test_get_user. Bạn chỉ điền phần ruột, khung là của framework.
Vài chỗ khác cùng một dạng:
- Lớp base cho API client. Khung
build_request -> send -> handle_error -> parsenằm ở lớp cha: dựng header xác thực, gửi kèm timeout và retry, gặp mã lỗi thì ném exception thống nhất. Client con của từng dịch vụ chỉ đổi bướcparse, vì mỗi API trả về một hình dạng JSON khác nhau. - Importer nhiều định dạng file. Nhập CSV, Excel hay JSON thì vẫn là
mở file -> đọc từng bản ghi -> validate -> ghi DB -> báo cáo số dòng lỗi. Chỉ bước đọc bản ghi là khác nhau theo định dạng, phần validate và ghi DB dùng chung để mọi đường nhập liệu chịu cùng một bộ luật. - Hook vòng đời của framework. Một
save()ở lớp model thường không chỉ ghi xuống DB: nó gọipre_save, ghi, rồi gọipost_save. Hai hook đó mặc định không làm gì, bạn override khi cần chuẩn hoá dữ liệu trước khi ghi hoặc đẩy event sau khi ghi.
Điểm chung của cả bốn ví dụ: khung nằm ở nơi khác, bạn chỉ điền vào chỗ trống. Đó chính là nguyên tắc Hollywood ở trên, phát biểu theo góc nhìn người viết code: bạn không gọi khung, khung gọi bạn.
Trade-off
Được:
- Thứ tự các bước được bảo đảm. Trình tự nằm trong template method ở lớp cha, lớp con không xếp lại được. Không còn cảnh một biến thể lỡ tay ghi DB trước khi validate.
- Phần chung viết một lần. Mọi thứ lặp lại giữa các biến thể (mở kết nối, ghi log, dọn dẹp) sống ở đúng một chỗ, sửa một lần là cả họ hưởng.
- Lớp con gọn và đúng trọng tâm. Mở file lớp con ra là thấy ngay phần thật sự khác biệt, không bị chôn giữa đống code khung lặp lại.
- Dễ bắt buộc các bước không được thiếu. Khai báo
@abstractmethodlà lớp con quên cài đặt sẽ nổ ngay lúc tạo đối tượng, chứ không âm thầm bỏ qua một bước.
Phải trả giá:
- Ràng buộc bằng kế thừa nên chỉ đổi được lúc viết code. Chọn biến thể nào là chọn tạo instance của lớp con nào; không tráo được hành vi lúc chạy như Strategy.
- Fragile base class. Lớp con bám vào chi tiết cài đặt của lớp cha, nên một thay đổi tưởng vô hại ở lớp cha (đổi kiểu dữ liệu truyền giữa hai bước chẳng hạn) có thể làm vỡ những lớp con mà bạn không hề mở ra xem.
- Khung cứng gây khó cho biến thể lệch chuẩn. Gặp một trường hợp cần bỏ hẳn một bước hoặc đảo thứ tự, bạn chỉ còn hai đường xấu: lách bằng cờ điều kiện nhét vào lớp cha, hoặc override luôn cả template method và thế là mất sạch cái đang muốn giữ.
- Lần vết luồng chạy mệt. Nhiều tầng kế thừa thì để hiểu một lần chạy bạn phải nhảy qua bốn năm file mới ghép đủ mặt các bước, trong khi với composition thì chỉ cần nhìn xem đối tượng nào được cắm vào.
Tóm tắt
- Template Method đặt khung của thuật toán vào một method ở lớp cha; method này gọi các bước theo thứ tự cố định, lớp con chỉ override vài bước.
- Nó gom trình tự chung về một chỗ, xoá việc lặp lại cấu trúc thuật toán ở nhiều lớp.
- Tinh thần là nguyên tắc Hollywood: khung gọi bước của lớp con, không phải lớp con điều khiển khung.
- Nó dùng kế thừa, đối lập với Strategy (dùng composition, tráo hành vi lúc chạy).
- Dùng khi nhiều biến thể chia sẻ cùng trình tự; tránh khi chỉ có một biến thể hoặc cần đổi hành vi động.
Nguồn tham khảo
- Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương Template Method, kèm phần bàn về "the Hollywood principle".
- Kai