Create Template Method

Template Method Pattern Generator

Creates Template Method pattern infrastructure for algorithm skeletons with customizable steps.

When to Use

Component Characteristics

Abstract Template Class

• Defines algorithm skeleton
• Implements invariant steps
• Declares abstract/hook methods
• Calls methods in sequence

Concrete Implementations

• Override specific steps
• Provide algorithm variants
• Inherit common behavior
• Maintain overall structure

Hook Methods

• Optional override points
• Default empty implementation
• Allow customization
• Don't break flow

Generation Process

Step 1: Generate Abstract Template

Path: src/Domain/{BoundedContext}/Template/

1. Abstract{Name}Template.php — Algorithm skeleton with template method

Step 2: Generate Concrete Templates

Path: src/Domain/{BoundedContext}/Template/ or src/Application/{BoundedContext}/

1. {Variant1}{Name}Template.php — First variant implementation
2. {Variant2}{Name}Template.php — Second variant implementation
3. {Variant3}{Name}Template.php — Third variant implementation

Step 3: Generate Support Classes (Optional)

Path: src/Domain/{BoundedContext}/ValueObject/

1. {Name}Result.php — Result value object
2. {Name}Config.php — Configuration value object

Step 4: Generate Tests

1. {Variant}{Name}TemplateTest.php — Individual template tests
2. Abstract{Name}TemplateTest.php — Template skeleton tests

File Placement

Naming Conventions

Quick Template Reference

Abstract Template

abstract readonly class Abstract{Name}Template
{
    public function execute({InputType} $input): {OutputType}
    {
        $this->validate($input);
        $data = $this->extract($input);
        $transformed = $this->transform($data);
        $result = $this->load($transformed);
        $this->afterLoad($result);

        return $result;
    }

    abstract protected function extract({InputType} $input): array;
    abstract protected function transform(array $data): array;

    protected function validate({InputType} $input): void
    {
        // Default validation
    }

    protected function afterLoad({OutputType} $result): void
    {
        // Hook method - optional override
    }
}

Concrete Template

final readonly class {Variant}{Name}Template extends Abstract{Name}Template
{
    protected function extract({InputType} $input): array
    {
        // Variant-specific extraction
    }

    protected function transform(array $data): array
    {
        // Variant-specific transformation
    }
}

Usage Example

// Create templates for different formats
$csvImporter = new CsvDataImporterTemplate();
$jsonImporter = new JsonDataImporterTemplate();
$xmlImporter = new XmlDataImporterTemplate();

// Use same interface
$result = $csvImporter->execute($fileContent);

Common Template Method Variants

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md — Abstract Template, Concrete Template, Hook Methods templates
• references/examples.md — DataImporter, ReportGenerator, OrderProcessor with tests