Suntikan ketergantungan dengan Laravel ' s IOC

Sebagai pemaju, kami sentiasa berusaha mencari cara baru untuk menulis kod yang direka dengan baik dan bersih dengan mengadopsi gaya baru, menggunakan corak reka bentuk, dan mencuba rangka kerja baru yang mantap. Dalam artikel ini, kami akan meneroka corak reka bentuk suntikan ketergantungan melalui komponen IOC Laravel dan melihat bagaimana ia dapat memperbaiki reka bentuk kami.

Takeaways Key

Suntikan Ketergantungan (DI) adalah corak reka bentuk yang membolehkan decoupling kebergantungan keras, menjadikan kod lebih fleksibel, boleh diguna semula, dan lebih mudah untuk diuji. Dalam IOC Laravel (penyongsangan kawalan), ini dicapai dengan meluluskan kebergantungan yang diperlukan ke dalam objek secara luaran dan bukannya mempunyai objek yang membuat kebergantungan atau meminta objek kilang untuk membuatnya.
• bekas IOC Laravel adalah alat yang berkuasa untuk menguruskan dependensi kelas. Ia mengawal bagaimana objek yang berbeza diselesaikan dan dibuat. Apabila kelas mempunyai kebergantungan, bekas secara automatik menyuntikkannya apabila kelas itu dimanfaatkan melalui proses yang disebut "pendawaian auto".
• Perkhidmatan boleh terikat kepada bekas IOC Laravel menggunakan kaedah pengikat. Kaedah ini menerima dua hujah: nama kelas atau antara muka yang akan digunakan semasa menyelesaikan perkhidmatan, dan penutupan yang mengembalikan contoh kelas. Penutupan akan menerima contoh kontena, yang membolehkan anda menyelesaikan sebarang kebergantungan lain yang diperlukan untuk menyegarkan kelas.
• bekas IOC Laravel juga membolehkan mengikat antara muka. Ini membolehkan anda mengikat antara muka kepada pelaksanaan yang diberikan. Kemudian, apabila antara muka diminta, bekas akan menyuntik pelaksanaan terikat. Ini seterusnya meningkatkan fleksibiliti dan kebolehgunaan semula kod.
Suntikan Ketergantungan

Suntikan ketergantungan adalah istilah yang dicipta oleh Martin Fowler, dan ia adalah tindakan suntikan komponen ke dalam permohonan anda. Seperti Ward Cunningham berkata:

Suntikan ketergantungan adalah elemen utama seni bina tangkas.

mari kita lihat contoh:

Jika anda ingin menguji atau mengekalkan kelas ini, anda perlu mengakses pangkalan data sebenar dan melakukan beberapa pertanyaan. Untuk mengelakkan daripada melakukan itu dan untuk

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct(){
</span>        <span>$this->connection = new Connection;
</span>    <span>}
</span>    
    <span>public function retrieveByCredentials( array $credentials ){
</span>        <span>$user = $this->connection
</span>                        <span>->where( 'email', $credentials['email'])
</span>                        <span>->where( 'password', $credentials['password'])
</span>                        <span>->first();
</span>                        
        <span>return $user;
</span>    <span>}
</span><span>}</span>

decouple

kelas dari yang lain, anda mempunyai satu daripada tiga pilihan untuk menyuntik kelas sambungan tanpa menggunakannya secara langsung. Apabila menyuntik komponen ke dalam kelas anda, anda boleh menggunakan salah satu daripada tiga pilihan:

Suntikan Pembina

suntikan setter

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

Begitu juga kita boleh menyuntik kebergantungan kita menggunakan kaedah setter:

Suntikan antara muka

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    <span>public function __construct(){
</span>        <span>...
</span>    <span>}
</span>    
    <span>public function setConnection( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

Apabila kelas melaksanakan antara muka kami, kami menentukan kaedah suntikan untuk menyelesaikan pergantungan.

<span>interface ConnectionInjector{
</span>    <span>public function injectConnection( Connection $con );
</span><span>}
</span>
<span>class UserProvider implements ConnectionInjector{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct(){
</span>        <span>...
</span>    <span>}
</span>    
    <span>public function injectConnection( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span><span>}</span>

Kelebihan

Sekarang, ketika menguji kelas kita, kita dapat mengejek kelas pergantungan dan lulus sebagai parameter. Setiap kelas mesti difokuskan pada tugas tertentu dan tidak perlu bimbang dengan menyelesaikan kebergantungan mereka. Dengan cara itu, anda akan mempunyai aplikasi yang lebih fokus dan boleh dipelihara.

Jika anda ingin mengetahui lebih lanjut mengenai DI, Alejandro Gervassio meliputi secara meluas dan profesional dalam siri ini, jadi pastikan anda memberi artikel -artikel ini dibaca. Sekarang, bagaimana dengan IOC? IOC (penyongsangan kawalan) tidak perlu menggunakan suntikan ketergantungan, tetapi ia dapat membantu anda menguruskan kebergantungan anda dengan berkesan.

penyongsangan kawalan

IOC adalah komponen mudah yang menjadikan kebergantungan menyelesaikan lebih mudah. Anda menerangkan objek anda ke bekas, dan setiap kali anda menyelesaikan kelas, kebergantungan disuntik secara automatik.

Laravel IOC

Laravel IOC entah bagaimana istimewa dengan cara menyelesaikan dependensi, apabila anda meminta objek:

Kami akan menggunakan contoh mudah yang akan kami tingkatkan semasa artikel ini.

Kelas Simpleauth mempunyai kebergantungan FileSessionStorage, jadi kod kami mungkin kelihatan seperti ini:

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct(){
</span>        <span>$this->connection = new Connection;
</span>    <span>}
</span>    
    <span>public function retrieveByCredentials( array $credentials ){
</span>        <span>$user = $this->connection
</span>                        <span>->where( 'email', $credentials['email'])
</span>                        <span>->where( 'password', $credentials['password'])
</span>                        <span>->first();
</span>                        
        <span>return $user;
</span>    <span>}
</span><span>}</span>

Ini adalah cara klasik untuk melakukannya, mari kita mulakan dengan menggunakan suntikan pembina.

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

Sekarang kita buat objek kita:

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    <span>public function __construct(){
</span>        <span>...
</span>    <span>}
</span>    
    <span>public function setConnection( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

sekarang saya mahu menggunakan Laravel IOC untuk menguruskan semua itu.

Kerana kelas aplikasi memanjangkan kelas kontena, anda sentiasa boleh mengakses bekas melalui fasad aplikasi.

<span>interface ConnectionInjector{
</span>    <span>public function injectConnection( Connection $con );
</span><span>}
</span>
<span>class UserProvider implements ConnectionInjector{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct(){
</span>        <span>...
</span>    <span>}
</span>    
    <span>public function injectConnection( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span><span>}</span>

parameter pertama untuk kaedah pengikat adalah ID unik untuk mengikat pada bekas, yang kedua adalah fungsi panggil balik yang akan dilaksanakan setiap kali kita menyelesaikan kelas FileSessionStorage, kita juga boleh lulus rentetan yang mewakili nama kelas seperti yang kita akan lihat Seterusnya.

Nota: Jika anda memeriksa pakej Laravel, anda akan mengikat kadang -kadang dikumpulkan seperti (Lihat, Lihat.Finder ..).

katakan bahawa mungkin kita mahu menukar storan sesi kami ke MySQL, kelas kami harus sama dengan:

<span>class FileSessionStorage{
</span>  <span>public function __construct(){
</span>    <span>session_start();
</span>  <span>}
</span>  
  <span>public function get( $key ){
</span>    <span>return $_SESSION[$key];
</span>  <span>}
</span>
  <span>public function set( $key, $value ){
</span>    <span>$_SESSION[$key] = $value;
</span>  <span>}
</span><span>}
</span>
<span>class SimpleAuth{
</span>  <span>protected $session;
</span>
  <span>public function __construct(){
</span>    <span>$this->session = new FileSessionStorage;
</span>  <span>}
</span><span>}
</span>
<span>//creating a SimpleAuth
</span><span>$auth = new SimpleAuth();</span>

Sekarang kita telah mengubah ketergantungan, kita perlu menukar pembina Simpleauth dan mengikat objek baru ke bekas!

Modul tahap tinggi tidak boleh bergantung kepada modul tahap rendah. Kedua -dua

harus bergantung kepada abstraksi.
Abstraksi tidak boleh bergantung kepada butiran. Butiran harus bergantung
apabila abstraksi.
Robert C. Martin

Kelas Simpleauth kami tidak perlu prihatin tentang bagaimana storan kami dilakukan, sebaliknya ia harus memberi tumpuan lebih kepada hanya memakan perkhidmatan.

jadi kita boleh abstrak pelaksanaan penyimpanan kita:

Dengan cara ini kita hanya dapat melaksanakan dan meminta contoh antara muka sessionStorage:

<span>class SimpleAuth{
</span>  <span>protected $session;
</span>
  <span>public function __construct( FileSessionStorage $session ){
</span>    <span>$this->session = $session;
</span>  <span>}
</span><span>}</span>

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct(){
</span>        <span>$this->connection = new Connection;
</span>    <span>}
</span>    
    <span>public function retrieveByCredentials( array $credentials ){
</span>        <span>$user = $this->connection
</span>                        <span>->where( 'email', $credentials['email'])
</span>                        <span>->where( 'password', $credentials['password'])
</span>                        <span>->first();
</span>                        
        <span>return $user;
</span>    <span>}
</span><span>}</span>

Jika kita cuba menyelesaikan kelas Simpleauth melalui bekas menggunakan App :: Make ('Simpleauth'), bekas akan membuang BindingResolutionException, setelah cuba menyelesaikan kelas dari pengikatan, kembali ke kaedah refleksi dan menyelesaikannya semua kebergantungan.

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    
    <span>public function __construct( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

Bekas cuba untuk memberi instantiasi antara muka. Kita boleh membetulkannya dengan membuat pengikatan khusus untuk antara muka kita.

<span>class UserProvider{
</span>    <span>protected $connection;
</span>    <span>public function __construct(){
</span>        <span>...
</span>    <span>}
</span>    
    <span>public function setConnection( Connection $con ){
</span>        <span>$this->connection = $con;
</span>    <span>}
</span>    <span>...</span>

Sekarang setiap kali kita cuba menyelesaikan antara muka melalui bekas, kita akan mendapat contoh MySqlSessionStorage. Sekiranya kami mahu menukar perkhidmatan storan kami, kami hanya dapat mengemas kini pengikatan.

Nota: Jika anda ingin melihat sama ada kelas terikat pada bekas, anda boleh menggunakan apl :: terikat ('classname') atau gunakan apl :: bindif ('classname') untuk mendaftarkan pengikatan jika ia tidak mempunyai ' t sudah didaftarkan.

Laravel IOC juga menawarkan App :: Singleton ('ClassName', 'Resolver') untuk pengikatan bersama.

Anda juga boleh menggunakan App :: Instance ('ClassName', 'Instance') untuk membuat contoh bersama.
Sekiranya bekas tidak dapat menyelesaikan kebergantungan, ia akan membuang refleksiException, tetapi kita boleh menggunakan aplikasinya :: resolvingyAny (penutupan) untuk menyelesaikan sebarang jenis yang diberikan atau sebagai bentuk sandaran.

Nota: Jika anda mendaftarkan resolver untuk jenis yang diberikan, kaedah ResolvingAny juga akan dipanggil, tetapi nilai dari kaedah pengikat dikembalikan.

Petua Akhir

di mana untuk menyimpan pengikatan:
• Jika anda hanya mempunyai aplikasi kecil, anda boleh menggunakan global/start.php anda, tetapi jika projek anda semakin besar, anda mesti menggunakan pembekal perkhidmatan.
  
Ujian:
• Apabila anda hanya menguji, anda perlu mempertimbangkan menggunakan PHP Artisan Tinker, ia sangat kuat, dan boleh meningkatkan aliran kerja ujian Laravel anda.
  
Refleksi API: API Refleksi PHP sangat kuat dan jika anda ingin memahami Laravel IOC yang anda perlukan untuk mengenali API Refleksi, pastikan anda menyemak tutorial ini untuk maklumat lanjut.
• 
  Kesimpulan

seperti biasa, cara terbaik untuk mengetahui sesuatu ialah memeriksa kod sumber. Laravel IOC hanya satu fail dan tidak boleh membawa anda lama untuk melalui semua fungsi. Adakah anda ingin mengetahui lebih lanjut mengenai Laravel IOC atau IOC secara umum? Marilah kita tahu!

Soalan -soalan yang sering ditanya mengenai suntikan ketergantungan dalam IOC Laravel

Apakah tujuan utama suntikan ketergantungan dalam IOC Laravel? Ini bermakna bahawa bukannya mempunyai objek anda yang mewujudkan kebergantungan atau meminta objek kilang untuk membuatnya untuk mereka, anda lulus kebergantungan yang diperlukan ke dalam objek secara luaran. Ini menjadikan kod anda lebih fleksibel, boleh diguna semula, dan lebih mudah untuk diuji kerana anda dapat mengawal kebergantungan dari luar kelas.

Bagaimanakah kontena IOC Laravel berfungsi? Ia mengawal bagaimana objek yang berbeza diselesaikan dan dibuat. Apabila kelas mempunyai kebergantungan, bekas secara automatik menyuntikkannya apabila kelas itu dimanfaatkan. Ini dilakukan melalui proses yang disebut "pendawaian auto," di mana bekas memeriksa kelas untuk menentukan kebergantungan secara automatik. Mengikat perkhidmatan ke bekas IOC Laravel, anda boleh menggunakan kaedah pengikat. Kaedah ini menerima dua hujah: nama kelas atau antara muka yang akan digunakan semasa menyelesaikan perkhidmatan, dan penutupan yang mengembalikan contoh kelas. Penutupan akan menerima contoh kontena, yang membolehkan anda menyelesaikan sebarang kebergantungan lain yang diperlukan untuk menyegarkan kelas. Dan singleton dalam kontena IOC Laravel terletak pada bagaimana keadaan diuruskan. Apabila anda mengikat perkhidmatan, contoh baru perkhidmatan akan dibuat setiap kali anda menyelesaikannya. Sebaliknya, apabila anda menggunakan singleton, contoh yang sama akan dikembalikan setiap kali perkhidmatan diselesaikan. Dari bekas IOC Laravel, anda boleh menggunakan kaedah Make. Kaedah ini menerima nama perkhidmatan untuk menyelesaikannya sebagai hujahnya. Sekiranya perkhidmatan itu terikat kepada bekas, ia akan mengembalikan contoh perkhidmatan, dengan semua kebergantungannya secara automatik disuntik. Ujian di Laravel dengan membuat kod anda lebih fleksibel dan dipadamkan. Ini bermakna anda boleh dengan mudah menukar kebergantungan dengan objek mengejek semasa ujian. Ini menjadikannya lebih mudah untuk mengasingkan kod di bawah ujian dan untuk mengawal persekitaran ujian. . Ini membolehkan anda mengikat antara muka kepada pelaksanaan yang diberikan. Kemudian, apabila antara muka diminta, bekas akan menyuntik pelaksanaan terikat. kelas. Apabila anda cuba menyelesaikan kelas, bekas akan secara automatik membina dan menyuntik semua kebergantungan yang diperlukan oleh kelas. Kontena adalah cara untuk kumpulan pendaftaran IOC yang berkaitan di satu lokasi. Mereka adalah tempat utama untuk mengkonfigurasi permohonan anda. Setiap aplikasi Laravel termasuk beberapa penyedia perkhidmatan keluar dari kotak untuk perkhidmatan teras.

Bagaimana saya boleh mendaftarkan pembekal perkhidmatan dalam bekas IOC Laravel? Sebaik sahaja pembekal perkhidmatan didaftarkan, ia akan bootstrapped oleh Laravel apabila permohonan itu bootstrapped.

Atas ialah kandungan terperinci Suntikan ketergantungan dengan Laravel ' s IOC. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!