Erkundung der Abh?ngigkeitsinjektion mit Lazy Objects in PHP 8.4

Im Bereich des modernen PHP wurde mit der Ver?ffentlichung von Version 8.4 eine bahnbrechende Funktion eingeführt: Lazy Objects. Diese Objekte erm?glichen eine neue M?glichkeit, die Initialisierung zu verschieben, bis sie unbedingt erforderlich ist, wodurch die Leistung gesteigert und der Ressourcenverbrauch reduziert wird. Diese Funktionalit?t ist durch Verbesserungen der ReflectionClass-API tief in die Sprache integriert, wie im Lazy Initialization for Lazy Objects RFC beschrieben.

Beispiel aus dem RFC
Um das Potenzial von Lazy Objects zu veranschaulichen, betrachten Sie das folgende Beispiel direkt im RFC:

class MyClass
{
    public function __construct(private int $foo)
    {
        // Heavy initialization logic here.
    }

    // ...
}

$initializer = static function (MyClass $ghost): void {
    $ghost->__construct(123);
};

$reflector = new ReflectionClass(MyClass::class);
$object = $reflector->newLazyGhost($initializer);

// At this point, $object is a lazy ghost object.

Mit diesem Mechanismus k?nnen Entwickler den Initialisierungsprozess genau steuern und sicherstellen, dass Ressourcen nur geladen werden, wenn darauf zugegriffen wird.

Inspiriert durch diesen RFC machte ich mich daran, einen PSR-11-kompatiblen Dependency-Injection-Container zu erstellen und dabei die Lazy Objects API für optimale Leistung zu nutzen.

Die Grundlage des ContainerLazyObject

Der Kern unseres Containers liegt in der ContainerLazyObject-Klasse. Damit k?nnen Sie Abh?ngigkeiten registrieren und tr?ge initialisieren, d. h. sie werden nur dann instanziiert, wenn sie tats?chlich ben?tigt werden. Hier ist die Hauptmethode, die diese Aufgabe ausführt:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

Registrieren von Diensten im Container

Unser Container unterstützt verschiedene Arten der Registrierung von Diensten und bietet Entwicklern Flexibilit?t. Hier einige Beispiele:

$container = new ContainerLazyObject();
$containerer->set(DatabaseService::class, fn() => new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, fn() => new LoggerService());

// Alternative approach with class names
$container->set(DatabaseService::class, DatabaseService::class);
$containerr->set(LoggerService::class, LoggerService::class);

// Using already instantiated objects
$container->set(DatabaseService::class, new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, new LoggerService());

Diese Flexibilit?t macht das ContainerLazyObject an verschiedene Szenarien anpassbar, sei es der dynamische Aufbau von Abh?ngigkeiten oder die Wiederverwendung vorkonfigurierter Objekte.

Dienste aus dem Container abrufen
Sobald Dienste im Container registriert sind, k?nnen Sie sie bei Bedarf abrufen. Der Container stellt sicher, dass Dienste verz?gert instanziiert werden, sodass sie erst erstellt werden, wenn sie tats?chlich angefordert werden. Hier ist ein Beispiel, wie Sie die registrierten Dienste abrufen k?nnen:

// Retrieving the services from the container
$loggerService = $container->get(LoggerService::class);
$databaseService = $container->get(DatabaseService::class);

Der Kern von ContainerLazyObject Das Herz unseres Containers liegt in der ContainerLazyObject-Klasse. Damit k?nnen Sie Abh?ngigkeiten registrieren und tr?ge initialisieren, d. h. sie werden nur erstellt, wenn sie tats?chlich verwendet werden. Hier ist die Hauptmethode, die diese Aufgabe ausführt:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

PSR-11-Kompatibilit?t

Ein zus?tzlicher Vorteil des ContainerLazyObject ist seine Kompatibilit?t mit PSR-11, dem PHP-Standard für Dependency-Injection-Container. Dies gew?hrleistet die Interoperabilit?t mit Bibliotheken und Frameworks gem?? der Spezifikation und macht es zu einer leichten und universellen L?sung.

Leistungsvergleich mit anderen Containern

Um die Leistung unseres Containers zu messen, habe ich PhpBench in einer kontrollierten Umgebung verwendet und es mit beliebten Alternativen verglichen: Pimple, Illuminate und PHP-DI. Die Ergebnisse waren ermutigend:

class MyClass
{
    public function __construct(private int $foo)
    {
        // Heavy initialization logic here.
    }

    // ...
}

$initializer = static function (MyClass $ghost): void {
    $ghost->__construct(123);
};

$reflector = new ReflectionClass(MyClass::class);
$object = $reflector->newLazyGhost($initializer);

// At this point, $object is a lazy ghost object.

Unser Container zeigte eine hervorragende Leistung und war in einfachen Abh?ngigkeitsaufl?sungsszenarien deutlich schneller als robustere Alternativen wie Illuminate Container und PHP-DI.

Die komplette Klasse

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

Abschluss

PHP 8.4 und seine Lazy Objects haben neue M?glichkeiten zur Vereinfachung und Optimierung der Abh?ngigkeitsinjektion er?ffnet. Unser ContainerLazyObject ist nicht nur leichtgewichtig, effizient und flexibel, sondern auch PSR-11-konform und gew?hrleistet so die Interoperabilit?t mit anderen Bibliotheken und Frameworks.

Probieren Sie diesen Ansatz aus und sehen Sie, wie er das Abh?ngigkeitsmanagement in Ihrem n?chsten Projekt vereinfachen kann!

Das obige ist der detaillierte Inhalt vonErstellen eines PSR-kompatiblen Dependency-Injection-Containers mit PHP Lazy Objects. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!