Principe d'inversion du contrôle, quel est son lien avec l'injection de dépendances

Inversion de contrôle (IOC)

Premièrement, regardons un exemple.

class Person
{
   private $name = '';
   private $age = 0;

   public function __construct(string $name, int $age)
   {
       $this->name = $name;
       $this->age = $age;
   }

   public function eat ()
   {
       echo '吃东西' . PHP_EOL;
   }

   public function drink ()
   {
       echo '喝水' . PHP_EOL;
   }

   public function sleep ()
   {
       echo '睡觉' . PHP_EOL;
   }

   public function wakeup ()
   {
       echo '起床' . PHP_EOL;
   }

   public function drive ()
   {
       echo '开车' . PHP_EOL;
   }

   public function wash ()
   {
       echo '洗漱' . PHP_EOL;
   }
}

Xiao Ming doit maintenant aller travailler quand il se réveille le matin, donc Xiao Ming doit faire les choses suivantes

$person = new Person('小明', 24);
$person->wakeup();
$person->wash();
$person->eat();
echo '带上车钥匙、手机、电脑' .PHP_EOL;
$person->drive();

Le processus ci-dessus est contrôlé par le programmeur lui-même. Trouvons maintenant un moyen de laisser le framework contrôler le processus. Nous ajoutons une nouvelle méthode dans la classe Person, le code est le suivant :

public function work (callable $bring)
{
    $this->wakeup();
    $this->wash();
    $this->eat();
    $bring();
    $this->drive();
}

Xiao Huang doit également aller travailler, et maintenant il n'a plus qu'à installer les conseils du framework pour terminer l'action d'aller travailler .

$person = new Person('小黄', 29);
$person->work(function ()
{
    echo '带上手机、车钥匙、文件' . PHP_EOL;
});

Le code modifié a terminé l'inversion du contrôle. Dans le code précédent, l'ensemble du processus de travail était contrôlé par le programmeur, mais dans le code modifié, le framework contrôle le processus de travail. Le contrôle de flux du programme est « inversé » du programmeur vers le framework.

Vous pouvez maintenant donner la définition de l'inversion de contrôle :

En fait, l'inversion de contrôle est une idée de conception relativement générale, pas une méthode de mise en œuvre spécifique, et est généralement utilisée à titre indicatif pour la conception le niveau du cadre. Le « contrôle » mentionné ici fait référence au contrôle du flux d'exécution du programme, tandis que « l'inversion » fait référence au programmeur contrôlant l'exécution de l'ensemble du programme avant d'utiliser le framework. Après avoir utilisé le framework, le flux d'exécution de l'ensemble du programme est contrôlé via le framework. Le contrôle du processus est « inversé » du programmeur au framework.

Injection de dépendances

L'inversion de contrôle est une idée de conception, tandis que l'injection de dépendances est une technique de codage spécifique et l'injection de dépendances est l'implémentation. technique la plus courante d’inversion de contrôle. L'injection de dépendances a l'air "haut de gamme", mais elle est en réalité très simple à comprendre et à maîtriser.

Alors, qu’est-ce que l’injection de dépendance exactement ? Nous pouvons le résumer en une phrase : au lieu de créer des objets de classe dépendants à l'intérieur de la classe via new(), une fois les objets de classe dépendants créés en externe, ils sont passés (ou injectés) via des constructeurs, des paramètres de fonction, etc. .

Regardons un exemple :

interface Log
{
   function write (string $msg);
}

class TextLog implements Log
{
   public function __construct($dirname, $txtname)
   {
       $this->makeDir($dirname);
       $this->mkTxt($txtname);
   }

   private function makeDir (string $dirName) :void
   {
       // do something
   }

   private function mkTxt (string $txtName) :void
   {
       // do something
   }

   public function write (string $msg)
   {
       // do something
   }
}

class RedisLog implements Log
{
   private $redis = null;
   private $key = '';

   public function __construct(string $key)
   {
       $this->redis = '...'; // 获取redis实例
       $this->key = $key;
       // ...
   }

   public function write (string $msg)
   {
       // do something
   }
}

class App
{
   public function run ()
   {
       // do something

       // 记录日志
       (new RedisLog('log'))->write('框架运行信息记录');
   }
}

Comme vous pouvez le voir, la classe App dépend de la classe RedisLog si nous n'utilisons plus redis pour enregistrer les jours dans le futur, mais utilisons des fichiers texte. à la place, nous devons modifier le code en cours d'exécution.

Maintenant, nous passons à l'utilisation de la technique d'injection de dépendances pour le réécrire. Le code est le suivant

class App
{
   private $logHandle = null;

   public function __construct(Log $log)
   {
       $this->logHandle = $log;
   }

   public function run ()
   {
       // do something

       // 记录日志
       $this->logHandle->write('框架运行信息记录');
   }
}

La classe App réécrite ne dépend plus de la classe RedisLog et peut être remplacée par d'autres ; Enregistrez les classes à tout moment. Tant que la classe implémente la méthode d'écriture. Comme vous pouvez le constater, l’injection de dépendances peut remplacer de manière flexible les classes dépendantes. De plus, c’est le moyen le plus efficace d’écrire du code testable.

Il existe un article sur l'injection de dépendances dans Zhihu. Il est très facile à comprendre. Le lien est le suivant :

Une brève discussion sur l'inversion de contrôle et l'injection de dépendances https://zhuanlan.zhihu.com/p/33492169

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!