Ein weißer Strahl geht geradlinig durch einen klaren Glasblock mit sanftem rotem Randlicht.
Funktion · Reines PHP

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.

Keine PHP-Extension

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.
index.phpProduktion

        
        
        <?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,
        
        
        
      
        
        
        ]);
        
        
        
      
TerminalDeploy

        
        
        # 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
        
        
        
      
Kein eval()

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.

OrderService.phpIhr Code

        
        
        <?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.

OrderServiceOriginalTrait.phpkompiliert

        
        
        <?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.

OrderService.phpgeneriert

        
        
        <?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]);
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Statische PHP-Dateien

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
OrderService.phpTypinfo

        
        
            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]);
        
        
        
      
        
        
            }
        
        
        
      
ProjectCache-Verzeichnis

        
        
        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.