NestJS-API-er for virksomhetsbackend · leksjon

Feilhåndtering og interceptorer

Implementer egendefinerte unntaksfiltre for elegant feilhåndtering, og bruk interceptorer til å transformere svar eller logge forespørsler.

Leksjon 3 av 312 trinn

Feilhåndtering og interceptorer er en gratis leksjon i NestJS-API-er for virksomhetsbackend på CoddyKit. Dette er leksjon 3 av 3. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i NestJS-API-er for virksomhetsbackend, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i NestJS-API-er for virksomhetsbackend inneholder totalt 3 leksjoner.

Elegant feilhåndtering i API-er

Når du bygger API-er, er det svært viktig å håndtere feil på en god måte. I stedet for at API-et krasjer eller returnerer uklare meldinger, bør det gi klientene tydelige og konsistente tilbakemeldinger.

Dette gjør API-et brukervennlig og bidrar til feilsøking av problemer både på klient- og serversiden.

Innebygde NestJS-unntak

NestJS tilbyr et sett med standard HTTP-unntak som arver fra HttpException. Disse unntakene tilsvarer vanlige HTTP-statuskoder.

BadRequestException (400)
UnauthorizedException (401)
NotFoundException (404)
InternalServerErrorException (500)

Ved å bruke disse sikrer du at API-et kommuniserer med klienten ved hjelp av standardisert HTTP.

Kaste innebygde unntak

Du kan kaste disse unntakene direkte fra kontrollerne eller tjenestene dine. NestJS sitt innebygde unntakslag fanger dem opp og formaterer automatisk et standardisert JSON-feilsvar.

Prøv å kjøre dette eksempelet og åpne /greet/World (suksess) og /greet/error (feil) for å se forskjellen:

import { NestFactory } from '@nestjs/core';
import { Controller, Get, Param, NotFoundException, Module } from '@nestjs/common';

@Controller('greet')
class GreetController {
  @Get(':name')
  hello(@Param('name') name: string) {
    if (name === 'error') {
      throw new NotFoundException('Name "error" is not allowed!');
    }
    return `Hello, ${name}!`;
  }
}

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

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

Egendefinerte unntaksfiltre

Selv om innebygde unntak er nyttige, kan du trenge mer kontroll over formatet på feilsvaret. Det er her egendefinerte unntaksfiltre kommer inn.

Med et egendefinert filter kan du fange bestemte unntak (eller alle unntak) og definere nøyaktig hvilket svar som sendes tilbake til klienten, inkludert egendefinert logging eller integrasjon med eksterne tjenester.

Bygge et egendefinert filter

For å opprette et egendefinert filter implementerer du grensesnittet ExceptionFilter og dekorerer det med @Catch(), der du angir hvilke unntakstyper det skal håndtere. Her er et grunnleggende eksempel:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch(HttpException)
export class CustomHttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
        customMessage: `An error occurred: ${exception.message}`,
      });
  }
}

Bruke egendefinerte filtre

Når filteret er opprettet, må det tas i bruk. Du kan bruke filtre:

Globalt: Ved å bruke app.useGlobalFilters(new MyFilter()) i main.ts.
På kontrollernivå: Ved å bruke @UseFilters(MyFilter) på en kontrollerklasse.
På metodenivå: Ved å bruke @UseFilters(MyFilter) på en bestemt rutebehandlingsmetode.

Globale filtre fanger opp unntak i hele applikasjonen og gir en konsistent feilstruktur.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module'; // Assume AppModule exists
import { CustomHttpExceptionFilter } from './custom-http-exception.filter'; // Assume filter exists

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new CustomHttpExceptionFilter());
  await app.listen(3000);
}

Introduksjon til interceptorer

Interceptorer er en annen kraftig funksjon i NestJS, inspirert av aspektorientert programmering (AOP). De lar deg «fange opp» forespørsler og svar og legge til ekstra logikk før eller etter at en rutebehandler kjøres.

Tenk på dem som kroker i livssyklusen for forespørsler og svar, som gir deg detaljert kontroll.

Vanlige bruksområder for interceptorer

Interceptorer er svært allsidige og kan brukes til ulike formål:

Logging: Logg detaljer om forespørsler, kjøretid og svar.
Transformere svar: Endre strukturen på dataene som sendes ut (for eksempel ved å pakke dem inn i et data-objekt).
Bufring: Implementer bufring av svar for bedre ytelse.
Knytte til ekstra logikk: Kjør kode før eller etter en metode.

Eksempel på en logging-interceptor

Her er en enkel interceptor som logger hvor lang tid det tar å fullføre en forespørsel. Den bruker RxJS-operatorer som tap og finalize til å samhandle med den observerbare strømmen.

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap, finalize } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before request...');

    const now = Date.now();
    return next.handle().pipe(
      tap(() => console.log(`After request... ${Date.now() - now}ms`)),
      finalize(() => console.log('Request/response cycle finalized.'))
    );
  }
}

Transformere svar

Interceptorer kan også transformere dataene som returneres av rutebehandlerne. Dette er vanlig for å standardisere API-svar, for eksempel ved å pakke alle vellykkede data inn i en data-egenskap for å sikre konsistens.

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

interface Response<T> {
  data: T;
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(map(data => ({ data })));
  }
}

Hurtigsjekk: Feil eller intercept

Du har lært om både unntaksfiltre og interceptorer. La oss teste om du har forstått hovedrollene deres.

Besvar den i den interaktive leksjonen

Oppsummering og neste steg

I denne leksjonen gikk vi gjennom viktige teknikker for å bygge robuste NestJS-API-er:

Elegant feilhåndtering ved hjelp av innebygde HTTP-unntak.
Egendefinerte unntaksfiltre for å tilpasse feilsvar og håndtere bestemte unntak.
Interceptorer for logging, transformering av svar og håndtering av tverrgående funksjonalitet.

Når du mestrer disse konseptene, blir det enklere å bygge profesjonelle, vedlikeholdbare og brukervennlige API-er.

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 20
Leksjoner: 76

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilhåndtering og interceptorer» gratis?

Ja – hele teksten i «Feilhåndtering og interceptorer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av NestJS-API-er for virksomhetsbackend-kurset, kan du oppgradere til CoddyKit PRO. Kurset i NestJS-API-er for virksomhetsbackend inneholder totalt 3 leksjoner.

Hva lærer jeg i «Feilhåndtering og interceptorer»?

Implementer egendefinerte unntaksfiltre for elegant feilhåndtering, og bruk interceptorer til å transformere svar eller logge forespørsler. Du øver på NestJS-API-er for virksomhetsbackend med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med NestJS-API-er for virksomhetsbackend?

Ingen tidligere erfaring er nødvendig. NestJS-API-er for virksomhetsbackend på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 3.

Hvor lang tid tar leksjonen «Feilhåndtering og interceptorer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne NestJS-API-er for virksomhetsbackend-leksjonen?

Ja. Alle NestJS-API-er for virksomhetsbackend-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til NestJS-API-er for virksomhetsbackend