django高级之缓存与信号

Posted wjw6692353

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了django高级之缓存与信号相关的知识,希望对你有一定的参考价值。

一、缓存

由于Django是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views的返回值保存至内存或者memcache中,5分钟内再有人来访问时,则不再去执行view中的操作,而是直接从内存或者memcache中之前缓存的内容拿到,并返回。

Django中提供了6种缓存方式:

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

1、配置

a、开发调试

技术图片
    # 此为开始调试用,实际内部不做任何操作
    # 配置:
        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)
                ,
                KEY_PREFIX: ‘‘,                                             # 缓存key的前缀(默认空)
                VERSION: 1,                                                 # 缓存key的版本(默认1)
                KEY_FUNCTION 函数名                                          # 生成key的函数(默认函数会生成为:【前缀:版本:key】)
            
        


    # 自定义key
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix‘. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return %s:%s:%s % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func
View Code

b、内存

技术图片
    # 此缓存将内容保存至内存的变量中
    # 配置:
        CACHES = 
            default: 
                BACKEND: django.core.cache.backends.locmem.LocMemCache,
                LOCATION: unique-snowflake,
            
        

    # 注:其他配置同开发调试版本
View Code

c、文件

技术图片
    # 此缓存将内容保存至文件
    # 配置:

        CACHES = 
            default: 
                BACKEND: django.core.cache.backends.filebased.FileBasedCache,
                LOCATION: /var/tmp/django_cache,
            
        
    # 注:其他配置同开发调试版本
View Code

d、数据库

技术图片
    # 此缓存将内容保存至数据库

    # 配置:
        CACHES = 
            default: 
                BACKEND: django.core.cache.backends.db.DatabaseCache,
                LOCATION: my_cache_table, # 数据库表
            
        

    # 注:执行创建表命令 python manage.py createcachetable
View Code

e、Memcache缓存(python-memcached模块)

技术图片
# 此缓存使用python-memcached模块连接memcache

    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.MemcachedCache,
            LOCATION: 127.0.0.1:11211,
        
    

    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.MemcachedCache,
            LOCATION: unix:/tmp/memcached.sock,
        
       

    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.MemcachedCache,
            LOCATION: [
                172.19.26.240:11211,
                172.19.26.242:11211,
            ]
        
    
View Code

f、Memcache缓存(pylibmc模块)

技术图片
    # 此缓存使用pylibmc模块连接memcache
    
    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.PyLibMCCache,
            LOCATION: 127.0.0.1:11211,
        
    

    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.PyLibMCCache,
            LOCATION: /tmp/memcached.sock,
        
       

    CACHES = 
        default: 
            BACKEND: django.core.cache.backends.memcached.PyLibMCCache,
            LOCATION: [
                172.19.26.240:11211,
                172.19.26.242:11211,
            ]
        
    
View Code

2、应用

a. 全站使用

技术图片
   使用中间件,经过一系列的认证等操作,如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户,当返回给用户之前,判断缓存中是否已经存在,如果不存在则UpdateCacheMiddleware会将缓存保存至缓存,从而实现全站缓存

    MIDDLEWARE = [
        django.middleware.cache.UpdateCacheMiddleware,
        # 其他中间件...
        django.middleware.cache.FetchFromCacheMiddleware,
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""
View Code

b. 单独视图缓存

技术图片
    方式一:
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)
        def my_view(request):
            ...

    方式二:
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r^foo/([0-9]1,2)/$, cache_page(60 * 15)(my_view)),
        ]
View Code

c、局部模板使用

技术图片
    a. 引入TemplateTag

        % load cache %

    b. 使用缓存

        % cache 5000 缓存key %
            缓存内容
        % endcache %
View Code

更多:猛击这里

二、序列化

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户,特别的Ajax请求一般返回的为Json格式。

1、serializers

1
2
3
4
5
from django.core import serializers
 
ret = models.BookType.objects.all()
 
data = serializers.serialize("json", ret)

2、json.dumps

1
2
3
4
5
6
7
8
import json
 
#ret = models.BookType.objects.all().values(‘caption‘)
ret = models.BookType.objects.all().values_list(‘caption‘)
 
ret=list(ret)
 
result = json.dumps(ret)

由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:

 三、信号

Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。

1、Django内置信号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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中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内置的信号,仅需注册指定信号,当程序执行相应操作时,自动触发注册函数:

注册信号,写入与project同名的文件夹下的_init_.py文件中,也是换数据库引擎的地方。

技术图片
    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("xxoo_callback")
        print(sender,kwargs)

    xxoo.connect(callback)
    # xxoo指上述导入的内容
View Code
技术图片
def my_callback(sender, **kwargs):
    print("Request finished!")

# 方法一:
from django.core.signals import request_finished

request_finished.connect(my_callback)

# 方法二:
from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")
示例
技术图片
from django.db.models.signals import pre_save
from django.dispatch import receiver
from myapp.models import MyModel


@receiver(pre_save, sender=MyModel)
def my_handler(sender, **kwargs):
    ...
指定发送者

2、自定义信号

a. 定义信号

在某py文件中定义信号。

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

b. 注册信号

在_init_.py 中注册信号

1
2
3
4
5
def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
pizza_done.connect(callback)

c. 触发信号

1
2
3
from 路径 import pizza_done
 
pizza_done.send(sender=‘seven‘,toppings=123, size=456)

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

 

以上是关于django高级之缓存与信号的主要内容,如果未能解决你的问题,请参考以下文章

Django进阶之缓存和信号

自动化运维Python系列之Django信号缓存操作

Django缓存和信号

Django13 /缓存信号django的读写分离

如何将 Django 信号与抽象模型一起使用?

python-- Django 中间件缓存信号