结合thinkphp浅谈反射控制反转和依赖注入

我的博客

文章出自 Inn 的博客：https://www.gog5.cn/archives/8/
第一次开通博客，欢迎小伙伴们点赞、交换友情链接

IoC 是什么

建议先看看 IoC 基础，写的很好。

Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。Ioc 意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。传统程序设计，我们直接在对象内部通过 new 进行创建对象，是程序主动去创建依赖对象；而 IoC 是有专门一个容器来创建这些对象，即由 Ioc 容器来控制对象的创建。

传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转，而反转则是由容器来帮忙创建及注入依赖对象。为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，依赖对象的获取被反转了。

<?php

interface Database
{public function insert();
}

class Mysql implements Database
{public function insert()
    {echo 'Mysql insert';}
}
class Oracle implements Database
{public function insert()
    {echo 'Oracle insert';}
}

class App
{
    protected $database;

    public function __construct()
    {$this->database = new Mysql();
    }

    public function insertLog()
    {$this->database->insert();
    }
}

$app = new App();
$app->insertLog();

上面的代码实现了写入数据库日志功能，看起来没什么问题，但是如果我要把 Mysql 改成 Oracle 数据库，那就得重新修改 App 类了。实际上这并没有达到解耦。我们可以稍作修改。

class App
{
    protected $database;

    public function __construct(Database $database)
    {$this->database = $database;}

    public function insertLog()
    {$this->database->insert();
    }
}

$app = new App(new Oracle());
$app->insertLog();

现在通过构造函数传递参数就可以实现修改数据库了，由外部注入依赖对象，App 对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了，我们可以称其为控制反转。

IoC 和 DI

DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解 DI 的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 谁依赖于谁：当然是应用程序依赖于 IoC 容器；
• 为什么需要依赖：应用程序需要 IoC 容器来提供对象需要的外部资源；
• 谁注入谁：很明显是 IoC 容器注入应用程序某个对象，应用程序依赖的对象；
• 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

我们来看看 thinkphp6 的获取容器中的实例方法

$arrayItem = app('org\utils\ArrayItem');

这里实际上在底层调用了 think\Container 的invokeClass方法

public function invokeClass(string $class, array $vars = [])
{
    try {$reflect = new ReflectionClass($class);
    } catch (ReflectionException $e) {throw new ClassNotFoundException('class not exists:' . $class, $class, $e);
    }

    if ($reflect->hasMethod('__make')) {$method = $reflect->getMethod('__make');
        if ($method->isPublic() && $method->isStatic()) {$args = $this->bindParams($method, $vars);
            return $method->invokeArgs(null, $args);
        }
    }

    $constructor = $reflect->getConstructor();

    $args = $constructor ? $this->bindParams($constructor, $vars) : [];

    $object = $reflect->newInstanceArgs($args);

    $this->invokeAfter($class, $object);

    return $object;
}

原来 tp 是用反射来实现依赖注入的，我们看到这行，正是实例化了一个反射类。

$reflect = new ReflectionClass($class);

反射指在 PHP 运行状态中，扩展分析 PHP 程序，导出或提取出关于类，方法，属性，参数等详细信息，包括注释。这种动态获取信息以及动态调用对象方法的功能称为反射 API，反射类的方法有：

https://www.php.net/manual/zh/book.reflection.php

ReflectionClass::__construct — 初始化 ReflectionClass 类
ReflectionClass::export — 导出一个类
ReflectionClass::getConstant — 获取定义过的一个常量
ReflectionClass::getConstants — 获取一组常量
ReflectionClass::getConstructor — 获取类的构造函数
ReflectionClass::getDefaultProperties — 获取默认属性
ReflectionClass::getDocComment — 获取文档注释
ReflectionClass::getEndLine — 获取最后一行的行数
ReflectionClass::getExtension — 根据已定义的类获取所在扩展的 ReflectionExtension 对象
ReflectionClass::getExtensionName — 获取定义的类所在的扩展的名称
ReflectionClass::getFileName — 获取定义类的文件名
ReflectionClass::getInterfaceNames — 获取接口（interface）名称
ReflectionClass::getInterfaces — 获取接口
ReflectionClass::getMethod — 获取一个类方法的 ReflectionMethod。ReflectionClass::getMethods — 获取方法的数组
ReflectionClass::getModifiers — 获取类的修饰符
ReflectionClass::getName — 获取类名
ReflectionClass::getNamespaceName — 获取命名空间的名称
ReflectionClass::getParentClass — 获取父类
ReflectionClass::getProperties — 获取一组属性
ReflectionClass::getProperty — 获取类的一个属性的 ReflectionProperty
ReflectionClass::getReflectionConstant — Gets a ReflectionClassConstant for a class's constant
ReflectionClass::getReflectionConstants — Gets class constants
ReflectionClass::getShortName — 获取短名
ReflectionClass::getStartLine — 获取起始行号
ReflectionClass::getStaticProperties — 获取静态（static）属性
ReflectionClass::getStaticPropertyValue — 获取静态（static）属性的值
ReflectionClass::getTraitAliases — 返回 trait 别名的一个数组
ReflectionClass::getTraitNames — 返回这个类所使用 traits 的名称的数组
ReflectionClass::getTraits — 返回这个类所使用的 traits 数组
ReflectionClass::hasConstant — 检查常量是否已经定义
ReflectionClass::hasMethod — 检查方法是否已定义
ReflectionClass::hasProperty — 检查属性是否已定义
ReflectionClass::implementsInterface — 接口的实现
ReflectionClass::inNamespace — 检查是否位于命名空间中
ReflectionClass::isAbstract — 检查类是否是抽象类（abstract）ReflectionClass::isAnonymous — 检查类是否是匿名类
ReflectionClass::isCloneable — 返回了一个类是否可复制
ReflectionClass::isFinal — 检查类是否声明为 final
ReflectionClass::isInstance — 检查类的实例
ReflectionClass::isInstantiable — 检查类是否可实例化
ReflectionClass::isInterface — 检查类是否是一个接口（interface）ReflectionClass::isInternal — 检查类是否由扩展或核心在内部定义
ReflectionClass::isIterable — Check whether this class is iterable
ReflectionClass::isIterateable — 检查是否可迭代（iterateable）ReflectionClass::isSubclassOf — 检查是否为一个子类
ReflectionClass::isTrait — 返回了是否为一个 trait
ReflectionClass::isUserDefined — 检查是否由用户定义的
ReflectionClass::newInstance — 从指定的参数创建一个新的类实例
ReflectionClass::newInstanceArgs — 从给出的参数创建一个新的类实例。ReflectionClass::newInstanceWithoutConstructor — 创建一个新的类实例而不调用它的构造函数
ReflectionClass::setStaticPropertyValue — 设置静态属性的值
ReflectionClass::__toString — 返回 ReflectionClass 对象字符串的表示形式。

知道反射类的基本方法了，我们来实现一个不用 new 对应 class 就可以实例化对象的方法：

function make($class)
{
    // 建立这个类的反射类
    $reflect = new ReflectionClass($class);
    // 拿到构造方法
    $constructor = $reflect->getConstructor();
    // 没有构造方法, 直接返回实例
    if (is_null($constructor)) {return $reflect->newInstance();
    }
    // 获取构造方法的参数
    $parameters = $constructor->getParameters();
    // 传入参数实例化 class
    return $reflect->newInstanceArgs($parameters);
}

$std = new stdClass();
var_dump($std);
$std2 = make('stdClass');
var_dump($std2);

上面的 $std 和 $std2 对象都是一样的。但是我们还没实现依赖注入，接着再来改造一下。

...

class App
{
    protected $database;

    public function __construct(Oracle $database)
    {$this->database = $database;}

    public function insertLog()
    {$this->database->insert();
    }
}

function make($class)
{$reflect = new ReflectionClass($class);
    $constructor = $reflect->getConstructor();
    if (is_null($constructor)) {return $reflect->newInstance();
    }

    // 返回构造函数里的依赖实例
    $instances = getParameters($constructor);
    return $reflect->newInstanceArgs($instances);
}

function getParameters($constructor)
{$parameters = $constructor->getParameters();
    $dependencies = [];
    foreach ($parameters as $parameter) {
        // 调用 make 方法递归获取实例
        //$parameter->getClass()->name  获得类型提示类名，比如 function Test(App $app)，就是 App
        $dependencies[] = make($parameter->getClass()->name);
    }
    return $dependencies;
}
$app = make('App');
$app->insertLog();

上面程序里 IoC 容器自动实例化了 Oracle 类，并注入到 App 类里，所以我们不需要手动传入，我们可以称其为依赖注入。

解耦合

上面的代码还是没有完全达到解偶。如果很多页面的构造里都注入了 Mysql，但是有一天要把系统换成 Oracle 记录日志，那我们岂不是全部页面都要改成 Oracle？
而且之前课程 浅谈 thinkphp 的服务容器 (https://www.gog5.cn/archives/6/)
我们还没有实现 IoC 和 DI。

所以会结合上一节 浅谈 thinkphp 的服务容器 实现依赖注入。

interface Database
{public function insert();
}
class Mysql implements Database
{public function insert()
    {echo 'Mysql insert';}
}
class Oracle implements Database
{public function insert()
    {echo 'Oracle insert';}
}

class App
{
    protected $database;

    public function __construct(Database $database)
    {$this->database = $database;}

    public function insertLog()
    {$this->database->insert();
    }
}

class Container
{protected $bind = [];

    /**
     * @param string $abstract 类标识、接口
     * @param string $concrete 要绑定的类
     */
    public function bind($abstract, $concrete)
    {$this->bind[$abstract] = $this->build($concrete);
    }

    public function make($abstract)
    {if (!isset($this->bind[$abstract])) {$this->bind($abstract, $abstract);
        }
        return $this->bind[$abstract];
    }

    // 相当于之前的 make 方法
    public function build($abstract)
    {$reflect = new ReflectionClass($abstract);
        $constructor = $reflect->getConstructor();
        if (is_null($constructor)) {return $reflect->newInstance();
        }
        $instances = $this->getParameters($constructor);
        return $reflect->newInstanceArgs($instances);
    }

    protected function getParameters($constructor)
    {$parameters = $constructor->getParameters();
        $dependencies = [];
        foreach ($parameters as $parameter) {$dependencies[] = $this->make($parameter->getClass()->name);
        }
        return $dependencies;
    }
}

$container = new Container();
$container->bind('Database', 'Mysql');
$app = $container->make('App');
$app->insertLog();

我们把 App 构造的类提示从 Oracle 类改成 Database接口，这样就可以让容器决定注入数据库类了：

public function __construct(Database $database)

怎么让容器决定注入的类，bind方法里，先是把 Mysql 类实例化，然后映射到 Database 接口。
make解析实例的时候，会把 Database 换成 Mysql 实例，注入到参数里。

$container->bind('Database', 'Mysql');

以后需要更换数据库时候，只要在绑定容器的地方，把映射类替换掉，所有页面也都生效了。

$container->bind('Database', 'Oracle');

到这里容器、依赖注入、控制反转也就讲完了。