PHP类的反射和依赖注入

/**
 * 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 = , $y = )
    {
        $this->x = $x;
        $this->y = $y;
    }
}

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

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

    const PI = 3.14;

    public function __construct(Point $point, $radius = )
    {
        $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, );
    }
}

ReflectionClass

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

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

　　

反射出类的常量

$reflectionClass->getConstants();

　　

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

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

　　

 

通过反射获取属性

$reflectionClass->getProperties();

　　

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

array() {
  []=>
  object(ReflectionProperty)# () {
    ["name"]=>
    string() "radius"
    ["class"]=>
    string() "Circle"
  }
  []=>
  object(ReflectionProperty)# () {
    ["name"]=>
    string() "center"
    ["class"]=>
    string() "Circle"
  }
}

反射出类中定义的方法

$reflectionClass->getMethods();

　　

返回ReflectionMethod对象构成的数组

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"
  }
}

　　

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

$constructor = $reflectionClass->getConstructor();

　　

 

反射出方法的参数

$parameters = $constructor->getParameters();

　　

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

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

　　

 

依赖注入

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

//构建类的对象
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[] = '';
            }
        } else {
            //递归解析出依赖类的对象
            $dependencies[] = make($parameter->getClass()->name);
        }
    }

    return $dependencies;
}

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

$circle = make('Circle');
$area = $circle->area();
var_dump($area);
$areas = $circle->printCenter();
var_dump($areas);

　　

float(3.14)
center coordinate is (0, 0)