Quel est le cœur de Laravel

Le cœur de Laravel est le conteneur de service, qui est le conteneur IOC. Le conteneur fournit une série de services nécessaires dans l'ensemble du framework, notamment l'injection de dépendances et l'inversion de contrôle. L'inversion de contrôle est un principe de conception en programmation orientée objet qui peut être utilisé pour réduire le couplage entre les codes informatiques.

L'environnement d'exploitation de cet article : système Windows 10, Laravel version 6, ordinateur Dell G3.

Quel est le cœur de Laravel

Le conteneur de services, également appelé conteneur IOC, contient en fait deux parties : l'injection de dépendances (DI) et l'inversion de contrôle (IOC), et constitue le véritable noyau de Laravel. Divers autres modules fonctionnels tels que Route (routage), Eloquent ORM (composant ORM de base de données), Request and Response (requête et réponse), etc. sont en fait fournis par des modules de classe qui n'ont rien à voir avec le noyau. De l'instanciation à l'utilisation finale par vous, le conteneur de services de Laravel en est en fait responsable. Le concept de conteneur de services est difficile à expliquer clairement. Il ne peut être expliqué que étape par étape à partir de l'historique du conteneur de services. Ce conteneur fournit une série de services nécessaires dans l'ensemble du framework.

L'histoire de la naissance des conteneurs IoC - L'âge de pierre (Mode Original)

Nous prenons un "Superman" comme classe,

classe Superman {}

On peut imaginer qu'un Superman doit avoir au moins un super pouvoir à sa naissance, ce super pouvoir peut également être abstrait dans un objet. Définissons une classe pour cet objet pour le décrire. Un super pouvoir doit avoir de multiples attributs et méthodes (de fonctionnement). Laissez libre cours à votre imagination, mais pour l'instant nous allons définir grossièrement un "super pouvoir" qui n'a que des attributs. Quant à ce qu'il peut faire, nous l'enrichirons plus tard :

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

. A ce moment, nous revenons en arrière et modifions la classe "Superman" précédente afin qu'un "Superman" reçoive un super pouvoir lors de sa création :

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

Dans ce cas, lorsque nous créons une instance "Superman", nous créons également un "Superman" Cependant, nous avons vu qu'il existe une dépendance inévitable entre "Superman" et "Superpower".

La soi-disant « dépendance » signifie « si je compte sur toi, sans toi il n'y aura pas de moi ».

Dans un projet qui implémente une programmation orientée objet, de telles dépendances sont visibles partout. Une petite quantité de dépendance n’a pas un impact trop intuitif. Au fur et à mesure que nous développons cet exemple, nous réaliserons progressivement à quel point l’expérience est cauchemardesque lorsque la dépendance atteint un certain niveau. Bien sûr, j'expliquerai aussi naturellement comment résoudre le problème.

Dans l'exemple précédent, la classe de superpuissance est un superpuissance spécifique après instanciation, mais nous savons que les superpuissances de Superman sont diversifiées, et les méthodes et attributs de chaque superpuissance sont assez différentes. Il n'y a aucun moyen d'être complètement décrit par une classe. Faisons des modifications maintenant. Supposons que Superman puisse avoir les super pouvoirs suivants :

Vol, les attributs sont : vitesse de vol, durée du vol

force brute, les attributs sont : valeur de force

bombes énergétiques, les attributs sont : valeur de dégâts, tir. distance, nombre de tirs simultanés

Nous avons créé les classes suivantes :

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) {}
}

D'accord, maintenant notre Superman est un peu "occupé". Lorsque Superman sera initialisé, allons-nous instancier ses super pouvoirs si nécessaire ? C'est à peu près comme suit :

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)
        );
        */
    }
}

Nous devons instancier manuellement une série de classes requises dans le constructeur (ou d'autres méthodes), pour que ce ne soit pas bon. Il est concevable que si les besoins changent (différents monstres sévissent sur la terre), que de nouveaux superpuissances plus ciblées soient nécessaires, ou que la méthode d'utilisation des superpuissances doive être modifiée, nous devrons réinventer Superman. Autrement dit, tout en changeant mes super pouvoirs, je dois aussi créer un nouveau surhomme. L'efficacité est trop faible ! Le monde avait déjà été détruit avant la création du nouveau Superman.

À ce moment-là, la personne qui avait une idée a pensé : Pourquoi ça ne peut pas être comme ça ? Les capacités de Superman peuvent être modifiées à tout moment, simplement en ajoutant ou en mettant à jour une puce ou un autre appareil (Iron Man vient à l'esprit). Dans ce cas, il n’est pas nécessaire de recommencer.

L'histoire de la naissance des conteneurs IoC - L'âge du bronze (mode usine)

Nous ne devons pas solidifier manuellement le comportement d'initialisation de ses "super pouvoirs" dans la classe "Superman", mais le tourner vers l'extérieur pour être responsable et créer les superpuissances de l'extérieur. Des modules, des appareils ou des puces (nous les appellerons désormais collectivement « modules ») sont implantés dans une certaine interface dans le corps de Superman. Cette interface est une donnée tant que ce « module ». satisfait l'interface, tout appareil répondant à cette interface peut être utilisé par Superman. Il peut être utilisé pour améliorer et augmenter une certaine capacité de Superman. Ce comportement consistant à rendre le monde extérieur responsable de ses exigences de dépendance peut être appelé « Inversion de contrôle (IoC) ».

Le mode usine, comme son nom l'indique, est un mode de développement dans lequel toutes les instances d'éléments externes dont dépend une classe peuvent être créées par une ou plusieurs "usines", ce qui est le "mode usine".

Afin de fabriquer des modules de superpuissance pour Superman, nous avons créé une usine capable de fabriquer une variété de modules grâce à une seule méthode :

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视频教程】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!