Création d'un conteneur d'injection de dépendances compatible PSR avec des objets paresseux PHP

Explorer l'injection de dépendances avec des objets paresseux dans PHP 8.4

Dans le domaine du PHP moderne, la sortie de la version 8.4 a introduit une fonctionnalité révolutionnaire : les objets paresseux. Ces objets offrent une nouvelle façon de différer l'initialisation jusqu'à ce que cela soit absolument nécessaire, améliorant ainsi les performances et réduisant l'utilisation des ressources. Cette fonctionnalité est profondément intégrée au langage grâce aux améliorations apportées à l'API ReflectionClass, comme indiqué dans la RFC Lazy Initialization for Lazy Objects.

Exemple du RFC
Pour illustrer le potentiel des Lazy Objects, considérons l'exemple suivant directement dans la 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.

Ce mécanisme permet aux développeurs de contrôler finement le processus d'initialisation, garantissant que les ressources ne sont chargées que lors de leur accès.

Inspiré par cette RFC, j'ai décidé de créer un conteneur d'injection de dépendances compatible PSR-11, en tirant parti de l'API Lazy Objects pour des performances optimales.

La fondation du ContainerLazyObject

Le cœur de notre conteneur réside dans la classe ContainerLazyObject. Avec lui, vous pouvez enregistrer des dépendances et les initialiser paresseusement, ce qui signifie qu'elles ne sont instanciées que lorsque cela est réellement nécessaire. Voici la méthode principale qui effectue cette tâche :

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);
}

Enregistrement des services dans le conteneur

Notre conteneur prend en charge différentes manières d'enregistrer des services, offrant une flexibilité aux développeurs. Voici quelques exemples :

$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());

Cette flexibilité rend le ContainerLazyObject adaptable à divers scénarios, qu'il s'agisse de créer dynamiquement des dépendances ou de réutiliser des objets préconfigurés.

Récupération des services du conteneur
Une fois les services enregistrés dans le conteneur, vous pouvez les récupérer à tout moment. Le conteneur garantit que les services sont instanciés paresseusement, de sorte qu'ils ne seront créés que lorsqu'ils seront réellement demandés. Voici un exemple de comment récupérer les services enregistrés :

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

Le cœur de ContainerLazyObject Le cœur de notre conteneur réside dans la classe ContainerLazyObject. Avec lui, vous pouvez enregistrer des dépendances et les initialiser paresseusement, ce qui signifie qu'elles ne sont créées que lorsqu'elles sont réellement utilisées. Voici la méthode principale qui effectue cette tâche :

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);
}

Compatibilité PSR-11

Un avantage supplémentaire de ContainerLazyObject est sa compatibilité avec PSR-11, le standard PHP pour les conteneurs d'injection de dépendances. Cela garantit l'interopérabilité avec les bibliothèques et les frameworks suivant la spécification, ce qui en fait une solution légère et universelle.

Comparaison des performances avec d'autres conteneurs

Pour mesurer les performances de notre conteneur, j'ai utilisé PhpBench dans un environnement contrôlé, en le comparant à des alternatives populaires : Pimple, Illuminate et PHP-DI. Les résultats ont été encourageants :

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.

Notre conteneur a démontré d'excellentes performances, étant nettement plus rapide que des alternatives plus robustes comme Illuminate Container et PHP-DI dans des scénarios simples de résolution de dépendances.

La classe complète

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);
}

Conclusion

PHP 8.4 et ses Lazy Objects ont ouvert de nouvelles possibilités pour simplifier et optimiser l'injection de dépendances. Notre ContainerLazyObject, en plus d'être léger, efficace et flexible, est conforme PSR-11, garantissant l'interopérabilité avec d'autres bibliothèques et frameworks.

Essayez cette approche et voyez comment elle peut simplifier la gestion des dépendances dans votre prochain projet !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!