Tiêm dịch vụ Nest.js từ một mô-đun khác

Việc chèn một dịch vụ từ một mô-đun Nest.js khác bao gồm một số bước để đảm bảo tổ chức mô-đun và chèn phần phụ thuộc phù hợp. Sử dụng hai mô-đun mẫu, tìm hiểu cách hoạt động của quy trình xuất và nhập dịch vụ.

Tạo dự án Nest.js

Để tạo ứng dụng Nest.js, hãy đảm bảo rằng Giao diện dòng lệnh (CLI) đã được cài đặt trên hệ thống của bạn. Trong trường hợp không, hãy thực hiện lệnh sau để thiết lập CLI:

 npm install -g @nestjs/cli

Để tạo dự án Nest.js mới bằng Giao diện dòng lệnh Nest.js (CLI), hãy thực hiện các bước sau:1. Cài đặt Nest.js CLI bằng cách chạy lệnh “npm install-g @nestjs/cli” hoặc “@yarn Global add Nestjs-cli”. Điều này sẽ cho phép bạn quản lý và tương tác với các dự án Nest.js của mình từ dòng lệnh.2. Chạy lệnh “nest new” để tạo dự án Nest.js mới trong thư mục đã chỉ định. Cấu hình mặc định cho dự án mới tạo đã được thiết lập và sẵn sàng để phát triển.

 nest new <project-name>

Sau khi thực hiện lệnh được cung cấp, người ta có thể thay thế’‘bằng tên gọi mà họ chọn để thiết lập môi trường phát triển Nest.js mới mang tiêu đề được chỉ định.

Cấu hình hiện tại của dự án của bạn phải phù hợp với mô tả được minh họa trong phần trình bày đồ họa được cung cấp bên dưới:

Để trau dồi kỹ năng tích hợp các dịch vụ trên các mô-đun riêng biệt, bạn cần tạo hai mô-đun riêng biệt, đó là mô-đun-a và mô-đun-b, cùng với các tệp dịch vụ và bộ điều khiển đi kèm cho mỗi mô-đun.

Chạy lệnh này để tạo mô-đun-a:

 nest generate module module-a

Và chạy lệnh tương đương cho module-b:

 nest generate module module-b

Để tạo các tệp cần thiết cho mô-đun-a, hãy thực hiện lệnh sau:

 nest generate service module-a && nest generate controller module-a

Và chạy lệnh tương đương cho module-b:

 nest generate service module-b && nest generate controller module-b

Cấu trúc của thư mục dự án hiện tại của bạn sẽ giống với sự sắp xếp theo thứ bậc, bao gồm hai thư mục con chính—cụ thể là “src/module-a” và “src/module-b”.

Xuất dịch vụ từ Mô-đun A

Để trích xuất thành phần Service-A từ Mô-đun-A và làm cho nó có thể truy cập được để sử dụng ở nơi khác trong ứng dụng, người ta phải đưa nó vào trong số các mục được liệt kê trong mục “xuất” trong tệp mô-đun của Mô-đun-A (tức là Mô-đun-A. mô-đun.ts). Thông thường, khi sử dụng Giao diện dòng lệnh Nest.js (CLI), không có mảng “xuất” được xác định trước được cung cấp cùng với trình trang trí “@Module”; do đó, tệp mô-đun kết quả sẽ có cấu trúc tương tự như sau:

 // 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],
})

export class ModuleAModule {}

Để cho phép khả năng truy cập của module-a.service.ts bằng các mô-đun khác nhập module-a , mảng aexports phải được tạo trong trình trang trí @Module và ModuleAService phải được thêm vào nó.

Giống như vậy:

 import { Module } from '@nestjs/common';
import { ModuleAService } from './module-a.service';
import { ModuleAController } from './module-a.controller';

@Module({
  providers: [ModuleAService],
  controllers: [ModuleAController],
  exports: [ModuleAService],
})

export class ModuleAModule {}

Để thực hiện kiểm tra trên dịch vụ module-a, bạn có thể tạo một tệp mới có tên module-a.service.ts trong cùng thư mục với các tệp khác trong dự án này. Tệp này sẽ chứa một hàm đơn giản sử dụng lớp ModuleAService và thể hiện chức năng của nó.

 import { Injectable } from '@nestjs/common';

@Injectable()
export class ModuleAService {
  getHello(): string {
    return 'Hello from Module A!';
  }
}

Văn bản nhất định dường như được viết bằng ngôn ngữ thông tục và thiếu sự tinh tế. Đây là một nỗ lực nhằm diễn đạt lại nó một cách tinh tế hơn: Để đảm bảo chức năng phù hợp của dịch vụ này, chúng tôi khuyên bạn nên gọi hàm nói trên trong mô-đun được chỉ định (mô-đun-b) sau khi chèn dịch vụ-a. Bằng cách đó, người ta có thể xác minh việc tích hợp thành công dịch vụ nói trên.

Nhập dịch vụ vào Mô-đun B

Để một mô-đun có thể được nhập vào một mô-đun khác, nó phải được liệt kê trong số các mục nhập của trang trí @Module của mô-đun nhận. Do đó, trong trường hợp mô-đun-a đang được mô-đun-b nhập, nó phải được thêm vào mảng nhập trong trình trang trí @Module của mô-đun-b.

Để sử dụng các mô-đun đã nhập trong dự án Nest.js, người ta phải tạo một mảng nhập khẩu trong tệp mô-đun ứng dụng theo cách thủ công. Giao diện dòng lệnh Nest.js (CLI) không cung cấp chức năng này theo mặc định, cần phải can thiệp thủ công để đưa vào.

Thật vậy, quá trình này bao gồm việc nhập mô-đun gốc từ tệp “module-a.module.ts” vào mô-đun nhận nằm trong “module-b.module.ts”. Sau đó, một câu lệnh nhập được tạo trong mã của mô-đun nhận và được thêm vào một mảng cụ thể, sau đó mô-đun mong muốn, cụ thể là “ModuleAModule”, sẽ được thêm vào cùng mảng đó.

 // 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],
})

export class ModuleBModule {}

Thật vậy, chúng ta hãy tiến hành bước tiếp theo bằng cách mở tệp module-b.service.ts trong dự án của chúng tôi. Chúng ta sẽ cần nhập cả lớp trang trí @Inject và lớp ModuleAService từ hai nguồn khác nhau trong cơ sở mã của ứng dụng của chúng ta. Cụ thể, chúng tôi phải lấy các mục này từ gói @nestjs/common cho gói trước và một vị trí riêng biệt ở nơi khác trong cấu trúc dự án của chúng tôi cho gói sau.

 import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';

Trình trang trí Inject chỉ định tham số của nó là đối tượng nhận dự kiến ​​của phần chèn phụ thuộc, biểu thị rằng đó là một thành phần quan trọng trong chức năng của hệ thống và cần được cung cấp các tài nguyên hoặc dịch vụ cần thiết để hoạt động hiệu quả.

Thật vậy, trong ngữ cảnh của lớp ModuleBService, cần phải kết hợp đoạn mã nói trên vào một thời điểm thích hợp.

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Việc cấp quyền truy cập vào các phương thức của ModuleAService được tạo điều kiện thông qua khối mã được cung cấp, từ đó cho phép sử dụng trong ModuleBService.

Người ta có thể xác thực chức năng của Dịch vụ, phương thức “getHello” của ModuleAService, thông qua thử nghiệm.

 // module-b.service.ts
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from 'src/module-a/module-a.service';

@Injectable()
export class ModuleBService {
  @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

  getHello(): string {
    return this.moduleAService.getHello();
  }
}

Thật vậy, bây giờ chúng ta hãy tiến hành sửa đổi nội dung của tệp module-b.controller.ts bằng cách thay thế mã hiện có bằng đoạn mã được cung cấp.

 // module-b.controller.ts
import { Controller, Get } from '@nestjs/common';
import { ModuleBService } from './module-b.service';

@Controller('module-b')
export class ModuleBController {
  constructor(private readonly moduleBService: ModuleBService) {}

  @Get('/hello')
  getHello(): string {
    return this.moduleBService.getHello();
  }
}

Đoạn mã được cung cấp thiết lập cơ chế xử lý yêu cầu HTTP GET cho hàm “getHello”, chịu trách nhiệm truy xuất và xử lý dữ liệu liên quan đến các yêu cầu hoặc đầu vào cụ thể của người dùng.

Cuối cùng, thực hiện yêu cầu GET bằng cURL tới http://localhost:3000/module-b/hello. Lệnh sẽ hiển thị “Xin chào từ Mô-đun A!” trong bảng điều khiển.

Việc đưa dịch vụ vào một mô-đun khác thành công đặc biệt có lợi khi phát triển API trong Nest.js, thường liên quan đến nhiều mô-đun phụ thuộc lẫn nhau yêu cầu quyền truy cập vào các chức năng của nhau.

Lợi ích của việc tiêm chéo mô-đun

Việc kết hợp một dịch vụ bằng cách gọi trực tiếp ban đầu có thể được coi là một lựa chọn phù hợp; tuy nhiên, nó thường dẫn đến kiến ​​trúc phức tạp hơn, khó bảo trì hơn và bị giới hạn về phạm vi theo thời gian.

Thật vậy, việc triển khai chèn mô-đun chéo sẽ thúc đẩy một hệ thống gắn kết và dễ thích ứng hơn bằng cách tăng cường tính mô-đun và tạo điều kiện tái sử dụng thành phần. Hơn nữa, cách tiếp cận này củng cố sự phụ thuộc, nâng cao tính khả thi của thử nghiệm và tạo ra một thiết kế kết hợp lỏng lẻo, hợp lý về mặt kiến ​​trúc, có khả năng hỗ trợ sự phát triển.