Un article pour parler de l'injection de dépendances DI en php

Qu'est-ce que l'injection de dépendance DI ? L'article suivant vous donnera une compréhension approfondie de l'injection de dépendances DI en php. J'espère qu'il vous sera utile ! Qu'est-ce que DI/Dependency Injection ? En termes simples, cela signifie que vous exploitez actuellement une classe, mais que certaines méthodes ou fonctions de cette classe ne peuvent pas être complétées par cette classe seule, mais peuvent être complétées par avec l'aide d'un autre. class

Le signe le plus direct est lorsque les données du paramètre sont transmises en tant qu'objet. À proprement parler, vous voulez faire fonctionner une classe dans une autre classe. Il existe une interdépendance entre les deux classes. La méthode de transmission des paramètres s'appelle injection

La raison. pourquoi l'injection de dépendances apparaît

• Lorsque l'injection de dépendances n'est pas utilisée, lorsque php doit utiliser une autre classe dans une classe, les opérations suivantes sont souvent effectuées依赖注入DI 其实本质上是指对类的依赖通过构造器完成 自动注入
• 通俗来说，就是你当前操作一个类，但是这个类的某些方法或者功能不是单单只靠这个类就能完成的，而是要 借助另一个类 的才能完成的
• 最直接的标志就是传参数据为对象的时候。严格来说，你想在一个类中操作另一个类，这两个类之间形成了相互依赖关系，传参的方式叫 注入

依赖注入出现的原因

• 在未使用依赖注入的时候，php 需要在一个类中使用另一个类的时候，往往都会进行如下操作
• 比如我在 container 类中需要用到 adapter 类，就需要在使用之前进行实例化
• 如果需要用到大量的外部类，这就会造成了 耦合度太高，很容易造成后期的 维护困难
• 通俗的来讲，也就是 container 脱离不了外部类去工作，这就叫 耦合度太高

<?php
class container
{
    private $adapter;

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

简单的依赖注入

• 上面的代码耦合度太高，导致了 依赖注入 的出现，主要是为了 解耦合
• 如下案例，我们只需要将所需要操作的类对象传入即可
• 依赖注入 操作的参数是 对象，而不是普通参数，是不是有更好的理解了
• 但是这样的简单依赖注入，会造成如果你依赖的类很多，你传参的时候会很长，容易混乱

<?php
class container
{
    private $adapter;

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

高阶的依赖注入

• 为了解决上面 参数混乱 的问题，这时候，依赖注入进行了优化
  通过魔术方法，__get 去设置对象
• 这时候，我们就可以解决依赖太多，参数混乱的问题了

<?php
class container
{
    public $instance = [];

    public function __set($name, $value)
    {
        $this->instance[$name] = $value;
    }
}

$container = new container();

$container->adapter = new adapter();
$container->autofelix = new autofelix();

依赖注入的应用

• 我们先定义一个 容器类，主要用来向容器中 注入 你想要操作的类
• 使用的时候，只需要传容器这一个 对象 即可

<?php
class container
{
    public $instance = [];

    public function __set($name, $value)
    {
        $this->instance[$name] = $value;
    }
}

class adapter
{
    public $name = '我是调度器';
}

$container = new container();
$container->adapter = new adapter();

class autofelix
{
    private $container;

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

    public function who($class)
    {
        return $this->container->instance[$class]->name;
    }
}

$autofelix = new autofelix($container);

$who = $autofelix->who('adapter');

var_dump($who); //我是调度器

依赖注入高阶优化

• 在上面的应用中，我们 直接 将实例化后的对象注入容器中
• 这样会导致，所有的对象还没有被使用就会被实例化一遍，造成 资源的损耗
• 我们可以 传入闭包，这样对象就不会被实例化而注入，当你自己需要使用的时候，再去实例化，就可以减少 服务器资源的损耗
Par exemple, lorsque je suis dans adapter doit être utilisée dans la classe >container, elle doit être instanciée avant utilisation. Si un grand nombre de classes externes doivent être utilisées, cela entraînera Un couplage trop élevé peut facilement causer des <code>difficultés de maintenance à l'avenir. En termes simples, le conteneur ne peut pas fonctionner sans classes externes. le degré de couplage est trop élevé

<?php
$container = new container();
$container->adapter = new adapter();

//高阶优化
$container = new container();
$container->adapter = function () {
    return new adapter();
};

Injection de dépendance simple🎜🎜🎜Le degré de couplage du code ci-dessus est trop élevé, ce qui conduit à l'émergence de l'injection de dépendance, principalement pour Découplage🎜🎜Dans le cas suivant, il suffit de passer l'objet de classe qui doit être opéré🎜🎜Injection de dépendance Le paramètre de l'opération est Object , et ce n'est pas un paramètre ordinaire. Avez-vous une meilleure compréhension ? Mais une injection de dépendance aussi simple fera que si vous dépendez de plusieurs classes, le temps pendant lequel vous passerez les paramètres sera très long et facile à confusion🎜🎜 rrreee🎜🎜Injection de dépendances de haut niveau🎜🎜🎜🎜Afin de résoudre le problème ci-dessus de confusion des paramètres, à ce stade, l'injection de dépendances a été optimisée
grâce à la méthode magique, __get Allez définir l'objet🎜🎜À ce stade, nous pouvons résoudre le problème du trop grand nombre de dépendances et des paramètres confus🎜🎜rrreee🎜🎜Application de l'injection de dépendances🎜🎜🎜 🎜Nous définissons d'abord une classe conteneur, principalement utilisée pour injecter la classe que vous souhaitez exploiter dans le conteneur. Lors de son utilisation, il vous suffit de passer l'objet . du conteneur. 🎜🎜rrreee🎜🎜Optimisation de l'injection de dépendances de haut niveau🎜🎜🎜🎜Dans l'application ci-dessus, nous directement injectons les objets instanciés dans le conteneur🎜🎜Cela provoquera tout. les objets doivent être instanciés avant d'être utilisés, provoquant une Perte de ressources🎜🎜Nous pouvons passer en fermeture afin que l'objet ne soit pas instancié et injecté lorsque vous en avez besoin. vous-même, instanciez-le à nouveau. Vous pouvez réduire la perte de ressources du serveur🎜🎜rrreee🎜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!