Template Method: a fixed skeleton with hooks

Template Method is a design pattern in which a base class fixes the steps of an algorithm, and their order, in one method, the template method, and lets subclasses supply the steps that differ. Some steps are required: the base class declares them, and every subclass must implement them. Others are hooks: they come with a default, often one that does nothing, which a subclass may override. The base class calls the subclass’s code, not the other way round, a reversal the Gang of Four call the Hollywood principle: “don’t call us, we’ll call you”. Use it when several variants share one procedure that must not drift apart, such as importers, report builders, test fixtures and the request handling of a framework.

The idea: the base class owns the order

Three importers that each copy the same sequence of reading, checking, converting and saving rows will drift: one skips the check, another converts before checking. A template method keeps the sequence in one place. Here run() is the only method that knows the order; each format supplies how it reads, and one format also uses the hook for rejected rows:

# A data import as a template method: run() fixes the order of the steps once, in the base class. Subclasses fill in
# the steps that differ (reading a format) and may override a hook (here, what to do with rejected rows).
import csv
import io
import json


class Importer:
    def run(self, source):  # the template method: the order lives here and nowhere else
        rows = self.read(source)  # required: every format reads differently
        good = [r for r in rows if self.valid(r)]
        self.rejected(len(rows) - len(good))  # hook: does nothing unless a subclass says otherwise
        saved = [self.transform(r) for r in good]
        print(f"  saved {saved}")

    def read(self, source):
        raise NotImplementedError

    def valid(self, row):  # a default step, shared by all formats
        return row.get("name", "").strip() != "" and row.get("qty", "").isdigit()

    def transform(self, row):
        return (row["name"].strip().title(), int(row["qty"]))

    def rejected(self, count):  # the hook's default
        pass


class CsvImporter(Importer):
    def read(self, source):
        return list(csv.DictReader(io.StringIO(source)))


class JsonImporter(Importer):
    def read(self, source):
        return [{k: str(v) for k, v in item.items()} for item in json.loads(source)]

    def rejected(self, count):  # this format reports bad rows
        print(f"  {count} row(s) rejected")


print("CSV:")
CsvImporter().run("name,qty\npens,12\n,3\nink,x\nruler,4\n")
print("JSON:")
JsonImporter().run('[{"name": "paper", "qty": 500}, {"name": "glue", "qty": "two"}]')

CSV:
  saved [('Pens', 12), ('Ruler', 4)]
JSON:
  1 row(s) rejected
  saved [('Paper', 500)]

The CSV importer wrote no validation code, yet its rows with an empty name and a quantity of “x” were rejected, because the check belongs to the skeleton. The JSON importer added one behaviour, reporting rejected rows, by overriding the hook, and changed nothing else.

That is the payoff. A fourth format, say fixed-width text, is one new class with one method; the checks, the conversion and the reporting come with the skeleton, and a fix to the validation reaches every format at once. The price is a tight bond between the classes: a subclass can vary only the steps the base class chose to expose, and it relies on the base class calling them in the order it always has.

The pattern comes with a few neighbours worth naming. Composition gives the same skeleton without inheritance: the varying steps are passed in as functions or small objects. Standard-library template methods are classes you already use: Java’s AbstractList and InputStream, Rust’s Iterator, Python’s unittest.TestCase. The fragile base class problem is a subclass that breaks when the base class changes its own skeleton. Calls from constructors to overridable steps run code before the object is ready, and each language fails differently.

Required steps, hooks and a template no subclass can reorder Pro: opens with a Pro, Premium or Ultimate pass