Qual é o conceito de recipiente de serviço em Laravel?

Question

Qual é o conceito de recipiente de serviço em Laravel?

Estou a começar a investigar o Laravel, mas não entendo o conceito de contentor de Serviço.

Como funciona e o que é que os programadores precisam de saber para utilizar plenamente este conceito em Laravel?

31

php design-patterns laravel laravel-5 laravel-5.2

Author: Moppo, 2016-05-05

Source

2 answers

Recipiente Laravel criar exemplo para aplicação completa a partir de serviços (classe) Não precisamos criar instance para a nossa aplicação como

$myclass = new MyClass();
$mymethod = $myclass->myMethod();

App:: bind

Primeiro, vamos procurar o método estático bind da classe. bind está apenas a ligar a sua classe instance(objecto) com uma aplicação, nada mais.

App::bind('myapp', function(){
    return new MyClass();
});

Agora, podemos usar este objecto para a nossa aplicação usando make um método estático de App classe.

$myclass = App::make(MyClass::class);
$mymethod = $myclass->myMethod();

App: singleton

No exemplo acima, quando vamos chamar o método make, Então ele gera cada vez que novo instance da classe, então Laravel tem uma solução bonita para Singleton Podemos ligar um object à nossa aplicação pelo método singleton.

App::singleton(MyClass::class, function(){
    return new MyClass();
});

Podemos ser resolvidos pelo método de make. Agora, nós sempre recebemos exatamente o mesmo exemplo deste método.

$myclass = App::make(MyClass::class);
$mymethod = $myclass->myMethod();

App::instância Podemos ligar uma instância ao container e sempre retornaremos exatamente o mesmo instância que utiliza o método instance.

$myclass = new MyClass();
App::instance(MyClass::class, $myclass);

Podemos ser resolvidos por

$myclass = App::make(MyClass::class);

Podemos ligar a interface por

App::instance(MyClassInterface::class, new MyClass);

Aplicação Obrigatória

Yaa, temos uma pergunta, Como podemos implementar a vinculação em nossa aplicação? Podemos implementar a vinculação na nossa AppServiceProvider

app/Providers/AppServiceProvider.php

namespace App\Providers;

use App\SocialProvider;
use App\TwitterSocialProvider;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
  /**
   * Bootstrap any application services.
   *
   * @return void
   */
   public function boot()
  {

  }

   /**
   * Register any application services.
   *
   * @return void
   */
   public function register()
   {
      $this->app->bind(
        MyClassInterface::class,
        MyClass::class
      );
  }
}

Conclusão: Contentor de Serviço ajuda a criar objecto de classe ou servico.

3

Author: Paresh Barad, 2018-01-13 12:09:00

score 27 · Accepted Answer

O recipiente de Serviço em Laravel é um recipiente de injecção dependente e um registo da aplicação

As vantagens de usar um recipiente de Serviço Sobre a criação manual dos seus objectos são:

Capacidade de gerir as dependências de classe na criação de objectos

Você define como um objeto deve ser criado em um ponto da aplicação (a ligação) e cada vez que você precisa criar uma nova instância, você só pede para o serviço container, and it will create it for you, along with the required dependencies

Por exemplo, em vez de criar objectos manualmente com a palavra-chave new:

//every time we need YourClass we should pass the dependency manually
$instance = new YourClass($dependency);

Pode registar uma ligação no contentor de Serviço:

//add a binding for the class YourClass 
App::bind( YourClass::class, function()
{
    //do some preliminary work: create the needed dependencies
    $dependency = new DepClass( config('some.value') );

    //create and return the object with his dependencies
    return new YourClass( $dependency );
});

E criar uma instância através do contentor de serviço com:

//no need to create the YourClass dependencies, the SC will do that for us!
$instance = App::make( YourClass::class );

Ligação das interfaces às classes de betão

Com a injecção automática de dependência de Laravel, quando é necessária uma interface em alguma parte do o app (isto é, no construtor de um controlador), uma classe de concreto é instanciada automaticamente pelo recipiente de Serviço. Mudar a classe de concreto na ligação, irá mudar os objetos de concreto instanciados através de todo o seu aplicativo:

//everityme a UserRepositoryInterface is requested, create an EloquentUserRepository 
App::bind( UserRepositoryInterface::class, EloquentUserRepository::class ); 

//from now on, create a TestUserRepository 
App::bind( UserRepositoryInterface::class, TestUserRepository::class );

Utilização do contentor de serviço como Registo

Você pode criar e armazenar instâncias de objetos únicos no recipiente e obtê-los de volta mais tarde: usando o método App::instance para fazer a ligação, e, portanto, usando o recipiente como um Registro.

// Create an instance.
$kevin = new User('Kevin');

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

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

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

Como nota final, essencialmente o recipiente de serviço-é-o objecto Application: estende a classe Container, obtendo todas as funcionalidades do contentor