Template Method Pattern: Fixing the Skeleton, Letting Subclasses Fill In Steps

// VIOLATION: three classes, each re-implementing an almost-identical pipeline
class CsvReportGenerator {
    void generate(String source) {
        System.out.println("Connecting to " + source);
        String rawData = "raw-data";                 // fetch
        if (rawData == null) throw new IllegalStateException("no data"); // validate
        String transformed = rawData.toUpperCase();   // transform (varies)
        System.out.println("Writing CSV: " + transformed); // render (varies)
        System.out.println("Saved report.csv");        // save
    }
}
 
class PdfReportGenerator {
    void generate(String source) {
        System.out.println("Connecting to " + source);
        String rawData = "raw-data";                 // fetch — duplicated
        if (rawData == null) throw new IllegalStateException("no data"); // validate — duplicated
        String transformed = rawData.trim();           // transform (varies)
        System.out.println("Rendering PDF: " + transformed); // render (varies)
        System.out.println("Saved report.pdf");         // save — duplicated
    }
}
// A fix to "validate" (e.g. also reject empty strings) must be applied to
// every generator individually — and it's easy to miss one.

// The base class owns the algorithm's shape. generate() is final —
// no subclass can reorder steps or skip validation.
abstract class ReportGenerator {
 
    // Template method: the fixed skeleton
    public final void generate(String source) {
        String rawData = fetchData(source);
        validate(rawData);
        String transformed = transform(rawData);
        render(transformed);
        save();
        afterSave(); // hook — optional extension point
    }
 
    // Fixed step — identical for every subclass
    protected String fetchData(String source) {
        System.out.println("Connecting to " + source);
        return "raw-data-from-" + source;
    }
 
    // Fixed step — identical for every subclass
    protected void validate(String data) {
        if (data == null || data.isBlank()) {
            throw new IllegalStateException("No data to report on");
        }
    }
 
    // Abstract step — every subclass MUST define its own transform
    protected abstract String transform(String data);
 
    // Abstract step — every subclass MUST define its own render
    protected abstract void render(String data);
 
    // Fixed step
    private void save() {
        System.out.println("Report saved.");
    }
 
    // Hook — default no-op; override only if a subclass needs post-save work
    protected void afterSave() {
        // no-op by default
    }
}
 
class CsvReportGenerator extends ReportGenerator {
    @Override
    protected String transform(String data) {
        return data.toUpperCase();
    }
 
    @Override
    protected void render(String data) {
        System.out.println("Writing CSV rows: " + data);
    }
}
 
class PdfReportGenerator extends ReportGenerator {
    @Override
    protected String transform(String data) {
        return data.trim();
    }
 
    @Override
    protected void render(String data) {
        System.out.println("Rendering PDF pages: " + data);
    }
 
    // Overrides the hook — PDF generation needs an extra step, CSV doesn't
    @Override
    protected void afterSave() {
        System.out.println("Emailing PDF to distribution list...");
    }
}
 
class Demo {
    public static void main(String[] args) {
        ReportGenerator csv = new CsvReportGenerator();
        csv.generate("orders-db");
 
        ReportGenerator pdf = new PdfReportGenerator();
        pdf.generate("orders-db");
    }
}

abstract class DataImporter<T> {
 
    // Template method
    public final ImportResult importFile(Path filePath) {
        List<String> lines = readLines(filePath);
        List<T> records = parseRecords(lines);
        List<T> validRecords = filterInvalid(records);
        int saved = persist(validRecords);
        onImportComplete(saved, records.size() - validRecords.size());
        return new ImportResult(saved, records.size() - validRecords.size());
    }
 
    // Fixed step
    private List<String> readLines(Path filePath) {
        try {
            return Files.readAllLines(filePath);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
 
    // Abstract — format-specific parsing (CSV vs JSON vs fixed-width)
    protected abstract List<T> parseRecords(List<String> lines);
 
    // Fixed step — reused validation logic
    private List<T> filterInvalid(List<T> records) {
        return records.stream().filter(this::isValid).toList();
    }
 
    // Abstract — each record type validates differently
    protected abstract boolean isValid(T record);
 
    // Abstract — persistence target varies (SQL table, document store, etc.)
    protected abstract int persist(List<T> validRecords);
 
    // Hook — default no-op; only some importers need a completion notification
    protected void onImportComplete(int saved, int rejected) {
        // no-op by default
    }
}
 
record CustomerRecord(String name, String email) {}
 
class CustomerCsvImporter extends DataImporter<CustomerRecord> {
    @Override
    protected List<CustomerRecord> parseRecords(List<String> lines) {
        return lines.stream()
            .skip(1) // header row
            .map(line -> line.split(","))
            .map(parts -> new CustomerRecord(parts[0], parts[1]))
            .toList();
    }
 
    @Override
    protected boolean isValid(CustomerRecord record) {
        return record.email().contains("@");
    }
 
    @Override
    protected int persist(List<CustomerRecord> validRecords) {
        System.out.println("Saving " + validRecords.size() + " customers");
        return validRecords.size();
    }
 
    @Override
    protected void onImportComplete(int saved, int rejected) {
        System.out.printf("Import complete: %d saved, %d rejected%n", saved, rejected);
    }
}
 
record ImportResult(int saved, int rejected) {}

class CustomerCsvImporterTest {
    @Test
    void parsesValidRowsAndSkipsHeader() {
        CustomerCsvImporter importer = new CustomerCsvImporter();
        // Testing parseRecords() in isolation would require a package-private
        // test seam, OR testing through the public template method:
        Path tempFile = writeTempCsv("name,email\nArvind,arvind@example.com\nBad,not-an-email");
 
        ImportResult result = importer.importFile(tempFile);
 
        assertEquals(1, result.saved());
        assertEquals(1, result.rejected());
    }
 
    private Path writeTempCsv(String content) { /* ... */ return null; }
}
 
// A minimal test-only subclass can validate the SKELETON itself,
// independent of any real subclass's business logic:
class SkeletonOrderTest {
    static class RecordingImporter extends DataImporter<String> {
        List<String> callOrder = new ArrayList<>();
        protected List<String> parseRecords(List<String> lines) {
            callOrder.add("parse"); return lines;
        }
        protected boolean isValid(String r) { callOrder.add("validate"); return true; }
        protected int persist(List<String> valid) { callOrder.add("persist"); return valid.size(); }
    }
 
    @Test
    void stepsRunInFixedOrder() {
        RecordingImporter importer = new RecordingImporter();
        importer.importFile(Path.of("dummy.csv"));
        assertEquals(List.of("parse", "validate", "persist"), importer.callOrder);
    }
}

List<Customer> customers = jdbcTemplate.query(
    "SELECT * FROM customers",
    (rs, rowNum) -> new Customer(rs.getString("name"), rs.getString("email"))
    // ^ this lambda is the ONE varying step; connection handling, exception
    // translation, and resource cleanup are all fixed inside JdbcTemplate
);

abstract class ReportGenerator {
    private final RenderStrategy renderStrategy; // composition for THIS one step
 
    protected ReportGenerator(RenderStrategy renderStrategy) {
        this.renderStrategy = renderStrategy;
    }
 
    public final void generate(String source) {
        String rawData = fetchData(source);
        validate(rawData);
        String transformed = transform(rawData);
        renderStrategy.render(transformed); // delegate to an injected strategy, not a subclass override
        save();
    }
 
    protected String fetchData(String source) { /* fixed */ return "data"; }
    protected void validate(String data) { /* fixed */ }
    protected abstract String transform(String data); // still varies by inheritance
    private void save() { /* fixed */ }
}
 
interface RenderStrategy {
    void render(String data);
}