Inversion des Kontrollprinzips, was hat es mit der Abhängigkeitsinjektion zu tun?

Inversion of Control (IOC)

Schauen wir uns zunächst ein Beispiel an.

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 muss jetzt zur Arbeit gehen, wenn er morgens aufwacht, also muss Xiao Ming die folgenden Dinge tun

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

Die oben genannten Prozesse werden alle vom Programmierer selbst gesteuert. Lassen Sie uns nun einen Weg finden, den Prozess vom Framework steuern zu lassen. Wir fügen der Person-Klasse eine neue Methode hinzu. Der Code lautet wie folgt:

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

Xiao Huang muss auch zur Arbeit gehen. Jetzt muss er nur noch die Anleitung des Frameworks installieren, um die Aktion zur Arbeit abzuschließen.

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

Der geänderte Code hat die Umkehrung der Kontrolle abgeschlossen. Im vorherigen Code wurde der gesamte Arbeitsprozess vom Programmierer gesteuert, aber im geänderten Code steuert das Framework den Arbeitsprozess. Die Flusskontrolle des Programms wird vom Programmierer zum Framework „umgekehrt“.

Jetzt können wir die Definition der Kontrollumkehr angeben:

Tatsächlich ist die Umkehrung der Kontrolle eine relativ allgemeine Entwurfsidee, keine spezifische Implementierungsmethode, und wird im Allgemeinen als Leitfaden für den Entwurf der Framework-Ebene verwendet. Die hier erwähnte „Steuerung“ bezieht sich auf die Steuerung des Programmausführungsflusses, während sich „Inversion“ darauf bezieht, dass der Programmierer die Ausführung des gesamten Programms kontrolliert, bevor er das Framework verwendet. Nach der Verwendung des Frameworks wird der Ausführungsfluss des gesamten Programms über das Framework gesteuert. Die Steuerung des Prozesses wird vom Programmierer auf das Framework „umgekehrt“.

Abhängigkeitsinjektion

Die Umkehrung der Kontrolle ist eine Designidee, während die Abhängigkeitsinjektion eine spezifische Codierungstechnik ist, die am häufigsten verwendete Technik zur Implementierung der Umkehrung der Kontrolle. Die Abhängigkeitsinjektion sieht „hochwertig“ aus, ist aber tatsächlich sehr einfach zu verstehen und zu beherrschen.

Was genau ist Abhängigkeitsinjektion? Wir können es in einem Satz zusammenfassen: Anstatt abhängige Klassenobjekte innerhalb der Klasse über new () zu erstellen, werden die abhängigen Klassenobjekte nach der externen Erstellung über Konstruktoren, Funktionsparameter usw. übergeben (oder injiziert). Klassenverwendung .

Schauen wir uns ein Beispiel an:

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('框架运行信息记录');
   }
}

Wie Sie sehen können, hängt die App-Klasse von der RedisLog-Klasse ab. Wenn wir Redis nicht mehr verwenden, um zukünftige Tage aufzuzeichnen, sondern stattdessen Textdateien verwenden, müssen wir die ändern Code im Lauf.

Jetzt wechseln wir zum Umschreiben zur Abhängigkeitsinjektionstechnik. Der Code lautet wie folgt:

class App
{
   private $logHandle = null;

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

   public function run ()
   {
       // do something

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

Die neu geschriebene App-Klasse hängt nicht mehr von der RedisLog-Klasse ab und kann jederzeit durch andere Log-Klassen ersetzt werden Die Klasse implementiert die Schreibmethode Can. Wie Sie sehen, kann die Abhängigkeitsinjektion abhängige Klassen flexibel ersetzen. Darüber hinaus ist sie die effektivste Methode, testbaren Code zu schreiben.

Es gibt einen Artikel über Abhängigkeitsinjektion in Zhihu, der auch sehr leicht zu verstehen ist. Der Link lautet wie folgt:

Ein kurzer Vortrag über die Umkehrung der Kontrolle und die Abhängigkeitsinjektion https://zhuanlan.zhihu.com/p/33492169

Das obige ist der detaillierte Inhalt vonInversion des Kontrollprinzips, was hat es mit der Abhängigkeitsinjektion zu tun?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!