
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.
Un paquete de Composer. Ninguna herramienta extra.
Composer instala el framework y sus dependencias PHP. Ninguna extensión de PHP propia que activar, ningún binario que distribuir.
composer require goaop/frameworkSin extensión de PHP
Sin paso por PECL ni PIE y sin código C. El compilador es un paquete de Composer escrito en PHP, así que no hay ninguna extensión que instalar, activar o recompilar cuando cambia PHP o tu imagen base de Docker.
Ver la instalaciónSin eval()
El framework nunca llama a eval(). Las clases compiladas se escriben en archivos .php reales y se cargan con include, así que OPcache las cachea y una revisión ve cada línea.
Sigue una claseArchivos PHP estáticos
Tu clase se convierte en un trait más una pequeña clase proxy con firmas tipadas y docblocks genéricos. Los IDE, PHPStan y los escáneres de seguridad los leen como tu propio código.
Ver los tipos
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.
<?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
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.
<?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.
<?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.
<?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]);
}
}
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
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]);
}
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.
Todo lo demás que incluye
- Intercepta cualquier cosaNingún método queda fuera de alcance.
- Hooks de propiedadesIntercepta cada lectura y escritura de una propiedad.
- DepurableNada de magia que no puedas recorrer paso a paso.
- RendimientoCoste cero sin comportamientos, menos de 1 µs con ellos.
- Lenguaje de pointcutsSelecciona exactamente el código que quieres y pruébalo en vivo.
- Extensiones de claseNuevas interfaces y traits para clases existentes.
- Encaja en tu stackSymfony, Laravel, Yii3 y tu agente de programación con IA.