php 依赖注入的理解

• PHP 依赖注入容器实现

• w3c-PHP7中Closure :: call使用示例

• php手册-Closure::call

• php手册-反射

依赖注入是应用于一个类的实例化需要依赖另外一个类的场景。

materials = [$bread];
    }


    /**
     * 测试函数
     */
    public function getName()
    {
        echo '111';
    }

}


class Container
{
    /**
     * @var Closure[]
     */
    public $binds = [];

    /**
     * Bind class by closure.
     *
     * @param string $class
     * @param Closure $closure
     * @return $this
     */
    public function bind(string $class, Closure $closure)
    {
        $this->binds[$class] = $closure;

        return $this;
    }

    /**
     * Get object by class
     *
     * @param string $class
     * @param array $params
     * @return object
     */
    public function make(string $class, array $params = [])
    {
        if (isset($this->binds[$class])) {
            //  或者 if (array_key_exists($class,$this->binds)) {
            return ($this->binds[$class])->call($this, $this, ...$params);
        }

        return new $class(...$params);
    }
}

$container = new Container();

$container->bind(Hamburger::class, function (Container $container) {
    //  此时使用 make 得到i的是    return new $class(...$params); 也就是返回的 Bread 类的实例，因为没有 bind Bread 这个类
    $bread = $container->make(Bread::class);
    return new Hamburger($bread);
});


//
echo '
';
echo '$container类';
print_r($container);
echo '
';

echo 'Hamburger参数值
';
print_r(($container->binds['Hamburger'])->call($container, $container)); // 直接使用类名或者类都可以
echo '或者
';
print_r(($container->binds[Hamburger::class])->call($container, $container));
echo '
';
echo 'Hamburger 的闭包 
';
print_r(($container->binds[Hamburger::class]));
 
 
 
  
 
   
 
     
   
 
  
 
  

    image.png 
  
 
 
 
 
在调用 bind 方法的时候，第一个参数并不一点非要传递类，是可以传递任何字符串的，只要保证 bind(‘string’) 与 make('string') 中 string 值保持一致即可，这也是laravel 中 alias别名的原理。 别传递类，是为了在使用的时候方便知道make 出来的是哪个类。这可以说是一种约定
 
 
以上方式，为了好理解，我直接取出了 make中的 return 处理，在实例使用中，如果需要使用某个类，在绑定之后，可以直接使用以下方式就可以获取到类的实例化
 
 
$hambuger = $container->make(Hamburger::class);
 
 
 
  
$container->binds[Hamburger::class] 对应的值是一个闭包。因为 Hamburger::class 在使用到 bind 方法的时候，调用第二个参数 Closure 的时候是需要传递值的，所以 ($this->binds[$class])->call($this, $this, ...$params) 中的第一个 container) 中Container $container` 的实参
 如果我们使用回掉的时候不需要传递参数，如以下方式，则 call(),就不需要传递第二个参数
 使用 Closure::call 可以得到参数中类的实例化，们以上的测试是为了获取到 Hamburger 类的实例化
 但是如果直接使用闭包，则无法获取到想要的类
 
 
 
 
 
  
Container 类不变，如果改成以下使用方式
 
 
 
 
$container = new Container();
$container->bind(Hamburger::class, function () {
    return 111;
});


echo '
';
print_r(($container->binds[Hamburger::class])->call($container));
echo '
';

print_r(($container->binds[Hamburger::class])());

make 方法也可以改成
public function make(string $class, array $params = [])
    {
        if (isset($this->binds[$class])) {
            return ($this->binds[$class])->call($this, ...$params);
        }

        return new $class(...$params);
    }
 
 
 
  
 
   
 
     
   
 
  
 
  

    image.png 
  
 
 
 
 
不过如开篇所说，依赖注入是应用于一个类的实例化需要依赖另外一个类的场景 如果一个类的实例化不需要依赖别的类，那么我们就不需要使用 Container 类的这种方式了
 
 
以上方式的依赖注入，需要先使用 bind 函数绑定相应的类，并在绑定的回掉中将构造函数需要的类 Bread 先实例化，这样其实并没有得到很好的优化。我们可以使用PHP的反射机制，来自动的实例化需要的参数类，而不用手动 bind
 
 
    /**
     * @param string $class
     * @param array $params
     * @return mixed|object
     * @throws ReflectionException
     */
    public function make(string $class, array $params = [])
    {
        if (isset($this->binds[$class])) {
            return ($this->binds[$class])->call($this, $this, ...$params);
        }

          return $this->binds[$class] = $this->resolve($class, $params);
    }

    /**
     * Get object by reflection
     *
     * @param $abstract
     * @return object
     * @throws ReflectionException
     */
    protected function resolve($abstract)
    {
        // 获取反射对象
        $constructor = (new ReflectionClass($abstract))->getConstructor();
        // 构造函数未定义，直接实例化对象
        if (is_null($constructor)) {
//  如果没有构造函数，则直接返回实 $abstract 的例化
            return new $abstract;
        }
        // 获取构造函数参数
        $parameters = $constructor->getParameters();
        $arguments  = [];
        foreach ($parameters as $parameter) {
            // 获得参数的类型提示类
            $paramClassName = $parameter->getClass()->getName();
            // 参数没有类型提示类，抛出异常
            if (is_null($paramClassName)) {
                throw new Exception('Fail to get instance by reflection');
            }
            // 实例化参数 $paramClassName 参数没有绑定的情况下，还是会回掉到 resolve 函数，但是总会有不需要类实例为参数的类，为节点，则一步步走出来。
// 但是这种情况下是使用与实例传递的是类的情况，而不适用于其他参数 如果在 Bread 中添加一个构造函数，你就会发现报错
//不过    $constructor = (new ReflectionClass($abstract))->getConstructor(); 就是限制的查看构造函数的处理。
            $arguments[] = $this->make($paramClassName);
        }

        return new $abstract(...$arguments);
    }
 
 
使用
 
 
$container = new Container();
$hambuger = $container->make(Hamburger::class);
$hambuger->getName();
 
 

binds[$class])) {
            return ($this->binds[$class])->call($this, $this, ...$params);
        }
           return $this->binds[$class] = $this->resolve($class, $params);
    }


    /**
     * 解析一个类的构造函数，并且实例化
     * @param $abstract
     * @param $request_params
     * @return mixed
     * @throws \ReflectionException
     */
    protected function resolve($abstract, $request_params)
    {
        //  获取构造函数
        $constructor = (new \ReflectionClass($abstract))->getConstructor();
        // 没有构造函数，则直接返回类的实例化
        if (is_null($constructor)) {
            return new $abstract;
        }

        // 获取构造函数中的参数
        $params = $constructor->getParameters();
        $arguments = [];
        foreach ($params as $param) {
            if (is_null($param->getClass())) {
                $arguments[] = $request_params[$param->getPosition()]; // 对应的位置赋值对应的参数
                //  参数不是类
            } else {
                $arguments[] = $this->make($param->getClass()->getName());
            }
        }
        return new $abstract(...$arguments);
    }

}