Django之缓存和信号

缓存

中间件和缓存之间的关系

　　在写缓存之前写了一个下中间件随笔。是因为一般缓存页面时,需要在response用户之前缓存到缓存服务器,因为如果在views处理后即存入缓存,可能会与用户收到的页面不一致,为什么呢?因为中间件有很多层,你不确定哪一层会对页面做其他处理(包括页面渲染,数据处理等等).

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

Django提供的6中缓存机制

• 开发调试
• 内存
• 文件
• 数据库
• Memcache缓存（python-memcached模块
• Memcache缓存（pylibmc模块,只是与上面换了个模块而已）

配置

下面缓存的配置都在setting.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）
        },
        '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

 

内存模式

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

    # 注：其他配置同开发调试版本

 

 文件模式

# 此缓存将内容保存至文件
    # 配置：

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

 

数据库模式

# 此缓存将内容保存至数据库

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

    # 注：执行创建表命令 python manage.py createcachetable

Memcache缓存（python-memcached模块）

# 此缓存使用python-memcached模块连接memcache
#单台IP端口连接模式
    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',
            ]
        }
    }

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

 

 缓存的应用

单独视图缓存

# 方式一、views.py中
from django.views.decorators.cache import cache_page
@cache_page(60 * 15)   #  相当于15分钟 可以写10这个相当于十秒
def cache(request):
            ...
# 方式二、urls.py中
from django.conf.urls import url
from app01 import views
from django.views.decorators.cache import cache_page

urlpatterns = [
    url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(views.cache)), # 和上面的同理
]

 

局部视图使用

a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

        {% cache 5000 缓存key %}
            缓存内容
        {% endcache %}

 

全站使用 

 在setting配置的加上2个中间件，'django.middleware.cache.UpdateMiddleware'这个中间件在最上面，'django.middleware.cache.FetchFormCacheMiddleware',这个中间件在最下面


MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
]

 

然后你需要在项目配置文件中加入下面几个必须的设置：

• CACHE_MIDDLEWARE_ALIAS：用来存储的缓存别名
• CACHE_MIDDLEWARE_SECONDS：每个页面应该被缓存的秒数   
• CACHE_MIDDLEWARE_KEY_PREFIX：关键的前缀，当多个站点使用同一个配置的时候，这个可以设置可以避免发生冲突；如果你不在乎的话， 你可以是用一个空字符串，建议你别这样做

 'django.middleware.cache.UpdateMiddleware',

这个中间件的作用就是当服务器响应response是，它会查看这个响应是否有缓存，如果没有就写入到缓存中并返回给客户端，否则直接返回给客户端

'django.middleware.cache.FetchFormCacheMiddleware',

客户端请求request时作用 查看是否有缓存，如果有不经过views直接返回，否则进入views视图执行函数获取缓存 

单独视图缓存示例：

setting的设置为文件保存缓存

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': os.path.join(BASE_DIR,'cache'),
    }
}

 

urls.py的代码

# 第一种在试图函数加装饰器
from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^cache/$', views.cache),
]


# 第二种方式在路由系统加装饰器
from django.conf.urls import url
from django.contrib import admin
from app01 import views
from django.views.decorators.cache import cache_page
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^cache/$', cache_page(10)(views.cache)),  # 缓存超时时间为10秒
]

 

views.py代码

from django.views.decorators.cache import cache_page
@cache_page(10)  # 第二种方式就不需要在这家装饰器
def cache(request):
    import time
    ctime = time.time()
    return render(request, 'cache.html', {'ctime': ctime})

 

cache.html代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>
</body>
</html>

 

局部视图 

 setting部门代码不变，

urls.py的代码

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^cache/$', views.cache),
]

 

views.py代码

def cache(request):
    import time
    ctime = time.time()
    return render(request, 'cache.html', {'ctime': ctime})

 

cache.html代码

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>

     {% cache 10 c1 %}
       <h1>{{ ctime }}</h1>  {# 只缓存该部分时间为十秒 #}
     {% endcache %}
</body>
</html>

　

Django缓存的三种方式的优先级，全站>单独视图>局部视图

也就是说三种都写了一最高优先级为准

信号

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内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

    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代指上面导入的信号，如request_finished，request_started，request_started等替换前面的xxoo，而callback就是你要注册的函数

如果我们把导入信号以及将注册函数都写到一个单独的文件里，为了在程序启动的时候执行信号中的注册函数，可以在于项目同名的文件中的init文件中导入该文件即可

自定义信号

自定义信号一共需要三步骤：

• 定义信号
• 注册信号
• 触发信号

自定义信号

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

 pizza_done为信号名字，根据自己的需求写就好，触发的时候需要的两个参数关键字参数toppings、size

注册信号

def callback(sender, **kwargs):

    print("callback")

    print(sender,kwargs)

 pizza_done.connect(callback)

触发信号

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

触发的时候就是我们使用我们自定义的信号.send(sender='seven',toppings=123, size=456) 这个sender随便写不影响，

由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。也就是说我们也可以自定义一下当年某个条件达到触发要求的时候我们自定义的信号就会触发。

 内置信号的示列

models.py的代码

from django.db import models


# Create your models here.
class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

    def __str__(self):
        return self.username

 

 

views.py的代码

from django.shortcuts import render,HttpResponse
from app01 import models


# Create your views here.
def test(request):
    models.UserInfo.objects.create(username='admin', password='admin')
    return HttpResponse('OK')

 

 

信号的代码可以写在项目下的__init__.py下也可以写单独建一个.py的文件只需要在__init__.py里面导入就好

from django.db.models.signals import pre_save,post_save

def pre_save_func(sender,**kwargs):

    print("pre_save_func")
    print("pre_save_msg:",sender,kwargs)

def post_save_func(sender,**kwargs):
    print("post_save_func")
    print("post_save_msg:",sender,kwargs)

pre_save.connect(pre_save_func)             #把函数注册到pre_save里面 models对象保存前触发callback函数
post_save.connect(post_save_func)           #把函数注册到post_save里面 models对象保存后触发函数

 

我们访问前面写的路由关系

后台打印的信息

pre_save_func
pre_save_msg: <class 'app01.models.UserInfo'> {'signal': <django.db.models.signals.ModelSignal object at 0x03D98310>, 'instance': <UserInfo: admin>, 'raw': False, 'using': 'default', 'update_fields': None}
[01/Aug/2018 16:06:12] "GET /test/ HTTP/1.1" 200 2
post_save_func
post_save_msg: <class 'app01.models.UserInfo'> {'signal': <django.db.models.signals.ModelSignal object at 0x03D98370>, 'instance': <UserInfo: admin>, 'created': True, 'update_fields': None, 'raw': False, 'using': 'default'}

 

比较打印结果我们可以看出保存成功后的instance后面有一个键值对为'created': True

我们还可以使用装饰起来触发信号，上面的__init__.py改写为

这个信号为请求结束再触发

from django.core.signals import request_finished
from django.dispatch import receiver


@receiver(request_finished) # 请求结束后触发这个信号
def callback(sender, **kwargs):
    print("Request finished!")

 

我们可以看到的效果为当我们发起请求整个请求结束后会在后台打印"request finished"