Was sind Controllers in NestJS?

Question

Accepted Answer

**Controllers** verarbeiten eingehende **HTTP-Anfragen** und geben Antworten zurück. Sie definieren die Routen deiner Anwendung und fungieren als Einstiegspunkt — sie empfangen Anfragen, extrahieren Daten, delegieren an Services und geben Ergebnisse zurück. Sie halten Routing-Belange von Geschäftslogik getrennt.

## Definition eines Controllers

```ts
import { Controller, Get, Post, Body, Param } from "@nestjs/common";

@Controller("users")          // the route PREFIX → all routes start with /users
export class UsersController {
  constructor(private usersService: UsersService) {}   // inject a service via DI

@Get()                       // GET /users
  findAll() {
    return this.usersService.findAll();
  }

@Get(":id")                  // GET /users/:id
  findOne(@Param("id") id: string) {        // extract the route param
    return this.usersService.findOne(id);
  }

@Post()                      // POST /users
  create(@Body() dto: CreateUserDto) {       // extract the request body
    return this.usersService.create(dto);
  }
}
```

## So funktioniert es: Dekoratoren bilden Methoden auf Routen ab

```text
@Controller("users") → route prefix /users
@Get() / @Post() / @Put() / @Patch() / @Delete() → HTTP method + sub-path
Combined: @Get(":id") inside @Controller("users") → GET /users/:id
```

Dekoratoren binden Klassenmethoden deklarativ an HTTP-Routen — sauber und lesbar, ohne manuelle Route Registration.

## Parameter-Dekoratoren extrahieren Anfragedaten

```ts
@Get(":id")
example(
  @Param("id") id: string,        // route parameter (/users/:id)
  @Query("sort") sort: string,    // query string (?sort=name)
  @Body() body: CreateUserDto,    // request body
  @Headers("authorization") auth: string,  // a header
  @Req() req: Request,            // the raw request object (rarely needed)
) {}
```

Nests Parameter-Dekoratoren (`@Param`, `@Query`, `@Body`, `@Headers`) extrahieren sauber genau die Daten, die du brauchst — ohne manuelles Parsing von `req`.

## Controller sollten DÜNN sein

```ts
// ✅ controller delegates to a service — stays thin
@Post()
create(@Body() dto: CreateUserDto) {
  return this.usersService.create(dto);   // business logic lives in the SERVICE
}
// ❌ don't put database queries / business logic directly in the controller
```

Best Practice: Halte Controller **dünn** — sie behandeln HTTP-Belange (Routing, Datenextraktion, Rückgabe von Antworten) und delegieren alle Geschäftslogik an **Services**. Diese Trennung hält Code testbar und organisiert.

## Warum es wichtig ist

Controller sind ein grundlegender NestJS-Baustein — der Einstiegspunkt für alle HTTP-Anfragen und der Ort, an dem die Routen deiner API definiert sind.

Das Verstehen, wie Dekoratoren (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) Methoden auf Routen abbilden und deklarativ Anfragedaten extrahieren, ist essentielles alltägliches NestJS-Wissen — so baust du jeden Endpoint.

Genauso wichtig ist das Prinzip, Controller **dünn** zu halten (nur HTTP-Belange zu behandeln und Geschäftslogik an injizierte Services zu delegieren), was NestJS's Separation-of-Concerns-Philosophie verkörpert und Code wartbar und testbar hält.

Controller bilden zusammen mit Services und Modulen die Kernstruktur jeder NestJS-Anwendung, weshalb es wichtig ist, sie von Anfang an zu verstehen.