Behaviors & Matching-Rules
Die vollständige Referenz zum Schreiben von Behaviors, der dynamischen Middleware, die das Framework um Ihren Code herum ausführt, und zu den Matching-Rules, die festlegen, wo sie greifen.
Aus dem Englischen übersetzt. Maßgeblich ist die englische Seite. Original lesen
Diese Seite behandelt alles, was Sie bei der Arbeit mit dem Framework schreiben: Behavior-Klassen (Verhaltensklassen), die Behaviors (Verhalten) darin, die als dynamische Middleware um Ihren Code herum laufen, den Call-Context (Aufrufkontext), den jedes Behavior erhält, und die Matching-Rules (Auswahlregeln), die auswählen, wo es läuft. Wenn Sie noch keinen Kernel eingerichtet haben, beginnen Sie mit Erste Schritte. Vollständige Walkthroughs vom Problem bis zum funktionierenden Code finden Sie beim Caching-Behavior und beim Logging-Behavior.
Begriffe auf dieser Seite
Abschnitt betitelt „Begriffe auf dieser Seite“Die API des Frameworks behält die klassischen Namen bei, Sie begegnen ihnen also im Code, in Klassennamen und in Fehlermeldungen. Diese Dokumentation verwendet die Alltagsbegriffe und nennt den API-Begriff einmal:
| In dieser Dokumentation | In der API | Was es ist |
|---|---|---|
| Behavior class (Verhaltensklasse) | Aspect (Aspekt) | Eine Klasse, die Go\Aop\Aspect implementiert und zusammengehörige Behaviors bündelt |
| Behavior (Verhalten), d. h. Middleware | Advice | Eine öffentliche Methode der Behavior-Klasse mit genau einem Attribut aus Go\Lang\Attribute: #[Before], #[After], #[AfterThrowing] oder #[Around] |
| Matching rule (Auswahlregel) | Pointcut | Der Ausdruck in diesem Attribut, der auswählt, wo das Behavior läuft |
| Call context (Aufrufkontext) | Joinpoint | Der abgefangene Moment (ein Methodenaufruf, ein Property-Zugriff, die Erzeugung eines Objekts), dem Behavior als Objekt übergeben |
| Compile step (Kompilierschritt) | Weaving | Die Umwandlung Ihrer Klassen in die Dateien, die PHP lädt, mit angehängten Behaviors |
| Class extension (Klassenerweiterung) | Introduction (Einführung) | Ein Interface und ein Trait, die bestehenden Klassen hinzugefügt werden |
Behavior-Klassen
Abschnitt betitelt „Behavior-Klassen“namespace App\Aspect;
use Go\Aop\Aspect;use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\AfterThrowing;use Go\Lang\Attribute\Around;use Psr\Log\LoggerInterface;
class ServiceAspect implements Aspect{ public function __construct(private readonly LoggerInterface $logger) {}
#[Around('execution(public App\Service\*->*(*))')] public function measure(MethodInvocation $invocation): mixed { $start = hrtime(true); try { return $invocation->proceed(); } finally { $this->logger->debug($invocation . ' took ' . (hrtime(true) - $start) . ' ns'); } }
#[AfterThrowing('execution(public App\Service\*->*(*))')] public function logFailure(MethodInvocation $invocation, \Throwable $exception): void { $this->logger->error($invocation . ' failed: ' . $exception->getMessage()); }}Eine Behavior-Klasse ist eine gewöhnliche PHP-Klasse, die Go\Aop\Aspect implementiert. Sie enthält Logik wie Logging, Caching, Sicherheitsprüfungen oder Transaktionen, die sonst in viele Klassen kopiert würde. Jedes ihrer Behaviors läuft als Middleware um den Code, den seine Matching-Rule auswählt: measure() oben umschließt jede öffentliche Methode von App\Service, und logFailure() läuft, wenn eine davon eine Exception wirft. Weil es eine ganz normale Klasse ist, können Sie Constructor-Injection, privaten Zustand, Traits und alles andere nutzen, was PHP bietet.
Wann ein Behavior läuft
Abschnitt betitelt „Wann ein Behavior läuft“Das Attribut eines Behaviors legt fest, wann es relativ zum abgefangenen Aufruf läuft.
| Attribut | Läuft |
|---|---|
#[Before] |
Vor dem Aufruf. Es kann die Argumente mit setArguments() ändern. |
#[After] |
Nach dem Aufruf, auch wenn dieser eine Exception wirft (wie finally). |
#[AfterThrowing] |
Wenn der Aufruf eine Exception wirft. Es erhält die Exception als zweites Argument; danach wird die Exception erneut geworfen. |
#[Around] |
Anstelle des Aufrufs, wie eine Middleware. Es entscheidet, ob proceed() aufgerufen wird, und sein Rückgabewert wird zum Ergebnis. |
Alle vier Attribute liegen im Namespace Go\Lang\Attribute und erwarten eine Matching-Rule als Argument.
namespace Aspect;
use Go\Aop\Aspect;use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\Before;
class MonitorAspect implements Aspect{ #[Before('execution(public Example->*(*))')] public function beforeMethodExecution(MethodInvocation $invocation): void { echo 'Calling Before Interceptor for: ', $invocation, ' with arguments: ', json_encode($invocation->getArguments()), "<br>\n"; }}Ein Before-Behavior läuft unmittelbar vor der ursprünglichen Methode. Nutzen Sie es, um Eingaben zu validieren oder Berechtigungen zu prüfen. Um zu ändern, was die ursprüngliche Methode erhält, ersetzen Sie die Argumente:
#[Before('execution(public App\Service\UserService->rename(*))')]public function trimName(MethodInvocation $invocation): void{ $arguments = $invocation->getArguments(); $arguments[0] = trim($arguments[0]); $invocation->setArguments($arguments);}getArguments() listet die Argumente nach Position auf, Sie sprechen sie also über ihren Index an.
use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\After;
#[After('execution(public App\Service\ImportService->run(*))')]public function releaseLock(MethodInvocation $invocation): void{ $this->lock->release();}Ein After-Behavior funktioniert wie ein finally-Block: Es läuft, egal ob die Methode normal zurückkehrt oder eine Exception wirft. Nutzen Sie es, um Ressourcen freizugeben oder Timer zu stoppen.
AfterThrowing
Abschnitt betitelt „AfterThrowing“use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\AfterThrowing;
#[AfterThrowing('execution(public App\Service\*->*(*))')]public function logFailure(MethodInvocation $invocation, \Throwable $exception): void{ $this->logger->error($invocation . ' failed: ' . $exception->getMessage());}Ein AfterThrowing-Behavior läuft nur, wenn der Aufruf eine Exception wirft. Es erhält die Exception als zweites Argument. Das Framework wirft die Exception nach dem Behavior erneut, der Aufrufer bekommt sie also weiterhin zu sehen. Nutzen Sie es, um Fehler zu loggen oder Alarme auszulösen.
use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\Around;
#[Around('execution(public App\Service\*->*(*))')]public function measure(MethodInvocation $invocation): mixed{ $start = hrtime(true); try { return $invocation->proceed(); } finally { $this->logger->debug($invocation . ' took ' . (hrtime(true) - $start) . ' ns'); }}Ein Around-Behavior läuft anstelle des Aufrufs, wie eine Middleware in einem HTTP-Stack. Mit proceed() geben Sie die Kontrolle an den ursprünglichen Code weiter, und was das Behavior zurückgibt, wird zum Ergebnis. Damit ist Around der mächtigste Typ: Es entscheidet, ob das Original überhaupt läuft, kann die Argumente vor proceed() ändern, den Rückgabewert ändern und Exceptions abfangen. Nutzen Sie es für Caching, Transaktionen und Retry-Logik.
Wenn Sie proceed() nicht aufrufen, läuft die ursprüngliche Methode nicht:
#[Around('execution(public App\Service\ReportService->build(*))')]public function cacheReport(MethodInvocation $invocation): mixed{ $key = $invocation . json_encode($invocation->getArguments());
return $this->reports[$key] ??= $invocation->proceed();}Der Call-Context
Abschnitt betitelt „Der Call-Context“Jedes Behavior erhält ein Objekt, das den abgefangenen Aufruf beschreibt: seine Argumente, das Objekt, auf dem er läuft, und proceed(), um fortzufahren. Seine Klasse hängt davon ab, was die Matching-Rule auswählt.
Referenz der Call-Contexts
Abschnitt betitelt „Referenz der Call-Contexts“| Klasse | Erhalten bei | Wichtigste Methoden |
|---|---|---|
MethodInvocation |
execution() dynamischer und statischer Methoden |
getThis(), getScope(), getMethod(), getArguments(), setArguments(), proceed() |
FunctionInvocation |
execution() von Funktionen in Namespaces |
getFunction(), getArguments(), setArguments(), proceed() |
FieldAccess |
access() von Properties |
getThis(), getField(), getAccessType(), getValue(), getValueToSet(), proceed() |
ConstructorInvocation |
initialization() |
getConstructor(), getArguments(), getThis() (null, solange das Objekt noch nicht existiert), proceed() |
Alle liegen in Go\Aop\Intercept. Eine MethodInvocation lässt sich als String verwenden, wie es die Beispiele oben in Log-Meldungen tun.
Generische Typen
Abschnitt betitelt „Generische Typen“Diese Klassen deklarieren @template-Typen, sodass PHPStan und IDEs die Typen von getThis() und proceed() kennen. Schreiben Sie die konkreten Typen in den Docblock Ihres Behaviors:
use App\Model\Order;use App\Service\OrderService;use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\Around;
/** * @param MethodInvocation<OrderService, Order> $invocation */#[Around('execution(public App\Service\OrderService->place(*))')]public function auditOrder(MethodInvocation $invocation): Order{ $order = $invocation->proceed(); // … return $order;}Hier teilt MethodInvocation<OrderService, Order> dem Analysewerkzeug mit, dass getThis() ein OrderService ist und proceed() eine Order zurückgibt.
Wie Behaviors zu Middleware werden
Abschnitt betitelt „Wie Behaviors zu Middleware werden“Hinter dem Anhängen eines Behaviors steckt keine Magie. Für jede abgefangene Methode generiert das Framework eine schlichte Middleware-Kette. Jedes Behavior wird als Closure referenziert, erzeugt mit der First-Class-Callable-Syntax, direkt auf der Instanz der Behavior-Klasse:
static $__joinPoint = InterceptorInjector::forMethod( self::class, 'doSomething', [ Interceptor::before(The::aspect(MonitorAspect::class)->beforeMethodExecution(...)), ], $this->doSomethingOriginalAlias(...),);The::aspect() holt die Instanz der Behavior-Klasse aus dem Container des Kernels, und ->beforeMethodExecution(...) ist die Behavior-Methode, die Sie geschrieben haben. Sie können sie in Ihrer IDE per Ctrl-Klick öffnen, darin einen Breakpoint setzen und den generierten Code schrittweise durchlaufen, als wäre er von Hand geschrieben. Die Call-Contexts werden beim Kompilieren erzeugt und im generierten Code gecacht, es gibt also keine Reflection und kein Parsen von Attributen zur Laufzeit. Mehr zum generierten Code finden Sie unter Debuggable.
Behaviors, die im Container als einfache Closures registriert sind statt als Methoden einer Behavior-Klasse, werden stattdessen über den Lazy-Accessor The::advice() angehängt. Er sucht den registrierten Eintrag über seinen Bezeichner und entpackt ihn bis zur eigentlichen Closure:
Interceptor::around(The::advice('advisor.Demo\Aspect\DynamicMethodsAspect->aroundMagicMethods')),Matching-Rules
Abschnitt betitelt „Matching-Rules“Eine Matching-Rule ist ein Ausdruck, der auswählt, wo ein Behavior läuft: Methodenausführungen, Property-Zugriffe, Funktionsaufrufe oder die Erzeugung von Objekten. Sie ist das Argument des Attributs am Behavior:
#[Before('execution(public App\Service->save(*))')]Im Playground können Sie Regeln an einer PHP-Datei ausprobieren; dieser Abschnitt ist die vollständige Referenz.
Arten von Regeln
Abschnitt betitelt „Arten von Regeln“| Regel | Wählt aus |
|---|---|
execution(modifiers Class->method(*)) |
Ausführung einer dynamischen Methode |
execution(modifiers Class::method(*)) |
Ausführung einer statischen Methode |
execution(Namespace\function(*)) |
Aufrufe einer Systemfunktion aus diesem Namespace |
access(modifiers Class->property) |
Lese- und Schreibzugriffe auf eine Instanz-Property |
within(ClassFilter) |
Jedes Member (Methoden und Properties) der passenden Klassen |
initialization(ClassFilter) |
Die Erzeugung von Objekten mit new |
staticinitialization(ClassFilter) |
Das erste Laden der passenden Klassen |
@execution(Attribute) |
Methoden, die das Attribut tragen |
@access(Attribute) |
Properties, die das Attribut tragen |
@within(Attribute) |
Jedes Member von Klassen, die das Attribut tragen |
matchInherited() |
Nur Member, die von einer Elternklasse geerbt oder aus einem Trait importiert sind; !matchInherited() schließt sie aus |
matchReturningByReference() |
Methoden und Funktionen, die als function &name() deklariert sind; !matchReturningByReference() schließt sie aus |
$this->pointcutName |
Eine benannte Regel, deklariert mit #[Pointcut] an einer Methode derselben Behavior-Klasse |
Aspect\Class->pointcutName |
Eine benannte Regel einer anderen Behavior-Klasse |
Die Argumentliste ist immer (*): Argumente werden nicht gematcht.
Achten Sie auf das Trennzeichen: -> wählt dynamische Methoden aus, :: statische.
execution(public App\Service\OrderService->place(*))execution(public App\Util\Money::format(*))Um Aufrufe magischer Methoden abzufangen, hängen Sie das Behavior an __call selbst:
execution(public Foo->__call(*))Namen und Wildcards
Abschnitt betitelt „Namen und Wildcards“| Muster | Bedeutung |
|---|---|
* |
Beliebige Zeichen innerhalb eines Namensteils, auch keine, nie über ein \ hinweg: get* (auch get), *Service (auch Service), App\*\Controller (genau eine Namespace-Ebene dazwischen) |
** |
Beliebige Namespace-Tiefe: App\** ist jede Klasse unterhalb von App, **->*(*) ist jede Methode |
a|b |
Alternativen innerhalb eines Namensteils, z. B. get*|is*. Sie gelten für den Teil, in dem sie stehen: App\Cart|Order ist App\Cart oder App\Order, nie ein globales Order. Für Klassen aus verschiedenen Namespaces verbinden Sie zwei Regeln mit || |
Foo+ |
Foo selbst, seine Unterklassen und Implementierungen sowie Klassen, die den Trait Foo verwenden (direkt oder über eine Elternklasse) |
Namen werden unter Beachtung der Groß- und Kleinschreibung gematcht. Schreiben Sie Namespaces mit einem einzelnen Backslash; in einem PHP-String in einfachen Anführungszeichen ist kein Escaping nötig.
execution(public **->save*(*))execution(public App\Repository\*Repository->find*|get*(*))execution(public App\Contract\Cacheable+->*(*))Modifier
Abschnitt betitelt „Modifier“Regeln für Methoden und Properties akzeptieren diese Modifier:
public,protected,privatefinal,readonly- die Modifier der asymmetrischen Sichtbarkeit
private(set)undprotected(set)
Alternativen verbinden Sie mit |:
execution(public|protected App\Service->*(*))Durch Leerzeichen getrennte Modifier müssen alle vorhanden sein, und | bindet stärker als das Leerzeichen. final public|protected trifft finale Methoden, die public oder protected sind. Pro Muster wird eine Gruppe von Alternativen unterstützt.
Statische Properties werden nie abgefangen, ebenso wenig readonly-Properties oder Properties, die bereits Hooks haben. Der Abschnitt zur Property-Interception unten führt jeden Fall auf; die Gründe stehen unter Einschränkungen & Upgrade.
Rückgabetypen
Abschnitt betitelt „Rückgabetypen“Ein Muster für Methoden oder Funktionen kann den deklarierten Rückgabetyp einschränken:
execution(public App\Repo->find*(*): App\Entity|null)Union-Typen verwenden |, Intersection-Typen &, und ?Foo ist dasselbe wie Foo|null.
Regeln kombinieren
Abschnitt betitelt „Regeln kombinieren“| Operator | Bedeutung |
|---|---|
&& |
Beide treffen zu |
|| |
Eine von beiden trifft zu |
! |
Negation |
( ) |
Gruppierung |
within(App\**) && !execution(public **->__construct(*))Kommentare
Abschnitt betitelt „Kommentare“Kommentare beginnen mit // und reichen bis zum Zeilenende. Sie helfen bei langen, mehrzeiligen Ausdrücken:
#[Around(' execution(public App\Service\**->*(*)) // every public service method && !matchReturningByReference() // skip function &name() && !matchInherited() // skip inherited and trait methods')]public function trace(MethodInvocation $invocation): mixed{ return $invocation->proceed();}Benannte Regeln
Abschnitt betitelt „Benannte Regeln“Deklarieren Sie eine Regel einmal und referenzieren Sie sie aus mehreren Behaviors:
use Go\Aop\Aspect;use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\After;use Go\Lang\Attribute\Before;use Go\Lang\Attribute\Pointcut;
class HealthyLiveAspect implements Aspect{ #[Pointcut('execution(public App\Human->eat(*))')] protected function humanEat(): void {}
#[Before('$this->humanEat')] public function washUpBeforeEat(MethodInvocation $invocation): void { /* ... */ }
#[After('$this->humanEat')] public function cleanTeethAfterEat(MethodInvocation $invocation): void { /* ... */ }}Die #[Pointcut]-Methode hat einen leeren Rumpf; nur ihr Attribut zählt. Referenzieren Sie sie aus derselben Behavior-Klasse als $this->humanEat. Aus einer anderen verwenden Sie den Namen der deklarierenden Klasse, zum Beispiel App\Aspect\HealthyLiveAspect->humanEat.
Regeln nach Attribut
Abschnitt betitelt „Regeln nach Attribut“@execution, @access und @within wählen Member nach den PHP-Attributen aus, die sie tragen. So markieren Sie den Code, der ein Behavior bekommen soll, statt ihn über den Namen zu matchen:
namespace App\Attribute;
#[\Attribute(\Attribute::TARGET_METHOD)]final class Cacheable {}use Go\Aop\Aspect;use Go\Aop\Intercept\MethodInvocation;use Go\Lang\Attribute\Around;
class CachingAspect implements Aspect{ #[Around('@execution(App\Attribute\Cacheable)')] public function cache(MethodInvocation $invocation): mixed { // … return $invocation->proceed(); }}@access(Attribute) tut dasselbe für Properties, und @within(Attribute) wählt jedes Member von Klassen aus, die das Attribut tragen. Attribute kompilierter Klassen werden mit ihren ursprünglichen Argumenten in den generierten Code übernommen, das Auslesen zur Laufzeit funktioniert also wie zuvor. Das Caching-Behavior baut auf dieser Regel ein vollständiges #[Cacheable(ttl: 600)].
Behaviors an Properties
Abschnitt betitelt „Behaviors an Properties“use Go\Aop\Intercept\FieldAccess;use Go\Aop\Intercept\FieldAccessType;use Go\Lang\Attribute\Around;
#[Around('access(public App\Entity\User->email)')]public function normalizeEmail(FieldAccess $access): mixed{ if ($access->getAccessType() === FieldAccessType::Write) { return strtolower($access->proceed()); }
return $access->proceed();}access(...)-Regeln fangen Lese- und Schreibzugriffe auf Instanz-Properties über native Property-Hooks von PHP 8.4 in den generierten Proxy-Klassen ab. Das Behavior erhält einen FieldAccess. Bei einem Schreibzugriff gibt proceed() den Wert zurück, der gespeichert wird, ein Around-Behavior kann ihn also ändern, wie im Beispiel.
Was sich abfangen lässt:
- Properties, die in der kompilierten Klasse selbst deklariert sind, einschließlich per Constructor Promotion deklarierter Properties (auch
final, unter PHP 8.5). Die Zuweisung durch den Konstruktor wird als Schreibzugriff abgefangen. - geerbte public- und protected-Properties aus Elternklassen
Was übersprungen wird:
static-,readonly- und bereits mit Hooks versehene Properties- geerbte
final-Properties aus Elternklassen - geerbte
private-Properties
Für Properties mit Array-Typ erzeugt der Proxy nur einen &get-Hook per Referenz, ohne set. So bleiben indirekte Änderungen wie array_push($this->items, ...) gültig.
Wenn Doctrine eine Entity hydriert oder flusht, liest und schreibt es die rohen Property-Werte, Property-Behaviors laufen also nur für Zugriffe aus Ihrem eigenen Code. Das Doctrine-Setup finden Sie unter Integrationen, einen Überblick auf der Feature-Seite zu Property-Hooks.
Class-Extensions
Abschnitt betitelt „Class-Extensions“use App\Model\JsonSerializableTrait;use Go\Aop\Aspect;use Go\Lang\Attribute\DeclareParents;
class SerializableAspect implements Aspect{ #[DeclareParents('within(App\Model\*)', interfaceName: \JsonSerializable::class, traitName: JsonSerializableTrait::class)] protected null $jsonSerializable;}namespace App\Model;
trait JsonSerializableTrait{ public function jsonSerialize(): mixed { return get_object_vars($this); }}Eine Class-Extension ändert, welche Fähigkeiten bestehende Klassen nach außen bieten, während ein Behavior ändert, was passiert, wenn ihr Code läuft. #[DeclareParents] an einer Property der Behavior-Klasse fügt den passenden Klassen ein Interface und einen Trait hinzu, der es implementiert. Hier wird jede Klasse in App\Model zu JsonSerializable, ohne dass Sie eine davon bearbeiten. Das funktioniert auch für Klassen aus Composer-Paketen, siehe die Feature-Seite zu Class-Extensions.
Behaviors an Funktionsaufrufen
Abschnitt betitelt „Behaviors an Funktionsaufrufen“use Go\Aop\Intercept\FunctionInvocation;use Go\Lang\Attribute\Around;
#[Around('execution(App\Service\file_get_contents(*))')]public function logRead(FunctionInvocation $invocation): mixed{ $this->logger->debug('Reading ' . $invocation->getArguments()[0]);
return $invocation->proceed();}execution(App\Service\file_get_contents(*)) fängt Aufrufe von file_get_contents() aus Code im Namespace App\Service ab. Das Behavior erhält eine FunctionInvocation.
Die Proxys abgefangener Funktionen werden mit declare(strict_types=1) generiert, eine Datei pro Namespace. Die Argumente werden nach dem Modus der aufrufenden Datei umgewandelt, bevor der Proxy betreten wird.
Erzeugung von Objekten
Abschnitt betitelt „Erzeugung von Objekten“use Go\Aop\Intercept\ConstructorInvocation;use Go\Lang\Attribute\Around;
#[Around('initialization(App\Model\Order)')]public function trackOrderCreation(ConstructorInvocation $invocation): mixed{ $order = $invocation->proceed(); // … return $order;}initialization(App\Model\Order) fängt new Order(...) in kompilierten Dateien ab. Das Behavior erhält eine ConstructorInvocation. Deren getThis() gibt null zurück, solange das Objekt noch nicht existiert.
staticinitialization(App\Model\*) läuft einmal, nachdem die Klasse geladen wurde.
Behavior-Klassen registrieren
Abschnitt betitelt „Behavior-Klassen registrieren“Behavior-Klassen sind Services des Containers des Kernels. Registrieren Sie sie in configureAop() Ihres Kernels, vorzugsweise als verzögerte Services:
use Aspect\MonitorAspect;use Go\Core\AspectContainer;use Go\Core\AspectKernel;
class ApplicationAspectKernel extends AspectKernel{ protected function configureAop(AspectContainer $container): void { // Deferred (recommended): constructed on first use $container->addLazyService(MonitorAspect::class, static fn() => new MonitorAspect());
// Eager alternative: // $container->add(MonitorAspect::class, new MonitorAspect()); }}addLazyService() registriert eine Factory. Der Compile-Step instanziiert nie Behavior-Klassen: Jede wird erst erzeugt, wenn eines ihrer Behaviors zum ersten Mal läuft, als natives Lazy Object von PHP 8.4. add() registriert eine Instanz, die Sie bereits erzeugt haben.
Abhängigkeiten
Abschnitt betitelt „Abhängigkeiten“Die Factory erhält den Container des Kernels, einen AspectContainer. Das ist ein PSR-11-Container, Sie können die Abhängigkeiten der Behavior-Klasse also daraus beziehen:
use Go\Core\AspectContainer;use Psr\Log\LoggerInterface;
$container->addLazyService( ServiceAspect::class, static fn(AspectContainer $c) => new ServiceAspect($c->getService(LoggerInterface::class)),);Services aus dem eigenen PSR-11-Container Ihrer Anwendung stehen zur Verfügung, sobald Sie ihn mit setDelegate() an den Container des Kernels anbinden. Die Bridges für Symfony, Laravel und Yii3 registrieren Behavior-Klassen für Sie; siehe Integrationen. Die Kernel-Optionen behandelt Konfiguration & CLI.
Geerbte Methoden
Abschnitt betitelt „Geerbte Methoden“Ein Behavior läuft einmal pro Methodenausführung, egal wie viele Klassen der Hierarchie kompiliert sind. Eine Methode, die eine kompilierte Klasse nur erbt, wird vom nächsten kompilierten Vorfahren abgefangen, auf den die Regel dort zutrifft (bis hinauf zur Klasse, die die Methode deklariert); die Unterklasse erbt diese abgefangene Methode und überschreibt nichts.
Gibt es keinen solchen Vorfahren, etwa bei einer Elternklasse außerhalb von includePaths oder einer, auf die die Regel nicht zutrifft, fängt die Unterklasse die geerbte Methode selbst ab.
Um eine Regel auf Member zu beschränken, die eine Klasse selbst deklariert, ergänzen Sie !matchInherited(). Es schließt Member aus, die von einer Elternklasse geerbt oder aus einem Trait importiert sind.
Einschränkungen
Abschnitt betitelt „Einschränkungen“Einige Arten von Methoden können kein Behavior bekommen oder verhalten sich dann anders. Die vollständige Liste mit den Gründen steht unter Einschränkungen & Upgrade. Kurz gefasst:
- Rückgabe per Referenz. Eine Methode oder Funktion, die als
function &name()deklariert ist, lässt sich nicht abfangen; ihr Kompilieren schlägt mit einerWeavingExceptionfehl. Schließen Sie solche Methoden mit&& !matchReturningByReference()aus einer breiten Regel aus. - Trait-Methoden mit
#[\Override]. Eine Methode, die eine Klasse aus einem Trait importiert und die#[\Override]trägt, lässt sich in dieser Klasse nicht abfangen; ihr Kompilieren schlägt mit einerWeavingExceptionfehl. Schließen Sie sie mit&& !matchInherited()aus oder hängen Sie das Behavior an den Trait selbst, zum Beispielexecution(public HelloTrait->hello(*)), was in jeder Klasse gilt, die den Trait verwendet. - Generatoren. Bei einer Methode, die
yieldenthält, läuft das Behavior beim Aufruf der Methode, undproceed()gibt dasGenerator-Objekt zurück. Die gelieferten Werte sieht das Behavior nicht. - Argumente.
getArguments()listet die Argumente nach Position auf. Ein variadischer Parameter per Referenz (&...$values) wird an die ursprüngliche Methode per Wert übergeben. #[\SensitiveParameter]. Zwei interne Frames zwischen dem Call-Context und der ursprünglichen Methode enthalten inThrowable::getTrace()weiterhin das Argument-Array. Mitzend.exception_ignore_args=On, dem Standard in Produktion, hat kein Frame Argumente.- Properties. Statische, readonly- und bereits mit Hooks versehene Properties werden nicht abgefangen, ebenso wenig geerbte
final- oder geerbteprivate-Properties.
© 2026 Alexander Lisachenko
