Um cubo de vidro com um ponto de luz amarela e quente no interior, tocado por dois feixes finos.
Recurso · Property hooks

Intercepte cada leitura e escrita de propriedade.

Valide, normalize e audite o acesso a propriedades sem adicionar getters, setters ou métodos mágicos. Aplique comportamentos diretamente às propriedades e mantenha o seu código legível e analisável estaticamente.

Quase* qualquer propriedade

O que você pode interceptar

Leituras e escritas das propriedades que você declara passam por um comportamento: valide, normalize ou audite. Em uma escrita, proceed() retorna o valor que é armazenado, então um comportamento em volta da escrita pode alterá-lo antes que ele seja gravado.

  • Propriedades public, protected e private declaradas na classe
  • Propriedades promovidas no construtor e final: a atribuição do construtor conta como escrita
  • Propriedades public e protected herdadas de uma classe pai
  • Visibilidade assimétrica (private(set)) e atributos ficam intactos
  • Propriedades de array continuam funcionando com array_push(), via hooks &get
  • Sem suporte: *Propriedades static, readonly e que já têm hooks ficam de fora: o PHP não permite hooks nelas.
src/Aspect/UserAspect.phpnormalizar na escrita
#[Around('access(public App\Entity\User->email)')]public function normalizeEmail(FieldAccess $access): mixed{    if ($access->getAccessType() === FieldAccessType::Write) {        return strtolower($access->proceed());    }     return $access->proceed();}
Como funciona

Hooks nativos do PHP. Gerados automaticamente.

O framework transforma a sua classe em arquivos PHP comuns. As propriedades marcadas são reescritas com hooks get e set nativos do PHP 8.4+, que invocam os comportamentos aplicados sempre que a propriedade é acessada.

A sua classe

Duas propriedades têm #[Auditable], o atributo que o comportamento de auditoria abaixo procura; a terceira, não. O arquivo fica exatamente como você o escreveu.

Customer.phpseu código

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        class Customer
        
        
        
      
        
        
        {
        
        
        
      
        
        
            #[Auditable]
        
        
        
      
        
        
            public string $email = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Auditable]
        
        
        
      
        
        
            public string $plan = 'free';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      

Código compilado

O corpo da sua classe como a trait CustomerOriginalTrait. Cada propriedade marcada deixa uma nota de uma linha, e todas as outras linhas mantêm o seu número para o Xdebug.

CustomerOriginalTrait.phpcompilado

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        trait CustomerOriginalTrait
        antes: class Customer
        
        
      
        
        
        {
        
        
        
      
        
        
            /* Moved by weaving interceptor to the {@see App\Entity\Customer->email} */
        
        
        
      
        
        
         
        
        
        
      
        
        
         
        
        
        
      
        
        
            /* Moved by weaving interceptor to the {@see App\Entity\Customer->plan} */
        
        
        
      
        
        
         
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
        
        
        include_once AOP_CACHE_DIR . '/src/Entity/Customer.php';
        
        
        
      

Classe proxy com hooks

A classe que o PHP carrega: o nome da sua classe, a trait e as propriedades marcadas declaradas de novo com atributo, tipo e valor padrão, mais hooks get e set. Cada hook passa o acesso pelo middleware de auditoria.

Customer.phpgerado

        
        
        <?php
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use Go\Aop\Framework\InterceptorInjector;
        
        
        
      
        
        
        use Go\Aop\Framework\Interceptor;
        
        
        
      
        
        
        use Go\Aop\Framework\The;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccess;
        
        
        
      
        
        
        use App\Aspect\AuditAspect;
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
        class Customer implements \Go\Aop\Proxy
        mesmo nome de classe
        
        
      
        
        
        {
        
        
        
      
        
        
            use CustomerOriginalTrait;
        o resto da sua classe
        
        
      
        
        
            #[\App\Attribute\Auditable]
        atributo mantido
        
        
      
        
        
            public string $email = '' {
        hooks nativos do PHP 8.4
        
        
      
        
        
                get {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        tipado para PHPStan e IDEs
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'email',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        seu comportamento de auditoria
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    return $__joinPoint->read($this, $this->email);
        leituras passam direto
        
        
      
        
        
                }
        
        
        
      
        
        
                set {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'email',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    $this->email = $__joinPoint->write($this, $value, $this->email);
        escritas passam pelo comportamento
        
        
      
        
        
                }
        
        
        
      
        
        
            }
        
        
        
      
        
        
            #[\App\Attribute\Auditable]
        
        
        
      
        
        
            public string $plan = 'free' {
        
        
        
      
        
        
                get {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'plan',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    return $__joinPoint->read($this, $this->plan);
        
        
        
      
        
        
                }
        
        
        
      
        
        
                set {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'plan',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    $this->plan = $__joinPoint->write($this, $value, $this->plan);
        
        
        
      
        
        
                }
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Trilha de auditoria

Audite cada alteração com um atributo

Marque as propriedades que importam com #[Auditable]. O comportamento de auditoria é aplicado a cada uma delas como middleware dinâmico: cada escrita é registrada com o nome da propriedade, o valor antigo e o novo, venha a escrita de onde vier.

  • Cada escrita de uma propriedade marcada, de qualquer código: de fora, de dentro da classe, do construtor
  • O valor antigo e o novo, antes que a escrita seja gravada
  • Propriedades não marcadas e leituras não custam nada a mais
  • A entidade mantém propriedades public simples: sem setters, sem __set()
src/Attribute/Auditable.phpseu atributo
#[\Attribute(\Attribute::TARGET_PROPERTY)]final class Auditable {}
O que é registradouso
$customer->plan = 'pro';         // audit: plan, from "free" to "pro"$customer->upgrade('team');      // audit: plan, from "pro" to "team"$customer->displayName = 'Ann';  // no record: no #[Auditable]echo $customer->email;           // reads pass through untouched
Customer.phpsua entidade

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        class Customer
        
        
        
      
        
        
        {
        
        
        
      
        
        
            #[Auditable]
        auditada
        
        
      
        
        
            public string $email = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Auditable]
        auditada
        
        
      
        
        
            public string $plan = 'free';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        não auditada
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
AuditAspect.phpcomportamento de auditoria

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Aspect;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use Go\Aop\Aspect;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccess;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccessType;
        
        
        
      
        
        
        use Go\Lang\Attribute\Around;
        
        
        
      
        
        
        use Psr\Log\LoggerInterface;
        
        
        
      
        
        
         
        
        
        
      
        
        
        final class AuditAspect implements Aspect
        
        
        
      
        
        
        {
        
        
        
      
        
        
            public function __construct(private LoggerInterface $audit) {}
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Around('@access(App\Attribute\Auditable)')]
        cada propriedade #[Auditable]
        
        
      
        
        
            public function auditWrite(FieldAccess $access): mixed
        
        
        
      
        
        
            {
        
        
        
      
        
        
                if ($access->getAccessType() === FieldAccessType::Write) {
        só escritas
        
        
      
        
        
                    $this->audit->info('Property changed', [
        
        
        
      
        
        
                        'property' => $access->getField()->name,
        
        
        
      
        
        
                        'from'     => $access->getValue(),
        
        
        
      
        
        
                        'to'       => $access->getValueToSet(),
        
        
        
      
        
        
                    ]);
        
        
        
      
        
        
                }
        
        
        
      
        
        
         
        
        
        
      
        
        
                return $access->proceed();
        o valor é gravado
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      

Rápido o bastante para deixar ligado

As medições e a lista completa de regras estão em docs/advices.md e docs/performance.md.

  • mágica0sem __get nem __set: IDEs e o PHPStan veem propriedades reais
  • nativoPHP 8.4compilado nos próprios property hooks da linguagem
Playground

Selecione as suas próprias propriedades

Comece com @access(App\Attribute\Auditable) e depois mude: cada propriedade que ele alcança acende no playground, linha por linha.

Teste o seu pointcut