tp5.1中的容器和facade的實現

　　首先定義：

　　　　容器（Container）實現類的統一管理，確保對象實例的唯一性。

　　　　門面（Facade）為容器（Container）中的類提供了一個靜態調用接口，相比於傳統的靜態方法調用， 帶來了更好的可測試性和擴展性，你可以為任何的非靜態類庫定義一個facade類。

　先看源代碼

　　　　

　　容器的實現：這里，框架已經幫我們綁定了系統常用類到容器中，在之后使用時，只需要調用助手函數 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，再配合容器來實現動態類的靜態化調用。

總結：

　　對於上面的例子來說，
　　一共有A,B,C三個類，假設還會有更多的類，和A類中的方法關聯，為了方便，管理。
　　我們把管理這些依賴注入的類叫做容器。

　　

　　facade就是給類穿上靜態馬甲，而且還可以起個新的名字，這樣原有的類名變的更加安全
　　如初說的直白一點，Facade功能可以讓類無需實例化而直接進行靜態方式調用。就是使用后，
　　類可以直接用靜態方式調用