摘要：出于需要，我們自己造一個輕量級的輪子，為了保持規范，我們基于來實現。這樣我們就擁有了一個功能豐富，使用方便的輕量級容器了，趕快整合到你的項目中去吧。

什么是容器

在開發過程中，經常會用到的一個概念就是依賴注入。我們借助依懶注入來解耦代碼，選擇性的按需加載服務，而這些通常都是借助容器來實現。

容器實現對對象的統一管理，并且確保對象實例的唯一性

容器可以很輕易的找到有很多實現示例，如 PHP-DI 、 YII-DI 等各種實現，通常他們要么大而全，要么高度適配特定業務，與實際需要存在沖突。

出于需要，我們自己造一個輕量級的輪子，為了保持規范，我們基于 PSR-11 來實現。

PSR-11

PSR 是 php-fig 提供的標準化建議，雖然不是官方組織，但是得到廣泛認可。PSR-11 提供了容器接口。它包含 ContainerInterface 和 兩個異常接口，并提供使用建議。

/**
 * Describes the interface of a container that exposes methods to read its entries.
 */
interface ContainerInterface
{
    /**
     * Finds an entry of the container by its identifier and returns it.
     *
     * @param string $id Identifier of the entry to look for.
     *
     * @throws NotFoundExceptionInterface  No entry was found for **this** identifier.
     * @throws ContainerExceptionInterface Error while retrieving the entry.
     *
     * @return mixed Entry.
     */
    public function get($id);

    /**
     * Returns true if the container can return an entry for the given identifier.
     * Returns false otherwise.
     *
     * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
     * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
     *
     * @param string $id Identifier of the entry to look for.
     *
     * @return bool
     */
    public function has($id);
}

實現示例

我們先來實現接口中要求的兩個方法

abstract class AbstractContainer implements ContainerInterface
{

    protected $resolvedEntries = [];

    /**
     * @var array
     */
    protected $definitions = [];

    public function __construct($definitions = [])
    {
        foreach ($definitions as $id => $definition) {
            $this->injection($id, $definition);
        }
    }

    public function get($id)
    {

        if (!$this->has($id)) {
            throw new NotFoundException("No entry or class found for {$id}");
        }

        $instance = $this->make($id);

        return $instance;
    }

    public function has($id)
    {
        return isset($this->definitions[$id]);
    }

實際我們容器中注入的對象是多種多樣的，所以我們多帶帶抽出實例化方法。

    protected function make($name)
    {

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

        $definition = $this->definitions[$name];
        $params = [];
        if (is_array($definition) && isset($definition["class"])) {
            $params = $definition;
            $definition = $definition["class"];
            unset($params["class"]);
        }

        $object = $this->reflector($definition, $params);

        return $this->resolvedEntries[$name] = $object;
    }

    public function reflector($concrete, array $params = [])
    {
        if ($concrete instanceof Closure) {
            return $concrete($params);
        } elseif (is_string($concrete)) {
            $reflection = new ReflectionClass($concrete);
            $dependencies = $this->getDependencies($reflection);
            foreach ($params as $index => $value) {
                $dependencies[$index] = $value;
            }
            return $reflection->newInstanceArgs($dependencies);
        } elseif (is_object($concrete)) {
            return $concrete;
        }
    }

    /**
     * @param ReflectionClass $reflection
     * @return array
     */
    private function getDependencies($reflection)
    {
        $dependencies = [];
        $constructor = $reflection->getConstructor();
        if ($constructor !== null) {
            $parameters = $constructor->getParameters();
            $dependencies = $this->getParametersByDependencies($parameters);
        }

        return $dependencies;
    }

    /**
     *
     * 獲取構造類相關參數的依賴
     * @param array $dependencies
     * @return array $parameters
     * */
    private function getParametersByDependencies(array $dependencies)
    {
        $parameters = [];
        foreach ($dependencies as $param) {
            if ($param->getClass()) {
                $paramName = $param->getClass()->name;
                $paramObject = $this->reflector($paramName);
                $parameters[] = $paramObject;
            } elseif ($param->isArray()) {
                if ($param->isDefaultValueAvailable()) {
                    $parameters[] = $param->getDefaultValue();
                } else {
                    $parameters[] = [];
                }
            } elseif ($param->isCallable()) {
                if ($param->isDefaultValueAvailable()) {
                    $parameters[] = $param->getDefaultValue();
                } else {
                    $parameters[] = function ($arg) {
                    };
                }
            } else {
                if ($param->isDefaultValueAvailable()) {
                    $parameters[] = $param->getDefaultValue();
                } else {
                    if ($param->allowsNull()) {
                        $parameters[] = null;
                    } else {
                        $parameters[] = false;
                    }
                }
            }
        }
        return $parameters;
    }

如你所見，到目前為止我們只實現了從容器中取出實例，從哪里去提供實例定義呢，所以我們還需要提供一個方法.

    /**
     * @param string $id
     * @param string | array | callable $concrete
     * @throws ContainerException
     */
    public function injection($id, $concrete)
    {
        if (!is_string($id)) {
            throw new InvalidArgumentException(sprintf(
                "The id parameter must be of type string, %s given",
                is_object($id) ? get_class($id) : gettype($id)
            ));
        }

        if (is_array($concrete) && !isset($concrete["class"])) {
            throw new ContainerException("數組必須包含類定義");
        }

        $this->definitions[$id] = $concrete;
    }

只有這樣嗎？對的，有了這些操作我們已經有一個完整的容器了，插箱即用。

不過為了使用方便，我們可以再提供一些便捷的方法，比如數組式訪問。

class Container extends AbstractContainer implements ArrayAccess
{

    public function offsetExists($offset)
    {
        return $this->has($offset);
    }

    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    public function offsetSet($offset, $value)
    {
        return $this->injection($offset, $value);
    }

    public function offsetUnset($offset)
    {
        unset($this->resolvedEntries[$offset]);
        unset($this->definitions[$offset]);
    }
}

這樣我們就擁有了一個功能豐富，使用方便的輕量級容器了，趕快整合到你的項目中去吧。

點擊這里查看完整代碼