Mitä ovat kontrollerit NestJS:ssä?

Question

IT Interview Practice · Accepted Answer

**Controllers** käsittelevät saapuvia **HTTP-pyyntöjä** ja palauttavat vastauksia. Ne määrittelevät sovelluksesi reitit ja toimivat sisääntulopisteenä — vastaanottavat pyynnöt, poistavat tietoja, delegoivat palveluihin ja palauttavat tuloksia. Ne pitävät reitityksen huolenaiheet erillään liiketoimintalogiikasta.

## Kontrollerin määrittäminen

```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);
  }
}
```

## Kuinka se toimii: koristeluilla kuvataan metodit reiteille

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

Koristerakenteilla sidotaan deklaratiivisesti luokkametodit HTTP-reiteille — puhtaasti ja luettavasti, ilman manuaalista reittirekisteröintiä.

## Parametrikoristerakenteen purkaa pyynnön tiedot

```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)
) {}
```

Nestin parametrikoristerakenteet (`@Param`, `@Query`, `@Body`, `@Headers`) purkavat puhtaasti tarkalleen ne tiedot, joita tarvitset — ilman `req`:n manuaalista jäsentämistä.

## Kontrollerin tulee olla OHUT

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

Paras käytäntö: pidä kontrollerit **ohuina** — ne käsittelevät HTTP-huolia (reititys, tietojen poistaminen, vastausten palauttaminen) ja delegoivat kaikki liiketoimintalogiikan **palveluihin**. Tämä erotus pitää koodin testattavana ja järjestettynä.

## Miksi se on tärkeää

Kontrollerit ovat NestJS:n perusrakennesarja — sisääntulopiste kaikille HTTP-pyynnöille ja paikka, jossa API:n reitit määritetään.

Ymmärtää, kuinka koristerakenteet (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) kuvaavat metodeja reiteille ja purkavat pyynnön tiedot deklaratiivisesti, on olennaista päivittäistä NestJS-tietoa — näin rakennat minkä tahansa päätepisteen.

Yhtä tärkeä on periaate, jossa kontrollerit pidetään **ohuina** (käsitellään vain HTTP-huolia ja delegoidaan liiketoimintalogiikka injektoiduille palveluille), mikä sisältää NestJS:n separation-of-concerns-filosofiaa ja pitää koodin ylläpidettävänä ja testattavana.

Kontrollerit yhdessä palveluiden ja moduulien kanssa muodostavat jokaisen NestJS-sovelluksen perusrakenteen, mikä tekee niistä oleellisia ymmärtää alusta alkaen.

Kontrollerin määrittäminen

Kuinka se toimii: koristeluilla kuvataan metodit reiteille

Parametrikoristerakenteen purkaa pyynnön tiedot

Kontrollerin tulee olla OHUT

Miksi se on tärkeää

Aiheeseen liittyvät kysymykset