Django的缓存机制和信号量相关

最新推荐文章于 2022-03-25 23:21:34 发布
转载 最新推荐文章于 2022-03-25 23:21:34 发布 · 84 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zhaopanpan/p/9270251.html

本文详细介绍了Django中的缓存机制，包括六种缓存方式及其配置方法，并展示了如何在视图函数级别、全站及局部实现缓存。此外还讲解了Django信号机制的应用。

缓存介绍

缓存的简介

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

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

　　缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等操作,而是直接从内存或memcache的缓存中去取得数据,然后返回给用户.

　　备注：Django提供的缓存机制是基于memcache的。

Django提供了6种缓存方式

  • 开发调试缓存
  • 内存缓存
  • 文件缓存
  • 数据库缓存
  • Memcache缓存(使用python-memcached模块)
  • Memcache缓存(使用pylibmc模块)

经常使用的有文件缓存和Mencache缓存

各种缓存配置

开发调试(此模式为开发调试使用,实际上不执行任何操作)

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）
  },
 }
}
复制代码

内存缓存(将缓存内容保存至内存区域中)

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）
  }  
 }
}
复制代码

文件缓存(把缓存数据存储在文件中)

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）  } } }
复制代码

数据库缓存(把缓存数据存储在数据库中)

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）  } } }
复制代码

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

python manage.py createcachetable

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

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

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', ]

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', ]
复制代码

Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用

Django中的缓存应用

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

Django提供的不同粒度的缓存：

　　1.视图函数级别：只缓存某个视图函数的return值    from django.views.decorators.cache import cache_page

　　2.全局：在全局settings中，加两个中间件。 

　　3.局部：模板层次的，{% load cache %}  可以选择性的将缓存内容添加到：  {% cache %} 要缓存的内容   {% endcache%}

数据库：

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

 

视图函数级别的缓存

基于FBV的缓存

复制代码 
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())
复制代码

基于CBV的缓存：

from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page


class Timer(APIView):

    @method_decorator(cache_page(10))    # 需要用一个装饰器包一下
    def dispatch(self, request, *args, **kwargs):
        return super(Timer,self).dispatch(request,*args,**kwargs)

    def get(self,request):
        ctime = time.time()
        return render(request, 'timer.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会以自己的形式把缓存文件保存在配置文件中指定的目录中. 

 全站使用缓存

既然是全站缓存,当然要使用Django中的中间件.

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

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

复制代码 
缓存整个站点，是最简单的缓存方法

在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件
MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    'django.middleware.common.CommonMiddleware',
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)
“update” 必须配置在第一个
“fetch” 必须配置在最后一个
复制代码

修改settings.py配置文件

复制代码 
MIDDLEWARE_CLASSES = (
    'django.middleware.cache.UpdateCacheMiddleware',   #响应HttpResponse中设置几个headers 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'django.middleware.security.SecurityMiddleware', 'django.middleware.cache.FetchFromCacheMiddleware', #用来缓存通过GET和HEAD方法获取的状态码为200的响应  ) CACHE_MIDDLEWARE_SECONDS=10
复制代码

视图函数：

复制代码 
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秒,页面上的时间变化一次,这样就实现了全站缓存.

局部视图缓存

例子,刷新页面时,整个网页有一部分实现缓存

views视图函数

复制代码 
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 2 'name' %} <h3>缓存:-----:{{ t }}</h3> {% endcache %} </body> </html> 
复制代码

Django的信号

Django提供一种信号机制。其实就是观察者模式，又叫发布-订阅(Publish/Subscribe) 。当发生一些动作的时候，发出信号，然后监听了这个信号的函数就会执行。

通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。用于在框架执行操作时解耦。

Django内置信号 

复制代码 
Model signals
    pre_init                    # django的modal执行其构造方法前，自动触发
    post_init                   # django的modal执行其构造方法后，自动触发
    pre_save                    # django的modal对象保存前，自动触发 post_save # django的modal对象保存后，自动触发 pre_delete # django的modal对象删除前，自动触发 post_delete # django的modal对象删除后，自动触发 m2m_changed # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发 class_prepared # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发 Management signals pre_migrate # 执行migrate命令前，自动触发 post_migrate # 执行migrate命令后，自动触发 Request/response signals request_started # 请求到来前，自动触发 request_finished # 请求结束后，自动触发 got_request_exception # 请求异常后，自动触发 Test signals setting_changed # 使用test测试修改配置文件时，自动触发 template_rendered # 使用test测试渲染模板时，自动触发 Database Wrappers connection_created # 创建数据库连接时，自动触发
复制代码
复制代码 
Django 提供了一系列的内建信号，允许用户的代码获得DJango的特定操作的通知。这包含一些有用的通知：
django.db.models.signals.pre_save & django.db.models.signals.post_save
在模型 save()方法调用之前或之后发送。

django.db.models.signals.pre_delete & django.db.models.signals.post_delete
在模型delete()方法或查询集的delete() 方法调用之前或之后发送。

django.db.models.signals.m2m_changed
模型上的 ManyToManyField 修改时发送。

django.core.signals.request_started & django.core.signals.request_finished
Django建立或关闭HTTP 请求时发送。
复制代码

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

方式1:

复制代码 
from django.core.signals import request_finished
    from django.core.signals import request_started from django.core.signals import got_request_exception from django.db.models.signals import class_prepared from django.db.models.signals import pre_init, post_init from django.db.models.signals import pre_save, post_save from django.db.models.signals import pre_delete, post_delete from django.db.models.signals import m2m_changed from django.db.models.signals import pre_migrate, post_migrate from django.test.signals import setting_changed from django.test.signals import template_rendered from django.db.backends.signals import connection_created def callback(sender, **kwargs): print("pre_save_callback") print(sender,kwargs) pre_save.connect(callback) ＃ 该脚本代码需要写到app或者项目的初始化文件中，当项目启动时执行注册代码
复制代码

方式2:

from django.core.signals import request_finished
from django.dispatch import receiver @receiver(request_finished) def my_callback(sender, **kwargs): print("Request finished!")

自定义信号 

a. 定义信号

import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

 

b. 注册信号

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
  
pizza_done.connect(callback)

 

c. 触发信号

from 路径 import pizza_done
  
pizza_done.send(sender='seven',toppings=123, size=456)

 

由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。 

练习：数据库添加一条记录时生成一个日志记录。

转载于:https://www.cnblogs.com/zhaopanpan/p/9270251.html

Angela㐅cc
关注
python-DRF_RBAC-基于角色的访问控制_xadmin的使用_django缓存_django信号
qq_31455841的博客
11-17 978
DRF-Django rest framework 1. RBAC-基于角色的访问控制 1. 什么是RBAC # 概念 RBAC 是基于角色的访问控制（Role-Based Access Control ） 在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。 # 应用 RBAC - Role-Based Access Cont
django 刷新缓存_Django 中的缓存问题
weixin_39564524的博客
12-19 468
Django 中的缓存问题简单介绍​在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面.​当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力.​缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等...
15：django 缓存架构
dianliao7817的博客
01-10 424
动态网站的一个基本权衡就是他们是动态的，每次一个用户请求一个页面，web服务器进行各种各样的计算-从数据库查询到模板渲染到业务逻辑-从而生成站点访问者看到的页面。从处理开销的角度来看，相比标准的从文件系统读取文件的服务器调度，这是昂贵了不少。尽管对于大多数网站来说，这种开销不是什么大问题，因为大多数web应用不过是想学学院的首页那样，都是小到中型的站点，流量也很少。但对于中到大型的站点来...
Django中的缓存机制
weixin_30770783的博客
07-08 236
　　Django 是动态网站，一般来说需要实时地生成访问的网页，展示给访问者，这样，内容可以随时变化，但是从数据库读多次把所需要的数据取出来，要比从内存或者硬盘等一次读出来 付出的成本大很多。 缓存系统工作原理： 　　对于给定的网址，尝试从缓存中找到网址，如果页面在缓存中，直接返回缓存的页面，如果缓存中没有，一系列操作（比如查数据库）后，保存生成的页面内容到缓存系统以供下一次使用，然后返回生成...
Django之缓存篇
m0_61993498的博客
03-25 5038
1.什么是缓存 定义：缓存是一类可以更快的读取数据的介质统称，也指其他可以加快得数据读取的存储方式。一般来存储临时数据，常用的介质是快速很快据的内存。 意义：试图渲染有一定的成本，数据库查询的频率过高；所以对于低频变动的页面可以考虑缓存技术，减少实际渲染次数；用户得到响应的时间也会减少。 简单例子：网上购物如果的推荐图片一个月换一次，属于低频变动，因此可以通过缓存技术，这样子就不需要花费时间去数据库寻找了。 2.Django的缓存方式 1.数据库缓存 说明：将变动低频的数据放入数据库当中。
django中cache缓存技术的使用
Mrjiajia的博客
08-31 5717
1.设定缓存  缓存选择在你的settings文件的 CACHE_BACKEND 设置中，如果你使用缓存但没有指定 CACHE_BACKEND ，Django将默认使用 simple:///  2. 内存缓冲  CACHE_BACKEND = ‘memcached://127.0.0.1:11211/’ CACHE_BAC
Django 分页器 缓存 信号 序列化
weixin_34246551的博客
12-18 329
阅读目录 分页器 缓存 信号 序列化 Django分页器（paginator） 导入 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger view from django.shortcuts import render,HttpRes...
理解Django的缓存机制和信号量
道可道 非常道
03-30 357
缓存介绍 缓存的简介 在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面. 当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力. 缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等操作,...
Django 缓存机制与信号机制
avz72927的博客
01-23 130
Django的缓存机制 缓存的简介 在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面. 当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力. 缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这...
深入理解Django-Signals信号量
09-19
Django的信号机制提供了一种方式，使得在特定操作执行前后，如模型保存、删除等，可以触发自定义的行为。这些行为通常由注册的接收器（receiver）函数来执行。Django自身定义了一些常见的信号，例如`request_started...
【Django缓存机制详解】：从基础到高级应用
Django缓存机制概述 缓存是提高Web应用性能的关键技术之一，尤其在处理大量请求时，缓存可以显著减少数据库的负载，缩短响应时间。Django，作为一个高级的Python Web框架，内置了灵活的缓存系统，支持多种缓存机制...
Django中的缓存机制和性能优化
Django中的缓存机制简介 ## 1.1 什么是缓存？ 缓存是一种将数据临时存储起来的技术，可以加速数据的访问速度。在web应用中，缓存可以存储已经计算过的页面或数据，提高页面的加载速度，减轻服务器压力。 ## 1.2 ...
Django Signals示例：深入理解Django信号机制
在实际应用中，Django Signals可以用来实现多种功能，例如在模型保存后自动更新索引、在删除操作后清理相关缓存、在用户注册成功后发送欢迎邮件等。开发者需要编写对应的Signal处理函数，并将其连接到相应的信号上。...
Django-Signals信号量
weixin_34241036的博客
02-18 177
信号量最为Django的一个核心知识点，在项目中很少有使用到，所以很多人都不了解或者没听过过(包括我)。简单来说就是在进行一些操作的前后我们可以发出一个信号来获得特定的操作，这些操作包括(信息来自：https://yiyibooks.cn/xx/Djang...： django.db.models.signals.pre_save&am...
基于Opencv+QT的视频播放器.zip
09-13
基于Opencv+QT的视频播放器.zip
wisp-containers-testing-1.3.0-sources.jar
09-13
wisp-containers-testing-1.3.0-sources.jar
JDK1.8：jdk-8u461-windows-x64.zip、jdk-8u461-windows-i586.exe、jdk-8u461-windows-i586.zip、jdk-8u461-win
最新发布
09-13
JDK1.8：jdk-8u461-windows-x64.zip、jdk-8u461-windows-i586.exe、jdk-8u461-windows-i586.zip、jdk-8u461-win
Android结构化KV存储框架，基于yaml生成java结构化存储类.zip
09-13
Android结构化KV存储框架，基于yaml生成java结构化存储类.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值