Un article pour comprendre et implémenter les conteneurs IOC dans les frameworks PHP modernes

Cet article vous apporte des connaissances pertinentes sur PHP, qui présente principalement le contenu pertinent sur les conteneurs IOC. Le nom complet d'IOC est : Inversion Of Control, jetons-y un coup d'œil ensemble, j'espère que cela vous sera utile. à tout le monde.

Qu'est-ce qu'un conteneur ?

Je pense que beaucoup de gens ont entendu parler de l'injection de dépendances. Les conditions de base de la mise en œuvre de l'injection de dépendances sont indissociables des conteneurs. Les conteneurs sont utilisés pour gérer les dépendances de classe et l'injection, et sont responsables de la gestion des services et du découplage des composants. peut mettre des conteneurs Comprenez-le comme un très grand tableau dédié au stockage d'objets.

Comme le montre la figure, l'appelant obtient l'instance d'objet via l'étiquette du conteneur. Comme on peut le voir sur l'image, elle peut être obtenue via ::class ou directement via l'étiquette de l'objet.

Qu'est-ce que le CIO ?

Vous avez peut-être entendu parler des conteneurs IOC. Le nom complet d'IOC est : (Inversion Of Control).

Comprenons ce qu'est l'inversion de contrôle. Dans notre codage traditionnel, nos dépendances entre les classes consistent généralement à créer de nouveaux objets via le codage, puis à les transmettre. Avec l'inversion de contrôle, nous pouvons donner le contrôle au conteneur ou au framework. mettre en œuvre. Le but est de nous permettre de créer des objets sans codage en dur. Comme vous pouvez le voir sur la figure 1, de nombreux objets sont stockés dans le conteneur, qui peuvent être utilisés directement lorsque nous souhaitons les utiliser. Les objets dans le conteneur ne nécessitent pas que nous les créions dans le code. Lorsqu'un certain objet de classe est nécessaire, l'objet sera obtenu à partir du conteneur. Si l'objet n'existe pas, il sera automatiquement créé. Cela signifie que nous omettons le processus de création d'objets dans le code et que le conteneur nous aide à réaliser ce processus de création. C'est ce qu'on appelle le contrôle d'inversion. Pour résumer IOC en une phrase : transférez le contrôle de la création d'objets à l'instanciation de la classe d'implémentation du conteneur.

Par exemple : si nous voulons créer une classe sans utiliser IOC

<?php
class Sunny{
}
$sunny = new Sunny();

nous devons créer manuellement une nouvelle classe. Dans ce cas, elle est codée en dur dans le code.

Le code utilisant le conteneur IOC peut être écrit comme ceci.

<?php
class Sunny{
}
$sunny = Container::getBean(Sunny::class);

Aidez-nous à implémenter ce cours dans le conteneur. Certains étudiants peuvent avoir des questions lorsqu'ils voient cela. Si j'utilise le nouveau Sunny, le code ne sera-t-il pas plus court et plus simple ? Regardons un exemple après avoir examiné l'injection de dépendances.

Injection de dépendances

Maintenant que nous savons ce qu'est IOC, une nouvelle question se pose lorsque nous créons une classe, que devons-nous faire si les constructeurs de certaines classes nous demandent de passer des paramètres ? Grâce à l'étude d'IOC, nous savons que le conteneur IOC nous aidera à résoudre le problème de la création d'instances d'objet dans le conteneur, s'il s'avère que la classe a d'autres dépendances, elle effectuera une recherche de dépendance. Le processus du conteneur trouvant les objets requis est appelé DL (Dependency Lookup, recherche de dépendance). L'injection des dépendances requises dans des fragments de code est appelée DI (Dependency Injection, injection de dépendances).

Par exemple, le nouvel exemple Sunny mentionné dans IOC. S'il existe plusieurs dépendances entre les classes.

<?php
class Computer{
    public function run(){
        echo "编程中....\n";
    }
}
class Sunny{
    private $computer;
    public function __construct(Computer $computer){
        $this->computer = $computer;
    }
    public function program(){
        $this->computer->run();
    }
}
$sunny = new Sunny(new Computer());
$sunny->program();

Ici, vous pouvez voir que la classe Sunny veut dépendre de la classe Computer pour la programmation. Si vous utilisez le conteneur IOC pour implémenter l'injection de dépendances, le code sera simple.

<?php
class Computer{
    public function run(){
        echo "编程中....\n";
    }
}
class Sunny{
    private $computer;
    public function __construct(Computer $computer){
        $this->computer = $computer;
    }
    public function program(){
        $this->computer->run();
    }
}
$sunny = Container::getBean(Sunny::class);
$sunny->program();

Résumé en une phrase : résolvez les dépendances sur d'autres classes lors de la création d'instances de classe et fournissez dynamiquement à un objet les autres objets dont il a besoin.

Inversion des dépendances

Le problème résolu par l'inversion des dépendances est de coupler vaguement les lourdes dépendances entre les modules. Les modules supérieurs ne doivent pas s'appuyer sur les modules inférieurs, ils doivent tous s'appuyer sur des abstractions. Habituellement, une compréhension simple de l’inversion de dépendance consiste à programmer vers des interfaces ou des abstractions. Jetons un coup d'œil à la programmation orientée interface à travers l'exemple suivant.

class Cache{
    public function set($key,$value){
        $redis = new CFile();
        $redis->set($key,$value);
    }
}
class CFile{
    public function set($key,$value){
        echo "file:{$key}->{$value}\n";
    }
}
$cache = new Cache();
$cache->set("name","sunny");

Le code ci-dessus ne semble pas avoir de gros problème, mais que se passe-t-il si un jour le cache de fichiers est remplacé par le cache Redis ?

class Cache{
    public function set($key,$value){
        $redis = new CRedis();
        $redis->set($key,$value);
    }
}
class CRedis{
    public function set($key,$value){
        echo "redis:{$key}->{$value}\n";
    }
}
$cache = new Cache();
$cache->set("name","sunny");

On peut voir à partir de ce code que lorsque le pilote utilisé par un cache change, le code du cache doit également apporter les modifications correspondantes, car le code est écrit sur l'appelant et le degré de couplage devient plus élevé. C'est la même chose que modifier le code, permettant aux programmeurs de programmer vers l'interface, rendant le code plus polyvalent et standardisé.

interface ICache{
    public function set($key,$value);
}
class CRedis implements ICache {
    public function set($key,$value)
{
        echo "redis:{$key}->{$value}\n";
    }
}
class CFile implements ICache{
    public function set($key,$value)
{
        echo "file:{$key}->{$value}\n";
    }
}
class Cache{
    private $drive;
    public function __construct(ICache $drive)
{
        $this->drive = $drive;
    }
    public function set($key,$value){
        $this->drive->set($key,$value);
    }
}
$cache = new Cache(new CFile());
$cache->set("name","sunny");

Beaucoup de gens pensent lorsqu'ils voient ce code, ne devrais-je pas simplement passer l'objet souhaité directement dans le constructeur ? Pourquoi devons-nous définir une interface ? En fait, l'interface est définie pour standardiser le code. Quel que soit le pilote que vous utilisez, tant qu'il implémente mon interface, vous pouvez l'utiliser sans interface, les développeurs ne sauront pas quelles méthodes doivent être incluses dans le pilote lors du développement. le conducteur. Lorsque nous utilisons l'interface, nous avons uniquement besoin de programmer pour l'interface. Cache ne se soucie pas de la façon dont la classe est implémentée. Cache fonctionne uniquement selon la méthode d'interface.

Résumé en une phrase : L'inversion des dépendances permet un couplage lâche

Combat pratique : Implémenter des conteneurs basés sur les principes des conteneurs

<?php
class Container
{
    // 当前容器对象
    private static $instance;
    // 存放在容器里面到实例
    protected $instances = [];
    private function __construct()
{
    }
    public static function getInstance()
{
        if (!self::$instance) {
            self::$instance = new static();
        }
        return self::$instance;
    }
    /**
     * 获取对象实例
     * @param $key
     * @return mixed
     */
    public function get($key)
{
        if (isset($this->instances[$key])) {
            return $this->instances[$key];
        }
    }
    /**
     * 绑定对象、闭包、类到容器
     * @param $key
     * @param null $concrete
     * @return Container
     */
    public function bind($key, $concrete = null)
{
        if ($concrete instanceof Closure) {
            $this->instances[$key] = $concrete;
        } elseif (is_object($concrete)) {
            $this->instances[$key] = $concrete;
        }
        return $this;
    }
}
class Sunny
{
    public function getName()
{
        echo time() . "\n";
    }
}
$app = Container::getInstance();
$sunny = $app->bind(Sunny::class,new Sunny());
$sunny = $app->get(Sunny::class);
$sunny->getName();

Combat pratique : Implémenter l'injection de dépendances

Container.php
<?php
class Container
{
    // 当前容器对象
    private static $instance;
    // 存放在容器里面到实例
    protected $instances = [];
    private function __construct()
{
    }
    public static function getInstance()
{
        if (!self::$instance) {
            self::$instance = new static();
        }
        return self::$instance;
    }
    /**
     * 获取对象实例
     * @param $key
     * @return mixed
     * @throws ReflectionException
     */
    public function get($key)
{
        if (isset($this->instances[$key])) {
            return $this->instances[$key];
        }
        return $this->make($key);
    }
    /**
     * 绑定对象、闭包、类到容器
     * @param $key
     * @param null $concrete
     * @return Container
     * @throws ReflectionException
     */
    public function bind($key, $concrete = null)
{
        if ($concrete instanceof Closure) {
            $this->instances[$key] = $concrete;
        } elseif (is_object($concrete)) {
            $this->instances[$key] = $concrete;
        } else {
            $this->make($key, $concrete);
        }
        return $this;
    }
    /**
     * 创建类绑定到类实例
     * @param $abstract
     * @param null $atgs
     * @return mixed
     * @throws ReflectionException
     */
    public function make($abstract, $atgs = null)
{
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }
        $object = $this->invokeClass($abstract);
        $this->instances[$abstract] = $object;
        return $object;
    }
    /**
     * 反射解析类
     * @param $abstract
     * @return object
     * @throws ReflectionException
     */
    public function invokeClass($abstract)
{
        $reflectionClass = new \ReflectionClass($abstract);
        // 获取构造方法
        $construct = $reflectionClass->getConstructor();
        // 获取参数得到实例
        $params = $construct ? $this->parserParams($construct) : [];
        $object = $reflectionClass->newInstanceArgs($params);
        return $object;
    }
    /**
     * 解析构造方法参数
     * @param $reflect
     * @return array
     * @throws ReflectionException
     */
    public function parserParams(ReflectionMethod $reflect)
{
        $args = [];
        $params = $reflect->getParameters();
        if (!$params) {
            return $args;
        }
        if (count($params) > 0) {
            foreach ($params as $param) {
                $class = $param->getClass();
                if ($class) {
                    $args[] = $this->make($class->getName());
                    continue;
                }
                // 获取变量的名称
                $name = $param->getName();
                // 默认值
                $def = null;
                // 如果有默认值，从默认值获取类型
                if ($param->isOptional()) {
                    $def = $param->getDefaultValue();
                }
                $args[] = $_REQUEST[$name] ?? $def;
            }
        }
        return $args;
    }
}
Test.php
<?php
class Test
{
    public $name;
    private $test1;
    public function __construct(Test1 $test1)
{
        $this->test1 = $test1;
        $this->name = $this->test1->getName();
    }
}
Test1.php
<?php
class Test1
{
    public function getName(){
        return "test1返回的名字";
    }
}
Sunny.php
<?php
require_once "./Container.php";
require_once "./Test.php";
require_once "./Test1.php";
class Sunny
{
    private $test;
    public function __construct(Test $test)
{
        $this->test = $test;
    }
    public function getName()
{
        echo "获取test里面的name：{$this->test->name}\n";
    }
}
$app = Container::getInstance();
$sunny = $app->get(Sunny::class);
$sunny->getName();

Apprentissage recommandé : "Tutoriel vidéo PHP"

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!