Zum Inhalt springen
Dokumentation

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.

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
src/Aspect/ServiceAspect.php
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.

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.

src/Aspect/MonitorAspect.php
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.

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();
}

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.

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.

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.

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')),

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.

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(*))
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+->*(*))

Regeln für Methoden und Properties akzeptieren diese Modifier:

  • public, protected, private
  • final, readonly
  • die Modifier der asymmetrischen Sichtbarkeit private(set) und protected(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.

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.

Operator Bedeutung
&& Beide treffen zu
|| Eine von beiden trifft zu
! Negation
( ) Gruppierung
within(App\**) && !execution(public **->__construct(*))

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();
}

Deklarieren Sie eine Regel einmal und referenzieren Sie sie aus mehreren Behaviors:

src/Aspect/HealthyLiveAspect.php
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.

@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:

src/Attribute/Cacheable.php
namespace App\Attribute;
#[\Attribute(\Attribute::TARGET_METHOD)]
final class Cacheable {}
src/Aspect/CachingAspect.php
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)].

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.

src/Aspect/SerializableAspect.php
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;
}
src/Model/JsonSerializableTrait.php
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.

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.

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 sind Services des Containers des Kernels. Registrieren Sie sie in configureAop() Ihres Kernels, vorzugsweise als verzögerte Services:

app/ApplicationAspectKernel.php
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.

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.

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.

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 einer WeavingException fehl. 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 einer WeavingException fehl. Schließen Sie sie mit && !matchInherited() aus oder hängen Sie das Behavior an den Trait selbst, zum Beispiel execution(public HelloTrait->hello(*)), was in jeder Klasse gilt, die den Trait verwendet.
  • Generatoren. Bei einer Methode, die yield enthält, läuft das Behavior beim Aufruf der Methode, und proceed() gibt das Generator-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 in Throwable::getTrace() weiterhin das Argument-Array. Mit zend.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 geerbte private-Properties.

© 2026 Alexander Lisachenko