Erstellen eines PSR-kompatiblen Dependency-Injection-Containers mit PHP Lazy Objects

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!