var exporter

Composant VarExporter

Le composant VarExporter fournit divers outils pour gérer l'état interne des objets :

• VarExporter::export() permet d'exporter n'importe quelle structure de données PHP sérialisable vers du code PHP brut. Ce faisant, il préserve toute la sémantique associée au mécanisme de sérialisation de PHP ( __wakeup , __sleep , Serializable , __serialize , __unserialize ) ;
• Instantiator::instantiate() crée un objet et définit ses propriétés sans appeler son constructeur ni aucune autre méthode ;
• Hydrator::hydrate() peut définir les propriétés d'un objet existant ;
• Lazy*Trait peut faire en sorte qu'une classe se comporte comme un fantôme à chargement paresseux ou un proxy virtuel.

VarExporter::export()

La raison d'utiliser VarExporter::export() vs serialize() ou igbinary est la performance : grâce à OPcache, le code résultant est nettement plus rapide et plus efficace en mémoire que l'utilisation unserialize() ou igbinary_unserialize() .

Contrairement à var_export() , cela fonctionne sur n'importe quelle valeur PHP sérialisable.

Il apporte également quelques améliorations par rapport à var_export() / serialize() :

• la sortie est compatible PSR-2 ;
• la sortie peut être réindentée sans gâcher r ou n dans les données ;
• les classes manquantes renvoient une ClassNotFoundException au lieu d'être désérialisées en objets PHP_Incomplete_Class ;
• les références impliquant des instances SplObjectStorage , ArrayObject ou ArrayIterator sont conservées ;
• Les classes Reflection* , IteratorIterator et RecursiveIteratorIterator lèvent une exception lors de la sérialisation (leur version non sérialisée est de toute façon cassée, voir https://bugs.php.net/76737).

Instantiateur et Hydrateur

Instantiator::instantiate($class) crée un objet de la classe donnée sans appeler son constructeur ni aucune autre méthode.

Hydrator::hydrate() définit les propriétés d'un objet existant, y compris les propriétés privées et protégées. Par exemple:

 // Sets the public or protected $object->propertyName property
Hydrator:: hydrate ( $ object , [ ' propertyName ' => $ propertyValue ]);

// Sets a private property defined on its parent Bar class:
Hydrator:: hydrate ( $ object , [ " Bar  privateBarProperty " => $ propertyValue ]);

// Alternative way to set the private $object->privateBarProperty property
Hydrator:: hydrate ( $ object , [], [
    Bar::class => [ ' privateBarProperty ' => $ propertyValue ],
]);

Lazy*Trait

Le composant fournit deux modèles de chargement différé : les objets fantômes et les proxys virtuels (voir https://martinfowler.com/eaaCatalog/lazyLoad.html pour référence).

Les objets fantômes fonctionnent uniquement avec des classes concrètes et non internes. Dans le cas générique, ils ne sont pas compatibles avec l'utilisation d'usines dans leur initialiseur.

Les proxys virtuels fonctionnent avec des classes concrètes, abstraites ou internes. Ils fournissent une API qui ressemble aux objets réels et leur transmettent les appels. Ils peuvent poser des problèmes d'identité car les proxys peuvent ne pas être considérés comme des équivalents aux objets réels qu'ils proxy.

En raison de ce problème d’identité, les objets fantômes doivent être privilégiés lorsque cela est possible. Les exceptions levées par la classe ProxyHelper peuvent aider à décider quand elle peut être utilisée ou non.

Les objets fantômes et les proxys virtuels fournissent tous deux des implémentations pour LazyObjectInterface qui permettent de les réinitialiser à leur état initial ou de les initialiser de force en cas de besoin. Notez que la réinitialisation d'un objet fantôme ignore ses propriétés en lecture seule. Vous devez utiliser un proxy virtuel pour réinitialiser les propriétés en lecture seule.

LazyGhostTrait

En utilisant LazyGhostTrait soit directement dans vos classes, soit en utilisant ProxyHelper::generateLazyGhost() , vous pouvez rendre leurs instances téléchargeables paresseusement. Cela fonctionne en créant ces instances vides et en calculant leur état uniquement lors de l'accès à une propriété.

 class FooLazyGhost extends Foo
{
    use LazyGhostTrait;
}

$ foo = FooLazyGhost:: createLazyGhost (initializer: function ( Foo $ instance ): void {
    // [...] Use whatever heavy logic you need here
    // to compute the $dependencies of the $instance
    $ instance -> __construct (... $ dependencies );
    // [...] Call setters, etc. if needed
});

// $foo is now a lazy-loading ghost object. The initializer will
// be called only when and if a *property* is accessed.

LazyProxyTrait

Alternativement, LazyProxyTrait peut être utilisé pour créer des proxys virtuels :

 $ proxyCode = ProxyHelper:: generateLazyProxy ( new ReflectionClass (Foo::class));
// $proxyCode contains the reference to LazyProxyTrait
// and should be dumped into a file in production envs
eval ( ' class FooLazyProxy ' . $ proxyCode );

$ foo = FooLazyProxy:: createLazyProxy (initializer: function (): Foo {
    // [...] Use whatever heavy logic you need here
    // to compute the $dependencies of the $instance
    $ instance = new Foo (... $ dependencies );
    // [...] Call setters, etc. if needed

    return $ instance ;
});
// $foo is now a lazy-loading virtual proxy object. The initializer will
// be called only when and if a *method* is called. 

Ressources

• Documentation
• Contribuer
• Signaler les problèmes et envoyer des Pull Requests dans le référentiel Symfony principal