看 Laravel 原始碼瞭解 Container

coding01發表於2018-05-20

Laravel原始碼AI

自從上文《看 Laravel 原始碼瞭解 ServiceProvider 的載入》，我們知道 Application (or Container) 充當 Laravel 的容器，基本把所有 Laravel 核心的功能納入這個容器裡了。

我們今天來看看這個 Application / Container 到底是什麼東西？

瞭解 Container 之前，我們需要先簡單說說 Inversion of Control (控制反轉) 的原理。

Inversion of Control

要知道什麼是 Inversion of Control 之前，我們最好先了解一個原則：

依賴倒轉原則 (Dependence Inversion Priciple, DIP)提倡：

高層模組不應該依賴底層模組。兩個都應該依賴抽象

抽象不應該依賴細節，細節應該依賴抽象

針對介面程式設計，不要針對實現程式設計

在程式設計時，我們對程式碼進行模組化開發，它們之間避免不了有依賴，如模組 A 依賴模組 B，那麼根據 DIP，模組 A 應該依賴模組 B 的介面，而不應該依賴模組 B 的實現。

下面我們舉個例子。

我們需要一個 Logger 功能，將系統 log 輸出到檔案中。我們可以可以這麼寫：

class LogToFile {
    public function execute($message) {
        info('log the message to a file :'.$message);
    }
}
複製程式碼

在需要的地方直接呼叫：

class UseLogger {
    protected $logger;

    public function __construct(LogToFile $logger) {
        $this->logger = $logger;
    }

    public function show() {
        $user = 'yemeishu';
        $this->logger->execute($user);
    }
}
複製程式碼

寫個測試用例：

$useLogger = new UseLogger(new LogToFile());

$useLogger->show();
複製程式碼

如果這時候我們需要將 log 輸出到釘釘上，我們重新寫一個 LogToDD 類：

class LogToDD {
    public function execute($message) {
        info('log the message to 釘釘 :'.$message);
    }
}
複製程式碼

這時候，我們還需要修改使用端 (UseLogger) 程式碼，讓它引入 LogToDD 類：

class UseLogger {
    protected $logger;

    public function __construct(LogToDD $logger) {
        $this->logger = $logger;
    }

    public function show() {
        $user = 'yemeishu';
        $this->logger->execute($user);
    }
}
複製程式碼

其實到這，你就能「嗅出」壞程式碼來了：

假如我使用端特別多，那就意味著每個地方我都要做引入修改。

根據 DIP 原則，我們應該面向介面開發。讓使用端依賴介面，而不是實現。所以我們建立一個介面：

interface Logger {
    public function execute($message);
}
複製程式碼

然後讓 LogToFile 和 LogToDD 作為 Logger 的實現：

class LogToFile implements Logger {
    public function execute($message) {
        info('log the message to a file :'.$message);
    }
}

class LogToDD implements Logger {
    public function execute($message) {
        info('log the message to 釘釘 :'.$message);
    }
}
複製程式碼

這樣我們在使用端時，直接引入 Logger 介面，讓程式碼剝離具體實現。

class UseLogger {
    protected $logger;

    public function __construct(Logger $logger) {
        $this->logger = $logger;
    }

    public function show() {
        $user = 'yemeishu';
        $this->logger->execute($user);
    }
}
複製程式碼

這樣就可以保證，無論是使用檔案儲存，還是下發到釘釘上，都可以不用去改程式碼了，只需要再真正呼叫的時候，隨著業務需要自行選擇。如測試：

$useLogger1 = new UseLogger(new LogToFile());
$useLogger1->show();

$useLogger2 = new UseLogger(new LogToDD());
$useLogger2->show();
複製程式碼

結果：

但這裡有個問題，最後在例項化使用時，還是要「硬編碼」的方式 new 我們的實現類 (LogToDD or LogToFile)。

那有沒有辦法更進一步把最後的 new LogToDD() 也控制反轉了呢？

繫結的實現

這裡我們把實現類繫結在 interface 或者標識 key 上，只要解析這個 interface 或者 key，就可以拿到我們的實現類。

我們來寫一個簡單的類來達到繫結和解析的功能：

class SimpleContainer {

    // 用於儲存所有繫結 key-value
    protected static $container = [];

    public static function bind($name, Callable $resolver) {
        static::$container[$name] = $resolver;
    }

    public static function make($name) {
        if(isset(static::$container[$name])){
            $resolver = static::$container[$name] ;
            return $resolver();
        }
        throw new Exception("Binding does not exist in container");
    }
}
複製程式碼

我們可以測試下：

SimpleContainer::bind(Logger::class, function () {
    return new LogToFile();
});

$useLogger3 = new UseLogger(SimpleContainer::make(Logger::class));

$useLogger3->show();
複製程式碼

只要有一處繫結了 Logger 和 LogToFile 的關係，就可以在任何需要呼叫的地方直接解析引用了。

也就意味著，通過這種方法，在所有編碼的地方都是引入「interface」，而不是實現類。徹底實現 DPI 原則。

當我們把所有這種繫結聚集在一起，就構成了我們今天的主題內容：「Container」—— illuminate / container。

Laravel Container

在研究 Laravel Container 之前，我們根據上面的例子，使用 Container，看怎麼方便實現。

$container = new Container();
$container->bind(Logger::class, LogToFile::class);

$useLogger4 = new UseLogger($container->make(Logger::class));
$useLogger4->show();
複製程式碼

達到一樣的效果

[2018-05-19 15:36:30] testing.INFO: log the message to a file :yemeishu
複製程式碼

注：在 Laravel 開發時，我們會把這個繫結寫在 APPServiceProvider 的 boot 或者 register 中，或者其他的 ServiceProvider 上也行。

結合上一篇文章《看 Laravel 原始碼瞭解 ServiceProvider 的載入》和以上的原理的講解。我們對 Container 的使用，已經不陌生了。

接下來就可以看看 Container 的原始碼了。

Container 原始碼解析

從上文可以知道，Container 的作用主要有兩個，一個是繫結，另個一個是解析。

繫結

我們看看主要有哪些繫結型別：

繫結一個單例

繫結例項

繫結介面到實現

繫結初始資料

情境繫結

tag 標記繫結

下面我們根據這些型別進行分析：

1. 繫結一個單例

public function singleton($abstract, $concrete = null)
    {
        $this->bind($abstract, $concrete, true);
    }
複製程式碼

主要利用引數 $share = true 來標記此時繫結為一個單例。

2. 繫結例項

public function instance($abstract, $instance)
{
    $this->removeAbstractAlias($abstract);

    $isBound = $this->bound($abstract);

    unset($this->aliases[$abstract]);

    // We'll check to determine if this type has been bound before, and if it has
    // we will fire the rebound callbacks registered with the container and it
    // can be updated with consuming classes that have gotten resolved here.
    $this->instances[$abstract] = $instance;

    if ($isBound) {
        $this->rebound($abstract);
    }

    return $instance;
}
複製程式碼

繫結例項，主要是將 [$abstract, $instance]儲存進陣列 $instances 中。

3. tag 標記繫結

/**
 * Assign a set of tags to a given binding.
 *
 * @param  array|string  $abstracts
 * @param  array|mixed   ...$tags
 * @return void
 */
public function tag($abstracts, $tags)
{
    $tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);

    foreach ($tags as $tag) {
        if (! isset($this->tags[$tag])) {
            $this->tags[$tag] = [];
        }

        foreach ((array) $abstracts as $abstract) {
            $this->tags[$tag][] = $abstract;
        }
    }
}
複製程式碼

這個挺好理解，主要是將 $abstracts 陣列放在同一組標籤下，最後可以通過 tag，解析這一組 $abstracts。

4. 繫結

public function bind($abstract, $concrete = null, $shared = false)
{
    // If no concrete type was given, we will simply set the concrete type to the
    // abstract type. After that, the concrete type to be registered as shared
    // without being forced to state their classes in both of the parameters.
    $this->dropStaleInstances($abstract);

    // 如果傳入的實現為空，則繫結 $concrete 自己
    if (is_null($concrete)) {
        $concrete = $abstract;
    }

    // If the factory is not a Closure, it means it is just a class name which is
    // bound into this container to the abstract type and we will just wrap it
    // up inside its own Closure to give us more convenience when extending.
    // 目的是將 $concrete 轉成閉包函式
    if (! $concrete instanceof Closure) {
        $concrete = $this->getClosure($abstract, $concrete);
    }

    // 儲存到 $bindings 陣列中，如果 $shared = true, 則表示繫結單例
    $this->bindings[$abstract] = compact('concrete', 'shared');

    // If the abstract type was already resolved in this container we'll fire the
    // rebound listener so that any objects which have already gotten resolved
    // can have their copy of the object updated via the listener callbacks.
    if ($this->resolved($abstract)) {
        $this->rebound($abstract);
    }
}
複製程式碼

解析

/**
 * Resolve the given type from the container.
 *
 * @param  string  $abstract
 * @param  array  $parameters
 * @return mixed
 */
public function make($abstract, array $parameters = [])
{
    return $this->resolve($abstract, $parameters);
}

/**
 * Resolve the given type from the container.
 *
 * @param  string  $abstract
 * @param  array  $parameters
 * @return mixed
 */
protected function resolve($abstract, $parameters = [])
{
    $abstract = $this->getAlias($abstract);

    $needsContextualBuild = ! empty($parameters) || ! is_null(
        $this->getContextualConcrete($abstract)
    );

    // If an instance of the type is currently being managed as a singleton we'll
    // just return an existing instance instead of instantiating new instances
    // so the developer can keep using the same objects instance every time.
    if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
        return $this->instances[$abstract];
    }

    $this->with[] = $parameters;

    $concrete = $this->getConcrete($abstract);

    // We're ready to instantiate an instance of the concrete type registered for
    // the binding. This will instantiate the types, as well as resolve any of
    // its "nested" dependencies recursively until all have gotten resolved.
    if ($this->isBuildable($concrete, $abstract)) {
        $object = $this->build($concrete);
    } else {
        $object = $this->make($concrete);
    }

    // If we defined any extenders for this type, we'll need to spin through them
    // and apply them to the object being built. This allows for the extension
    // of services, such as changing configuration or decorating the object.
    foreach ($this->getExtenders($abstract) as $extender) {
        $object = $extender($object, $this);
    }

    // If the requested type is registered as a singleton we'll want to cache off
    // the instances in "memory" so we can return it later without creating an
    // entirely new instance of an object on each subsequent request for it.
    if ($this->isShared($abstract) && ! $needsContextualBuild) {
        $this->instances[$abstract] = $object;
    }

    $this->fireResolvingCallbacks($abstract, $object);

    // Before returning, we will also set the resolved flag to "true" and pop off
    // the parameter overrides for this build. After those two things are done
    // we will be ready to return back the fully constructed class instance.
    $this->resolved[$abstract] = true;

    array_pop($this->with);

    return $object;
}
複製程式碼

我們一步步來分析該「解析」函式：

$needsContextualBuild = ! empty($parameters) || ! is_null(
    $this->getContextualConcrete($abstract)
);
複製程式碼

該方法主要是區分，解析的物件是否有引數，如果有引數，還需要對引數做進一步的分析，因為傳入的引數，也可能是依賴注入的，所以還需要對傳入的引數進行解析；這個後面再分析。

// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
    return $this->instances[$abstract];
}
複製程式碼

如果是繫結的單例，並且不需要上面的引數依賴。我們就可以直接返回 $this->instances[$abstract]。

$concrete = $this->getConcrete($abstract);

...

/**
 * Get the concrete type for a given abstract.
 *
 * @param  string  $abstract
 * @return mixed   $concrete
 */
protected function getConcrete($abstract)
{
    if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
        return $concrete;
    }

    // If we don't have a registered resolver or concrete for the type, we'll just
    // assume each type is a concrete name and will attempt to resolve it as is
    // since the container should be able to resolve concretes automatically.
    if (isset($this->bindings[$abstract])) {
        return $this->bindings[$abstract]['concrete'];
    }

    return $abstract;
}
複製程式碼

這一步主要是先從繫結的上下文找，是不是可以找到繫結類；如果沒有，則再從 $bindings[] 中找關聯的實現類；最後還沒有找到的話，就直接返回 $abstract 本身。

// We're ready to instantiate an instance of the concrete type registered for
// the binding. This will instantiate the types, as well as resolve any of
// its "nested" dependencies recursively until all have gotten resolved.
if ($this->isBuildable($concrete, $abstract)) {
    $object = $this->build($concrete);
} else {
    $object = $this->make($concrete);
}

...

/**
 * Determine if the given concrete is buildable.
 *
 * @param  mixed   $concrete
 * @param  string  $abstract
 * @return bool
 */
protected function isBuildable($concrete, $abstract)
{
    return $concrete === $abstract || $concrete instanceof Closure;
}
複製程式碼

這個比較好理解，如果之前找到的 $concrete 返回的是 $abstract 值，或者 $concrete 是個閉包，則執行 $this->build($concrete)，否則，表示存在巢狀依賴的情況，則採用遞迴的方法執行 $this->make($concrete)，直到所有的都解析完為止。

$this->build($concrete)

/**
 * Instantiate a concrete instance of the given type.
 *
 * @param  string  $concrete
 * @return mixed
 *
 * @throws \Illuminate\Contracts\Container\BindingResolutionException
 */
public function build($concrete)
{
    // If the concrete type is actually a Closure, we will just execute it and
    // hand back the results of the functions, which allows functions to be
    // used as resolvers for more fine-tuned resolution of these objects.
    // 如果傳入的是閉包，則直接執行閉包函式，返回結果
    if ($concrete instanceof Closure) {
        return $concrete($this, $this->getLastParameterOverride());
    }

    // 利用反射機制，解析該類。
    $reflector = new ReflectionClass($concrete);

    // If the type is not instantiable, the developer is attempting to resolve
    // an abstract type such as an Interface of Abstract Class and there is
    // no binding registered for the abstractions so we need to bail out.
    if (! $reflector->isInstantiable()) {
        return $this->notInstantiable($concrete);
    }

    $this->buildStack[] = $concrete;

    // 獲取建構函式
    $constructor = $reflector->getConstructor();

    // If there are no constructors, that means there are no dependencies then
    // we can just resolve the instances of the objects right away, without
    // resolving any other types or dependencies out of these containers.
    // 如果沒有建構函式，則表明沒有傳入引數，也就意味著不需要做對應的上下文依賴解析。
    if (is_null($constructor)) {
        // 將 build 過程的內容 pop，然後直接構造物件輸出。
        array_pop($this->buildStack);

        return new $concrete;
    }

    // 獲取建構函式的引數
    $dependencies = $constructor->getParameters();

    // Once we have all the constructor's parameters we can create each of the
    // dependency instances and then use the reflection instances to make a
    // new instance of this class, injecting the created dependencies in.
    // 解析出所有上下文依賴物件，帶入函式，構造物件輸出
    $instances = $this->resolveDependencies(
        $dependencies
    );

    array_pop($this->buildStack);

    return $reflector->newInstanceArgs($instances);
}
複製程式碼

此方法分成兩個分支：如果 $concrete instanceof Closure，則直接呼叫閉包函式，返回結果：$concrete()；另一種分支就是，傳入的就是一個 $concrete === $abstract === 類名，通過反射方法，解析並 new 該類。

具體解釋看上面的註釋。 ReflectionClass 類的使用，具體參考：php.golaravel.com/class.refle…

程式碼往下看：

// If we defined any extenders for this type, we'll need to spin through them
// and apply them to the object being built. This allows for the extension
// of services, such as changing configuration or decorating the object.
foreach ($this->getExtenders($abstract) as $extender) {
    $object = $extender($object, $this);
}

// If the requested type is registered as a singleton we'll want to cache off
// the instances in "memory" so we can return it later without creating an
// entirely new instance of an object on each subsequent request for it.
if ($this->isShared($abstract) && ! $needsContextualBuild) {
    $this->instances[$abstract] = $object;
}

$this->fireResolvingCallbacks($abstract, $object);

// Before returning, we will also set the resolved flag to "true" and pop off
// the parameter overrides for this build. After those two things are done
// we will be ready to return back the fully constructed class instance.
$this->resolved[$abstract] = true;

array_pop($this->with);

return $object;
複製程式碼

這些就比較好理解了。主要判斷是否存在擴充套件，則相應擴充套件功能；如果是繫結單例，則將解析的結果存到 $this->instances 陣列中；最後做一些解析的「善後工作」。

最後我們再看看 tag 標籤的解析：

/**
 * Resolve all of the bindings for a given tag.
 *
 * @param  string  $tag
 * @return array
 */
public function tagged($tag)
{
    $results = [];

    if (isset($this->tags[$tag])) {
        foreach ($this->tags[$tag] as $abstract) {
            $results[] = $this->make($abstract);
        }
    }

    return $results;
}
複製程式碼

現在看這個就更好理解了，如果傳入的 tag 標籤值存在 tags 陣列中，則遍歷所有 $abstract, 一一解析，將結果儲存陣列輸出。

總結

雖然 Container 核心的內容我們瞭解了，但還有很多細節值得我們接著研究，如：$alias 相關的，事件相關的，擴充套件相關的。

最後收尾，推薦大家看看這個 Container：silexphp/Pimple

A small PHP 5.3 dependency injection container pimple.symfony.com

未完待續

看 Laravel 原始碼瞭解 ServiceProvider 的載入
2018-06-12
Laravel原始碼IDE
Laravel 原始碼筆記容器類 Container
2020-03-04
Laravel原始碼筆記AI
Laravel 原始碼解讀
2019-03-29
Laravel原始碼
Laravel Container (容器) 概念詳解 (上)
2017-09-19
LaravelAI
Laravel 原始碼的解讀
2020-01-02
Laravel原始碼
深入瞭解SpringMVC原始碼解析
2021-11-27
SpringMVC原始碼
Laravel核心解讀–Session原始碼解析
2018-08-11
LaravelSession原始碼
Laravel核心解讀–Cookie原始碼分析
2018-09-01
LaravelCookie原始碼
Laravel php artisan optimize 原始碼解讀
2017-06-25
LaravelPHP原始碼
Laravel 原始碼解讀：PHP artisan down
2017-06-28
Laravel原始碼PHP
商城系統原始碼你瞭解多少？
2020-04-16
原始碼
Laravel5.8 版本核心原始碼註解
2019-07-23
Laravel原始碼
elastic-job 原始碼解讀之從原始碼看null值
2021-09-09
AST原始碼Null
帶你瞭解比特幣Bitcoin原始碼
2020-11-26
比特幣原始碼
Laravel 核心物件之 Container
2017-09-22
Laravel物件AI
Laravel 模組開發包 (nWidart/Laravel-modules) 原始碼解讀
2019-08-16
LaravelDart原始碼
Laravel 執行原理分析與原始碼分析,底層看這篇足矣
2021-02-23
Laravel原始碼
HashMap原始碼分析(二):看完徹底瞭解HashMap
2019-07-18
HashMap原始碼
從淺入深瞭解Koa2原始碼
2022-04-11
原始碼
Laravel 路由原始碼分析
2019-02-27
Laravel路由原始碼
1.6 - Laravel - 5.6 - Container Bind 機制
2020-03-07
LaravelAI
Laravel Container (容器) 深入理解 (下)
2017-09-20
LaravelAI
Laravel 原始碼閱讀指南 -- Cookie 原始碼解析
2018-09-02
Laravel原始碼Cookie
筆記-runtime原始碼解析之讓你徹底瞭解底層原始碼
2019-03-28
筆記原始碼
對於網校系統原始碼，你瞭解多少？
2021-02-19
原始碼
Element原始碼分析系列2-Container(佈局容器)
2019-03-04
原始碼AI
Laravel 佇列原始碼解析
2019-11-16
Laravel佇列原始碼
Laravel 原始碼閱讀 - Queue
2019-08-06
Laravel原始碼
Laravel 原始碼閱讀 - Eloquent
2019-08-02
Laravel原始碼
Laravel 路由管道原始碼分析
2018-12-25
Laravel路由原始碼
高價回收，Laravel原始碼
2022-12-22
Laravel原始碼
1.7 - Laravel - 5.6 - Container make 解析機制
2020-03-12
LaravelAI
中文註釋版 Laravel 容器類（Container）
2020-10-29
LaravelAI
Laravel5.5LTS 版本原始碼閱讀註解
2019-06-01
Laravel原始碼
從JDK原始碼看OutputStream
2019-02-25
JDK原始碼
如何看Spring原始碼
2019-05-08
Spring原始碼
從Class原始碼看反射
2020-09-21
原始碼反射
從Chrome原始碼看WebSocket
2018-05-27
Chrome原始碼Web

看 Laravel 原始碼瞭解 Container

Inversion of Control

繫結的實現

Laravel Container

Container 原始碼解析

繫結

解析

總結

相關文章