Apakah inti laravel

Inti laravel ialah bekas perkhidmatan, iaitu bekas IOC. Bekas menyediakan satu siri perkhidmatan yang diperlukan dalam keseluruhan rangka kerja, termasuk suntikan kebergantungan dan penyongsangan kawalan adalah prinsip reka bentuk dalam pengaturcaraan berorientasikan objek yang boleh digunakan untuk mengurangkan gandingan antara kod komputer.

Persekitaran pengendalian artikel ini: sistem Windows 10, Laravel versi 6, komputer Dell G3.

Apakah teras laravel

Bekas perkhidmatan, juga dipanggil bekas IOC, sebenarnya mengandungi dua bahagian: suntikan kebergantungan (DI) dan penyongsangan kawalan (IOC), dan merupakan teras sebenar laravel. Pelbagai modul berfungsi lain seperti Route (perutean), Eloquent ORM (komponen ORM pangkalan data), Permintaan dan Respons (permintaan dan tindak balas), dan lain-lain, sebenarnya disediakan oleh modul kelas yang tiada kaitan dengan teras kelas ini dari Dari instantiasi hingga penggunaan akhir oleh anda, bekas perkhidmatan laravel sebenarnya bertanggungjawab untuknya. Konsep bekas perkhidmatan sukar untuk dijelaskan dengan jelas Ia hanya boleh dijelaskan langkah demi langkah dari sejarah bekas perkhidmatan

Bekas ini menyediakan satu siri perkhidmatan yang diperlukan dalam keseluruhan rangka kerja.

Kisah kelahiran kontena IoC - Zaman Batu (mod asal)

Kami menganggap "Superman" sebagai kelas,

kelas Superman {}

Kita boleh bayangkan bahawa seorang superman mesti mempunyai sekurang-kurangnya satu kuasa besar apabila dia dilahirkan. Kuasa besar ini juga boleh disarikan kepada objek. Kuasa besar mesti mempunyai pelbagai atribut dan kaedah (operasi) Anda boleh bayangkan ini secara bebas, tetapi buat masa ini kami akan mentakrifkan secara kasar "kuasa besar" yang hanya mempunyai atribut, kami akan mengembangkannya kemudian:

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

Pada masa ini kita kembali dan mengubah suai kelas "Superman" sebelum ini supaya "Superman" diberi kuasa super apabila ia dicipta:

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

Dalam kes ini, apabila kita mencipta "Superman" "Instance, contoh "superpower" juga dicipta. Walau bagaimanapun, kita telah melihat bahawa terdapat pergantungan yang tidak dapat dielakkan antara "superman" dan "superpower".

Apa yang dipanggil "pergantungan" bermaksud "jika saya bergantung pada anda, tidak akan ada saya tanpa anda."

Dalam projek yang melaksanakan pengaturcaraan berorientasikan objek, kebergantungan sedemikian boleh dilihat di mana-mana sahaja. Sebilangan kecil pergantungan tidak mempunyai kesan yang terlalu intuitif Apabila kita membongkar contoh ini secara beransur-ansur, kita secara beransur-ansur akan menyedari betapa mimpi buruknya apabila pergantungan itu mencapai tahap tertentu. Sudah tentu, saya juga secara semula jadi akan menerangkan cara menyelesaikan masalah itu.

Dalam contoh sebelumnya, kelas kuasa besar ialah kuasa besar tertentu selepas instantiasi, tetapi kita tahu bahawa kuasa besar Superman dipelbagaikan, dan setiap kuasa besar mempunyai kaedah dan sifat tersendiri Perbezaannya tidak boleh dihuraikan sepenuhnya oleh satu jenis. Mari kita buat pengubahsuaian sekarang. Mari kita andaikan bahawa Superman boleh mempunyai kuasa besar berikut:

Terbang, atribut ialah: kelajuan penerbangan, tempoh penerbangan

brute force, atribut ialah: nilai kekuatan

Bom tenaga, atribut termasuk: nilai kerosakan, jarak menembak, bilangan pukulan serentak

Kami telah mencipta kelas berikut:

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

Baiklah, sekarang Superman kami agak " Sibuk ". Apabila Superman dimulakan, adakah kita akan membuat instantiat kuasa-kuasa besarnya seperti yang diperlukan secara kasarnya seperti berikut:

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

Kita perlu membuat instantiat secara manual dalam pembina (atau kaedah lain) Kelas yang diperlukan oleh siri ini bukan? baik. Ia boleh difikirkan bahawa jika keperluan berubah (raksasa yang berbeza berleluasa di bumi), lebih banyak kuasa besar baru yang disasarkan diperlukan, atau kaedah kuasa besar perlu diubah, kita mesti mencipta semula Superman. Dalam erti kata lain, sambil menukar kuasa besar saya, saya juga perlu mencipta superman baru. Kecekapan terlalu rendah! Dunia telah pun musnah sebelum Superman baharu dicipta.

Pada masa ini, orang yang mempunyai idea berfikir: Kenapa tidak boleh jadi begini? Kebolehan Superman boleh diubah pada bila-bila masa, hanya dengan menambah atau mengemas kini cip atau peranti lain (Iron Man terlintas di fikiran). Dalam kes ini, tidak perlu bermula semula.

Kisah Kelahiran Kontena IoC - Zaman Gangsa (Mod Kilang)

Kita tidak seharusnya secara manual mengukuhkan tingkah laku permulaan "kuasa besar" beliau dalam kelas "Superman", tetapi sebaliknya The luar bertanggungjawab untuk mencipta modul kuasa besar, peranti atau cip dari luar (kami akan merujuknya sebagai "modul" mulai sekarang), dan menanamnya ke dalam antara muka tertentu dalam badan Superman Antara muka ini diberikan, selagi ini ". modul" memuaskan Peranti dalam antara muka ini boleh digunakan oleh Superman untuk meningkatkan dan meningkatkan keupayaan Superman tertentu. Tingkah laku yang menjadikan dunia luar bertanggungjawab terhadap keperluan pergantungannya boleh dipanggil "Penyongsangan Kawalan (IoC)".

Mod kilang, seperti namanya, ialah mod pembangunan di mana semua kejadian perkara luaran yang bergantung kepada kelas boleh dibuat oleh satu atau lebih "kilang", iaitu "mod kilang".

Untuk membuat modul kuasa besar untuk Superman, kami mencipta kilang yang boleh membuat pelbagai modul melalui hanya satu kaedah:

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

Atas ialah kandungan terperinci Apakah inti laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!