
Pas d’extension. Pas de boîte noire. Juste du PHP.
Le framework fonctionne avec Composer et génère des fichiers PHP ordinaires auxquels vos comportements sont attachés. Lisez-les, déboguez-les et exécutez-les avec les outils que vous utilisez déjà.
Un seul paquet Composer. Aucun outil en plus.
Composer installe le framework et ses dépendances PHP. Aucune extension PHP spécifique à activer, aucun binaire à livrer.
composer require goaop/frameworkAucune extension PHP
Pas d’étape PECL ou PIE, pas de code C. Le moteur est un paquet Composer écrit en PHP : aucune extension à installer, à activer ou à recompiler quand PHP ou votre image Docker de base change.
Voir l’installationPas d’eval()
Le framework n’appelle jamais eval(). Les classes compilées sont écrites dans de vrais fichiers .php et chargées avec include : OPcache les met en cache, et une revue de code en voit chaque ligne.
Suivre une classeDes fichiers PHP statiques
Votre classe devient un trait et une petite classe proxy, avec des signatures typées et des docblocks génériques. Les IDE, PHPStan et les scanners de sécurité les lisent comme votre propre code.
Voir les types
Le compilateur est écrit en PHP.
Le framework fonctionne comme un paquet Composer ordinaire. Il analyse vos classes, les confronte à vos règles et génère un nouveau code source PHP auquel les comportements sont attachés. Aucune extension spécifique à installer, à activer ou à recompiler.
En développement, les classes sont compilées à leur premier chargement. En production, compilez-les une fois pour toutes pendant le déploiement ou la construction de l’image, avec cache:warmup:aop. Les requêtes se contentent d’inclure les fichiers PHP générés.
- Aucune extension spécifique : seule l’extension tokenizer intégrée à PHP est requise.
- Pas de recompilation après une mise à jour de PHP : installez des dépendances Composer compatibles et préchauffez le cache.
- Le même compilateur partout : développement, CI et production.
- Production en lecture seule : les fichiers générés à l’avance peuvent s’exécuter depuis un système de fichiers en lecture seule.
<?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
Du PHP généré, chargé comme n’importe quel autre fichier.
Le framework génère du code source PHP au lieu d’exécuter du code contenu dans des chaînes. Chaque classe compilée produit deux fichiers dans le cache, chargés par l’include standard de PHP. OPcache les traite comme n’importe quel autre fichier PHP, et chaque ligne générée reste lisible et débogable.
Votre source
Un comportement transactionnel est attaché à placeOrder(). Votre fichier reste exactement tel que vous l’avez écrit.
<?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);
}
}
Source compilée
Le corps de votre classe, sous la forme du trait OrderServiceOriginalTrait. Seule la ligne de déclaration change : les numéros de ligne correspondent et les points d’arrêt Xdebug se déclenchent toujours. Une ligne ajoutée charge le proxy.
<?php
declare(strict_types=1);
namespace App\Order;
trait OrderServiceOriginalTrait
avant : 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
La classe que PHP charge : le nom de votre classe, toujours final, qui utilise le trait. Chaque méthode dotée d’un comportement l’exécute comme middleware, puis appelle votre méthode d’origine via un alias privé.
<?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
même nom, toujours final
{
use OrderServiceOriginalTrait {
le corps de votre classe
OrderServiceOriginalTrait::placeOrder as private placeOrderOriginalAlias;
}
public function placeOrder(\App\Order\Cart $cart): \App\Order\Order
{
/** @var DynamicMethodInvocation<self, \App\Order\Order> $__joinPoint */
typé pour PHPStan et les IDE
static $__joinPoint = InterceptorInjector::forMethod(
self::class,
'placeOrder',
[
Interceptor::around(The::aspect(TransactionAspect::class)->inTransaction(...)),
Ctrl-clic ouvre le comportement
],
$this->placeOrderOriginalAlias(...),
votre méthode d’origine
);
return $__joinPoint->__invoke($this, [$cart]);
}
}
Du code orienté objet que PHPStan comprend
Le code compilé se compose de classes et de traits aux signatures typées, sans méthode magique entre les deux. Chaque joinpoint porte un docblock générique : PHPStan et votre IDE savent que $__joinPoint->__invoke() renvoie un Order, même dans le répertoire du cache.
- Le nom de votre classe, le mot-clé final et les signatures typées sont conservés
- Tout ce qui s’exécute est un fichier du cache, sans indirection par __call()
- Les joinpoints déclarent des types @template, par exemple MethodInvocation<OrderService, Order>
- Les chemins du cache reflètent vos sources : relecteurs et scanners retrouvent chaque fichier
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
Issu du docblock @var du fichier compilé
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
La méthode compilée appelle votre comportement directement, comme un callable de première classe : votre IDE peut donc y naviguer. Les détails sont dans le README.
Tout le reste, déjà inclus
- Tout intercepterAucune méthode n’est hors d’atteinte.
- Property hooksInterceptez chaque lecture et chaque écriture de propriété.
- DébogableAucune magie que vous ne puissiez suivre pas à pas.
- PerformancesCoût nul sans comportement, moins de 1 µs avec.
- Langage de pointcutsSélectionnez exactement le code visé, et testez-le en direct.
- Extensions de classeDe nouvelles interfaces et de nouveaux traits pour des classes existantes.
- S’intègre à votre stackSymfony, Laravel, Yii3 et votre agent de codage IA.