Django高级之-缓存机制

1 缓存介绍

在动态网站中，用户所有的请求，服务器都会去数据库中进行相应的增,删,查,改，渲染模板，执行业务逻辑，最后生成用户看到的页面。

当一个网站的用户访问量很大的时候，每一次的的后台操作都会消耗很多的服务端资源，所以必须使用缓存来减轻后端服务器的压力。

将对数据库操作查询所得到的数据放入另外一台机器上(缓存)中，当用户再次请求时，直接去缓存中拿，避免对数据库的频繁操作，加快数据的显示时间。

缓存是将一些常用的数据保存内存或者memcache中，在一定的时间内有人来访问这些数据时，则不再去执行数据库及渲染等操作，而是直接从内存或memcache的缓存中去取得数据，然后返回给用户。缓存里面的数据一般都设置有超时时间，缓存一般用在数据变化不大，实时率不高的情况下。

2 Django中的6种缓存方式

开发调试缓存：此模式为开发调试使用,实际上不执行任何操作
内存缓存：将缓存内容保存至内存区域中，在内存就是一个大字典，里面key:val，页面也是字符串转成二进制存入val
文件缓存：把缓存数据存储在文件中
数据库缓存：把缓存数据存储在数据库中

-创建缓存的数据库表使用的语句 python3 manage.py createcachetable

-虽然也要去数据库中查，但缓存是已经查好的结果，不用再连表查询

-缓存到内存数据库，redis

Memcache缓存(使用python-memcached模块)
Memcache缓存(使用pylibmc模块)

Memcached是Django原生支持的缓存系统，要使用Memcached，需要下载Memcached的支持库python-memcached或pylibmc。

Memcached是基于内存的缓存，数据存储在内存中，所以如果服务器死机的话，数据就会丢失，所以Memcached一般与其他缓存配合使用，经常使用的有文件缓存和Mencache缓存。

3 Django6种缓存的配置

3.1 开发调试

settings.py文件配置

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.2 内存缓存

settings.py文件配置

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.3 文件缓存

settings.py文件配置

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）
        }
    }   
}

3.4 数据库缓存

settings.py文件配置

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

注意,创建缓存的数据库表使用的语句

python3 manage.py createcachetable

3.5 Memcache缓存(python-memcached模块连接memcache)

settings.py文件配置

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）
        }
    }
}

LOCATION也可以配置成如下:

'LOCATION': 'unix:/tmp/memcached.sock',   # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
'LOCATION': [             # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

3.6 Memcache缓存(pylibmc模块连接memcache)

settings.py文件配置

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）
        },  
    }
}

LOCATION也可以配置成如下:

'LOCATION': '/tmp/memcached.sock',  # 指定某个路径为缓存目录
'LOCATION': [          # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

4 Django中的缓存应用

Django提供了不同粒度的缓存，可以缓存某个页面，可以只缓存一个页面的某个部分，甚至可以缓存整个网站。

4.1 前端混合开发缓存的使用

数据库：

class Book(models.Model):
    name=models.CharField(max_length=32)
    price=models.DecimalField(max_digits=6,decimal_places=1)

4.1.1 视图函数使用缓存

单页面缓存(单个视图)，在视图函数上加装饰器

views.py：

from django.views.decorators.cache import cache_page
import time
from .models import *

@cache_page(15)        #超时时间为15秒
def index(request):
　　t=time.time()      #获取当前时间
　　bookList=Book.objects.all()
　　return render(request,"index.html",locals())

模板(index.html)：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>

上面的例子是基于内存的缓存配置,基于文件的缓存该怎么配置呢??

更改settings.py的配置

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

然后再次刷新浏览器，可以看到在刚才配置的目录下生成的缓存文件。

通过实验可以知道，Django会以自己的形式把缓存文件保存在配置文件中指定的目录中。

4.1.2 全站使用缓存

既然是全站缓存，缓存所有视图，当然要使用Django中的中间件。

用户的请求通过中间件，经过一系列的认证等操作，如果请求的内容在缓存中存在，则使用 FetchFromCacheMiddleware 获取内容并返回给用户。

当返回给用户之前，判断缓存中是否已经存在，如果不存在，则 UpdateCacheMiddleware 会将缓存保存至Django的缓存之中，以实现全站缓存。

在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件：

MIDDLEWARE_CLASSES = (
    'django.middleware.cache.UpdateCacheMiddleware',     #响应走时，在最上方出中间件之前，重写process_response，设置几个headers，进行缓存
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware’, #请求来时，走到最下方中间件，重写process_request，取出缓存
)


CACHE_MIDDLEWARE_SECONDS=10   # 全站缓存时间配置，10秒，放在中间件列表外面

注意：“update” 必须配置在第一个，“fetch” 必须配置在最后一个。

views.py：

from django.views.decorators.cache import cache_page
import time
from .models import *

def index(request):
     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())

def foo(request):
    t=time.time()       #获取当前时间
    return HttpResponse("HELLO:"+str(t))

模板(index.html)：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3 style="color: green">当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>

其余代码不变，刷新浏览器是10秒，页面上的时间变化一次，这样就实现了全站缓存。

4.1.3 局部视图缓存

刷新页面时,整个网页有一部分（视图的局部位置）实现缓存。

views.py：

from django.views.decorators.cache import cache_page
import time
from .models import *

def index(request):
     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())

模板(index.html):

{% load cache %}    <!--模板中导入标签-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <h3 style="color: green">不缓存:-----{{ t }}</h3>

{% cache 5 'name' %}            <!--缓存时间5秒，name是唯一key值(缓存后通过key才能找到它)，视图缓存本身的路径就是key-->
 <h3>缓存:-----:{{ t }}</h3>    <!--缓存的局部页面-->
{% endcache %}

</body>
</html>

4.2 前后端分离缓存的使用

应用场景：第一次查询所有图书，你通过多表联查序列化之后的数据，直接缓存起来。后续查询，直接先去缓存查，如果有直接返回。如果没有，再去连表查，返回之前再缓存。

views.py

from django.core.cache import cache

# 进行缓存
cache.set('key',value)  # value可以是任意数据类型

# 获取缓存
cache.get('key') 

# cache是一个对象，有set和get方法，利用了点拦截__setattr__，__getattr__
# 不单可以缓存json格式字符，还能缓存一个对象；把对象序列化(用的pickle)后保存在文件中，取的时候再转成对象

posted @ 2023-01-01 22:14 不会钓鱼的猫阅读(73) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Just so so

Django高级之-缓存机制

1 缓存介绍

2 Django中的6种缓存方式

3 Django6种缓存的配置

3.1 开发调试

3.2 内存缓存

3.3 文件缓存

3.4 数据库缓存

3.5 Memcache缓存(python-memcached模块连接memcache)

3.6 Memcache缓存(pylibmc模块连接memcache)

4 Django中的缓存应用

4.1 前端混合开发缓存的使用

4.1.1 视图函数使用缓存

4.1.2 全站使用缓存

4.1.3 局部视图缓存

4.2 前后端分离缓存的使用

公告