Exemples d'inversion de contrôle et d'injection de dépendances PHP

Cet article partage principalement avec vous des exemples d'inversion de contrôle PHP et d'injection de dépendances. Le but de l'injection de dépendances est d'obtenir une architecture logicielle faiblement couplée pour de meilleurs tests, gestion et expansion du code.

Inversion de contrôle  : Lorsque l'appelant a besoin de l'aide de l'appelé, dans le processus de programmation traditionnel, l'appelant crée généralement l'instance d'appelé de l'appelant, mais ici l'instance d'appelé. Le travail de création de l'appelé n'est plus effectué par l'appelant, mais la création de l'appelé est déplacée à l'extérieur de l'appelant, inversant ainsi la création de l'appelé et éliminant l'invocation. Le contrôle créé par l'appelant sur l'appelé est donc appelé inversion de contrôle.

Injection de dépendances  : Pour réaliser une inversion de contrôle, la solution habituelle est de laisser le travail de création de l'instance de l'appelé au conteneur IoC, puis dans l'appelant d'injecter l'appelé (implémenté via constructeur/méthode d'injection), afin de parvenir au découplage de l'appelant et de l'appelé, ce processus est appelé injection de dépendances. L'injection de dépendances est une implémentation d'inversion de contrôle. Il existe trois méthodes d'injection courantes : l'injection de définition, l'injection de constructeur et l'injection de propriétés.

Container (Container)  : gère le cycle de vie de la génération d'objets, de l'acquisition de ressources, de la destruction, etc., établit des dépendances entre les objets et peut retarder le chargement des objets. Les plus connus sont PHP-DI et Pimple.

Démonstration du code IoC :

Supposons que l'application a des exigences de stockage Si l'API du module de bas niveau est directement appelée dans l'application de haut niveau, l'application va créer des dépendances.

<?php
/**
 * 高层
 */
class App
{
    private $writer;

    public function __construct()
    {
        $this->writer = new FloppyWriter();
    }

    public function save()
    {
        $this->writer->saveToFloppy();
    }
}

/**
 * 低层，软盘存储
 */
class FloppyWriter
{
    public function saveToFloppy()
    {
        echo __METHOD__;
    }
}

$app = new App();
$app->save(); // FloppyWriter::saveToFloppy

Supposons que le programme doive être porté sur une autre plate-forme et que cette plate-forme utilise un disque USB comme support de stockage, le programme ne peut pas être directement réutilisé et doit être modifié. Dans ce cas, en raison des changements de bas niveau, les changements de haut niveau suivent également, ce qui est une mauvaise conception. Les programmes ne doivent pas s'appuyer sur des implémentations concrètes, mais sur des interfaces abstraites. Veuillez consulter la démonstration de code :

<?php
/**
 * 接口
 */
interface IDeviceWriter
{
    public function saveToDevice();
}

/**
 * 高层
 */
class App
{
    /**
     * @var IDeviceWriter
     */
    private $writer;

    /**
     * @param IDeviceWriter $writer
     */
    public function setWriter($writer)
    {
        $this->writer = $writer;
    }

    public function save()
    {
        $this->writer->saveToDevice();
    }
}

/**
 * 低层，软盘存储
 */
class FloppyWriter implements IDeviceWriter
{

    public function saveToDevice()
    {
        echo __METHOD__;
    }
}

/**
 * 低层，USB盘存储
 */
class UsbDiskWriter implements IDeviceWriter
{

    public function saveToDevice()
    {
        echo __METHOD__;
    }
}

$app = new App();
$app->setWriter(new UsbDiskWriter());
$app->save(); // UsbDiskWriter::saveToDevice

$app->setWriter(new FloppyWriter());
$app->save(); // FloppyWriter::saveToDevice

Le contrôle est transféré du FloppyWriter réel à l'interface abstraite IDeviceWriter, rendant l'application dépendante de l'interface IDeviceWriter, et FloppyWriter et UsbDiskWriter dépendent également de l'interface IDeviceWriter.
C'est IoC. Face aux changements, le haut niveau n'a pas besoin de modifier une ligne de code, et ne s'appuie plus sur le bas niveau, mais s'appuie sur l'injection, ce qui conduit à la DI.

Si ce composant a de nombreuses dépendances, nous devons créer plusieurs méthodes de définition de paramètres pour transmettre les dépendances, ce qui rend notre code difficile à maintenir.

<?php
//创建依赖实例
$request = new Request();
$filter = new Filter();

//把实例作为参数传递给构造函数
$some = new SomeComponent($request, $filter);

$some->setRequest($request);
$some->setFilter($filter);

La solution est de fournir un conteneur pour l'instance dépendante. Ce conteneur agit comme un registre global, injecté dans le conteneur plutôt que dans l'instance spécifique.

<?php
class SomeComponent
{

    protected $_di;

    public function __construct($di)
    {
        $this->_di = $di;
    }

    public function someRequest()
    {

        // 请求实例
        $connection = $this->_di->get(&#39;request&#39;);

    }

    public function someOtherRequest()
    {

        // 请求实例
        $connection = $this->_di->get(&#39;request&#39;);

        // 过滤器实例
        $filter = $this->_di->get(&#39;filter&#39;);

    }

}

$di = new DI();

//在容器中注册一个request服务
$di->set(&#39;request&#39;, function() {
    return new Request(array(
        "test" => "test"
    ));
});

//在容器中注册一个filter服务
$di->set(&#39;filter&#39;, function() {
    return new Filter();
});

//把传递服务的容器作为唯一参数传递给组件
$some = new SomeComponent($di);
$some->someRequest();

Ce composant peut désormais obtenir facilement les services dont il a besoin. Le service utilise un chargement paresseux et n'est initialisé qu'en cas de besoin, ce qui économise également les ressources du serveur. Cette composante est désormais fortement découplée.
Recommandations associées :

Analyse de l'injection de dépendance PHP et de l'inversion de contrôle

Exemple d'injection de dépendance PHP (DI) et d'inversion de contrôle (IoC) Tutoriels

Inversion PHP du contrôle et injection de dépendances

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!