Assurez-vous que vos modules sont bien organisés avec une injection propre et réutilisable.
L'injection d'un service à partir d'un autre module Nest.js implique quelques étapes pour garantir une injection de dépendances et une organisation du module appropriées. À l’aide de deux exemples de modules, découvrez comment fonctionne le processus d’exportation et d’importation de services.
Générer un projet Nest.js
Pour générer un projet Nest.js, vous devez avoir installé la CLI sur votre appareil. Si ce n'est pas le cas, exécutez cette commande pour l'installer :
npm install -g @nestjs/cli
Une fois la CLI Nest.js installée, exécutez cette commande pour générer un nouveau projet Nest.js :
nest new
Vous pouvez remplacer «
La structure actuelle de votre projet devrait ressembler à l’image ci-dessous :
Pour vous entraîner à injecter un service d'un module vers un autre module, vous générerez deux modules, module-a et module-b. Vous générerez également leurs fichiers de service et de contrôleur correspondants.
Exécutez cette commande pour générer le module-a :
nest generate modulemodule-a
Et exécutez la commande équivalente pour module-b :
nest generate modulemodule-b
Exécutez ensuite cette commande pour générer les fichiers de service et de contrôleur pour le module-a :
nest generate service module-a && nest generate controller module-a
Et exécutez la commande équivalente pour module-b :
nest generate service module-b && nest generate controller module-b
Votre répertoire de projet actuel devrait ressembler à ceci, avec src/module-a et src/module-b répertoires :
Exporter un service depuis le module A
Pour exporter le service module-a depuis le module-a, vous devez le lister comme exportation dans le fichier module du module-a (module-a.module.ts). Par défaut, la CLI Nest.js ne fournit pas de exportations tableau dans le @Module décorateur, donc le fichier de module généré ressemblera à ceci :
// 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{}
Pour rendre service-un (module-a.service.ts) accessible aux modules qui importent le module-a, créez un exportations tableau dans le @Module décorateur et ajouter ModuleAService à cela.
Ainsi:
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{}
Ensuite, à des fins de test, ajoutez une fonction simple à votre module: un fichier de service (module-a.service.ts):
import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
getHello(): string {
return'Hello from Module A!';
}
}
Cette fonction renvoie un exemple de chaîne. Pour confirmer que vous pouvez importer correctement ce service, vous appellerez cette fonction depuis le module-b après avoir injecté le service-a.
Importer un service dans le module B
Pour importer un module dans un autre, vous devez le lister comme import dans le importations tableau du module de réception. Dans ce cas, vous devez ajouter le module-a au importations tableau de modules-b @Module décorateur.
Comme auparavant, la CLI Nest.js ne génère pas automatiquement un importations tableau, vous devez donc l'ajouter manuellement.
Tout d’abord, importez le module parent (module-a.module.ts) dans le module de réception (module-b.module.ts), créer le importations tableau et ajoutez ModuleAModule au tableau :
// 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{}
Ensuite, ouvrez votre module-b.service.ts fichier et importer le Injecter décorateur et ModuleAServeice depuis @nids/commun et ../module-a/module-a.service, respectivement:
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';
Le Injecter decorator marque son paramètre comme cible pour l’injection de dépendances.
Ensuite, dans votre ModuleBService classe, ajoutez le bloc de code ci-dessous :
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
Le bloc de code ci-dessus donne à votre ModuleBService l'accès aux méthodes disponibles dans votre ModuleAService.
Vous pouvez tester le service en appelant le moduleAService obtenirBonjour méthode.
// 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();
}
}
Ensuite, ouvrez votre module-b.controller.ts fichier et remplacez le code généré par le bloc de code ci-dessous :
// 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();
}
}
Le bloc de code ci-dessus définit un OBTENIR gestionnaire d'itinéraire pour le obtenirBonjour fonction.
Enfin, faire une requête GET avec curl à localhost: 3000/module-b/hello. La commande doit afficher « Bonjour du module A! » à votre console.
Vous avez réussi à injecter un service dans un autre module. Cela peut s'avérer utile lorsque vous êtes créer des API avec Nest.js qui ont plusieurs modules qui doivent s’appeler les méthodes des uns et des autres.
Avantages de l’injection multi-modules
Même si appeler directement un service depuis un autre module peut sembler plus simple au début, cela peut conduire à un système plus complexe, moins maintenable et moins évolutif à long terme.
Cependant, l’injection entre modules favorise la modularité et la réutilisabilité du code, ce qui facilite sa maintenance. De plus, il centralise les dépendances, améliore la testabilité et prend en charge une architecture évolutive et découplée.
