Stellen Sie sicher, dass Ihre Module mit sauberer, wiederverwendbarer Injektion gut organisiert sind.
Das Einfügen eines Dienstes aus einem anderen Nest.js-Modul erfordert einige Schritte, um eine ordnungsgemäße Abhängigkeitsinjektion und Modulorganisation sicherzustellen. Erfahren Sie anhand von zwei Beispielmodulen, wie der Prozess des Exports und Imports von Diensten funktioniert.
Generieren eines Nest.js-Projekts
Um ein Nest.js-Projekt zu generieren, muss die CLI auf Ihrem Gerät installiert sein. Wenn Sie dies nicht tun, führen Sie diesen Befehl aus, um es zu installieren:
npm install -g @nestjs/cli
Führen Sie bei installierter Nest.js-CLI diesen Befehl aus, um ein neues Nest.js-Projekt zu generieren:
nest new
Sie können „
Ihre aktuelle Projektstruktur sollte wie im Bild unten aussehen:
Um das Einfügen eines Dienstes von einem Modul in ein anderes Modul zu üben, generieren Sie zwei Module, Modul-a und Modul-b. Sie generieren auch die entsprechenden Service- und Controller-Dateien.
Führen Sie diesen Befehl aus, um Modul-a zu generieren:
nest generate modulemodule-a
Und führen Sie den entsprechenden Befehl für Modul-b aus:
nest generate modulemodule-b
Führen Sie dann diesen Befehl aus, um die Dienst- und Controllerdateien für Modul-a zu generieren:
nest generate service module-a && nest generate controller module-a
Und führen Sie den entsprechenden Befehl für Modul-b aus:
nest generate service module-b && nest generate controller module-b
Ihr aktuelles Projektverzeichnis sollte so aussehen, mit src/module-a Und src/module-b Verzeichnisse:
Exportieren eines Dienstes aus Modul A
Um den Modul-a-Dienst aus dem Modul-a-Modul zu exportieren, müssen Sie ihn als Export in der Moduldatei von Modul-a auflisten (module-a.module.ts). Standardmäßig stellt die Nest.js-CLI keine bereit Exporte Array in der @Modul decorator, sodass die generierte Moduldatei wie folgt aussieht:
// module-a.module.ts
import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
})
exportclassModuleAModule{}
Service-a machen (module-a.service.ts) zugänglich für Module, die Modul-a importieren, erstellen Sie ein Exporte Array in der @Modul Dekorateur und hinzufügen ModuleAService dazu.
Etwa so:
import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
exports: [ModuleAService],
})
exportclassModuleAModule{}
Fügen Sie als Nächstes zu Testzwecken eine einfache Funktion zu Ihrem Modul hinzu – eine Servicedatei (module-a.service.ts):
import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
getHello(): string {
return'Hello from Module A!';
}
}
Diese Funktion gibt eine Beispielzeichenfolge zurück. Um zu bestätigen, dass Sie diesen Dienst korrekt importieren können, rufen Sie diese Funktion aus Modul-b auf, nachdem Sie Dienst-a eingefügt haben.
Importieren eines Dienstes in Modul B
Um ein Modul in ein anderes zu importieren, müssen Sie es als Import im auflisten Importe Array des Empfangsmoduls. In diesem Fall müssen Sie module-a zum hinzufügen Importe Array von Modul-Bs @Modul Dekorateur.
Wie zuvor generiert die Nest.js-CLI nicht automatisch eine Importe Array, daher müssen Sie es manuell hinzufügen.
Importieren Sie zunächst das übergeordnete Modul (module-a.module.ts) in das Empfangsmodul (module-b.module.ts), erstellen Sie die Importe Array, und hinzufügen ModulAModul zum Array:
// module-b.module.ts
import { Module } from'@nestjs/common';
import { ModuleBController } from'./module-b.controller';
import { ModuleBService } from'./module-b.service';
import { ModuleAModule } from'../module-a/module-a.module';@Module({
imports: [ModuleAModule],
controllers: [ModuleBController],
providers: [ModuleBService],
})
exportclassModuleBModule{}
Als nächstes öffnen Sie Ihr module-b.service.ts Datei und importieren Sie die Injizieren Dekorateur und ModulAServerice aus @nests/common Und ../module-a/module-a.service, jeweils:
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';
Der Injizieren Decorator markiert seinen Parameter als Ziel für die Abhängigkeitsinjektion.
Als nächstes in Ihrem ModuleBService Klasse, fügen Sie den folgenden Codeblock hinzu:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
Der obige Codeblock gewährt Ihrem ModuleBService Zugriff auf die in Ihrem ModuleAService verfügbaren Methoden.
Sie können den Dienst testen, indem Sie die ModuleAServices aufrufen getHallo Methode.
// module-b.service.ts
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'src/module-a/module-a.service';@Injectable()
exportclassModuleBService{
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
getHello(): string {
returnthis.moduleAService.getHello();
}
}
Als nächstes öffnen Sie Ihr module-b.controller.ts Datei und ersetzen Sie den generierten Code durch den folgenden Codeblock:
// module-b.controller.ts
import { Controller, Get } from'@nestjs/common';
import { ModuleBService } from'./module-b.service';@Controller('module-b')
exportclassModuleBController{
constructor(private readonly moduleBService: ModuleBService) {}
@Get('/hello')
getHello(): string {
returnthis.moduleBService.getHello();
}
}
Der obige Codeblock richtet einen ein ERHALTEN Routenhandler für die getHallo Funktion.
Endlich, Stellen Sie eine GET-Anfrage mit Curl an localhost: 3000/module-b/hello. Der Befehl sollte „Hallo von Modul A!“ ausgeben. auf Ihre Konsole.
Sie haben erfolgreich einen Dienst in ein anderes Modul eingefügt. Dies kann nützlich sein, wenn Sie es sind Erstellen von APIs mit Nest.js die über mehrere Module verfügen, die sich gegenseitig die Methoden aufrufen müssen.
Vorteile der Cross-Module-Injection
Auch wenn der direkte Aufruf eines Dienstes von einem anderen Modul zunächst einfacher erscheint, kann er auf lange Sicht zu einem komplexeren, weniger wartbaren und weniger skalierbaren System führen.
Die modulübergreifende Injektion fördert jedoch die Modularität und Wiederverwendbarkeit des Codes und erleichtert so die Wartung. Darüber hinaus zentralisiert es Abhängigkeiten, verbessert die Testbarkeit und unterstützt eine skalierbare, entkoppelte Architektur.
