Was sind Provider und Services?

Question

Accepted Answer

In NestJS ist ein **Provider** jede Klasse, die als Abhängigkeit **injiziert** werden kann, und ein **Service** ist die häufigste Art — eine Klasse, die **Geschäftslogik** enthält. Das Kennzeichnen einer Klasse mit `@Injectable()` macht sie zu einem Provider, den das DI-System von NestJS erstellen und injizieren kann.

## Einen Service definieren (die häufigste Art von Provider)

```ts
import { Injectable } from "@nestjs/common";

@Injectable()              // marks the class as a provider (injectable)
export class UsersService {
  private users = [];

findAll() { return this.users; }                  // business logic
  findOne(id: string) { return this.users.find(u => u.id === id); }
  create(data) { this.users.push(data); return data; }
}
```

Der Dekorator `@Injectable()` teilt NestJS mit, dass diese Klasse an Dependency Injection teilnimmt — sie kann in Controller oder andere Provider injiziert werden.

## Injizieren eines Service über den Konstruktor

```ts
@Controller("users")
export class UsersController {
  // NestJS sees this parameter and INJECTS a UsersService instance automatically
  constructor(private usersService: UsersService) {}

@Get()
  findAll() {
    return this.usersService.findAll();   // use the injected service
  }
}
```

Sie deklarieren die Abhängigkeit als Konstruktorparameter; NestJS erstellt und liefert die Instanz — Sie schreiben niemals `new UsersService()`.

## Registrieren von Providern in einem Modul

```ts
@Module({
  controllers: [UsersController],
  providers: [UsersService],        // register the provider so DI can resolve it
  exports: [UsersService],          // make it available to OTHER modules that import this one
})
export class UsersModule {}
```

Provider müssen in dem `providers`-Array eines Moduls registriert werden, damit DI von ihnen weiß, und `exports` teilt sie mit anderen Modulen.

## Provider sind standardmäßig Singletons

```text
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
```

## Warum Services von Controllern trennen?

```text
Controller → handles HTTP (routing, request/response)
Service    → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
  TESTABLE (test the service in isolation), and ORGANIZED.
```

## Warum es wichtig ist

Provider und Services sind zentral für die Architektur von NestJS und sein Dependency-Injection-gestütztes Design.

Services enthalten die **Geschäftslogik** der Anwendung und sind von Controllern (die nur mit HTTP-Belangen umgehen) getrennt — diese Trennung der Belange macht die Logik wiederverwendbar über Controller hinweg, leicht isoliert testbar und gut organisiert.

Zu verstehen, dass `@Injectable()` eine Klasse als injizierbar Provider kennzeichnet, dass Provider in Modulen registriert und über Konstruktoren injiziert werden (DI erstellt die Instanzen für Sie), und dass sie standardmäßig Singletons sind, ist fundamentales tägliches NestJS-Wissen.

Das Provider/Service-Muster, kombiniert mit Controllern und Modulen, ist das Rückgrat jeder NestJS-Anwendung — seine Beherrschung ist wesentlich für den Aufbau gut strukturierter, wartbarer Backends und gehört zu den ersten Konzepten, die man in dem Framework lernen sollte.