เพิ่มประสิทธิภาพให้กับ NestJS สำหรับการประมวลผลที่เร็วและมีประสิทธิภาพสูง

#javascript #node #nestjs #backend

ในโลกของการพัฒนาแอปพลิเคชันและเว็บเซอร์วิส ประสิทธิภาพและความเร็วในการประมวลผลมีความสำคัญอย่างมาก ในบทความนี้เราจะมาสอนวิธีการเพิ่มประสิทธิภาพให้กับ NestJS เพื่อให้สามารถรองรับการประมวลผลที่เร็วและมีประสิทธิภาพสูงตามที่คุณต้องการ

ก่อนอื่นเรามาตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Node.js และ NestJS ไว้ในเครื่องของคุณแล้วนะครับ ถ้ายังไม่ได้ติดตั้งคุณสามารถติดตั้งได้ง่ายๆ โดยใช้คำสั่งต่อไปนี้:

npm install -g @nestjs/cli

เมื่อคุณได้ติดตั้ง NestJS แล้ว ลองสร้างโปรเจคใหม่ด้วยคำสั่ง:

nest new my-project

ในบทความนี้ เราจะมาเรียนรู้และปรับปรุงประสิทธิภาพของ NestJS ในด้านต่อไปนี้:

การใช้ Caching เพื่อเพิ่มประสิทธิภาพ
การใช้ Middleware เพื่อประมวลผลข้อมูลก่อนเข้าสู่ Controller
การใช้ Dependency Injection ให้เหมาะสม

มาเริ่มกันเลย! 🚀

1) การใช้ Caching เพื่อเพิ่มประสิทธิภาพ

การใช้ Caching เป็นเทคนิคหนึ่งที่ช่วยเพิ่มประสิทธิภาพแอปพลิเคชันของคุณอย่างมาก โดยการเก็บข้อมูลที่ถูกคำนวณไว้ล่วงหน้า เพื่อให้ครั้งถัดไปที่มีการเรียกข้อมูลจะเป็นเหมือนเดิม คุณสามารถใช้ Caching ใน NestJS ได้โดยใช้คำสั่ง @Cacheable() ก่อนเมธอดที่คุณต้องการเก็บข้อมูลไว้

import { Controller, Get, CacheTTL, CacheInterceptor } from '@nestjs/common';
import { AppService } from './app.service';

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

  @Get()
  @CacheTTL(60) // ให้ Cache ข้อมูลเป็นเวลา 60 วินาที
  getHello(): string {
    return this.appService.getHello();
  }
}

ในตัวอย่างนี้ เราใช้ @Cacheable() และ @CacheTTL() เพื่อ

ให้เมธอด getHello() ถูกเรียกใช้งานเป็นระยะเวลา 60 วินาที หลังจากนั้นข้อมูลจะถูกเก็บในแคชและนำมาใช้ในครั้งถัดไปที่มีการเรียกเมธอดนี้

การใช้ Caching นี้เหมาะสำหรับเมธอดที่มีการคำนวณข้อมูลที่ใช้เวลานานหรือมีการเรียกใช้งานบ่อยๆ ซึ่งช่วยลดโหลดของฐานข้อมูลและเพิ่มความเร็วในการตอบกลับของแอปพลิเคชัน

2) การใช้ Middleware เพื่อประมวลผลข้อมูลก่อนเข้าสู่ Controller

Middleware ใน NestJS เป็นอีกหนึ่งเครื่องมือที่ช่วยให้คุณปรับปรุงประสิทธิภาพของแอปพลิเคชันของคุณ โดยคุณสามารถใช้ Middleware เพื่อประมวลผลข้อมูลที่เข้ามาในระหว่างการส่งเรียกไปยัง Controller ตามที่คุณต้องการ

เพื่อให้คุณเข้าใจง่ายๆ เรามาดูตัวอย่าง Middleware ที่เราจะสร้างขึ้นมาด้วยกัน:

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    console.log('Request received...');
    next();
  }
}

ในตัวอย่างนี้ เราได้สร้าง Middleware ที่ชื่อว่า LoggerMiddleware ซึ่งเป็นตัวกลางในการประมวลผลข้อมูลที่เข้ามาในระหว่างการเรียก Controller ซึ่งมีหน้าที่ในการ log ข้อความ "Request received..." ลงใน console ทุกครั้งที่มีการเรียกของ Request

หลังจากนั้นในการเรียกใช้งาน Middleware นี้ คุณสามารถนำมาประยุกต์ใช้ใน Controller ได้ดังนี้:

import { Controller, Get, UseMiddleware } from '@nestjs/common';
import { AppService } from './app.service';
import { LoggerMiddleware } from './logger.middleware';

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

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

ในตัวอย่างนี้ เราใช้ @UseMiddleware() เพื่อใช้งาน LoggerMiddleware ที่เราได้สร้างขึ้น ซึ่งจะทำการ log ข้อความ "Request received..." ลงใน console ทุกครั้งที่มีการเรียกของ Request ไปยัง Controller

Middleware เป็นเครื่องมือที่ช่วยให้คุณปรับปรุงประสิทธิภาพแอปพลิเคชันของคุณอย่างสมบูรณ์ คุณสามารถสร้าง Middleware ตามความต้องการของคุณเองเพื่อให้ทำหน้าที่เพิ่มเติมในกระบวนการของแอปพลิเคชัน

3) การใช้ Dependency Injection ให้เหมาะสม

NestJS มากับคุณสมบัติที่สำคัญที่ชื่อว่า "Dependency Injection" (DI) ซึ่งเป็นระบบที่ช่วยให้การเชื่อมต่อและใช้งาน Component และ Service ในแอปพลิเคชันของคุณเป็นไปอย่างสะดวกและเรียบง่าย ใน NestJS คุณสามารถใช้ DI ได้โดยใช้ @Injectable() กับ Class ที่คุณต้องการให้เป็น

Injectable

เรามาดูตัวอย่างการใช้งาน Dependency Injection กันครับ:

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello NestJS Beginners!';
  }
}

ในตัวอย่างนี้ เราใช้ @Injectable() เพื่อระบุว่า AppService เป็น Injectable ซึ่งใน Class AppController เราสามารถ Inject AppService เข้ามาใช้งานได้โดยการสร้าง constructor ดังนี้:

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

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

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

การใช้งาน Dependency Injection ทำให้การเชื่อมต่อและใช้งาน Component และ Service ของแอปพลิเคชันเป็นไปอย่างเรียบง่าย คุณสามารถสร้างและใช้งาน Service หรือ Component ใน NestJS ได้โดยไม่ต้องกังวลเรื่องของการเชื่อมต่อ และ NestJS จะทำการแยกแยะและให้คุณ Inject สิ่งที่คุณต้องการเข้าไปใน Class ต่างๆ อย่างง่ายดาย

สรุปก็คือ

การเพิ่มประสิทธิภาพให้กับ NestJS เพื่อรองรับการประมวลผลที่เร็วและมีประสิทธิภาพสูงไม่ใช่เรื่องยากอย่างที่คิด โดยคุณสามารถใช้ Caching เพื่อลดโหลดของฐานข้อมูลและเพิ่มความเร็วในการตอบกลับของแอปพลิเคชัน ใช้ Middleware เพื่อประมวลผลข้อมูลก่อนส่งไปยัง Controller และใช้ Dependency Injection ให้เหมาะสมเพื่อเชื่อมต่อและใช้งาน Component และ Service อย่างมีประสิทธิภาพ