Django 缓存机制

# settings.py
MIDDLEWARE = [
    # 更新缓存中间件应该在前面
    'django.middleware.cache.UpdateCacheMiddleware',

    # 其他中间件...
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',

    # 获取缓存中间件应该在后面
    'django.middleware.cache.FetchFromCacheMiddleware',
]

# 缓存设置
CACHE_MIDDLEWARE_ALIAS = 'default'  # 使用的缓存别名
CACHE_MIDDLEWARE_SECONDS = 600      # 默认缓存时间（秒）
CACHE_MIDDLEWARE_KEY_PREFIX = ''    # 缓存键前缀

from django.views.decorators.cache import cache_page
from django.urls import path
from . import views

urlpatterns = [
    # 缓存整个站点（通过中间件）
    path('', views.home, name='home'),

    # 缓存特定视图
    path('about/', cache_page(60 * 15)(views.about), name='about'),

    # 或者使用装饰器语法
    path('contact/', views.contact, name='contact'),
]

# 基于类的视图缓存
from django.views.generic import TemplateView
from django.views.decorators.cache import cache_page

urlpatterns += [
    path('faq/', cache_page(60 * 60)(TemplateView.as_view(
        template_name='faq.html'
    )), name='faq'),
]

{% load cache %}

<!-- 基本缓存 -->
{% cache 300 sidebar %}
    <div class="sidebar">
        <h3>热门文章</h3>
        {% for article in popular_articles %}
            <div class="article">
                <h4>{{ article.title }}</h4>
                <p>{{ article.summary }}</p>
            </div>
        {% endfor %}
    </div>
{% endcache %}

<!-- 基于变量的缓存 -->
{% cache 300 article_header article.id %}
    <header class="article-header">
        <h1>{{ article.title }}</h1>
        <div class="meta">
            作者: {{ article.author.username }}
            发布时间: {{ article.publish_date }}
        </div>
    </header>
{% endcache %}

<!-- 使用缓存后端 -->
{% cache 300 footer "special_cache" %}
    <footer>
        <p>© 2023 我的网站. 所有权利保留.</p>
    </footer>
{% endcache %}

{% load cache %}

<!-- 基于多个变量缓存 -->
{% cache 3600 user_profile user.id user.profile_updated %}
    <div class="profile">
        <img src="{{ user.avatar.url }}" alt="{{ user.username }}">
        <h2>{{ user.get_full_name }}</h2>
        <p>{{ user.bio }}</p>

        <div class="stats">
            <span>文章: {{ user.article_count }}</span>
            <span>粉丝: {{ user.follower_count }}</span>
        </div>
    </div>
{% endcache %}

<!-- 条件缓存 -->
{% if not user.is_authenticated %}
    {% cache 600 anonymous_welcome %}
        <div class="welcome-message">
            <h2>欢迎访问我们的网站！</h2>
            <p>请<a href="{% url 'login' %}">登录</a>或<a href="{% url 'register' %}">注册</a>。</p>
        </div>
    {% endcache %}
{% endif %}

<!-- 嵌套缓存 -->
{% cache 1200 page_content %}
    <div class="content">
        {% cache 300 featured_content %}
            <section class="featured">
                <h2>特色内容</h2>
                {% for item in featured_items %}
                    <div class="item">{{ item.title }}</div>
                {% endfor %}
            </section>
        {% endcache %}

        {% cache 600 recent_posts %}
            <section class="recent">
                <h2>最新文章</h2>
                {% for post in recent_posts %}
                    <article>{{ post.title }}</article>
                {% endfor %}
            </section>
        {% endcache %}
    </div>
{% endcache %}

from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from django.core.cache import cache
from .models import Product, Category

# 基于信号自动失效缓存
@receiver([post_save, post_delete], sender=Product)
def invalidate_product_cache(sender, **kwargs):
    """产品数据变更时失效相关缓存"""
    cache_keys = [
        'featured_products',
        'product_list',
        'product_stats',
    ]

    for key in cache_keys:
        cache.delete(key)

    # 失效分类相关的缓存
    if hasattr(kwargs.get('instance'), 'category'):
        category_id = kwargs['instance'].category_id
        cache.delete(f'category_products_{category_id}')

# 基于版本的缓存
def get_product_list(force_refresh=False):
    """带版本控制的缓存"""
    cache_key = 'product_list'
    version_key = 'product_list_version'

    if force_refresh:
        # 强制刷新，增加版本号
        current_version = cache.get(version_key, 0)
        cache.set(version_key, current_version + 1)
        cache.delete(cache_key)

    current_version = cache.get(version_key, 0)
    versioned_key = f"{cache_key}_v{current_version}"

    data = cache.get(versioned_key)
    if data is None:
        data = list(Product.objects.all())
        cache.set(versioned_key, data, 60 * 60)

    return data

# 写时失效模式
class CachedProductService:
    @cached_function(timeout=3600)
    def get_products_by_category(self, category_id):
        return list(Product.objects.filter(category_id=category_id))

    def create_product(self, product_data):
        # 创建产品
        product = Product.objects.create(**product_data)

        # 失效相关缓存
        self._invalidate_category_cache(product.category_id)
        self._invalidate_general_cache()

        return product

    def _invalidate_category_cache(self, category_id):
        cache_key = f"get_products_by_category:({category_id},):@{{}}"
        cache.delete(cache_key)

    def _invalidate_general_cache(self):
        cache.delete('featured_products')
        cache.delete('product_list')

import time
from django.core.cache import cache
from django.core.cache.backends.base import DEFAULT_TIMEOUT

def get_with_penetration_protection(key, func, timeout=DEFAULT_TIMEOUT):
    """
    带缓存穿透保护的获取函数
    """
    # 尝试获取缓存
    value = cache.get(key)
    if value is not None:
        return value

    # 检查是否有其他进程正在计算
    lock_key = f"{key}_lock"
    if cache.add(lock_key, 'locked', 60):  # 获取锁
        try:
            # 重新检查缓存（防止多个请求同时到达）
            value = cache.get(key)
            if value is not None:
                return value

            # 计算值
            value = func()

            # 存储到缓存
            cache.set(key, value, timeout)
            return value
        finally:
            # 释放锁
            cache.delete(lock_key)
    else:
        # 等待其他进程完成
        for i in range(10):  # 最多等待1秒
            time.sleep(0.1)
            value = cache.get(key)
            if value is not None:
                return value

        # 如果等待超时，直接计算（降级）
        return func()

# 空值缓存（防止缓存穿透）
def get_product_details(product_id):
    """获取产品详情，缓存空值防止穿透"""
    cache_key = f"product_details_{product_id}"

    value = cache.get(cache_key)
    if value is not None:
        if value == '__NULL__':  # 空值标记
            return None
        return value

    try:
        product = Product.objects.get(id=product_id)
        cache.set(cache_key, product, 3600)
        return product
    except Product.DoesNotExist:
        # 缓存空值，较短时间
        cache.set(cache_key, '__NULL__', 300)
        return None

# 热点数据预加载
def preload_hot_data():
    """预加载热点数据"""
    hot_products = Product.objects.filter(is_hot=True)[:10]
    cache.set('hot_products', list(hot_products), 3600)

    # 设置下次预加载时间
    cache.set('last_preload_time', time.time(), 3600)

# 定时预加载
def scheduled_preload():
    """定时预加载任务"""
    last_preload = cache.get('last_preload_time', 0)
    if time.time() - last_preload > 1800:  # 30分钟
        preload_hot_data()