Laravel
tjänster

Binda ett gränssnitt till implementering

I en tjänsteleverantör register metod kan vi binda ett gränssnitt till ett genomförande:

public function register()
{  
    App::bind( UserRepositoryInterface::class, EloquentUserRepository::class );        
}

Från och med nu, varje gång appen behöver en instans av UserRepositoryInterface , kommer Laravel automatiskt att injicera en ny instans av EloquentUserRepository :

//this will get back an instance of EloquentUserRepository 
$repo = App::make( UserRepositoryInterface:class );

Bind ett tillfälle

Vi kan använda servicebehållaren som ett register genom att binda en instans av ett objekt i det och få tillbaka det när vi behöver det:

// Create an instance.
$john = new User('John');

// Bind it to the service container.
App::instance('the-user', $john);

// ...somewhere and/or in another class...

// Get back the instance
$john = App::make('the-user'); 

Binder en Singleton till servicebehållaren

Vi kan binda en klass som singleton:

public function register()
{
    App::singleton('my-database', function()
    {
        return new Database();
    });
}

På det här sättet, första gången en instans av 'my-database' begärs till servicebehållaren, skapas en ny instans. Alla successiva förfrågningar från denna klass kommer att få tillbaka den första skapade instansen:

//a new instance of Database is created 
$db = App::make('my-database'); 

//the same instance created before is returned
$anotherDb = App::make('my-database');

Introduktion

Servicebehållaren är det viktigaste applikationsobjektet. Det kan användas som en Dependency Injection Container och ett register för applikationen genom att definiera bindningar i tjänsteleverantörerna

Tjänsteleverantörer är klasser där vi definierar hur våra serviceklasser ska skapas genom applikationen, starta om deras konfiguration och binda gränssnitt till implementeringar

Tjänster är klasser som slår samman en eller flera logikkorrelerade uppgifter tillsammans

Använda servicebehållaren som behållare för beroende av injektion

Vi kan använda Service Container som en Dependency Injection Container genom att binda skapandet av objekt med deras beroenden i en punkt i applikationen

Låt oss anta att skapandet av en PdfCreator behöver två objekt som beroenden; varje gång vi behöver bygga en instans av PdfCreator , borde vi överföra dessa beroenden till che constructor. Genom att använda Service Container som DIC, definierar vi skapandet av PdfCreator i den bindande definitionen, och tar det nödvändiga beroendet direkt från Service Container:

App:bind('pdf-creator', function($app) {

    // Get the needed dependencies from the service container.
    $pdfRender = $app->make('pdf-render');
    $templateManager = $app->make('template-manager');

    // Create the instance passing the needed dependencies.
    return new PdfCreator( $pdfRender, $templateManager );    
});

Sedan, i alla punkter i vår app, för att få en ny PdfCreator , kan vi helt enkelt göra:

$pdfCreator = App::make('pdf-creator');

Och servicebehållaren skapar en ny instans tillsammans med de nödvändiga beroenden för oss.