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

"""
缓存工作原理：

1. 请求到达时，首先检查缓存中是否存在所需数据
2. 如果存在（缓存命中），直接返回缓存数据
3. 如果不存在（缓存未命中），执行计算/查询操作
4. 将结果存储到缓存中，下次请求可直接使用
5. 缓存数据有过期时间，过期后重新生成

缓存优势：
- 减少数据库负载
- 降低响应时间
- 提高系统吞吐量
- 改善用户体验

缓存挑战：
- 数据一致性问题
- 缓存雪崩、穿透、击穿
- 内存使用管理
- 缓存策略选择
"""

"""
Django缓存层级：

1. 数据库查询缓存
   - QuerySet缓存
   - select_related/prefetch_related优化

2. 模板片段缓存
   - 模板标签缓存
   - 片段缓存

3. 视图级别缓存
   - 视图函数缓存
   - 类视图缓存

4. 页面级别缓存
   - 完整页面缓存
   - 中间件缓存

5. 应用层缓存
   - 自定义缓存逻辑
   - 业务逻辑缓存

6. 代理层缓存
   - Nginx缓存
   - CDN缓存
"""

"""
常见的缓存策略：

1. Cache-Aside Pattern (旁路缓存)
   - 应用负责从数据库加载数据到缓存
   - 缓存未命中时，应用从数据库获取数据并存入缓存

2. Read-Through Pattern (读穿透)
   - 缓存层透明地从数据库加载数据
   - 应用只需与缓存交互

3. Write-Through Pattern (写穿透)
   - 数据写入时同时写入缓存和数据库
   - 保证数据一致性

4. Write-Behind Pattern (写回)
   - 数据先写入缓存，后台异步写入数据库
   - 提高性能，但可能丢失数据
"""

# Django内置缓存后端
from django.core.cache import cache
from django.core.cache.backends.base import BaseCache

"""
Django支持的缓存后端：

1. DummyCache - 空缓存（用于开发环境）
2. LocMemCache - 本地内存缓存
3. FileBasedCache - 文件系统缓存
4. DatabaseCache - 数据库缓存
5. MemcachedCache - Memcached缓存
6. PyLibMCCache - PyLibMC缓存
7. RedisCache - Redis缓存（需要第三方包）

选择原则：
- 开发环境：LocMemCache
- 小型应用：LocMemCache或FileBasedCache
- 生产环境：Redis或Memcached
- 分布式应用：Redis或Memcached
"""

# Django缓存API使用
from django.core.cache import cache
import time

# 基本操作
def cache_operations_demo():
    """缓存操作演示"""
    
    # 设置缓存
    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)
    
    # 获取缓存或设置默认值
    value = cache.get_or_set('key2', lambda: expensive_function(), timeout=60)
    
    # 批量操作
    cache.set_many({'a': 1, 'b': 2, 'c': 3}, timeout=300)
    values = cache.get_many(['a', 'b', 'c'])
    
    # 删除操作
    cache.delete('key')
    cache.delete_many(['a', 'b', 'c'])
    cache.clear()  # 清空所有缓存
    
    return value

def expensive_database_query():
    """模拟昂贵的数据库查询"""
    time.sleep(1)  # 模拟耗时操作
    return "expensive result"

def expensive_function():
    """模拟昂贵的函数调用"""
    time.sleep(0.5)
    return "expensive function result"

# 缓存键生成
def generate_cache_key(*args, **kwargs):
    """生成缓存键"""
    import hashlib
    import json
    
    # 将参数转换为字符串
    key_data = {
        'args': args,
        'kwargs': kwargs
    }
    
    # 生成哈希
    key_str = json.dumps(key_data, sort_keys=True)
    hash_key = hashlib.md5(key_str.encode()).hexdigest()
    
    return f"computed:{hash_key}"

# 带参数的缓存函数
def cached_function_with_params(user_id, category):
    """带参数的缓存函数"""
    cache_key = f"user_profile:{user_id}:{category}"
    result = cache.get(cache_key)
    
    if result is None:
        # 从数据库获取数据
        result = get_user_data(user_id, category)
        cache.set(cache_key, result, timeout=3600)  # 1小时
    
    return result

def get_user_data(user_id, category):
    """获取用户数据"""
    # 模拟数据库查询
    time.sleep(0.1)
    return {"user_id": user_id, "category": category, "data": "user data"}

# 缓存装饰器
from django.core.cache import cache
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
from django.views.generic import ListView
import functools

def cached_function(timeout=300):
    """函数缓存装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 生成缓存键
            cache_key = f"func:{func.__name__}:{hash(str(args) + str(kwargs))}"
            
            # 尝试从缓存获取
            result = cache.get(cache_key)
            if result is None:
                # 执行函数并缓存结果
                result = func(*args, **kwargs)
                cache.set(cache_key, result, timeout=timeout)
            
            return result
        return wrapper
    return decorator

# 使用示例
@cached_function(timeout=600)
def calculate_expensive_operation(x, y):
    """昂贵的计算操作"""
    time.sleep(2)  # 模拟耗时计算
    return x * y + x ** 2 + y ** 2

# 类方法缓存装饰器
def cached_method(timeout=300):
    """方法缓存装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(self, *args, **kwargs):
            # 包含实例信息的缓存键
            cache_key = f"method:{self.__class__.__name__}:{func.__name__}:{id(self)}:{hash(str(args) + str(kwargs))}"
            
            result = cache.get(cache_key)
            if result is None:
                result = func(self, *args, **kwargs)
                cache.set(cache_key, result, timeout=timeout)
            
            return result
        return wrapper
    return decorator

class DataProcessor:
    """数据处理器"""
    
    def __init__(self, processor_id):
        self.processor_id = processor_id
    
    @cached_method(timeout=1800)
    def process_data(self, data):
        """处理数据"""
        time.sleep(1)  # 模拟处理时间
        return f"Processed {len(data)} items for processor {self.processor_id}"

# 高级缓存装饰器
def smart_cache(timeout=300, key_prefix='', version=1):
    """智能缓存装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 生成更智能的缓存键
            key_parts = [key_prefix, func.__module__, func.__name__]
            
            # 添加参数到键中
            if args:
                key_parts.extend([str(arg) for arg in args])
            if kwargs:
                # 按键排序确保一致性
                sorted_kwargs = sorted(kwargs.items())
                key_parts.append(str(sorted_kwargs))
            
            cache_key = ":".join(key_parts)
            cache_key = f"{cache_key}:v{version}"
            
            # 尝试获取缓存
            result = cache.get(cache_key)
            if result is None:
                result = func(*args, **kwargs)
                cache.set(cache_key, result, timeout=timeout)
            
            return result
        return wrapper
    return decorator

# 使用示例
@smart_cache(timeout=3600, key_prefix='stats', version=2)
def get_user_statistics(user_id, period='daily'):
    """获取用户统计数据"""
    # 模拟复杂的数据聚合
    time.sleep(1)
    return {
        'user_id': user_id,
        'period': period,
        'views': 100,
        'actions': 50
    }

# settings.py - 缓存配置
"""
缓存配置示例
"""
import os

# 基础缓存配置
CACHES = {
    # 默认缓存
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': [
            'redis://127.0.0.1:6379/1',
            'redis://127.0.0.1:6380/1',  # 支持多个Redis实例
        ],
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
            'CONNECTION_POOL_KWARGS': {
                'max_connections': 20,
                'retry_on_timeout': True,
            },
            'COMPRESSOR': 'django_redis.compressors.zlib.ZlibCompressor',
            'SERIALIZER': 'django_redis.serializers.json.JSONSerializer',
        },
        'KEY_PREFIX': 'myapp',
        'TIMEOUT': 300,  # 5分钟默认超时
        'VERSION': 1,
    },
    
    # 会话缓存
    'sessions': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/2',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        },
        'KEY_PREFIX': 'session',
        'TIMEOUT': 1209600,  # 2周
    },
    
    # 临时缓存
    'temporary': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'temp-cache',
        'OPTIONS': {
            'MAX_ENTRIES': 1000,
        },
        'TIMEOUT': 60,  # 1分钟
    },
}

# 开发环境配置
if os.environ.get('DJANGO_ENV') == 'development':
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
            'LOCATION': 'unique-snowflake',
            'OPTIONS': {
                'MAX_ENTRIES': 1000,
            }
        }
    }

# 生产环境配置
if os.environ.get('DJANGO_ENV') == 'production':
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.redis.RedisCache',
            'LOCATION': os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379/1'),
            'OPTIONS': {
                'CLIENT_CLASS': 'django_redis.client.DefaultClient',
                'CONNECTION_POOL_KWARGS': {
                    'max_connections': 50,
                    'retry_on_timeout': True,
                    'socket_keepalive': True,
                    'socket_keepalive_options': {True},
                },
            },
            'KEY_PREFIX': os.environ.get('CACHE_KEY_PREFIX', 'prod'),
            'TIMEOUT': 300,
        }
    }

# 缓存相关设置
CACHE_MIDDLEWARE_ALIAS = 'default'  # 中间件使用的缓存别名
CACHE_MIDDLEWARE_SECONDS = 600     # 页面缓存时间
CACHE_MIDDLEWARE_KEY_PREFIX = ''   # 页面缓存键前缀

# 会话使用缓存
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'sessions'

# Redis缓存高级配置
"""
pip install django-redis redis hiredis
"""
import redis
from django.conf import settings

class RedisCacheManager:
    """Redis缓存管理器"""
    
    def __init__(self):
        self.redis_client = redis.Redis(
            host=getattr(settings, 'REDIS_HOST', 'localhost'),
            port=getattr(settings, 'REDIS_PORT', 6379),
            db=getattr(settings, 'REDIS_DB', 0),
            password=getattr(settings, 'REDIS_PASSWORD', None),
            decode_responses=False,  # 保持字节模式
            socket_connect_timeout=5,
            socket_timeout=5,
            retry_on_timeout=True,
        )
    
    def get_connection_pool(self):
        """获取连接池"""
        pool = redis.ConnectionPool(
            host=getattr(settings, 'REDIS_HOST', 'localhost'),
            port=getattr(settings, 'REDIS_PORT', 6379),
            db=getattr(settings, 'REDIS_DB', 0),
            password=getattr(settings, 'REDIS_PASSWORD', None),
            max_connections=getattr(settings, 'REDIS_MAX_CONNECTIONS', 20),
            retry_on_timeout=True,
        )
        return redis.Redis(connection_pool=pool)
    
    def get_pipeline(self):
        """获取管道操作"""
        return self.redis_client.pipeline()
    
    def batch_set(self, data_dict, expire_time=300):
        """批量设置"""
        pipe = self.get_pipeline()
        for key, value in data_dict.items():
            pipe.setex(key, expire_time, value)
        pipe.execute()
    
    def batch_get(self, keys):
        """批量获取"""
        return self.redis_client.mget(keys)
    
    def atomic_increment(self, key, amount=1, expire_time=300):
        """原子递增操作"""
        value = self.redis_client.incrby(key, amount)
        # 设置过期时间
        self.redis_client.expire(key, expire_time)
        return value
    
    def get_with_lock(self, key, compute_func, lock_timeout=10, cache_timeout=300):
        """带锁的缓存获取"""
        lock_key = f"lock:{key}"
        
        # 尝试获取锁
        if self.redis_client.set(lock_key, "1", nx=True, ex=lock_timeout):
            try:
                # 计算并设置缓存
                result = compute_func()
                self.redis_client.setex(key, cache_timeout, result)
                return result
            finally:
                # 释放锁
                self.redis_client.delete(lock_key)
        else:
            # 等待锁释放后返回缓存值
            import time
            start_time = time.time()
            while time.time() - start_time < lock_timeout:
                result = self.redis_client.get(key)
                if result is not None:
                    return result
                time.sleep(0.1)
            # 超时后执行计算
            result = compute_func()
            self.redis_client.setex(key, cache_timeout, result)
            return result

# Redis缓存配置类
class RedisCacheConfig:
    """Redis缓存配置类"""
    
    @staticmethod
    def get_production_config():
        """生产环境Redis配置"""
        return {
            'BACKEND': 'django.core.cache.backends.redis.RedisCache',
            'LOCATION': [
                'redis://master.redis.example.com:6379/1',
                'redis://slave.redis.example.com:6379/1',
            ],
            'OPTIONS': {
                'CLIENT_CLASS': 'django_redis.client.ShardClient',
                'CONNECTION_POOL_KWARGS': {
                    'max_connections': 100,
                    'retry_on_timeout': True,
                    'health_check_interval': 30,
                    'socket_keepalive': True,
                },
                'COMPRESSOR': 'django_redis.compressors.zlib.ZlibCompressor',
                'SERIALIZER': 'django_redis.serializers.pickle.PickleSerializer',
            },
            'KEY_PREFIX': 'prod_app',
            'TIMEOUT': 900,  # 15分钟
            'VERSION': 1,
        }
    
    @staticmethod
    def get_session_config():
        """会话Redis配置"""
        return {
            'BACKEND': 'django.core.cache.backends.redis.RedisCache',
            'LOCATION': 'redis://session.redis.example.com:6379/2',
            'OPTIONS': {
                'CLIENT_CLASS': 'django_redis.client.DefaultClient',
                'CONNECTION_POOL_KWARGS': {
                    'max_connections': 50,
                },
            },
            'KEY_PREFIX': 'session',
            'TIMEOUT': 1209600,  # 2周
            'VERSION': 1,
        }

# 缓存健康检查
class CacheHealthChecker:
    """缓存健康检查器"""
    
    def __init__(self):
        from django.core.cache import caches
        self.cache = caches['default']
    
    def check_health(self):
        """检查缓存健康状态"""
        try:
            # 测试缓存连接
            test_key = 'health_check:test'
            test_value = 'healthy'
            
            # 设置和获取测试值
            self.cache.set(test_key, test_value, timeout=10)
            retrieved_value = self.cache.get(test_key)
            
            # 验证结果
            if retrieved_value == test_value:
                return {
                    'status': 'healthy',
                    'message': 'Cache is accessible and responsive',
                    'response_time': self._measure_response_time()
                }
            else:
                return {
                    'status': 'unhealthy',
                    'message': 'Cache returned unexpected value',
                    'expected': test_value,
                    'received': retrieved_value
                }
        except Exception as e:
            return {
                'status': 'unhealthy',
                'message': f'Cache error: {str(e)}',
                'error_type': type(e).__name__
            }
    
    def _measure_response_time(self):
        """测量响应时间"""
        import time
        start_time = time.time()
        self.cache.get('health_check:test')
        return time.time() - start_time

# Memcached配置
"""
pip install python-memcached
或
pip install pylibmc
"""

# Memcached缓存配置
MEMCACHED_CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': [
            '127.0.0.1:11211',
            '127.0.0.1:11212',
        ],
        'OPTIONS': {
            'binary': True,
            'behaviors': {
                'tcp_nodelay': True,
                'ketama': True,
                'remove_failed': 4,
                'retry_timeout': 2,
                'dead_timeout': 10,
            }
        },
        'KEY_PREFIX': 'myapp',
        'TIMEOUT': 300,
    }
}

# Memcached管理类
class MemcachedManager:
    """Memcached管理器"""
    
    def __init__(self):
        import memcache
        self.mc = memcache.Client(
            ['127.0.0.1:11211', '127.0.0.1:11212'],
            debug=0
        )
    
    def get_multi(self, keys):
        """批量获取"""
        return self.mc.get_multi(keys)
    
    def set_multi(self, mapping, time=2592000):  # 30天
        """批量设置"""
        return self.mc.set_multi(mapping, time=time)
    
    def add(self, key, val, time=2592000):
        """仅在键不存在时设置"""
        return self.mc.add(key, val, time=time)
    
    def incr(self, key, delta=1):
        """递增操作"""
        return self.mc.incr(key, delta)
    
    def decr(self, key, delta=1):
        """递减操作"""
        return self.mc.decr(key, delta)

# Memcached缓存装饰器
def memcached_cached(timeout=300, key_prefix=''):
    """Memcached缓存装饰器"""
    def decorator(func):
        import hashlib
        import pickle
        
        def wrapper(*args, **kwargs):
            # 生成缓存键
            key_data = f"{key_prefix}:{func.__name__}:{args}:{sorted(kwargs.items())}"
            cache_key = hashlib.md5(key_data.encode()).hexdigest()
            
            # 尝试从Memcached获取
            cached_result = cache.get(cache_key)
            if cached_result is None:
                # 执行函数
                result = func(*args, **kwargs)
                # 存储到缓存
                cache.set(cache_key, result, timeout=timeout)
                return result
            return cached_result
        return wrapper
    return decorator

# 低层级缓存 - 缓存单个值
from django.core.cache import cache

def low_level_cache_example():
    """低层级缓存示例"""
    
    # 基本缓存操作
    cache.set('simple_key', 'simple_value', 300)  # 5分钟过期
    value = cache.get('simple_key')
    
    # 带默认值的获取
    value = cache.get('nonexistent_key', 'default_value')
    
    # 仅当键不存在时设置
    cache.add('new_key', 'new_value', 600)  # 10分钟
    
    # 获取或计算
    expensive_result = cache.get_or_set(
        'expensive_calculation',
        lambda: perform_expensive_calculation(),
        1800  # 30分钟
    )
    
    # 批量操作
    cache.set_many({
        'key1': 'value1',
        'key2': 'value2',
        'key3': 'value3'
    }, 600)
    
    values = cache.get_many(['key1', 'key2', 'key3'])
    
    return values

def perform_expensive_calculation():
    """执行昂贵的计算"""
    import time
    time.sleep(2)  # 模拟耗时操作
    return sum(range(1000000))

# 缓存键命名规范
class CacheKeyGenerator:
    """缓存键生成器"""
    
    @staticmethod
    def generate_user_key(user_id, suffix=''):
        """生成用户相关缓存键"""
        prefix = 'user'
        return f"{prefix}:{user_id}:{suffix}" if suffix else f"{prefix}:{user_id}"
    
    @staticmethod
    def generate_model_key(model_name, obj_id, field=''):
        """生成模型对象缓存键"""
        prefix = 'model'
        if field:
            return f"{prefix}:{model_name}:{obj_id}:{field}"
        return f"{prefix}:{model_name}:{obj_id}"
    
    @staticmethod
    def generate_query_key(query_params, model_name):
        """生成查询缓存键"""
        import hashlib
        query_str = str(sorted(query_params.items())) if query_params else ''
        hash_suffix = hashlib.md5(f"{model_name}:{query_str}".encode()).hexdigest()[:8]
        return f"query:{model_name}:{hash_suffix}"
    
    @staticmethod
    def generate_fragment_key(template_name, fragment_name, context_hash=''):
        """生成模板片段缓存键"""
        if context_hash:
            return f"fragment:{template_name}:{fragment_name}:{context_hash}"
        return f"fragment:{template_name}:{fragment_name}"

# 使用示例
def user_profile_cache_example(user_id):
    """用户资料缓存示例"""
    from django.contrib.auth.models import User
    
    # 生成缓存键
    profile_key = CacheKeyGenerator.generate_user_key(user_id, 'profile')
    permissions_key = CacheKeyGenerator.generate_user_key(user_id, 'permissions')
    
    # 获取缓存的用户资料
    profile_data = cache.get(profile_key)
    if profile_data is None:
        user = User.objects.get(id=user_id)
        profile_data = {
            'username': user.username,
            'email': user.email,
            'first_name': user.first_name,
            'last_name': user.last_name,
        }
        cache.set(profile_key, profile_data, 3600)  # 1小时
    
    # 获取缓存的权限信息
    permissions = cache.get(permissions_key)
    if permissions is None:
        user = User.objects.get(id=user_id)
        permissions = list(user.user_permissions.values_list('codename', flat=True))
        cache.set(permissions_key, permissions, 1800)  # 30分钟
    
    return {
        'profile': profile_data,
        'permissions': permissions
    }

# 模板片段缓存
from django.core.cache import cache
from django.template import Library
from django.utils.cache import patch_cache_control
from django.views.decorators.cache import cache_page

register = Library()

@register.simple_tag(takes_context=True)
def cached_partial(context, template_name, timeout=300, **kwargs):
    """缓存的模板片段标签"""
    from django.template.loader import render_to_string
    import hashlib
    
    # 生成缓存键
    cache_key = f"partial:{template_name}:{hash(str(kwargs))}"
    
    # 尝试从缓存获取
    rendered = cache.get(cache_key)
    if rendered is None:
        # 渲染模板
        rendered = render_to_string(template_name, {**context.flatten(), **kwargs})
        # 存储到缓存
        cache.set(cache_key, rendered, timeout)
    
    return rendered

# 自定义缓存模板标签
from django import template
from django.template.base import Node, Variable, TemplateSyntaxError
import re

register = template.Library()

class CacheNode(Node):
    """缓存节点"""
    
    def __init__(self, nodelist, expire_time_var, fragment_name, vary_on):
        self.nodelist = nodelist
        self.expire_time_var = Variable(expire_time_var)
        self.fragment_name = fragment_name
        self.vary_on = vary_on

    def render(self, context):
        """渲染缓存节点"""
        try:
            expire_time = self.expire_time_var.resolve(context)
        except template.VariableDoesNotExist:
            expire_time = 0
        
        # 生成缓存键
        vary_values = [Variable(var).resolve(context) for var in self.vary_on]
        cache_key = f"template.cache.{self.fragment_name}." + ".".join(str(v) for v in vary_values)
        
        value = cache.get(cache_key)
        if value is None:
            value = self.nodelist.render(context)
            cache.set(cache_key, value, expire_time)
        
        return value

@register.tag('cache')
def do_cache(parser, token):
    """缓存模板标签"""
    nodelist = parser.parse(('endcache',))
    parser.delete_first_token()
    
    tokens = token.contents.split()
    if len(tokens) < 3:
        raise TemplateSyntaxError("'%s' tag requires at least 2 arguments" % tokens[0])
    
    return CacheNode(nodelist, tokens[1], tokens[2], tokens[3:])

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

{% cache 600 navigation request.user.is_staff %}
    <!-- 导航菜单，根据用户角色变化 -->
    <nav>
        {% if request.user.is_staff %}
            <a href="/admin/">管理面板</a>
        {% endif %}
        <a href="/dashboard/">仪表板</a>
    </nav>
{% endcache %}
"""

# 视图级别缓存
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
from django.views.generic import ListView, DetailView
from django.views import View
from django.http import JsonResponse
from django.core.cache import cache
import json

# 函数视图缓存
@cache_page(60 * 15)  # 缓存15分钟
def product_list_view(request):
    """商品列表视图（带缓存）"""
    from .models import Product
    
    products = Product.objects.filter(is_active=True).select_related('category')
    
    return JsonResponse({
        'products': [
            {
                'id': p.id,
                'name': p.name,
                'price': float(p.price),
                'category': p.category.name if p.category else None
            }
            for p in products
        ]
    })

@cache_page(60 * 30, cache='temporary')  # 使用临时缓存后端
def dashboard_stats_view(request):
    """仪表板统计视图"""
    from .models import Order, User
    
    stats = {
        'total_users': User.objects.count(),
        'total_orders': Order.objects.count(),
        'monthly_revenue': get_monthly_revenue(),
        'active_sessions': get_active_sessions_count()
    }
    
    return JsonResponse(stats)

def get_monthly_revenue():
    """获取月收入"""
    # 模拟计算
    import random
    return random.randint(10000, 50000)

def get_active_sessions_count():
    """获取活跃会话数"""
    # 模拟获取
    import random
    return random.randint(50, 200)

# 类视图缓存
@method_decorator(cache_page(60 * 10), name='dispatch')
class ProductListView(ListView):
    """商品列表类视图"""
    model = Product
    template_name = 'products/list.html'
    context_object_name = 'products'
    
    def get_queryset(self):
        return Product.objects.filter(is_active=True).select_related('category')

@method_decorator(cache_page(60 * 60), name='get')  # 1小时缓存
class ProductDetailView(DetailView):
    """商品详情类视图"""
    model = Product
    template_name = 'products/detail.html'
    context_object_name = 'product'

# 自定义缓存视图
class CachedAPIView(View):
    """带缓存的API视图"""
    
    def get_cache_key(self, request):
        """生成缓存键"""
        return f"api:{request.path}:{hash(request.GET.urlencode())}"
    
    def get_cache_timeout(self):
        """获取缓存超时时间"""
        return 300  # 5分钟
    
    def get(self, request):
        """GET请求处理"""
        cache_key = self.get_cache_key(request)
        
        # 尝试从缓存获取
        cached_response = cache.get(cache_key)
        if cached_response:
            return JsonResponse(cached_response)
        
        # 生成响应
        response_data = self.generate_response_data(request)
        
        # 缓存响应
        cache.set(cache_key, response_data, self.get_cache_timeout())
        
        return JsonResponse(response_data)
    
    def generate_response_data(self, request):
        """生成响应数据"""
        # 子类需要实现此方法
        raise NotImplementedError

# 特定条件缓存
def conditional_cache_page(timeout):
    """条件缓存装饰器"""
    def decorator(view_func):
        def wrapper(request, *args, **kwargs):
            # 检查是否应该缓存
            if should_cache_request(request):
                # 使用标准缓存
                from django.views.decorators.cache import cache_page
                cached_view = cache_page(timeout)(view_func)
                return cached_view(request, *args, **kwargs)
            else:
                # 不缓存，直接调用原函数
                return view_func(request, *args, **kwargs)
        return wrapper
    return decorator

def should_cache_request(request):
    """判断是否应该缓存请求"""
    # 不缓存POST请求
    if request.method != 'GET':
        return False
    
    # 不缓存带认证信息的请求
    if request.user.is_authenticated:
        return False
    
    # 不缓存带特定参数的请求
    if 'nocache' in request.GET:
        return False
    
    # 不缓存管理员页面
    if request.path.startswith('/admin/'):
        return False
    
    return True

# 使用条件缓存
@conditional_cache_page(60 * 15)
def conditional_cached_view(request):
    """条件缓存视图"""
    return JsonResponse({'message': 'This might be cached'})

# 模型层面缓存
from django.db import models
from django.core.cache import cache
from django.conf import settings
import hashlib
from typing import Optional, List, Dict, Any

class CacheMixin:
    """缓存混入类"""
    
    def get_cache_key(self, field: str = '', suffix: str = '') -> str:
        """生成模型实例缓存键"""
        base_key = f"{self._meta.label}:{self.pk}"
        if field:
            base_key = f"{base_key}:{field}"
        if suffix:
            base_key = f"{base_key}:{suffix}"
        return base_key
    
    def get_cache_timeout(self) -> int:
        """获取缓存超时时间"""
        return getattr(settings, 'MODEL_CACHE_TIMEOUT', 300)
    
    def cache_get(self, field: str, default=None):
        """从缓存获取字段值"""
        cache_key = self.get_cache_key(field)
        return cache.get(cache_key, default)
    
    def cache_set(self, field: str, value, timeout: Optional[int] = None):
        """设置字段缓存"""
        cache_key = self.get_cache_key(field)
        cache.set(cache_key, value, timeout or self.get_cache_timeout())
    
    def cache_delete(self, field: str = ''):
        """删除字段缓存"""
        if field:
            cache_key = self.get_cache_key(field)
            cache.delete(cache_key)
        else:
            # 删除所有相关缓存
            base_pattern = self.get_cache_key('')
            # 这里需要根据具体缓存后端实现模式匹配删除
            # 对于Redis，可以使用KEYS命令（生产环境需谨慎使用）
    
    def cache_property(self, func):
        """缓存属性装饰器"""
        @property
        def cached_prop(self):
            cache_key = self.get_cache_key(func.__name__)
            value = cache.get(cache_key)
            if value is None:
                value = func(self)
                cache.set(cache_key, value, self.get_cache_timeout())
            return value
        return cached_prop

# 带缓存的用户模型
class CachedUser(models.Model, CacheMixin):
    """带缓存的用户模型"""
    username = models.CharField(max_length=150, unique=True)
    email = models.EmailField()
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=150)
    is_active = models.BooleanField(default=True)
    date_joined = models.DateTimeField(auto_now_add=True)
    
    def get_full_name(self):
        """获取全名"""
        return f"{self.first_name} {self.last_name}".strip()
    
    @CacheMixin.cache_property
    def profile_summary(self):
        """缓存的个人资料摘要"""
        # 模拟复杂计算
        import time
        time.sleep(0.1)  # 模拟耗时操作
        return {
            'username': self.username,
            'full_name': self.get_full_name(),
            'email': self.email,
            'account_age_days': (self.date_joined.now() - self.date_joined).days
        }
    
    def get_permissions(self):
        """获取用户权限（带缓存）"""
        cache_key = self.get_cache_key('permissions')
        permissions = cache.get(cache_key)
        
        if permissions is None:
            # 从数据库获取权限
            permissions = list(self.user_permissions.values_list('codename', flat=True))
            cache.set(cache_key, permissions, 300)  # 5分钟
        
        return permissions
    
    def save(self, *args, **kwargs):
        """保存时清除相关缓存"""
        # 保存前清除缓存
        self.cache_delete('profile_summary')
        self.cache_delete('permissions')
        
        super().save(*args, **kwargs)
    
    def delete(self, *args, **kwargs):
        """删除时清除所有缓存"""
        # 清除所有相关缓存
        self.cache_delete()
        super().delete(*args, **kwargs)

# 查询集缓存
class CachedQuerySet(models.QuerySet):
    """带缓存的查询集"""
    
    def cache_results(self, timeout=300, key_prefix='query'):
        """缓存查询结果"""
        import hashlib
        
        # 生成查询的哈希值作为缓存键
        query_hash = hashlib.md5(str(self.query).encode()).hexdigest()
        cache_key = f"{key_prefix}:{query_hash}"
        
        results = cache.get(cache_key)
        if results is None:
            results = list(self)
            cache.set(cache_key, results, timeout)
        
        return results
    
    def cache_count(self, timeout=300):
        """缓存计数结果"""
        import hashlib
        
        query_hash = hashlib.md5(str(self.query).encode()).hexdigest()
        cache_key = f"count:{query_hash}"
        
        count = cache.get(cache_key)
        if count is None:
            count = self.count()
            cache.set(cache_key, count, timeout)
        
        return count

class CachedManager(models.Manager):
    """带缓存的管理器"""
    
    def get_queryset(self):
        return CachedQuerySet(self.model, using=self._db)
    
    def cached_filter(self, *args, **kwargs):
        """缓存过滤结果"""
        import hashlib
        
        # 生成缓存键
        filter_str = str(sorted((args, tuple(sorted(kwargs.items())))))
        cache_key = f"filter:{self.model._meta.label}:{hashlib.md5(filter_str.encode()).hexdigest()[:8]}"
        
        results = cache.get(cache_key)
        if results is None:
            results = list(self.filter(*args, **kwargs))
            cache.set(cache_key, results, 300)  # 5分钟
        
        return results

# 使用示例模型
class Product(models.Model):
    """商品模型"""
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    category = models.ForeignKey('Category', on_delete=models.CASCADE)
    description = models.TextField()
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    objects = CachedManager()
    
    @CacheMixin.cache_property
    def related_products(self):
        """相关商品"""
        return list(Product.objects.filter(
            category=self.category,
            is_active=True
        ).exclude(id=self.id)[:10])
    
    def get_price_with_tax(self):
        """含税价格（带缓存）"""
        cache_key = self.get_cache_key('price_with_tax')
        price_with_tax = cache.get(cache_key)
        
        if price_with_tax is None:
            tax_rate = 0.1  # 10%税率
            price_with_tax = float(self.price) * (1 + tax_rate)
            cache.set(cache_key, price_with_tax, 3600)  # 1小时
        
        return price_with_tax

class Category(models.Model):
    """分类模型"""
    name = models.CharField(max_length=100)
    slug = models.SlugField(unique=True)
    
    objects = CachedManager()
    
    @CacheMixin.cache_property
    def active_products_count(self):
        """活跃商品数量"""
        return self.product_set.filter(is_active=True).count()

# 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)  # 缓存1分钟
            return None
    
    @staticmethod
    def update_data_with_cache(model_class, pk, **updates):
        """使用Cache-Aside模式更新数据"""
        cache_key = f"model:{model_class._meta.label}:{pk}"
        
        # 1. 更新数据库
        updated_count = model_class.objects.filter(pk=pk).update(**updates)
        
        # 2. 删除缓存（让下次查询重新加载）
        cache.delete(cache_key)
        
        return updated_count
    
    @staticmethod
    def delete_data_with_cache(model_class, pk):
        """使用Cache-Aside模式删除数据"""
        cache_key = f"model:{model_class._meta.label}:{pk}"
        
        # 1. 删除数据库记录
        deleted_count = model_class.objects.filter(pk=pk).delete()[0]
        
        # 2. 删除缓存
        cache.delete(cache_key)
        
        return deleted_count

# 使用示例
def user_operations_with_cache(user_id):
    """使用Cache-Aside模式的用户操作"""
    
    # 获取用户
    user = CacheAsidePattern.get_data_with_cache(
        'auth.User', user_id, timeout=1800  # 30分钟
    )
    
    if user:
        # 更新用户
        CacheAsidePattern.update_data_with_cache(
            'auth.User', user_id, last_login=timezone.now()
        )
    
    return user

# 高级Cache-Aside实现
class AdvancedCacheAside:
    """高级Cache-Aside实现"""
    
    def __init__(self, cache_backend='default', default_timeout=300):
        from django.core.cache import caches
        self.cache = caches[cache_backend]
        self.default_timeout = default_timeout
    
    def get_or_fetch(self, cache_key: str, fetch_func, timeout: int = None, 
                     cache_empty: bool = True):
        """获取或获取并缓存"""
        # 从缓存获取
        result = self.cache.get(cache_key)
        
        if result is not None:
            if result == "__empty__":
                return None if cache_empty else result
            return result
        
        # 执行获取函数
        result = fetch_func()
        
        # 缓存结果
        if result is None and not cache_empty:
            # 不缓存空值
            pass
        else:
            cache_value = result if result is not None else "__empty__"
            self.cache.set(
                cache_key, 
                cache_value, 
                timeout or self.default_timeout
            )
        
        return result
    
    def invalidate_pattern(self, pattern: str):
        """根据模式删除缓存（需要Redis支持）"""
        try:
            import redis
            # 获取Redis客户端
            r = redis.Redis(host='localhost', port=6379, db=0)
            keys = r.keys(pattern)
            if keys:
                r.delete(*keys)
        except ImportError:
            # 如果没有Redis，记录警告
            import logging
            logger = logging.getLogger(__name__)
            logger.warning(f"Cannot invalidate cache pattern {pattern}, Redis not available")

# 使用示例
def advanced_cache_usage():
    """高级缓存使用示例"""
    cache_handler = AdvancedCacheAside(default_timeout=600)
    
    def fetch_expensive_data():
        """获取昂贵数据的函数"""
        import time
        time.sleep(1)  # 模拟耗时操作
        return {"data": "expensive result", "timestamp": time.time()}
    
    # 使用高级缓存
    result = cache_handler.get_or_fetch(
        "expensive_calculation:v1",
        fetch_expensive_data,
        timeout=900  # 15分钟
    )
    
    return result

# Read-Through模式实现
from django.core.cache import cache
from django.db import models

class ReadThroughCache:
    """Read-Through缓存实现"""
    
    def __init__(self, model_class, cache_timeout=300):
        self.model_class = model_class
        self.cache_timeout = cache_timeout
        self.cache_prefix = f"read_through:{model_class._meta.label}"
    
    def get(self, key):
        """获取数据，自动从底层加载"""
        cache_key = f"{self.cache_prefix}:{key}"
        
        # 尝试从缓存获取
        result = cache.get(cache_key)
        if result is None:
            # 缓存未命中，从数据库加载
            result = self._load_from_db(key)
            if result is not None:
                # 存入缓存
                cache.set(cache_key, result, self.cache_timeout)
        
        return result
    
    def _load_from_db(self, key):
        """从数据库加载数据"""
        try:
            # 假设key是主键
            return self.model_class.objects.get(pk=key)
        except self.model_class.DoesNotExist:
            return None
    
    def get_many(self, keys):
        """批量获取"""
        cache_keys = [f"{self.cache_prefix}:{key}" for key in keys]
        
        # 批量从缓存获取
        cached_results = cache.get_many(cache_keys)
        
        # 找出未命中的键
        missing_keys = []
        for i, key in enumerate(keys):
            cache_key = cache_keys[i]
            if cache_key not in cached_results:
                missing_keys.append(key)
        
        # 从数据库加载未命中的数据
        if missing_keys:
            db_results = self._load_many_from_db(missing_keys)
            
            # 存入缓存
            cache_to_set = {}
            for key, value in zip(missing_keys, db_results):
                cache_key = f"{self.cache_prefix}:{key}"
                cache_to_set[cache_key] = value
            
            if cache_to_set:
                cache.set_many(cache_to_set, self.cache_timeout)
            
            # 合并结果
            cached_results.update({
                f"{self.cache_prefix}:{key}": value 
                for key, value in zip(missing_keys, db_results)
            })
        
        # 返回按原始顺序排列的结果
        results = []
        for key in keys:
            cache_key = f"{self.cache_prefix}:{key}"
            results.append(cached_results.get(cache_key))
        
        return results
    
    def _load_many_from_db(self, keys):
        """批量从数据库加载"""
        return list(self.model_class.objects.filter(pk__in=keys))

# 使用示例
def read_through_usage():
    """Read-Through使用示例"""
    from django.contrib.auth.models import User
    
    user_cache = ReadThroughCache(User, cache_timeout=1800)  # 30分钟
    
    # 单个获取
    user = user_cache.get(1)
    
    # 批量获取
    users = user_cache.get_many([1, 2, 3, 4, 5])
    
    return users

# 带验证的Read-Through
class ValidatedReadThroughCache(ReadThroughCache):
    """带验证的Read-Through缓存"""
    
    def __init__(self, model_class, cache_timeout=300, validator=None):
        super().__init__(model_class, cache_timeout)
        self.validator = validator or self._default_validator
    
    def _default_validator(self, obj):
        """默认验证器"""
        return obj is not None and hasattr(obj, 'pk')
    
    def get(self, key):
        """获取数据并验证"""
        result = super().get(key)
        
        if not self.validator(result):
            # 验证失败，删除缓存并重新加载
            cache_key = f"{self.cache_prefix}:{key}"
            cache.delete(cache_key)
            result = self._load_from_db(key)
            
            if self.validator(result):
                cache.set(cache_key, result, self.cache_timeout)
        
        return result

# 使用示例
def validated_read_through_usage():
    """带验证的Read-Through使用示例"""
    from django.contrib.auth.models import User
    
    def user_validator(user):
        """用户验证器"""
        return user is not None and user.is_active
    
    user_cache = ValidatedReadThroughCache(
        User, 
        cache_timeout=900,  # 15分钟
        validator=user_validator
    )
    
    user = user_cache.get(1)
    return user

# Write-Through模式实现
class WriteThroughCache:
    """Write-Through缓存实现"""
    
    def __init__(self, model_class, cache_timeout=300):
        self.model_class = model_class
        self.cache_timeout = cache_timeout
        self.cache_prefix = f"write_through:{model_class._meta.label}"
    
    def create(self, **data):
        """创建并写入缓存"""
        # 1. 创建数据库记录
        instance = self.model_class.objects.create(**data)
        
        # 2. 同时写入缓存
        cache_key = f"{self.cache_prefix}:{instance.pk}"
        cache.set(cache_key, instance, self.cache_timeout)
        
        return instance
    
    def update(self, key, **data):
        """更新并同步缓存"""
        # 1. 更新数据库
        updated_count = self.model_class.objects.filter(pk=key).update(**data)
        
        if updated_count > 0:
            # 2. 同步更新缓存
            cache_key = f"{self.cache_prefix}:{key}"
            
            # 从数据库获取最新数据并更新缓存
            try:
                updated_instance = self.model_class.objects.get(pk=key)
                cache.set(cache_key, updated_instance, self.cache_timeout)
            except self.model_class.DoesNotExist:
                # 如果数据库中不存在，删除缓存
                cache.delete(cache_key)
        
        return updated_count
    
    def bulk_update(self, updates_list):
        """批量更新"""
        updated_count = 0
        cache_updates = {}
        
        for update_data in updates_list:
            pk = update_data.pop('pk')
            count = self.model_class.objects.filter(pk=pk).update(**update_data)
            updated_count += count
            
            if count > 0:
                # 准备缓存更新
                try:
                    updated_instance = self.model_class.objects.get(pk=pk)
                    cache_key = f"{self.cache_prefix}:{pk}"
                    cache_updates[cache_key] = updated_instance
                except self.model_class.DoesNotExist:
                    cache.delete(f"{self.cache_prefix}:{pk}")
        
        # 批量更新缓存
        if cache_updates:
            cache.set_many(cache_updates, self.cache_timeout)
        
        return updated_count
    
    def delete(self, key):
        """删除并同步缓存"""
        # 1. 删除数据库记录
        deleted_count = self.model_class.objects.filter(pk=key).delete()[0]
        
        # 2. 同步删除缓存
        if deleted_count > 0:
            cache_key = f"{self.cache_prefix}:{key}"
            cache.delete(cache_key)
        
        return deleted_count
    
    def get(self, key):
        """获取（只读操作）"""
        cache_key = f"{self.cache_prefix}:{key}"
        result = cache.get(cache_key)
        
        if result is None:
            try:
                result = self.model_class.objects.get(pk=key)
                cache.set(cache_key, result, self.cache_timeout)
            except self.model_class.DoesNotExist:
                result = None
        
        return result

# 使用示例
def write_through_usage():
    """Write-Through使用示例"""
    from django.contrib.auth.models import User
    
    user_cache = WriteThroughCache(User, cache_timeout=1800)
    
    # 创建用户
    user = user_cache.create(
        username='newuser',
        email='newuser@example.com',
        first_name='New',
        last_name='User'
    )
    
    # 更新用户
    user_cache.update(user.pk, last_name='Updated')
    
    # 获取用户
    retrieved_user = user_cache.get(user.pk)
    
    return retrieved_user

# 事务安全的Write-Through
from django.db import transaction

class TransactionSafeWriteThroughCache(WriteThroughCache):
    """事务安全的Write-Through缓存"""
    
    def update(self, key, **data):
        """事务安全的更新"""
        with transaction.atomic():
            # 1. 更新数据库
            updated_count = self.model_class.objects.filter(pk=key).update(**data)
            
            if updated_count > 0:
                # 2. 同步更新缓存
                try:
                    updated_instance = self.model_class.objects.select_for_update().get(pk=key)
                    cache_key = f"{self.cache_prefix}:{key}"
                    cache.set(cache_key, updated_instance, self.cache_timeout)
                except self.model_class.DoesNotExist:
                    cache.delete(f"{self.cache_prefix}:{key}")
        
        return updated_count
    
    def bulk_update(self, updates_list):
        """事务安全的批量更新"""
        with transaction.atomic():
            updated_count = 0
            cache_updates = {}
            
            for update_data in updates_list:
                pk = update_data.pop('pk')
                
                # 使用select_for_update锁定记录
                try:
                    instance = self.model_class.objects.select_for_update().get(pk=pk)
                    for field, value in update_data.items():
                        setattr(instance, field, value)
                    instance.save()
                    updated_count += 1
                    
                    # 准备缓存更新
                    cache_key = f"{self.cache_prefix}:{pk}"
                    cache_updates[cache_key] = instance
                except self.model_class.DoesNotExist:
                    continue
            
            # 批量更新缓存
            if cache_updates:
                cache.set_many(cache_updates, self.cache_timeout)
        
        return updated_count