Strategy Pattern in Magento 2

1. Das Strategy Pattern

Das Strategy Pattern (GoF) definiert eine Familie von Algorithmen hinter einem gemeinsamen Interface. Der Context kennt das Interface, nicht die konkrete Implementierung. Algorithmen können zur Laufzeit ausgetauscht werden:

// Strategy Interface
interface PriceCalculatorInterface
{
    public function calculate(float $basePrice, array $context): float;
}

// Konkrete Strategie 1
class StandardPriceCalculator implements PriceCalculatorInterface
{
    public function calculate(float $basePrice, array $context): float
    {
        return $basePrice;
    }
}

// Konkrete Strategie 2
class DiscountPriceCalculator implements PriceCalculatorInterface
{
    public function calculate(float $basePrice, array $context): float
    {
        $discount = $context['discount_percent'] ?? 0;
        return $basePrice * (1 - $discount / 100);
    }
}

// Context: nutzt Strategy ohne konkrete Implementierung zu kennen
class PriceContext
{
    public function __construct(
        private PriceCalculatorInterface $calculator
    ) {}

    public function getPrice(float $basePrice, array $context): float
    {
        return $this->calculator->calculate($basePrice, $context);
    }
}

2. Strategy in Magento 2: Wo es auftaucht

Das Strategy Pattern ist eines der am häufigsten verwendeten Patterns in Magento 2:

• Tax Calculators — TaxCalculatorInterface: verschiedene Steuerberechnungsalgorithmen (Row-based, Unit-based, Total-based)
• Shipping Methods — AbstractCarrier: jede Versandmethode ist eine eigene Strategy
• Payment Methods — MethodInterface: Kreditkarte, PayPal, Überweisung als austauschbare Strategies
• Price Renderers — verschiedene Preisdarstellungen je Produkttyp
• Search Adapters — MySQL vs Elasticsearch als austauschbare Such-Strategies

// Magento Tax Calculator Strategy (vereinfacht)
interface TaxCalculatorInterface
{
    /**
     * Calculate tax for the given item details.
     */
    public function calculateWithTaxInPrice(
        QuoteDetailsItemInterface $item,
        float $quantity,
        bool $round
    ): AppliedTaxRateInterface;
}

// Row-based Calculator — eine der Strategien
class RowBaseCalculator implements TaxCalculatorInterface
{
    public function calculateWithTaxInPrice(
        QuoteDetailsItemInterface $item,
        float $quantity,
        bool $round
    ): AppliedTaxRateInterface {
        // Steuerberechnung pro Zeile (Row)
        $price = $item->getUnitPrice() * $quantity;
        return $this->applyRates($price);
    }
}

3. Versandmethoden als Strategy

Versandmethoden sind das klarste Strategy-Beispiel in Magento 2. Jeder Carrier implementiert AbstractCarrier mit der collectRates()-Methode als Kernstrategie:

<?php
declare(strict_types=1);

namespace Mironsoft\Shipping\Model\Carrier;

use Magento\Quote\Model\Quote\Address\RateRequest;
use Magento\Quote\Model\Quote\Address\RateResult\ErrorFactory;
use Magento\Quote\Model\Quote\Address\RateResult\MethodFactory;
use Magento\Shipping\Model\Carrier\AbstractCarrier;
use Magento\Shipping\Model\Carrier\CarrierInterface;
use Magento\Shipping\Model\Rate\ResultFactory;

/**
 * Flat rate carrier strategy — returns fixed shipping rate.
 */
class FlatRate extends AbstractCarrier implements CarrierInterface
{
    protected string $_code = 'mironsoft_flatrate';

    public function __construct(
        private readonly ResultFactory $rateResultFactory,
        private readonly MethodFactory $rateMethodFactory,
        // Parent constructor parameters...
    ) {}

    /**
     * Collect shipping rates for this carrier strategy.
     */
    public function collectRates(RateRequest $request): ?\Magento\Shipping\Model\Rate\Result
    {
        if (!$this->getConfigFlag('active')) {
            return null;
        }

        $result = $this->rateResultFactory->create();
        $method = $this->rateMethodFactory->create();

        $method->setCarrier($this->_code);
        $method->setCarrierTitle($this->getConfigData('title'));
        $method->setMethod('standard');
        $method->setMethodTitle('Standard Shipping');
        $method->setPrice((float) $this->getConfigData('price'));

        $result->append($method);
        return $result;
    }

    public function getAllowedMethods(): array
    {
        return ['standard' => 'Standard Shipping'];
    }
}

4. Eigene Strategy implementieren

Ein praktisches Beispiel: verschiedene Export-Formate (CSV, XML, JSON) als austauschbare Strategies:

<?php
declare(strict_types=1);

namespace Mironsoft\Export\Api;

/**
 * Export formatter strategy interface.
 */
interface FormatterInterface
{
    /**
     * Format data array into export string.
     *
     * @param array<string, mixed> $data
     */
    public function format(array $data): string;

    public function getMimeType(): string;

    public function getFileExtension(): string;
}

<?php
declare(strict_types=1);

namespace Mironsoft\Export\Model\Formatter;

use Mironsoft\Export\Api\FormatterInterface;

/**
 * CSV export formatter strategy.
 */
class CsvFormatter implements FormatterInterface
{
    public function format(array $data): string
    {
        $output = '';
        foreach ($data as $row) {
            $output .= implode(',', array_map(
                fn($value) => '"' . str_replace('"', '""', (string) $value) . '"',
                $row
            )) . "\n";
        }
        return $output;
    }

    public function getMimeType(): string { return 'text/csv'; }
    public function getFileExtension(): string { return 'csv'; }
}

5. Strategy mit DI und Pools

Magento 2 nutzt oft einen Pool (Array von Strategies) kombiniert mit DI, um Strategies konfigurierbar zu machen:

<?php
declare(strict_types=1);

namespace Mironsoft\Export\Model;

use Mironsoft\Export\Api\FormatterInterface;

/**
 * Export service — uses strategy pool for format selection.
 */
class ExportService
{
    /** @param FormatterInterface[] $formatters */
    public function __construct(
        private readonly array $formatters
    ) {}

    public function export(array $data, string $format): string
    {
        $formatter = $this->formatters[$format]
            ?? throw new \InvalidArgumentException("Unknown format: $format");

        return $formatter->format($data);
    }

    /** @return string[] */
    public function getSupportedFormats(): array
    {
        return array_keys($this->formatters);
    }
}

<!-- di.xml: Strategy Pool konfigurieren -->
<type name="Mironsoft\Export\Model\ExportService">
    <arguments>
        <argument name="formatters" xsi:type="array">
            <item name="csv" xsi:type="object">Mironsoft\Export\Model\Formatter\CsvFormatter</item>
            <item name="xml" xsi:type="object">Mironsoft\Export\Model\Formatter\XmlFormatter</item>
            <item name="json" xsi:type="object">Mironsoft\Export\Model\Formatter\JsonFormatter</item>
        </argument>
    </arguments>
</type>

6. Zusammenfassung

Das Strategy Pattern ist eines der meistgenutzten GoF-Pattern in Magento 2. Es macht Algorithmen austauschbar ohne den Context-Code zu ändern. In Magento wird es durch DI-Pools in di.xml konfigurierbar — neue Strategien werden durch neue Klassen und di.xml-Einträge hinzugefügt, nicht durch Core-Änderungen.

7. FAQ: Strategy Pattern in Magento 2