Un faisceau blanc traverse un bloc de verre transparent, souligné d’un léger liseré de lumière rouge.
Fonctionnalité · PHP pur

Pas d’extension. Pas de boîte noire. Juste du PHP.

Le framework fonctionne avec Composer et génère des fichiers PHP ordinaires auxquels vos comportements sont attachés. Lisez-les, déboguez-les et exécutez-les avec les outils que vous utilisez déjà.

Aucune extension PHP

Le compilateur est écrit en PHP.

Le framework fonctionne comme un paquet Composer ordinaire. Il analyse vos classes, les confronte à vos règles et génère un nouveau code source PHP auquel les comportements sont attachés. Aucune extension spécifique à installer, à activer ou à recompiler.

En développement, les classes sont compilées à leur premier chargement. En production, compilez-les une fois pour toutes pendant le déploiement ou la construction de l’image, avec cache:warmup:aop. Les requêtes se contentent d’inclure les fichiers PHP générés.

  • Aucune extension spécifique : seule l’extension tokenizer intégrée à PHP est requise.
  • Pas de recompilation après une mise à jour de PHP : installez des dépendances Composer compatibles et préchauffez le cache.
  • Le même compilateur partout : développement, CI et production.
  • Production en lecture seule : les fichiers générés à l’avance peuvent s’exécuter depuis un système de fichiers en lecture seule.
index.phpproduction

        
        
        <?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,
        
        
        
      
        
        
        ]);
        
        
        
      
Terminaldéploiement

        
        
        # 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
        
        
        
      
Pas d’eval()

Du PHP généré, chargé comme n’importe quel autre fichier.

Le framework génère du code source PHP au lieu d’exécuter du code contenu dans des chaînes. Chaque classe compilée produit deux fichiers dans le cache, chargés par l’include standard de PHP. OPcache les traite comme n’importe quel autre fichier PHP, et chaque ligne générée reste lisible et débogable.

Votre source

Un comportement transactionnel est attaché à placeOrder(). Votre fichier reste exactement tel que vous l’avez écrit.

OrderService.phpvotre 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);
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      

Source compilée

Le corps de votre classe, sous la forme du trait OrderServiceOriginalTrait. Seule la ligne de déclaration change : les numéros de ligne correspondent et les points d’arrêt Xdebug se déclenchent toujours. Une ligne ajoutée charge le proxy.

OrderServiceOriginalTrait.phpcompilé

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Order;
        
        
        
      
        
        
         
        
        
        
      
        
        
        trait OrderServiceOriginalTrait
        avant : 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';
        
        
        
      

Classe proxy

La classe que PHP charge : le nom de votre classe, toujours final, qui utilise le trait. Chaque méthode dotée d’un comportement l’exécute comme middleware, puis appelle votre méthode d’origine via un alias privé.

OrderService.phpgénéré

        
        
        <?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
        même nom, toujours final
        
        
      
        
        
        {
        
        
        
      
        
        
            use OrderServiceOriginalTrait {
        le corps de votre classe
        
        
      
        
        
                OrderServiceOriginalTrait::placeOrder as private placeOrderOriginalAlias;
        
        
        
      
        
        
            }
        
        
        
      
        
        
            public function placeOrder(\App\Order\Cart $cart): \App\Order\Order
        
        
        
      
        
        
            {
        
        
        
      
        
        
                /** @var DynamicMethodInvocation<self, \App\Order\Order> $__joinPoint */
        typé pour PHPStan et les IDE
        
        
      
        
        
                static $__joinPoint = InterceptorInjector::forMethod(
        
        
        
      
        
        
                    self::class,
        
        
        
      
        
        
                    'placeOrder',
        
        
        
      
        
        
                    [
        
        
        
      
        
        
                        Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
        Ctrl-clic ouvre le comportement
        
        
      
        
        
                    ],
        
        
        
      
        
        
                    $this->placeOrderOriginalAlias(...),
        votre méthode d’origine
        
        
      
        
        
                );
        
        
        
      
        
        
                return $__joinPoint->__invoke($this, [$cart]);
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Fichiers PHP statiques

Du code orienté objet que PHPStan comprend

Le code compilé se compose de classes et de traits aux signatures typées, sans méthode magique entre les deux. Chaque joinpoint porte un docblock générique : PHPStan et votre IDE savent que $__joinPoint->__invoke() renvoie un Order, même dans le répertoire du cache.

  • Le nom de votre classe, le mot-clé final et les signatures typées sont conservés
  • Tout ce qui s’exécute est un fichier du cache, sans indirection par __call()
  • Les joinpoints déclarent des types @template, par exemple MethodInvocation<OrderService, Order>
  • Les chemins du cache reflètent vos sources : relecteurs et scanners retrouvent chaque fichier
OrderService.phpinfos de type

        
        
            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
            Issu du docblock @var du fichier compilé
          
      
        
        
                    self::class,
        
        
        
      
        
        
                    'placeOrder',
        
        
        
      
        
        
                    [
        
        
        
      
        
        
                        Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
        
        
        
      
        
        
                    ],
        
        
        
      
        
        
                    $this->placeOrderOriginalAlias(...),
        
        
        
      
        
        
                );
        
        
        
      
        
        
                return $__joinPoint->__invoke($this, [$cart]);
        
        
        
      
        
        
            }
        
        
        
      
Projectrépertoire du cache

        
        
        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
        
        
        
      

La méthode compilée appelle votre comportement directement, comme un callable de première classe : votre IDE peut donc y naviguer. Les détails sont dans le README.