PHP具有完整的反射API，提供了对类、接口、函数、方法和扩展进行逆向工程的能力。通过类的反射提供的能力我们能够知道类是如何被定义的，它有什么属性、什么方法、方法都有哪些参数，类文件的路径是什么等很重要的信息。正是因为类的反射，很多PHP框架才能实现依赖注入自动解决类与类之间的依赖关系，这给我们平时的开发带来了很大的方便。

本文主要是讲解如何利用类的反射来实现依赖注入(Dependency Injection)，并不会去逐条讲述PHP Reflection里的每一个API。为了更好地理解，我们通过一个例子来看类的反射，以及如何实现依赖注入。

下面这个类代表了坐标系里的一个点，有两个属性横坐标x和纵坐标y。

1. /** 
2.  
3.  * Class Point 
4.  
5.  */ 
6.  
7. class Point 
8.  
9. { 
10.  
11.  public $x; 
12.  
13.  public $y; 
14.  
15.    
16.  
17.  /** 
18.  
19.  * Point constructor. 
20.  
21.  * @param int $x horizontal value of point's coordinate 
22.  
23.  * @param int $y vertical value of point's coordinate 
24.  
25.  */ 
26.  
27.  public function __construct($x = 0, $y = 0) 
28.  
29.  { 
30.  
31.  $this->x = $x; 
32.  
33.  $this->y = $y; 
34.  
35.  } 
36.  
37. } 

接下来这个类代表圆形，可以看到在它的构造函数里有一个参数是Point类的，即Circle类是依赖与Point类的。

1. class Circle 
2.  
3. { 
4.  
5.  /** 
6.  
7.  * @var int 
8.  
9.  */ 
10.  
11.  public $radius;//半径 
12.  
13.    
14.  
15.  /** 
16.  
17.  * @var Point 
18.  
19.  */ 
20.  
21.  public $center;//圆心点 
22.  
23.    
24.  
25.  const PI = 3.14; 
26.  
27.    
28.  
29.  public function __construct(Point $point, $radius = 1) 
30.  
31.  { 
32.  
33.  $this->center = $point; 
34.  
35.  $this->radius = $radius; 
36.  
37.  } 
38.  
39.    
40.  
41.  //打印圆点的坐标 
42.  
43.  public function printCenter() 
44.  
45.  { 
46.  
47.  printf('center coordinate is (%d, %d)', $this->center->x, $this->center->y); 
48.  
49.  } 
50.  
51.    
52.  
53.  //计算圆形的面积 
54.  
55.  public function area() 
56.  
57.  { 
58.  
59.  return 3.14 * pow($this->radius, 2); 
60.  
61.  } 
62.  
63. } 

ReflectionClass

下面我们通过反射来对Circle这个类进行反向工程。把Circle类的名字传递给reflectionClass来实例化一个ReflectionClass类的对象。

1. $reflectionClass = new reflectionClass(Circle::class); 
2.  
3. //返回值如下 
4.  
5. object(ReflectionClass)#1 (1) { 
6.  
7.  ["name"]=> 
8.  
9.  string(6) "Circle" 
10.  
11. } 

反射出类的常量

$reflectionClass->getConstants();

返回一个由常量名称和值构成的关联数组

1. array(1) { 
2.  
3.  ["PI"]=> 
4.  
5.  float(3.14) 
6.  
7. } 

通过反射获取属性

$reflectionClass->getProperties();

返回一个由ReflectionProperty对象构成的数组

1. array(3) { 
2.  
3.  [0]=> 
4.  
5.  object(ReflectionMethod)#2 (2) { 
6.  
7.  ["name"]=> 
8.  
9.  string(11) "__construct" 
10.  
11.  ["class"]=> 
12.  
13.  string(6) "Circle" 
14.  
15.  } 
16.  
17.  [1]=> 
18.  
19.  object(ReflectionMethod)#3 (2) { 
20.  
21.  ["name"]=> 
22.  
23.  string(11) "printCenter" 
24.  
25.  ["class"]=> 
26.  
27.  string(6) "Circle" 
28.  
29.  } 
30.  
31.  [2]=> 
32.  
33.  object(ReflectionMethod)#4 (2) { 
34.  
35.  ["name"]=> 
36.  
37.  string(4) "area" 
38.  
39.  ["class"]=> 
40.  
41.  string(6) "Circle" 
42.  
43.  } 
44.  
45. } 

我们还可以通过getConstructor()来单独获取类的构造方法，其返回值为一个ReflectionMethod对象。

$constructor = $reflectionClass->getConstructor();

反射出方法的参数

$parameters = $constructor->getParameters();

其返回值为ReflectionParameter对象构成的数组。

1. array(2) { 
2.  
3.  [0]=> 
4.  
5.  object(ReflectionParameter)#3 (1) { 
6.  
7.  ["name"]=> 
8.  
9.  string(5) "point" 
10.  
11.  } 
12.  
13.  [1]=> 
14.  
15.  object(ReflectionParameter)#4 (1) { 
16.  
17.  ["name"]=> 
18.  
19.  string(6) "radius" 
20.  
21.  } 
22.  
23. } 

依赖注入

好了接下来我们编写一个名为make的函数，传递类名称给make函数返回类的对象，在make里它会帮我们注入类的依赖，即在本例中帮我们注入Point对象给Circle类的构造方法。

1. //构建类的对象 
2.  
3. function make($className) 
4.  
5. { 
6.  
7.  $reflectionClass = new ReflectionClass($className); 
8.  
9.  $constructor = $reflectionClass->getConstructor(); 
10.  
11.  $parameters = $constructor->getParameters(); 
12.  
13.  $dependencies = getDependencies($parameters); 
14.  
15.     
16.  
17.  return $reflectionClass->newInstanceArgs($dependencies); 
18.  
19. } 
20.  
21.    
22.  
23. //依赖解析 
24.  
25. function getDependencies($parameters) 
26.  
27. { 
28.  
29.  $dependencies = []; 
30.  
31.  foreach($parameters as $parameter) { 
32.  
33.   $dependency = $parameter->getClass(); 
34.  
35.   if (is_null($dependency)) { 
36.  
37.    if($parameter->isDefaultValueAvailable()) { 
38.  
39.     $dependencies[] = $parameter->getDefaultValue(); 
40.  
41.    } else { 
42.  
43.     //不是可选参数的为了简单直接赋值为字符串0 
44.  
45.     //针对构造方法的必须参数这个情况 
46.  
47.     //laravel是通过service provider注册closure到IocContainer, 
48.  
49.     //在closure里可以通过return new Class($param1, $param2)来返回类的实例 
50.  
51.     //然后在make时回调这个closure即可解析出对象 
52.  
53.     //具体细节我会在另一篇文章里面描述 
54.  
55.     $dependencies[] = '0'; 
56.  
57.    } 
58.  
59.   } else { 
60.  
61.    //递归解析出依赖类的对象 
62.  
63.    $dependencies[] = make($parameter->getClass()->name); 
64.  
65.   } 
66.  
67.  } 
68.  
69.  return $dependencies; 
70.  
71. } 

定义好make方法后我们通过它来帮我们实例化Circle类的对象:

1. $circle = make('Circle'); 
2.  
3. $area = $circle->area(); 
4.  
5. /*var_dump($circle, $area); 
6.  
7. object(Circle)#6 (2) { 
8.  
9.  ["radius"]=> 
10.  
11.  int(1) 
12.  
13.  ["center"]=> 
14.  
15.  object(Point)#11 (2) { 
16.  
17.  ["x"]=> 
18.  
19.  int(0) 
20.  
21.  ["y"]=> 
22.  
23.  int(0) 
24.  
25.  } 
26.  
27. } 
28.  
29. float(3.14)*/ 

通过上面这个实例我简单描述了一下如何利用PHP类的反射来实现依赖注入，Laravel的依赖注入也是通过这个思路来实现的，只不过设计的更精密大量地利用了闭包回调来应对各种复杂的依赖注入。

Tags: php反射注入

分享到：