Memahami suntikan kebergantungan php dan penyongsangan kemahiran control_php

Untuk memahami dua konsep suntikan kebergantungan PHP dan penyongsangan kawalan, anda mesti memahami isu berikut:

DI——Suntikan Kebergantungan

IoC——Penyongsangan Kawalan

1. Siapakah peserta?​

Jawapan: Secara umumnya terdapat tiga pihak, satu ialah objek; Izinkan saya menerangkan kata nama itu sekali lagi Objek merujuk kepada mana-mana objek Java biasa, bekas IoC/DI hanya merujuk kepada program rangka kerja yang digunakan untuk melaksanakan fungsi IoC/DI merujuk kepada objek dari luar objek, secara kolektif dirujuk sebagai sumber, seperti: objek lain yang diperlukan oleh objek, atau sumber fail yang diperlukan oleh objek, dll.

2. Kebergantungan: Siapa bergantung kepada siapa? Mengapa terdapat kebergantungan?

Jawapan: Sesuatu objek bergantung pada bekas IoC/DI. Kebergantungan tidak dapat dielakkan Dalam projek, terdapat pelbagai hubungan antara pelbagai kelas, dan adalah mustahil untuk mereka semua bebas sepenuhnya, yang membentuk kebergantungan. Pembangunan tradisional menggunakan panggilan langsung apabila menggunakan kelas lain, yang akan membentuk gandingan yang kuat, yang harus dielakkan. Suntikan kebergantungan meminjam bekas untuk memindahkan objek bergantung untuk mencapai penyahgandingan.

3. Suntikan: Siapa yang menyuntik kepada siapa? Apa sebenarnya yang disuntik?

Jawapan: Suntikan sumber luaran yang diperlukan ke dalam objek melalui bekas

4. Penyongsangan kawalan: Siapa yang mengawal siapa? Kawal apa? Mengapa ia dipanggil pembalikan?

Jawapan: Objek kawalan kontena IoC/DI terutamanya mengawal penciptaan tika objek. Pembalikan adalah relatif kepada arah positif, jadi apakah yang dikira sebagai arah positif? Fikirkan tentang aplikasi dalam keadaan biasa Jika anda ingin menggunakan C di dalam A, apakah yang anda akan lakukan? Sudah tentu, objek C dicipta secara langsung, iaitu, sumber luaran yang diperlukan C diperoleh secara aktif dalam kelas A. Keadaan ini dipanggil ke hadapan. Jadi apa yang terbalik? Iaitu, kelas A tidak lagi memperoleh C secara aktif, tetapi secara pasif menunggu bekas IoC/DI untuk mendapatkan contoh C, dan kemudian menyuntiknya ke dalam kelas A secara terbalik.

5 Adakah suntikan pergantungan dan penyongsangan kawalan adalah konsep yang sama?

Jawapan: Seperti yang dapat dilihat daripada di atas: suntikan kebergantungan diterangkan dari perspektif aplikasi Suntikan ketergantungan boleh diterangkan dengan lebih lengkap: aplikasi bergantung pada bekas untuk mencipta dan menyuntiknya Sumber luaran yang diperlukan; manakala penyongsangan kawalan diterangkan dari perspektif bekas, penerangan lengkap: bekas mengawal aplikasi, dan bekas menyuntik sumber luaran yang diperlukan oleh aplikasi ke dalam aplikasi secara terbalik.

Mari kita lihat dengan lebih dekat beberapa kaedah pelaksanaan suntikan kebergantungan melalui contoh:

1. Suntikan Pembina

<&#63;php
class Book {
  private $db_conn;
 
  public function __construct($db_conn) {
    $this->db_conn = $db_conn;
  }
}

2. Suntikan setter

<&#63;php

 
class book{
   private $db;
　　　private $file;
   function setdb($db){
     $this->db=$db;
   }
   function setfile($file){
     $this->file=$file;
   }
}
class file{}
class db{}
...

class test{
　　 $book = new Book();
 　　 $book->setdb(new db()); 
   $book->setfile(new file());
}
&#63;>

Kod kedua-dua kaedah di atas sangat jelas, tetapi apabila kita perlu menyuntik banyak kebergantungan, ini bermakna menambah banyak baris, yang akan menjadi lebih sukar untuk diurus.

Penyelesaian yang lebih baik ialah mencipta kelas sebagai bekas untuk semua kebergantungan Dalam kelas ini, anda boleh menyimpan, mencipta, mendapatkan dan mencari kebergantungan yang diperlukan

<&#63;php
class Ioc {
  protected $db_conn;
  public static function make_book() {
    $new_book = new Book();
    $new_book->set_db(self::$db_conn);
    //...
    //...
    //其他的依赖注入
    return $new_book;
  }
}

Pada masa ini, jika anda ingin mendapatkan contoh buku, anda hanya perlu melaksanakan $newone = Ioc::makebook();

Di atas adalah contoh kontena yang khusus Adalah lebih baik untuk tidak menulis kaedah suntikan kebergantungan yang lebih baik menggunakan pendaftaran pendaftaran dan mendapatkan pemerolehan

<&#63;php
class Ioc {
/**
* @var 注册的依赖数组
*/
 
  protected static $registry = array();
 
  /**
  * 添加一个resolve到registry数组中
  * @param string $name 依赖标识
  * @param object $resolve 一个匿名函数用来创建实例
  * @return void
  */
  public static function register($name, Closure $resolve)
  {
   static::$registry[$name] = $resolve;
  }
 
  /**
   * 返回一个实例
   * @param string $name 依赖的标识
   * @return mixed
   */
  public static function resolve($name)
  {
    if ( static::registered($name) )
    {
     $name = static::$registry[$name];
     return $name();
    }
    throw new Exception('Nothing registered with that name, fool.');
  }
  /**
  * 查询某个依赖实例是否存在
  * @param string $name id
  * @return bool 
  */
  public static function registered($name)
  {
   return array_key_exists($name, static::$registry);
  }
}

Anda kini boleh mendaftar dan menyuntik satu melalui kaedah berikut

<&#63;php
$book = Ioc::registry('book', function(){
$book = new Book;
$book->setdb('...');
$book->setprice('...');
return $book;
});
 
//注入依赖
$book = Ioc::resolve('book');
&#63;>

Di atas adalah pemahaman tentang suntikan ketergantungan PHP dan penyongsangan kawalan saya harap ia akan membantu semua orang untuk mempelajari pengaturcaraan PHP.