In today's world, speed and efficiency in responding to requests are of paramount importance for large-scale and high-traffic systems. Online platforms such as e-commerce websites, social networks, and banking services face a massive volume of data and user requests. This high demand not only places a significant load on servers and databases but can also significantly impact the user experience. In this context, implementing a caching system can be an effective solution to improve performance and reduce resource load.
In this article, we explore the implementation of an advanced caching system that combines AVL trees and Redis. This system includes security mechanisms, TTL (Time to Live) management, and integration with Redis to enhance performance and flexibility. The goal is to leverage the advantages of both technologies while mitigating their weaknesses.
Important Note: This article was developed with the assistance of artificial intelligence.
Improved Memory Efficiency:
Enhanced Security:
Advanced TTL Management:
Diverse Data Structures:
Increased Flexibility and Customization:
Increased Architectural Complexity:
Increased Time Overhead:
Data Maintenance and Synchronization:
Higher Development and Maintenance Costs:
Security Complexity:
Below, we introduce the professional implementation of this caching system. This implementation includes an AVL tree for managing data with TTL capabilities and Redis for fast data storage.
First, we implement the AVL tree with TTL management capabilities.
// src/utils/avltree.ts
export class AVLNode {
key: string;
value: any;
ttl: number; // Expiration time in milliseconds
height: number;
left: AVLNode | null;
right: AVLNode | null;
constructor(key: string, value: any, ttl: number) {
this.key = key;
this.value = value;
this.ttl = Date.now() + ttl;
this.height = 1;
this.left = null;
this.right = null;
}
isExpired(): boolean {
return Date.now() > this.ttl;
}
}
export class AVLTree {
private root: AVLNode | null;
constructor() {
this.root = null;
}
private getHeight(node: AVLNode | null): number {
return node ? node.height : 0;
}
private updateHeight(node: AVLNode): void {
node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
}
private rotateRight(y: AVLNode): AVLNode {
const x = y.left!;
y.left = x.right;
x.right = y;
this.updateHeight(y);
this.updateHeight(x);
return x;
}
private rotateLeft(x: AVLNode): AVLNode {
const y = x.right!;
x.right = y.left;
y.left = x;
this.updateHeight(x);
this.updateHeight(y);
return y;
}
private getBalance(node: AVLNode): number {
return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
}
insert(key: string, value: any, ttl: number): void {
this.root = this.insertNode(this.root, key, value, ttl);
}
private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
if (!node) return new AVLNode(key, value, ttl);
if (key < node.key) {
node.left = this.insertNode(node.left, key, value, ttl);
} else if (key > node.key) {
node.right = this.insertNode(node.right, key, value, ttl);
} else {
node.value = value;
node.ttl = Date.now() + ttl;
return node;
}
this.updateHeight(node);
const balance = this.getBalance(node);
// Balancing the tree
if (balance > 1 && key < node.left!.key) return this.rotateRight(node);
if (balance < -1 && key > node.right!.key) return this.rotateLeft(node);
if (balance > 1 && key > node.left!.key) {
node.left = this.rotateLeft(node.left!);
return this.rotateRight(node);
}
if (balance < -1 && key < node.right!.key) {
node.right = this.rotateRight(node.right!);
return this.rotateLeft(node);
}
return node;
}
search(key: string): any {
let node = this.root;
while (node) {
if (node.isExpired()) {
this.delete(key);
return null;
}
if (key === node.key) return node.value;
node = key < node.key ? node.left : node.right;
}
return null;
}
delete(key: string): void {
this.root = this.deleteNode(this.root, key);
}
private deleteNode(node: AVLNode | null, key: string): AVLNode | null {
if (!node) return null;
if (key < node.key) {
node.left = this.deleteNode(node.left, key);
} else if (key > node.key) {
node.right = this.deleteNode(node.right, key);
} else {
if (!node.left || !node.right) return node.left || node.right;
let minLargerNode = node.right;
while (minLargerNode.left) minLargerNode = minLargerNode.left;
node.key = minLargerNode.key;
node.value = minLargerNode.value;
node.ttl = minLargerNode.ttl;
node.right = this.deleteNode(node.right, minLargerNode.key);
}
this.updateHeight(node);
const balance = this.getBalance(node);
if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
if (balance < -1 && this.getBalance(node.right!) <= 0) return this.rotateLeft(node);
if (balance > 1 && this.getBalance(node.left!) < 0) {
node.left = this.rotateLeft(node.left!);
return this.rotateRight(node);
}
if (balance < -1 && this.getBalance(node.right!) > 0) {
node.right = this.rotateRight(node.right!);
return this.rotateLeft(node);
}
return node;
}
}
In this section, we implement the cache service that utilizes both the AVL tree and Redis for cache management. Additionally, we incorporate a token validation mechanism.
// src/cache/cache.service.ts
import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';
@Injectable()
export class CacheService {
private avlTree: AVLTree;
private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens
constructor(@InjectRedis() private readonly redis: Redis) {
this.avlTree = new AVLTree();
}
validateToken(token: string): void {
if (!this.authorizedTokens.has(token)) {
throw new UnauthorizedException('Invalid access token');
}
}
async set(key: string, value: any, ttl: number, token: string): Promise<void> {
this.validateToken(token);
try {
// Store in Redis
await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
// Store in AVL Tree
this.avlTree.insert(key, value, ttl);
} catch (error) {
throw new InternalServerErrorException('Failed to set cache');
}
}
async get(key: string, token: string): Promise<any> {
this.validateToken(token);
try {
// First, attempt to retrieve from Redis
const redisValue = await this.redis.get(key);
if (redisValue) {
return JSON.parse(redisValue);
}
// If not found in Redis, retrieve from AVL Tree
const avlValue = this.avlTree.search(key);
if (avlValue) {
// Re-store in Redis for faster access next time
// Assuming the remaining TTL is maintained in AVL Tree
// For simplicity, we set a new TTL
const newTtl = 60000; // 60 seconds as an example
await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
return avlValue;
}
return null;
} catch (error) {
throw new InternalServerErrorException('Failed to get cache');
}
}
async delete(key: string, token: string): Promise<void> {
this.validateToken(token);
try {
// Remove from Redis
await this.redis.del(key);
// Remove from AVL Tree
this.avlTree.delete(key);
} catch (error) {
throw new InternalServerErrorException('Failed to delete cache');
}
}
}
The controller manages API requests to the cache service.
// src/cache/cache.controller.ts
import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';
class SetCacheDto {
key: string;
value: any;
ttl: number; // milliseconds
token: string;
}
@Controller('cache')
export class CacheController {
constructor(private readonly cacheService: CacheService) {}
@Post('set')
@HttpCode(HttpStatus.CREATED)
async setCache(@Body() body: SetCacheDto) {
await this.cacheService.set(body.key, body.value, body.ttl, body.token);
return { message: 'Data cached successfully' };
}
@Get('get/:key')
async getCache(@Param('key') key: string, @Query('token') token: string) {
const value = await this.cacheService.get(key, token);
return value ? { value } : { message: 'Key not found or expired' };
}
@Delete('delete/:key')
@HttpCode(HttpStatus.NO_CONTENT)
async deleteCache(@Param('key') key: string, @Query('token') token: string) {
await this.cacheService.delete(key, token);
return { message: 'Key deleted successfully' };
}
}
Defines the cache module that connects the service and controller and injects Redis.
// src/cache/cache.module.ts
import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';
@Module({
imports: [
RedisModule.forRoot({
config: {
host: 'localhost',
port: 6379,
// Other Redis configurations
},
}),
],
providers: [CacheService],
controllers: [CacheController],
})
export class CacheModule {}
To use Redis in the NestJS project, we utilize the @nestjs-modules/ioredis package. First, install the package:
npm install @nestjs-modules/ioredis ioredis
Then, configure Redis in the CacheModule as shown above. If you require more advanced configurations, you can use separate configuration files.
For managing and validating tokens, various strategies can be employed. In this simple implementation, tokens are maintained in a fixed set. For larger projects, it is recommended to use JWT (JSON Web Tokens) or other advanced security methods.
In this implementation, DTO (Data Transfer Object) classes are used for input validation and error management. Additionally, the cache service utilizes general error handling to prevent unexpected issues.
Finally, we add the cache module to the main application module.
// src/utils/avltree.ts
export class AVLNode {
key: string;
value: any;
ttl: number; // Expiration time in milliseconds
height: number;
left: AVLNode | null;
right: AVLNode | null;
constructor(key: string, value: any, ttl: number) {
this.key = key;
this.value = value;
this.ttl = Date.now() + ttl;
this.height = 1;
this.left = null;
this.right = null;
}
isExpired(): boolean {
return Date.now() > this.ttl;
}
}
export class AVLTree {
private root: AVLNode | null;
constructor() {
this.root = null;
}
private getHeight(node: AVLNode | null): number {
return node ? node.height : 0;
}
private updateHeight(node: AVLNode): void {
node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
}
private rotateRight(y: AVLNode): AVLNode {
const x = y.left!;
y.left = x.right;
x.right = y;
this.updateHeight(y);
this.updateHeight(x);
return x;
}
private rotateLeft(x: AVLNode): AVLNode {
const y = x.right!;
x.right = y.left;
y.left = x;
this.updateHeight(x);
this.updateHeight(y);
return y;
}
private getBalance(node: AVLNode): number {
return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
}
insert(key: string, value: any, ttl: number): void {
this.root = this.insertNode(this.root, key, value, ttl);
}
private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
if (!node) return new AVLNode(key, value, ttl);
if (key < node.key) {
node.left = this.insertNode(node.left, key, value, ttl);
} else if (key > node.key) {
node.right = this.insertNode(node.right, key, value, ttl);
} else {
node.value = value;
node.ttl = Date.now() + ttl;
return node;
}
this.updateHeight(node);
const balance = this.getBalance(node);
// Balancing the tree
if (balance > 1 && key < node.left!.key) return this.rotateRight(node);
if (balance < -1 && key > node.right!.key) return this.rotateLeft(node);
if (balance > 1 && key > node.left!.key) {
node.left = this.rotateLeft(node.left!);
return this.rotateRight(node);
}
if (balance < -1 && key < node.right!.key) {
node.right = this.rotateRight(node.right!);
return this.rotateLeft(node);
}
return node;
}
search(key: string): any {
let node = this.root;
while (node) {
if (node.isExpired()) {
this.delete(key);
return null;
}
if (key === node.key) return node.value;
node = key < node.key ? node.left : node.right;
}
return null;
}
delete(key: string): void {
this.root = this.deleteNode(this.root, key);
}
private deleteNode(node: AVLNode | null, key: string): AVLNode | null {
if (!node) return null;
if (key < node.key) {
node.left = this.deleteNode(node.left, key);
} else if (key > node.key) {
node.right = this.deleteNode(node.right, key);
} else {
if (!node.left || !node.right) return node.left || node.right;
let minLargerNode = node.right;
while (minLargerNode.left) minLargerNode = minLargerNode.left;
node.key = minLargerNode.key;
node.value = minLargerNode.value;
node.ttl = minLargerNode.ttl;
node.right = this.deleteNode(node.right, minLargerNode.key);
}
this.updateHeight(node);
const balance = this.getBalance(node);
if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
if (balance < -1 && this.getBalance(node.right!) <= 0) return this.rotateLeft(node);
if (balance > 1 && this.getBalance(node.left!) < 0) {
node.left = this.rotateLeft(node.left!);
return this.rotateRight(node);
}
if (balance < -1 && this.getBalance(node.right!) > 0) {
node.right = this.rotateRight(node.right!);
return this.rotateLeft(node);
}
return node;
}
}
The main application file that bootstraps NestJS.
// src/cache/cache.service.ts
import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';
@Injectable()
export class CacheService {
private avlTree: AVLTree;
private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens
constructor(@InjectRedis() private readonly redis: Redis) {
this.avlTree = new AVLTree();
}
validateToken(token: string): void {
if (!this.authorizedTokens.has(token)) {
throw new UnauthorizedException('Invalid access token');
}
}
async set(key: string, value: any, ttl: number, token: string): Promise<void> {
this.validateToken(token);
try {
// Store in Redis
await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
// Store in AVL Tree
this.avlTree.insert(key, value, ttl);
} catch (error) {
throw new InternalServerErrorException('Failed to set cache');
}
}
async get(key: string, token: string): Promise<any> {
this.validateToken(token);
try {
// First, attempt to retrieve from Redis
const redisValue = await this.redis.get(key);
if (redisValue) {
return JSON.parse(redisValue);
}
// If not found in Redis, retrieve from AVL Tree
const avlValue = this.avlTree.search(key);
if (avlValue) {
// Re-store in Redis for faster access next time
// Assuming the remaining TTL is maintained in AVL Tree
// For simplicity, we set a new TTL
const newTtl = 60000; // 60 seconds as an example
await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
return avlValue;
}
return null;
} catch (error) {
throw new InternalServerErrorException('Failed to get cache');
}
}
async delete(key: string, token: string): Promise<void> {
this.validateToken(token);
try {
// Remove from Redis
await this.redis.del(key);
// Remove from AVL Tree
this.avlTree.delete(key);
} catch (error) {
throw new InternalServerErrorException('Failed to delete cache');
}
}
}
After implementing all components, you can run the application to ensure its functionality.
// src/cache/cache.controller.ts
import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';
class SetCacheDto {
key: string;
value: any;
ttl: number; // milliseconds
token: string;
}
@Controller('cache')
export class CacheController {
constructor(private readonly cacheService: CacheService) {}
@Post('set')
@HttpCode(HttpStatus.CREATED)
async setCache(@Body() body: SetCacheDto) {
await this.cacheService.set(body.key, body.value, body.ttl, body.token);
return { message: 'Data cached successfully' };
}
@Get('get/:key')
async getCache(@Param('key') key: string, @Query('token') token: string) {
const value = await this.cacheService.get(key, token);
return value ? { value } : { message: 'Key not found or expired' };
}
@Delete('delete/:key')
@HttpCode(HttpStatus.NO_CONTENT)
async deleteCache(@Param('key') key: string, @Query('token') token: string) {
await this.cacheService.delete(key, token);
return { message: 'Key deleted successfully' };
}
}
Set Cache:
// src/cache/cache.module.ts
import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';
@Module({
imports: [
RedisModule.forRoot({
config: {
host: 'localhost',
port: 6379,
// Other Redis configurations
},
}),
],
providers: [CacheService],
controllers: [CacheController],
})
export class CacheModule {}
Get Cache:
npm install @nestjs-modules/ioredis ioredis
Delete Cache:
// src/app.module.ts
import { Module } from '@nestjs/common';
import { CacheModule } from './cache/cache.module';
@Module({
imports: [CacheModule],
controllers: [],
providers: [],
})
export class AppModule {}
Banking and Financial Systems:
High-Traffic E-commerce Platforms:
Messaging and Social Networking Applications:
Weather and Currency Exchange Applications:
Content Management Systems and Media Platforms:
Analytical Applications and Real-Time Dashboards:
In this article, we implemented an advanced caching system using AVL trees and Redis within the NestJS framework. This system, offering advanced TTL management, token-based security, and Redis integration, provides a robust and flexible solution for high-demand applications. The combination of these two technologies leverages the strengths of both, addressing Redis's weaknesses and enhancing overall caching performance.
The above is the detailed content of Boosting Speed and Performance with Advanced Caching in NestJS: How to Use AVL Trees and Redis. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
