Ein Artikel zum Verständnis und zur Implementierung von IOC-Containern in modernen PHP-Frameworks

Dieser Artikel bringt Ihnen relevantes Wissen über PHP, das hauptsächlich den relevanten Inhalt zu IOC-Containern vorstellt. Der vollständige Name von IOC lautet: Schauen wir uns das gemeinsam an an alle. Hilfreich.

Was ist ein Container?

Ich glaube, viele Menschen haben von der Implementierung von Abhängigkeitsinjektionen gehört. Container werden zur Verwaltung von Klassenabhängigkeiten und -injektionen verwendet und sind für die Dienstverwaltung und Entkopplung von Komponenten verantwortlich Kann Container ablegen. Verstehen Sie es als ein supergroßes Array, das der Speicherung von Objekten gewidmet ist.

Wie in der Abbildung gezeigt, erhält der Aufrufer die Objektinstanz über die Bezeichnung des Containers. Wie im Bild zu sehen ist, kann sie über ::class oder direkt über die Objektbezeichnung abgerufen werden.

Was ist IOC?

Vielleicht haben Sie schon einmal von IOC-Containern gehört. Der vollständige Name von IOC lautet: (Inversion Of Control).

Lassen Sie uns verstehen, was die Umkehrung der Kontrolle ist. In unserer traditionellen Codierung bestehen unsere Abhängigkeiten zwischen Klassen normalerweise darin, dass wir durch Codierung neue Objekte erstellen und diese dann weitergeben. Mit der Umkehrung der Kontrolle können wir die Kontrolle an den Container oder das Framework weitergeben implementieren. Der Zweck besteht darin, es uns zu ermöglichen, Objekte ohne harte Codierung zu erstellen. Wie Sie in Abbildung 1 sehen können, sind im Container viele Objekte gespeichert, die direkt verwendet werden können, wenn wir sie verwenden möchten. Für die Objekte im Container müssen wir sie nicht im Code erstellen. Wenn ein bestimmtes Klassenobjekt benötigt wird, wird das Objekt aus dem Container abgerufen. Wenn das Objekt nicht vorhanden ist, wird es automatisch erstellt. Dies bedeutet, dass wir den Prozess der Objekterstellung im Code weglassen und der Container uns dabei hilft, diesen Erstellungsprozess zu realisieren. Dies wird als Inversionskontrolle bezeichnet. Um IOC in einem Satz zusammenzufassen: Übertragen Sie die Kontrolle über die Erstellung von Objekten auf die Instanziierung der Container-Implementierungsklasse.

Zum Beispiel: Wenn wir eine Klasse ohne Verwendung von IOC

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

erstellen möchten, müssen wir manuell eine neue Klasse erstellen. In diesem Fall ist sie im Code fest codiert.

Der Code, der den IOC-Container verwendet, kann so geschrieben werden.

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

Helfen Sie uns, diesen Kurs im Container zu implementieren. Wenn ich das neue Sunny verwende, wird der Code dann nicht kürzer und einfacher sein. Schauen wir uns ein Beispiel an, nachdem wir uns die Abhängigkeitsinjektion angesehen haben.

Abhängigkeitsinjektion

Da wir nun wissen, was IOC ist, stellt sich eine neue Frage: Was sollen wir tun, wenn die Konstruktoren einiger Klassen von uns die Übergabe von Parametern verlangen? Durch das Studium von IOC wissen wir, dass der IOC-Container uns bei der Lösung des Problems der Objektinstanzerstellung hilft. Wenn er beim Erstellen eines Objekts im Container feststellt, dass die Klasse andere Abhängigkeiten aufweist Der Container, der die erforderlichen Objekte findet, wird DL (Dependency Lookup, Abhängigkeitssuche) genannt. Das Einfügen erforderlicher Abhängigkeiten in Codefragmente wird als DI (Dependency Injection, Abhängigkeitsinjektion) bezeichnet.

Zum Beispiel das im IOC erwähnte neue Sunny-Beispiel. Wenn mehrere Abhängigkeiten zwischen Klassen bestehen.

<?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();

Hier können Sie sehen, dass die Sunny-Klasse für die Programmierung auf die Computer-Klasse angewiesen ist. Wenn Sie den IOC-Container zum Implementieren der Abhängigkeitsinjektion verwenden, ist der Code einfach.

<?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();

Zusammenfassung in einem Satz: Lösen Sie beim Erstellen von Klasseninstanzen die Abhängigkeiten von anderen Klassen und stellen Sie einem Objekt dynamisch andere benötigte Objekte zur Verfügung.

Abhängigkeitsinversion

Das durch die Abhängigkeitsinversion gelöste Problem besteht darin, die starken Abhängigkeiten zwischen Modulen lose zu koppeln. Die oberen Module sollten nicht von den unteren Modulen abhängen, sie sollten alle auf Abstraktionen basieren. Normalerweise besteht ein einfaches Verständnis der Abhängigkeitsinversion darin, in Richtung Schnittstellen oder Abstraktionen zu programmieren. Schauen wir uns die schnittstellenorientierte Programmierung anhand des folgenden Beispiels an.

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");

Der obige Code scheint kein großes Problem zu haben, aber was ist, wenn der Dateicache eines Tages in Redis-Cache geändert wird?

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");

Aus diesem Code ist ersichtlich, dass bei einer Änderung des von einem Cache verwendeten Treibers auch der Cache-Code entsprechende Änderungen vornehmen muss, da der Code auf den Aufrufer geschrieben wird und der Kopplungsgrad höher wird. Es ist das Gleiche wie das Ändern des Codes und ermöglicht es Programmierern, in Richtung der Schnittstelle zu programmieren, wodurch der Code vielseitiger und standardisierter wird.

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");

Viele Leute denken, wenn sie diesen Code sehen, sollte ich das gewünschte Objekt nicht einfach direkt an den Konstruktor übergeben? Warum müssen wir eine Schnittstelle definieren? Tatsächlich ist die Schnittstelle so definiert, dass sie den Code standardisiert, solange sie meine Schnittstelle implementiert. Ohne eine Schnittstelle wissen Entwickler nicht, welche Methoden in den Treiber aufgenommen werden sollen der Fahrer. Wenn wir eine Schnittstelle verwenden, müssen wir nur für die Schnittstelle programmieren. Der Cache kümmert sich nicht darum, wie die Klasse nur gemäß der Schnittstellenmethode funktioniert.

Zusammenfassung in einem Satz: Abhängigkeitsumkehr erreicht lose Kopplung

Praktischer Kampf: Implementieren Sie Container basierend auf Containerprinzipien

<?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();

Praktischer Kampf: Implementieren Sie die Abhängigkeitsinjektion

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();

Empfohlenes Lernen: „PHP-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonEin Artikel zum Verständnis und zur Implementierung von IOC-Containern in modernen PHP-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!