> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

```mermaid theme={null}
flowchart TD
    A["Démarrage de l'application"] --> B["Lecture de bootstrap/providers.php"]
    B --> C["Instanciation de tous les providers"]
    C --> D["Exécution de register() pour tous<br>Bindings dans le conteneur uniquement"]
    D --> E["Exécution de boot() pour tous<br>View composers, listeners, etc."]
    E --> F["Application prête<br>Début du traitement des requêtes"]
```

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`.

<Info>
  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](https://laravel.com/docs/lifecycle).
</Info>

## É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`.

```shell theme={null}
php artisan make:provider RiakServiceProvider
```

### Méthode `register`

Dans `register`, contentez-vous d'enregistrer des bindings dans le [conteneur de services](/fr/service-container). 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 theme={null}
<?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 theme={null}
<?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](https://laravel.com/docs/views#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 theme={null}
<?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 () {
            // ...
        });
    }
}
```

<Warning>
  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.
</Warning>

#### Injection dans `boot`

Vous pouvez également injecter des dépendances dans `boot` via type-hint. Le [conteneur](/fr/service-container) les résout automatiquement.

```php theme={null}
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 theme={null}
<?php

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

<Info>
  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.
</Info>

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

```php theme={null}
<?php

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

## Créer un service provider personnalisé

Voyons comment en créer un.

<Steps>
  <Step title="Générer le provider">
    ```shell theme={null}
    php artisan make:provider PaymentServiceProvider
    ```
  </Step>

  <Step title="Ajouter les bindings dans `register`">
    ```php theme={null}
    <?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
        }
    }
    ```
  </Step>

  <Step title="Ajouter à `bootstrap/providers.php`">
    Avec `make:provider`, c'est automatique ; sinon, ajoutez-le manuellement.

    ```php theme={null}
    <?php

    return [
        App\Providers\AppServiceProvider::class,
        App\Providers\PaymentServiceProvider::class,
    ];
    ```
  </Step>
</Steps>

## 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.

```mermaid theme={null}
flowchart TD
    A["Démarrage de l'application"] --> B["Chargement et initialisation des providers normaux"]
    B --> C["Les providers différés n'enregistrent<br>que la liste de leurs services"]
    C --> D["Traitement des requêtes"]
    D --> E{{"Un service d'un provider<br>différé est demandé ?"}}
    E -->|"Non"| F["Le provider n'est pas chargé<br>Économie de mémoire et de temps"]
    E -->|"Oui"| G["Le provider est chargé à la volée"]
    G --> H["Exécution de register()"]
    H --> I["Le conteneur fournit le service"]
```

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 theme={null}
<?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];
    }
}
```

<Tip>
  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.
</Tip>

## Prochaines étapes

<Card title="Conteneur de services" icon="box" href="/fr/service-container">
  Approfondissez le fonctionnement du conteneur de services et les bindings.
</Card>


## Related topics

- [Service providers différés](/fr/advanced/deferred-provider.md)
- [Conteneur de services](/fr/service-container.md)
- [Cycle de vie d'une requête](/fr/lifecycle.md)
- [FAQ sur la nouvelle structure d'application Laravel 11+](/fr/advanced/app-structure-faq.md)
- [Guide de migration de l'ancienne vers la nouvelle structure](/fr/advanced/app-structure-migration.md)