So implementieren Sie die reflektierende Injektion in einem PHP-Interview

PHP verfügt über eine vollständige Reflexions-API, die die Möglichkeit bietet, Klassen, Schnittstellen, Funktionen, Methoden und Erweiterungen zurückzuentwickeln. Durch die von der Klassenreflexion bereitgestellten Funktionen können wir wissen, wie die Klasse definiert ist, welche Attribute sie hat, welche Methoden sie hat, welche Parameter die Methode hat, wie der Pfad zur Klassendatei lautet und andere sehr wichtige Informationen. Gerade aufgrund der Klassenreflexion können viele PHP-Frameworks die Abhängigkeitsinjektion implementieren, um die Abhängigkeiten zwischen Klassen automatisch aufzulösen, was unserer täglichen Entwicklung große Erleichterung bringt.

In diesem Artikel wird hauptsächlich erläutert, wie die Klassenreflexion zum Implementieren der Abhängigkeitsinjektion (Abhängigkeitsinjektion) verwendet wird. Es wird nicht jede API in PHP Reflection einzeln beschrieben. Zum besseren Verständnis schauen wir uns die Klassenreflexion anhand eines Beispiels an und zeigen, wie die Abhängigkeitsinjektion implementiert wird.

Die folgende Klasse stellt einen Punkt im Koordinatensystem dar und hat zwei Attribute: Abszisse x und Ordinate y.

/**
 * Class Point
 */
class Point
{
  public $x;
  public $y;

  /**
   * Point constructor.
   * @param int $x horizontal value of point's coordinate
   * @param int $y vertical value of point's coordinate
   */
  public function __construct($x = 0, $y = 0)
  {
    $this->x = $x;
    $this->y = $y;
  }
}

Die nächste Klasse stellt einen Kreis dar. Sie können sehen, dass es in ihrem Konstruktor einen Parameter gibt, der zur Point-Klasse gehört, das heißt, die Circle-Klasse ist von der Point-Klasse abhängig .

class Circle
{
  /**
   * @var int
   */
  public $radius;//半径

  /**
   * @var Point
   */
  public $center;//圆心点

  const PI = 3.14;

  public function __construct(Point $point, $radius = 1)
  {
    $this->center = $point;
    $this->radius = $radius;
  }
  
  //打印圆点的坐标
  public function printCenter()
  {
    printf('center coordinate is (%d, %d)', $this->center->x, $this->center->y);
  }

  //计算圆形的面积
  public function area()
  {
    return 3.14 * pow($this->radius, 2);
  }
}

ReflectionClass

Als Nächstes verwenden wir Reflection, um die Circle-Klasse zurückzuentwickeln. Übergeben Sie den Namen der Circle-Klasse an ReflectionClass, um ein Objekt der ReflectionClass-Klasse zu instanziieren.

$reflectionClass = new reflectionClass(Circle::class);
//返回值如下
object(ReflectionClass)#1 (1) {
 ["name"]=>
 string(6) "Circle"
}

Reflektierte Konstanten der Klasse

$reflectionClass->getConstants();

Gibt ein assoziatives Array von Konstantennamen und -werten zurück

array(1) {
 ["PI"]=>
 float(3.14)
}

Eigenschaften durch Reflektion abrufen

$reflectionClass->getProperties();

Gibt ein aus ReflectionProperty-Objekten bestehendes Array zurück

array(2) {
 [0]=>
 object(ReflectionProperty)#2 (2) {
  ["name"]=>
  string(6) "radius"
  ["class"]=>
  string(6) "Circle"
 }
 [1]=>
 object(ReflectionProperty)#3 (2) {
  ["name"]=>
  string(6) "center"
  ["class"]=>
  string(6) "Circle"
 }
}

Reflektiert die in der Klasse definierte Methode

$reflectionClass->getMethods();

Gibt ein Array von ReflectionMethod-Objekten zurück

array(3) {
 [0]=>
 object(ReflectionMethod)#2 (2) {
  ["name"]=>
  string(11) "__construct"
  ["class"]=>
  string(6) "Circle"
 }
 [1]=>
 object(ReflectionMethod)#3 (2) {
  ["name"]=>
  string(11) "printCenter"
  ["class"]=>
  string(6) "Circle"
 }
 [2]=>
 object(ReflectionMethod)#4 (2) {
  ["name"]=>
  string(4) "area"
  ["class"]=>
  string(6) "Circle"
 }
}

Wir können die Konstruktormethode der Klasse auch separat über getConstructor(), Its, abrufen Der Rückgabewert ist ein ReflectionMethod-Objekt.

$constructor = $reflectionClass->getConstructor();

Spiegeln Sie die Parameter der Methode wider

$parameters = $constructor->getParameters();

Der Rückgabewert ist ein Array bestehend aus ReflectionParameter-Objekten.

array(2) {
 [0]=>
 object(ReflectionParameter)#3 (1) {
  ["name"]=>
  string(5) "point"
 }
 [1]=>
 object(ReflectionParameter)#4 (1) {
  ["name"]=>
  string(6) "radius"
 }
}

Abhängigkeitsinjektion

Okay, als nächstes schreiben wir eine Funktion namens make, übergeben den Klassennamen an die make-Funktion und geben das Objekt der Klasse zurück make Es wird uns helfen, die Abhängigkeiten der Klasse einzufügen, das heißt in diesem Fall, es hilft uns, das Point-Objekt in den Konstruktor der Circle-Klasse einzufügen.

//构建类的对象
function make($className)
{
  $reflectionClass = new ReflectionClass($className);
  $constructor = $reflectionClass->getConstructor();
  $parameters = $constructor->getParameters();
  $dependencies = getDependencies($parameters);
  
  return $reflectionClass->newInstanceArgs($dependencies);
}

//依赖解析
function getDependencies($parameters)
{
  $dependencies = [];
  foreach($parameters as $parameter) {
    $dependency = $parameter->getClass();
    if (is_null($dependency)) {
      if($parameter->isDefaultValueAvailable()) {
        $dependencies[] = $parameter->getDefaultValue();
      } else {
        //不是可选参数的为了简单直接赋值为字符串0
        //针对构造方法的必须参数这个情况
        //laravel是通过service provider注册closure到IocContainer,
        //在closure里可以通过return new Class($param1, $param2)来返回类的实例
        //然后在make时回调这个closure即可解析出对象
        //具体细节我会在另一篇文章里面描述
        $dependencies[] = '0';
      }
    } else {
      //递归解析出依赖类的对象
      $dependencies[] = make($parameter->getClass()->name);
    }
  }

  return $dependencies;
}

Nachdem wir die make-Methode definiert haben, verwenden wir sie, um Objekte der Circle-Klasse zu instanziieren:

$circle = make('Circle');
$area = $circle->area();
/*var_dump($circle, $area);
object(Circle)#6 (2) {
 ["radius"]=>
 int(1)
 ["center"]=>
 object(Point)#11 (2) {
  ["x"]=>
  int(0)
  ["y"]=>
  int(0)
 }
}
float(3.14)*/

Durch die Im obigen Beispiel habe ich kurz beschrieben, wie die Reflexion von PHP-Klassen zur Implementierung der Abhängigkeitsinjektion verwendet wird. Die Abhängigkeitsinjektion von Laravel wird ebenfalls durch diese Idee implementiert, aber das Design ist ausgefeilter und nutzt in großem Umfang Schließungsrückrufe, um verschiedene komplexe Abhängigkeiten zu bewältigen Injektionen.

Empfohlenes Tutorial: PHP-Video-Tutorial

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die reflektierende Injektion in einem PHP-Interview. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!