NestJS უზრუნველყოფს ჩაშენებული caching module-ს (@nestjs/cache-manager) ერთიანი API-ით, რომელიც მუშაობს სხვადსხვა store-ებთან — ნაგულისხმევად in-memory, ან Redis distributed caching-ისთვის მრავალი instance-ის ფარგლებში. Caching მკაცრად აუმჯობესებს performance-ს განმეორებული ძვირი ოპერაციების თავიდან 避けることで.
({
: [
.({
: ,
: ,
: ,
}),
],
})
{}
@Controller("products")
@UseInterceptors(CacheInterceptor) // automatically caches GET responses
export class ProductsController {
@Get()
@CacheTTL(30000) // override TTL for this route
findAll() {
return this.productsService.findAll(); // result cached; subsequent GETs are instant
}
}
CacheInterceptor ავტომატურად cache-ს სახელავს GET endpoint-ის პასუხებს (URL-ით გასაღებული) და ხელმისაწვდომელი ხდის cached შედეგებს განმეორებითი request-ების დროს — ეს არის ყველაზე მარტივი გზა read-heavy endpoint-ების cache-აციისთვის.
@Injectable()
export class ProductsService {
constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}
async getProduct(id: string) {
const cached = await this.cache.get(`product:${id}`); // check cache first
if (cached) return cached; // cache HIT
const product = await this.db.findProduct(id); // cache MISS — fetch
await this.cache.set(`product:${id}`, product, 3600000); // store (1h TTL)
return product;
}
}
CACHE_MANAGER-ის injecting-ით სრული კონტროლი მიიღება — get-or-fetch pattern (cache-ის შემოწმება, წყაროსთან დაბრუნება, შედეგის შენახვა) ხელმისაწვდომელი კონკრეტული ძვირი ოპერაციების cache-აციისთვის.
CacheModule.registerAsync({
useFactory: async () => ({
store: await redisStore({ url: process.env.REDIS_URL }), // use Redis as the store
ttl: 60000,
}),
});
იგივე API, Redis-ით მხარდაჭერილი, იძლება განზიარებულ cache-ს ყველა app instance-ის ფარგლებში — აუცილებელი მრავალი instance-ის გაშვებისას (in-memory cache არ იზიარება მათ შორის).
async updateProduct(id: string, data) {
await this.db.update(id, data);
await this.cache.del(`product:${id}`); // INVALIDATE on change → avoid stale data
}
The biggest caching challenge: INVALIDATION. When data changes, the cache must be
cleared/updated, or users see stale data. Strategies: TTL (accept brief staleness),
explicit deletion on writes (cache.del), or cache tags.
Caching არის ერთი ყველაზე მაღალი-გავლენის performance optimization-ი back-end აპლიკაციებისთვის, და NestJS-ის ჩაშენებული caching module აქცევს მას სუფთა და თანმიმდევრულ.
იმის გაგება მნიშვნელოვანია, რადგან read-heavy API-ები მშვენივრად სარგებლობენ cache-ს ძვირი ოპერაციების (database query-ები, გარე API call-ები, გამოთვლები) — დაკავშირებული latency-ის და load-ის მკაცრი შემცირება.
NestJS გთავაზობთ როგორც მარტივ auto-caching-ს (CacheInterceptor GET endpoint-ებისთვის) ისე fine-grained manual control-ს (CACHE_MANAGER get-or-fetch pattern კონკრეტული ოპერაციებისთვის).
მნიშვნელოვანი ის არის, რომ ერთიანი API მუშაობს სხვადსხვა store-ებთან, ასე რომ ერთი და იგივე კოდი შეიძლება გამოიყენოს in-memory caching-ს (სწრაფი, ერთი-instance) ან Redis-ს (განზიარებული cache მრავალი instance-ის ფარგლებში) — და იმის ცოდნა, რომ in-memory cache არ არის განზიარებული ჰორიზონტალური სკალირების დროს (Redis-ის საჭირო distributed caching-ისთვის) არის მნიშვნელოვანი არქიტექტურული პუნქტი.
თანაბრად მნიშვნელოვანია caching-ის ცენტრალური სირთულის გაგება — invalidation (cache-ს დაზიანება ან update-ი მონაცემების ცვლილებისას, TTL-ით ან explicit deletion-ით, stale მონაცემების ემსახურებისა თავიდან ასაცილებლად) — რადგან ამის არასწორად გაკეთება არის caching failure-ის კლასიკური შემთხვევა.
cache-ის როგორ და როდის გამოყენება, სწორი store-ის არჩევა deployment-ისთვის, და invalidation-ის სწორად დამუშავება არის ღირებული senior-level ცოდნა სწრაფი, scalable NestJS service-ების აშენებისთვის.