如何實現Laravel的服務容器

時間 2019-11-07

標籤如何實現 laravel 服務容器简体版

原文原文鏈接

如何實現服務容器(Ioc Container)

1. 容器的本質

服務容器自己就是一個數組，鍵名就是服務名，值就是服務。

服務能夠是一個原始值，也能夠是一個對象，能夠說是任意數據。

服務名能夠是自定義名，也能夠是對象的類名，也能夠是接口名。

// 服務容器
$container = [
    // 原始值
    'text' => '這是一個字符串',
    // 自定義服務名
    'customName' => new StdClass(),
    // 使用類名做爲服務名
    'StdClass' => new StdClass(),
    // 使用接口名做爲服務名
    'Namespace\\StdClassInterface' => new StdClass(),
];

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

// 綁定服務到容器
$container['standard'] = new StdClass();
// 獲取服務
$standard = $container['standard'];
var_dump($standard);

2. 封裝成類

爲了方便維護，咱們把上面的數組封裝到類裏面。php

$instances仍是上面的容器數組。咱們增長兩個方法，instance用來綁定服務，get用來從容器中獲取服務。redis

class BaseContainer
{

    // 已綁定的服務
    protected $instances = [];

    // 綁定服務
    public function instance($name, $instance)
    {
        $this->instances[$name] = $instance;
    }

    // 獲取服務
    public function get($name)
    {
        return isset($this->instances[$name]) ? $this->instances[$name] : null;
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

$container = new BaseContainer();
// 綁定服務
$container->instance('StdClass', new StdClass());
// 獲取服務
$stdClass = $container->get('StdClass');
var_dump($stdClass);

3. 按需實例化

如今咱們在綁定一個對象服務的時候，就必需要先把類實例化，若是綁定的服務沒有被用到，那麼類就會白白實例化，形成性能浪費。數組

爲了解決這個問題，咱們增長一個bind函數，它支持綁定一個回調函數，在回調函數中實例化類。這樣一來，咱們只有在使用服務時，纔回調這個函數，這樣就實現了按需實例化。函數

這時候，咱們獲取服務時，就不僅是從數組中拿到服務並返回了，還須要判斷若是是回調函數，就要執行回調函數。因此咱們把get方法的名字改爲make。意思就是生產一個服務，這個服務能夠是已綁定的服務，也能夠是已綁定的回調函數，也能夠是一個類名，若是是類名，咱們就直接實例化該類並返回。性能

而後，咱們增長一個新數組$bindings，用來存儲綁定的回調函數。而後咱們把bind方法改一下，判斷下$instance若是是一個回調函數，就放到$bindings數組，不然就用make方法實例化類。ui

class DeferContainer extends BaseContainer
{
    // 已綁定的回調函數
    protected $bindings = [];

    // 綁定服務
    public function bind($name, $instance)
    {
        if ($instance instanceof Closure) {
            // 若是$instance是一個回調函數，就綁定到bindings。
            $this->bindings[$name] = $instance;
        } else {
            // 調用make方法，建立實例
            $this->instances[$name] = $this->make($name);
        }
    }

    // 獲取服務
    public function make($name)
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }

        if (isset($this->bindings[$name])) {
            // 執行回調函數並返回
            $instance = call_user_func($this->bindings[$name]);
        } else {
            // 尚未綁定到容器中，直接new.
            $instance = new $name();
        }

        return $instance;
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

$container = new DeferContainer();
// 綁定服務
$container->bind('StdClass', function () {
    echo "我被執行了\n";
    return new StdClass();
});
// 獲取服務
$stdClass = $container->make('StdClass');
var_dump($stdClass);

StdClass這個服務綁定的是一個回調函數，在回調函數中才會真正的實例化類。若是沒有用到這個服務，那回調函數就不會被執行，類也不會被實例化。this

4. 單例

從上面的代碼中能夠看出，每次調用make方法時，都會執行一次回調函數，並返回一個新的類實例。可是在某些狀況下，咱們但願這個實例是一個單例，不管make多少次，只實例化一次。spa

這時候，咱們給bind方法增長第三個參數$shared，用來標記是不是單例，默認不是單例。而後把回調函數和這個標記都存到$bindings數組裏。日誌

爲了方便綁定單例服務，再增長一個新的方法singleton，它直接調用bind，而且$shared參數強制爲true。code

對於make方法，咱們也要作修改。在執行$bindings裏的回調函數之後，作一個判斷，若是以前綁定時標記的shared是true，就把回調函數返回的結果存儲到$instances裏。因爲咱們是先從$instances裏找服務，因此這樣下次再make的時候就會直接返回，而不會再次執行回調函數。這樣就實現了單例的綁定。

class SingletonContainer extends DeferContainer
{
    // 綁定服務
    public function bind($name, $instance, $shared = false)
    {
        if ($instance instanceof Closure) {
            // 若是$instance是一個回調函數，就綁定到bindings。
            $this->bindings[$name] = [
                'callback' => $instance,
                // 標記是否單例
                'shared' => $shared
            ];
        } else {
            // 調用make方法，建立實例
            $this->instances[$name] = $this->make($name);
        }
    }

    // 綁定一個單例
    public function singleton($name, $instance)
    {
        $this->bind($name, $instance, true);
    }

    // 獲取服務
    public function make($name)
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }

        if (isset($this->bindings[$name])) {
            // 執行回調函數並返回
            $instance = call_user_func($this->bindings[$name]['callback']);

            if ($this->bindings[$name]['shared']) {
                // 標記爲單例時，存儲到服務中
                $this->instances[$name] = $instance;
            }
        } else {
            // 尚未綁定到容器中，直接new.
            $instance = new $name();
        }

        return $instance;
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

$container = new SingletonContainer();
// 綁定服務
$container->singleton('anonymous', function () {
    return new class
    {
        public function __construct()
        {
            echo "我被實例化了\n";
        }
    };
});
// 不管make多少次，只會實例化一次
$container->make('anonymous');
$container->make('anonymous');
// 獲取服務
$anonymous = $container->make('anonymous');
var_dump($anonymous)

上面的代碼用singleton綁定了一個名爲anonymous的服務，回調函數裏返回了一個匿名類的實例。這個匿名類在被實例化時會輸出一段文字。不管咱們make多少次anonymous，這個回調函數只會被執行一次，匿名類也只會被實例化一次。

5. 自動注入

自動注入是Ioc容器的核心，沒有自動注入就沒法作到控制反轉。

自動注入就是指，在實例化一個類時，用反射類來獲取__construct所須要的參數，而後根據參數的類型，從容器中找到已綁定的服務。咱們只要有了__construct方法所需的全部參數，就能自動實例化該類，實現自動注入。

如今，咱們增長一個build方法，它只接收一個參數，就是類名。build方法會用反射類來獲取__construct方法所須要的參數，而後返回實例化結果。

另一點就是，咱們以前在調用make方法時，若是傳的是一個未綁定的類，咱們直接new了這個類。如今咱們把未綁定的類交給build方法來構建，由於它支持自動注入。

class InjectionContainer extends SingletonContainer
{

    // 獲取服務
    public function make($name)
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }
        if (isset($this->bindings[$name])) {
            // 執行回調函數並返回
            $instance = call_user_func($this->bindings[$name]['callback']);

            if ($this->bindings[$name]['shared']) {
                // 標記爲單例時，存儲到服務中
                $this->instances[$name] = $instance;
            }
        } else {
            // 使用build方法構建此類
            $instance = $this->build($name);
        }

        return $instance;
    }

    // 構建一個類，並自動注入服務
    public function build($class)
    {

        $reflector = new ReflectionClass($class);

        $constructor = $reflector->getConstructor();

        if (is_null($constructor)) {
            // 沒有構造函數，直接new
            return new $class();
        }

        $dependencies = [];

        // 獲取構造函數所需的參數
        foreach ($constructor->getParameters() as $dependency) {
            if (is_null($dependency->getClass())) {
                // 參數類型不是類時，沒法從容器中獲取依賴
                if ($dependency->isDefaultValueAvailable()) {
                    // 查找參數的默認值，若是有就使用默認值
                    $dependencies[] = $dependency->getDefaultValue();
                } else {
                    // 沒法提供類所依賴的參數
                    throw new Exception('找不到依賴參數：' . $dependency->getName());
                }
            } else {
                // 參數類型是類時，就用make方法構建該類
                $dependencies[] = $this->make($dependency->getClass()->name);
            }
        }

        return $reflector->newInstanceArgs($dependencies);
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

class Redis
{
}

class Cache
{
    protected $redis;

    // 構造函數中依賴Redis服務
    public function __construct(Redis $redis)
    {
        $this->redis = $redis;
    }
}

$container = new InjectionContainer();
// 綁定Redis服務
$container->singleton(Redis::class, function () {
    return new Redis();
});
// 構建Cache類
$cache = $container->make(Cache::class);
var_dump($cache);

6. 自定義依賴參數

如今有個問題，若是類依賴的參數不是類或接口，只是一個普通變量，這時候就沒法從容器中獲取依賴參數了，也就沒法實例化類了。

那麼接下來咱們就支持一個新功能，在調用make方法時，支持傳第二個參數$parameters，這是一個數組，沒法從容器中獲取的依賴，就從這個數組中找。

固然，make方法是用不到這個參數的，由於它不負責實例化類，它直接傳給build方法。在build方法尋找依賴的參數時，就先從$parameters中找。這樣就實現了自定義依賴參數。

須要注意的一點是， build方法是按照參數的名字來找依賴的，因此 parameters中的鍵名也必須跟 __construct中參數名一致。

class ParametersContainer extends InjectionContainer
{
    // 獲取服務
    public function make($name, array $parameters = [])
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }
        if (isset($this->bindings[$name])) {
            // 執行回調函數並返回
            $instance = call_user_func($this->bindings[$name]['callback']);

            if ($this->bindings[$name]['shared']) {
                // 標記爲單例時，存儲到服務中
                $this->instances[$name] = $instance;
            }
        } else {
            // 使用build方法構建此類
            $instance = $this->build($name, $parameters);
        }

        return $instance;
    }

    // 構建一個類，並自動注入服務
    public function build($class, array $parameters = [])
    {
        $reflector = new ReflectionClass($class);

        $constructor = $reflector->getConstructor();

        if (is_null($constructor)) {
            // 沒有構造函數，直接new
            return new $class();
        }

        $dependencies = [];

        // 獲取構造函數所需的參數
        foreach ($constructor->getParameters() as $dependency) {

            if (isset($parameters[$dependency->getName()])) {
                // 先從自定義參數中查找
                $dependencies[] = $parameters[$dependency->getName()];
                continue;
            }

            if (is_null($dependency->getClass())) {
                // 參數類型不是類或接口時，沒法從容器中獲取依賴
                if ($dependency->isDefaultValueAvailable()) {
                    // 查找默認值，若是有就使用默認值
                    $dependencies[] = $dependency->getDefaultValue();
                } else {
                    // 沒法提供類所依賴的參數
                    throw new Exception('找不到依賴參數：' . $dependency->getName());
                }
            } else {
                // 參數類型是類時，就用make方法構建該類
                $dependencies[] = $this->make($dependency->getClass()->name);
            }
        }

        return $reflector->newInstanceArgs($dependencies);
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

class Redis
{
}

class Cache
{
    protected $redis;

    protected $name;

    protected $default;

    // 構造函數中依賴Redis服務和name參數，name的類型不是類，沒法從容器中查找
    public function __construct(Redis $redis, $name, $default = '默認值')
    {
        $this->redis = $redis;
        $this->name = $name;
        $this->default = $default;
    }
}

$container = new ParametersContainer();
// 綁定Redis服務
$container->singleton(Redis::class, function () {
    return new Redis();
});
// 構建Cache類
$cache = $container->make(Cache::class, ['name' => 'test']);
var_dump($cache);

提示：實際上，Laravel容器的 build方法並無第二個參數 $parameters，它是用類屬性來維護自定義參數。原理都是同樣的，只是實現方式不同。這裏爲了方便理解，不引入過多概念。

7. 服務別名

別名能夠理解成小名、外號。服務別名就是給已綁定的服務設置一些外號，使咱們經過外號也能找到該服務。

這個就比較簡單了，咱們增長一個新的數組$aliases，用來存儲別名。再增長一個方法alias，用來讓外部註冊別名。

惟一須要咱們修改的地方，就是在make時，要先從$aliases中找到真實的服務名。

class AliasContainer extends ParametersContainer
{
    // 服務別名
    protected $aliases = [];

    // 給服務綁定一個別名
    public function alias($alias, $name)
    {
        $this->aliases[$alias] = $name;
    }

    // 獲取服務
    public function make($name, array $parameters = [])
    {
        // 先用別名查找真實服務名
        $name = isset($this->aliases[$name]) ? $this->aliases[$name] : $name;

        return parent::make($name, $parameters);
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

$container = new AliasContainer();

// 綁定服務
$container->instance('text', '這是一個字符串');
// 給服務註冊別名
$container->alias('string', 'text');
$container->alias('content', 'text');

var_dump($container->make('string'));
var_dump($container->make('content'));

8. 擴展綁定

有時候咱們須要給已綁定的服務作一個包裝，這時候就用到擴展綁定了。咱們先看一個實際的用法，理解它的做用後，纔看它是如何實現的。

// 綁定日誌服務
$container->singleton('log', new Log());

// 對已綁定的服務再次包裝
$container->extend('log', function(Log $log){
    // 返回了一個新服務
    return new RedisLog($log);
});

如今咱們看它是如何實現的。增長一個$extenders數組，用來存放擴展器。再增長一個extend方法，用來註冊擴展器。

而後在make方法返回$instance以前，按順序依次調用以前註冊的擴展器。

class ExtendContainer extends AliasContainer
{
    // 存放擴展器的數組
    protected $extenders = [];

    // 給服務綁定擴展器
    public function extend($name, $extender)
    {
        if (isset($this->instances[$name])) {
            // 已經實例化的服務，直接調用擴展器
            $this->instances[$name] = $extender($this->instances[$name]);
        } else {
            $this->extenders[$name][] = $extender;
        }
    }

    // 獲取服務
    public function make($name, array $parameters = [])
    {
        $instance = parent::make($name, $parameters);

        if (isset($this->extenders[$name])) {
            // 調用擴展器
            foreach ($this->extenders[$name] as $extender) {
                $instance = $extender($instance);
            }
        }

        return $instance;
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

class Redis
{
    public $name;

    public function __construct($name = 'default')
    {
        $this->name = $name;
    }

    public function setName($name)
    {
        $this->name = $name;
    }
}

$container = new ExtendContainer();

// 綁定Redis服務
$container->singleton(Redis::class, function () {
    return new Redis();
});

// 給Redis服務綁定一個擴展器
$container->extend(Redis::class, function (Redis $redis) {
    $redis->setName('擴展器');
    return $redis;
});
$redis = $container->make(Redis::class);
var_dump($redis->name);

9. 上下文綁定

有時侯咱們可能有兩個類使用同一個接口，但但願在每一個類中注入不一樣的實現，例如兩個控制器，分別爲它們注入不一樣的Log服務。

class ApiController
{
    public function __construct(Log $log)
    {
    }
}

class WebController
{
    public function __construct(Log $log)
    {
    }
}

最終咱們要用如下方式實現：

// 當ApiController依賴Log時，給它一個RedisLog
$container->addContextualBinding('ApiController','Log',new RedisLog());

// 當WebController依賴Log時，給它一個FileLog
$container->addContextualBinding('WebController','Log',new FileLog());

爲了更直觀更方便更語義化的使用，咱們把這個過程改爲鏈式操做：

$container->when('ApiController')
        ->needs('Log')
        ->give(new RedisLog());

咱們增長一個$context數組，用來存儲上下文。同時增長一個addContextualBinding方法，用來註冊上下文綁定。以ApiController爲例，$context的真實模樣是：

$context['ApiController']['Log'] = new RedisLog();

而後build方法實例化類時，先從上下文中查找依賴參數，就實現了上下文綁定。

接下來，看看鏈式操做是如何實現的。

首先定義一個類Context，這個類有兩個方法，needs和give。
而後在容器中，增長一個when方法，它返回一個Context對象。在Context對象的give方法中，咱們已經具有了註冊上下文所須要的全部參數，因此就能夠在give方法中調用addContextualBinding來註冊上下文了。

class ContextContainer extends ExtendContainer
{
    // 依賴上下文
    protected $context = [];

    // 構建一個類，並自動注入服務
    public function build($class, array $parameters = [])
    {
        $reflector = new ReflectionClass($class);

        $constructor = $reflector->getConstructor();

        if (is_null($constructor)) {
            // 沒有構造函數，直接new
            return new $class();
        }

        $dependencies = [];

        // 獲取構造函數所需的參數
        foreach ($constructor->getParameters() as $dependency) {

            if (isset($this->context[$class]) && isset($this->context[$class][$dependency->getName()])) {
                // 先從上下文中查找
                $dependencies[] = $this->context[$class][$dependency->getName()];
                continue;
            }

            if (isset($parameters[$dependency->getName()])) {
                // 從自定義參數中查找
                $dependencies[] = $parameters[$dependency->getName()];
                continue;
            }

            if (is_null($dependency->getClass())) {
                // 參數類型不是類或接口時，沒法從容器中獲取依賴
                if ($dependency->isDefaultValueAvailable()) {
                    // 查找默認值，若是有就使用默認值
                    $dependencies[] = $dependency->getDefaultValue();
                } else {
                    // 沒法提供類所依賴的參數
                    throw new Exception('找不到依賴參數：' . $dependency->getName());
                }
            } else {
                // 參數類型是一個類時，就用make方法構建該類
                $dependencies[] = $this->make($dependency->getClass()->name);
            }
        }

        return $reflector->newInstanceArgs($dependencies);
    }

    // 綁定上下文
    public function addContextualBinding($when, $needs, $give)
    {
        $this->context[$when][$needs] = $give;
    }

    // 支持鏈式方式綁定上下文
    public function when($when)
    {
        return new Context($when, $this);
    }
}

class Context
{
    protected $when;

    protected $needs;

    protected $container;

    public function __construct($when, ContextContainer $container)
    {
        $this->when = $when;
        $this->container = $container;
    }

    public function needs($needs)
    {
        $this->needs = $needs;

        return $this;
    }

    public function give($give)
    {
        // 調用容器綁定依賴上下文
        $this->container->addContextualBinding($this->when, $this->needs, $give);
    }
}

// ----------- ↓↓↓↓示例代碼↓↓↓↓ ----------- //

class Dog
{
    public $name;

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

class Cat
{
    public $name;

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

$container = new ContextContainer();

// 給Dog類設置上下文綁定
$container->when(Dog::class)
    ->needs('name')
    ->give('小狗');
// 給Cat類設置上下文綁定
$container->when(Cat::class)
    ->needs('name')
    ->give('小貓');

$dog = $container->make(Dog::class);
$cat = $container->make(Cat::class);
var_dump('Dog:' . $dog->name);
var_dump('Cat:' . $cat->name);

10. 完整代碼

class Container
{
    // 已綁定的服務
    protected $instances = [];
    // 已綁定的回調函數
    protected $bindings = [];
    // 服務別名
    protected $aliases = [];
    // 存放擴展器的數組
    protected $extenders = [];
    // 依賴上下文
    protected $context = [];

    // 綁定服務實例
    public function instance($name, $instance)
    {
        $this->instances[$name] = $instance;
    }

    // 綁定服務
    public function bind($name, $instance, $shared = false)
    {
        if ($instance instanceof Closure) {
            // 若是$instance是一個回調函數，就綁定到bindings。
            $this->bindings[$name] = [
                'callback' => $instance,
                // 標記是否單例
                'shared' => $shared
            ];
        } else {
            // 調用make方法，建立實例
            $this->instances[$name] = $this->make($name);
        }
    }

    // 綁定一個單例
    public function singleton($name, $instance)
    {
        $this->bind($name, $instance, true);
    }

    // 給服務綁定一個別名
    public function alias($alias, $name)
    {
        $this->aliases[$alias] = $name;
    }

    // 給服務綁定擴展器
    public function extend($name, $extender)
    {
        if (isset($this->instances[$name])) {
            // 已經實例化的服務，直接調用擴展器
            $this->instances[$name] = $extender($this->instances[$name]);
        } else {
            $this->extenders[$name][] = $extender;
        }
    }

    // 獲取服務
    public function make($name, array $parameters = [])
    {
        // 先用別名查找真實服務名
        $name = isset($this->aliases[$name]) ? $this->aliases[$name] : $name;

        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }

        if (isset($this->bindings[$name])) {
            // 執行回調函數並返回
            $instance = call_user_func($this->bindings[$name]['callback']);

            if ($this->bindings[$name]['shared']) {
                // 標記爲單例時，存儲到服務中
                $this->instances[$name] = $instance;
            }
        } else {
            // 使用build方法構建此類
            $instance = $this->build($name, $parameters);
        }

        if (isset($this->extenders[$name])) {
            // 調用擴展器
            foreach ($this->extenders[$name] as $extender) {
                $instance = $extender($instance);
            }
        }

        return $instance;
    }

    // 構建一個類，並自動注入服務
    public function build($class, array $parameters = [])
    {
        $reflector = new ReflectionClass($class);

        $constructor = $reflector->getConstructor();

        if (is_null($constructor)) {
            // 沒有構造函數，直接new
            return new $class();
        }

        $dependencies = [];

        // 獲取構造函數所需的參數
        foreach ($constructor->getParameters() as $dependency) {

            if (isset($this->context[$class]) && isset($this->context[$class][$dependency->getName()])) {
                // 先從上下文中查找
                $dependencies[] = $this->context[$class][$dependency->getName()];
                continue;
            }

            if (isset($parameters[$dependency->getName()])) {
                // 從自定義參數中查找
                $dependencies[] = $parameters[$dependency->getName()];
                continue;
            }

            if (is_null($dependency->getClass())) {
                // 參數類型不是類或接口時，沒法從容器中獲取依賴
                if ($dependency->isDefaultValueAvailable()) {
                    // 查找默認值，若是有就使用默認值
                    $dependencies[] = $dependency->getDefaultValue();
                } else {
                    // 沒法提供類所依賴的參數
                    throw new Exception('找不到依賴參數：' . $dependency->getName());
                }
            } else {
                // 參數類型是一個類時，就用make方法構建該類
                $dependencies[] = $this->make($dependency->getClass()->name);
            }
        }

        return $reflector->newInstanceArgs($dependencies);
    }

    // 綁定上下文
    public function addContextualBinding($when, $needs, $give)
    {
        $this->context[$when][$needs] = $give;
    }

    // 支持鏈式方式綁定上下文
    public function when($when)
    {
        return new Context($when, $this);
    }
}

class Context
{
    protected $when;

    protected $needs;

    protected $container;

    public function __construct($when, Container $container)
    {
        $this->when = $when;
        $this->container = $container;
    }

    public function needs($needs)
    {
        $this->needs = $needs;

        return $this;
    }

    public function give($give)
    {
        // 調用容器綁定依賴上下文
        $this->container->addContextualBinding($this->when, $this->needs, $give);
    }
}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。