PHP Master | Suntikan pergantungan dengan jerawat

mata teras

Suntikan ketergantungan adalah konsep utama dalam pembangunan aplikasi, dan dengan menyuntik kebergantungan ke dalam modul dan bukannya kod keras mereka, anda boleh menulis kod yang lebih efisien dan lebih mudah dipelihara.
Pimple adalah bekas suntikan ketergantungan yang mudah yang menggunakan penutupan PHP untuk menentukan kebergantungan dengan cara yang boleh diurus, membantu mengekalkan kod anda.
Dua teknik utama untuk suntikan suntikan adalah suntikan ketergantungan berasaskan pembina dan suntikan berasaskan setter, masing-masing dengan kelebihan dan kekurangannya sendiri.
Pimple menyokong prinsip pembangunan perisian kering dengan bertindak sebagai bekas yang mentakrifkan kebergantungan, mengelakkan pertindihan, menjadikannya lebih mudah untuk mengurus dan memusatkan perkhidmatan dalam aplikasi.
Pimple juga menyediakan ciri -ciri canggih seperti keupayaan untuk mengembalikan contoh yang sama menggunakan objek bersama, dan keupayaan untuk mengubahsuai penutupan yang sedia ada secara dinamik tanpa menjejaskan pelaksanaan asal.

Dalam pembangunan aplikasi, kami cuba membuat modul mandiri untuk menggunakan semula kod dalam projek masa depan. Walau bagaimanapun, mewujudkan modul yang sepenuhnya bebas yang menyediakan fungsi yang berguna adalah sukar; Di sinilah suntikan ketergantungan berguna, kerana ia membolehkan kita menyuntik kebergantungan yang diperlukan untuk kod berfungsi dengan baik tanpa kod keras mereka ke dalam modul. Jerawat adalah bekas suntikan pergantungan yang mudah yang menggunakan penutupan PHP untuk menentukan kebergantungan dengan cara yang boleh diurus. Dalam artikel ini, kami akan meneroka masalah ketergantungan keras, bagaimana suntikan ketergantungan menyelesaikan masalah ini, dan bagaimana menggunakan jerawat untuk membuat kod memanfaatkan suntikan ketergantungan lebih mudah untuk dikekalkan.

KEPENTINGAN KEPUTUSAN KEPUTUSAN Apabila menulis aplikasi, kami menggunakan banyak kelas PHP. Kelas mungkin perlu memanggil kaedah satu atau lebih kelas lain untuk menyediakan fungsi yang diharapkan, jadi kami mengatakan bahawa kelas pertama bergantung kepada kelas lain. Contohnya:

Kelas A bergantung pada Kelas B. Jika Kelas B tidak tersedia, kod di atas tidak akan berfungsi. Selain itu, setiap kali kita mengikat kod penciptaan objek di dalam kelas, kita akan mempunyai kebergantungan khusus pada kelas. Ketergantungan khusus adalah penghalang untuk menulis kod yang boleh diuji. Pendekatan yang lebih baik adalah untuk menyediakan objek Kelas B ke Kelas A. Objek ini boleh disediakan oleh pembina atau kaedah setter A. Sebelum kita membincangkan lagi, mari kita lihat senario yang lebih realistik.

Perkongsian kandungan di laman rangkaian sosial sangat biasa pada hari ini, dan kebanyakan laman web secara langsung memaparkan suapan profil sosial mereka di laman web mereka. Katakan kami mempunyai kelas yang dipanggil SocialFeeds yang menjana suapan dari laman sosial seperti Twitter, Facebook, Google, dll. Buat kelas berasingan untuk mengendalikan setiap perkhidmatan ini. Di sini kita akan melihat kelas twitterservice yang berinteraksi dengan Twitter. Kelas SocialFeeds menggunakan Twitterservice untuk meminta suapan Twitter. Twitterservice berinteraksi dengan pangkalan data untuk mendapatkan token pengguna tertentu yang mengakses API. Tanda itu diserahkan kepada kelas OAuth, yang mengambil makanan menggunakan token yang disediakan dan mengembalikannya ke kelas SocialFeeds.

<?php
class A
{
    public function a1() {
        $b = new B();
        $b->b1();
    }
}

<?php
class SocialFeeds
{
    public function getSocialFeeds() {
        $twService = new TwitterService();
        echo $twService->getTweets();
    }
}

<?php
class TwitterService
{
    public function getTweets() {
        $db = new DB();
        $query = "Query to get user token from database";
        $token = $db->getQueryResults($query);

        $oauth = new OAuth();
        return $oauth->requestTwitterFeed($token);
    }
}

<?php
class OAuth
{
    public function requestTwitterFeed($token) {
        // Retrieve and return twitter feed using the token         
    }
}

Adalah jelas bahawa sosialfeeds bergantung pada twitterservice. Tetapi Twitterservice bergantung kepada DB dan OAuth, jadi sosial -sosial bergantung kepada DB dan OAuth secara tidak langsung. Jadi apa masalahnya? SocialFeeds bergantung kepada pelaksanaan konkrit tiga kelas, jadi mustahil untuk menguji sosial secara berasingan tanpa pelaksanaan sebenar kelas lain. Atau, katakan kami ingin menggunakan pangkalan data yang berbeza atau pembekal OAuth yang berbeza. Dalam kes ini, kita perlu menggantikan kelas sedia ada dengan kelas baru sepanjang kod.

Betulkan kebergantungan tertentu

Penyelesaian kepada kebergantungan ini adalah mudah, iaitu secara dinamik menyediakan objek apabila perlu tanpa menggunakan pelaksanaan konkrit. Terdapat dua jenis teknik yang boleh menyuntik kebergantungan: suntikan ketergantungan berasaskan pembina dan suntikan berasaskan setter.

suntikan berasaskan pembina

Menggunakan suntikan ketergantungan berasaskan pembina, objek ketergantungan dicipta secara luaran dan diluluskan sebagai parameter kepada pembina kelas. Kita boleh menetapkan objek ini kepada pembolehubah kelas dan menggunakannya di mana -mana sahaja di dalam kelas. Suntikan berasaskan pembina kelas SocialFeeds adalah seperti berikut:

<?php
class DB
{
    public function getQueryResults($query) {
        // Get results from database and return token
    }
}

Contoh Twitterservice diluluskan sebagai objek kepada pembina. SocialFeeds masih bergantung pada Twitterservice, tetapi sekarang kami bebas untuk menyediakan versi penyedia perkhidmatan Twitter yang berlainan, dan juga objek mengejek untuk tujuan ujian. Mengenai kelas Twitterservice, DB dan OAuth juga ditakrifkan dengan cara yang sama.

<?php
class SocialFeeds
{
    public $twService;

    public function __construct($twService) {
        $this->twService = $twService;
    }

    public function getSocialFeeds() {
        echo $this->twService->getTweets();
    }
}

suntikan berasaskan seter

Menggunakan suntikan berasaskan setter, objek disediakan oleh kaedah setter dan bukannya pembina. Berikut adalah pelaksanaan suntikan ketergantungan berasaskan setter kelas SocialFeeds:

<?php
$db = new DB();
$oauth = new OAuth();
$twService = new TwitterService($db, $oauth);
$socialFeeds = new SocialFeeds($twService);
$socialFeeds->getSocialFeeds();

kod inisialisasi sekarang termasuk db dan oauth kelihatan seperti ini:

<?php
class SocialFeeds
{
    public $twService;

    public function getSocialFeeds() {
        echo $this->twService->getTweets();
    }

    public function setTwitterService($twService) {
        $this->twService = $twService;
    }
}

suntikan pembina dan setter

Pilih suntikan berasaskan pembina atau suntikan berasaskan setter terpulang kepada anda. Suntikan berasaskan pembina adalah sesuai apabila semua kebergantungan diperlukan untuk memberi instantiasi kelas. Suntikan berasaskan setter sesuai apabila kebergantungan tidak diperlukan setiap masa.

Pro

Pembina - Lihat saja pembina kelas untuk mengenal pasti semua kebergantungan kelas

• setor - Menambah kebergantungan baru semudah menambah kaedah setter baru dan tidak memecahkan kod sedia ada

Kekurangan

• Pembina - Menambah kebergantungan baru akan menambah parameter kepada pembina;
setor - kita perlu mencari kebergantungan yang diperlukan secara manual kerana mereka tidak ditentukan di mana sahaja

Selepas memahami suntikan pergantungan dan pelbagai teknik suntikan, sudah tiba masanya untuk melihat jerawat dan bagaimana ia sesuai dengannya.

peranan jerawat dalam di

Apabila kita sudah dapat menyuntik kebergantungan menggunakan teknik yang disebutkan di atas, anda mungkin tertanya -tanya mengapa anda memerlukan jerawat. Untuk menjawab soalan ini, kita perlu melihat prinsip kering.

Jangan ulangi diri anda (kering) adalah prinsip dalam pembangunan perisian yang bertujuan untuk mengurangkan duplikasi pelbagai maklumat, yang sangat berguna dalam seni bina pelbagai lapisan. Pernyataan prinsip kering adalah bahawa "setiap serpihan pengetahuan mesti mempunyai perwakilan tunggal, jelas, berwibawa dalam sistem" - Wikipedia

Pertimbangkan contoh suntikan berasaskan pembina. Setiap kali kita menginginkan objek kelas SocialFeed, kita perlu mengulangi keseluruhan proses persediaan instantiating dan lulus kebergantungannya. Menurut Dry, kod tersebut harus dielakkan untuk mencegah masalah penyelenggaraan. Jerawat bertindak sebagai bekas yang mentakrifkan kebergantungan sedemikian untuk mengelakkan pertindihan. Mari kita lihat contoh mudah untuk melihat bagaimana jerawat berfungsi.

<?php
class A
{
    public function a1() {
        $b = new B();
        $b->b1();
    }
}

Buat contoh jerawat sebagai bekas untuk menyimpan dependensi. Ia melaksanakan antara muka SPL Arrayaccess, jadi menggunakannya sangat serupa dengan menggunakan tatasusunan. Pertama, kita menentukan kunci yang memegang nama mana -mana kelas yang kita mahu. Kami kemudian menentukan penutupan untuk mengembalikan contoh kelas yang ditentukan yang bertindak sebagai perkhidmatan. Perhatikan bahawa contoh bekas akan diluluskan kepada $ C, jadi kita boleh merujuk kepada kunci yang ditakrifkan seperti yang diperlukan; Sekarang, apabila kita mahu contoh kelas, kita boleh merujuk kunci untuk mendapatkan objek tersebut. Mari kita menukar contoh sosial untuk jerawat. Contoh-contoh di laman web Pimple Rasmi menunjukkan suntikan berasaskan pembina, jadi di sini kami akan menggambarkan suntikan berasaskan setter. Ingat bahawa untuk menggunakan jerawat, kita tidak perlu mengubah suai kaedah setter atau kod yang ditakrifkan sebelum ini - kita hanya merangkum logik.

<?php
class SocialFeeds
{
    public function getSocialFeeds() {
        $twService = new TwitterService();
        echo $twService->getTweets();
    }
}

db dan kelas OAuth adalah modul bebas, jadi kami mengembalikan contoh baru mereka secara langsung dalam penutupan. Kami kemudian menggunakan suntikan berasaskan setter untuk menambah kebergantungan ke kelas Twitterservice. Kami telah menambah kelas DB dan OAuth ke bekas, jadi kami boleh mengaksesnya secara langsung di dalam fungsi menggunakan $ C ['DB'] dan $ C ['OAUTH']. Sekarang, kebergantungan dikemas dalam bekas sebagai perkhidmatan. Setiap kali kita mahu menggunakan kelas DB yang berbeza atau perkhidmatan OAuth yang berbeza, kita hanya menggantikan kelas dalam pernyataan kontena dan semuanya akan berjalan dengan sempurna. Dengan jerawat, anda hanya perlu menambah kebergantungan baru di satu tempat.

Penggunaan jerawat lanjutan

Dalam senario di atas, Pimple mengembalikan contoh baru setiap kelas dari penutupan setiap kali ia diminta. Dalam sesetengah kes, kita perlu menggunakan objek yang sama tanpa memulakan contoh baru setiap kali, seperti menyambung ke pangkalan data adalah contoh yang sempurna. Pimple menyediakan keupayaan untuk mengembalikan contoh yang sama menggunakan objek yang dikongsi.

<?php
class A
{
    public function a1() {
        $b = new B();
        $b->b1();
    }
}

Juga, setakat ini kami telah menentukan semua kebergantungan dalam satu lokasi dalam bekas jerawat. Walau bagaimanapun, pertimbangkan satu kes di mana kita memerlukan perkhidmatan yang mempunyai kebergantungannya tetapi dikonfigurasikan sedikit berbeza dari perkhidmatan asal. Sebagai contoh, katakan kita perlu mengakses ORM untuk melaksanakan beberapa fungsi kelas Twitterservice. Kita tidak boleh mengubah penutupan yang sedia ada kerana ia memaksa semua fungsi sedia ada untuk menggunakan ORM. Pimple menyediakan kaedah lanjutan () untuk mengubahsuai penutupan yang sedia ada secara dinamik tanpa menjejaskan pelaksanaan asal. Pertimbangkan kod berikut:

<?php
class SocialFeeds
{
    public function getSocialFeeds() {
        $twService = new TwitterService();
        echo $twService->getTweets();
    }
}

Sekarang, kami dapat menggunakan versi lanjutan yang berbeza dari tweet_service dalam kes -kes khas. Parameter pertama adalah nama perkhidmatan, dan parameter kedua adalah fungsi yang dapat mengakses contoh objek dan bekas. Malah, lanjutan () adalah cara yang kuat untuk menambah kebergantungan secara dinamik untuk memenuhi situasi yang berbeza, tetapi pastikan untuk mengehadkan versi perkhidmatan yang dilanjutkan dengan minimum, kerana ia meningkatkan jumlah kod pendua.

Ringkasan

Menguruskan kebergantungan adalah salah satu tugas yang paling penting dan sukar dalam pembangunan aplikasi web. Kita boleh menggunakan suntikan ketergantungan pembina dan kaedah setter untuk mengurusnya dengan berkesan. Walau bagaimanapun, suntikan pergantungan itu sendiri juga mempunyai beberapa masalah, dan jerawat menyelesaikan masalah ini dengan menyediakan bekas ringan untuk membuat dan menyimpan kebergantungan objek dengan cara yang kering. Jangan ragu untuk berkongsi pengalaman anda menguruskan kebergantungan dalam projek anda dan pemikiran anda mengenai jerawat sebagai bekas suntikan ketergantungan dalam komen di bawah.

Soalan Lazim mengenai Suntikan Ketergantungan dengan Jerawat (Soalan Lazim)

Apakah jerawat dan mengapa ia digunakan dalam php?

Pimple adalah bekas suntikan pergantungan PHP yang mudah yang membolehkan anda mengurus dan memusatkan perkhidmatan dalam aplikasi anda. Ia digunakan dalam PHP, menjadikan kod lebih fleksibel, boleh diguna semula dan lebih mudah untuk diuji. Dengan menggunakan jerawat, anda boleh memberi objek objek di satu tempat dan menyuntiknya ke bahagian -bahagian yang berlainan dari aplikasi anda, mengurangkan keperluan untuk keadaan global dan menjadikan kod anda lebih mudah untuk mengekalkan dan menguji.

bagaimana jerawat berfungsi?

Pimple berfungsi dengan menyimpan definisi perkhidmatan dalam bekas. Definisi ini boleh dipanggil (fungsi atau kaedah) dan mereka mengembalikan contoh perkhidmatan. Apabila anda mengakses perkhidmatan dari bekas, Pimple melaksanakan definisi perkhidmatan untuk membuat objek perkhidmatan. Ini membolehkan anda menguruskan perkhidmatan dengan cara berpusat dan berkongsi perkhidmatan sepanjang permohonan.

bagaimana memasang jerawat?

jerawat boleh dipasang menggunakan komposer (alat pengurusan pergantungan PHP). Anda boleh memasang komposer secara global pada sistem anda dan kemudian memperkenalkan jerawat dalam projek anda dengan menjalankan perintah

.

bagaimana untuk menentukan perkhidmatan dalam jerawat?

Dalam jerawat, anda boleh menentukan perkhidmatan dengan memberikan objek yang boleh dipanggil ke kunci dalam bekas. Objek yang boleh dipanggil harus mengembalikan contoh perkhidmatan. Sebagai contoh, anda boleh menentukan perkhidmatan untuk kelas pengirim mel seperti ini:

$container['mailer'] = function ($c) { return new Mailer($c['smtp']); };

Dalam contoh ini, perkhidmatan pengirim mel ditakrifkan sebagai contoh baru kelas Mailer, di mana perkhidmatan SMTP disuntik sebagai kebergantungan.

Bagaimana untuk mengakses perkhidmatan dalam jerawat?

anda boleh mengakses perkhidmatan dalam jerawat menggunakan notasi array dengan kekunci perkhidmatan. Sebagai contoh, anda boleh mengakses perkhidmatan pengirim mel seperti ini:

. Apabila anda mengakses perkhidmatan, Pimple melaksanakan definisi perkhidmatan dan mengembalikan objek perkhidmatan. $mailer = $container['mailer'];

Bagaimana untuk berkongsi perkhidmatan dalam jerawat?

Secara lalai, Pimple mengembalikan contoh perkhidmatan baru setiap kali ia mengakses perkhidmatan. Jika anda ingin berkongsi perkhidmatan dan mengembalikan contoh yang sama setiap kali, anda boleh menggunakan kaedah

. Sebagai contoh, anda boleh berkongsi perkhidmatan pengirim mel seperti ini: share(). $container['mailer'] = $container->share(function ($c) { return new Mailer($c['smtp']); });

Bolehkah saya melanjutkan perkhidmatan dalam jerawat?

Ya, anda boleh menggunakan kaedah

untuk melanjutkan perkhidmatan dalam jerawat. Ini membolehkan anda mengubah suai perkhidmatan selepas mendefinisikannya. Sebagai contoh, anda boleh melanjutkan perkhidmatan pengirim mel seperti ini untuk menambah konfigurasi tambahan: extend()

$container['mailer'] = $container->extend('mailer', function ($mailer, $c) { $mailer->setFrom($c['email.from']); return $mailer; }); Dalam contoh ini, kaedah

dipanggil pada perkhidmatan pengirim mel menggunakan perkhidmatan

sebagai parameter. setFrom() email.from Bagaimana untuk melindungi parameter dalam jerawat?

Dalam jerawat, anda boleh menggunakan kaedah

untuk melindungi parameter (yang tidak boleh dianggap sebagai parameter perkhidmatan). Ini membolehkan anda menyimpan nilai dalam bekas tanpa merawatnya sebagai definisi perkhidmatan. Sebagai contoh, anda boleh melindungi nilai konfigurasi seperti ini:

. protect() $container['config.value'] = $container->protect(function () { return 'value'; }); Bagaimana menggunakan jerawat dalam projek?

Anda boleh menggunakan jerawat dalam projek dengan membuat contoh baru kelas Pimplecontainer dan menentukan perkhidmatan di sana. Anda kemudian boleh mengakses perkhidmatan dari bekas di mana anda memerlukannya dalam permohonan. Ini membolehkan anda menguruskan perkhidmatan secara berpusat dan menyuntiknya ke bahagian -bahagian yang berlainan dari aplikasi anda.

Apakah faedah menggunakan jerawat?

Pimple menyediakan banyak manfaat untuk pembangunan PHP. Ia menjadikan kod anda lebih fleksibel kerana ia membolehkan anda menguruskan perkhidmatan dengan cara yang berpusat. Ia menjadikan kod anda lebih mudah untuk digunakan semula kerana ia membolehkan anda berkongsi perkhidmatan sepanjang aplikasi anda. Ia menjadikan kod anda lebih mudah untuk diuji kerana ia membolehkan anda menyuntik perkhidmatan mengejek untuk ujian. Dengan menggunakan jerawat, anda boleh meningkatkan kualiti kod anda dan memudahkan untuk mengekalkan dan menguji.

Atas ialah kandungan terperinci PHP Master | Suntikan pergantungan dengan jerawat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!