18.15-Hono性能调优实践

import { Hono } from 'hono'
 
const app = new Hono()
 
app.get('/hello', (c) => c.text('Hello'))

// 不好：所有中间件都跑在所有路由上
app.use('*', logger())       // 每次请求都打日志
app.use('*', cors())         // 每次请求都处理 CORS
app.use('*', auth())         // 每次请求都鉴权
app.use('*', rateLimit())    // 每次请求都限流
 
app.get('/api/data', handler)
app.get('/health', healthHandler)  // 健康检查也要跑所有中间件

// 好：只对需要的路由加中间件
const api = new Hono()
api.use('*', auth())
api.use('*', rateLimit())
api.get('/data', handler)
 
const public = new Hono()
public.use('*', cors())
public.get('/health', healthHandler)  // 不需要鉴权、限流
 
app.route('/api', api)
app.route('/', public)

// 缓存命中时，直接返回，不调用 next()
app.get('/api/models', async (c, next) => {
  const cached = await cache.get('models')
  if (cached) {
    return c.json(cached)  // 短路返回，跳过后续中间件
  }
  await next()
})

// SSE 流式响应
app.get('/api/events', (c) => {
  const stream = new ReadableStream({
    async start(controller) {
      const encoder = new TextEncoder()
 
      // 监听事件，推送到客户端
      const listener = (event: any) => {
        controller.enqueue(
          encoder.encode(`data: ${JSON.stringify(event)}\n\n`)
        )
      }
 
      eventBus.on('update', listener)
 
      // 客户端断开时清理
      c.req.raw.signal.addEventListener('abort', () => {
        eventBus.off('update', listener)
        controller.close()
      })
    },
  })
 
  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      Connection: 'keep-alive',
    },
  })
})

app.post('/api/ai/chat', async (c) => {
  const { messages } = await c.req.json()
 
  const stream = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
    messages,
    stream: true,
  })
 
  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
    },
  })
})

// src/middleware/index.ts
import { Hono } from 'hono'
import { logger } from './logger'
import { cors } from './cors'
import { auth } from './auth'
import { rateLimit } from './rate-limit'
import { cache } from './cache'
 
export function createApp() {
  const app = new Hono()
 
  // 全局中间件（所有请求）
  app.use('*', logger())
  app.use('*', cors())
 
  // 公开 API
  const publicAPI = new Hono()
  publicAPI.use('*', rateLimit({ limit: 100, window: 60 }))
  app.route('/api/public', publicAPI)
 
  // 私有 API
  const privateAPI = new Hono()
  privateAPI.use('*', auth())
  privateAPI.use('*', rateLimit({ limit: 1000, window: 60 }))
  app.route('/api', privateAPI)
 
  // 健康检查（无中间件）
  app.get('/health', (c) => c.text('OK'))
 
  return app
}

// src/lib/cache-layer.ts
export class CacheLayer {
  constructor(
    private memory: MemoryCache,
    private kv: KVNamespace
  ) {}
 
  async get<T>(key: string): Promise<T | null> {
    // L1：内存
    const mem = this.memory.get(key)
    if (mem) return mem as T
 
    // L2：KV
    const kv = await this.kv.get(key, { type: 'json' })
    if (kv) {
      // 回填 L1
      this.memory.set(key, kv, 60_000)
      return kv as T
    }
 
    return null
  }
 
  async set<T>(key: string, value: T, ttl: number): Promise<void> {
    this.memory.set(key, value, Math.min(ttl, 60_000))
    await this.kv.put(key, JSON.stringify(value), { expirationTtl: ttl })
  }
}

// src/middleware/metrics.ts
export function metrics() {
  return async (c: Context, next: Next) => {
    const start = Date.now()
    const path = new URL(c.req.url).pathname
 
    try {
      await next()
 
      const duration = Date.now() - start
      const status = c.res.status
 
      // 上报到监控系统
      await reportMetric({
        path,
        status,
        duration,
        timestamp: Date.now(),
      })
    } catch (e) {
      const duration = Date.now() - start
      await reportMetric({
        path,
        status: 500,
        duration,
        error: (e as Error).message,
        timestamp: Date.now(),
      })
      throw e
    }
  }
}

console.log(JSON.stringify({
  level: 'info',
  path: '/api/ai/query',
  method: 'POST',
  status: 200,
  duration: 123,
  userId: '123',
  cacheHit: false,
  tokens: 500,
  timestamp: Date.now(),
}))