เพิ่มประสิทธิภาพให้กับ NestJS สำหรับการประมวลผลที่เร็วและมีประสิทธิภาพสูง
Tags: javascript, node, nestjs, backend
Published: 2023-07-20 17:25:41

---
title: เพิ่มประสิทธิภาพให้กับ NestJS สำหรับการประมวลผลที่เร็วและมีประสิทธิภาพสูง
published: true
description: การเพิ่มประสิทธิภาพให้กับ NestJS เพื่อรองรับการประมวลผลที่เร็วและมีประสิทธิภาพสูงไม่ใช่เรื่องยากอย่างที่คิด
tags: javascript, nodejs, nestjs, backend
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1d77gv81pzn3hd96e9ij.jpg
---

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

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

```bash
npm install -g @nestjs/cli
```

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

```bash
nest new my-project
```

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

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

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

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

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

```typescript
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 ที่เราจะสร้างขึ้นมาด้วยกัน:

```typescript
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 ได้ดังนี้:

```typescript
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 กันครับ:

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

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

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

```typescript
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 อย่างมีประสิทธิภาพ