Was ist der Kern von Laravel?

Der Kern von Laravel ist der Service-Container, der IOC-Container. Der Container stellt eine Reihe von Diensten bereit, die im gesamten Framework benötigt werden, einschließlich Abhängigkeitsinjektion und Kontrollinversion. Die Umkehrung der Kontrolle ist ein Entwurfsprinzip in der objektorientierten Programmierung, das verwendet werden kann, um die Kopplung zwischen Computercodes zu reduzieren.

Die Betriebsumgebung dieses Artikels: Windows 10-System, Laravel Version 6, Dell G3-Computer.

Was ist der Kern von Laravel? Der Service-Container, auch IOC-Container genannt, besteht tatsächlich aus zwei Teilen: Abhängigkeitsinjektion (DI) und Inversion of Control (IOC) und ist der eigentliche Kern von Laravel. Verschiedene andere Funktionsmodule wie Route (Routing), Eloquent ORM (Datenbank-ORM-Komponente), Request and Response (Anfrage und Antwort) usw. werden tatsächlich von Klassenmodulen bereitgestellt, die nichts mit dem Kern zu tun haben. Diese Klassen werden von registriert Von der Instanziierung bis zur endgültigen Verwendung durch Sie ist der Service-Container von Laravel tatsächlich dafür verantwortlich. Das Konzept des Service-Containers lässt sich nur Schritt für Schritt anhand der Geschichte des Service-Containers erklären. Dieser Container stellt eine Reihe von Diensten bereit, die im gesamten Framework benötigt werden.

Die Geschichte der Geburt von IoC-Containern – Die Steinzeit (Originalmodus)

Wir nehmen einen „Superman“ als Klasse,

Klasse Superman {}

Wir können uns vorstellen, dass ein Superman mindestens eine Superkraft haben muss Wenn er geboren wird, kann diese Superkraft auch in ein Objekt abstrahiert werden. Definieren wir eine Klasse für dieses Objekt, um es zu beschreiben. Eine Supermacht muss mehrere Attribute und (Operations-)Methoden haben. Sie können sich das frei vorstellen, aber zunächst werden wir eine „Supermacht“, die nur Attribute hat, grob definieren. Was sie kann, werden wir später bereichern:

class Power {
    /**
     * 能力值
     */
    protected $ability;
    /**
     * 能力范围或距离
     */
    protected $range;
    public function __construct($ability, $range)
    {
        $this->ability = $ability;
        $this->range = $range;
    }
}

Zu diesem Zeitpunkt gehen wir zurück und modifizieren die vorherige „Superman“-Klasse, sodass ein „Superman“ bei seiner Erstellung eine Superkraft erhält:

class Superman
{
    protected $power;
    public function __construct()
    {
        $this->power = new Power(999, 100);
    }
}

In diesem Fall erstellen wir beim Erstellen einer „Superman“-Instanz auch eine „Superman“ Wir haben jedoch gesehen, dass zwischen „Superman“ und „Superpower“ eine unvermeidliche Abhängigkeit besteht.

Die sogenannte „Abhängigkeit“ bedeutet „Wenn ich mich auf dich verlasse, gibt es mich ohne dich nicht.“

In einem Projekt, das objektorientierte Programmierung implementiert, sind solche Abhängigkeiten überall zu sehen. Ein geringes Maß an Abhängigkeit hat keine sehr intuitive Wirkung. Wenn wir dieses Beispiel nach und nach entfalten, werden wir nach und nach erkennen, was für ein Albtraumerlebnis es ist, wenn die Abhängigkeit ein bestimmtes Maß erreicht. Natürlich erkläre ich Ihnen auch selbstverständlich, wie Sie das Problem lösen können.

Im vorherigen Beispiel ist die Supermachtklasse nach der Instanziierung eine bestimmte Supermacht, aber wir wissen, dass Supermans Superkräfte vielfältig sind und die Methoden und Attribute jeder Supermacht sehr unterschiedlich sind. Es gibt keine Möglichkeit, sie vollständig durch eine Klasse zu beschreiben. Nehmen wir nun Änderungen vor. Nehmen wir an, dass Superman die folgenden Superkräfte haben kann:

Fliegen, Attribute sind: Fluggeschwindigkeit, Flugdauer

Brute Force, Attribute sind: Stärkewert

Energiebomben, Attribute sind: Schadenswert, Schießen Entfernung, Anzahl gleichzeitiger Schüsse

Wir haben folgende Klassen erstellt:

class Flight
{
    protected $speed;
    protected $holdtime;
    public function __construct($speed, $holdtime) {}
}
class Force
{
    protected $force;
    public function __construct($force) {}
}
class Shot
{
    protected $atk;
    protected $range;
    protected $limit;
    public function __construct($atk, $range, $limit) {}
}

Okay, jetzt ist unser Superman etwas „beschäftigt“. Wenn Superman initialisiert wird, werden wir seine Superkräfte nach Bedarf instanziieren? Das ist ungefähr wie folgt:

class Superman
{
    protected $power;
    public function __construct()
    {
        $this->power = new Fight(9, 100);
        // $this->power = new Force(45);
        // $this->power = new Shot(99, 50, 2);
        /*
        $this->power = array(
            new Force(45),
            new Shot(99, 50, 2)
        );
        */
    }
}

Wir müssen eine Reihe erforderlicher Klassen im Konstruktor (oder anderen Methoden) manuell instanziieren, also nicht gut. Es ist denkbar, dass wir Superman neu erfinden müssen, wenn sich die Bedürfnisse ändern (verschiedene Monster wuchern auf der Erde), gezieltere neue Superkräfte benötigt werden oder die Methode der Superkräfte geändert werden muss. Mit anderen Worten: Während ich meine Superkräfte ändere, muss ich auch einen neuen Supermann erschaffen. Der Wirkungsgrad ist zu gering! Die Welt war bereits zerstört, bevor der neue Superman erschaffen wurde.

Zu diesem Zeitpunkt dachte die Person mit einer Idee: Warum kann das nicht so sein? Supermans Fähigkeiten können jederzeit geändert werden, indem einfach ein Chip oder ein anderes Gerät hinzugefügt oder aktualisiert wird (da fällt mir Iron Man ein). In diesem Fall ist es nicht nötig, noch einmal von vorne zu beginnen.

Die Geschichte der Geburt von IoC-Containern – Die Bronzezeit (Fabrikmodus)

Wir sollten das Verhalten der Initialisierung seiner „Superkräfte“ in der „Superman“-Klasse nicht manuell festigen, sondern es nach außen wenden, um verantwortungsvoll zu sein und Die Superkräfte werden von außen erzeugt (wir werden sie im Folgenden zusammenfassend als „Module“ bezeichnen). Diese Schnittstelle ist eine Selbstverständlichkeit. Erfüllt die Schnittstelle, kann jedes Gerät, das diese Schnittstelle erfüllt, von Superman verwendet werden. Es kann verwendet werden, um eine bestimmte Fähigkeit von Superman zu verbessern und zu steigern. Dieses Verhalten, die Außenwelt für ihre Abhängigkeitsanforderungen verantwortlich zu machen, kann als „Inversion of Control (IoC)“ bezeichnet werden.

Der Fabrikmodus ist, wie der Name schon sagt, ein Entwicklungsmodus, in dem alle Instanzen externer Dinge, von denen eine Klasse abhängt, von einer oder mehreren „Fabriken“ erstellt werden können, dem „Fabrikmodus“.

Um Supermachtmodule für Superman herzustellen, haben wir eine Fabrik geschaffen, die eine Vielzahl von Modulen mit nur einer Methode herstellen kann:

class SuperModuleFactory
{
    public function makeModule($moduleName, $options)
    {
        switch ($moduleName) {
            case 'Fight':     return new Fight($options[0], $options[1]);
            case 'Force':     return new Force($options[0]);
            case 'Shot':     return new Shot($options[0], $options[1], $options[2]);
        }
    }
}

这时候，超人 创建之初就可以使用这个工厂！

class Superman
{
    protected $power;
    public function __construct()
    {
        // 初始化工厂
        $factory = new SuperModuleFactory;
        // 通过工厂提供的方法制造需要的模块
        $this->power = $factory->makeModule('Fight', [9, 100]);
        // $this->power = $factory->makeModule('Force', [45]);
        // $this->power = $factory->makeModule('Shot', [99, 50, 2]);
        /*
        $this->power = array(
            $factory->makeModule('Force', [45]),
            $factory->makeModule('Shot', [99, 50, 2])
        );
        */
    }
}

可以看得出，我们不再需要在超人初始化之初，去初始化许多第三方类，只需初始化一个工厂类，即可满足需求。但这样似乎和以前区别不大，只是没有那么多 new 关键字。其实我们稍微改造一下这个类，你就明白，工厂类的真正意义和价值了。

class Superman
{
    protected $power;
    public function __construct(array $modules)
    {
        // 初始化工厂
        $factory = new SuperModuleFactory;
        // 通过工厂提供的方法制造需要的模块
        foreach ($modules as $moduleName => $moduleOptions) {
            $this->power[] = $factory->makeModule($moduleName, $moduleOptions);
        }
    }
}
// 创建超人
$superman = new Superman([
    'Fight' => [9, 100],
    'Shot' => [99, 50, 2]
    ]);

现在修改的结果令人满意。现在，“超人” 的创建不再依赖任何一个 “超能力” 的类，我们如若修改了或者增加了新的超能力，只需要针对修改 SuperModuleFactory 即可。

【相关推荐：laravel视频教程】

Das obige ist der detaillierte Inhalt vonWas ist der Kern von Laravel?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!