Let’s talk about Service Container in laravel

What is Service Container

The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection.

From the explanation of Service Container in Laravel official documentation, we can see that its role is to help us manage and perform dependency injection.

Why use Service Container

In "Dependency Injection", we saw that using dependency injection can greatly reduce the coupling of the code, but it also brings a disadvantage, which is that it requires Manage the injected objects yourself.
If a component has many dependencies, we need to create a setter method with multiple parameters to pass the dependencies, or create a constructor with multiple parameters to pass them. In addition, we need to create dependencies every time before using the component. This makes our code like this less maintainable.
So providing a container (Service Container) for dependent instances is a practical and elegant method.
For example, the following is the entry file of laravel (comments have been removed):

// public/index.php
<?php

require __DIR__.&#39;/../bootstrap/autoload.php&#39;;

$app = require_once __DIR__.&#39;/../bootstrap/app.php&#39;;

$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);

$response = $kernel->handle(
    $request = Illuminate\Http\Request::capture()
);

$response->send();

$kernel->terminate($request, $response);

// bootstrap/app.php
<?php

$app = new Illuminate\Foundation\Application(
    realpath(__DIR__.&#39;/../&#39;)
);

$app->singleton(
    Illuminate\Contracts\Http\Kernel::class,
    App\Http\Kernel::class
);

$app->singleton(
    Illuminate\Contracts\Console\Kernel::class,
    App\Console\Kernel::class
);

$app->singleton(
    Illuminate\Contracts\Debug\ExceptionHandler::class,
    App\Exceptions\Handler::class
);

return $app;

First look at bootstrap/app.php, where $app is An instance of Illuminate\Foundation\Application, and the Illuminate\Foundation\Application class inherits from Container, so $app is actually a Service Container.
Then the following three singleton methods define when dependencies Illuminate\Contracts\Http\Kernel, Illuminate\Contracts\Console\Kernel, Illuminate\Contracts\Debug \ExceptionHandlerWhen using these three interfaces, which class should be injected as a singleton.
Then look at public/index.php, the make method actually uses Service Container to create a new Illuminate\Contracts\Http\Kernel instance, which is different from ordinary new That is, his dependencies will be automatically injected into it.

Isn’t it very concise?

In fact, not only Laravel, but also frameworks such as Yii2 and Phalcon manage dependency injection by implementing containers.

How to use Service Container

Since it is a container, it is nothing more than two things, putting things in and taking things out. The corresponding to Service Container is binding (Binding) and resolving (Resolving) ).

Get the container

In Laravel's Service Provider, you can get the container through $this->app. In addition, you can also use app () to get the container.
If you use Service Container outside Laravel, just create a new Illuminate\Container\Container to get the container.

$container is used below to represent the obtained container.

Binding

• Binding returns an instance of the interface

//使用闭包
$container->bind('BarInterface', function(){
    return new Bar();
});
//或者使用字符串
$container->bind('FooInterface', 'Foo');

• Binding singleton

The singleton method binds a class or interface that will only be parsed once to the container, and subsequent calls will return the same instance from the container:

$container->singleton('BarInterface', function(){
    return new Bar();
});

• Bind instance

You can also use the instance method to bind an existing object instance to the container. Subsequent calls will return the specified instance from the container:

$bar = new Bar();
$bar->setSomething(new Something);

$container->instance('Bar', $bar);

• Situational binding

Sometimes, you There may be two classes that use the same interface, but you want each class to be able to inject a different implementation.

$container->when('Man')
          ->needs('PartnerInterface')
          ->give('Woman');
$container->when('Woman')
          ->needs('PartnerInterface')
          ->give('Man');

• Mark

Sometimes, you may need to parse all bindings under a certain "category".

$container->bind('Father', function () {
    //
});
$container->bind('Mother', function () {
    //
});
$container->bind('Daughter', function () {
    //
});
$container->bind('Son', function () {
    //
});
$container->tag(['Father', 'Mother', 'Daughter', 'Son'], 'familyMembers');

$container->bind('Family', function ($container) {
    return new Family($container->tagged('familyMembers'));
});

Analysis

• make method

$foo = $container->make('Foo');

• Array method

$bar = $container['Bar'];

• Resolving is marked bound

$familyMembers = $container->tagged('familyMembers');

foreach ($familyMembers as $inpidual) {
    $inpidual->doSomething();
}

Resolving event

Whenever the service container resolves a The event is triggered when the object is created. You can listen to this event using the resolving method.

$container->resolving(function ($object, $container) {
    // 当容器解析任何类型的对象时会被调用...
});

$container->resolving('Foo', function (Foo $foo, $container) {
    // 当容器解析「Foo」类型的对象时会被调用...
});

Related recommendations: The latest five Laravel video tutorials