thinkphp5源码剖析系列3-容器与门面

容器和门面是tp框架的精髓所在

涉及容器与门面之前我们先链接几个简单的设计模式

• 单例模式

<?php
namespace sjms;
// 单例模式
class Single{
    private static $me = null;
    // 防止对象被new
    private function __construct(){
        
    }
    public static function  getInstance(){
        self::$me || self::$me = new self;
        return self::$me;
    }
}

• 注册树模式

<?php
namespace sjms;
// 注册树模式
class Register{
    // 注册树池子
    private static $objects = [];
    // 注册对象
    public static function set($key, $object){
        self::$objects[$key] = $object;
    }
    // 从注册树获取对象，如果没有注册对象
    public static function get($key){
        if(!isset(self::$objects[$key])){
            self::$objects[$key] = new $key;
        }
        return self::$objects[$key];
    }
    // 注销注册树对象
    public static function _unset($key){
        if(isset(self::$objects[$key]))
            unset(self::$objects[$key]);
    }
}

• 依赖注入

<?php
namespace sjmsdi;
class Person{
    /*
     * 依赖注入
     * 依赖：Person类Car类
     * 注入：将Car类Person类
     */
    public function buy($obj){
        // $bmw = new Car();
        $price = $obj->pay();
        return $price;
    }
}

• 反射机制

    public function index()
    {
        // 实例化对象
        $obj1 = new Car();
        // 对象的反射类
        $obj2 = new ReflectionClass($obj1);
        // 相当于实例化这个类
        $instance = $obj2->newInstance();
        // 获取这个类的所有方法[返回对象数组集
        $methods = $obj2->getMethods();
        // 执行某个方法
        echo $instance->pay();
        // 获取单个方法[返回对象
        $method = $obj2->getMethod('pay');
        // 判断某个方法是否是公用的[返回对象
        $method = new ReflectionMethod($instance, 'pay');
        $isPublic = $method->isPublic();
        var_export("is public : {$isPublic}");
        // 获取方法的所有形参[返回对象数组集
        var_dump($method->getParameters());
    }

• 构造自己的容器类

<?php
namespace sjmsdi;
class Car{
    /*
     * 依赖注入
     */
    public function pay($name){
        echo $name . ' buy car';
    }
}

<?php
namespace sjmsdi;
class Person{
    public function __construct(Car $c,$name)
    {
        $this->name = $name;
        $this->obj = $c;
    }
    /*
     * 依赖注入
     * 依赖：Person类Car类
     * 注入：将Car类Person类
     */
    public function buy(){
        $this->obj->pay($this->name);
    }
}

<?php
namespace sjms;
// 自己的容器类
class Continer{
    private $instances = [];
    private static $instance = NULL;
    public static function getInstance(){
        if(is_null(static::$instance)){
            static::$instance = new static;
        }
        return static::$instance;
    }

    public function set($key, $value){
        $this->instances[$key] = $value;
    } 

    // 获取容器里面的实例，会用到反射机制
    public function get($key,$data = []){
        if(!empty($this->instances[$key])){
            $key = $this->instances[$key];
        }
        // 反射类
        $reflect = new ReflectionClass($key);
        // 获取类的构造函数
        $c = $reflect->getConstructor();
        if(!$c){
            return new $key;
        }
        // 获取类的构造函数所有的参数
        $params = $c->getParameters();
        if(empty($params)){
            return new $key;
        }
        // 如果构造函数有参
        foreach($params as $param){
            $class = $param->getClass();
            if(!$class){
                // 如果不是类参数
                $paramName = $param->name;
                // 自动传参
                if(isset($data[$paramName])){
                    $args[] = $data[$paramName];
                }
                // todo
            }else{
                // 递归[依赖注入的思维]
                $args[] = $this->get($class->name);
            }
        }
        return $reflect->newInstanceArgs($args);
    }
}

 public function index()
    {
        $c = Continer::getInstance();
        $c->get('sjmsdiPerson',['name' => 'tom'])->buy();

    }

• tp5中的容器类,Container.php

    /**
     * 获取容器中的对象实例
     * @access public
     * @param  string        $abstract       类名或者标识
     * @param  array|true    $vars           变量
     * @param  bool          $newInstance    是否每次创建新的实例
     * @return object
     */
    public static function get($abstract, $vars = [], $newInstance = false)
    {
        return static::getInstance()->make($abstract, $vars, $newInstance);
    }

    /**
     * 创建类的实例
     * @access public
     * @param  string        $abstract       类名或者标识
     * @param  array|true    $vars           变量
     * @param  bool          $newInstance    是否每次创建新的实例
     * @return object
     */
    public function make($abstract, $vars = [], $newInstance = false)
    {
        if (true === $vars) {
            // 总是创建新的实例化对象
            $newInstance = true;
            $vars        = [];
        }

        $abstract = isset($this->name[$abstract]) ? $this->name[$abstract] : $abstract;
    
        // 如果注册树上面有，则从注册树上面取
        if (isset($this->instances[$abstract]) && !$newInstance) {
            return $this->instances[$abstract];
        }

        // 如果有绑定标识
        if (isset($this->bind[$abstract])) {
            $concrete = $this->bind[$abstract];

            if ($concrete instanceof Closure) {
                $object = $this->invokeFunction($concrete, $vars);
            } else {
                // 绑定别名
                $this->name[$abstract] = $concrete;
                return $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 = [])
    {
        try {
            $reflect = new ReflectionClass($class);

            // 是否有构造类的__make方法，如果有则直接make
            if ($reflect->hasMethod('__make')) {
                $method = new ReflectionMethod($class, '__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) : [];

            return $reflect->newInstanceArgs($args);

        } catch (ReflectionException $e) {
            throw new ClassNotFoundException('class not exists: ' . $class, $class);
        }
    }

• 门面模式

门面为容器中的类提供了一个静态调用接口
相对于传统的静态方法调用，带来了更好的可测试性和扩展性
门面模式其实就是通过静态的方式调用类的方法
门面模式的实现：
1：门面类继承门面基类，，覆盖父类的getFacadeClass()方法，此方法是映射装饰类的类名（由于容器的绑定标识机制，app对应的是 hinApp::class

<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2018 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <liu21st@gmail.com>
// +----------------------------------------------------------------------

namespace thinkfacade;

use thinkFacade;

/**
 * @see 	hinkApp
 * @mixin 	hinkApp
 * @method 	hinkApp bind(string $bind) static 绑定模块或者控制器
 * @method void initialize() static 初始化应用
 * @method void init(string $module='') static 初始化模块
 * @method 	hinkResponse run() static 执行应用
 * @method 	hinkApp dispatch(	hink
outeDispatch $dispatch) static 设置当前请求的调度信息
 * @method void log(mixed $log, string $type = 'info') static 记录调试信息
 * @method mixed config(string $name='') static 获取配置参数
 * @method 	hink
outeDispatch routeCheck() static URL路由检测（根据PATH_INFO)
 * @method 	hinkApp routeMust(bool $must = false) static 设置应用的路由检测机制
 * @method 	hinkModel model(string $name = '', string $layer = 'model', bool $appendSuffix = false, string $common = 'common') static 实例化模型
 * @method object controller(string $name, string $layer = 'controller', bool $appendSuffix = false, string $empty = '') static 实例化控制器
 * @method 	hinkValidate validate(string $name = '', string $layer = 'validate', bool $appendSuffix = false, string $common = 'common') static 实例化验证器类
 * @method 	hinkdbQuery db(mixed $config = [], mixed $name = false) static 数据库初始化
 * @method mixed action(string $url, $vars = [], $layer = 'controller', $appendSuffix = false) static 调用模块的操作方法
 * @method string parseClass(string $module, string $layer, string $name, bool $appendSuffix = false) static 解析应用类的类名
 * @method string version() static 获取框架版本
 * @method bool isDebug() static 是否为调试模式
 * @method string getModulePath() static 获取当前模块路径
 * @method void setModulePath(string $path) static 设置当前模块路径
 * @method string getRootPath() static 获取应用根目录
 * @method string getAppPath() static 获取应用类库目录
 * @method string getRuntimePath() static 获取应用运行时目录
 * @method string getThinkPath() static 获取核心框架目录
 * @method string getRoutePath() static 获取路由目录
 * @method string getConfigPath() static 获取应用配置目录
 * @method string getConfigExt() static 获取配置后缀
 * @method string setNamespace(string $namespace) static 设置应用类库命名空间
 * @method string getNamespace() static 获取应用类库命名空间
 * @method string getSuffix() static 是否启用类库后缀
 * @method float getBeginTime() static 获取应用开启时间
 * @method integer getBeginMem() static 获取应用初始内存占用
 * @method 	hinkContainer container() static 获取容器实例
 */
class App extends Facade
{
    /**
     * 获取当前Facade对应类名（或者已经绑定的容器对象标识）
     * @access protected
     * @return string
     */
    protected static function getFacadeClass()
    {
        return 'app';
    }
}

2:门面基类，门面基类实现 __callStatic魔术方法，将静态调用转发到 装饰类的对象调用

<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2018 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <liu21st@gmail.com>
// +----------------------------------------------------------------------

namespace think;

class Facade
{
    /**
     * 绑定对象
     * @var array
     */
    protected static $bind = [];

    /**
     * 始终创建新的对象实例
     * @var bool
     */
    protected static $alwaysNewInstance;

    /**
     * 绑定类的静态代理
     * @static
     * @access public
     * @param  string|array  $name    类标识
     * @param  string        $class   类名
     * @return object
     */
    public static function bind($name, $class = null)
    {
        if (__CLASS__ != static::class) {
            return self::__callStatic('bind', func_get_args());
        }

        if (is_array($name)) {
            self::$bind = array_merge(self::$bind, $name);
        } else {
            self::$bind[$name] = $class;
        }
    }

    /**
     * 创建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);
    }

    /**
     * 获取当前Facade对应类名（或者已经绑定的容器对象标识）
     * @access protected
     * @return string
     */
    protected static function getFacadeClass()
    {}

    /**
     * 带参数实例化当前Facade类
     * @access public
     * @return mixed
     */
    public static function instance(...$args)
    {
        if (__CLASS__ != static::class) {
            return self::createFacade('', $args);
        }
    }

    /**
     * 调用类的实例
     * @access public
     * @param  string        $class          类名或者标识
     * @param  array|true    $args           变量
     * @param  bool          $newInstance    是否每次创建新的实例
     * @return mixed
     */
    public static function make($class, $args = [], $newInstance = false)
    {
        if (__CLASS__ != static::class) {
            return self::__callStatic('make', func_get_args());
        }

        if (true === $args) {
            // 总是创建新的实例化对象
            $newInstance = true;
            $args        = [];
        }

        return self::createFacade($class, $args, $newInstance);
    }

    // 调用实际类的方法
    public static function __callStatic($method, $params)
    {
        var_dump($method);
        return call_user_func_array([static::createFacade(), $method], $params);
    }
}

• 门面模式调用

    public function index()
    {
        // 门面模式的静态调用 相当于 就是容器类调用对象方法
        $boo = Config::get('app.') == Container::get('config')->get('app.');
        var_dump($boo);
    }