Idee der Laravel-Abhängigkeitsinjektion

Abhängigkeitsinjektion

Abhängigkeitsinjektion ist ein schicker Begriff, aber er bedeutet tatsächlich, dass die Abhängigkeiten einer Klasse durch den Konstruktor oder in einigen Fällen durch die „Setter“-Methode „injiziert“ werden. Schauen wir uns zunächst ein Codebeispiel in einem Laravel-Controller an:

<?php

namespace App\Http\Controllers;

use Illuminate\Routing\Controller;
use App\Users\Repository as UserRepository;

class UserController extends Controller
{
    /**
     * 用户 Repository 的实例。
     */
    protected $users;

    /**
     * 创建一个新的控制器实例。
     *
     * @param  UserRepository  $users
     * @return void
     */
    public function __construct(UserRepository $users)
    {
        $this->users = $users;
    }

    /**
     * 显示指定 ID 的用户。
     *
     * @param  int  $id
     * @return View
     */
    public function show($id)
    {
        $user_info = $this->users->find($id);
        return view(&#39;user&#39;, [&#39;user_info&#39; => $user_info]);
    }
}

Laravel verwaltet Klassenabhängigkeiten und führt die Abhängigkeitsinjektion über Servicecontainer durch. Wenn Sie eine Schnittstelle als Typhinweis für Funktionsparameter verwenden, müssen Sie die angegebene Implementierung an die Schnittstelle binden:

interface EventPusher {
    public function send($data);
}

class RedisEventPusher implements EventPusher {
    public function send($data) {
        //
    }
}

$this->app->bind('App\Contracts\EventPusher', 'App\Services\RedisEventPusher');

use App\Contracts\EventPusher;

/**
 * 创建一个新的类实例。
 *
 * @param  EventPusher  $pusher
 * @return void
 */
public function __construct(EventPusher $pusher)
{
    $this->pusher = $pusher;
}

Dies ist die sogenannte Schnittstelle- Bei der orientierten Programmierung kann eine Schnittstelle als Spezifikation und Einschränkung verstanden werden. High-Level-Module hängen nicht direkt von Low-Level-Modulen ab, sie sollten alle von Abstraktionen (sogenannten Schnittstellen) abhängen.

Der wichtigste Vorteil der Verwendung der Abhängigkeitsinjektion besteht darin, dass sie das Objekt und die externen Ressourcen, die es benötigt, effektiv trennt und sie lose gekoppelt macht, was der Wiederverwendung von Funktionen förderlich ist und, was noch wichtiger ist, die gesamte Architektur von verbessert Werden Sie sehr flexibel.

Inversion of Control

Inversion of Control (abgekürzt als IoC) ist ein Designprinzip in der objektorientierten Programmierung. Die gebräuchlichste Methode heißt Dependency Injection (DI), die andere Methode heißt „Dependency Lookup“. Durch die Umkehrung der Kontrolle übergibt eine externe Entität, die alle Objekte im System steuert, bei der Erstellung eines Objekts die Referenz des Objekts, von dem sie abhängt, an dieses. Man kann auch sagen, dass Abhängigkeiten in das Objekt eingefügt werden.

<?php
/**
 * 没有IoC/DI的时候，常规的A类使用C类的示例
 */

/**
 * Class c
 */
class c
{
    public function say()
    {
        echo &#39;hello&#39;;
    }
}

/**
 * Class a
 */
class a
{
    private $c;
    public function __construct()
    {
        $this->c = new C(); // 实例化创建C类
    }

    public function sayC()
    {
        echo $this->c->say(); // 调用C类中的方法
    }
}

$a = new a();
$a->sayC();

Mit dem IoC/DI-Container erstellt Klasse A nicht mehr aktiv C, wie in der folgenden Abbildung dargestellt:

Stattdessen wartet es passiv darauf, dass der IoC/DI-Container eine Instanz von C erhält, und fügt sie dann umgekehrt in Klasse A ein, wie in der folgenden Abbildung dargestellt:

<?php
/**
 * 当有了IoC/DI的容器后,a类依赖c实例注入的示例
 */

/**
 * Class c
 */
class c
{
    public function say()
    {
        echo &#39;hello&#39;;
    }
}

/**
 * Class a
 */
class a
{
    private $c;
    public function setC(C $c)
    {
        $this->c = $c; // 实例化创建C类
    }

    public function sayC()
    {
        echo $this->c->say(); // 调用C类中的方法
    }
}

$c = new C();
$a = new a();
$a->setC($c);
$a->sayC();