![$blog_data[0]->title](https://theeducation.net/public/frontend/assets/blog_images/63242fec4540bimage081228.jpg)
What is Service Container in Laravel:
If you've ever used the Laravel framework, you've probably heard of service containers and service providers. In fact, they're the backbone of the Laravel framework and do all the heavy lifting when you launch an instance of any Laravel application.
In this article, we're going to have a glimpse of what the service container is all about, and following that we'll discuss the service provider in detail. In the course of this article, I'll also demonstrate how to create a custom service provider in Laravel. Once you create a service provider, you also need to register it with the Laravel application in order to actually use it, so we'll go through that as well.
There are two important methods, boot and register, that your service provider may implement, and in the last segment of this article we'll discuss these two methods thoroughly.
Before we dive into the discussion of a service provider, I'll try to introduce the service container as it will be used heavily in your service provider implementation.
Understand Service Containers and Service Providers:
What Is a Service Container?
In the simplest terms, we could say that the service container in Laravel is a box that holds various components' bindings, and they are served as needed throughout the application.
In the words of the official Laravel documentation:
The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection.
So whenever you need to inject any built-in component or service, you could type hint it in your constructor or method, and it'll be injected automatically from the service container as it contains everything you need! Isn't that cool? It saves you from manually instantiating the components and thus avoids tight coupling in your code.
Let's have a look at a quick example to understand it.
Class SomeClass
{
public function __construct(FooBar $foobarObject)
{
// use $foobarObject object
}
}
As you can see, the SomeClass needs an instance of FooBar to instantiate itself. So, basically, it has a dependency that needs to be injected. Laravel does this automatically by looking into the service container and injecting the appropriate dependency.
And if you're wondering how Laravel knows which components or services to include in the service container, the answer is the service provider. It's the service provider that tells Laravel to bind various components into the service container. In fact, it's called service container bindings, and you need to do it via the service provider.
So it's the service provider that registers all the service container bindings, and it's done via the register method of the service provider implementation.
That should raise another question: how does Laravel know about various service providers? Perhaps you think Laravel should figure that out automatically too? Unfortunately, now, that's something you need to inform Laravel explicitly.
Go ahead and look at the contents of the config/app.php file. You'll find an array entry that lists all the service providers that your app can use.
'providers' => [
/*
* Laravel Framework Service Providers...
*/
Illuminate\Auth\AuthServiceProvider::class,
Illuminate\Broadcasting\BroadcastServiceProvider::class,
Illuminate\Bus\BusServiceProvider::class,
Illuminate\Cache\CacheServiceProvider::class,
Illuminate\Foundation\Providers\ConsoleSupportServiceProvider::class,
Illuminate\Cookie\CookieServiceProvider::class,
Illuminate\Database\DatabaseServiceProvider::class,
Illuminate\Encryption\EncryptionServiceProvider::class,
Illuminate\Filesystem\FilesystemServiceProvider::class,
Illuminate\Foundation\Providers\FoundationServiceProvider::class,
Illuminate\Hashing\HashServiceProvider::class,
Illuminate\Mail\MailServiceProvider::class,
Illuminate\Notifications\NotificationServiceProvider::class,
Illuminate\Pagination\PaginationServiceProvider::class,
Illuminate\Pipeline\PipelineServiceProvider::class,
Illuminate\Queue\QueueServiceProvider::class,
Illuminate\Redis\RedisServiceProvider::class,
Illuminate\Auth\Passwords\PasswordResetServiceProvider::class,
Illuminate\Session\SessionServiceProvider::class,
Illuminate\Translation\TranslationServiceProvider::class,
Illuminate\Validation\ValidationServiceProvider::class,
Illuminate\View\ViewServiceProvider::class,
/*
* Package Service Providers...
*/
/*
* Application Service Providers...
*/
App\Providers\AppServiceProvider::class,
App\Providers\AuthServiceProvider::class,
// App\Providers\BroadcastServiceProvider::class,
App\Providers\EventServiceProvider::class,
App\Providers\RouteServiceProvider::class,
],
From the next section onwards, we'll focus on the service provider, which is the main topic of this article!
What Is a Service Provider?
If the service container is something that allows you to define bindings and inject dependencies, then the service provider is the place where these dependencies are defined.
<?php
namespace Illuminate\Cache;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Support\ServiceProvider;
use Symfony\Component\Cache\Adapter\Psr16Adapter;
class CacheServiceProvider extends ServiceProvider implements DeferrableProvider
{
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->app->singleton('cache', function ($app) {
return new CacheManager($app);
});
$this->app->singleton('cache.store', function ($app) {
return $app['cache']->driver();
});
$this->app->singleton('cache.psr6', function ($app) {
return new Psr16Adapter($app['cache.store']);
});
$this->app->singleton('memcached.connector', function () {
return new MemcachedConnector;
});
}
/**
* Get the services provided by the provider.
*
* @return array
*/
public function provides()
{
return [
'cache', 'cache.store', 'cache.psr6', 'memcached.connector',
];
}
}
The important thing to note here is the register method, which allows you to define service container bindings. As you can see, there are four bindings for the cache, cache.store, cache.psr6, and memcached.connector services.
Basically, we're informing Laravel that whenever there's a need to resolve a cache entry, it should return the instance of CacheManager. So we're just adding a kind of mapping in the service container that can be accessed via $this->app.
This is the proper way to add any service to a Laravel service container. That also allows you to realize the bigger picture of how Laravel goes through the register method of all service providers and populates the service container! And as we've mentioned earlier, it picks up the list of service providers from the config/app.php file.
And that's the story of the service provider. In the next section, we'll discuss how to create a custom service provider so that you can register your custom services into the Laravel service container.
Create a Custom Service Provider:
Laravel already comes with a hands-on command-line utility tool, artisan, which allows you to create template code so that you don't have to create it from scratch. Go ahead and move to the command line and run the following command in your application root to create a custom service provider.
$php artisan make:provider EnvatoCustomServiceProvider
Provider created successfully.
And that should create the file EnvatoCustomServiceProvider.php under the app/Providers directory. Open the file to see what it holds.
<?php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
class EnvatoCustomServiceProvider extends ServiceProvider
{
/**
* Register services.
*
* @return void
*/
public function register()
{
//
}
/**
* Bootstrap services.
*
* @return void
*/
public function boot()
{
//
}
}
As we discussed earlier, there are two methods, register and boot, that you'll be dealing with most of the time when you work with your custom service provider.
The register method is the place where you define all your custom service container bindings. On the other hand, the boot method is the place where you can consume already registered services via the register method. In the last segment of this article, we'll discuss these two methods in detail as we'll go through some practical use cases to understand the usage of both methods.
Register Your Custom Service Provider:
So you've created your custom service provider. That's great! Next, you need to inform Laravel about your custom service provider so that it can load it along with other service providers during bootstrapping.
To register your service provider, you just need to add an entry to the array of service providers in the config/app.php file. Add the following line to the providers array:
App\Providers\EnvatoCustomServiceProvider::class,
And that's it—you've registered your service provider with Laravel! But the service provider we've created is almost a blank template and is of no use at the moment. In the next section, we'll go through a couple of practical examples to see what you could do with the register and boot methods.
Create the Register and Boot Methods:
To start with, we'll go through the register method to understand how you could actually use it. Open the service provider file app/Providers/EnvatoCustomServiceProvider.php that was created earlier, and replace the existing code with the following.
<?php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
use App\Library\Services\DemoOne;
class EnvatoCustomServiceProvider extends ServiceProvider
{
public function boot()
{
}
public function register()
{
$this->app->bind('App\Library\Services\DemoOne', function ($app) {
return new DemoOne();
});
}
}
There are two important things to note here:
- We've imported
App\Library\Services\DemoOneso that we can use it. TheDemoOneclass isn't created yet, but we'll do that in a moment. - In the register method, we've used the
bindmethod of the service container to add our service container binding. So, whenever theApp\Library\Services\DemoOnedependency needs to be resolved, it'll call the closure function, and it instantiates and returns theApp\Library\Services\DemoOneobject.
So you just need to create the app/Library/Services/DemoOne.php file for this to work.
<?php
namespace App\Library\Services;
class DemoOne
{
public function doSomethingUseful()
{
return 'Output from DemoOne';
}
}
And here's the code somewhere in your controller where the dependency will be injected.
<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Library\Services\DemoOne;
class TestController extends Controller
{
public function index(DemoOne $customServiceInstance)
{
echo $customServiceInstance->doSomethingUseful();
}
}
That's a very simple example of binding a class. In fact, in the above example, there's no need to create a service provider and implement the register method as we did, since Laravel can automatically resolve it using reflection.
Implement the boot Method:
The next candidate is the boot method, which you could use to extend the core Laravel functionality. In this method, you could access all the services that were registered using the register method of the service provider. In most cases, you want to register your event listeners in this method, which will be triggered when something happens.
Let's have a look at a couple of examples that require the boot method implementation.
If you want to register a view composer, it's the perfect place to do that! In fact, the boot method is frequently used to add view composers!
public function boot()
{
View::composer(
'demo', 'App\Http\ViewComposers\DemoComposer'
);
}
Of course, you want to import a facade Illuminate\Support\Facades\View in your service provider first.
In the same vein, you could share the data across multiple views as well.
public function boot()
{
View::share('key', 'value');
}
Conclusion:
In this article, we started with a look at the service container. Then we looked at service providers and how they are connected with the service container.
Following that, we developed a custom service provider, and in the latter half of the article we went through a couple of practical examples.
1 Comments
Post Comment
Trending Posts
-
Adding Google ReCaptcha to forms in Laravel
13 Sep 2022
-
What is Migration in Laravel
21 Sep 2022
-
Difference Between Let And Const In Javascript
16 Jul 2022
-
What is Events and Listeners in Laravel
04 Mar 2023
shaheryar bhatti