Explication détaillée de la façon dont PHP implémente l'injection automatique de dépendances basée sur les astuces du mécanisme de réflexion_php

Cet article présente principalement la méthode de PHP pour réaliser une injection automatique de dépendances basée sur le mécanisme de réflexion, et analyse l'utilisation de la réflexion pour réaliser une injection automatique de dépendances en php en combinaison avec des exemples. Les étapes, principes et techniques de fonctionnement associées, cet article décrit avec des exemples comment PHP implémente l'injection automatique de dépendances basée sur le mécanisme de réflexion. Partagez-le avec tout le monde pour votre référence, jetons un œil à cet article !

L'injection de dépendances est également appelée inversion de contrôle. Toute personne ayant utilisé un framework devrait le connaître. Beaucoup de gens pensent que c'est quelque chose de très haut de gamme quand ils voient ce nom, et sont intimidés par ce nom. Aujourd'hui, j'ai pris le temps de faire quelques recherches et de percer son mystère. Sans plus tarder, passons directement au 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;
  }
}

Le code ci-dessus utilise la fonction de réflexion de PHP pour créer une classe conteneur. , utilisez cette classe pour implémenter la fonction d'injection de dépendances d'autres classes. L'injection de dépendances ci-dessus est divisée en deux types, l'un est l'injection de dépendances du constructeur et l'autre est l'injection de dépendances de la méthode. Nous utilisons les trois classes suivantes pour les tests.

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';
  }
}

Test de l'injection de dépendance du constructeur

// 使用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) {
  }
 }
}

Injection de dépendance de méthode de test

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

À partir des deux exemples ci-dessus, nous pouvons voir que lorsque nous créons un objet ou appelons une méthode, nous n'avons pas besoin de savoir de quelle classe dépend la classe ou la méthode. L’utilisation du mécanisme de réflexion peut facilement injecter automatiquement les classes requises pour nous.

Résumé

D'accord, pensez-vous que le code ci-dessus est très simple en fait, tant que vous êtes familier avec le mécanisme de réflexion ? De PHP, l'injection de dépendances n'est pas difficile à mettre en œuvre. Le code ci-dessus est écrit simplement pour faciliter la compréhension. Dans les projets réels, ce ne sera certainement pas si simple. Par exemple, les classes et les paramètres injectés seront configurés. les classes instanciées seront mises en cache la prochaine fois que vous aurez besoin d'une instance de cette classe, vous pourrez l'utiliser directement sans la réinitialiser, etc. Mais je crois qu'une fois qu'on a compris le principe, on peut améliorer le reste en fonction des besoins du projet.

Recommandations associées :

Brève description des exemples de mécanismes de réflexion php et explication détaillée

Exemple de code d'utilisation du mécanisme de réflexion PHP

Détails du mécanisme de réflexion PHP et exemples d'architecture de plug-in

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!