Un haz blanco atraviesa en línea recta un bloque de vidrio transparente con un suave borde de luz roja.
Funcionalidad · PHP puro

Sin extensiones. Sin cajas negras. Solo PHP.

El framework funciona con Composer y genera archivos PHP corrientes con tus comportamientos ya aplicados. Léelos, depúralos y ejecútalos con las herramientas que ya usas.

Sin extensión de PHP

El compilador está escrito en PHP.

El framework funciona como un paquete de Composer cualquiera. Analiza tus clases, las compara con tus reglas y genera nuevo código PHP con los comportamientos aplicados. Ninguna extensión propia que instalar, activar o recompilar.

En desarrollo, las clases se compilan la primera vez que se cargan. En producción, compílalas una sola vez durante el despliegue o la construcción de la imagen con cache:warmup:aop. Las peticiones solo incluyen los archivos PHP generados.

  • Ninguna extensión propia: solo hace falta la extensión tokenizer, que viene con PHP.
  • Nada que recompilar al actualizar PHP: instala dependencias de Composer compatibles y precalienta la caché.
  • El mismo compilador en todas partes: desarrollo, CI y producción.
  • Producción de solo lectura: los archivos generados de antemano pueden ejecutarse desde un sistema de archivos de solo lectura.
index.phpproducción

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

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

PHP generado, cargado como cualquier otro archivo.

El framework genera código PHP en lugar de ejecutar código a partir de cadenas. Cada clase compilada produce dos archivos en la caché, que se cargan con el include estándar de PHP. OPcache los trata como cualquier otro archivo PHP, y cada línea generada sigue a la vista para inspeccionarla y depurarla.

Tu código

Un comportamiento transaccional se aplica a placeOrder(). Tu archivo queda exactamente como lo escribiste.

OrderService.phptu código

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

Código compilado

El cuerpo de tu clase, como el trait OrderServiceOriginalTrait. Solo cambia la línea de la declaración, así que los números de línea coinciden y los breakpoints de Xdebug siguen saltando. Una línea añadida carga el proxy.

OrderServiceOriginalTrait.phpcompilado

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

Clase proxy

La clase que carga PHP: el nombre de tu clase, todavía final, que usa el trait. Cada método con un comportamiento lo ejecuta como middleware y luego llama a tu método original a través de un alias privado.

OrderService.phpgenerado

        
        
        <?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
        mismo nombre, sigue final
        
        
      
        
        
        {
        
        
        
      
        
        
            use OrderServiceOriginalTrait {
        el cuerpo de tu clase
        
        
      
        
        
                OrderServiceOriginalTrait::placeOrder as private placeOrderOriginalAlias;
        
        
        
      
        
        
            }
        
        
        
      
        
        
            public function placeOrder(\App\Order\Cart $cart): \App\Order\Order
        
        
        
      
        
        
            {
        
        
        
      
        
        
                /** @var DynamicMethodInvocation<self, \App\Order\Order> $__joinPoint */
        tipado para PHPStan e IDE
        
        
      
        
        
                static $__joinPoint = InterceptorInjector::forMethod(
        
        
        
      
        
        
                    self::class,
        
        
        
      
        
        
                    'placeOrder',
        
        
        
      
        
        
                    [
        
        
        
      
        
        
                        Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
        Ctrl-clic abre el comportamiento
        
        
      
        
        
                    ],
        
        
        
      
        
        
                    $this->placeOrderOriginalAlias(...),
        tu método original
        
        
      
        
        
                );
        
        
        
      
        
        
                return $__joinPoint->__invoke($this, [$cart]);
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Archivos PHP estáticos

Código orientado a objetos que PHPStan entiende

El código compilado son clases y traits con firmas tipadas, sin métodos mágicos de por medio. Cada joinpoint lleva un docblock genérico, así que PHPStan y tu IDE saben que $__joinPoint->__invoke() devuelve un Order, incluso dentro del directorio de caché.

  • Se conservan el nombre de tu clase, la palabra clave final y las firmas tipadas
  • Todo lo que se ejecuta es un archivo de la caché, sin la indirección de __call()
  • Los joinpoints declaran tipos @template, p. ej. MethodInvocation<OrderService, Order>
  • Las rutas de la caché reflejan tu código fuente, así que revisores y escáneres encuentran cada archivo
OrderService.phpinfo de tipos

        
        
            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
            Del docblock @var del archivo compilado
          
      
        
        
                    self::class,
        
        
        
      
        
        
                    'placeOrder',
        
        
        
      
        
        
                    [
        
        
        
      
        
        
                        Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
        
        
        
      
        
        
                    ],
        
        
        
      
        
        
                    $this->placeOrderOriginalAlias(...),
        
        
        
      
        
        
                );
        
        
        
      
        
        
                return $__joinPoint->__invoke($this, [$cart]);
        
        
        
      
        
        
            }
        
        
        
      
Projectdirectorio de caché

        
        
        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
        
        
        
      

El método compilado llama a tu comportamiento directamente, como first-class callable, así que tu IDE puede saltar a él. Más detalles en el README.