Optimization of routing cache strategy

Route Caching Strategy Optimization

Route caching strategy is a key method to enhance the performance of Koa2 applications. A reasonable caching mechanism can reduce redundant computations and database queries, significantly lowering server load. The middleware architecture of Koa2 provides flexible space for caching implementation, allowing for designs that balance response speed and resource consumption.

Basic Principles of Caching Strategy

The core idea of route caching is to store frequently accessed and rarely changed data in memory or external caching systems. Common caching layers in Koa2 applications include:

1. Full Response Caching: Stores the entire HTTP response
2. Data Result Caching: Stores processed data objects from routes
3. Fragment Caching: Stores partial fragments of template rendering

Memory caching is suitable for small to medium-sized applications, using modules like lru-cache:

const LRU = require('lru-cache')
const cache = new LRU({
  max: 500, // Maximum cache entries
  maxAge: 1000 * 60 * 5 // 5-minute validity
})

Dynamic Route Caching Implementation

Dynamic routes require special handling for cache key generation. Consider an API route with parameters:

router.get('/api/users/:id', async (ctx) => {
  const cacheKey = `user_${ctx.params.id}`
  const cached = cache.get(cacheKey)
  
  if (cached) {
    ctx.body = cached
    return
  }

  const user = await User.findById(ctx.params.id)
  cache.set(cacheKey, user)
  ctx.body = user
})

For routes with complex query parameters, serialize the parameters to generate cache keys:

function generateCacheKey(ctx) {
  return `${ctx.path}?${querystring.stringify(ctx.query)}`
}

Cache Invalidation Strategy Design

Common cache invalidation mechanisms include:

1. Time-based Expiration: Sets a fixed cache lifetime
2. Active Clearing: Immediately clears related caches upon data changes
3. Conditional Validation: Uses ETag or Last-Modified for conditional requests

Example of active clearing:

router.put('/api/users/:id', async (ctx) => {
  const userId = ctx.params.id
  await User.updateById(userId, ctx.request.body)
  
  // Clear related caches
  cache.del(`user_${userId}`)
  cache.del('user_list') // Also clear list cache
  
  ctx.body = { success: true }
})

Multi-Level Cache Architecture

A multi-level cache can further improve performance:

async function getWithCache(key, fetchFunc, ttl) {
  // Level 1: Memory cache
  let data = memoryCache.get(key)
  if (data) return data

  // Level 2: Redis cache
  data = await redis.get(key)
  if (data) {
    memoryCache.set(key, data, ttl)
    return data
  }

  // Fallback to source
  data = await fetchFunc()
  memoryCache.set(key, data, ttl)
  await redis.setex(key, ttl * 2, data) // Longer Redis cache time
  
  return data
}

Cache Performance Monitoring

Implementing cache hit rate monitoring helps optimize strategies:

const stats = {
  hits: 0,
  misses: 0
}

app.use(async (ctx, next) => {
  await next()
  
  if (ctx.state.fromCache) {
    stats.hits++
  } else {
    stats.misses++
  }
})

// Periodic statistics output
setInterval(() => {
  const total = stats.hits + stats.misses
  const ratio = total > 0 ? (stats.hits / total * 100).toFixed(2) : 0
  console.log(`Cache hit rate: ${ratio}% (${stats.hits}/${total})`)
}, 60000)

Handling Special Scenarios

Pagination queries require special caching:

router.get('/api/posts', async (ctx) => {
  const { page = 1, size = 10 } = ctx.query
  const cacheKey = `posts_${page}_${size}`
  
  const posts = await getWithCache(cacheKey, async () => {
    return Post.find()
      .skip((page - 1) * size)
      .limit(size)
  }, 300000) // 5-minute cache
  
  ctx.body = posts
})

Cache cleanup for associated data updates:

router.post('/api/comments', async (ctx) => {
  const comment = await Comment.create(ctx.request.body)
  
  // Clear related post caches
  cache.del(`post_${comment.postId}`)
  cache.del(`post_${comment.postId}_comments`)
  
  ctx.body = comment
})

Cache Security Considerations

Prevent cache breakdown and avalanche:

async function safeGet(key, fetchFunc, ttl) {
  const value = cache.get(key)
  if (value !== undefined) return value

  // Use mutex lock to prevent cache breakdown
  const lockKey = `${key}_lock`
  if (cache.get(lockKey)) {
    await new Promise(resolve => setTimeout(resolve, 100))
    return safeGet(key, fetchFunc, ttl)
  }

  cache.set(lockKey, true, 1000) // 1-second lock
  
  try {
    const data = await fetchFunc()
    cache.set(key, data, ttl)
    return data
  } finally {
    cache.del(lockKey)
  }
}

Practical Optimization Case

E-commerce product detail page caching solution:

router.get('/api/products/:id', async (ctx) => {
  const productId = ctx.params.id
  const cacheKey = `product_${productId}_v2` // Versioned cache key
  
  const product = await getWithCache(cacheKey, async () => {
    const [baseInfo, skus, reviews] = await Promise.all([
      Product.findById(productId),
      Sku.find({ productId }),
      Review.find({ productId }).limit(5)
    ])
    
    return {
      ...baseInfo.toObject(),
      skus,
      reviews,
      updatedAt: Date.now() // Add timestamp
    }
  }, 1800000) // 30-minute cache

  // Client-side cache validation
  if (ctx.get('If-Modified-Since')) {
    const lastModified = new Date(ctx.get('If-Modified-Since')).getTime()
    if (product.updatedAt <= lastModified) {
      ctx.status = 304
      return
    }
  }

  ctx.set('Last-Modified', new Date(product.updatedAt).toUTCString())
  ctx.body = product
})