Verständnis der PHP-Abhängigkeitsinjektion und Inversion von control_php-Fähigkeiten

Um die beiden Konzepte der PHP-Abhängigkeitsinjektion und der Umkehrung der Kontrolle zu verstehen, müssen Sie die folgenden Probleme verstehen:

DI – Abhängigkeitsinjektion

IoC – Umkehrung der Kontrolle

1. Wer sind die Teilnehmer? ​

Antwort: Im Allgemeinen gibt es drei Parteien, eine ist ein Objekt, die andere ist die externe Ressource eines Objekts. Lassen Sie mich die Substantive noch einmal erklären. Der IoC/DI-Container bezieht sich einfach auf ein Rahmenprogramm, das zur Implementierung der IoC/DI-Funktionen verwendet wird Von außerhalb des Objekts stammende Ressourcen werden kollektiv als Ressourcen bezeichnet, z. B.: andere vom Objekt benötigte Objekte oder vom Objekt benötigte Dateiressourcen usw.

2. Abhängigkeit: Wer ist von wem abhängig? Warum gibt es Abhängigkeiten?

Antwort: Ein Objekt hängt vom IoC/DI-Container ab. Abhängigkeiten sind unvermeidlich. In einem Projekt gibt es verschiedene Beziehungen zwischen verschiedenen Klassen, und es ist unmöglich, dass alle vollständig unabhängig sind, was zu Abhängigkeiten führt. Die traditionelle Entwicklung verwendet bei Verwendung anderer Klassen direkte Aufrufe, die eine starke Kopplung bilden, die vermieden werden sollte. Die Abhängigkeitsinjektion leiht Container aus, um abhängige Objekte zu übertragen und eine Entkopplung zu erreichen.

3. Injektion: Wer spritzt in wen? Was genau wird gespritzt?

Antwort: Injizieren Sie die benötigten externen Ressourcen über den Container in das Objekt

4. Umkehrung der Kontrolle: Wer kontrolliert wen? Was kontrollieren? Warum heißt es Umkehrung?

Antwort: Das Containerkontrollobjekt von IoC/DI steuert hauptsächlich die Erstellung von Objektinstanzen. Die Umkehrung erfolgt relativ zur positiven Richtung. Was gilt also als positive Richtung? Denken Sie über die Anwendung unter normalen Umständen nach, wenn Sie C in A verwenden möchten. Natürlich wird das Objekt von C direkt erstellt, dh die erforderliche externe Ressource C wird aktiv in Klasse A abgerufen. Diese Situation wird als vorwärts bezeichnet. Was ist also umgekehrt? Das heißt, Klasse A erhält C nicht mehr aktiv, sondern wartet passiv darauf, dass der IoC/DI-Container eine Instanz von C erhält, und fügt sie dann umgekehrt in Klasse A ein.

5. Sind Abhängigkeitsinjektion und Umkehrung der Kontrolle dasselbe Konzept?

Antwort: Wie aus dem Obigen ersichtlich ist, wird die Abhängigkeitsinjektion aus der Perspektive der Anwendung beschrieben. Die Abhängigkeitsinjektion kann ausführlicher beschrieben werden: Die Anwendung hängt vom Container ab Um die erforderlichen externen Ressourcen zu erstellen und einzufügen, wird die Umkehrung der Steuerung aus der Perspektive des Containers beschrieben. Die Beschreibung ist jedoch vollständig: Der Container steuert die Anwendung, und der Container injiziert umgekehrt die von der Anwendung benötigten externen Ressourcen in die Anwendung.

Sehen wir uns einige Implementierungsmethoden der Abhängigkeitsinjektion anhand von Beispielen genauer an:

1. Konstruktorinjektion

<&#63;php
class Book {
  private $db_conn;
 
  public function __construct($db_conn) {
    $this->db_conn = $db_conn;
  }
}

2. Setter-Injektion

<&#63;php

 
class book{
   private $db;
　　　private $file;
   function setdb($db){
     $this->db=$db;
   }
   function setfile($file){
     $this->file=$file;
   }
}
class file{}
class db{}
...

class test{
　　 $book = new Book();
 　　 $book->setdb(new db()); 
   $book->setfile(new file());
}
&#63;>

Der Code der beiden oben genannten Methoden ist sehr klar, aber wenn wir viele Abhängigkeiten einfügen müssen, müssen wir viele Zeilen hinzufügen, was schwieriger zu verwalten ist.

Eine bessere Lösung besteht darin, eine Klasse als Container für alle Abhängigkeiten zu erstellen. In dieser Klasse können Sie die erforderlichen Abhängigkeiten speichern, erstellen, abrufen und finden

<&#63;php
class Ioc {
  protected $db_conn;
  public static function make_book() {
    $new_book = new Book();
    $new_book->set_db(self::$db_conn);
    //...
    //...
    //其他的依赖注入
    return $new_book;
  }
}

Wenn Sie zu diesem Zeitpunkt eine Buchinstanz erhalten möchten, müssen Sie nur $newone = Ioc::makebook();

ausführen

Das Obige ist ein konkretes Beispiel für einen Container. Es ist besser, keine bestimmte Abhängigkeitsinjektionsmethode zu schreiben

<&#63;php
class Ioc {
/**
* @var 注册的依赖数组
*/
 
  protected static $registry = array();
 
  /**
  * 添加一个resolve到registry数组中
  * @param string $name 依赖标识
  * @param object $resolve 一个匿名函数用来创建实例
  * @return void
  */
  public static function register($name, Closure $resolve)
  {
   static::$registry[$name] = $resolve;
  }
 
  /**
   * 返回一个实例
   * @param string $name 依赖的标识
   * @return mixed
   */
  public static function resolve($name)
  {
    if ( static::registered($name) )
    {
     $name = static::$registry[$name];
     return $name();
    }
    throw new Exception('Nothing registered with that name, fool.');
  }
  /**
  * 查询某个依赖实例是否存在
  * @param string $name id
  * @return bool 
  */
  public static function registered($name)
  {
   return array_key_exists($name, static::$registry);
  }
}

Sie können sich jetzt über die folgenden Methoden registrieren und eine Injektion vornehmen

<&#63;php
$book = Ioc::registry('book', function(){
$book = new Book;
$book->setdb('...');
$book->setprice('...');
return $book;
});
 
//注入依赖
$book = Ioc::resolve('book');
&#63;>

Das Obige ist das Verständnis der PHP-Abhängigkeitsinjektion und der Umkehrung der Kontrolle. Ich hoffe, dass es für jeden hilfreich sein wird, PHP-Programmierung zu lernen.