其他分享
首页 > 其他分享> > django缓存与信号

django缓存与信号

作者:互联网

目录

django缓存与信号

一 django缓存

1 缓存介绍

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

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

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

2 Django中的6种缓存方式

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

# 经常使用的有文件缓存和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)
  }  
 }   
}
# 注意:创建缓存的数据库表使用的语句:

python manage.py createcachetable

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

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',
]
# 存的缓存,数据存储在内存中。所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用。

4 Django中的缓存应用

4.1 使用概览

4.1.1 缓存粒度
1) 三种粒度:整站缓存,单页面缓存,局部缓存2) 单页面缓存	from django.views.decorators.cache import cache_page    @cache_page(5)    def index(request):        import time        ctime=time.time()        return render(request,'index.html',context={'ctime':ctime})3) 页面中某个位置缓存(局部缓存)	# 缓存3s钟。xxx唯一key,唯一的	{% load cache %}    {% cache 3 'xxx'%}    这一部分用缓存    时间为:{{ ctime }}    {% endcache %}4) 整站缓存(两个中间件)	# 在setting中配置	‘django.middleware.cache.UpdateCacheMiddleware’, #第一,重写了process_response  ,全部中间件校验完成后返回缓存    '。。。',    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后,重写了process_requset  , 全部中间件认证完成后请求缓存    # 缓存过期时间    CACHE_MIDDLEWARE_SECONDS=5
4.1.2 前后端分离后缓存使用
1) 查出一堆json格式数据,链表查了8个表 2) 前后端分离以后,	-只需要会如何把字典,字符串,对象放到缓存中,    -如何取出来3) 具体使用from django.core.cache import cacheclass BookView(APIView):    def get(self, request):        res_data = cache.get('book_list_dic',)        if res_data:  # 有缓存,直接返回            print('走了缓存')            return Response(res_data)        else:  # 没有缓存,再走数据库            book_list = models.Book.objects.all()            ser = serializer.BookSer(book_list, many=True)            # 想把ser.data缓存起来            cache.set('book_list_dic', ser.data, 100)            print('没走缓存')            return Response(ser.data)        4) cache可以缓存所有数据类型,包括自定义的类(pickle)

4.2 视图函数使用缓存

数据库:

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

视图:

from django.views.decorators.cache import cache_pageimport timefrom .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.3 全站使用缓存

    -既然是全站缓存,当然要使用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_pageimport timefrom .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.4 局部视图缓存

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

views视图函数

from django.views.decorators.cache import cache_pageimport timefrom .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信号

1 概览

1) Django提供一种信号机制。当发生一些动作的时候,发出信号,然后监听了这个信号的函数就会执行。其实就是观察者模式,又叫发布-订阅(Publish/Subscribe) 。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接收者。用于在框架执行操作时解耦。2) Django内置信号	Django 提供了一系列的内建信号,    3) 内置信号的使用(两种方式)	# #1 导入内置信号        # from django.core.signals import request_started        # #2 写一个函数        # def aa(sender, **kwargs):        #     print(sender)        #     print(kwargs)        #     print('请求来了,我写日志了。。。')        #        #        # #3 跟内置信号绑定        # request_started.connect(aa)        # 方式二        from django.core.signals import request_started,request_finished        from django.dispatch import receiver        @receiver(request_finished)  # 内置信号pre_save和my_callback函数绑定了        def my_callback(sender, **kwargs):            print("请zzou了,走了我")4) 信号的应用场景:    -记录日志(对象创建就写入日志)    -解耦合    

2 Django内置信号

Model signals    pre_init                    # django的 Model 执行其构造方法前,自动触发    post_init                   # django的 Model 执行其构造方法后,自动触发    pre_save                    # django的 Model 对象保存前,自动触发    post_save                   # django的 Model 对象保存后,自动触发    pre_delete                  # django的 Model 对象删除前,自动触发    post_delete                 # django的 Model 对象删除后,自动触发    m2m_changed                 # django的 Model 中使用m2m字段操作第三张表(add,remove,clear)前后,自动触发    class_prepared              # 程序启动时,检测已注册的app中 Model 类,对于每一个类,自动触发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 请求时发送。

3 内置信号的使用

# 对于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

方式一:

#放到__init__里from django.db.models.signals import pre_saveimport loggingdef callBack(sender, **kwargs):    print(sender)    print(kwargs)    # 创建对象写日志    logging.basicConfig(level=logging.DEBUG)    # logging.error('%s创建了一个%s对象'%(sender._meta.db_table,kwargs.get('instance').title))    logging.debug('%s创建了一个%s对象'%(sender._meta.model_name,kwargs.get('instance').title))pre_save.connect(callBack)

方式二:

from django.db.models.signals import pre_savefrom django.dispatch import receiver@receiver(pre_save)def my_callback(sender, **kwargs):    print("对象创建成功")    print(sender)    print(kwargs)

4 自定义信号

a). 定义信号(一般创建一个py文件)(toppings,size 是接受的参数)import django.dispatchpizza_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中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。 练习:数据库添加一条记录时生成一个日志记录。

标签:缓存,cache,request,django,signals,信号,import
来源: https://www.cnblogs.com/chaochaofan/p/14932349.html