Menyelam dalam-dalam ke dalam bekas IoC Laravel

Penyongsangan Kawalan (IoC) ialah teknik yang membolehkan penyongsangan kawalan berbanding kod prosedur klasik. Sudah tentu, bentuk IoC yang paling menonjol ialah suntikan pergantungan (DI). Bekas IoC Laravel ialah salah satu ciri Laravel yang paling biasa digunakan, tetapi mungkin paling kurang difahami.

Ini adalah contoh yang sangat mudah menggunakan suntikan kebergantungan untuk melaksanakan penyongsangan kawalan.

<?php

class JeepWrangler
{
    public function __construct(Petrol $fuel)
    {
        $this->fuel = $fuel;
    }
	
    public function refuel($litres)
    {
	    return $litres * $this->fuel->getPrice();
    }
}

class Petrol
{
    public function getPrice()
    {
    	return 130.7;
    }
}

$petrol = new Petrol;
$car = new JeepWrangler($petrol);

$cost = $car->refuel(60);

Dengan menggunakan suntikan pembina, kami kini mewakilkan penciptaan contoh Petrol kepada pemanggil itu sendiri, sekali gus mencapai penyongsangan kawalan. JeepWrangler kami tidak perlu tahu dari mana Petrol datang, ia hanya perlu mendapatkannya. Petrol 实例的创建委托给调用者本身，从而实现控制反转。我们的 JeepWrangler 不需要知道 Petrol 是从哪里来的，只要获取到即可。

那么这一切与 Laravel 有什么关系呢？实际上相当多。如果您不知道，Laravel 实际上是一个 IoC 容器。正如您所料，容器是一个包含事物的对象。 Laravel 的 IoC 容器用于包含许多不同的绑定。你在 Laravel 中所做的一切都会在某个时刻与 IoC 容器进行交互。这种交互通常采用正在解析的绑定的形式。

如果您打开任何现有的 Laravel 服务提供程序，您很可能会在 register 方法中看到类似的内容（示例已简化很多）。

$this->app['router'] = $this->app->share(function($app) {
    return new Router;
});

这是一个非常非常基本的绑定。它由绑定的名称（router）和解析器（闭包）组成。当从容器中解析该绑定时，我们将返回一个 Router 的实例。

Laravel 通常会将相似的绑定名称分组，例如 session 和 session.store。

要解析绑定，我们可以直接调用方法，或者在容器上使用 make 方法。

$router = $this->app->make('router');

这就是容器最基本的形式所做的事情。但是，就像 Laravel 的大多数东西一样，它不仅仅是绑定和解析类。

共享和非共享绑定

如果您浏览过几个 Laravel 服务提供者，您会注意到大多数绑定的定义与前面的示例类似。又来了：

$this->app['router'] = $this->app->share(function($app) {
    return new Router;
});

此绑定在容器上使用 share 方法。 Laravel 使用静态变量来存储先前解析的值，并在再次解析绑定时简单地重用该值。这基本上就是 share 方法的作用。

$this->app['router'] = function($app) {
    static $router;
     
    if (is_null($router)) {
        $router = new Router;
    }
     
    return $router;
     
};

另一种编写方法是使用 bindShared 方法。

$this->app->bindShared('router', function($app) {
    return new Router;
});

您还可以使用 singleton 和 instance 方法来实现共享绑定。那么，如果它们都实现了相同的目标，那么有什么区别呢？实际上并不是很多。我个人更喜欢使用 bindShared 方法。

条件绑定

有时您可能想要将某些内容绑定到容器，但前提是它之前尚未绑定过。有几种方法可以解决此问题，但最简单的方法是使用 bindIf 方法。

$this->app->bindIf('router', function($app) {
    return new ImprovedRouter;
});

仅当 router 绑定尚不存在时，才会绑定到容器。这里唯一需要注意的是如何共享条件绑定。为此，您需要向 bindIf 方法提供第三个参数，其值为 true。

自动依赖关系解析

IoC 容器最常用的功能之一是它能够自动解析未绑定类的依赖关系。这到底是什么意思？首先，我们实际上不需要将某些东西绑定到容器来解析实例。我们可以简单地 make 几乎任何类的实例。

class Petrol
{
    public function getPrice()
    {
        return 130.7;
    }
}

// In our service provider...
$petrol = $this->app->make('Petrol');

容器将为我们实例化 Petrol 类。最好的部分是它还将为我们解决构造函数的依赖关系。

class JeepWrangler
{
    public function __construct(Petrol $fuel)
    {
        $this->fuel = $fuel;
    }
	
    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
    
}

// In our service provider...
$car = $this->app->make('JeepWrangler');

容器做的第一件事是检查 JeepWrangler 类的依赖项。然后它将尝试解决这些依赖关系。因此，因为我们的 JeepWrangler 类型提示了 Petrol 类，所以容器将自动解析并将其作为依赖项注入。

容器无法自动注入非类型提示的依赖项。因此，如果您的依赖项之一是数组，那么您需要手动实例化它或为参数指定默认值。

绑定实现

让 Laravel 自动解决依赖关系非常棒，并且简化了手动实例化类的过程。但是，有时您希望注入特定的实现，尤其是在使用接口时。通过使用类的完全限定名称作为绑定可以轻松实现这一点。为了演示这一点，我们将使用一个名为 Fuel

Jadi apa kaitan semua ini dengan Laravel? Agak banyak sebenarnya. Jika anda tidak tahu, Laravel sebenarnya adalah bekas IoC. Seperti yang anda jangkakan, bekas ialah objek yang mengandungi benda. Bekas IoC Laravel digunakan untuk mengandungi banyak pengikatan yang berbeza. Semua yang anda lakukan dalam Laravel akan berinteraksi dengan bekas IoC pada satu ketika. Interaksi ini biasanya berbentuk pengikat yang diselesaikan.

🎜 🎜Jika anda membuka mana-mana pembekal perkhidmatan Laravel sedia ada, kemungkinan besar anda akan melihat sesuatu yang serupa dalam kaedah register (contohnya lebih mudah). 🎜

interface Fuel
{
    public function getPrice();
}

🎜Ini adalah pengikatan yang sangat-sangat asas. Ia terdiri daripada nama pengikatan (router) dan penyelesai (penutupan). Apabila pengikatan diselesaikan daripada bekas, kami akan mengembalikan contoh Router. 🎜

Laravel selalunya mengumpulkan nama pengikatan yang serupa, seperti session dan session.store.

🎜Untuk menyelesaikan pengikatan, kami boleh memanggil kaedah secara terus atau menggunakan kaedah make pada bekas. 🎜

class JeepWrangler
{
    public function __construct(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }
	
    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
}

class Petrol implements Fuel
{
    public function getPrice()
    {
        return 130.7;
    }
}

🎜Inilah yang dilakukan oleh bekas dalam bentuk yang paling asas. Tetapi, seperti kebanyakan perkara dalam Laravel, terdapat lebih daripada sekadar mengikat dan menyelesaikan kelas. 🎜

Ikatan kongsi dan bukan kongsi🎜🎜

🎜Jika anda menyemak imbas melalui beberapa pembekal perkhidmatan Laravel, anda akan mendapati bahawa kebanyakan pengikatan ditakrifkan sama seperti contoh sebelumnya. Ini kita pergi lagi: 🎜🎜🎜

$this->app->bind('Fuel', 'Petrol');

// Or, we could instantiate it ourselves.
$this->app->bind('Fuel', function ($app) {
    return new Petrol;
});

🎜Ikatan ini menggunakan kaedah share pada bekas. Laravel menggunakan pembolehubah statik untuk menyimpan nilai yang telah diselesaikan sebelum ini dan hanya menggunakan semula nilai apabila pengikatan diselesaikan semula. Ini pada asasnya yang dilakukan oleh kaedah share. 🎜

class PremiumPetrol implements Fuel
{
    public function getPrice()
    {
        return 144.3;
    }
}

// In our service provider...
$this->app->bind('Fuel', 'PremiumPetrol');

🎜Cara lain untuk menulisnya ialah menggunakan kaedah bindShared. 🎜

abstract class Car
{
    public function __construct(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }

    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
}

🎜Anda juga boleh menggunakan kaedah singleton dan instance untuk melaksanakan pengikatan kongsi. Jadi, jika mereka berdua mencapai matlamat yang sama, apa bezanya? Tak banyak sebenarnya. Saya secara peribadi lebih suka menggunakan kaedah bindShared. 🎜

Ikatan bersyarat🎜🎜

🎜Kadangkala anda mungkin ingin mengikat sesuatu pada bekas, tetapi hanya jika ia belum diikat sebelum ini. Terdapat beberapa cara untuk menyelesaikan masalah ini, tetapi yang paling mudah ialah menggunakan kaedah bindIf. 🎜🎜🎜

class JeepWrangler extends Car
{
    //
}

class NissanPatrol extends Car
{
    //
}

🎜Ikatan router hanya akan diikat pada bekas jika ia belum wujud. Satu-satunya perkara yang perlu diperhatikan di sini ialah bagaimana pengikatan bersyarat dikongsi. Untuk melakukan ini, anda perlu menyediakan parameter ketiga kepada kaedah bindIf dengan nilai true. 🎜

Penyelesaian pergantungan automatik🎜🎜

🎜Salah satu ciri bekas IoC yang paling biasa digunakan ialah keupayaannya untuk menyelesaikan kebergantungan kelas tidak terikat secara automatik. Apakah maksud ini? Pertama, kita sebenarnya tidak perlu mengikat sesuatu pada bekas untuk menyelesaikan kejadian itu. Kita hanya boleh membuat contoh bagi hampir mana-mana kelas. 🎜🎜🎜

class Diesel implements Fuel
{
    public function getPrice()
    {
        return 135.3;
    }
}

🎜Bekas akan membuat kelas Petrol untuk kami. Bahagian yang terbaik ialah ia juga akan menyelesaikan kebergantungan pembina untuk kami. 🎜

$this->app->when('JeepWrangler')->needs('Fuel')->give('Petrol');
$this->app->when('NissanPatrol')->needs('Fuel')->give('Diesel');

🎜Perkara pertama yang dilakukan oleh bekas ialah menyemak kebergantungan kelas JeepWrangler. Ia kemudiannya akan cuba menyelesaikan kebergantungan ini. Oleh itu, kerana petunjuk taip JeepWrangler kami untuk kelas Petrol, bekas itu akan menyelesaikan dan menyuntiknya secara automatik sebagai pergantungan. 🎜 🎜Bekas tidak boleh menyuntik kebergantungan bukan pembayang jenis secara automatik. Jadi jika salah satu kebergantungan anda ialah tatasusunan, maka anda perlu membuat instantiat secara manual atau menentukan nilai lalai untuk parameter. 🎜🎜🎜

Pelaksanaan mengikat🎜🎜

🎜Memiliki Laravel menyelesaikan kebergantungan secara automatik adalah bagus dan memudahkan proses membuat kelas secara manual. Walau bagaimanapun, kadangkala anda ingin menyuntik pelaksanaan tertentu, terutamanya apabila menggunakan antara muka. Ini mudah dicapai dengan menggunakan nama kelas yang layak sepenuhnya sebagai pengikatan. Untuk menunjukkan ini, kami akan menggunakan antara muka baharu yang dipanggil Fuel. 🎜🎜🎜

interface Fuel
{
    public function getPrice();
}

现在我们的 JeepWrangler 类可以对接口进行类型提示，并且我们将确保我们的 Petrol 类实现该接口。

class JeepWrangler
{
    public function __construct(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }
	
    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
}

class Petrol implements Fuel
{
    public function getPrice()
    {
        return 130.7;
    }
}

现在，我们可以将 Fuel 接口绑定到容器，并让它解析 Petrol 的新实例。

$this->app->bind('Fuel', 'Petrol');

// Or, we could instantiate it ourselves.
$this->app->bind('Fuel', function ($app) {
    return new Petrol;
});

现在，当我们创建 JeepWrangler 的新实例时，容器会看到它请求 Fuel ，并且它会知道自动注入 Petrol。

这也使得更换实现变得非常容易，因为我们可以简单地更改容器中的绑定。为了进行演示，我们可能会开始使用优质汽油为汽车加油，这种汽油价格稍贵一些。

class PremiumPetrol implements Fuel
{
    public function getPrice()
    {
        return 144.3;
    }
}

// In our service provider...
$this->app->bind('Fuel', 'PremiumPetrol');

上下文绑定

请注意，上下文绑定仅在 Laravel 5 中可用。

上下文绑定允许您将实现（就像我们上面所做的那样）绑定到特定的类。

abstract class Car
{
    public function __construct(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }

    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
}

然后，我们将创建一个新的 NissanPatrol 类来扩展抽象类，并且我们将更新 JeepWrangler 来扩展它。

class JeepWrangler extends Car
{
    //
}

class NissanPatrol extends Car
{
    //
}

最后，我们将创建一个新的 Diesel 类，该类实现 Fuel 接口。

class Diesel implements Fuel
{
    public function getPrice()
    {
        return 135.3;
    }
}

现在，我们的吉普牧马人将使用汽油加油，我们的日产途乐将使用柴油加油。如果我们尝试使用与之前相同的方法，将实现绑定到接口，那么这两辆车都会获得相同类型的燃料，这不是我们想要的。

因此，为了确保每辆车都使用正确的燃料加油，我们可以通知容器在每种情况下使用哪种实现。

$this->app->when('JeepWrangler')->needs('Fuel')->give('Petrol');
$this->app->when('NissanPatrol')->needs('Fuel')->give('Diesel');

标记

请注意，标记仅在 Laravel 5 中可用。

能够解析容器中的绑定非常重要。通常，只有知道某些内容如何绑定到容器时，我们才能解决该问题。在 Laravel 5 中，我们现在可以为绑定添加标签，以便开发人员可以轻松解析具有相同标签的所有绑定。

如果您正在开发一个允许其他开发人员构建插件的应用程序，并且您希望能够轻松解析所有这些插件，那么标签将非常有用。

$this->app->tag('awesome.plugin', 'plugin');

// Or an array of tags.

$tags = ['plugin', 'theme'];

$this->app->tag('awesome.plugin', $tags);

现在，要解析给定标记的所有绑定，我们可以使用 tagged 方法。

$plugins = $this->app->tagged('plugin');

foreach ($plugins as $plugin) {
    $plugin->doSomethingFunky();
}

篮板和重新绑定

当您将某些内容多次绑定到同名容器时，称为重新绑定。 Laravel 会注意到你再次绑定了一些东西并会触发反弹。

这里最大的好处是当您开发一个包时，允许其他开发人员通过重新绑定容器中的组件来扩展它。要使用它，我们需要在 Car 摘要上实现 setter 注入。

abstract class Car
{
    public function __construct(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }

    public function refuel($litres)
    {
        return $litres * $this->fuel->getPrice();
    }
    
    public function setFuel(Fuel $fuel)
    {
        $this->fuel = $fuel;
    }
    
}

假设我们将 JeepWrangler 像这样绑定到容器。

$this->app->bindShared('fuel', function ($app) {
    return new Petrol;
});

$this->app->bindShared('car', function ($app) {
	return new JeepWrangler($app['fuel']);
});

这完全没问题，但假设另一位开发人员出现并希望扩展此功能并在汽车中使用优质汽油。因此，他们使用 setFuel 方法将新燃料注入汽车。

$this->app['car']->setFuel(new PremiumPetrol);

在大多数情况下，这可能就是所需要的；但是，如果我们的包变得更加复杂并且 fuel 绑定被注入到其他几个类中怎么办？这将导致其他开发人员必须多次设置他们的新实例。因此，为了解决这个问题，我们可以利用重新绑定：

$this->app->bindShared('car', function ($app) {
    return new JeepWrangler($app->rebinding('fuel', function ($app, $fuel) {
		$app['car']->setFuel($fuel);
	}));
});

重新绑定 方法将立即返回给我们已经绑定的实例，以便我们能够在 JeepWrangler 的构造函数中使用它。提供给 rebinding 方法的闭包接收两个参数，第一个是 IoC 容器，第二个是新绑定。然后，我们可以自己使用 setFuel 方法将新绑定注入到我们的 JeepWrangler 实例中。

剩下的就是其他开发人员只需在容器中重新绑定 fuel 即可。他们的服务提供商可能如下所示：

$this->app->bindShared('fuel', function () {
    return new PremiumPetrol;
});

一旦绑定在容器中反弹，Laravel 将自动触发关联的闭包。在我们的示例中，新的 PremiumPetrol 实例将在我们的 JeepWrangler 实例上设置。

扩展

如果您想将依赖项注入核心绑定之一或由包创建的绑定，那么容器上的 extend 方法是最简单的方法之一。

此方法将解析来自容器的绑定，并以容器和解析的实例作为参数执行闭包。这使您可以轻松解析和注入您自己的绑定，或者简单地实例化一个新类并注入它。

$this->app->extend('car', function ($app, $car) {
    $car->setFuel(new PremiumPetrol);
});

与重新绑定不同，这只会设置对单个绑定的依赖关系。

Laravel 之外的使用

与构成 Laravel 框架的许多 Illuminate 组件一样，Container 可以在 Laravel 之外的独立应用程序中使用。为此，您必须首先将其作为 composer.json 文件中的依赖项。

{
    "require": {
        "illuminate/container": "4.2.*"
   }
}

这将安装容器的最新 4.2 版本。现在，剩下要做的就是实例化一个新容器。

require 'vendor/autoload.php';

$app = new Illuminate\Container\Container;

$app->bindShared('car', function () {
    return new JeepWrangler;
});

在所有组件中，当您需要灵活且功能齐全的 IoC 容器时，这是最容易使用的组件之一。

Atas ialah kandungan terperinci Menyelam dalam-dalam ke dalam bekas IoC Laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!