谈谈thinkphp5.1中容器(Container)和门面(Facade)的实现

曾经终败给现在 2022-05-17 09:47 146阅读 0赞

p5.1中引入了容器(Container)和门面(Facade)这两个新的类

官方文档已经给出了定义：

> 容器（Container）实现类的统一管理，确保对象实例的唯一性。
> 
> 门面（Facade）为容器（Container）中的类提供了一个静态调用接口，相比于传统的静态方法调用， 带来了更好的可测试性和扩展性，你可以为任何的非静态类库定义一个facade类。

深入源码，我们来看看它到底是如何实现的：

// 在框架目录下的base.php文件
    
    // 注册核心类到容器
    Container::getInstance()->bind([
        'app'                   => App::class,
        'build'                 => Build::class,
        'cache'                 => Cache::class,
        'config'                => Config::class,
        ...
    ]);
    
    // 注册核心类的静态代理
    Facade::bind([
        facade\App::class      => App::class,
        facade\Build::class    => Build::class,
        facade\Cache::class    => Cache::class,
        facade\Config::class   => Config::class,
        ...
    ]);
    
    // 注册类库别名
    Loader::addClassAlias([
        'App'      => facade\App::class,
        'Build'    => facade\Build::class,
        'Cache'    => facade\Cache::class,
        'Config'   => facade\Config::class,
        ...
    ]);

容器实现：

这里，框架已经帮我们绑定了系统常用类到容器中，在之后使用时，只需要调用助手函数 app()进行容器中的类解析调用，对于已经绑定的类标识，会自动快速实例化。

// 实例化缓存类
    
    app('cache'); 
    // app('cache', ['file']); 参数化调用
    
    // 相当于执行了
    Container::get('cache');
    
    // 查看源码，Container调用的其实是make方法，在该方法里调用反射等实现类的实例化，过程如下：

public function make($abstract, $vars = [], $newInstance = false)
    {
        if (true === $vars) {
            // 总是创建新的实例化对象
            $newInstance = true;
            $vars        = [];
        }
    
        if (isset($this->instances[$abstract]) && !$newInstance) {
            $object = $this->instances[$abstract];
        } else {
            if (isset($this->bind[$abstract])) {
                $concrete = $this->bind[$abstract];
    　　　　　　　// 闭包实现
                if ($concrete instanceof \Closure) {
                    $object = $this->invokeFunction($concrete, $vars);
                } else {
                    $object = $this->make($concrete, $vars, $newInstance);
                }
            } else {
    　　　　　　　// 反射实现
                $object = $this->invokeClass($abstract, $vars);
            }
    
            if (!$newInstance) {
                $this->instances[$abstract] = $object;
            }
        }
    
        return $object;
    }

/**
     * 调用反射执行类的实例化 支持依赖注入
     * @access public
     * @param  string    $class 类名
     * @param  array     $vars  变量
     * @return mixed
     */
    public function invokeClass($class, $vars = [])
    {
        $reflect     = new \ReflectionClass($class);
        $constructor = $reflect->getConstructor();
    
        if ($constructor) {
            $args = $this->bindParams($constructor, $vars);
        } else {
            $args = [];
        }
    
        return $reflect->newInstanceArgs($args);
    }

/**
     * 执行函数或者闭包方法 支持参数调用
     * @access public
     * @param  string|array|\Closure $function 函数或者闭包
     * @param  array                 $vars     变量
     * @return mixed
     */
    public function invokeFunction($function, $vars = [])
    {
        $reflect = new \ReflectionFunction($function);
        $args    = $this->bindParams($reflect, $vars);
    
        return $reflect->invokeArgs($args);
    }

> 简而言之，容器内部是通过反射类或闭包等来实现类的实例化。

门面实现：

以一个例子来分析：

facade\Config::get('app_debug');

我们来分析一下它的实现方式：

// thinkphp\library\facade\Config 类

namespace think\facade;
    
    use think\Facade;
    
    class Config extends Facade
    {
    }

// 从源代码上看 Config本身没有任何方法，它继承了Facade的方法，但Facade并没有get这个静态方法
    // 此时，系统自动触发了魔术方法：__callStatic（）,Facade重写了此方法：

public static function __callStatic($method, $params)
    {
        return call_user_func_array([static::createFacade(), $method], $params);
    }

// 可见，最后调用的是用户自定义函数：call_user_func_array([实例, 方法], 参数)，为了获得Config实例，Facade又定义了一个获取对象的方法：

/**
     * 创建Facade实例
     * @static
     * @access protected
     * @param  string    $class          类名或标识
     * @param  array     $args           变量
     * @param  bool      $newInstance    是否每次创建新的实例
     * @return object
     */
    protected static function createFacade($class = '', $args = [], $newInstance = false)
    {
        $class       = $class ?: static::class;
        $facadeClass = static::getFacadeClass();
    
        if ($facadeClass) {
            $class = $facadeClass;
        } elseif (isset(self::$bind[$class])) {
            $class = self::$bind[$class];
        }
    
        if (static::$alwaysNewInstance) {
            $newInstance = true;
        }
    
        return Container::getInstance()->make($class, $args, $newInstance);
    }

// 其内部是通过容器来实例化对象
    // 因为在base.php中已经将 think\Config 类绑定到 config 这个标识

Container::getInstance()->bind([
    　　'config'  => Config::class
    ])
    
    // 在 createFacade 方法中，获取类的名称：$class = $class ?: static::class; 即得到 config 这个标识

// 在容器的make方法中，根据config标识，找到绑定的 think\Config 类，并调用其动态方法 get。
    
    facade\Config::get('app_debug'); 
    
    // 最后调用的是：
    
    (new think\Config())->get('app_debug');

>  简而言之，门面的实现是通过PHP的魔术方法 \_\_callStatic，再配合容器来实现动态类的静态化调用。