Template Method Design Pattern

public abstract class ImportJob {

    /** final: subclasses fill the steps, they never reorder them. */
    public final ImportResult run() {
        lock.acquire(name());
        try {
            RawBatch raw = fetch();          // abstract — every job must supply
            List<Row> rows = parse(raw);     // abstract
            validate(rows);                  // default, overridable
            beforeWrite(rows);               // hook — usually does nothing
            ImportResult result = writeInBatches(rows);
            metrics.record(name(), result);
            return result;
        } catch (Exception e) {
            alerts.page(name(), e);          // one place, so no job can forget
            throw e;
        } finally {
            lock.release(name());            // ditto
        }
    }

    protected abstract String name();
    protected abstract RawBatch fetch();
    protected abstract List<Row> parse(RawBatch raw);

    /** Default step: most jobs are happy with this. */
    protected void validate(List<Row> rows) {
        rows.forEach(Row::requireMandatoryFields);
    }

    /** Hook: deliberately empty. Override only if you need it. */
    protected void beforeWrite(List<Row> rows) { }
}

public final class CsvImportJob extends ImportJob {
    protected String name()                  { return "csv-import"; }
    protected RawBatch fetch()               { return sftp.download(path); }
    protected List<Row> parse(RawBatch raw)  { return CsvParser.parse(raw); }
}

// HttpServlet.service() is the JDK's own template method: it inspects the HTTP
// verb and calls doGet, doPost or doPut — the hooks you actually override.

from abc import ABC, abstractmethod
from typing import final


class ImportJob(ABC):

    @final                      # advisory: type checkers enforce it, Python doesn't
    def run(self) -> ImportResult:
        lock.acquire(self.name)
        try:
            raw = self.fetch()
            rows = self.parse(raw)
            self.validate(rows)
            self.before_write(rows)          # hook
            result = self.write_in_batches(rows)
            metrics.record(self.name, result)
            return result
        except Exception as exc:
            alerts.page(self.name, exc)
            raise
        finally:
            lock.release(self.name)

    @property
    @abstractmethod
    def name(self) -> str: ...

    @abstractmethod
    def fetch(self) -> RawBatch: ...

    @abstractmethod
    def parse(self, raw: RawBatch) -> list[Row]: ...

    def validate(self, rows: list[Row]) -> None:
        for row in rows:
            row.require_mandatory_fields()

    def before_write(self, rows: list[Row]) -> None:
        """Hook. Deliberately empty."""


# Two Python-specific notes. `@final` is checked by mypy, not by the runtime —
# a determined subclass can still override run(), so the guarantee is weaker
# than Java's. And unittest.TestCase is the template method every Python
# developer has already used: run() calls setUp, then your test_*, then
# tearDown, in an order you don't control and shouldn't want to.

class ImportJob {
public:
    virtual ~ImportJob() = default;

    // NON-VIRTUAL INTERFACE: the public entry point is non-virtual, so it
    // cannot be overridden, and the customisation points are PRIVATE virtuals.
    // This is the standard C++ idiom for Template Method, and it's stricter
    // than the Java version — a subclass can supply steps but cannot even see
    // the skeleton, let alone replace it.
    ImportResult run() {
        Lock guard{name()};
        try {
            auto raw  = fetch();
            auto rows = parse(raw);
            validate(rows);
            beforeWrite(rows);
            auto result = writeInBatches(rows);
            metrics::record(name(), result);
            return result;
        } catch (const std::exception& e) {
            alerts::page(name(), e);
            throw;
        }
        // Lock's destructor releases — RAII means "finally" isn't needed.
    }

private:
    virtual std::string name() const = 0;
    virtual RawBatch fetch() = 0;
    virtual std::vector<Row> parse(const RawBatch&) = 0;

    virtual void validate(const std::vector<Row>& rows) {
        for (const auto& r : rows) r.requireMandatoryFields();
    }
    virtual void beforeWrite(const std::vector<Row>&) {}   // hook
};

// The compile-time variant, when you don't want virtual dispatch at all:
// CRTP — `template <class Derived> class ImportJob { ... static_cast<Derived*>(this)->fetch(); }`

public abstract class ImportJob
{
    // No `virtual` = it cannot be overridden. C# makes non-virtual the default,
    // so the skeleton is sealed unless you deliberately open it.
    public async Task<ImportResult> RunAsync(CancellationToken ct = default)
    {
        await _lock.AcquireAsync(Name, ct);
        try
        {
            var raw    = await FetchAsync(ct);
            var rows   = Parse(raw);
            Validate(rows);
            BeforeWrite(rows);                       // hook
            var result = await WriteInBatchesAsync(rows, ct);
            _metrics.Record(Name, result);
            return result;
        }
        catch (Exception ex)
        {
            _alerts.Page(Name, ex);
            throw;
        }
        finally
        {
            await _lock.ReleaseAsync(Name);
        }
    }

    protected abstract string Name { get; }
    protected abstract Task<RawBatch> FetchAsync(CancellationToken ct);
    protected abstract IReadOnlyList<Row> Parse(RawBatch raw);

    protected virtual void Validate(IReadOnlyList<Row> rows) { /* default */ }
    protected virtual void BeforeWrite(IReadOnlyList<Row> rows) { }   // hook
}

// `protected` matters here: these are extension points for subclasses, not
// public API. Making them public invites callers to run half the algorithm,
// which is exactly the thing the template method is protecting.

// Classes work, but JavaScript's honest version of this pattern is usually a
// function that takes the varying steps — no inheritance, no `super`, and the
// skeleton stays just as fixed.

export const runImport = async ({ name, fetch, parse, validate = defaultValidate, beforeWrite }) => {
  await lock.acquire(name)
  try {
    const raw = await fetch()
    const rows = parse(raw)
    validate(rows)
    beforeWrite?.(rows)                       // hook, optional by construction
    const result = await writeInBatches(rows)
    metrics.record(name, result)
    return result
  } catch (err) {
    alerts.page(name, err)
    throw err
  } finally {
    await lock.release(name)
  }
}

const csvImport = {
  name: 'csv-import',
  fetch: () => sftp.download(path),
  parse: raw => parseCsv(raw),
}

await runImport(csvImport)

// Same guarantees, one less concept — and the caller can't reorder the steps
// because they never see them. React class components are the inheritance
// version most JS developers have met: you write render() and componentDidMount()
// and React decides when they run, which is the Hollywood Principle exactly.

package importer

// Go has no inheritance, so Template Method inverts: the skeleton is a FUNCTION
// and the blanks are an interface. The guarantee is identical — callers can't
// reorder steps they never see — and it composes better than a base class.

type Source interface {
	Name() string
	Fetch(ctx context.Context) (RawBatch, error)
	Parse(RawBatch) ([]Row, error)
}

// Optional steps become optional interfaces, checked with a type assertion —
// Go's equivalent of an overridable hook.
type Validator interface{ Validate([]Row) error }

func Run(ctx context.Context, src Source) (result ImportResult, err error) {
	if err = lock.Acquire(ctx, src.Name()); err != nil {
		return ImportResult{}, err
	}
	defer lock.Release(src.Name())            // cannot be forgotten
	defer func() {
		if err != nil {
			alerts.Page(src.Name(), err)
		}
	}()

	raw, err := src.Fetch(ctx)
	if err != nil {
		return ImportResult{}, fmt.Errorf("fetch: %w", err)
	}
	rows, err := src.Parse(raw)
	if err != nil {
		return ImportResult{}, fmt.Errorf("parse: %w", err)
	}
	if v, ok := src.(Validator); ok {         // the hook, if the source wants it
		if err = v.Validate(rows); err != nil {
			return ImportResult{}, err
		}
	}
	return writeInBatches(ctx, rows)
}

// sort.Sort is the standard library's template method: the algorithm is fixed
// and you supply Len, Less and Swap.

abstract class ImportJob {
  // TypeScript has no `final`, so the convention is to keep the template public
  // and the steps protected — and to say so in a comment, because the compiler
  // will not stop a subclass overriding run().
  async run(): Promise<ImportResult> {
    await lock.acquire(this.name)
    try {
      const raw = await this.fetch()
      const rows = this.parse(raw)
      this.validate(rows)
      this.beforeWrite(rows)
      const result = await writeInBatches(rows)
      metrics.record(this.name, result)
      return result
    } catch (err) {
      alerts.page(this.name, err)
      throw err
    } finally {
      await lock.release(this.name)
    }
  }

  protected abstract get name(): string
  protected abstract fetch(): Promise<RawBatch>
  protected abstract parse(raw: RawBatch): Row[]

  protected validate(rows: Row[]): void { rows.forEach(requireMandatoryFields) }
  protected beforeWrite(_rows: Row[]): void {}
}

// The composition version types the holes precisely, and needs no class at all:
type ImportSteps = {
  readonly name: string
  fetch(): Promise<RawBatch>
  parse(raw: RawBatch): Row[]
  validate?(rows: Row[]): void        // `?` makes "hook" a type, not a convention
}

export const runImport = async (steps: ImportSteps): Promise<ImportResult> => { /* … */ }