Laravel
Diensten

Een interface binden aan implementatie

In een Service Provider- register kunnen we een interface binden aan een implementatie:

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

Vanaf nu, telkens als de app een exemplaar van UserRepositoryInterface , zal Laravel automatisch een nieuw exemplaar van EloquentUserRepository injecteren:

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

Een exemplaar binden

We kunnen de servicecontainer als register gebruiken door een instantie van een object erin te binden en terug te krijgen wanneer we het nodig hebben:

// 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'); 

Een singleton binden aan de servicecontainer

We kunnen een klas binden als Singleton:

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

Op deze manier wordt de eerste keer dat een exemplaar van 'my-database' aan de servicecontainer wordt gevraagd, een nieuw exemplaar gemaakt. Alle opeenvolgende aanvragen van deze klasse krijgen de eerste gemaakte instantie terug:

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

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

Invoering

De servicecontainer is het belangrijkste toepassingsobject. Het kan worden gebruikt als een afhankelijkheidsinjectiecontainer en een register voor de toepassing door bindingen in de serviceproviders te definiëren

Serviceproviders zijn klassen waarin we de manier definiëren waarop onze serviceklassen worden gemaakt via de toepassing, hun configuratie opstarten en interfaces koppelen aan implementaties

Services zijn klassen die een of meer logisch gecorreleerde taken samenvoegen

De servicecontainer gebruiken als een afhankelijkheidsinjectiecontainer

We kunnen de servicecontainer gebruiken als een afhankelijkheidsinjectiecontainer door het creatieproces van objecten met hun afhankelijkheden in één punt van de toepassing te binden

Laten we aannemen dat voor het maken van een PdfCreator twee objecten nodig zijn als afhankelijkheden; elke keer dat we een instantie van PdfCreator moeten bouwen, moeten we deze afhankelijkheden doorgeven aan che constructor. Door de Service Container als DIC te gebruiken, definiëren we het maken van PdfCreator in de bindende definitie, waarbij we de vereiste afhankelijkheid rechtstreeks van de Service Container nemen:

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 );    
});

Vervolgens kunnen we op elk punt van onze app eenvoudig een nieuwe PdfCreator krijgen:

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

En de servicecontainer maakt een nieuwe instantie, samen met de benodigde afhankelijkheden voor ons.