
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.
Comportamentos aplicados às propriedades, não aos setters
Marque uma propriedade com um atributo, e as leituras e escritas dela disparam automaticamente os comportamentos que você definir.
Quase* qualquer propriedade
Valide, normalize ou audite propriedades public, protected, private, promovidas e final, com a visibilidade assimétrica intacta.
Veja o que é cobertoComo funciona
As propriedades marcadas voltam na classe que o PHP carrega como hooks get e set nativos do PHP 8.4, que executam o comportamento.
Acompanhe uma classeTrilha de auditoria
Marque propriedades com #[Auditable] e registre cada alteração com o valor antigo e o novo, venha a escrita de onde vier.
Veja o comportamento
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.
#[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();}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.
<?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.
<?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.
<?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);
}
}
}
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()
#[\Attribute(\Attribute::TARGET_PROPERTY)]final class Auditable {}$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
<?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;
}
}
<?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.
- por acesso< 0.3 µspara uma leitura ou escrita de propriedade pelo seu middleware
- mágica0sem __get nem __set: IDEs e o PHPStan veem propriedades reais
- nativoPHP 8.4compilado nos próprios property hooks da linguagem
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 pointcutTudo o mais que vem incluído
- PHP puroSem extensões. Sem caixas-pretas. Só PHP.
- Intercepte qualquer coisaNenhum método fica de fora.
- 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.