十五 Django框架，缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供了6种缓存方式：
　　1、开发调试，没有实质用途，只是配置了缓存配置
　　2、内存，将缓存保存在本地内存
　　3、文件，将缓存保存在本地文件
　　4、数据库，将缓存保存在数据库
　　5、Memcache缓存（python-memcached模块）将缓存保存在Memcache，用的python-memcached模块
　　6、Memcache缓存（pylibmc模块）将缓存保存在Memcache，用的pylibmc模块

配置

1、开发调试配置，

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return '%s:%s:%s' % (key_prefix, version, key)

# 配置：
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',   # 开发调试，引擎
        'TIMEOUT': 300,                                             # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        'OPTIONS': {
            'MAX_ENTRIES': 300,                                     # 最大缓存个数（默认300）
            'CULL_FREQUENCY': 3,                                    # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        'KEY_PREFIX': '',                                           # 缓存key的前缀（默认空）
        'VERSION': 1,                                               # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # 'KEY_FUNCTION': default_key_func                           # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

2、内存配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return '%s:%s:%s' % (key_prefix, version, key)

# 配置：
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',     #配置内存引擎
        'LOCATION': 'unique-snowflake',                                 #配置内存缓存名称

        'TIMEOUT': 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        'OPTIONS': {
            'MAX_ENTRIES': 300,             # 最大缓存个数（默认300）
            'CULL_FREQUENCY': 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        'KEY_PREFIX': '',                   # 缓存key的前缀（默认空）
        'VERSION': 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # 'KEY_FUNCTION': default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

3、文件配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return '%s:%s:%s' % (key_prefix, version, key)

# 配置：
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',     #配置文件引擎
        'LOCATION': os.path.join(BASE_DIR,'huancuen'),                        #配置文件缓存路径,当前工程下的huancuen文件夹

        'TIMEOUT': 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        'OPTIONS': {
            'MAX_ENTRIES': 300,             # 最大缓存个数（默认300）
            'CULL_FREQUENCY': 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        'KEY_PREFIX': '',                   # 缓存key的前缀（默认空）
        'VERSION': 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # 'KEY_FUNCTION': default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

4、数据库配置，这种方式不推荐，缓存本来就是解决数据库访问量，结果还是要访问数据库

# 配置：
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',     #配置数据库引擎
        'LOCATION': 'my_cache_table',                                 #配置数据库表，注意：执行创建表命令 python manage.py createcachetable

        'TIMEOUT': 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        'OPTIONS': {
            'MAX_ENTRIES': 300,             # 最大缓存个数（默认300）
            'CULL_FREQUENCY': 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        'KEY_PREFIX': '',                   # 缓存key的前缀（默认空）
        'VERSION': 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # 'KEY_FUNCTION': default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

5、Memcache缓存（python-memcached模块）配置

# 此缓存使用python-memcached模块连接memcache，3种连接方式

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',  #连接引擎
            'LOCATION': '127.0.0.1:11211',　　　　　　　　　　　　　　　　　　　　　 #服务器IP和端口
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',　　#连接引擎
            'LOCATION': 'unix:/tmp/memcached.sock',　　　　　　　　　　　　　　　　　
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', #连接引擎
            'LOCATION': [　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#多服务器IP和端口
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }
#其他参数同上

6、Memcache缓存（pylibmc模块）配置

# 此缓存使用pylibmc模块连接memcache，3种连接方式
    
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',　　#连接引擎
            'LOCATION': '127.0.0.1:11211',　　　　　　　　　　　　　　　　　　　　　#ip端口
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '/tmp/memcached.sock',
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',　　#连接引擎
            'LOCATION': [　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#多服务器ip端口
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }
#其他参数同上

缓存应用

注意：以上任意那种方式的缓存，在应用上都是一样的，应用首先要在全局配置缓存参数

1、全站应用缓存，不常用

使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

Django提供了两个写好的中间件，用于全站缓存

MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',  #当请求来的时候判断缓存是否存在，如果不存在写入缓存
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware', #如果缓存存在,在缓存里拿数据
    ]

全站缓存中间件注册

#中间件
MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    # 'app1.chajian.zhong_jian_jian.zhongjianjian',
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',   #
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
]

只要在中间件列表里注册了这两个缓存中间件，就自动缓存全站了

2、单独视图缓存

就是在逻辑处理函数上用上缓存装饰器，这样被用上缓存装饰器的逻辑处理的页面将自动缓存，要去掉全局的缓存中间件

导入缓存装饰器模块 from django.views.decorators.cache import cache_page

@cache_page(60)缓存装饰器，用在要缓存的逻辑处理函数上，参数是缓存时间秒

from django.shortcuts import render,redirect
import time

from django.views.decorators.cache import cache_page #导入缓存装饰器

#逻辑处理模块
@cache_page(5)  #运用缓存装饰器，缓存保存时间5秒
def special(request):
    t = time.time()
    return render(request, 'app1/index.html',locals())

3、局部模板使用缓存

就是在html模板里应用，指定一个页面的某一个区块缓存

{% load cache %}#在模板页面导入局部缓存模块

{% cache 缓存时间 自定义缓存名称 %}
　　需要缓存的区块
{% endcache %}

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" type="text/css" href="/static/css/tou.css">
</head>
<body>

{% cache 5 suij %}
   {{ t }}
{% endcache %}

</body>
</html>

将缓存保存在Redis

首先安装Redis缓存软件

然后安装Django中使用Redis缓存的第三方模块 django-redis

配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return '%s:%s:%s' % (key_prefix, version, key)

# 配置：
CACHES = {
    'default': {
        'BACKEND': "django_redis.cache.RedisCache",     #配置文件引擎
        'LOCATION': "redis://127.0.0.1:6379",                        #配置文件缓存路径

        'TIMEOUT': 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        'OPTIONS': {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            'MAX_ENTRIES': 300,             # 最大缓存个数（默认300）
            'CULL_FREQUENCY': 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        'KEY_PREFIX': 'jxiou',                   # 缓存key的前缀（默认空）
        'VERSION': 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # 'KEY_FUNCTION': default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

配置默认连接池

配置默认连接池很简单, 你只需要在 CACHES 中使用 CONNECTION_POOL_KWARGS 设置连接池的最大连接数量即可:

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        ...
        "OPTIONS": {
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    }
}

更多教程   http://django-redis-chs.readthedocs.io/zh_CN/latest/#id12

使用同上