
Keine Extensions. Keine Blackboxen. Nur PHP.
Das Framework arbeitet mit Composer und erzeugt gewöhnliche PHP-Dateien, an denen Ihr Verhalten bereits hängt. Lesen, debuggen und ausführen können Sie sie mit den Werkzeugen, die Sie schon nutzen.
Ein Composer-Paket. Keine zusätzlichen Tools.
Composer installiert das Framework und seine PHP-Abhängigkeiten. Keine eigene PHP-Extension zu aktivieren, kein Binary auszuliefern.
composer require goaop/frameworkKeine PHP-Extension
Kein PECL- oder PIE-Schritt und kein C-Code. Der Weaver ist ein Composer-Paket in PHP. Es gibt also keine Extension, die Sie installieren, aktivieren oder neu bauen müssen, wenn sich PHP oder Ihr Docker-Base-Image ändert.
Zum SetupKein eval()
Das Framework ruft nie eval() auf. Kompilierte Klassen landen in echten .php-Dateien und werden mit include geladen. OPcache cacht sie, und ein Review sieht jede Zeile.
Eine Klasse verfolgenStatische PHP-Dateien
Aus Ihrer Klasse werden ein Trait und eine kleine Proxy-Klasse mit typisierten Signaturen und generischen Docblocks. IDEs, PHPStan und Security-Scanner lesen sie wie Ihren eigenen Code.
Zu den Typen
Der Compiler ist in PHP geschrieben.
Das Framework ist ein gewöhnliches Composer-Paket. Es parst Ihre Klassen, gleicht sie mit Ihren Regeln ab und erzeugt neuen PHP-Quelltext, an dem das Verhalten bereits hängt. Keine eigene Extension zu installieren, zu aktivieren oder neu zu bauen.
In der Entwicklung werden Klassen beim ersten Laden kompiliert. In Produktion kompilieren Sie sie einmal beim Deployment oder Image-Build mit cache:warmup:aop. Requests binden dann nur noch die generierten PHP-Dateien ein.
- Keine eigene Extension: Nötig ist nur die eingebaute tokenizer-Extension von PHP.
- Kein Neubau nach PHP-Upgrades: kompatible Composer-Abhängigkeiten installieren und den Cache aufwärmen.
- Überall derselbe Compiler: Entwicklung, CI und Produktion.
- Read-only in Produktion: Vorab generierte Dateien laufen auch auf einem schreibgeschützten Dateisystem.
<?php
use Go\Aop\Features;
include __DIR__ . '/../vendor/autoload.php';
ApplicationAspectKernel::getInstance()->init([
'debug' => false,
'appDir' => __DIR__ . '/..',
'cacheDir' => __DIR__ . '/../var/cache/aop',
'includePaths' => [__DIR__ . '/../src'],
'features' => Features::PREBUILT_CACHE,
]);
# install: the weaver is a Composer package
composer require goaop/framework
# deploy: weave the whole cache once
vendor/bin/aspect cache:warmup:aop public/index.php
Generiertes PHP, geladen wie jede andere Datei.
Das Framework erzeugt PHP-Quelltext, statt Code aus Strings auszuführen. Jede kompilierte Klasse ergibt zwei Dateien im Cache, geladen über das normale include von PHP. OPcache behandelt sie wie jede andere PHP-Datei, und jede generierte Zeile bleibt lesbar und debugbar.
Ihr Quelltext
An placeOrder() hängt ein Transaktionsverhalten. Ihre Datei bleibt genau so, wie Sie sie geschrieben haben.
<?php
declare(strict_types=1);
namespace App\Order;
final class OrderService
{
public function __construct(
private readonly OrderRepository $orders,
) {}
public function placeOrder(Cart $cart): Order
{
return $this->orders->create($cart);
}
}
Kompilierter Quelltext
Ihr Klassenrumpf als Trait OrderServiceOriginalTrait. Nur die Deklarationszeile ändert sich, daher stimmen die Zeilennummern, und Xdebug-Breakpoints greifen weiterhin. Eine zusätzliche Zeile lädt den Proxy.
<?php
declare(strict_types=1);
namespace App\Order;
trait OrderServiceOriginalTrait
vorher: final class OrderService
{
public function __construct(
private readonly OrderRepository $orders,
) {}
public function placeOrder(Cart $cart): Order
{
return $this->orders->create($cart);
}
}
include_once AOP_CACHE_DIR . '/src/Order/OrderService.php';
Proxy-Klasse
Die Klasse, die PHP lädt: Ihr Klassenname, weiterhin final, mit dem Trait. Jede Methode mit Verhalten führt es als Middleware aus und ruft dann Ihre ursprüngliche Methode über einen privaten Alias auf.
<?php
declare(strict_types=1);
namespace App\Order;
use Go\Aop\Framework\InterceptorInjector;
use Go\Aop\Framework\Interceptor;
use Go\Aop\Framework\The;
use Go\Aop\Intercept\DynamicMethodInvocation;
use App\Aspect\TransactionAspect;
final class OrderService implements \Go\Aop\Proxy
gleicher Name, weiter final
{
use OrderServiceOriginalTrait {
Ihr Klassenrumpf
OrderServiceOriginalTrait::placeOrder as private placeOrderOriginalAlias;
}
public function placeOrder(\App\Order\Cart $cart): \App\Order\Order
{
/** @var DynamicMethodInvocation<self, \App\Order\Order> $__joinPoint */
typisiert für PHPStan und IDEs
static $__joinPoint = InterceptorInjector::forMethod(
self::class,
'placeOrder',
[
Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
Strg-Klick öffnet das Verhalten
],
$this->placeOrderOriginalAlias(...),
Ihre ursprüngliche Methode
);
return $__joinPoint->__invoke($this, [$cart]);
}
}
Objektorientierter Code, den PHPStan versteht
Der kompilierte Code besteht aus Klassen und Traits mit typisierten Signaturen, ohne magische Methoden dazwischen. Jeder Joinpoint trägt einen generischen Docblock, sodass PHPStan und Ihre IDE wissen, dass $__joinPoint->__invoke() eine Order zurückgibt, selbst im Cache-Verzeichnis.
- Ihr Klassenname, das Schlüsselwort final und die typisierten Signaturen bleiben erhalten
- Alles, was läuft, ist eine Datei im Cache, ohne Umweg über __call()
- Joinpoints deklarieren @template-Typen, z. B. MethodInvocation<OrderService, Order>
- Die Cache-Pfade spiegeln Ihren Quelltext, sodass Reviewer und Scanner jede Datei finden
public function placeOrder(\App\Order\Cart $cart): \App\Order\Order
{
/** @var DynamicMethodInvocation<self, \App\Order\Order> $__joinPoint */
static $__joinPoint = InterceptorInjector::forMethod(
static $__joinPoint
DynamicMethodInvocation<OrderService, Order>__invoke(…): Order
Aus dem @var-Docblock in der kompilierten Datei
self::class,
'placeOrder',
[
Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
],
$this->placeOrderOriginalAlias(...),
);
return $__joinPoint->__invoke($this, [$cart]);
}
var/cache/aop/
├── _include.cache # class map for Composer
└── src/
├── Aspect/
│ └── TransactionAspect.cache.php # compiled pointcuts of the behavior
└── Order/
├── OrderService.php # proxy class
└── OrderServiceOriginalTrait.php # your class body
Die kompilierte Methode ruft Ihr Verhalten direkt als First-Class-Callable auf, sodass Ihre IDE dorthin springen kann. Details stehen in der README.
Alles andere, was dabei ist
- Alles abfangenKeine Methode ist tabu.
- Property-HooksJeden Lese- und Schreibzugriff auf Properties abfangen.
- DebugbarKeine Magie, die Sie nicht Schritt für Schritt durchgehen können.
- PerformanceKeine Kosten ohne Verhalten, unter 1 µs mit.
- Pointcut-SpracheWählen Sie genau den Code aus, den Sie meinen, und probieren Sie es live aus.
- KlassenerweiterungenNeue Interfaces und Traits für bestehende Klassen.
- Passt zu Ihrem StackSymfony, Laravel, Yii3 und Ihr KI-Coding-Agent.