PHP에서 경량 컨테이너를 구현하는 방법(코드 예)

이 문서의 내용은 PHP에서 경량 컨테이너(코드 예제)를 구현하는 방법에 대한 것입니다. 필요한 친구들이 참고할 수 있기를 바랍니다.

컨테이너란 무엇인가

개발 과정에서 자주 사용되는 개념은 종속성 주입입니다. 우리는 지연 주입을 사용하여 코드를 분리하고 요청 시 서비스를 선택적으로 로드합니다. 이는 일반적으로 컨테이너의 도움으로 구현됩니다.

Containers는 객체의 통합 관리를 구현하고 객체 인스턴스의 고유성을 보장합니다.

Containers는 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]);
    }
}

이렇게 하면 기능이 풍부하고 사용하기 쉬운 경량 컨테이너를 최대한 빨리 프로젝트에 통합해 보겠습니다.

보려면 여기를 클릭하세요

전체 코드

위 내용은 PHP에서 경량 컨테이너를 구현하는 방법(코드 예)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!