
Sem extensões. Sem caixas-pretas. Só PHP.
O framework funciona com o Composer e gera arquivos PHP comuns com os seus comportamentos já aplicados. Leia, depure e execute esses arquivos com as ferramentas que você já usa.
Um pacote do Composer. Nenhuma ferramenta extra.
O Composer instala o framework e as suas dependências PHP. Nenhuma extensão personalizada do PHP para habilitar, nenhum binário para distribuir.
composer require goaop/frameworkSem extensão do PHP
Nenhuma etapa de PECL ou PIE e nenhum código C. O compilador é um pacote do Composer escrito em PHP, então não há extensão para instalar, habilitar ou recompilar quando o PHP ou a sua imagem base do Docker mudam.
Veja a configuraçãoSem eval()
O framework nunca chama eval(). As classes compiladas são gravadas em arquivos .php de verdade e carregadas com include, então o OPcache as mantém em cache e uma revisão enxerga cada linha.
Acompanhe uma classeArquivos PHP estáticos
A sua classe vira uma trait mais uma pequena classe proxy, com assinaturas tipadas e docblocks genéricos. IDEs, o PHPStan e scanners de segurança leem esses arquivos como se fossem o seu próprio código.
Veja os tipos
O compilador é escrito em PHP.
O framework funciona como um pacote comum do Composer. Ele analisa as suas classes, verifica quais correspondem às suas regras e gera um novo código-fonte PHP com os comportamentos aplicados. Nenhuma extensão personalizada para instalar, habilitar ou recompilar.
Em desenvolvimento, as classes são compiladas quando carregadas pela primeira vez. Em produção, compile-as uma única vez durante o deploy ou o build da imagem com cache:warmup:aop. As requisições apenas fazem include dos arquivos PHP gerados.
- Sem extensão personalizada: só a extensão tokenizer, que já vem com o PHP, é necessária.
- Sem recompilar depois de atualizar o PHP: basta instalar dependências compatíveis do Composer e aquecer o cache.
- O mesmo compilador em todo lugar: desenvolvimento, CI e produção.
- Produção somente leitura: os arquivos gerados de antemão rodam a partir de um sistema de arquivos somente leitura.
<?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 gerado, carregado como qualquer outro arquivo.
O framework gera código-fonte PHP em vez de executar código a partir de strings. Cada classe compilada produz dois arquivos no cache, carregados pelo include padrão do PHP. O OPcache os trata como qualquer outro arquivo PHP, e cada linha gerada continua aberta para inspeção e depuração.
O seu código-fonte
Um comportamento de transação é aplicado a placeOrder(). O seu arquivo fica exatamente como você o escreveu.
<?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
O corpo da sua classe, como a trait OrderServiceOriginalTrait. Só a linha da declaração muda, então os números de linha batem e os breakpoints do Xdebug continuam disparando. Uma linha adicionada carrega o proxy.
<?php
declare(strict_types=1);
namespace App\Order;
trait OrderServiceOriginalTrait
antes: 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
A classe que o PHP carrega: o nome da sua classe, ainda final, usando a trait. Cada método com um comportamento o executa como middleware e depois chama o seu método original por meio de um 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
mesmo nome, ainda final
{
use OrderServiceOriginalTrait {
o corpo da sua classe
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 IDEs
static $__joinPoint = InterceptorInjector::forMethod(
self::class,
'placeOrder',
[
Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
Ctrl-clique abre o comportamento
],
$this->placeOrderOriginalAlias(...),
o seu método original
);
return $__joinPoint->__invoke($this, [$cart]);
}
}
Código orientado a objetos que o PHPStan entende
O código compilado são classes e traits com assinaturas tipadas, sem métodos mágicos no meio do caminho. Cada joinpoint traz um docblock genérico, então o PHPStan e a sua IDE sabem que $__joinPoint->__invoke() retorna um Order, mesmo dentro do diretório de cache.
- O nome da sua classe, a palavra-chave final e as assinaturas tipadas são mantidos
- Tudo o que roda é um arquivo no cache, sem indireção via __call()
- Os joinpoints declaram tipos @template, por exemplo MethodInvocation<OrderService, Order>
- Os caminhos do cache espelham o seu código-fonte, então revisores e scanners encontram cada arquivo
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
Do docblock @var no arquivo 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
O método compilado chama o seu comportamento diretamente, como first-class callable, para que a sua IDE consiga pular até ele. Detalhes no README.
Tudo o mais que vem incluído
- Intercepte qualquer coisaNenhum método fica de fora.
- Property hooksIntercepte cada leitura e escrita de propriedade.
- DepurávelNenhuma mágica que você não possa percorrer passo a passo.
- DesempenhoCusto zero sem comportamentos, menos de 1 µs com eles.
- Linguagem de pointcutsSelecione exatamente o código que você quer e teste ao vivo.
- Extensões de classeNovas interfaces e traits para classes existentes.
- Funciona com a sua stackSymfony, Laravel, Yii3 e o seu agente de programação com IA.