NestJS-yritysbackendien API:t · Oppitunti

Reitit ja pyyntöjen käsittely

Määrittäkää API-reittejä, käsitelkää eri HTTP-metodeja ja poimikaa tietoja pyyntöjen leipäosista, parametreista ja kyselyistä.

Oppitunti 1/312 vaihetta

Reitit ja pyyntöjen käsittely on ilmainen NestJS-yritysbackendien API:t-oppitunti CoddyKitissä. Tämä on oppitunti 1/3. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu NestJS-yritysbackendien API:t-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. NestJS-yritysbackendien API:t-kurssilla on yhteensä 3 oppituntia.

API-reittien ymmärtäminen

Web-rajapintaa rakennettaessa tarvitaan tapa, jolla asiakkaat, kuten selain tai mobiilisovellus, voivat lähettää pyyntöjä palvelimen tiettyihin toimintoihin. Tähän tarvitaan reittejä!

Reitti määrittää, miten asiakkaan pyynnön URL-osoite (kuten /users tai /products/1) yhdistyy tiettyyn toimintaan sovelluksen koodissa. Se on kuin rajapinnan toimintojen katuosoite.

HTTP-metodit: toiminnan verbit

URL-osoitteen lisäksi jokainen pyyntö käyttää HTTP-metodia, joka kertoo palvelimelle, millaisen toiminnon asiakas haluaa suorittaa. Yleisiä metodeja ovat:

GET: Hakee tietoja (esimerkiksi käyttäjäluettelon).
POST: Luo uusia tietoja (esimerkiksi uuden käyttäjän).
PUT: Päivittää olemassa olevat tiedot kokonaan.
PATCH: Päivittää olemassa olevia tietoja osittain.
DELETE: Poistaa tietoja.

NestJS yhdistää nämä metodit ohjainten funktioihin dekorointiominaisuuksilla, kuten @Get() ja @Post().

Ensimmäinen GET-reittinne

Määritetään yksinkertainen reitti tietojen hakemista varten. NestJS:ssä saapuvia pyyntöjä käsitellään ja reittejä määritetään ohjaimilla.

@Controller()-dekorointiominaisuus määrittää kaikkien kyseisen ohjaimen reittien peruspolun. Sen jälkeen @Get()-metodin kaltaiset metodit määrittävät yksittäiset päätepisteet ja niiden HTTP-metodit.

Yksinkertainen GET-reittiesimerkki

Tässä on perusesimerkki NestJS-sovelluksesta, jossa on /greet-päätepiste. Suorittakaa esimerkki ja kokeilkaa sitten osoitteen http://localhost:3000/greet avaamista selaimessa tai Postmanin kaltaisella työkalulla.

Näkyviin pitäisi tulla: Hello from NestJS!

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get } from '@nestjs/common';

@Controller('greet')
class GreetController {
  @Get()
  getGreeting(): string {
    return 'Hello from NestJS!';
  }
}

@Module({
  controllers: [GreetController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Dynaamiset reitit parametreilla

Usein tarvitaan reittejä, jotka sisältävät dynaamisia tietoja, kuten tietyn käyttäjän hakemisen tunnisteen perusteella (esimerkiksi /users/123). Näitä kutsutaan polkuparametreiksi.

NestJS:ssä polkuparametrit määritetään kaksoispisteellä (:), jota seuraa parametrin nimi @Get()-dekorointiominaisuudessa (esimerkiksi @Get(':id')). Arvo haetaan metodin allekirjoituksessa @Param()-dekorointiominaisuudella.

Polkuparametrien esimerkki

Tässä esimerkissä käyttäjän tunniste haetaan URL-polusta. Jos suoritatte tämän ja käytte osoitteessa http://localhost:3000/users/123, tulos on:

User ID: 123

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Param } from '@nestjs/common';

@Controller('users')
class UsersController {
  @Get(':id')
  findUser(@Param('id') id: string): string {
    return `User ID: ${id}`;
  }
}

@Module({
  controllers: [UsersController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Suodattaminen kyselyparametreilla

Kyselyparametrit ovat toinen tapa välittää tietoja reiteille. Niitä käytetään usein valinnaiseen suodatukseen, lajitteluun tai sivutukseen (esimerkiksi /items?category=books&limit=5).

Nämä parametrit näkyvät URL-osoitteessa kysymysmerkin (?) jälkeen avain–arvo-pareina, jotka erotetaan toisistaan ampersandeilla (&). NestJS:ssä niihin pääsee helposti käsiksi @Query()-dekorointiominaisuudella.

Kyselyparametrien esimerkki

Tämä reitti käyttää kyselyparametreja kohteiden suodattamiseen. Jos suoritatte tämän ja käytte osoitteessa http://localhost:3000/items?category=books&limit=5, näette:

Category: books, Limit: 5

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Query } from '@nestjs/common';

@Controller('items')
class ItemsController {
  @Get()
  findItems(
    @Query('category') category: string,
    @Query('limit') limit: string,
  ): string {
    return `Category: ${category || 'all'}, Limit: ${limit || '10'}`;
  }
}

@Module({
  controllers: [ItemsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Pyynnön rungon käsittely (POST/PUT)

Kun toiminto lähettää paljon tietoja, kuten uutta resurssia luotaessa (POST) tai olemassa olevaa päivitettäessä (PUT), tiedot lähetetään yleensä pyynnön rungossa.

Pyynnön runko voi sisältää jäsenneltyjä tietoja, usein JSON-muodossa. NestJS tarjoaa @Body()-dekorointiominaisuuden, jolla nämä tiedot voidaan jäsentää ja poimia suoraan ohjaimen metodin argumentteihin.

Pyynnön rungon esimerkki (POST)

Tässä esimerkissä näytetään, miten pyyntörungossa vastaanotetaan tietoja POST-pyynnössä. Jos lähetät POST-pyynnön osoitteeseen http://localhost:3000/products JSON-rungolla, joka on esimerkiksi {"name": "Laptop", "price": 1200}, tuloste on:

Product created: {"name":"Laptop","price":1200}

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Post, Body } from '@nestjs/common';

interface Product {
  name: string;
  price: number;
}

@Controller('products')
class ProductsController {
  @Post()
  createProduct(@Body() product: Product): string {
    return `Product created: ${JSON.stringify(product)}`;
  }
}

@Module({
  controllers: [ProductsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Reittien käsittelyn tarkistus

Tarkastellaan seuraavaa NestJS-ohjaimen koodikatkelmaa:

import { Controller, Get, Param, Query } from '@nestjs/common';

@Controller('articles')
class ArticlesController {
  @Get(':id')
  getArticleById(@Param('id') id: string): string {
    return `Article ID: ${id}`;
  }

  @Get()
  searchArticles(@Query('keyword') keyword: string): string {
    return `Searching for: ${keyword || 'all articles'}`;
  }
}

Millä URL-osoitteella artikkeli, jonka tunnus on "123", haettaisiin onnistuneesti?

Vastaa interaktiivisessa oppitunnissa

Kertaus: reitit ja pyynnöt

Hienoa työtä! Olet käynyt läpi NestJS:n API-reittien määrittämisen ja erityyppisten saapuvien tietojen käsittelyn perusteet:

Reitit yhdistävät URL-osoitteet ohjainten toimintoihin.
HTTP-metodit (GET, POST, PUT, DELETE) määrittävät toiminnon tyypin.
Polkuparametrit (@Param()) poimivat dynaamiset osat URL-polusta.
Kyselyparametrit (@Query()) poimivat URL-merkkijonosta valinnaisia avain–arvo-pareja.
Pyyntörunko (@Body()) käsittelee POST/PUT-pyyntöjen mukana lähetettäviä tietoja.

Nämä ovat jokaisen vankan RESTful-rajapinnan keskeisiä rakennuspalikoita!

Aloita maksutta

Opi TypeScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 20
Oppitunnit: 76

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Reitit ja pyyntöjen käsittely” ilmainen?

Kyllä – oppitunnin ”Reitit ja pyyntöjen käsittely” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko NestJS-yritysbackendien API:t-kurssin, päivitä CoddyKit PROhon. NestJS-yritysbackendien API:t-kurssilla on yhteensä 3 oppituntia.

Mitä opin oppitunnilla ”Reitit ja pyyntöjen käsittely”?

Määrittäkää API-reittejä, käsitelkää eri HTTP-metodeja ja poimikaa tietoja pyyntöjen leipäosista, parametreista ja kyselyistä. Harjoittelet NestJS-yritysbackendien API:t-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni NestJS-yritysbackendien API:t-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin NestJS-yritysbackendien API:t-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/3.

Kuinka kauan ”Reitit ja pyyntöjen käsittely”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä NestJS-yritysbackendien API:t-oppitunnilla?

Kyllä. Jokainen NestJS-yritysbackendien API:t-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: NestJS-yritysbackendien API:t