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 zum Aufbau der Serverseite einer Webanwendung – 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 begegnen.

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

3.3. Das Entwicklungsmodell von [NestJS]

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

  • Module (Dekorator @[Module]): Ein Modul fasst eine Reihe 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 (Dekorator @[Controller]): Ein Controller ist der Einstiegspunkt der Anwendung – eine Klasse, in der jede Methode HTTP-Anfragen zu einer bestimmten URL entgegennimmt und dem Client eine Antwort 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 in ihrem Konstruktor – [NestJS] erzeugt die erforderliche Instanz und übergibt sie automatisch, ohne dass Sie jemals selbst new schreiben müssen: Dies nennt man Dependency Injection über den Konstruktor, eine in NestJS nahezu allgegenwärtige Praxis.

3.4. Ein erstes Beispiel: das Miniprojekt „hello“

Um diese drei Konzepte zu festigen, hier ein sehr kleines [NestJS]-Projekt, unabhängig von der Fallstudie (eine einzige Route /hello), das Sie erstellen können mit (geben Sie diese Befehle in einem leeren Ordner ein, den Sie in VSCode geöffnet haben [File/Open Folder]. Diese Befehle erstellen einen Ordner namens [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: einen Einstiegspunkt ([main.ts]), ein Wurzelmodul (app.module.ts), einen Controller (app.controller.ts) und einen 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]() markiert 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 jemals new [AppService]() geschrieben werden muss;
  • 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 und macht sie zu einem Controller: NestJS sendet ihr die HTTP-Anfragen, die ihren Routen entsprechen. Das Argument in den Klammern ist ein optionales Präfix, das allen Routen der Klasse vorangestellt wird – 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, der ihn in einer einzigen Zeile als Parameter deklariert UND als Eigenschaft der Instanz registriert (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') ordnet die folgende Methode der Route HTTP GET /hello zu: Dieser Dekorator macht die Aktion unter der testbaren Adresse http://localhost:3000/hello erreichbar, sobald der Server läuft. 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, anstatt 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 und macht sie zu einem Modul: Es fasst einen zusammenhängenden Teil der Anwendung zusammen und deklariert in dem als Argument übergebenen Objekt, woraus er besteht. Vier Eigenschaften sind möglich: controllers (die von diesem Modul bereitgestellten Controller), providers (die von diesem Modul bereitgestellten Services, die innerhalb des Moduls für die Injektion verfügbar sind), 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 Array providers 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)
ordnet eine Controller-Methode einer HTTP-Route zu
[@Param]('x')
liest ein variables Segment der URL aus, z. B. /getDoctorById/:id
[@Body]()
liest den Body JSON einer Anfrage POST aus, deserialisiert in eine Klasse
[@Injectable]()
deklariert einen Provider (Service, DAO …)
[@Module]({...})
deklariert ein Modul, eine Zusammenstellung von Controllern und Providern

Diese Dekoratoren werden einzeln und genau an der Stelle ausführlich erklärt, an der sie im Code des Servers [RdvMedecins] auftreten (Kapitel 4).