Apakah suntikan pergantungan laravel

Istilah suntikan kebergantungan laravel ialah istilah yang dicadangkan oleh Martin Fowler Ia adalah tingkah laku menyuntik komponen ke dalam aplikasi Suntikan Ketergantungan ialah elemen utama dalam seni bina tangkas. dilindungi $sambungan...}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  🎜>Persekitaran pengendalian artikel ini: sistem Windows 7, Laravel versi 5.7, komputer DELL G3.

Apakah suntikan pergantungan laravel?

Penjelasan terperinci tentang suntikan pergantungan dan IoC dalam Laravel:

Sebagai pembangun, kami Sentiasa cuba mencari cara baharu untuk menulis kod yang direka bentuk dengan baik dan teguh dengan menggunakan corak reka bentuk dan mencuba rangka kerja teguh baharu. Dalam artikel ini, kami akan meneroka corak reka bentuk Suntikan Ketergantungan dengan komponen IoC Laravel dan melihat cara ia boleh menambah baik reka bentuk kami.

Suntikan Kebergantungan

Istilah suntikan kebergantungan ialah istilah yang dicadangkan oleh Martin Fowler, iaitu tindakan menyuntik komponen ke dalam aplikasi. Seperti kata Ward Cunningham:

Suntikan kebergantungan ialah elemen utama dalam seni bina tangkas.

Mari kita lihat contoh:

Jika anda ingin menguji atau mengekalkan kelas ini, anda perlu mengakses contoh pangkalan data untuk melaksanakan beberapa pertanyaan. Untuk mengelak daripada melakukan ini, anda boleh

class UserProvider{
    protected $connection;

    public function __construct(){
        $this->connection = new Connection;
    }

    public function retrieveByCredentials( array $credentials ){
        $user = $this->connection
                        ->where( 'email', $credentials['email'])
                        ->where( 'password', $credentials['password'])
                        ->first();

        return $user;
    }
}

decouple

kelas ini daripada kelas lain, anda mempunyai satu daripada tiga pilihan untuk menyuntik kelas tanpa menggunakannya secara langsung. ConnectionApabila menyuntik komponen ke dalam kelas, anda boleh menggunakan salah satu daripada tiga pilihan berikut:

Suntikan kaedah pembina

Suntikan kaedah penetap

class UserProvider{
    protected $connection;

    public function __construct( Connection $con ){
        $this->connection = $con;
    }
    ...

Begitu juga, Kami juga boleh menggunakan kaedah Setter untuk menyuntik kebergantungan:

Suntikan antara muka

class UserProvider{
    protected $connection;
    public function __construct(){
        ...
    }

    public function setConnection( Connection $con ){
        $this->connection = $con;
    }
    ...

Apabila kelas melaksanakan antara muka kami, kami mentakrifkan kaedah

interface ConnectionInjector{
    public function injectConnection( Connection $con );
}

class UserProvider implements ConnectionInjector{
    protected $connection;

    public function __construct(){
        ...
    }

    public function injectConnection( Connection $con ){
        $this->connection = $con;
    }
}

untuk menyelesaikan masalah hubungan pergantungan.

injectConnectionKelebihan

Kini apabila menguji kelas kami, kami boleh mengejek kelas bergantung dan melepasinya sebagai parameter. Setiap kelas mesti menumpukan pada tugas tertentu dan tidak seharusnya bimbang dengan menyelesaikan kebergantungan mereka. Dengan cara ini, anda akan mempunyai aplikasi yang lebih fokus dan boleh diselenggara.

Jika anda ingin mengetahui lebih lanjut tentang DI, Alejandro Gervassio telah membincangkannya secara meluas dan pakar dalam siri artikel ini, jadi pastikan anda membacanya. Jadi, apakah IoC? IoC (Penyongsangan Kawalan) tidak memerlukan penggunaan suntikan kebergantungan, tetapi ia boleh membantu anda mengurus kebergantungan dengan berkesan.

Penyongsangan Kawalan

Ioc ialah komponen mudah yang memudahkan untuk menyelesaikan kebergantungan. Anda boleh menerangkan objek sebagai bekas, dan setiap kali kelas diselesaikan, kebergantungan disuntik secara automatik.

Laravel Ioc

Laravel Ioc adalah istimewa sedikit dalam cara ia menyelesaikan kebergantungan apabila anda meminta objek:

Kami menggunakan A contoh mudah akan memperbaikinya dalam artikel ini. Kelas

bergantung pada
, jadi kod kami mungkin kelihatan seperti ini: SimpleAuthFileSessionStorage

Ini ialah pendekatan klasik, mari mulakan dengan menggunakan suntikan pembina.

class FileSessionStorage{
  public function __construct(){
    session_start();
  }

  public function get( $key ){
    return $_SESSION[$key];
  }

  public function set( $key, $value ){
    $_SESSION[$key] = $value;
  }
}

class SimpleAuth{
  protected $session;

  public function __construct(){
    $this->session = new FileSessionStorage;
  }
}

//创建一个 SimpleAuth
$auth = new SimpleAuth();

Sekarang kita mencipta objek:

class SimpleAuth{
  protected $session;

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

Sekarang saya mahu menggunakan Laravel Ioc untuk menguruskan semua ini.

$auth = new SimpleAuth( new FileSessionStorage() );

Oleh kerana kelas

mewarisi daripada kelas

, anda boleh mengakses bekas melalui fasad Application. Parameter pertama kaedah ContainerApp

App::bind( 'FileSessionStorage', function(){
    return new FileSessionStorage;
});

ialah ID unik yang akan diikat pada bekas Parameter kedua ialah fungsi panggil balik yang dilaksanakan apabila kelas

dilaksanakan juga lulus rentetan A yang mewakili nama kelas, seperti yang ditunjukkan di bawah. bindFileSessionStorage

Nota:

Jika anda melihat pada pakej Laravel, anda akan melihat bahawa pengikatan kadangkala dikumpulkan, seperti ( , …). viewview.finder Dengan mengandaikan kita menukar storan sesi kepada storan Mysql, kelas kita sepatutnya kelihatan seperti:

Sekarang kita telah menukar kebergantungan, kita juga perlu menukar

class MysqlSessionStorage{

  public function __construct(){
    //...
  }

  public function get($key){
    // do something
  }

  public function set( $key, $value ){
    // do something
  }
}

pembina, dan ikat objek baru ke dalam bekas!

SimpleAuth

Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah, kedua-duanya harus bergantung pada objek abstrak.

Abstraksi tidak boleh bergantung pada butiran, butiran harus bergantung pada abstrak.

Robert C. Martin

Kelas

kami seharusnya tidak mengambil berat tentang cara penyimpanan kami dilakukan, sebaliknya ia harus menumpukan pada penggunaan perkhidmatan tersebut.

SimpleAuth Oleh itu, kami boleh melaksanakan storan kami secara abstrak:

Dengan cara ini kami boleh melaksanakan dan meminta contoh antara muka

interface SessionStorage{
  public function get( $key );
  public function set( $key, $value );
}

:

class FileSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class MysqlSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class SimpleAuth{

  protected $session;

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

}

如果我们使用 App::make('SimpleAuth') 通过容器解析 SimpleAuth
类，容器将会抛出 BindingResolutionException ，尝试从绑定解析类之后，返回到反射方法并解析所有依赖项。

Uncaught exception 'Illuminate\Container\BindingResolutionException' with message 'Target [SessionStorage] is not instantiable.'

容器正试图将接口实例化。我们可以为该接口做一个具体的绑定。

App:bind( 'SessionStorage', 'MysqlSessionStorage' );

现在每次我们尝试从容器解析该接口时，我们会得到一个 MysqlSessionStorage 实例。如果我们想要切换我们的存储服务，我们只要变更一下这个绑定。

Note: 如果你想要查看一个类是否已经在容器中被绑定，你可以使用 App::bound('ClassName') ，或者可以使用 App::bindIf('ClassName') 来注册一个还未被注册过的绑定。

Laravel Ioc 也提供 App::singleton('ClassName', 'resolver') 来处理单例的绑定。
你也可以使用 App::instance('ClassName', 'instance') 来创建单例的绑定。
如果容器不能解析依赖项就会抛出 ReflectionException ，但是我们可以使用 App::resolvingAny(Closure) 方法以回调函数的形式来解析任何指定的类型。

Note: 如果你为某个类型已经注册了一个解析方式 resolvingAny 方法仍然会被调用，但它会直接返回 bind 方法的返回值。

小贴士

• 这些绑定写在哪儿：
  如果只是一个小型应用你可以写在一个全局的起始文件 global/start.php 中，但如果项目变得越来越庞大就有必要使用 Service Provider 。

• 测试：
  当需要快速简易的测试可以考虑使用 php artisan tinker ，它十分强大，且能帮你提升你的 Laravel 测试流程。

• Reflection API：
  PHP 的 Reflection API 是非常强大的，如果你想要深入 Laravel Ioc 你需要熟悉 Reflection API ，可以先看下这个 教程 来获得更多的信息。

相关推荐：最新的五个Laravel视频教程

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