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

> Erfahren Sie, wie Sie mit den Service-Providern von Laravel die Dienste Ihrer Anwendung registrieren und starten.

## Was sind Service-Provider

Service-Provider sind der zentrale Ort, an dem eine gesamte Laravel-Anwendung gebootstrapt wird. Sowohl Ihre eigene Anwendung als auch alle Kernservices von Laravel werden über Service-Provider gebootstrapt.

Unter „Bootstrapping" versteht man das **Registrieren** unterschiedlichster Dinge, etwa Bindings im Service-Container, Event-Listener, Middleware und Routen. Service-Provider sind also die zentrale Stelle, an der Sie Ihre Anwendung konfigurieren.

```mermaid theme={null}
flowchart TD
    A["Anwendung startet"] --> B["bootstrap/providers.php laden"]
    B --> C["Alle Provider instanziieren"]
    C --> D["register() aller Provider ausführen<br>nur Bindings im Service-Container"]
    D --> E["boot() aller Provider ausführen<br>View-Composer, Event-Listener usw."]
    E --> F["Anwendung bereit<br>Verarbeitung von Requests beginnt"]
```

Intern verwendet Laravel zahlreiche Service-Provider, um Kerndienste wie Mailer, Queue und Cache zu bootstrappen. Viele davon sind „deferred provider" (verzögerte Provider): Sie werden nicht bei jedem Request geladen, sondern erst dann, wenn der von ihnen bereitgestellte Dienst tatsächlich benötigt wird.

Alle benutzerdefinierten Service-Provider werden in der Datei `bootstrap/providers.php` registriert.

<Info>
  Wenn Sie genauer verstehen möchten, wie Laravel Anfragen verarbeitet, sehen Sie sich die Dokumentation zum [Request-Lebenszyklus](https://laravel.com/docs/lifecycle) an.
</Info>

## Einen Service-Provider schreiben

Jeder Service-Provider erweitert die Klasse `Illuminate\Support\ServiceProvider`. Die meisten Service-Provider besitzen eine `register`- und eine `boot`-Methode.

Um einen neuen Provider zu erzeugen, verwenden Sie den Artisan-Befehl `make:provider`. Laravel registriert den neuen Provider automatisch in `bootstrap/providers.php`.

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

### Die `register`-Methode

Innerhalb der `register`-Methode sollten Sie ausschließlich Bindings im [Service-Container](/de/service-container) registrieren. Registrieren Sie in `register` keine Event-Listener, Routen oder andere Funktionen. Andernfalls könnten Sie versehentlich einen Service verwenden, der von einem noch nicht geladenen Service-Provider bereitgestellt wird.

```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
{
    /**
     * Anwendungsdienste registrieren
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}
```

Innerhalb der Methoden eines Service-Providers können Sie über die Eigenschaft `$this->app` jederzeit auf den Service-Container zugreifen.

#### Die Eigenschaften `bindings` und `singletons`

Wenn Sie viele einfache Bindings registrieren, können Sie statt jedes Binding einzeln zu registrieren die Eigenschaften `bindings` und `singletons` nutzen. Beim Laden des Service-Providers prüft das Framework diese Eigenschaften automatisch und registriert die 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
{
    /**
     * Alle zu registrierenden Container-Bindings
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Alle zu registrierenden Container-Singletons
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class => ServerToolsProvider::class,
    ];
}
```

### Die `boot`-Methode

Wenn Sie innerhalb eines Service-Providers einen [View-Composer](https://laravel.com/docs/views#view-composers) registrieren möchten, tun Sie dies in der `boot`-Methode. **Diese Methode wird erst aufgerufen, nachdem alle anderen Service-Provider registriert wurden.** Sie haben daher Zugriff auf alle vom Framework registrierten Dienste.

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

namespace App\Providers;

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

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Anwendungsdienste starten
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}
```

<Warning>
  Verwechseln Sie die Aufgaben der Methoden `register` und `boot` nicht: `register` dient ausschließlich zum Registrieren von Bindings, `boot` zur Initialisierung von Services und weiterem Setup.
</Warning>

#### Dependency Injection in `boot`

Auch in der `boot`-Methode können Sie Abhängigkeiten per Type-Hint entgegennehmen. Der [Service-Container](/de/service-container) injiziert die benötigten Abhängigkeiten automatisch.

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

/**
 * Anwendungsdienste starten
 */
public function boot(ResponseFactory $response): void
{
    $response->macro('serialized', function (mixed $value) {
        // ...
    });
}
```

## Service-Provider registrieren

Alle Service-Provider werden in der Datei `bootstrap/providers.php` registriert. Diese Datei gibt ein Array mit den Klassennamen der Service-Provider Ihrer Anwendung zurück.

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

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

<Info>
  In Laravel 13 registrieren Sie Service-Provider nicht mehr im `providers`-Array von `config/app.php`, sondern in `bootstrap/providers.php`. Beim Verwenden des Befehls `make:provider` erfolgt der Eintrag automatisch.
</Info>

Wenn Sie den Artisan-Befehl `make:provider` verwenden, trägt Laravel den Provider automatisch in die Datei ein. Erstellen Sie die Provider-Klasse manuell, müssen Sie den Klassennamen selbst in das Array eintragen.

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

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

## Einen eigenen Service-Provider erstellen

Erstellen wir nun praktisch einen eigenen Service-Provider.

<Steps>
  <Step title="Provider erzeugen">
    Legen Sie den Service-Provider mit dem Artisan-Befehl an.

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

  <Step title="In der register-Methode binden">
    Tragen Sie die Bindings in die `register`-Methode des erzeugten Providers ein.

    ```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
    {
        /**
         * Anwendungsdienste registrieren
         */
        public function register(): void
        {
            $this->app->singleton(PaymentGateway::class, function (Application $app) {
                return new StripePaymentGateway(
                    config('services.stripe.secret')
                );
            });
        }

        /**
         * Anwendungsdienste starten
         */
        public function boot(): void
        {
            // Falls beim Starten etwas zu tun ist, hier einfügen
        }
    }
    ```
  </Step>

  <Step title="In bootstrap/providers.php registrieren">
    Bei Verwendung von `make:provider` erfolgt der Eintrag automatisch. Andernfalls fügen Sie ihn manuell hinzu.

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

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

## Deferred Providers (verzögerte Provider)

Wenn ein Provider ausschließlich Bindings im Service-Container registriert, kann die Registrierung so lange verzögert werden, bis eines dieser Bindings tatsächlich benötigt wird. Da solche Provider nicht bei jedem Request vom Dateisystem geladen werden müssen, verbessert sich die Performance Ihrer Anwendung.

```mermaid theme={null}
flowchart TD
    A["Anwendung startet"] --> B["Reguläre Provider laden und initialisieren"]
    B --> C["Deferred Provider merken sich<br>nur die Liste bereitgestellter Dienste"]
    C --> D["Request-Verarbeitung"]
    D --> E{{"Wurde ein Dienst eines<br>deferred Providers angefordert?"}}
    E -->|"Nein"| F["Provider wird nicht geladen<br>spart Speicher und Rechenzeit"]
    E -->|"Ja"| G["Provider wird zur Laufzeit geladen"]
    G --> H["register() ausführen"]
    H --> I["Dienst aus dem Container bereitstellen"]
```

Um einen deferred Provider anzulegen, implementieren Sie das Interface `\Illuminate\Contracts\Support\DeferrableProvider` und definieren die Methode `provides`. Die Methode `provides` gibt die vom Provider registrierten Container-Bindings zurück.

```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
{
    /**
     * Anwendungsdienste registrieren
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
                return new Connection(config('riak'));
            });
    }

    /**
     * Vom Provider bereitgestellte Dienste ermitteln
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}
```

<Tip>
  Deferred Provider eignen sich besonders für Dienste, die nicht in der gesamten Anwendung, sondern nur in bestimmten Funktionen benötigt werden. So vermeiden Sie das Laden nicht benötigter Dienste und optimieren die Performance.
</Tip>

## Nächste Schritte

<Card title="Service-Container" icon="box" href="/de/service-container">
  Sehen Sie sich die Funktionsweise des Service-Containers und die Details der Bindings an.
</Card>


## Related topics

- [Deferred Service Provider](/de/advanced/deferred-provider.md)
- [Service-Container](/de/service-container.md)
- [FAQ zur neuen App-Struktur ab Laravel 11](/de/advanced/app-structure-faq.md)
- [Request-Lebenszyklus](/de/lifecycle.md)
- [Einen eigenen Provider für das AI SDK erstellen](/de/advanced/ai-sdk-custom-provider.md)