Um feixe branco atravessa em linha reta um bloco de vidro transparente com uma suave borda de luz vermelha.
Recurso · PHP puro

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.

Sem extensão do PHP

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.
index.phpprodução

        
        
        <?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
        
        
        
      
Sem eval()

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.

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

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.

OrderServiceOriginalTrait.phpcompilado

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

OrderService.phpgerado

        
        
        <?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]);
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Arquivos PHP estáticos

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

        
        
            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]);
        
        
        
      
        
        
            }
        
        
        
      
Projectdiretório de 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
        
        
        
      

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.