django的缓存如何配置？如何设置redis缓存？django的缓存如何应用？为什么要用django缓存？缓存的使用场景？缓存的优先级？如何进行缓存？_django redis max_entries

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

1.开发者调试缓存(此模式为开发调试使用,实际上不执行任何操作)
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.locmem.DummyCache',  # 指定缓存使用的引擎
  'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值 
  'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }  
 }
}


2.内存缓存(将缓存内容保存至内存区域中)
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定缓存使用的引擎
  'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值 
  'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }  
 }
}


3.文件缓存(把缓存数据存储在文件中)
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
  'LOCATION': '/var/tmp/django_cache',        #指定缓存的路径
  'TIMEOUT':300,              #缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }   
}



4.数据库缓存(把缓存数据存储在数据库中)
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
  'LOCATION': 'cache_table',          # 数据库表    
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }  
 }   
}


5.Memcache缓存(使用python-memecached模块连接memcache)
Memcached是Django原生的缓存系统,要使用Memcached,需要下载Memcache的支持库python-memcached或pylibmc.
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
  'LOCATION': '192.168.10.100:11211',         # 指定Memcache缓存服务器的IP地址和端口
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

6.Memcache缓存(使用pylibmc模块)
CACHES = {
  'default': {
   'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',  # 指定缓存使用的引擎
   'LOCATION':'192.168.10.100:11211',         # 指定本机的11211端口为Memcache缓存服务器
   'OPTIONS':{
    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
   },  
  }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

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

如何设置redis缓存？

1，django中应用redis缓存需要先安装第三方库 django-redis

2，settings.py文件中进行配置

CACHES = {
    # default 是缓存名，可以配置多个缓存 默认缓存名为default
    "default": {
        # 应用 django-redis 库的 RedisCache 缓存类
        "BACKEND": "django_redis.cache.RedisCache",
        # 配置正确的 ip和port
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            # redis客户端类
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            # redis连接池的关键字参数
            "CONNECTION_POOL_KWARGS": {
                "max_connections": 100
            }
            # 如果 redis 设置了密码，那么这里需要设置对应的密码，如果redis没有设置密码，那么这里也不设置
            # "PASSWORD": "123456",
        }
    },
    #注意：可配置多个缓存，前面的缓存后面加逗号
    "default2": {
        
    },
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

django的缓存如何应用？

1，全站缓存

MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware', 将数据更新到缓存中
    其他中间件...    
    'django.middleware.cache.FetchFromCacheMiddleware', 从缓存中读取数据
]
UpdateCacheMiddleware必须是第一个中间件，
原因为：因为避免之前的中间件修改过response的内容，造成缓存和数据库内容不一致

FetchFromCacheMiddleware必须是最后一个中间件
原因为：因为 要先请求进来，要先经过CSRF中间件，因为不合法的request，缓存也不应该给让他看到

然后，将以下必需设置添加到Django的settings文件中：
- CACHE_MIDDLEWARE_ALIAS - 用于存储的缓存别名。
- CACHE_MIDDLEWARE_SECONDS - 每个页面应缓存的秒数。
- CACHE_MIDDLEWARE_KEY_PREFIX - 用于生成缓存key的前缀，如果使用相同的Django安装在多个站点之间共享缓存，
- 请将其设置为站点名称或此Django实例特有的其他字符串，以防止发生密钥冲突。如果你不在乎，请使用空字符串。


2，视图函数缓存(记得取消全站缓存中间件配置)
	1，通过装饰器cache_page
	2，通过urls中配置cache_page

from django.views.decorators.cache import cache_page
 
 @cache_page(60 * 15)
 def index(request):
 	pass

from django.views.decorators.cache import cache_page
 
urlpatterns = [
    path('index/', cache_page(60 * 15)(views.index)),
]


3，模板文件缓存
   {% load cache %}
   {% cache 500 sidebar request.user.username %}
       指定登录用户的侧边栏
   {% endcache %}


4，低级缓存
不想缓存整个页面数据，而只是想缓存某些费时查询并且基本不会改变的数据，可以通过一个简单的低级缓存API实现，
该API可以缓存任何可以安全pickle的Python对象：字符串，字典，模型对象列表等
比如缓存某个函数的结果，或者某个API接口


from django.core.cache import cache
def get_cache_or_exc_func(key, func, *args, **kwargs):
    """
    根据传入的key和func，先获取缓存的内容，没有则使用func计算并保存
    :param key:缓存的key
    :param func:计算函数
    :param args:可变参数
    :param kwargs:可变关键字参数
    :return:缓存的内容或func计算的结果
    """


    # 加上cache锁
    with cache.lock(key + "_lock"):

        # 获取缓存中的变量
        result = cache.get(key)

        # 判断缓存中的变量是否存在
        if result:
            return result
        else:
            # 计算数据，得到结果
            result = func(*args, **kwargs)

            # 将结果保存到缓存中
            cache.set(key, result)
            return result


def get_result():
    # 做一些费时，但是不经常变更的数据查询，运算等
    time.sleep(5)
    return "lower level cache is ok !!!"


# 低级缓存
def lower_level_cache(request):
    result = get_cache_or_exc_func("lower_level_cache", get_result)
    return JsonResponse({"result":result})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

为什么要用django缓存？

Django的请求响应流程：
→ 用户浏览器输入URL地址
→ Web服务器将HTTP请求转发给uWSGI服务器
→ uWSGI服务器将Request请求转发给Django应用
→ Django中间件处理Request请求
→ 视图View处理
→ 模型类Models获取数据
→ 模板Template渲染
→ 再次经过Django中间件返回
→ uWSGI服务器将Response返回给Web服务器
→ Web服务器响应客户端的HTTP请求。

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


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

使用缓存的好处：

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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

缓存的使用场景？

对页面实时性要求不高的页面。对于大多数的购物网站，短期内商品的描述是没有变化的，可以使用缓存。
1

缓存的优先级？

由django的生命周期知各级缓存的优先级：中间件应用的全局缓存>视图函数缓存>模板渲染下的局部视图使用缓存。
1

django 如何进行缓存？

一个Request请求过来，先去缓存中查询，有就返回；没有就去数据库查询并处理，然后把结果缓存好（供下次请求使用），再返回
1