Hành viBehavioral

Template Methodaka Hollywood Principle

Cố định khung các bước của một thuật toán, chỉ để trống vài bước cho lớp con hoặc callback điền vào.Fix the skeleton of an algorithm and leave a few steps for subclasses or callbacks to fill in.

Độ khóDifficulty: DễEasy
Mức phổ biếnUsage: Mức phổ biếnUsage 4/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Quy trình làm phở ở một chuỗi quán: ninh nước dùng → trụng bánh → xếp thịt → chan nước → thêm rau. Quy trình đó cố định ở mọi chi nhánh. Chỉ bước 'xếp thịt' là khác: phở bò tái, phở gà, phở nạm. Đầu bếp không được đổi thứ tự — chỉ được điền vào chỗ trống.A pho chain's recipe: simmer broth → blanch noodles → add meat → pour broth → add herbs. The process is fixed in every branch. Only 'add meat' varies: rare beef, chicken, brisket. Cooks can't reorder the steps — they only fill in the blank.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Mỗi sáng hệ thống phải đối soát file quyết toán từ VNPay, Momo, ZaloPay. Ba class import copy y hệt nhau: đọc file, bỏ dòng header, parse, lọc dòng lỗi, lưu DB, ghi log báo cáo — chỉ khác đúng bước parse. Sửa cách ghi log là phải sửa ba nơi, và một nơi quên lọc số tiền âm.Every morning the system reconciles settlement files from VNPay, Momo and ZaloPay. Three import classes are copy-paste: read the file, skip headers, parse, filter bad rows, save to DB, log a report — differing only in the parse step. Changing the logging means three edits, and one of them forgets to filter negative amounts.

Với Template MethodWith Template Method

Đưa khung chung vào một template method (final) ở lớp cha: nó gọi các bước theo thứ tự cố định. Bước thay đổi là method abstract (parse), bước tuỳ chọn là hook có mặc định (headerLines). Lớp con chỉ điền chỗ trống. Spring dùng biến thể callback: JdbcTemplate giữ khung, bạn chỉ đưa RowMapper. Go không có kế thừa nên dùng hàm + interface nhỏ hoặc tham số hàm.Move the shared skeleton into a (final) template method in the base class: it calls the steps in a fixed order. Varying steps are abstract methods (parse); optional steps are hooks with defaults (headerLines). Subclasses only fill the blanks. Spring uses a callback variant: JdbcTemplate owns the skeleton and you just pass a RowMapper. Go has no inheritance, so it uses a function + small interface or function parameters.

Thành phần tham giaParticipants

AbstractClass: Chứa template method (final) và định nghĩa các bước abstract/hook.Holds the (final) template method and declares abstract steps/hooks.
Template method: Method cố định thứ tự các bước; không cho lớp con override.The method fixing the order of steps; subclasses can't override it.
ConcreteClass: Điền các bước abstract, có thể override hook.Fills in the abstract steps and may override hooks.
Client: Gọi template method, không quan tâm lớp con nào.Calls the template method, regardless of the subclass.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Job 6h sáng gọi importFile() trên một SettlementImporter (thực chất là VnpayImporter).The 6 am job calls importFile() on a SettlementImporter (actually a VnpayImporter).

← →

console

1> vnpay.importFile(vnpay-2026-10-10.csv)

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.pay.recon;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class SettlementImporter {
    private final Logger log = LoggerFactory.getLogger(getClass());
    private final SettlementRepository repo;

    protected SettlementImporter(SettlementRepository repo) {
        this.repo = repo;
    }

    // The template method: final, so subclasses can't reorder the steps
    public final ImportReport importFile(Path file) {1
        List<String> lines = readLines(file);
        log.info("[{}] importing {} ({} lines)", provider(), file, lines.size());
        List<Settlement> rows = lines.stream()
            .skip(headerLines())
            .map(this::parse)2
            .filter(this::accept)
            .toList();
        repo.saveAll(rows);
        return new ImportReport(provider(), lines.size(), rows.size());
    }

    protected abstract String provider();
    protected abstract Settlement parse(String line);   // varies per provider3

    protected int headerLines() { return 1; }           // hook with a default4
    protected boolean accept(Settlement s) {            // hook with a default
        return s.amount().signum() > 0;
    }

    private List<String> readLines(Path file) {
        try {
            return Files.readAllLines(file);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package recon

import (
	"bufio"
	"context"
	"fmt"
	"io"
	"time"
)

type Settlement struct {
	Ref    string
	Amount int64
	Day    time.Time
}

type Report struct {
	Provider        string
	Lines, Imported int
}

// Parser holds the steps that vary — a small interface, not an abstract class.
type Parser interface {1
	Provider() string
	HeaderLines() int
	Parse(line string) (Settlement, error)
}

type Store interface {
	SaveAll(ctx context.Context, rows []Settlement) error
}

// Import is the template method: a plain function owning the fixed steps.
func Import(ctx context.Context, r io.Reader, p Parser, store Store) (Report, error) {2
	sc := bufio.NewScanner(r)
	var rows []Settlement
	n := 0
	for sc.Scan() {
		n++
		if n <= p.HeaderLines() {
			continue
		}
		s, err := p.Parse(sc.Text())3
		if err != nil {
			return Report{}, fmt.Errorf("%s line %d: %w", p.Provider(), n, err)4
		}
		if s.Amount > 0 {
			rows = append(rows, s)
		}
	}
	if err := sc.Err(); err != nil {
		return Report{}, err
	}
	if err := store.SaveAll(ctx, rows); err != nil {
		return Report{}, err
	}
	return Report{Provider: p.Provider(), Lines: n, Imported: len(rows)}, nil
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Java dùng kế thừa: abstract class + final template method + method abstract/hook. Go không có kế thừa: template là một hàm nhận interface (hoặc nhận func).Java uses inheritance: abstract class + final template method + abstract/hook methods. Go has no inheritance: the template is a function taking an interface (or funcs).
02Embedding trong Go KHÔNG có dynamic dispatch: method của struct được nhúng gọi lại method của chính nó, không gọi bản 'override' của struct ngoài. Đừng cố mô phỏng abstract class bằng embedding.Go embedding has NO dynamic dispatch: a method of the embedded struct calls its own methods, never the outer struct's 'override'. Don't try to emulate abstract classes with embedding.
03Spring ưa biến thể callback hơn kế thừa: JdbcTemplate, RestTemplate, TransactionTemplate nhận lambda. Go cũng thế: sort.Slice(xs, less), http.HandlerFunc là các 'bước trống' dạng hàm.Spring prefers the callback variant over inheritance: JdbcTemplate, RestTemplate, TransactionTemplate take lambdas. So does Go: sort.Slice(xs, less), http.HandlerFunc are 'blank steps' as functions.
04Java khoá thứ tự bước bằng final. Go không cần: Import là hàm package-level, không ai override được.Java locks the step order with final. Go doesn't need it: Import is a package-level function nobody can override.

Ứng dụng thực tếReal-world usage

JdbcTemplate, RestTemplate, TransactionTemplateJdbcTemplate, RestTemplate, TransactionTemplate
Spring giữ phần khung lặp lại (mở/đóng tài nguyên, xử lý exception, commit/rollback); bạn chỉ đưa callback như RowMapper, ResponseExtractor, TransactionCallback.Spring keeps the repetitive skeleton (open/close resources, exception handling, commit/rollback); you only pass callbacks like RowMapper, ResponseExtractor, TransactionCallback.
AbstractList, HttpServlet, OncePerRequestFilterAbstractList, HttpServlet, OncePerRequestFilter
HttpServlet.service() là template gọi doGet/doPost; OncePerRequestFilter.doFilter() là final và gọi doFilterInternal() mà bạn cài đặt.HttpServlet.service() is a template dispatching to doGet/doPost; OncePerRequestFilter.doFilter() is final and calls the doFilterInternal() you implement.
sort.Sort và testing trong GoGo's sort.Sort and testing
sort.Sort giữ thuật toán sắp xếp, bạn cung cấp Len/Less/Swap; go test giữ vòng đời test, bạn chỉ viết hàm TestXxx (và TestMain làm hook).sort.Sort owns the algorithm while you provide Len/Less/Swap; go test owns the test lifecycle and you just write TestXxx funcs (with TestMain as a hook).
Job đối soát, import/exportReconciliation and import/export jobs
Đối soát nhiều cổng thanh toán, import đơn từ nhiều sàn (Shopee, Lazada, Tiki) — chung quy trình, khác định dạng file.Reconciling multiple payment gateways, importing orders from many marketplaces (Shopee, Lazada, Tiki) — same flow, different file formats.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Nhiều class có cùng quy trình, chỉ khác vài bước.Several classes share the same process and differ in a few steps.
Muốn KHOÁ thứ tự bước (bảo mật, transaction, audit) để không ai làm sai.You want to LOCK the step order (security, transactions, audit) so nobody gets it wrong.
Có đoạn code mở/đóng tài nguyên lặp lại quanh một phần thay đổi (callback như JdbcTemplate).Repetitive open/close-resource code wraps one varying part (callbacks like JdbcTemplate).

Không nên dùng khiAvoid it when

Các biến thể khác nhau ở gần như mọi bước — lúc đó Strategy cho cả thuật toán hợp hơn.Variants differ in almost every step — Strategy for the whole algorithm fits better.
Cần đổi hành vi lúc chạy hoặc kết hợp nhiều biến thể — kế thừa quá cứng, hãy dùng composition.You need runtime switching or combining variants — inheritance is too rigid; use composition.

Ưu điểmPros

Loại bỏ code trùng lặp, quy trình nằm ở một chỗ.Removes duplication; the process lives in one place.
Kiểm soát chặt điểm mở rộng: chỉ những bước được phép mới thay được.Tight control over extension points: only allowed steps can vary.
Lớp con/callback ngắn, chỉ chứa phần khác biệt.Subclasses/callbacks are short, containing only the differences.

Nhược điểmCons

Dựa vào kế thừa (ở Java): lớp con gắn chặt với lớp cha, đổi lớp cha dễ làm vỡ lớp con.Relies on inheritance (in Java): subclasses are tightly bound to the base; changing it can break them.
Luồng điều khiển nhảy qua lại cha–con khó theo dõi khi có nhiều hook.Control flow bouncing between parent and child is hard to follow with many hooks.
Lớp con có thể vi phạm Liskov nếu override hook làm hỏng giả định của khung.Subclasses may violate Liskov if a hook override breaks the skeleton's assumptions.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Mô phỏng abstract class bằng embedding trong GoEmulating an abstract class with embedding in Go

Dev Java sang Go thường viết struct 'Base' có method Run gọi b.Parse, rồi nhúng Base vào VNPay và 'override' Parse. Nhưng embedding không có dynamic dispatch: bên trong Run, b là Base nên LUÔN gọi Base.Parse. Hãy để template là hàm nhận interface.Java devs moving to Go often write a 'Base' struct whose Run calls b.Parse, embed Base into VNPay and 'override' Parse. But embedding has no dynamic dispatch: inside Run, b is a Base, so it ALWAYS calls Base.Parse. Make the template a function that takes an interface.

type Base struct{}

func (b Base) Run(lines []string) {
	for _, l := range lines {
		b.Parse(l) // ❌ always Base.Parse — b is a Base, not a VNPay
	}
}
func (Base) Parse(line string) { fmt.Println("base parse") }

type VNPay struct{ Base }

func (VNPay) Parse(line string) { fmt.Println("vnpay parse") } // ❌ never called by Run

// VNPay{}.Run(lines) prints "base parse" for every line

Dễ nhầm vớiEasily confused with

Template Method vs Strategy

Template Method thay MỘT VÀI bước bằng kế thừa (hoặc callback), khung giữ nguyên. Strategy thay CẢ thuật toán bằng composition, đổi được lúc chạy.Template Method varies A FEW steps via inheritance (or callbacks) while the skeleton stays. Strategy swaps the WHOLE algorithm via composition, switchable at runtime.

Template Method vs Factory Method

Factory Method thường là MỘT bước trong template method — bước đó có nhiệm vụ tạo object. Template Method là cả quy trình.A Factory Method is often ONE step inside a template method — the step that creates an object. Template Method is the whole process.

Bài tập áp dụngExercise

Thêm importer cho ZaloPay: file dùng dấu ';', KHÔNG có dòng header, và chỉ nhận giao dịch từ 10.000đ trở lên.Add a ZaloPay importer: the file uses ';', has NO header line, and only accepts transactions of 10,000 VND or more.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Template Method cố định điều gì?What does Template Method fix in place?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

3 bài toán Backend dùng pattern này3 backend problems use this pattern

Pattern liên quanRelated patterns

Strategy Factory Method Command Chain of Responsibility

Thảo luậnDiscussion

Template Methodaka Hollywood Principle

DễEasy

Mức phổ biếnUsage 4/5

~9 phút đọc~9 min read

package com.pay.recon; import java.io.IOException; import java.io.UncheckedIOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public abstract class SettlementImporter { private final Logger log = LoggerFactory.getLogger(getClass()); private final SettlementRepository repo; protected SettlementImporter(SettlementRepository repo) { this.repo = repo; } // The template method: final, so subclasses can't reorder the steps public final ImportReport importFile(Path file) {1 List<String> lines = readLines(file); log.info("[{}] importing {} ({} lines)", provider(), file, lines.size()); List<Settlement> rows = lines.stream() .skip(headerLines()) .map(this::parse)2 .filter(this::accept) .toList(); repo.saveAll(rows); return new ImportReport(provider(), lines.size(), rows.size()); } protected abstract String provider(); protected abstract Settlement parse(String line); // varies per provider3 protected int headerLines() { return 1; } // hook with a default4 protected boolean accept(Settlement s) { // hook with a default return s.amount().signum() > 0; } private List<String> readLines(Path file) { try { return Files.readAllLines(file); } catch (IOException e) { throw new UncheckedIOException(e); } } }

package recon import ( "bufio" "context" "fmt" "io" "time" ) type Settlement struct { Ref string Amount int64 Day time.Time } type Report struct { Provider string Lines, Imported int } // Parser holds the steps that vary — a small interface, not an abstract class. type Parser interface {1 Provider() string HeaderLines() int Parse(line string) (Settlement, error) } type Store interface { SaveAll(ctx context.Context, rows []Settlement) error } // Import is the template method: a plain function owning the fixed steps. func Import(ctx context.Context, r io.Reader, p Parser, store Store) (Report, error) {2 sc := bufio.NewScanner(r) var rows []Settlement n := 0 for sc.Scan() { n++ if n <= p.HeaderLines() { continue } s, err := p.Parse(sc.Text())3 if err != nil { return Report{}, fmt.Errorf("%s line %d: %w", p.Provider(), n, err)4 } if s.Amount > 0 { rows = append(rows, s) } } if err := sc.Err(); err != nil { return Report{}, err } if err := store.SaveAll(ctx, rows); err != nil { return Report{}, err } return Report{Provider: p.Provider(), Lines: n, Imported: len(rows)}, nil }

type Base struct{} func (b Base) Run(lines []string) { for _, l := range lines { b.Parse(l) // ❌ always Base.Parse — b is a Base, not a VNPay } } func (Base) Parse(line string) { fmt.Println("base parse") } type VNPay struct{ Base } func (VNPay) Parse(line string) { fmt.Println("vnpay parse") } // ❌ never called by Run // VNPay{}.Run(lines) prints "base parse" for every line