Service providers

Comment utiliser les service providers de Laravel pour enregistrer et amorcer les services de votre application.

​

Qu’est-ce qu’un service provider

Les service providers constituent le point central de l’amorçage (bootstrapping) d’une application Laravel. Votre propre application, comme tous les services centraux de Laravel, est amorcée via des service providers.

Par « amorcer », on entend enregistrer des choses : bindings au conteneur de services, listeners d’événements, middlewares, routes… Les service providers sont l’endroit central où configurer l’application.

En interne, Laravel utilise de nombreux service providers pour amorcer ses services centraux : mailer, queue, cache, etc. Beaucoup sont « différés » : ils ne sont pas chargés à chaque requête, mais uniquement lorsque le service qu’ils fournissent est réellement demandé.

Tous les service providers utilisateur s’enregistrent dans bootstrap/providers.php.

Pour en savoir plus sur la façon dont Laravel traite une requête, consultez la documentation du cycle de vie d’une requête.

​

Écrire un service provider

Tous les service providers héritent de Illuminate\Support\ServiceProvider. La plupart contiennent une méthode register et une méthode boot.

Pour générer un provider, utilisez la commande Artisan make:provider. Laravel l’ajoute automatiquement à bootstrap/providers.php.

php artisan make:provider RiakServiceProvider

​

Méthode register

Dans register, contentez-vous d’enregistrer des bindings dans le conteneur de services. Ne tentez pas d’enregistrer des listeners, des routes ou d’autres fonctionnalités : vous pourriez utiliser par mégarde un service dont le provider n’est pas encore chargé.

<?php

namespace App\Providers;

use App\Services\Riak\Connection;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider
{
    /**
     * Enregistre les services de l'application.
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}

Dans un service provider, $this->app donne accès au conteneur de services.

​

Propriétés bindings et singletons

Pour de nombreux bindings simples, plutôt que de les enregistrer un par un, utilisez les propriétés bindings et singletons. Laravel les inspecte automatiquement lors du chargement du provider.

<?php

namespace App\Providers;

use App\Contracts\DowntimeNotifier;
use App\Contracts\ServerProvider;
use App\Services\DigitalOceanServerProvider;
use App\Services\PingdomDowntimeNotifier;
use App\Services\ServerToolsProvider;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Tous les bindings du conteneur à enregistrer.
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Tous les singletons du conteneur à enregistrer.
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class => ServerToolsProvider::class,
    ];
}

​

Méthode boot

Enregistrez les view composers dans boot. Cette méthode est appelée après l’enregistrement de tous les autres providers, ce qui garantit l’accès à tous les services enregistrés par le framework.

<?php

namespace App\Providers;

use Illuminate\Support\Facades\View;
use Illuminate\Support\ServiceProvider;

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Amorce les services de l'application.
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}

Ne confondez pas les rôles de register et boot. register sert uniquement à l’enregistrement des bindings ; boot sert à l’initialisation des services et au reste.

​

Injection dans boot

Vous pouvez également injecter des dépendances dans boot via type-hint. Le conteneur les résout automatiquement.

use Illuminate\Contracts\Routing\ResponseFactory;

/**
 * Amorce les services de l'application.
 */
public function boot(ResponseFactory $response): void
{
    $response->macro('serialized', function (mixed $value) {
        // ...
    });
}

​

Enregistrement des service providers

Tous les service providers s’enregistrent dans bootstrap/providers.php. Ce fichier retourne un tableau de noms de classes de providers.

<?php

return [
    App\Providers\AppServiceProvider::class,
];

Sous Laravel 13, l’enregistrement se fait dans bootstrap/providers.php et non plus dans le tableau providers de config/app.php. make:provider l’ajoute automatiquement.

Après make:provider, Laravel ajoute automatiquement le provider. Si vous créez la classe manuellement, ajoutez-la vous-même au tableau.

<?php

return [
    App\Providers\AppServiceProvider::class,
    App\Providers\ComposerServiceProvider::class,
];

​

Créer un service provider personnalisé

Voyons comment en créer un.

1. Générer le provider

   php artisan make:provider PaymentServiceProvider
   
2. Ajouter les bindings dans `register`

   <?php
   
   namespace App\Providers;
   
   use App\Contracts\PaymentGateway;
   use App\Services\StripePaymentGateway;
   use Illuminate\Contracts\Foundation\Application;
   use Illuminate\Support\ServiceProvider;
   
   class PaymentServiceProvider extends ServiceProvider
   {
       /**
        * Enregistre les services de l'application.
        */
       public function register(): void
       {
           $this->app->singleton(PaymentGateway::class, function (Application $app) {
               return new StripePaymentGateway(
                   config('services.stripe.secret')
               );
           });
       }
   
       /**
        * Amorce les services de l'application.
        */
       public function boot(): void
       {
           // Placez ici l'initialisation éventuelle
       }
   }
   
3. Ajouter à `bootstrap/providers.php`

   Avec make:provider, c’est automatique ; sinon, ajoutez-le manuellement.

   <?php
   
   return [
       App\Providers\AppServiceProvider::class,
       App\Providers\PaymentServiceProvider::class,
   ];
   

​

Providers différés (Deferred Providers)

Si un provider n’enregistre que des bindings, vous pouvez différer son chargement jusqu’à ce que ces bindings soient réellement demandés. Cela évite de charger le provider sur chaque requête et améliore les performances.

Pour créer un provider différé, implémentez \Illuminate\Contracts\Support\DeferrableProvider et définissez la méthode provides qui retourne les bindings enregistrés.

<?php

namespace App\Providers;

use App\Services\Riak\Connection;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider implements DeferrableProvider
{
    /**
     * Enregistre les services de l'application.
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
                return new Connection(config('riak'));
            });
    }

    /**
     * Retourne les services fournis par le provider.
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}

Les providers différés conviennent aux services utilisés dans un contexte précis, non partout dans l’application. On évite le chargement inutile et on optimise les performances.

​

Prochaines étapes

Conteneur de services

Approfondissez le fonctionnement du conteneur de services et les bindings.