Zum Inhalt springen
Dokumentation

Erste Schritte

Installieren Sie das Framework mit Composer, legen Sie einen Kernel an, schreiben Sie Ihr erstes Behavior und sehen Sie zu, wie es um Ihren Code herum läuft.

Aus dem Englischen übersetzt. Maßgeblich ist die englische Seite. Original lesen

Sie schreiben ein Behavior (Verhalten) wie Logging, Caching, eine Sicherheitsprüfung oder eine Transaktion genau einmal, und das Framework hängt es als dynamische Middleware an jede Methode, die Sie auswählen. Im Code leben Behaviors in einer Behavior-Klasse (Verhaltensklasse), in der API ein Aspect (Aspekt): Jedes Behavior ist eine Methode, deren Attribut festlegt, wann sie läuft, und das eine Matching-Rule (Auswahlregel) trägt, die festlegt, wo. Ihre Klassen enthalten nur noch ihre Geschäftslogik. Die Begriffstabelle ordnet die Namen der API den Begriffen zu, die diese Dokumentation verwendet.

  • PHP 8.4 oder neuer. Läuft auf allen modernen PHP-Versionen.
  • Keine PECL- oder PIE-Extension. Das Framework ist reines PHP: kein php-aop, runkit oder uopz und kein eval(). Es nutzt die Extension tokenizer.
  • Composer. Das Framework und seine Abhängigkeiten werden als gewöhnliche Composer-Pakete installiert.

Der Einstieg besteht aus fünf Schritten:

  1. Das Framework mit Composer installieren.
  2. Den Kernel der Anwendung anlegen.
  3. Den Kernel im Front-Controller initialisieren.
  4. Eine Behavior-Klasse schreiben.
  5. Die Behavior-Klasse im Kernel registrieren.
Terminal-Fenster
composer require goaop/framework

Composer installiert das Framework nach vendor/goaop/framework.

Die Beispiele auf dieser Seite verwenden die folgende Struktur. Sie setzen voraus, dass Composer die Klassen in app/ und src/ per Autoload lädt, zum Beispiel über den Abschnitt autoload Ihrer composer.json.

app/ApplicationAspectKernel.php the kernel
public/index.php the front controller
src/ your application code, compiled by the framework
src/Aspect/MonitorAspect.php your first behavior class
var/cache/aop/ the cache of generated code
app/ApplicationAspectKernel.php
<?php
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
/**
* The application kernel
*/
class ApplicationAspectKernel extends AspectKernel
{
/**
* Register the behavior classes in the container
*/
protected function configureAop(AspectContainer $container): void
{
}
}

Der Kernel verwaltet alle Behavior-Klassen Ihrer Anwendung an einer Stelle. Erweitern Sie die abstrakte Klasse Go\Core\AspectKernel und implementieren Sie configureAop(). Die Methode bleibt vorerst leer; weiter unten registrieren Sie darin Ihre erste Behavior-Klasse.

public/index.php
<?php
include __DIR__ . '/../vendor/autoload.php'; // use composer
// Initialize the kernel
$applicationAspectKernel = ApplicationAspectKernel::getInstance();
$applicationAspectKernel->init([
'debug' => true, // use 'false' for production mode
'appDir' => __DIR__ . '/..', // Application root directory
'cacheDir' => __DIR__ . '/../var/cache/aop', // Cache directory
// Directories whose classes get behaviors; empty means all source files
'includePaths' => [
__DIR__ . '/../src/'
]
]);
// Your application starts here

Rufen Sie init() genau einmal auf, direkt nach dem Composer-Autoloader und bevor Ihre Anwendung ihre eigenen Klassen lädt. Für den Start genügen diese vier Optionen:

Option Zweck
debug true schaltet den Entwicklungsmodus ein. Verwenden Sie in Produktion false.
appDir Das Wurzelverzeichnis der Anwendung. Nur Dateien darunter werden kompiliert. Standard ist das Verzeichnis, das vendor/ enthält.
cacheDir Wohin der generierte Code geschrieben wird. Diese Option ist Pflicht.
includePaths Die zu kompilierenden Verzeichnisse. Ein leeres Array bedeutet alles unterhalb von appDir.

Halten Sie includePaths eng. Vendor-Code zu kompilieren ist langsam und selten nötig. Ein unbekannter Optionsschlüssel wirft Go\Aop\Exception\InvalidConfigurationException, ein Tippfehler fällt also sofort auf, statt still ignoriert zu werden. Die vollständige Liste der Optionen steht auf der Seite Konfiguration & CLI.

src/Aspect/MonitorAspect.php
<?php
namespace Aspect;
use Go\Aop\Aspect;
use Go\Aop\Intercept\MethodInvocation;
use Go\Lang\Attribute\Before;
/**
* A monitoring behavior class
*/
class MonitorAspect implements Aspect
{
/**
* Method that will be called before real method
*/
#[Before("execution(public Example->*(*))")]
public function beforeMethodExecution(MethodInvocation $invocation): void
{
echo 'Calling Before Interceptor for: ',
$invocation,
' with arguments: ',
json_encode($invocation->getArguments()),
"<br>\n";
}
}

Eine Behavior-Klasse ist eine gewöhnliche PHP-Klasse, die Go\Aop\Aspect implementiert. Jedes Behavior ist eine öffentliche Methode mit genau einem Attribut aus Go\Lang\Attribute, das festlegt, wann sie läuft.

  • Ein #[Before]-Behavior läuft vor dem abgefangenen Aufruf. Die übrigen Attribute sind #[After], #[AfterThrowing] und #[Around].
  • Der String im Attribut ist die Matching-Rule. execution(public Example->*(*)) wählt die Ausführung jeder öffentlichen, nicht statischen Methode der Klasse Example aus.
  • Das Behavior erhält eine MethodInvocation. Sie liefert Ihnen den abgefangenen Aufruf: getArguments() gibt seine Argumente zurück, und als String ergibt die Invocation den Namen der Methode.

Behavior-Methoden müssen public sein. Das Framework ruft sie direkt auf der Instanz der Behavior-Klasse auf, deshalb wird eine protected- oder private-Behavior-Methode schon beim Laden der Klasse abgewiesen. Eine Methode trägt höchstens ein Behavior-Attribut.

app/ApplicationAspectKernel.php
<?php
use Aspect\MonitorAspect;
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
class ApplicationAspectKernel extends AspectKernel
{
/**
* Register the behavior classes in the container
*/
protected function configureAop(AspectContainer $container): void
{
// Deferred (recommended): constructed on first use
$container->addLazyService(MonitorAspect::class, static fn() => new MonitorAspect());
}
}

Eine Behavior-Klasse ist ein Service des Containers des Kernels. addLazyService() registriert eine Factory. Der Compile-Step (Kompilierschritt) liest die Behavior-Klasse nur, die Factory läuft also erst, wenn eines ihrer Behaviors zum ersten Mal ausgeführt wird, nicht vorher.

Wenn Sie die Behavior-Klasse lieber vorab erzeugen, registrieren Sie stattdessen eine Instanz:

$container->add(MonitorAspect::class, new MonitorAspect());

Behavior-Klassen können ihre Abhängigkeiten auch aus dem PSR-11-Container Ihrer Anwendung beziehen, den Sie mit setDelegate() an den Container des Kernels anbinden. Wie das geht, zeigt die Seite Konfiguration & CLI.

Legen Sie eine Klasse an, die die Matching-Rule auswählen kann:

src/Example.php
<?php
class Example
{
public function greet(string $name): string
{
return "Hello, {$name}";
}
}

Verwenden Sie sie dann im Front-Controller, nach init():

public/index.php
<?php
include __DIR__ . '/../vendor/autoload.php';
ApplicationAspectKernel::getInstance()->init([/* … as above … */]);
$example = new Example();
echo $example->greet('World');

Öffnen Sie die Seite im Browser oder führen Sie php public/index.php aus. Vor Hello, World sehen Sie die Zeile aus dem Behavior, mit dem Methodennamen und den Argumenten ["World"]. Example enthält keinen Verweis auf die Behavior-Klasse. Das Behavior wurde an die Klasse gehängt, als der Autoloader sie geladen und kompiliert hat.

Sie rufen das Behavior nie selbst auf. Um festzulegen, für welche Methoden es läuft, ändern Sie die Matching-Rule, nicht die Klassen. Die Seite Behaviors & Matching-Rules erklärt, wann welches Behavior läuft, und die vollständige Syntax der Matching-Rules.

Die Konsole bin/aspect benötigt symfony/console:

Terminal-Fenster
composer require symfony/console
vendor/bin/aspect debug:aspect public/index.php

debug:aspect listet die registrierten Behavior-Klassen und ihre Behaviors auf. Jeder bin/aspect-Befehl erwartet den Pfad zu der Datei, die Ihren Kernel initialisiert, hier den Front-Controller, und führt diese Datei aus. debug:advisor --advisor=... zeigt die abgefangenen Aufrufe, die ein Advisor (ein Behavior mit seiner Matching-Rule) trifft. Greifen Sie zu diesen Befehlen, wenn ein Behavior nicht läuft.

Ihre Klassen werden kompiliert, wenn PHP sie lädt. Zur Laufzeit wird nichts um Ihre Objekte gewickelt, und kein Code wird mit eval() erzeugt. Jede kompilierte Klasse ist eine gewöhnliche PHP-Datei im Cache-Verzeichnis, und genau diese Datei führt PHP aus.

Bei einer kompilierten Klasse wandert der ursprüngliche Klassenrumpf in einen Trait. Eine generierte Klasse mit dem ursprünglichen Klassennamen verwendet diesen Trait, sodass Klassenname, Elternklassen und self:: unverändert bleiben. Jede abgefangene Methode erhält einen Call-Context (Aufrufkontext) mit ihren Behaviors:

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. ->beforeMethodExecution(...) ist die Behavior-Methode, die Sie geschrieben haben, referenziert mit der First-Class-Callable-Syntax. Sie können sie in Ihrer IDE per Ctrl-Klick öffnen, darin einen Breakpoint setzen und den generierten Code schrittweise durchlaufen. Das letzte Argument verweist auf den ursprünglichen Methodenrumpf.

Die Zeilennummern bleiben erhalten, deshalb funktionieren Xdebug-Breakpoints in Ihrem ursprünglichen Code weiterhin. Attribute der Klasse, ihrer Methoden, Parameter, Konstanten und Properties werden in den generierten Code übernommen, das Auslesen per Reflection funktioniert also wie zuvor. Methoden, die keine Matching-Rule auswählt, laufen ganz ohne Interception-Code.

cacheDir enthält die kompilierten Quellen, die Proxys, die Advisor-Caches und die Class-Map. Die Cache-Pfade spiegeln die Quellpfade relativ zu appDir. Die Dateien sind gewöhnliches PHP: Sie können sie öffnen, diffen und mit Ihren Sicherheitswerkzeugen scannen.

Committen Sie das Cache-Verzeichnis nicht. In der Entwicklung füllt das Framework es, während Klassen geladen werden. In Produktion bauen Sie es beim Deployment.

Mit 'debug' => true wird jede Klasse und jedes include über den Stream-Filter des Frameworks geladen, der sie kompiliert. Änderungen an der Kernel-Datei und an den Dateien der Behavior-Klassen invalidieren den Cache, und geänderte Dateien werden bei der nächsten Anfrage neu kompiliert. Es gibt keinen Build-Schritt: Klasse oder Behavior bearbeiten, Seite neu laden.

Der Entwicklungsmodus ist bei heißen Anfragen spürbar langsamer als der Produktionsmodus. Verwenden Sie ihn nicht in Produktion.

Mit 'debug' => false werden kompilierte Klassen über die Class-Map von Composer aus dem Cache geladen. Parser und Transformer werden bei warmen Anfragen gar nicht erst geladen.

Für das Deployment bauen Sie den Cache einmal und weisen den Kernel an, ihm zu vertrauen:

  1. Leeren Sie das Cache-Verzeichnis.

  2. Wärmen Sie den Cache auf:

    Terminal-Fenster
    vendor/bin/aspect cache:warmup:aop public/index.php

    Der Befehl schlägt fehl, wenn sich eine Datei nicht kompilieren lässt, sodass ein Deploy-Skript abbricht, statt einen unvollständigen Cache auszuliefern. Große Projekte kompilieren parallel schneller, zum Beispiel mit --workers=8.

  3. Starten Sie mit 'debug' => false und dem Feature PREBUILT_CACHE:

    public/index.php
    use Go\Aop\Features;
    ApplicationAspectKernel::getInstance()->init([
    'debug' => false,
    'appDir' => __DIR__ . '/..',
    'cacheDir' => __DIR__ . '/../var/cache/aop',
    'includePaths' => [__DIR__ . '/../src'],
    'features' => Features::PREBUILT_CACHE,
    ]);

Mit PREBUILT_CACHE kompiliert eine Anfrage nie und schreibt nie in das Cache-Verzeichnis, sie funktioniert also auch auf einem schreibgeschützten Dateisystem. Der Cache muss vollständig sein: Eine Klasse unterhalb der Include-Pfade, die der Cache nicht kennt, lässt die Anfrage mit einer WeavingException scheitern. Bauen Sie den Cache neu, sobald sich der Code oder die Behavior-Klassen ändern.

Die Seite Produktion & Performance behandelt OPcache, Preloading, Docker und Kubernetes.

Läuft Ihre Anwendung auf Symfony, Laravel oder Yii3, installieren Sie die passende Bridge, statt den Code im Front-Controller selbst zu schreiben. Die Bridge bootet das Framework früh im Lebenszyklus der Anwendung und lässt Sie Behavior-Klassen als Services im Container Ihres Frameworks registrieren. Siehe die Seite Integrationen oder die Repositories goaop/goaop-symfony-bundle, goaop/goaop-laravel-bridge und goaop/goaop-yii3-bridge.

Sie aktualisieren eine Anwendung von Version 3.x? Lesen Sie zuerst die Seite Einschränkungen & Upgrade. Sie führt jede Änderung auf.

Das Repository des Frameworks ist ein Plugin-Marketplace für Coding-Agents. Sein Plugin goaop enthält einen Agent Skill, der einem Agent beibringt, Behavior-Klassen, Behaviors und Matching-Rules zu schreiben, das Framework zu integrieren, den Cache zu deployen und herauszufinden, warum ein Behavior nicht läuft. In Claude Code:

/plugin marketplace add goaop/framework
/plugin install goaop@goaop

© 2026 Alexander Lisachenko