최신 PHP 프레임워크에서 IOC 컨테이너를 이해하고 구현하는 기사 1개

이 기사는 IOC 컨테이너에 대한 관련 내용을 주로 소개하는 PHP에 대한 관련 지식을 제공합니다. IOC의 전체 이름은 Inversion Of Control, Inversion Control 입니다. 모두에게 도움이 됩니다.

컨테이너란 무엇인가요?

종속성 주입 구현을 위한 기본 조건은 컨테이너와 분리할 수 없다는 사실을 많은 사람들이 들어봤을 것입니다. 컨테이너는 클래스 종속성 및 주입을 관리하는 데 사용되며 서비스 관리 및 구성 요소 분리를 담당한다는 것입니다. 컨테이너를 넣을 수 있는 객체를 저장하는 전용 초대형 배열로 이해하세요.

그림과 같이 호출자는 컨테이너의 레이블을 통해 객체 인스턴스를 얻습니다. 그림에서 볼 수 있듯이 ::class를 통해 또는 객체 레이블을 통해 직접 얻을 수 있습니다.

IOC란 무엇인가요?

IOC 컨테이너에 대해 들어보셨을 것입니다. IOC의 전체 이름은 (Inversion Of Control)입니다.

제어 반전이 무엇인지 이해해 보겠습니다. 기존 코딩에서 클래스 간의 종속성은 일반적으로 코딩을 통해 새 개체를 만든 다음 이를 전달하는 것입니다. 구현하다. 그림 1에서 볼 수 있듯이 컨테이너에는 많은 객체가 저장되어 있으며, 필요할 때 바로 사용할 수 있도록 하는 것이 목적입니다. 컨테이너의 개체를 코드로 생성할 필요는 없습니다. 특정 클래스 개체가 필요한 경우 해당 개체를 컨테이너에서 가져옵니다. 개체가 없으면 자동으로 생성됩니다. 이는 코드에서 객체를 생성하는 과정을 생략한다는 의미이며, 컨테이너는 이러한 생성 과정을 실현하도록 도와줍니다. 이를 반전 제어라고 합니다. IOC를 한 문장으로 요약하면 다음과 같습니다. 객체 생성 제어를 컨테이너 구현 클래스의 인스턴스화로 전달합니다.

예: IOC를 사용하지 않고 클래스를 생성하려면

<?php
class Sunny{
}
$sunny = new Sunny();

새 클래스를 수동으로 생성해야 합니다. 이 경우 코드에 하드 코딩됩니다.

IOC 컨테이너를 사용하는 코드는 다음과 같이 작성할 수 있습니다.

<?php
class Sunny{
}
$sunny = Container::getBean(Sunny::class);

이 클래스를 컨테이너 내부에 구현하도록 도와주세요. 어떤 학생들은 이것을 보고 질문을 할 수도 있습니다. 새로운 Sunny를 사용하면 코드가 더 짧아지고 간단해지지 않을까요? 의존성 주입을 살펴본 후 예시를 살펴보겠습니다.

종속성 주입

이제 IOC가 무엇인지 알았으니 새로운 질문이 생깁니다. 클래스를 생성할 때 일부 클래스의 생성자가 매개변수 전달을 요구하면 어떻게 해야 할까요? IOC 연구를 통해 우리는 IOC 컨테이너가 객체 인스턴스 생성 문제를 해결하는 데 도움이 된다는 것을 알고 있습니다. 컨테이너에서 객체를 생성할 때 클래스에 다른 종속성이 있는 것으로 확인되면 종속성 검색을 수행합니다. 컨테이너가 필요한 개체를 찾는 과정을 DL(Dependency Lookup, 종속성 조회)이라고 합니다. 필요한 종속성을 코드 조각에 주입하는 것을 DI(종속성 주입, 종속성 주입)라고 합니다.

예를 들어 IOC에서 언급된 새로운 Sunny 예시가 있습니다. 클래스 사이에 여러 종속성이 있는 경우.

<?php
class Computer{
    public function run(){
        echo "编程中....\n";
    }
}
class Sunny{
    private $computer;
    public function __construct(Computer $computer){
        $this->computer = $computer;
    }
    public function program(){
        $this->computer->run();
    }
}
$sunny = new Sunny(new Computer());
$sunny->program();

여기서 Sunny 클래스가 Computer 클래스에 종속되도록 프로그래밍하려는 것을 볼 수 있습니다. IOC 컨테이너를 사용하여 종속성 주입을 구현하면 코드가 간단해집니다.

<?php
class Computer{
    public function run(){
        echo "编程中....\n";
    }
}
class Sunny{
    private $computer;
    public function __construct(Computer $computer){
        $this->computer = $computer;
    }
    public function program(){
        $this->computer->run();
    }
}
$sunny = Container::getBean(Sunny::class);
$sunny->program();

한 문장으로 요약: 클래스 인스턴스 생성 시 다른 클래스에 대한 종속성을 해결하고, 필요한 다른 객체를 객체에 동적으로 제공합니다.

종속성 반전

종속성 반전으로 해결되는 문제는 모듈 간의 무거운 종속성을 느슨하게 결합하는 것입니다. 상위 모듈은 하위 모듈에 종속되어서는 안 되며 모두 추상화에 의존해야 합니다. 일반적으로 종속성 반전에 대한 간단한 이해는 인터페이스 또는 추상화를 향한 프로그래밍입니다. 다음 예제를 통해 인터페이스 지향 프로그래밍을 살펴보겠습니다.

class Cache{
    public function set($key,$value){
        $redis = new CFile();
        $redis->set($key,$value);
    }
}
class CFile{
    public function set($key,$value){
        echo "file:{$key}->{$value}\n";
    }
}
$cache = new Cache();
$cache->set("name","sunny");

위 코드는 별 문제 없어 보이지만, 어느 날 파일 캐시가 Redis 캐시로 변경된다면 어떨까요?

class Cache{
    public function set($key,$value){
        $redis = new CRedis();
        $redis->set($key,$value);
    }
}
class CRedis{
    public function set($key,$value){
        echo "redis:{$key}->{$value}\n";
    }
}
$cache = new Cache();
$cache->set("name","sunny");

이 코드에서 알 수 있듯이 캐시에서 사용하는 드라이버가 변경되면 캐시 코드도 그에 맞게 변경해야 합니다. 코드가 호출자에 작성되고 결합 정도가 높아지기 때문입니다. 이는 코드를 수정하는 것과 동일하여 프로그래머가 인터페이스에 맞춰 프로그래밍할 수 있도록 하여 코드를 더욱 다양하고 표준화되게 만듭니다.

interface ICache{
    public function set($key,$value);
}
class CRedis implements ICache {
    public function set($key,$value)
{
        echo "redis:{$key}->{$value}\n";
    }
}
class CFile implements ICache{
    public function set($key,$value)
{
        echo "file:{$key}->{$value}\n";
    }
}
class Cache{
    private $drive;
    public function __construct(ICache $drive)
{
        $this->drive = $drive;
    }
    public function set($key,$value){
        $this->drive->set($key,$value);
    }
}
$cache = new Cache(new CFile());
$cache->set("name","sunny");

많은 사람들이 이 코드를 보면 '그냥 원하는 객체를 생성자에 직접 전달하면 되지 않을까?'라고 생각하는 경우가 많습니다. 인터페이스를 정의해야 하는 이유는 무엇입니까? 사실 인터페이스는 코드를 표준화하기 위해 정의된 것입니다. 어떤 드라이버를 사용하든 내 인터페이스만 구현하면 개발자는 개발할 때 드라이버에 어떤 메서드를 포함해야 할지 알 수 없습니다. 운전사. 인터페이스를 사용할 때는 인터페이스에 대해서만 프로그래밍하면 됩니다. 캐시는 클래스가 어떻게 구현되는지에 대해서는 신경 쓰지 않고 인터페이스 메소드에 따라 작동합니다.

한 문장 요약: 종속성 역전으로 느슨한 결합 달성

실용 전투: 컨테이너 원칙을 기반으로 컨테이너 구현

<?php
class Container
{
    // 当前容器对象
    private static $instance;
    // 存放在容器里面到实例
    protected $instances = [];
    private function __construct()
{
    }
    public static function getInstance()
{
        if (!self::$instance) {
            self::$instance = new static();
        }
        return self::$instance;
    }
    /**
     * 获取对象实例
     * @param $key
     * @return mixed
     */
    public function get($key)
{
        if (isset($this->instances[$key])) {
            return $this->instances[$key];
        }
    }
    /**
     * 绑定对象、闭包、类到容器
     * @param $key
     * @param null $concrete
     * @return Container
     */
    public function bind($key, $concrete = null)
{
        if ($concrete instanceof Closure) {
            $this->instances[$key] = $concrete;
        } elseif (is_object($concrete)) {
            $this->instances[$key] = $concrete;
        }
        return $this;
    }
}
class Sunny
{
    public function getName()
{
        echo time() . "\n";
    }
}
$app = Container::getInstance();
$sunny = $app->bind(Sunny::class,new Sunny());
$sunny = $app->get(Sunny::class);
$sunny->getName();

실용 전투: 종속성 주입 구현

Container.php
<?php
class Container
{
    // 当前容器对象
    private static $instance;
    // 存放在容器里面到实例
    protected $instances = [];
    private function __construct()
{
    }
    public static function getInstance()
{
        if (!self::$instance) {
            self::$instance = new static();
        }
        return self::$instance;
    }
    /**
     * 获取对象实例
     * @param $key
     * @return mixed
     * @throws ReflectionException
     */
    public function get($key)
{
        if (isset($this->instances[$key])) {
            return $this->instances[$key];
        }
        return $this->make($key);
    }
    /**
     * 绑定对象、闭包、类到容器
     * @param $key
     * @param null $concrete
     * @return Container
     * @throws ReflectionException
     */
    public function bind($key, $concrete = null)
{
        if ($concrete instanceof Closure) {
            $this->instances[$key] = $concrete;
        } elseif (is_object($concrete)) {
            $this->instances[$key] = $concrete;
        } else {
            $this->make($key, $concrete);
        }
        return $this;
    }
    /**
     * 创建类绑定到类实例
     * @param $abstract
     * @param null $atgs
     * @return mixed
     * @throws ReflectionException
     */
    public function make($abstract, $atgs = null)
{
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }
        $object = $this->invokeClass($abstract);
        $this->instances[$abstract] = $object;
        return $object;
    }
    /**
     * 反射解析类
     * @param $abstract
     * @return object
     * @throws ReflectionException
     */
    public function invokeClass($abstract)
{
        $reflectionClass = new \ReflectionClass($abstract);
        // 获取构造方法
        $construct = $reflectionClass->getConstructor();
        // 获取参数得到实例
        $params = $construct ? $this->parserParams($construct) : [];
        $object = $reflectionClass->newInstanceArgs($params);
        return $object;
    }
    /**
     * 解析构造方法参数
     * @param $reflect
     * @return array
     * @throws ReflectionException
     */
    public function parserParams(ReflectionMethod $reflect)
{
        $args = [];
        $params = $reflect->getParameters();
        if (!$params) {
            return $args;
        }
        if (count($params) > 0) {
            foreach ($params as $param) {
                $class = $param->getClass();
                if ($class) {
                    $args[] = $this->make($class->getName());
                    continue;
                }
                // 获取变量的名称
                $name = $param->getName();
                // 默认值
                $def = null;
                // 如果有默认值，从默认值获取类型
                if ($param->isOptional()) {
                    $def = $param->getDefaultValue();
                }
                $args[] = $_REQUEST[$name] ?? $def;
            }
        }
        return $args;
    }
}
Test.php
<?php
class Test
{
    public $name;
    private $test1;
    public function __construct(Test1 $test1)
{
        $this->test1 = $test1;
        $this->name = $this->test1->getName();
    }
}
Test1.php
<?php
class Test1
{
    public function getName(){
        return "test1返回的名字";
    }
}
Sunny.php
<?php
require_once "./Container.php";
require_once "./Test.php";
require_once "./Test1.php";
class Sunny
{
    private $test;
    public function __construct(Test $test)
{
        $this->test = $test;
    }
    public function getName()
{
        echo "获取test里面的name：{$this->test->name}\n";
    }
}
$app = Container::getInstance();
$sunny = $app->get(Sunny::class);
$sunny->getName();

추천 학습: "PHP 비디오 튜토리얼"

위 내용은 최신 PHP 프레임워크에서 IOC 컨테이너를 이해하고 구현하는 기사 1개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!