一键导入
caching-strategies
Implement multi-layer caching with Redis, in-memory, and HTTP caching. Covers cache invalidation, stampede prevention, and cache-aside patterns.
菜单
Implement multi-layer caching with Redis, in-memory, and HTTP caching. Covers cache invalidation, stampede prevention, and cache-aside patterns.
Two-phase commit matchmaking that verifies both player connections before creating a match. Handles disconnections gracefully with automatic re-queue of healthy players.
Implement robust background job processing with dead letter queues, retries, and state machines. Use when building async workflows, scheduled tasks, or any work that shouldn't block the request/response cycle.
Manage data flow when producers outpace consumers. Bounded buffers, adaptive flushing, and graceful degradation prevent OOM crashes and data loss.
Collect-then-batch pattern for database operations achieving 30-40% throughput improvement. Includes graceful fallback to sequential processing when batch operations fail.
Exactly-once processing semantics with distributed coordination for file-based data pipelines. Atomic file claiming, status tracking, and automatic retry with in-memory fallback.
Cloud storage integration with signed URLs, visibility control, multi-tenant path conventions, and presigned uploads for direct client uploads.
| name | caching-strategies |
| description | Implement multi-layer caching with Redis, in-memory, and HTTP caching. Covers cache invalidation, stampede prevention, and cache-aside patterns. |
| license | MIT |
| compatibility | TypeScript/JavaScript, Python |
| metadata | {"category":"performance","time":"4h","source":"drift-masterguide"} |
Speed up your app with smart caching at every layer.
┌─────────────────────────────────────────────────────┐
│ Request │
└─────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ Layer 1: HTTP Cache (CDN/Browser) │
│ - Static assets, public API responses │
│ - Cache-Control headers │
└─────────────────────────────────────────────────────┘
│ miss
▼
┌─────────────────────────────────────────────────────┐
│ Layer 2: In-Memory Cache (Node/Process) │
│ - Hot data, computed values │
│ - LRU eviction │
└─────────────────────────────────────────────────────┘
│ miss
▼
┌─────────────────────────────────────────────────────┐
│ Layer 3: Distributed Cache (Redis) │
│ - Shared across instances │
│ - Session data, rate limits │
└─────────────────────────────────────────────────────┘
│ miss
▼
┌─────────────────────────────────────────────────────┐
│ Layer 4: Database │
└─────────────────────────────────────────────────────┘
// cache.ts
import { Redis } from 'ioredis';
import { LRUCache } from 'lru-cache';
interface CacheOptions {
ttl?: number; // Time to live in seconds
staleWhileRevalidate?: number;
tags?: string[]; // For invalidation
}
class MultiLayerCache {
private memory: LRUCache<string, { value: unknown; expires: number }>;
private redis: Redis;
constructor(redis: Redis) {
this.redis = redis;
this.memory = new LRUCache({
max: 1000,
ttl: 60 * 1000, // 1 minute default
});
}
async get<T>(key: string): Promise<T | null> {
// Layer 1: Memory
const memoryHit = this.memory.get(key);
if (memoryHit && memoryHit.expires > Date.now()) {
return memoryHit.value as T;
}
// Layer 2: Redis
const redisValue = await this.redis.get(key);
if (redisValue) {
const parsed = JSON.parse(redisValue) as T;
// Populate memory cache
this.memory.set(key, { value: parsed, expires: Date.now() + 60000 });
return parsed;
}
return null;
}
async set<T>(key: string, value: T, options: CacheOptions = {}): Promise<void> {
const ttl = options.ttl || 3600; // 1 hour default
// Set in Redis
await this.redis.setex(key, ttl, JSON.stringify(value));
// Set in memory (shorter TTL)
this.memory.set(key, {
value,
expires: Date.now() + Math.min(ttl * 1000, 60000),
});
// Track tags for invalidation
if (options.tags) {
for (const tag of options.tags) {
await this.redis.sadd(`cache:tag:${tag}`, key);
}
}
}
async getOrSet<T>(
key: string,
fetcher: () => Promise<T>,
options: CacheOptions = {}
): Promise<T> {
const cached = await this.get<T>(key);
if (cached !== null) {
return cached;
}
// Prevent cache stampede with lock
const lockKey = `lock:${key}`;
const acquired = await this.redis.set(lockKey, '1', 'EX', 10, 'NX');
if (!acquired) {
// Another process is fetching, wait and retry
await new Promise(resolve => setTimeout(resolve, 100));
return this.getOrSet(key, fetcher, options);
}
try {
const value = await fetcher();
await this.set(key, value, options);
return value;
} finally {
await this.redis.del(lockKey);
}
}
async invalidate(key: string): Promise<void> {
this.memory.delete(key);
await this.redis.del(key);
}
async invalidateByTag(tag: string): Promise<void> {
const keys = await this.redis.smembers(`cache:tag:${tag}`);
if (keys.length > 0) {
await this.redis.del(...keys);
for (const key of keys) {
this.memory.delete(key);
}
}
await this.redis.del(`cache:tag:${tag}`);
}
}
export { MultiLayerCache, CacheOptions };
// user-service.ts
class UserService {
constructor(private cache: MultiLayerCache) {}
async getUser(id: string): Promise<User> {
return this.cache.getOrSet(
`user:${id}`,
async () => {
return db.users.findUnique({ where: { id } });
},
{ ttl: 3600, tags: ['users', `user:${id}`] }
);
}
async updateUser(id: string, data: Partial<User>): Promise<User> {
const user = await db.users.update({
where: { id },
data,
});
// Invalidate cache
await this.cache.invalidate(`user:${id}`);
return user;
}
async deleteUser(id: string): Promise<void> {
await db.users.delete({ where: { id } });
await this.cache.invalidateByTag(`user:${id}`);
}
}
// http-cache-middleware.ts
import { Request, Response, NextFunction } from 'express';
interface HttpCacheOptions {
maxAge?: number;
sMaxAge?: number;
staleWhileRevalidate?: number;
private?: boolean;
vary?: string[];
}
function httpCache(options: HttpCacheOptions = {}) {
return (req: Request, res: Response, next: NextFunction) => {
const directives: string[] = [];
if (options.private) {
directives.push('private');
} else {
directives.push('public');
}
if (options.maxAge !== undefined) {
directives.push(`max-age=${options.maxAge}`);
}
if (options.sMaxAge !== undefined) {
directives.push(`s-maxage=${options.sMaxAge}`);
}
if (options.staleWhileRevalidate !== undefined) {
directives.push(`stale-while-revalidate=${options.staleWhileRevalidate}`);
}
res.setHeader('Cache-Control', directives.join(', '));
if (options.vary) {
res.setHeader('Vary', options.vary.join(', '));
}
next();
};
}
// Usage
app.get('/api/products',
httpCache({ maxAge: 60, sMaxAge: 300, staleWhileRevalidate: 86400 }),
async (req, res) => {
const products = await getProducts();
res.json(products);
}
);
# cache.py
import json
import time
from typing import TypeVar, Callable, Optional
from functools import lru_cache
import redis
T = TypeVar('T')
class MultiLayerCache:
def __init__(self, redis_client: redis.Redis):
self.redis = redis_client
self._memory: dict[str, tuple[any, float]] = {}
def get(self, key: str) -> Optional[any]:
# Layer 1: Memory
if key in self._memory:
value, expires = self._memory[key]
if expires > time.time():
return value
del self._memory[key]
# Layer 2: Redis
redis_value = self.redis.get(key)
if redis_value:
parsed = json.loads(redis_value)
self._memory[key] = (parsed, time.time() + 60)
return parsed
return None
def set(self, key: str, value: any, ttl: int = 3600, tags: list[str] = None):
self.redis.setex(key, ttl, json.dumps(value))
self._memory[key] = (value, time.time() + min(ttl, 60))
if tags:
for tag in tags:
self.redis.sadd(f"cache:tag:{tag}", key)
async def get_or_set(
self,
key: str,
fetcher: Callable[[], T],
ttl: int = 3600,
) -> T:
cached = self.get(key)
if cached is not None:
return cached
# Simple lock for stampede prevention
lock_key = f"lock:{key}"
if not self.redis.set(lock_key, "1", ex=10, nx=True):
await asyncio.sleep(0.1)
return await self.get_or_set(key, fetcher, ttl)
try:
value = await fetcher()
self.set(key, value, ttl)
return value
finally:
self.redis.delete(lock_key)
def invalidate_by_tag(self, tag: str):
keys = self.redis.smembers(f"cache:tag:{tag}")
if keys:
self.redis.delete(*keys)
for key in keys:
self._memory.pop(key.decode(), None)
self.redis.delete(f"cache:tag:{tag}")
# cache_decorator.py
from functools import wraps
def cached(key_template: str, ttl: int = 3600, tags: list[str] = None):
def decorator(func):
@wraps(func)
async def wrapper(*args, **kwargs):
# Build cache key from template
key = key_template.format(*args, **kwargs)
cached_value = cache.get(key)
if cached_value is not None:
return cached_value
result = await func(*args, **kwargs)
cache.set(key, result, ttl=ttl, tags=tags)
return result
return wrapper
return decorator
# Usage
@cached("user:{user_id}", ttl=3600, tags=["users"])
async def get_user(user_id: str) -> User:
return await db.users.find_unique(where={"id": user_id})
await cache.set('key', value, { ttl: 3600 }); // Expires in 1 hour
// On data change
eventBus.on('user.updated', async (userId) => {
await cache.invalidate(`user:${userId}`);
});
// Set with tags
await cache.set(`product:${id}`, product, { tags: ['products', `category:${categoryId}`] });
// Invalidate all products in category
await cache.invalidateByTag(`category:${categoryId}`);
async function updateUser(id: string, data: Partial<User>) {
const user = await db.users.update({ where: { id }, data });
await cache.set(`user:${id}`, user); // Update cache immediately
return user;
}