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

> Explicamos cómo usar los service providers de Laravel para registrar e inicializar los servicios de la aplicación.

## ¿Qué es un service provider?

Los service providers son el lugar central donde se realiza el bootstrapping de toda una aplicación Laravel. Tanto tu propia aplicación como todos los servicios centrales de Laravel se inicializan a través de service providers.

Por "bootstrap" entendemos **registrar** cosas como bindings del contenedor de servicios, listeners de eventos, middleware, rutas y demás. Los service providers son el lugar central donde configuras la aplicación.

```mermaid theme={null}
flowchart TD
    A["Arranque de la aplicación"] --> B["Se lee bootstrap/providers.php"]
    B --> C["Instanciación de todos los providers"]
    C --> D["Se ejecuta register() de todos<br>Solo bindings del contenedor"]
    D --> E["Se ejecuta boot() de todos<br>View composers, listeners, etc."]
    E --> F["Aplicación lista<br>Comienza el manejo de solicitudes"]
```

Internamente, Laravel usa muchos service providers para inicializar servicios centrales como mailer, colas o caché. Muchos son "diferidos": no se cargan en cada solicitud, sino solo cuando se necesita realmente el servicio que ofrecen.

Los service providers definidos por el usuario se registran en `bootstrap/providers.php`.

<Info>
  Si quieres profundizar en cómo Laravel procesa las solicitudes, consulta la documentación de [Ciclo de vida de la solicitud](https://laravel.com/docs/lifecycle).
</Info>

## Escribir un service provider

Todos los service providers extienden `Illuminate\Support\ServiceProvider`. La mayoría incluyen los métodos `register` y `boot`.

Genera un nuevo provider con el comando Artisan `make:provider`. Laravel lo registra automáticamente en `bootstrap/providers.php`.

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

### El método register

Dentro de `register` **solo** debes hacer bindings al [contenedor de servicios](/es/service-container). No registres listeners de eventos, rutas u otras funcionalidades en `register`. Podrías acabar usando por error servicios que aún no se hayan cargado.

```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
{
    /**
     * Registra los servicios de la aplicación
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}
```

Dentro de los métodos del provider, siempre puedes acceder al contenedor a través de `$this->app`.

#### Propiedades bindings y singletons

Si vas a registrar muchos bindings sencillos, en vez de hacerlo manualmente puedes usar las propiedades `bindings` y `singletons`. Cuando el framework carga el provider, comprueba automáticamente estas propiedades y registra los bindings.

```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
{
    /**
     * Todos los bindings a registrar en el contenedor
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Todos los singletons a registrar en el contenedor
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class => ServerToolsProvider::class,
    ];
}
```

### El método boot

Si registras un [view composer](https://laravel.com/docs/views#view-composers) en un service provider, hazlo en `boot`. **Este método se llama después de que todos los service providers estén registrados**, lo que significa que puedes acceder a todos los servicios registrados por el framework.

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

namespace App\Providers;

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

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Inicia los servicios de la aplicación
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}
```

<Warning>
  No confundas los papeles de `register` y `boot`. `register` es solo para registrar bindings; `boot` es para inicializar servicios y otras tareas de arranque.
</Warning>

#### Inyección de dependencias en boot

En `boot` también puedes usar type-hints para inyectar dependencias. El [contenedor de servicios](/es/service-container) las resuelve automáticamente.

```php theme={null}
use Illuminate\Contracts\Routing\ResponseFactory;

/**
 * Inicia los servicios de la aplicación
 */
public function boot(ResponseFactory $response): void
{
    $response->macro('serialized', function (mixed $value) {
        // ...
    });
}
```

## Cómo registrar service providers

Todos los service providers se registran en `bootstrap/providers.php`. Este archivo devuelve un array con los nombres de las clases de service provider de la aplicación.

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

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

<Info>
  En Laravel 13, los service providers se registran en `bootstrap/providers.php`, no en el array `providers` de `config/app.php`. `make:provider` añade la entrada automáticamente.
</Info>

Cuando ejecutas `make:provider`, Laravel añade automáticamente el provider al archivo. Si creas la clase manualmente, añádela tú mismo al array.

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

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

## Creación de un service provider personalizado

Vamos a crear un service provider personalizado paso a paso.

<Steps>
  <Step title="Generar el provider">
    Genera el service provider con Artisan.

    ```shell theme={null}
    php artisan make:provider PaymentServiceProvider
    ```
  </Step>

  <Step title="Hacer el binding en register">
    Escribe el binding en el método `register` del provider generado.

    ```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
    {
        /**
         * Registra los servicios de la aplicación
         */
        public function register(): void
        {
            $this->app->singleton(PaymentGateway::class, function (Application $app) {
                return new StripePaymentGateway(
                    config('services.stripe.secret')
                );
            });
        }

        /**
         * Inicia los servicios de la aplicación
         */
        public function boot(): void
        {
            // Escribe aquí la lógica de arranque si es necesario
        }
    }
    ```
  </Step>

  <Step title="Registrar en bootstrap/providers.php">
    Si usas `make:provider`, se añade automáticamente. Si no, añádelo tú mismo.

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

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

## Providers diferidos (Deferred Providers)

Si el provider solo registra bindings del contenedor de servicios, puedes diferir su registro hasta que realmente se necesiten. Al diferir su carga se evita leerlo del sistema de archivos en cada solicitud, mejorando el rendimiento.

```mermaid theme={null}
flowchart TD
    A["Arranque de la aplicación"] --> B["Se cargan e inicializan los providers normales"]
    B --> C["Los providers diferidos<br>solo registran la lista de servicios que ofrecen"]
    C --> D["Procesamiento de la solicitud"]
    D --> E{{"¿Se solicitó un servicio<br>de un provider diferido?"}}
    E -->|"No"| F["El provider no se carga<br>Se ahorra memoria y trabajo"]
    E -->|"Sí"| G["El provider se carga en ese momento"]
    G --> H["Se ejecuta register()"]
    H --> I["El servicio se sirve desde el contenedor"]
```

Para crear un provider diferido, implementa la interfaz `\Illuminate\Contracts\Support\DeferrableProvider` y define el método `provides`. `provides` devuelve los bindings del contenedor que registra el provider.

```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
{
    /**
     * Registra los servicios de la aplicación
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
                return new Connection(config('riak'));
            });
    }

    /**
     * Obtiene los servicios que ofrece el provider
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}
```

<Tip>
  Los providers diferidos son adecuados para servicios que solo se usan en ciertas funcionalidades y no en toda la aplicación. Al evitar la carga de servicios innecesarios optimizas el rendimiento.
</Tip>

## Próximos pasos

<Card title="Contenedor de servicios" icon="box" href="/es/service-container">
  Consulta los detalles del funcionamiento del contenedor de servicios y sus bindings.
</Card>


## Related topics

- [Service providers diferidos](/es/advanced/deferred-provider.md)
- [FAQ de la nueva estructura de aplicación de Laravel 11 y posteriores](/es/advanced/app-structure-faq.md)
- [Ciclo de vida de la solicitud](/es/lifecycle.md)
- [Guía de migración de la estructura antigua a la nueva](/es/advanced/app-structure-migration.md)
- [Actualización de Laravel 10 a 11](/es/blog/upgrade-10-to-11.md)