Skip to content

3. Kapitel 2 - Einführung in [NestJS]

3.1. Quellen

Dieses Kapitel stützt sich auf die folgenden Quellen:

3.2. Die Rolle von [NestJS] in einer Webanwendung

[NestJS] ist ein in TypeScript geschriebenes Node.js-Framework, das für den Aufbau der Serverseite einer Webanwendung gedacht ist – meist einer REST-API (JSON). Es erfindet die Verarbeitung des HTTP-Protokolls nicht neu: Standardmäßig stützt es sich auf Express, ein einfacheres Node.js-Framework, das rohe HTTP-Anfragen entgegennimmt und beantwortet. [NestJS] setzt darauf auf und bietet eine Code-Organisation, die weder Node.js noch Express von sich aus vorgeben: Aufteilung in Module, Controller und Services, Dependency Injection, Dekoratoren …

Seine Architektur ist stark von [Angular] inspiriert (Dekoratoren, Module, Dependency Injection) – eine Ähnlichkeit, die uns in Kapitel 4 zugutekommt, wenn wir auf der Clientseite genau denselben Konzepten wieder begegnen.

[NestJS] ist in erster Linie darauf ausgelegt, JSON-Antworten zu erzeugen: Standardmäßig wird alles, was eine Controller-Methode zurückgibt, automatisch in JSON umgewandelt und an den Client gesendet, ohne besondere Konfiguration.

3.3. Das Entwicklungsmodell von [NestJS]

Drei Konzepte bilden die Struktur einer [NestJS]-Anwendung:

  • Module (@[Module]-Dekorator): Ein Modul fasst eine Gruppe zusammengehöriger Funktionen zusammen – es deklariert, welche Controller und Services zu ihm gehören, welche anderen Module es benötigt und was es anderen zur Verfügung stellt. Eine [NestJS]-Anwendung geht immer von einem Wurzelmodul aus, [AppModule], das alle anderen Module des Projekts zusammenführt;
  • Controller (@[Controller]-Dekorator): Ein Controller ist der Einstiegspunkt der Anwendung – eine Klasse, in der jede Methode HTTP-Anfragen zu einer bestimmten URL entgegennimmt und eine Antwort an den Client zurückgibt;
  • Provider (Dekorator @[Injectable]): Ein Provider ist eine gewöhnliche Klasse, die typischerweise für die Geschäftslogik oder den Datenzugriff zuständig ist und die [NestJS] automatisch erzeugen und jedem Controller oder Service bereitstellen (also „injizieren“) kann, der sie benötigt.

In der Praxis deklariert eine Klasse, die einen Provider benötigt, diesen einfach als Parameter ihres Konstruktors – [NestJS] erzeugt die benötigte Instanz und übergibt sie automatisch, ohne dass Sie jemals selbst new schreiben müssen: Dies nennt man Dependency Injection über den Konstruktor, ein Vorgehen, das in NestJS fast immer verwendet wird.

3.4. Ein erstes Beispiel: das Miniprojekt „hello“

Zur Festigung dieser drei Konzepte folgt ein sehr kleines [NestJS]-Projekt, unabhängig von der Fallstudie (eine einzige Route /hello), das Sie wie folgt erstellen können (geben Sie diese Befehle in einem leeren Ordner ein, den Sie in VSCode über [File/Open Folder] geöffnet haben. Diese Befehle erstellen einen Ordner mit dem Namen [hello-nest]):

1
2
3
4
npm install -g [@nestjs/cli]
nest new hello-nest
cd hello-nest
npm run start:dev

Image

Dieser Befehl erzeugt ein Projekt mit den folgenden wesentlichen Dateien: [src/main.ts], src/app.module.ts, src/app.controller.ts, src/app.service.ts. Allein diese vier Dateien veranschaulichen die Architektur einer [NestJS]-Anwendung: ein Einstiegspunkt ([main.ts]), ein Wurzelmodul (app.module.ts), ein Controller (app.controller.ts) und ein Service (app.service.ts).

3.4.1. Der Service


// src/app.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}
  • Zeile 2: Jedes verwendete Element wird explizit importiert; hier wird [Injectable] aus [@nestjs/common] importiert, dem Modul, das die meisten Dekoratoren und Hilfsklassen von [NestJS] enthält;
  • Zeile 4: Ein Dekorator ist eine Annotation, die unmittelbar über einer TypeScript-Klasse, -Methode oder einem -Parameter steht (mit vorangestelltem Symbol @) und deren Verhalten ändert oder erweitert, ohne ihren Code zu verändern – der Mechanismus, auf dem praktisch das gesamte Vokabular von NestJS beruht. @[Injectable]() kennzeichnet diese Klasse als Provider: [NestJS] erzeugt sie selbstständig und stellt sie jeder anderen Klasse, die sie in ihrem Konstruktor anfordert, automatisch bereit, ohne dass man jemals new [AppService]() schreiben müsste;
  • Zeile 6: : string deklariert den Rückgabetyp – eine Besonderheit von TypeScript, die es in JavaScript nicht gibt.

3.4.2. Der Controller

// src/app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service.js';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) { }

  @Get('hello')
  getHello(): string {
    return this.appService.getHello();
  }
}
  • Zeile 5: @Controller() dekoriert die folgende Klasse, um sie zu einem Controller zu machen: NestJS leitet an sie die HTTP-Anfragen weiter, die zu ihren Routen gehören. Das Argument in den Klammern ist ein optionales Präfix, das am Anfang aller Routen der Klasse steht – hier ist es leer: Die Route „hello“ antwortet also direkt unter /hello;
  • Zeile 7: Der Konstruktor deklariert einen Parameter namens appService vom Typ [AppService], dem der TypeScript-Modifikator private readonly vorangestellt ist; dieser deklariert ihn in einer einzigen Zeile UND registriert ihn als Eigenschaft der Instanz (this.appService). [NestJS] stellt fest, dass der Controller einen [AppService]benötigt, erzeugt eine Instanz davon (eine einzige Instanz, die von der gesamten Anwendung gemeinsam genutzt wird) und stellt sie hier automatisch bereit: Das ist die zuvor erwähnte Dependency Injection über den Konstruktor;
  • Zeile 9: [@Get]('hello') verknüpft die folgende Methode mit der Route HTTP GET /hello: Dieser Dekorator macht die Aktion nach dem Start des Servers unter der testbaren Adresse http://localhost:3000/hello erreichbar. Andere Dekoratoren erfüllen dieselbe Aufgabe für die übrigen HTTP-Verben: @[Post](), @Put(), @Delete(), @Patch() (in der Fallstudie verwenden wir @[Post]() für /addAppointment und /deleteAppointment). Beachten Sie, dass der Methodenname [getHello] in Zeile 10 unerheblich ist. Er könnte beliebig lauten;
  • Zeile 11: Der Controller delegiert die Arbeit an den injizierten Service, statt die Antwort selbst zu programmieren: Er bleibt eine einfache Routing-Schicht, während die Geschäftslogik im Service liegt – ein Prinzip, das wir in der Fallstudie in Kapitel 3 in größerem Maßstab sehen werden.

3.4.3. Das Modul

// src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller.js';
import { AppService } from './app.service.js';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
  • Zeile 6: @[Module]({...}) dekoriert die folgende Klasse, um sie zu einem Modul zu machen: Es fasst einen zusammenhängenden Teil der Anwendung zusammen und deklariert in dem als Argument übergebenen Objekt, woraus dieser besteht. Vier Eigenschaften sind möglich: controllers (die von diesem Modul bereitgestellten Controller), providers (die von diesem Modul bereitgestellten Services, die innerhalb des Moduls injiziert werden können), imports (die anderen Module, von denen dieses abhängt) und exports (die Provider, die dieses Modul den Modulen zur Verfügung stellt, die es importieren);
  • Ohne die Zeile `controllers: [AppController]` würde `[NestJS]` diesen Controller ignorieren, und seine Routen würden auf keine Anfrage antworten; ohne `providers: [AppService]` würde die Dependency Injection des Controllers beim Start fehlschlagen.

3.4.4. Ausführung

Geben Sie mit VSCode in einem Terminal, das im Stammverzeichnis des Ordners [hello-nest] gestartet wurde, den folgenden Befehl ein:

npm run start:dev

Wenn Sie http://localhost:3000/hello in einem Browser öffnen, erhalten Sie die folgende Antwort:

Image

3.5. Provider und Dependency Injection

Eine mit @[Injectable]() annotierte Klasse ist ein Provider: [NestJS] weiß, wie sie zu instanziieren ist, und injiziert sie automatisch überall dort, wo sie in einem Konstruktor angefordert wird, sofern sie im providers-Array eines Moduls aufgeführt ist. Standardmäßig ist ein [NestJS]-Provider ein Singleton: Beim Start der Anwendung wird eine einzige Instanz erzeugt, und dieselbe Instanz wird von allen Komponenten gemeinsam genutzt, die sie benötigen – ein wichtiger Punkt, um die Rolle des Services [ApplicationModelService] in der Fallstudie (Kapitel 3) zu verstehen, der beim Start des Servers Daten zwischenspeichert.

3.6. Die weiteren Dekoratoren, die in der Fallstudie vorkommen

Dekorator
Rolle
[@Get](url), [@Post](url)
verknüpft eine Controller-Methode mit einer HTTP-Route
[@Param]('x')
liest ein variables Segment der URL aus, z. B. /getDoctorById/:id
[@Body]()
liest den JSON-Body einer POST-Anfrage aus, deserialisiert in eine Klasse
[@Injectable]()
deklariert einen Provider (Service, DAO …)
[@Module]({...})
deklariert ein Modul, eine Zusammenstellung aus Controllern und Providern

Diese Dekoratoren werden einzeln und im Detail an der Stelle erklärt, an der sie im Code des [RdvMedecins]-Servers erscheinen (Kapitel 3).