Hoe Nest.js Uitzonderingsfilters gebruiken om fouten af te handelen

Nest.js uitzonderingsfilters bieden een manier om uitzonderingen globaal of per controller te onderscheppen en af te handelen.

Door logica voor het afhandelen van fouten te centraliseren, kunnen ontwikkelaars hun processen stroomlijnen door alle foutgerelateerde code op één plek te consolideren. Deze aanpak vereenvoudigt niet alleen het oplossen van problemen, maar zorgt ook voor een meer georganiseerde presentatie van foutmeldingen aan eindgebruikers. Door gebruik te maken van uitzonderingsfilters kunnen ontwikkelaars fouten die optreden binnen een applicatie efficiënt beheren, waardoor een samenhangend reactiemechanisme ontstaat dat zorgt voor consistentie in het hele systeem.

Standaard foutafhandeling in Nest.js

Nest.js bevat een ingebouwd mechanisme voor foutafhandeling dat zorgt voor onbehandelde uitzonderingen die worden gegenereerd door de code van de toepassing.

Wanneer een uitzondering onopgemerkt blijft tijdens runtime in je applicatie die is ontwikkeld met het Nest.js framework, reageert het systeem automatisch met een HTTP-statuscode van 500 Internal Server Error, samen met een vooraf gedefinieerde JSON payload met informatie over het optreden van de fout. Dit formaat is ontworpen voor eenvoudig gebruik door ontwikkelaars die de oorzaak van het probleem eenvoudig kunnen achterhalen aan de hand van de verstrekte details.

 {
  "statusCode": 500,
  "message": "Internal server error"
}

Als een foutobject dat door uw code wordt gegooid zowel een statuscode als een bericht bevat, zal Nest.js deze waarden gebruiken in plaats van het standaardantwoord te geven.

Om de algemene afhandeling van fouten te voorkomen en in plaats daarvan een meer informatieve reactie aan clients te geven, is het belangrijk om alle potentiële fouten binnen je applicatie zorgvuldig te beheren. Dit kan worden bereikt door gebruik te maken van de al bestaande uitzonderingsfilters van Nest.js of door aangepaste filters te maken die zijn afgestemd op uw specifieke behoeften.

Een uitzonderingsfilter op maat maken

Om de procedure voor het ontwikkelen van een uitzonderingsfilter op maat te illustreren, probeer je er een te maken die alle HTTP-uitzonderingen kan aanpakken.

Overweeg om te beginnen met een document getiteld “http.exception.ts”, en vervolgens de volgende importeer-statements erin op te nemen:

 import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
} from '@nestjs/common';

import { Request, Response } from 'express';

Deze importen dienen de volgende doelen.

Een uitzonderingsfilter, zoals geïmplementeerd door deze interface, dient om uitzonderingen op te vangen en af te handelen die optreden tijdens de uitvoering van een programma.

De Catch decorator betekent een aanwijzing voor een klasse als een uitzonderingsfiltratiemechanisme binnen het Nest framework.

De interface ArgumentsHost presenteert een set methoden die het verkrijgen van argumenten die aan een bepaalde handler worden doorgegeven, vergemakkelijken. Door gebruik te maken van dit framework kan een geschikte uitvoeringscontext zoals HTTP, RPC of WebSockets worden geselecteerd om de genoemde argumenten uit te halen.

De HttpException vormt de basis van alle Nest HTTP exceptions en omvat een gestandaardiseerde structuur voor het afhandelen van fouten in webapplicaties.

de verzoek- en antwoordobjecten. De eerste vertegenwoordigt inkomende clientverzoeken, terwijl de tweede wordt gebruikt om antwoorden op die verzoeken terug te sturen.

Om een uitzonderingsfilter te implementeren voor het afhandelen van HttpException s in onze ASP.NET Core-applicatie, kunnen we een nieuwe klasse maken met de naam HttpExceptionFilter . Deze klasse moet erven van het ExceptionFilterAttribute en worden geannoteerd met het Catch attribuut om uitzonderingen van dit type te behandelen.

 @Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {}

Vul de klasse vervolgens met deze code:

 catch(exception: HttpException, host: ArgumentsHost) {
    // Get the response object from the arguments host
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();

    // Get the request object from the arguments host
    const request = ctx.getRequest<Request>();

    // Get the status code from the exception
    const status = exception.getStatus();

    // Send a JSON response using the response object
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message:
        exception.message
       || exception.getResponse()['message']
       || 'Internal Server Error',
    });
}

De huidige implementatie verwerft de verzoek- en antwoordparameters van de instantie ArgumentsHost en analyseert de uitzonderingen voor relevante gegevens. Het resultaat is een georganiseerd antwoord in JSON-formaat met informatieve inhoud over de fout die wordt doorgestuurd naar de eindgebruiker.

Uitzonderingsfilters binden

Je hebt de optie om een uitzonderingsfilter toe te passen op het niveau van individuele controllers of in je hele applicatie, afhankelijk van wat het beste past bij je vereisten.

Om een globaal uitzonderingsfilter universeel toe te passen, moet je het uitzonderingsfilter eerst opnemen in je primaire main.ts bestand. Presenteer vervolgens een instantiatie van uw uitzonderingsfilter aan de app.useGlobalFilters() methode.

 // main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpExceptionFilter } from './exception/http.exception';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Bind filter to the application
  app.useGlobalFilters(new HttpExceptionFilter());

  await app.listen(4050);
}

bootstrap();

Om een uitzondering aan een controller te koppelen, moet de decorator “UseFilters” samen met de bijbehorende uitzonderingsfilter worden gebruikt. Het proces bestaat uit het importeren van de “UseFilters”-decorator en het specifieke uitzonderingsfilter. Vervolgens moet de controllerclass worden geannoteerd met de “@UseFilters”-decorator, terwijl ook een instantie van de uitzonderingsfilter als argument wordt doorgegeven aan de decorator.

 @Controller()
@UseFilters(new HttpExceptionFilter())
export class AppController {}

De locatie waarop een filter wordt toegepast, bepaalt het bereik van de mogelijkheden voor foutafhandeling. Als een filter gebonden is aan een specifieke controller, zal het alleen van toepassing zijn op die specifieke controller, terwijl een filter dat de hele applicatie bestrijkt de hele applicatie zal bestrijken.

Ingebouwde uitzonderingen gebruiken om fouten te gooien

Nest.js biedt een reeks vooraf gedefinieerde uitzonderingscategorieën die kunnen worden gebruikt voor het gooien van fouten, die zijn ontworpen om de afhandeling van fouten te vereenvoudigen en de ontwikkeling van toepassingen te stroomlijnen door een gestandaardiseerde aanpak te bieden voor het beheren van uitzonderingen op een georganiseerde manier.

Men kan inderdaad de klasse NotFoundException gebruiken om een 404 statuscodefout te genereren als reactie op verzoeken die niet door de server kunnen worden uitgevoerd. Deze uitzondering wordt vaak gebruikt als er geprobeerd wordt om een bron of pagina te benaderen die niet bestaat op de server. Door deze uitzondering te gooien, kan de server de client laten weten dat de gevraagde inhoud niet beschikbaar is en informatie geven over waarom het verzoek is mislukt.

   getUserById(id: number) {
    const user = users.find((user) => user.id === id);

    if (!user) {
      throw new NotFoundException({
        message: `User with id ${id} not found`,
      });
    }
  }

Het voorgaande code segment gebruikt een voorwaardelijke expressie om te controleren of de gespecificeerde gebruiker aanwezig is. Als de gebruiker niet aanwezig is, wordt er een 404-exceptie gemaakt door de klasse NotFoundException te gebruiken en een bijbehorend bericht als argument op te geven.

Algemene ingebouwde uitzonderingsklassen

Aanvullende voorgedefinieerde uitzonderingscategorieën omvatten, maar zijn niet beperkt tot, de volgende voorbeelden.

De BadRequestException is een gespecialiseerde uitzondering in softwareontwikkeling die een HTTP-antwoord met een statuscode van 400 vertegenwoordigt. Deze exception wordt gegooid wanneer het verzoek van een client ongeldig of onjuist geformatteerd wordt geacht door de server, waardoor het niet verwerkt kan worden. De belangrijkste implicatie van deze exception is dat de client zijn verzoek moet aanpassen om eventuele fouten of onregelmatigheden te corrigeren.

De klasse UnauthorizedException gooit een exceptie die ongeautoriseerde toegang betekent, vergezeld van een HTTP-statuscode 401. Deze exceptie kan worden gegooid in situaties waarin de client de toegang tot de server weigert. Deze uitzondering kan worden gegooid in situaties waarin een gebruiker niet is geverifieerd of niet de vereiste rechten heeft om toegang te krijgen tot een specifieke bron.

De klasse ForbiddenException vertegenwoordigt een uitzondering die onbevoegde toegang betekent, vergezeld van een HTTP-statuscode 403. Deze uitzondering kan worden gegooid in situaties waarin een gebruiker met succes is geverifieerd, maar niet over de benodigde machtigingen beschikt om een bepaalde bewerking uit te voeren.

De RequestTimeoutException is een op Java gebaseerde exception die wordt gegooid wanneer een verzoek de opgegeven tijdslimiet heeft overschreden, wat resulteert in een HTTP-statuscode 408. Deze uitzondering kan door servers worden gebruikt om verzoeken te beëindigen die langer dan verwacht hebben geduurd om te verwerken.

De klasse ConflictException vertegenwoordigt een uitzondering die optreedt als gevolg van een conflict in de statuscode 409. Dit type exceptie kan worden gegooid wanneer het verzoek van de client in conflict komt met de huidige status van de bron die wordt bewerkt, bijvoorbeeld tijdens een poging om een bron aan te maken die al is aangemaakt.

De InternalServerErrorException is een type uitzondering die een onvoorziene fout vertegenwoordigt die optreedt binnen de server-side infrastructuur, wat resulteert in het onvermogen om aan de gevraagde taak te voldoen. Deze specifieke uitzondering heeft een bijbehorende HTTP-statuscode van 500 en moet worden gebruikt wanneer zich aan de serverzijde een onverwacht probleem voordoet waardoor niet aan de vraag van de client kan worden voldaan.

Best Practices voor foutafhandeling in Nest.js

Om fouten binnen een Nest.js-applicatie effectief te beheren, is het belangrijk om uitzonderingsfilters te gebruiken die globale uitzonderingen of uitzonderingen die specifiek zijn voor individuele controllers afvangen. Daarnaast kan men aangepaste uitzonderingsfilters instellen die zijn afgestemd op bepaalde fouttypen.

Verder is het van cruciaal belang om de juiste ingebouwde uitzonderingsklassen te gebruiken voor het gooien van nauwkeurige en significante foutmeldingen. Deze aanpak draagt aanzienlijk bij aan het verbeteren van de betrouwbaarheid van je Nest.js-applicaties.