Django缓存大总结

Django的缓存配置提供了6种方式，如下：

 1 1.开发者调试缓存(此模式为开发调试使用,实际上不执行任何操作)
 2 CACHES = {
 3  'default': {
 4   'BACKEND': 'django.core.cache.backends.locmem.DummyCache',  # 指定缓存使用的引擎
 5   'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值 
 6   'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
 7   'OPTIONS':{
 8    'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
 9    'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
10   }  
11  }
12 }
13 
14 
15 2.内存缓存(将缓存内容保存至内存区域中)
16 CACHES = {
17  'default': {
18   'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定缓存使用的引擎
19   'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值 
20   'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
21   'OPTIONS':{
22    'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
23    'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
24   }  
25  }
26 }
27 
28 
29 3.文件缓存(把缓存数据存储在文件中)
30 CACHES = {
31  'default': {
32   'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
33   'LOCATION': '/var/tmp/django_cache',        #指定缓存的路径
34   'TIMEOUT':300,              #缓存超时时间(默认为300秒,None表示永不过期)
35   'OPTIONS':{
36    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
37    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
38   }
39  }   
40 }
41 
42 
43 
44 4.数据库缓存(把缓存数据存储在数据库中)
45 CACHES = {
46  'default': {
47   'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
48   'LOCATION': 'cache_table',          # 数据库表    
49   'OPTIONS':{
50    'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
51    'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
52   }  
53  }   
54 }
55 
56 
57 5.Memcache缓存(使用python-memecached模块连接memcache)
58 Memcached是Django原生的缓存系统,要使用Memcached,需要下载Memcache的支持库python-memcached或pylibmc.
59 CACHES = {
60  'default': {
61   'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
62   'LOCATION': '192.168.10.100:11211',         # 指定Memcache缓存服务器的IP地址和端口
63   'OPTIONS':{
64    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
65    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
66   }
67  }
68 }
69 
70 6.Memcache缓存(使用pylibmc模块)
71 CACHES = {
72   'default': {
73    'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',  # 指定缓存使用的引擎
74    'LOCATION':'192.168.10.100:11211',         # 指定本机的11211端口为Memcache缓存服务器
75    'OPTIONS':{
76     'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
77     'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
78    },  
79   }
80  }

以上6种缓存引擎类的基类都是BaseCache

如何设置redis缓存

 1 1，django中应用redis缓存需要先安装第三方库 django-redis
 2 
 3 2，settings.py文件中进行配置
 4 
 5 CACHES = {
 6     # default 是缓存名，可以配置多个缓存 默认缓存名为default
 7     "default": {
 8         # 应用 django-redis 库的 RedisCache 缓存类
 9         "BACKEND": "django_redis.cache.RedisCache",
10         # 配置正确的 ip和port
11         "LOCATION": "redis://127.0.0.1:6379",
12         "OPTIONS": {
13             # redis客户端类
14             "CLIENT_CLASS": "django_redis.client.DefaultClient",
15             # redis连接池的关键字参数
16             "CONNECTION_POOL_KWARGS": {
17                 "max_connections": 100
18             }
19             # 如果 redis 设置了密码，那么这里需要设置对应的密码，如果redis没有设置密码，那么这里也不设置
20             # "PASSWORD": "123456",
21         }
22     },
23     #注意：可配置多个缓存，前面的缓存后面加逗号
24     "default2": {
25         
26     },
27 }

django的缓存如何应用？

 1 1，全站缓存
 2 
 3 MIDDLEWARE = [
 4     'django.middleware.cache.UpdateCacheMiddleware', 将数据更新到缓存中
 5     其他中间件...    
 6     'django.middleware.cache.FetchFromCacheMiddleware', 从缓存中读取数据
 7 ]
 8 UpdateCacheMiddleware必须是第一个中间件，
 9 原因为：因为避免之前的中间件修改过response的内容，造成缓存和数据库内容不一致
10 
11 FetchFromCacheMiddleware必须是最后一个中间件
12 原因为：因为 要先请求进来，要先经过CSRF中间件，因为不合法的request，缓存也不应该给让他看到
13 
14 然后，将以下必需设置添加到Django的settings文件中：
15 - CACHE_MIDDLEWARE_ALIAS - 用于存储的缓存别名。
16 - CACHE_MIDDLEWARE_SECONDS - 每个页面应缓存的秒数。
17 - CACHE_MIDDLEWARE_KEY_PREFIX - 用于生成缓存key的前缀，如果使用相同的Django安装在多个站点之间共享缓存，
18 - 请将其设置为站点名称或此Django实例特有的其他字符串，以防止发生密钥冲突。如果你不在乎，请使用空字符串。
19 
20 
21 2，视图函数缓存(记得取消全站缓存中间件配置)
22     1，通过装饰器cache_page
23     2，通过urls中配置cache_page
24 
25 from django.views.decorators.cache import cache_page
26  
27  @cache_page(60 * 15)
28  def index(request):
29      pass
30 
31 from django.views.decorators.cache import cache_page
32  
33 urlpatterns = [
34     path('index/', cache_page(60 * 15)(views.index)),
35 ]
36 
37 
38 3，模板文件缓存
39    {% load cache %}
40    {% cache 500 sidebar request.user.username %}
41        指定登录用户的侧边栏
42    {% endcache %}
43 
44 
45 4，低级缓存
46 不想缓存整个页面数据，而只是想缓存某些费时查询并且基本不会改变的数据，可以通过一个简单的低级缓存API实现，
47 该API可以缓存任何可以安全pickle的Python对象：字符串，字典，模型对象列表等
48 比如缓存某个函数的结果，或者某个API接口
49 
50 
51 from django.core.cache import cache
52 def get_cache_or_exc_func(key, func, *args, **kwargs):
53     """
54     根据传入的key和func，先获取缓存的内容，没有则使用func计算并保存
55     :param key:缓存的key
56     :param func:计算函数
57     :param args:可变参数
58     :param kwargs:可变关键字参数
59     :return:缓存的内容或func计算的结果
60     """
61 
62 
63     # 加上cache锁
64     with cache.lock(key + "_lock"):
65 
66         # 获取缓存中的变量
67         result = cache.get(key)
68 
69         # 判断缓存中的变量是否存在
70         if result:
71             return result
72         else:
73             # 计算数据，得到结果
74             result = func(*args, **kwargs)
75 
76             # 将结果保存到缓存中
77             cache.set(key, result)
78             return result
79 
80 
81 def get_result():
82     # 做一些费时，但是不经常变更的数据查询，运算等
83     time.sleep(5)
84     return "lower level cache is ok !!!"
85 
86 
87 # 低级缓存
88 def lower_level_cache(request):
89     result = get_cache_or_exc_func("lower_level_cache", get_result)
90     return JsonResponse({"result":result})

为什么要使用缓存 以及使用缓存的好处

Django的请求响应流程
1.用户浏览器输入URL地址
2.Web服务器将HTTP请求转发给uWSGI服务器
3.uWSGI服务器封装好Request请求转发给Django应用
4.Django中间件处理Request请求
5.Django经过路由层转发到相应的视图
6.视图View处理
7.模型层 Model获取数据
8.模板层 Template 渲染数据
9.再次经过中间件返回Response
10.uWSGI服务器将Response返回给Web服务器
11.Web服务器响应客户端的HTTP请求

这其中耗时最多的2个环节通常是视图中业务逻辑处理和从Models获取数据（SQL查询），
对于相同目的请求，也就是业务处理逻辑和SQL查询的数据都一样的请求，每次都进行了重复的计算，
并且数据是从硬盘读取而非内存。


如果每次请求都从数据库中请求并获取数据，并且当用户并发量十分大的时候，会增加服务器的负荷
因此使用缓存能有效的解决这类问题。如果能将渲染后的结果放到速度更快的缓存中，每次有请求过来，
先检查缓存中是否有对应的资源，如果有，直接从缓存中取出来返回响应，节省取数据和渲染的时间，
不仅能大大提高系统性能，还能提高用户体验。

使用缓存的好处：

降低服务器负载
避免重复计算
提高系统性能