django缓存策略 - 高性能应用优化指南

📂 所属阶段：第二部分 — 进阶特性
🎯 难度等级：中级
⏰ 预计学习时间：4-5小时

目录

缓存基础概念

缓存是提高Web应用性能的关键技术，通过存储计算结果或数据副本，避免重复计算和数据库查询。

缓存原理

缓存的工作原理很简单：当请求到达时，先检查缓存中是否有需要的数据。如果有，直接返回；如果没有，执行计算或查询，然后将结果存入缓存，供下次请求使用。

缓存的主要优势包括：

  • 减少数据库负载
  • 降低响应时间
  • 提高系统吞吐量
  • 改善用户体验

同时，缓存也带来了一些挑战，如数据一致性问题、缓存雪崩、穿透、击穿等。

缓存层级

django提供了多个层级的缓存，从低到高分别为：

  1. 数据库查询缓存
  2. 模板片段缓存
  3. 视图级别缓存
  4. 页面级别缓存
  5. 应用层缓存
  6. 代理层缓存

django缓存架构

缓存后端

django支持多种缓存后端，包括：

  • DummyCache - 空缓存（用于开发环境）
  • LocMemCache - 本地内存缓存
  • FileBasedCache - 文件系统缓存
  • DatabaseCache - 数据库缓存
  • MemcachedCache - Memcached缓存
  • RedisCache - Redis缓存（需要第三方包）

选择原则：

  • 开发环境：LocMemCache
  • 小型应用：LocMemCache或FileBasedCache
  • 生产环境：Redis或Memcached

缓存API

django提供了简单易用的缓存API：

from django.core.cache import cache

# 设置缓存
cache.set('key', 'value', timeout=300)  # 5分钟后过期

# 获取缓存
value = cache.get('key')
if value is None:
    # 缓存未命中，从数据库获取
    value = expensive_database_query()
    cache.set('key', value, timeout=300)

# 批量操作
cache.set_many({'a': 1, 'b': 2, 'c': 3}, timeout=300)
values = cache.get_many(['a', 'b', 'c'])

缓存后端配置

settings.py 配置

# settings.py - 缓存配置
import os

# 基础缓存配置
CACHES = {
    # 默认缓存
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        },
        'KEY_PREFIX': 'myapp',
        'TIMEOUT': 300,  # 5分钟默认超时
    },
    
    # 临时缓存
    'temporary': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'temp-cache',
        'TIMEOUT': 60,  # 1分钟
    },
}

Redis缓存配置

Redis是生产环境中最常用的缓存后端之一，需要先安装依赖：

pip install django-redis redis

缓存类型与使用

视图级别缓存

django提供了简单的装饰器来缓存视图：

from django.views.decorators.cache import cache_page
from django.http import JsonResponse
from .models import Product

# 函数视图缓存
@cache_page(60 * 15)  # 缓存15分钟
def product_list_view(request):
    products = Product.objects.filter(is_active=True).select_related('category')
    
    return JsonResponse({
        'products': [
            {
                'id': p.id,
                'name': p.name,
                'price': float(p.price),
            }
            for p in products
        ]
    })

模板片段缓存

在模板中，我们可以使用cache模板标签来缓存特定片段：

<!-- 在模板中使用 -->
{% load cache %}
{% cache 500 sidebar user.username %}
    <!-- 侧边栏内容，缓存500秒 -->
    <div class="sidebar">
        <h3>欢迎, {{ user.username }}!</h3>
        <p>这是侧边栏内容...</p>
    </div>
{% endcache %}

缓存策略模式

Cache-Aside模式

Cache-Aside（旁路缓存）是最常用的缓存策略之一：

class CacheAsidePattern:
    """Cache-Aside模式实现"""
    
    @staticmethod
    def get_data_with_cache(model_class, pk, timeout=300):
        """使用Cache-Aside模式获取数据"""
        cache_key = f"model:{model_class._meta.label}:{pk}"
        
        # 1. 先从缓存获取
        data = cache.get(cache_key)
        if data is not None:
            return data
        
        # 2. 缓存未命中，从数据库获取
        try:
            instance = model_class.objects.get(pk=pk)
            # 3. 将数据存入缓存
            cache.set(cache_key, instance, timeout)
            return instance
        except model_class.DoesNotExist:
            # 数据不存在，也缓存None值，避免频繁查询
            cache.set(cache_key, None, 60)
            return None

缓存性能优化

缓存压缩

对于大型数据集，可以使用缓存压缩来节省内存：

import pickle
import zlib
from django.core.cache import cache

class CompressedCache:
    """压缩缓存类"""
    
    @staticmethod
    def set_compressed(key, value, timeout=300):
        """设置压缩缓存"""
        # 序列化数据
        serialized_data = pickle.dumps(value)
        # 压缩数据
        compressed_data = zlib.compress(serialized_data)
        # 存储压缩后的数据
        cache.set(key, compressed_data, timeout)
    
    @staticmethod
    def get_compressed(key, default=None):
        """获取压缩缓存"""
        compressed_data = cache.get(key, default)
        if compressed_data is default:
            return default
        if compressed_data is None:
            return None
        # 解压缩数据
        serialized_data = zlib.decompress(compressed_data)
        # 反序列化
        return pickle.loads(serialized_data)

常见问题与解决方案

缓存雪崩

症状：大量缓存同时过期，导致数据库压力骤增。

解决方案：

  1. 使用随机过期时间
  2. 分级缓存策略
  3. 后台更新缓存
import random

def set_with_jitter(key, value, base_timeout=300, jitter_range=60):
    """设置带抖动的缓存"""
    actual_timeout = base_timeout + random.randint(-jitter_range, jitter_range)
    cache.set(key, value, actual_timeout)

缓存穿透

症状：查询不存在的数据，缓存中也没有，导致每次查询都打到数据库。

解决方案：

  1. 缓存空值
  2. 使用布隆过滤器
def get_with_null_cache(model_class, pk, timeout=300):
    """带空值缓存的获取"""
    cache_key = f"model:{model_class._meta.label}:{pk}"
    
    result = cache.get(cache_key)
    if result is not None:
        if result == "__null__":
            return None
        return result
    
    try:
        instance = model_class.objects.get(pk=pk)
        cache.set(cache_key, instance, timeout)
        return instance
    except model_class.DoesNotExist:
        # 缓存空值，避免频繁查询数据库
        cache.set(cache_key, "__null__", timeout=60)
        return None

缓存击穿

症状：热点数据过期时，大量并发请求同时查询数据库。

解决方案：

  1. 使用互斥锁
  2. 永不过期+后台更新

本章小结

在本章中，我们深入学习了django缓存策略：

  1. 缓存基础概念：理解了缓存的工作原理和重要性
  2. 缓存架构：掌握了django缓存系统的整体架构
  3. 缓存后端配置：学会了Redis等缓存后端的配置
  4. 缓存类型与使用：了解了不同层级的缓存使用方法
  5. 缓存策略模式：学习了Cache-Aside等模式
  6. 性能优化：掌握了缓存压缩等优化技术
  7. 问题解决方案：了解了雪崩、穿透、击穿等问题的解决方法

💡 核心要点：缓存策略需要根据具体的应用场景和性能需求来设计，合理的缓存策略能够显著提升应用性能，但也要注意避免缓存带来的复杂性和潜在问题。

🏷️ 标签云: django缓存 缓存策略 性能优化 Redis缓存 缓存层级