var exporter

VarExporter-Komponente

Die VarExporter-Komponente stellt verschiedene Tools zum Umgang mit dem internen Zustand von Objekten bereit:

• VarExporter::export() ermöglicht den Export jeder serialisierbaren PHP-Datenstruktur in einfachen PHP-Code. Dabei bleibt die gesamte Semantik erhalten, die mit dem Serialisierungsmechanismus von PHP verbunden ist ( __wakeup , __sleep , Serializable , __serialize , __unserialize );
• Instantiator::instantiate() erstellt ein Objekt und legt seine Eigenschaften fest, ohne seinen Konstruktor oder andere Methoden aufzurufen;
• Hydrator::hydrate() kann die Eigenschaften eines vorhandenen Objekts festlegen;
• Lazy*Trait kann dafür sorgen, dass sich eine Klasse wie ein Lazy-Loading-Ghost oder ein virtueller Proxy verhält.

VarExporter::export()

Der Grund für die Verwendung VarExporter::export() gegenüber serialize() oder igbinary ist die Leistung: Dank OPcache ist der resultierende Code deutlich schneller und speichereffizienter als die Verwendung von unserialize() oder igbinary_unserialize() .

Im Gegensatz zu var_export() funktioniert dies mit jedem serialisierbaren PHP-Wert.

Es bietet auch einige Verbesserungen gegenüber var_export() / serialize() :

• der Ausgang ist PSR-2-kompatibel;
• Die Ausgabe kann erneut eingerückt werden, ohne dass r oder n in den Daten durcheinander gebracht wird.
• fehlende Klassen lösen eine ClassNotFoundException aus, anstatt in PHP_Incomplete_Class -Objekte unserialisiert zu werden;
• Referenzen, die SplObjectStorage , ArrayObject oder ArrayIterator Instanzen betreffen, bleiben erhalten;
• Die Klassen Reflection* , IteratorIterator und RecursiveIteratorIterator lösen eine Ausnahme aus, wenn sie serialisiert werden (ihre nicht-erialisierte Version ist ohnehin fehlerhaft, siehe https://bugs.php.net/76737).

Instantiator und Hydrator

Instantiator::instantiate($class) erstellt ein Objekt der angegebenen Klasse, ohne seinen Konstruktor oder andere Methoden aufzurufen.

Hydrator::hydrate() legt die Eigenschaften eines vorhandenen Objekts fest, einschließlich privater und geschützter Objekte. Zum Beispiel:

 // 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

Die Komponente bietet zwei Lazy-Loading-Muster: Geisterobjekte und virtuelle Proxys (siehe https://martinfowler.com/eaaCatalog/lazyLoad.html als Referenz).

Geisterobjekte funktionieren nur mit konkreten und nicht internen Klassen. Im generischen Fall sind sie nicht mit der Verwendung von Fabriken in ihrem Initialisierer kompatibel.

Virtuelle Proxys arbeiten mit konkreten, abstrakten oder internen Klassen. Sie stellen eine API bereit, die den tatsächlichen Objekten ähnelt, und leiten Aufrufe an diese weiter. Sie können Identitätsprobleme verursachen, da Proxys möglicherweise nicht als Äquivalent zu den tatsächlichen Objekten angesehen werden, die sie vertreten.

Aufgrund dieses Identitätsproblems sollten nach Möglichkeit Geisterobjekte bevorzugt werden. Von der ProxyHelper -Klasse ausgelöste Ausnahmen können bei der Entscheidung helfen, wann sie verwendet werden kann oder nicht.

Sowohl Geisterobjekte als auch virtuelle Proxys bieten Implementierungen für das LazyObjectInterface , die es ermöglichen, sie auf ihren Anfangszustand zurückzusetzen oder sie bei Bedarf zwangsweise zu initialisieren. Beachten Sie, dass beim Zurücksetzen eines Geisterobjekts dessen schreibgeschützte Eigenschaften übersprungen werden. Sie sollten einen virtuellen Proxy verwenden, um schreibgeschützte Eigenschaften zurückzusetzen.

LazyGhostTrait

Durch die Verwendung LazyGhostTrait entweder direkt in Ihren Klassen oder durch die Verwendung von ProxyHelper::generateLazyGhost() können Sie deren Instanzen verzögert ladbar machen. Dies funktioniert, indem diese Instanzen leer erstellt werden und ihr Status nur beim Zugriff auf eine Eigenschaft berechnet wird.

 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

Alternativ kann LazyProxyTrait zum Erstellen virtueller Proxys verwendet werden:

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

Ressourcen

• Dokumentation
• Mitwirken
• Melden Sie Probleme und senden Sie Pull-Anfragen im Haupt-Symfony-Repository