Ausführliche Erklärung, wie PHP die automatische Abhängigkeitsinjektion basierend auf Tipps zum Reflection-Mechanismus_php implementiert

Dieser Artikel stellt hauptsächlich die Methode von PHP vor, um eine automatische Abhängigkeitsinjektion basierend auf dem Reflexionsmechanismus zu realisieren, und analysiert PHP mithilfe von Reflexion, um eine automatische Abhängigkeitsinjektion zu realisieren In Form von Beispielen beschreibt dieser Artikel anhand von Beispielen, wie PHP die automatische Abhängigkeitsinjektion basierend auf dem Reflexionsmechanismus implementiert. Teilen Sie es als Referenz mit allen. Schauen wir uns diesen Artikel an!

Abhängigkeitsinjektion wird auch als Umkehrung der Kontrolle bezeichnet. Jeder, der ein Framework verwendet hat, sollte damit vertraut sein. Viele Leute denken, dass es etwas sehr Hochwertiges ist, wenn sie den Namen sehen, und sind davon eingeschüchtert. Heute habe ich mir die Zeit genommen, etwas zu recherchieren und sein Geheimnis zu lüften. Kommen wir ohne weiteres zum Code:

/**
*
* 工具类，使用该类来实现自动依赖注入。
*
*/
class Ioc {
  // 获得类的对象实例
  public static function getInstance($className) {
    $paramArr = self::getMethodParams($className);
    return (new ReflectionClass($className))->newInstanceArgs($paramArr);
  }
  /**
   * 执行类的方法
   * @param [type] $className [类名]
   * @param [type] $methodName [方法名称]
   * @param [type] $params   [额外的参数]
   * @return [type]       [description]
   */
  public static function make($className, $methodName, $params = []) {
    // 获取类的实例
    $instance = self::getInstance($className);
    // 获取该方法所需要依赖注入的参数
    $paramArr = self::getMethodParams($className, $methodName);
    return $instance->{$methodName}(...array_merge($paramArr, $params));
  }
  /**
   * 获得类的方法参数，只获得有类型的参数
   * @param [type] $className  [description]
   * @param [type] $methodsName [description]
   * @return [type]       [description]
   */
  protected static function getMethodParams($className, $methodsName = 'construct') {
    // 通过反射获得该类
    $class = new ReflectionClass($className);
    $paramArr = []; // 记录参数，和参数类型
    // 判断该类是否有构造函数
    if ($class->hasMethod($methodsName)) {
      // 获得构造函数
      $construct = $class->getMethod($methodsName);
      // 判断构造函数是否有参数
      $params = $construct->getParameters();
      if (count($params) > 0) {
        // 判断参数类型
        foreach ($params as $key => $param) {
          if ($paramClass = $param->getClass()) {
            // 获得参数类型名称
            $paramClassName = $paramClass->getName();
            // 获得参数类型
            $args = self::getMethodParams($paramClassName);
            $paramArr[] = (new ReflectionClass($paramClass->getName()))->newInstanceArgs($args);
          }
        }
      }
    }
    return $paramArr;
  }
}

Der obige Code verwendet die Reflexionsfunktion von PHP, um eine Containerklasse zu erstellen Verwenden Sie diese Klasse, um die Abhängigkeitsinjektionsfunktion anderer Klassen zu implementieren. Die obige Abhängigkeitsinjektion ist in zwei Typen unterteilt: Die eine ist die Abhängigkeitsinjektion des Konstruktors und die andere die Abhängigkeitsinjektion der Methode. Zum Testen verwenden wir die folgenden drei Klassen.

class A {
  protected $cObj;
  /**
   * 用于测试多级依赖注入 B依赖A，A依赖C
   * @param C $c [description]
   */
  public function construct(C $c) {
    $this->cObj = $c;
  }
  public function aa() {
    echo 'this is A->test';
  }
  public function aac() {
    $this->cObj->cc();
  }
}
class B {
  protected $aObj;
  /**
   * 测试构造函数依赖注入
   * @param A $a [使用引来注入A]
   */
  public function construct(A $a) {
    $this->aObj = $a;
  }
  /**
   * [测试方法调用依赖注入]
   * @param C   $c [依赖注入C]
   * @param string $b [这个是自己手动填写的参数]
   * @return [type]  [description]
   */
  public function bb(C $c, $b) {
    $c->cc();
    echo "\r\n";
    echo 'params:' . $b;
  }
  /**
   * 验证依赖注入是否成功
   * @return [type] [description]
   */
  public function bbb() {
    $this->aObj->aac();
  }
}
class C {
  public function cc() {
    echo 'this is C->cc';
  }
}

Testabhängigkeitsinjektion des Konstruktors

// 使用Ioc来创建B类的实例，B的构造函数依赖A类，A的构造函数依赖C类。
$bObj = Ioc::getInstance('B');
$bObj->bbb(); // 输出：this is C->cc ， 说明依赖注入成功。
// 打印$bObj
var_dump($bObj);
// 打印结果，可以看出B中有A实例，A中有C实例，说明依赖注入成功。
object(B)#3 (1) {
 ["aObj":protected]=>
 object(A)#7 (1) {
  ["cObj":protected]=>
  object(C)#10 (0) {
  }
 }
}

Testmethoden-Abhängigkeitsinjektion

Ioc::make('B', 'bb', ['this is param b']);
// 输出结果，可以看出依赖注入成功。
this is C->cc
params:this is param b

Aus den obigen beiden Beispielen können wir ersehen, dass wir, wenn wir ein Objekt erstellen oder eine Methode aufrufen, nicht wissen müssen, von welcher Klasse die Klasse oder Methode abhängt. Durch die Verwendung des Reflexionsmechanismus können die erforderlichen Klassen für uns einfach automatisch eingefügt werden.

Zusammenfassung

Okay, denken Sie, dass der obige Code sehr einfach ist? Solange Sie mit dem Reflexionsmechanismus vertraut sind Von PHP ist die Implementierung der Abhängigkeitsinjektion nicht schwierig. Der obige Code wurde einfach geschrieben, um das Verständnis zu erleichtern. In tatsächlichen Projekten werden beispielsweise die injizierten Klassen und Parameter nicht so einfach konfiguriert Instanziierte Klassen werden zwischengespeichert. Wenn Sie das nächste Mal eine Instanz dieser Klasse benötigen, können Sie sie direkt verwenden, ohne sie erneut zu initialisieren usw. Aber ich glaube, dass man, sobald man die Prinzipien verstanden hat, den Rest entsprechend den Anforderungen des Projekts verbessern kann.

Verwandte Empfehlungen:

Kurze Beschreibung der Beispiele für PHP-Reflexionsmechanismen und ausführliche Erklärung

Beispielcode für die Verwendung des PHP-Reflektionsmechanismus

Details zum PHP-Reflektionsmechanismus und Beispiele für die Plug-in-Architektur

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung, wie PHP die automatische Abhängigkeitsinjektion basierend auf Tipps zum Reflection-Mechanismus_php implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!