What is the concept of Service Container in Laravel?

Question

I am starting to look into Laravel but I don't understand the concept of Service Container.

How does it work and what do developers need to know to fully utilize this concept in Laravel?

Clean

Answer 1

The Service Container is the Application object: it extends the Container class, getting all of the container's functionalities.

The advantages of using a Service Container over creating your objects manually are:

Ability to manage class dependencies on object creation

You define how a object should be created at one point of the application (the binding) and every time you need to create a new instance, you just ask the service container, and it will create the new instance for you, along with the required dependencies.

For example, instead of creating objects manually with the new keyword:

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

you can register a binding on the Service Container:

//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 its dependencies
    return new YourClass( $dependency );
});

and create an instance through the service container with:

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

Binding of interfaces to concrete classes

With Laravel automatic dependency injection, when an interface is required in some part of the app (i.e. in a controller's constructor), a concrete class is instantiated automatically by the Service Container. Changing the concrete class on the binding, will change the concrete objects instantiated through all of your app:

//every time 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 );

Using the Service Container as a Registry

You can create and store unique object instances in the container and get them back later: using the App::instance method to make the binding, and thus using the container as a Registry.

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

Cirrose

Brilliant explanation, I like to think of it as the application asking "when this class is requested, how would you like me to build it up?" – Risley

YourClass depends on DepClass and DepClass needs a parameter i.e. config('some.value') to be initialized. Suppose , instead of config('some.value'), we need a number as parameter from the user. Then what will be the changes in App::bind and App::make ? – Bak

A bit confused about "Using the Service Container as a Registry". What is the advantage? Is it means you dont need to pass around objects from method to method and just store it and get from registry? – Seabee

Answer 2

Laravel container create instance for full application from services(class) We don't need to create instance for our application like

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

App::bind

First, We are going look bind static method of App class. bind is just binding your class instance(object) with an application, nothing more.

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

Now, we can use this object for our application by using make a static method of App class.

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

App::singleton

In above example when we are going to call make method then its generate every time new instance of class, So Laravel have pretty solution for Singleton We can bind an object to our application by singleton method.

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

We can be resolved by make method. Now, we have always received the exact same instance from this method.

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

App::instance We can bind an instance to the container and we will always return the exact same instance using instance method.

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

We can be resolved by

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

We can bind interface by

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

Implementation Binding

Yaa, We have a question, How can we implement binding in our application? We can implement binding in our 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
      );
  }
}

Conclusion: Service container helps to create object of class or services.

Brutify

It means register method is called service container. Am I right? – Edh