Laravel
Prestations de service

Relier une interface à la mise en œuvre

Dans une méthode de register fournisseur de services, nous pouvons associer une interface à une implémentation:

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

A partir de maintenant, chaque fois que l'application aura besoin d'une instance de UserRepositoryInterface , Laravel injectera automatiquement une nouvelle instance d' EloquentUserRepository :

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

Relier une instance

Nous pouvons utiliser le conteneur de service en tant que registre en liant une instance d'un objet et le récupérer lorsque nous en aurons besoin:

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

Liaison d'un singleton au conteneur de services

On peut lier une classe en singleton:

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

Ainsi, la première fois qu'une instance de 'my-database' sera demandée au conteneur de services, une nouvelle instance sera créée. Toutes les requêtes successives de cette classe récupèreront la première instance créée:

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

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

introduction

Le conteneur de service est l'objet Application principal. Il peut être utilisé comme conteneur d'injection de dépendances et comme registre pour l'application en définissant des liaisons dans les fournisseurs de services.

Les fournisseurs de services sont des classes dans lesquelles nous définissons la manière dont nos classes de service seront créées via l'application, amorcent leur configuration et lient les interfaces aux implémentations.

Les services sont des classes qui regroupent une ou plusieurs tâches logiques corrélées

Utilisation du conteneur de services en tant que conteneur d'injection de dépendances

Nous pouvons utiliser le conteneur de services en tant que conteneur d'injection de dépendances en liant le processus de création d'objets avec leurs dépendances en un point de l'application.

Supposons que la création d'un PdfCreator nécessite deux objets en tant que dépendances; chaque fois que nous avons besoin de construire une instance de PdfCreator , nous devons transmettre ces dépendances au constructeur. En utilisant le conteneur de service en tant que DIC, nous définissons la création de PdfCreator dans la définition de la liaison, en prenant directement la dépendance requise à partir du conteneur de services:

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

Ensuite, à chaque PdfCreator de notre application, pour obtenir un nouveau PdfCreator , nous pouvons simplement faire:

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

Et le conteneur de service créera une nouvelle instance, avec les dépendances nécessaires pour nous.