Violettes Licht umhüllt eine Reihe klarer Glasobjekte und gibt jedem eine neue Facette.
Funktion · Klassenerweiterungen

Neue Fähigkeiten für Klassen, die nicht Ihnen gehören.

Fügen Sie bestehenden Klassen Interfaces und Traits hinzu, ohne ihren Quelltext zu ändern oder Vererbungshierarchien aufzubauen.

Zwei Wege, eine Klasse zu erweitern

Beide werden in einer Verhaltensklasse deklariert (in der API ein Aspect), und beide lassen Ihre Quelldateien unberührt.

Interception

Ändert, was passiert, wenn bestehender Code läuft.

#[Around('@execution(App\Attribute\Cacheable)')]

Die Methode behält ihre Signatur. Ein Verhalten läuft um jeden Aufruf: Caching, Logging, Transaktionen.

Alles abfangen
Introduction

Ändert, welche Fähigkeiten bestehende Klassen bieten.

#[DeclareParents('within(Acme\Payments\Dto\*)', …)]

Die Klasse erhält ein Interface und die Methoden eines Traits. Um bestehende Aufrufe läuft nichts; Ihr Code ruft die neuen Methoden auf.

Zum Beispiel
Fremde Klassen

Vendor-Klassen erweitern, ohne sie zu forken.

Ihre Export-Pipeline akzeptiert alles, was Exportable ist. Die DTOs des Payment-SDKs sind es nicht, und sie sind final. Statt das Paket zu forken oder jedes DTO in einen Adapter zu packen, fügt eine einzige Verhaltensklasse allen Ihr Interface und einen wiederverwendbaren Trait hinzu.

src/Contract/Exportable.phpIhr Code
interface Exportable{    /** @return array<string, scalar|null> */    public function toExportRow(): array;} // src/Export/ExportsPublicProperties.phptrait ExportsPublicProperties{    public function toExportRow(): array    {        return get_object_vars($this);    }}

Nennen Sie das Paket in includePaths, damit es wie Ihr eigener Code kompiliert wird. Vendor-Code zu kompilieren kostet Zeit beim Warm-up, also listen Sie nur die Pakete auf, die Sie erweitern.

public/index.phpKernel
AppKernel::getInstance()->init([    // …    'includePaths' => [        __DIR__ . '/src',        __DIR__ . '/vendor/acme/payments-sdk/src',    ],]);
Überall in Ihrer AppVerwendung
$charge = new Charge('ch_1', 4200, 'EUR');  // a vendor DTO $charge instanceof Exportable;  // true$exporter->write($charge);       // accepts any Exportable$charge->toExportRow();          // ['id' => 'ch_1', 'amount' => 4200, 'currency' => 'EUR']
Charge.phpVendor, unberührt

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace Acme\Payments\Dto;
        
        
        
      
        
        
         
        
        
        
      
        
        
        final readonly class Charge
        final und readonly
        
        
      
        
        
        {
        
        
        
      
        
        
            public function __construct(
        
        
        
      
        
        
                public string $id,
        
        
        
      
        
        
                public int $amount,
        
        
        
      
        
        
                public string $currency,
        
        
        
      
        
        
            ) {}
        
        
        
      
        
        
        }
        
        
        
      
ExportAspect.phpIhre Verhaltensklasse

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Aspect;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Contract\Exportable;
        
        
        
      
        
        
        use App\Export\ExportsPublicProperties;
        
        
        
      
        
        
        use Go\Aop\Aspect;
        
        
        
      
        
        
        use Go\Lang\Attribute\DeclareParents;
        
        
        
      
        
        
         
        
        
        
      
        
        
        final class ExportAspect implements Aspect
        
        
        
      
        
        
        {
        
        
        
      
        
        
            #[DeclareParents('within(Acme\Payments\Dto\*)', interfaceName: Exportable::class, traitName: ExportsPublicProperties::class)]
        jedes DTO des Pakets
        
        
      
        
        
            protected null $exportable;
        
        
        
      
        
        
        }
        
        
        
      
Charge.phpgeneriert

        
        
        <?php
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
        namespace Acme\Payments\Dto;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use Go\Aop\Framework\InterceptorInjector;
        
        
        
      
        
        
        use Go\Aop\Framework\Interceptor;
        
        
        
      
        
        
        use Go\Aop\Framework\The;
        
        
        
      
        
        
        final readonly class Charge implements \App\Contract\Exportable, \Go\Aop\Proxy
        Ihr Interface
        
        
      
        
        
        {
        
        
        
      
        
        
            use ChargeOriginalTrait, \App\Export\ExportsPublicProperties;
        Ihr Trait
        
        
      
        
        
        }
        
        
        
      

Verhalten ohne Vererbung

Mehr in docs/advices.md und docs/configuration.md.

  • Kein Fork zu pflegen

    Das Paket bleibt, wie Composer es installiert hat. Updates kommen weiter mit composer update, und das nächste Cache-Warm-up kompiliert sie erneut.

  • Auch finale und readonly-Klassen

    Die Klasse behält ihren Namen, ihre Modifier und ihre Elternklassen. Interface und Trait kommen zu ihr hinzu, nicht zu einer Unterklasse.

  • Ein echtes Interface

    instanceof und Typdeklarationen funktionieren, denn die Klasse, die PHP lädt, implementiert es wirklich.