Laravel框架下容器Container 的依赖注入和反射应用

　　依赖注入，简单说是把类里头依赖的对象，置于类外头，即客户端调用处。相当于把类与类解耦。

　　一个简单的例子：

　　

class A {

public function __construct() {
// 这种实例化写法, A类的内部,依赖了B类 需要解耦
$this->b = new B();
}

public function say(){
$this->b->talk();
}
}

class B{

public function __construct() {

}

public function talk(){
echo __METHOD__;
}
}

$a = new A;
$a->say();

　　A类依赖B类，耦合较重。

　　换一种写法：

　　

class A {

public function __construct(B $b) {// B的实例化,放在客户端,当作构造参数传递过来
$this->b = $b;
}

public function say(){
$this->b->talk();
}
}

class B{
public function __construct() {
}

public function talk(){
echo __METHOD__;
}
}

$b = new B;// 在客户端实例化B
$a = new A($b);// 构造器中传递
$a->say();

这个代码，就相当于实例化B的步骤放在了A类的外部，从而实现解耦。这就是依赖注入的一种实现方式。

Laravel框架中，通过这种依赖注入的方式，再配合反射功能，实现功能。

比如在Laravel的容器类，Container.php（vendor/laravel/framework/src/illuminate/Container/Container.php）中

利用反射，实例化注入的类。

来一段代码：

/**
*
* 依赖注入的思想,把外部依赖的类放在构造函数的参数里
*
* Laravel框架根据反射 搞定依赖
*/

class Test{

public function __construct(Para $p1, Parb $p2) {
echo $p1->getInfo()," ",$p2->getInfo()," ";
}

function say(){
echo __CLASS__;
return;
}
}

/**
* Class Para
* 参数A
*/
class Para {

function getInfo() {
echo __CLASS__;
}
}

/**
* Class Parb
* 参数B
*/
class Parb {

function getInfo(){
echo __CLASS__;
}
}

$obj = new Test(new Para(), new Parb());

// ===================================================

$reflector = new ReflectionClass($obj);// 对象 反射其类信息
$constructor = $reflector->getConstructor();

$dependencies = $constructor->getParameters();// 获取构造器下的参数信息
$parArr = array();
foreach ($dependencies as $depend){
// $depend->getClass()->name 获取类名称 构造器参数是类
$parArr[] = new ($depend->getClass()->name)();
}

$refNew = $reflector->newInstanceArgs($parArr);// Test 对象

$refNew->say();

代码中，获取$obj反射后的类信息，再取其构造器中的依赖类，实例化这些依赖类，再传入Test类中。　　

这就是Laravel容器中实现的依赖注入和反射应用。

下边的代码有助于理解Laravel框架下的容器Container概念。参考自文章：https://www.insp.top/article/learn-laravel-container

<?php

interface SuperModuleInterface{
public function activate(array $target);
}

class Superman
{
protected $module;

/**
* Superman constructor.
* @param SuperModuleInterface $module
* 通过构造器 注入依赖
*/
public function __construct(SuperModuleInterface $module)
{
$this->module = $module;
}

public function show(array $target){

$this->module->activate($target);
}
}

class PowerA implements SuperModuleInterface
{
public function activate(array $target)
{
echo '<pre>'. __METHOD__;
print_r(func_get_args());
}
}

class PowerB implements SuperModuleInterface
{
public function activate(array $target)
{
echo '<pre>'. __METHOD__;
print_r(func_get_args());
}
}

class Container
{
protected $binds;

protected $instances;

/**
* @param $abstract
* @param $concrete
* 把代词 绑定到容器里,为后续make
*/
public function bind($abstract, $concrete)
{
if ($concrete instanceof Closure) {
$this->binds[$abstract] = $concrete;
} else {
$this->instances[$abstract] = $concrete;
}
}

/**
* @param $abstract
* @param array $parameters
* @return mixed
* 创建对象
*/
public function make($abstract, $parameters = [])
{
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
// 把容器对象$this,放到参数数组第一个元素。为call_user_func_array使用
array_unshift($parameters, $this);

// 这里$this->binds[$abstract] 绑定的闭包函数, 执行函数参数是$parameters
return call_user_func_array($this->binds[$abstract], $parameters);
}
}

// 创建一个容器（后面称作超级工厂）
$container = new Container;

// 向该 超级工厂添加超能力模组的生产脚本
$container->bind('powerA', function($container) {
return new PowerA;
});

// 同上
$container->bind('powerB', function($container) {
return new PowerB;
});

// 向该 超级工厂添加超人的生产脚本
$container->bind('superman', function($container, $moduleName) {
return new Superman($container->make($moduleName));
});

echo "<pre>";

// 开始启动生产
$superman_1 = $container->make('superman', ['powerA']);
$superman_1->show(['a' => 1]);

$superman_2 = $container->make('superman', ['powerB']);
$superman_2->show(['b' => 1]);