Laravel核心——服務容器的細節特性

leoyang90發表於2019-02-16

Laravel

前言

首先歡迎關注我的部落格： www.leoyang90.cn

在前面幾個部落格中，我詳細講了 Ioc 容器各個功能的使用、繫結的原始碼、解析的原始碼，今天這篇部落格會詳細介紹 Ioc 容器的一些細節，一些特性，以便更好地掌握容器的功能。

注：本文使用的測試類與測試物件都取自 laravel 的單元測試檔案src/illuminate/tests/Container/ContainerTest.php

rebind繫結特性

rebind 在繫結之前

instance 和普通 bind 繫結一樣，當重新繫結的時候都會呼叫 rebind 回撥函式，但是有趣的是，對於普通 bind 繫結來說，rebind 回撥函式被呼叫的條件是當前介面被解析過：

public function testReboundListeners()
{
    unset($_SERVER[`__test.rebind`]);

    $container = new Container;
    $container->rebinding(`foo`, function () {
        $_SERVER[`__test.rebind`] = true;
    });
    $container->bind(`foo`, function () {
    });
    $container->make(`foo`);
    $container->bind(`foo`, function () {
    });

    $this->assertTrue($_SERVER[`__test.rebind`]);
}

所以遇到下面這樣的情況,rebinding 的回撥函式是不會呼叫的：

public function testReboundListeners()
{
    unset($_SERVER[`__test.rebind`]);

    $container = new Container;
    $container->rebinding(`foo`, function () {
        $_SERVER[`__test.rebind`] = true;
    });
    $container->bind(`foo`, function () {
    });
    $container->bind(`foo`, function () {
    });

    $this->assertFalse(isset($_SERVER[`__test.rebind`]));
}

有趣的是對於 instance 繫結：

public function testReboundListeners()
{
    unset($_SERVER[`__test.rebind`]);

    $container = new Container;
    $container->rebinding(`foo`, function () {
        $_SERVER[`__test.rebind`] = true;
    });
    $container->bind(`foo`, function () {
    });
    $container->instance(`foo`, function () {
    });

    $this->assertTrue(isset($_SERVER[`__test.rebind`]));
}

rebinding 回撥函式卻是可以被呼叫的。其實原因就是 instance 原始碼中 rebinding 回撥函式呼叫的條件是 rebound 為真，而普通 bind 函式呼叫 rebinding 回撥函式的條件是 resolved 為真. 目前筆者不是很清楚為什麼要對 instance 和 bind 區別對待，希望有大牛指導。

rebind 在繫結之後

為了使得 rebind 回撥函式在下一次的繫結中被啟用，在 rebind 函式的原始碼中，如果判斷當前物件已經繫結過，那麼將會立即解析：

public function rebinding($abstract, Closure $callback)
{
    $this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback;
    
    if ($this->bound($abstract)) {
        return $this->make($abstract);
    }
}

單元測試程式碼：

public function testReboundListeners1()
{
    unset($_SERVER[`__test.rebind`]);

    $container = new Container;
    $container->bind(`foo`, function () {
        return `foo`;
    });

    $container->resolving(`foo`, function () {
        $_SERVER[`__test.rebind`] = true;
    });

    $container->rebinding(`foo`, function ($container,$object) {//會立即解析
        $container[`foobar`] = $object.`bar`;
    });

    $this->assertTrue($_SERVER[`__test.rebind`]);

    $container->bind(`foo`, function () {
    });

    $this->assertEquals(`bar`, $container[`foobar`]);
}

resolving 特性

resolving 回撥的型別

resolving 不僅可以針對介面執行回撥函式，還可以針對介面實現的型別進行回撥函式。

public function testResolvingCallbacksAreCalledForType()
{
    $container = new Container;
    $container->resolving(`StdClass`, function ($object) {
        return $object->name = `taylor`;
    });
    $container->bind(`foo`, function () {
          return new StdClass;
    });
    $instance = $container->make(`foo`);

    $this->assertEquals(`taylor`, $instance->name);
}
public function testResolvingCallbacksShouldBeFiredWhenCalledWithAliases()
{
    $container = new Container;
    $container->alias(`StdClass`, `std`);
    $container->resolving(`std`, function ($object) {
        return $object->name = `taylor`;
    });
    $container->bind(`foo`, function () {
        return new StdClass;
    });
    $instance = $container->make(`foo`);

    $this->assertEquals(`taylor`, $instance->name);
}

resolving 回撥與 instance

前面講過，對於 singleton 繫結來說，resolving 回撥函式僅僅執行一次，只在 singleton 第一次解析的時候才會呼叫。如果我們利用 instance 直接繫結類的物件，不需要解析，那麼 resolving 回撥函式將不會被呼叫：

public function testResolvingCallbacksAreCalledForSpecificAbstracts()
{
    $container = new Container;
    $container->resolving(`foo`, function ($object) {
        return $object->name = `taylor`;
    });
    $obj = new StdClass;
    $container->instance(`foo`, $obj);
    $instance = $container->make(`foo`);

    $this->assertFalse(isset($instance->name));
}

extend 擴充套件特性

extend 用於擴充套件繫結物件的功能，對於普通繫結來說，這個函式的位置很靈活：

在繫結前擴充套件

public function testExtendIsLazyInitialized()
{
    ContainerLazyExtendStub::$initialized = false;
    
    $container = new Container;      
    $container->extend(`IlluminateTestsContainerContainerLazyExtendStub`, function ($obj, $container) {
        $obj->init();
        return $obj;   
    });    
    $container->bind(`IlluminateTestsContainerContainerLazyExtendStub`); 

    $this->assertFalse(ContainerLazyExtendStub::$initialized);   
    $container->make(`IlluminateTestsContainerContainerLazyExtendStub`);   
    $this->assertTrue(ContainerLazyExtendStub::$initialized);
}

在繫結後解析前擴充套件

public function testExtendIsLazyInitialized()
{
    ContainerLazyExtendStub::$initialized = false;
    
    $container = new Container;   
    $container->bind(`IlluminateTestsContainerContainerLazyExtendStub`);    
    $container->extend(`IlluminateTestsContainerContainerLazyExtendStub`, function ($obj, $container) {
        $obj->init();
        return $obj;   
    });    

    $this->assertFalse(ContainerLazyExtendStub::$initialized);   
    $container->make(`IlluminateTestsContainerContainerLazyExtendStub`);   
    $this->assertTrue(ContainerLazyExtendStub::$initialized);
}

在解析後擴充套件

public function testExtendIsLazyInitialized()
{
    ContainerLazyExtendStub::$initialized = false;
    
    $container = new Container;   
    $container->bind(`IlluminateTestsContainerContainerLazyExtendStub`);         
    
    $container->make(`IlluminateTestsContainerContainerLazyExtendStub`); 
    $this->assertFalse(ContainerLazyExtendStub::$initialized);
    
    $container->extend(`IlluminateTestsContainerContainerLazyExtendStub`, function ($obj, $container) {
        $obj->init();
        return $obj;   
    });
    $this->assertFalse(ContainerLazyExtendStub::$initialized);  
      
    $container->make(`IlluminateTestsContainerContainerLazyExtendStub`); 
    $this->assertTrue(ContainerLazyExtendStub::$initialized);
}

可以看出，無論在哪個位置，extend 擴充套件都有 lazy 初始化的特點，也就是使用 extend 函式並不會立即起作用，而是要等到 make 解析才會啟用。

extend 與 instance 繫結

對於 instance 繫結來說，暫時 extend 的位置需要位於 instance 之後才會起作用，並且會立即起作用，沒有 lazy 的特點：

public function testExtendInstancesArePreserved()
{
    $container = new Container;

    $obj = new StdClass;
    $obj->foo = `foo`;
    $container->instance(`foo`, $obj);
    $container->extend(`foo`, function ($obj, $container) {
        $obj->bar = `baz`;

        return $obj;
    });

    $this->assertEquals(`foo`, $container->make(`foo`)->foo);
    $this->assertEquals(`baz`, $container->make(`foo`)->bar);
}

extend 繫結與 rebind 回撥

無論擴充套件物件是 instance 繫結還是 bind 繫結，extend 都會啟動 rebind 回撥函式：

public function testExtendReBindingInstance()
{
    $_SERVER[`_test_rebind`] = false;

    $container = new Container;
    $container->rebinding(`foo`,function (){
        $_SERVER[`_test_rebind`] = true;
    });

    $obj = new StdClass;
    $container->instance(`foo`,$obj);

    $container->make(`foo`);

    $container->extend(`foo`, function ($obj, $container) {
        return $obj;
    });

    this->assertTrue($_SERVER[`_test_rebind`]);
}

public function testExtendReBinding()
{
    $_SERVER[`_test_rebind`] = false;

    $container = new Container;
    $container->rebinding(`foo`,function (){
        $_SERVER[`_test_rebind`] = true;
    });
    $container->bind(`foo`,function (){
        $obj = new StdClass;

        return $obj;
    });

    $container->make(`foo`);

    $container->extend(`foo`, function ($obj, $container) {
        return $obj;
    });

    this->assertFalse($_SERVER[`_test_rebind`]);
}

contextual 繫結特性

contextual 在繫結前

contextual 繫結不僅可以與 bind 繫結合作，相互不干擾，還可以與 instance 繫結相互合作。而且 instance 的位置也很靈活，可以在 contextual 繫結前，也可以在contextual 繫結後：

public function testContextualBindingWorksForExistingInstancedBindings()
{
    $container = new Container;

    $container->instance(`IlluminateTestsContainerIContainerContractStub`, new ContainerImplementationStub);

    $container->when(`IlluminateTestsContainerContainerTestContextInjectOne`)->needs(`IlluminateTestsContainerIContainerContractStub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $this->assertInstanceOf(
             `IlluminateTestsContainerContainerImplementationStubTwo`,
             $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
     );
}

contextual 在繫結後

public function testContextualBindingWorksForNewlyInstancedBindings()
{
    $container = new Container;

    $container->when(`IlluminateTestsContainerContainerTestContextInjectOne`)->needs(`IlluminateTestsContainerIContainerContractStub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $container->instance(`IlluminateTestsContainerIContainerContractStub`, new ContainerImplementationStub);

    $this->assertInstanceOf(
            `IlluminateTestsContainerContainerImplementationStubTwo`,
        $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
    );
}

contextual 繫結與別名

contextual 繫結也可以在別名上進行，無論賦予別名的位置是 contextual 的前面還是後面：

public function testContextualBindingDoesntOverrideNonContextualResolution()
{
    $container = new Container;

    $container->instance(`stub`, new ContainerImplementationStub);
    $container->alias(`stub`, `IlluminateTestsContainerIContainerContractStub`);

    $container->when(`IlluminateTestsContainerContainerTestContextInjectTwo`)->needs(`IlluminateTestsContainerIContainerContractStub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $this->assertInstanceOf(
            `IlluminateTestsContainerContainerImplementationStubTwo`,
            $container->make(`IlluminateTestsContainerContainerTestContextInjectTwo`)->impl
        );

    $this->assertInstanceOf(
            `IlluminateTestsContainerContainerImplementationStub`,
            $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
    );
}

public function testContextualBindingWorksOnNewAliasedBindings()
{
    $container = new Container;

    $container->when(`IlluminateTestsContainerContainerTestContextInjectOne`)->needs(`IlluminateTestsContainerIContainerContractStub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $container->bind(`stub`, ContainerImplementationStub::class);
    $container->alias(`stub`, `IlluminateTestsContainerIContainerContractStub`);

    $this->assertInstanceOf(
          `IlluminateTestsContainerContainerImplementationStubTwo`,
          $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
    );
}

爭議

目前比較有爭議的是下面的情況：

public function testContextualBindingWorksOnExistingAliasedInstances()
{
    $container = new Container;

    $container->alias(`IlluminateTestsContainerIContainerContractStub`, `stub`);
    $container->instance(`stub`, new ContainerImplementationStub);

    $container->when(`IlluminateTestsContainerContainerTestContextInjectOne`)->needs(`stub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $this->assertInstanceOf(
        `IlluminateTestsContainerContainerImplementationStubTwo`,
        $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
    ); 
}

由於instance的特性，當別名被繫結到其他物件上時，別名 stub 已經失去了與 IlluminateTestsContainerIContainerContractStub 之間的關係，因此不能使用 stub 代替作上下文繫結。
但是另一方面：

public function testContextualBindingWorksOnBoundAlias()
{
    $container = new Container;

    $container->alias(`IlluminateTestsContainerIContainerContractStub`, `stub`);
    $container->bind(`stub`, ContainerImplementationStub::class);

    $container->when(`IlluminateTestsContainerContainerTestContextInjectOne`)->needs(`stub`)->give(`IlluminateTestsContainerContainerImplementationStubTwo`);

    $this->assertInstanceOf(
        `IlluminateTestsContainerContainerImplementationStubTwo`,
        $container->make(`IlluminateTestsContainerContainerTestContextInjectOne`)->impl
    ); 
}

程式碼只是從 instance 繫結改為 bind 繫結，由於 bind 繫結只切斷了別名中的 alias 陣列的聯絡，並沒有斷絕abstractAlias陣列的聯絡，因此這段程式碼卻可以通過，很讓人難以理解。本人在給 Taylor Otwell 提出 PR 時，作者原話為“I`m not making any of these changes to the container on a patch release.”。也許，在以後(5.5或以後)版本作者會更新這裡的邏輯，我們就可以看看服務容器對別名繫結的態度了，大家也最好不要這樣用。

服務容器中的閉包函式引數

服務容器中很多函式都有閉包函式，這些閉包函式可以放入特定的引數，在繫結或者解析過程中，這些引數會被服務容器自動帶入各種類物件或者服務容器例項。

bind 閉包引數

public function testAliasesWithArrayOfParameters()
{
    $container = new Container;    
    $container->bind(`foo`, function ($app, $config) {
        return $config;    
    });    

    $container->alias(`foo`, `baz`);    
    $this->assertEquals([1, 2, 3], $container->makeWith(`baz`, [1, 2, 3]));
}

extend 閉包引數

public function testExtendedBindings()
{
    $container = new Container;    
    $container[`foo`] = `foo’;    
    $container->extend(`foo`, function ($old, $container) {
        return $old.`bar’;    
    });
   
    $this->assertEquals(`foobar`, $container->make(`foo`));
    
    $container = new Container;
    
    $container->singleton(`foo`, function () {
        return (object) [`name` => `taylor`];    
    });    
    $container->extend(`foo`, function ($old, $container) {
        $old->age = 26;
        return $old;    
    });
    
    $result = $container->make(`foo`);
    $this->assertEquals(`taylor`, $result->name);    
    $this->assertEquals(26, $result->age);   
    $this->assertSame($result, $container->make(`foo`));
}

bindmethod 閉包引數

public function testCallWithBoundMethod()
{
    $container = new Container;
    $container->bindMethod(`IlluminateTestsContainerContainerTestCallStub@unresolvable`, function ($stub,$container) {
        $container[`foo`] = `foo`;
        return $stub->unresolvable(`foo`, `bar`);
    });
    $result = $container->call(`IlluminateTestsContainerContainerTestCallStub@unresolvable`);
    $this->assertEquals([`foo`, `bar`], $result);
    $this->assertEquals(`foo`,$container[`foo`]);
}

resolve 閉包引數

public function testResolvingCallbacksAreCalledForSpecificAbstracts()
{
     $container = new Container;
     $container->resolving(`foo`, function ($object，$container) {
         return $object->name = `taylor`;
     });
 
     $container->bind(`foo`, function () {
        return new StdClass;
     });
     $instance = $container->make(`foo`);

     $this->assertEquals(`taylor`, $instance->name);
}

rebinding 閉包引數

public function testReboundListeners()
{
    $container = new Container;
    $container->bind(`foo`, function () {
        return `foo`;
    });
  
    $container->rebinding(`foo`, function ($container,$object) {
         $container[`bar`] = $object.`bar`;
    });
  
    $container->bind(`foo`, function () {
    });

    $this->assertEquals(`bar`,$container[`foobar`]);
}

Laravel 核心——服務容器的細節特性
2017-05-28
Laravel
Registry 容器映象服務端細節
2020-10-13
服務端
Laravel服務容器
2019-02-16
Laravel
Laravel核心程式碼學習 -- 服務容器(IocContainer)
2018-05-21
LaravelAI
深入Laravel服務容器
2019-02-16
Laravel
「Laravel 服務容器」自己的理解
2019-11-05
Laravel
深入剖析 Laravel 服務容器
2018-05-29
Laravel
Laravel 核心——IoC 服務容器原始碼解析（伺服器解析）
2017-05-12
Laravel原始碼伺服器
使用 Laravel 服務容器的優勢
2018-07-01
Laravel
Laravel原始碼解析 — 服務容器
2021-04-12
Laravel原始碼
Laravel 服務容器和提供器
2018-07-06
Laravel
Laravel 服務容器實現原理
2017-06-12
Laravel
Laravel 重點概念理解-服務容器
2019-01-25
Laravel
Laravel 學習筆記 —— 神奇的服務容器
2015-05-07
Laravel筆記
容器映象服務：雲原生時代的核心基石
2024-02-29
Laravel 服務容器、服務提供器、契約例項講解
2018-09-26
Laravel
Laravel 原始碼筆記 2 App 服務容器
2020-03-01
Laravel原始碼筆記APP
Laravel修煉：服務容器繫結與解析
2018-10-14
Laravel
細述docker容器中建立SSH服務映象
2019-06-23
Docker
Laravel底層學習筆記02 - 服務容器，服務提供者
2021-11-07
Laravel筆記
Laravel核心解讀–服務提供器(ServiceProvider)
2019-02-16
LaravelIDE
Laravel核心程式碼學習 -- 服務提供器
2018-05-22
Laravel
Laravel 原始碼閱讀指南 -- 服務容器 IocContainer
2018-05-28
Laravel原始碼AI
Laravel核心解讀–使用者認證系統的實現細節
2019-02-16
Laravel
Spring核心原理之 IoC容器中那些鮮為人知的細節（3）
2021-12-25
Spring
Laravel 的一個命名細節分享
2020-01-10
Laravel
Dapr實現分散式有狀態服務的細節
2020-11-05
分散式
Laravel核心程式碼學習–使用者認證系統的實現細節
2019-03-01
Laravel
Laravel核心程式碼學習--使用者認證系統的實現細節
2018-07-01
Laravel
事件與服務容器
2019-08-05
事件
Laravel ：register（註冊）和服務容器的理解
2019-12-18
Laravel
Docker容器服務搭建（一）
2024-03-05
Docker
【下一代核心技術DevOps】：（一）容器服務的Rancher選型
2017-12-14
dev
物件儲存服務的Lambda特性
2024-04-28
物件
Laravel 服務之任務排程
2017-05-06
Laravel
Lumen - 服務容器，服務提供者，Facades的關係
2018-05-11
Laravel Hprose RPC 服務
2019-08-09
LaravelROSRPC
Laravel 郵箱服務使用
2018-11-24
Laravel