Detailed explanation of how PHP implements automatic dependency injection based on reflection mechanism

Detailed explanation of how PHP implements automatic dependency injection based on reflection mechanism_php tips

韦小宝

Release： 2023-03-17 18:42:02

Original

1892 people have browsed it

This article mainly introduces the PHP method to realize automatic dependency injection based on the reflection mechanism, and analyzes phpusing reflection to realize automatic dependency injection in the form of examples. The steps, principles and related operating techniques, this article describes the method of automatic dependency injection based on the reflection mechanism. Share it with everyone for your reference, let’s take a look at this article! Dependency injection is also called inversion of control. Anyone who has used the framework should be familiar with it. Many people think it is something very high-end when they see the name, and are daunted by it. Today I took the time to do some research and unravel its mystery. Without further ado, let’s go straight to the 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 = &#39;construct&#39;) {
    // 通过反射获得该类
    $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;
  }
}

Copy after login

The above code uses PHP’s reflection function to create a container class, using This class implements the dependency injection function of other classes. The above dependency injection is divided into two types, one is dependency injection of constructor, and the other is dependency injection of method. We use the following three classes for testing.

class A {
  protected $cObj;
  /**
   * 用于测试多级依赖注入 B依赖A，A依赖C
   * @param C $c [description]
   */
  public function construct(C $c) {
    $this->cObj = $c;
  }
  public function aa() {
    echo &#39;this is A->test&#39;;
  }
  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 &#39;params:&#39; . $b;
  }
  /**
   * 验证依赖注入是否成功
   * @return [type] [description]
   */
  public function bbb() {
    $this->aObj->aac();
  }
}
class C {
  public function cc() {
    echo &#39;this is C->cc&#39;;
  }
}

Copy after login

Test dependency injection of constructor

// 使用Ioc来创建B类的实例，B的构造函数依赖A类，A的构造函数依赖C类。
$bObj = Ioc::getInstance(&#39;B&#39;);
$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) {
  }
 }
}

Copy after login

Test method dependency injection

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

Copy after login

From the above two From this example, we can see that when we

create an object

or call a method, we don't need to know which class the class or method depends on. Using the reflection mechanism can easily automatically inject the required classes for us.

SummaryOkay, do you think the above code is very simple? In fact, as long as you are familiar with the reflection mechanism of PHP, dependency injection does not It is not difficult to implement. The above code is written simply to facilitate understanding. In actual projects, it will definitely not be so simple. For example, the injected classes and parameters will be configured, for example, the instantiated classes will be cached. The next time you need an instance of this class, you can use it directly without reinitializing it, etc. But I believe that once you understand the principles, you can improve the rest according to the needs of the project.

Related recommendations:

Brief description of php reflection mechanism examples and detailed explanation

PHP reflection mechanism usage example code

php reflection mechanism details and plug-in architecture examples

The above is the detailed content of Detailed explanation of how PHP implements automatic dependency injection based on reflection mechanism_php tips. For more information, please follow other related articles on the PHP Chinese website!