Laravel
Servicios

Enlace de una interfaz a la implementación

En un método de register proveedor de servicios podemos vincular una interfaz a una implementación:

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

A partir de ahora, cada vez que la aplicación necesite una instancia de UserRepositoryInterface , Laravel inyectará automáticamente una nueva instancia de EloquentUserRepository :

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

Atar una instancia

Podemos usar el contenedor de servicios como un registro vinculando una instancia de un objeto en él y recuperarlo cuando lo necesitemos:

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

Enlazar un Singleton al contenedor de servicio

Podemos unir una clase como Singleton:

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

De esta manera, la primera vez que se solicite una instancia de 'my-database' al contenedor de servicios, se creará una nueva instancia. Todas las solicitudes sucesivas de esta clase recuperarán la primera instancia creada:

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

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

Introducción

El contenedor de servicios es el objeto principal de la aplicación. Se puede utilizar como un contenedor de inyección de dependencias y un registro para la aplicación mediante la definición de enlaces en los proveedores de servicios

Los proveedores de servicios son clases en las que definimos la forma en que nuestras clases de servicio se crearán a través de la aplicación, arrancarán su configuración y unirán las interfaces a las implementaciones.

Los servicios son clases que envuelven una o más tareas correlacionadas de lógica

Uso del contenedor de servicios como un contenedor de inyección de dependencias

Podemos usar el contenedor de servicios como un contenedor de inyección de dependencias vinculando el proceso de creación de objetos con sus dependencias en un punto de la aplicación

Supongamos que la creación de un PdfCreator necesita dos objetos como dependencias; Cada vez que necesitamos crear una instancia de PdfCreator , debemos pasar estas dependencias al constructor che. Al utilizar el contenedor de servicios como DIC, definimos la creación de PdfCreator en la definición de enlace, tomando la dependencia requerida directamente del contenedor de servicios:

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

Luego, en cada punto de nuestra aplicación, para obtener un nuevo PdfCreator , simplemente podemos hacer:

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

Y el contenedor de servicios creará una nueva instancia, junto con las dependencias necesarias para nosotros.