Django 2.0 学习(18)：Django 缓存、信号和extra

Django 缓存、信号和extra

Django 缓存

因为Django是动态网站，因此每次请求均会去数据库进行相应的操做，当程序访问量大时，耗时必然会显著增长。最简单的解决方法是：使用缓存，缓存将某个views的返回值保存在内存或者redis/memcache中，短期内再次访问该网页时，再也不去执行viwes中的操做，而是直接从内存或缓存数据库中获取内容，并返回。
Django中提供了6种缓存方式：

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

1.开发调试

# 此为开始调试用，内部不作任何操做
# 配置
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

2.内存

# 此缓存将内容保存在内存的变量中
# 配置
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
        "LOCATION": "unique-snowflake", # 给缓存放置的内存区设置名称
    }
}
# 注：其余配置同开发调试版本

3.文件

# 此缓存将内容保存在文件中
# 配置
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",    # 配置缓存存放的目录
    }
}
# 注：其余配置同开发调试版本

4.数据库

# 此缓存将内容保存在数据库中
# 配置
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.db.DatabaseCache",
        "LOCATION": "my_cache_table", # 数据库表
    }
}
# 注：须要执行建立表命令python manage.py createcachetable,这样会额外建立一张表来存放缓存数据

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

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

上面都是一些基本的配置，更重要的是配置以后去应用。

应用
1.全站使用缓存

# 使用中间件，通过一系列的认证等操做，若是内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户；当返回给用户以前，判断缓存中是否已经存在，若是不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

MIDDLEWARE = [
    "django.middleware.cache.UpdateCacheMiddleware",    # 放到第一个中间件位置
    # 其余中间件 ...
    "django.middleware.cache.FetchFromCacheMiddleware",    # 放到最后一个
]

CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

2.单独视图缓存

# 方式一：装饰器
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)),
]

3.局部视图缓存

# 1.引入TemplateTag
{% load cache %}

# 2.使用缓存
{% cache 5000 缓存key %}    # 缓存5秒
    缓存内容
{% endcache %}

Django 信号

Django中提供了"信号调度"，用于在框架执行操做时解耦，某些动做发生的时候，系统会根据信号定义的函数执行相应的操做。
Django中内置的信号

Model_signals
pre_init        # Django中的model对象执行其构造方法前，自动触发
psot_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,update),自动触发
class_prepared  # 程序启动时，检测到已注册得model类，对于每一个类，自动触发

Management_signals
pre_migrate     # 执行migrate命令前，自动触发
post_migrate    # 执行migrate命令后，自动触发

Request/Response_signals
request_started # 请求到来前，自动触发
request_finished    # 请求结束后，自动触发
got_request_exception   # 请求异常时，自动触发

Test_signals
setting_changed     # 配置文件改变时，自动触发
template_rendered   # 模板执行渲染操做时，自动触发

Database_Wrapped
connection_created  # 建立数据库链接时，自动触发

对于Django内置的信号，仅需注册指定信号，当程序执行相应操做时，系统会自动触发注册函数。例如：建立数据库记录，触发pre_save和post_save信号。
建立一个Django项目，配置好路由映射，models.py中的代码：

from django.db import models

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length64)

views.py中的代码：

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

def index(request):
    models.UserInfo.objects.create(name="abc", password="abc123")
    return HttpResponse("ok")

项目的__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)     # models对象保存前触发callback函数
post_save.connect(post_save_func)       # models对象保存后触发函数

建立一个index.html页面，用浏览器打开这个项目，在服务端后台打印信息以下：

pre_save_func
pre_save_msg: <class 'app01.models.UserInfo'> {'signal': <django.db.models.signals.ModelSignal object at 0x0000000002E62588>, 
'instance': <UserInfo: UserInfo object>, 'raw': False, 'using': 'default', 'update_fields': None}

post_save_func
post_save_msg: <class 'app01.models.UserInfo'> {'signal': <django.db.models.signals.ModelSignal object at 0x0000000002E62630>, 
'instance': <UserInfo: UserInfo object>, 'created': True, 'update_fields': None, 'raw': False, 'using': 'default'}

比较打印的结果，能够看到models对象保存后，在打印信息里包含一个"create=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!")

则在本次请求结束后会自动触发callback函数，在后台打印"request finished"这句话。

自定义信号
1.定义信号：新建一个项目，配置好路由，在项目根目录下建立一个signals_test.py文件，内容为

import django.dispatch

action = django.dispatch.Signal(providing_arg=["hello", "world"])

2.注册信号：项目应用下的__init__.py文件内容

from signal_test import action

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

action.connect(pre_save_func)

3.触发信号：views视图函数内容

from signal_test import action

action.send(sender="python", helle="hello", world="world")

用浏览器打开index.html页面，后台打印信息以下：

pre_save_func 
pre_save_msg: python {'signal': <django.dispatch.dispatcher.Signal object at 0x000000000391D710>, 'hello': 'hello', 'world': 'world'}

因为内置信号的触发已经集成到Django中，因此会自动调用。而对于自定义信号须要在任意位置触发。

Django extra

extra

extra(select=None, where=Noe, params=None, tables=None, order_by=None, select_params=None)

有些状况下，Django的查询语法难以表达复杂的WHERE子句，对于这种状况，Django提供了extra() QuerySet修改机制，它能在QuerySet生成的SQL从句中注入新子句。extra能够指定一个或多个参数，例如：select，where or tables。这些参数都不是必须的，可是至少要使用一个。注意：这些额外的方式对不一样的数据库引擎可能存在移植性问题(由于咱们在显示的书写SQL语句)，除非万不得已，尽可能避免这样作。

参数select：select参数能够在select从句中添加其余字段信息，他应该是一个字典，存放着属性名到SQL从句的映射：

queryRes = models.Article.objects.extra(select={"is_recent": "create_time > '2017-09-15'"})

结果集中每一个entry对象都有一个额外的属性is_recent，它是一个布尔值，表示Article对象的建立时间是否晚于2017-09-05。

practice

# in sqlite
article_obj = models.Article.objects.filter(nid=1).extra(select={"standard_time": "strftime('%%Y-%%m-%%d', create_time)"}).values("standard_time", "nid", "title")

# <QuerySet [{"title": "python 入门教程", "standard_time": "2017-05-12", "nid": 1}]>

参数where/tables：可使用where定义显示SQL where子句 - 也许执行非显示链接。可使用tables手动将表添加到SQL FROM子句。where和tables都接受字符串列表，全部where参数均为"与"任何其余搜索条件，例如：

query_res = models.Article.objects.extra(where=["nid in (1, 5) OR title like "py%", "nid>2"])

综合例子

current_user = models.UserInfo.objects.filter(username=username).first()        # 当前用户

models.Article.objects.all()        # 查出每一篇文章
models.Article.objects.all().filter(username=current_user)        # 查出当前用户的全部文章
models.Article.objects.all().filter(username=current_user).extra(select={"filter_create_date": "strftime('%%Y/%%m', create_time)"}).values_list("filter_create_date")        # 查出当前用户全部文章的create_time，而且只取出年份和月份

# extra是用来进行过滤的，参数select必须等于一个字典(转成sql的where语句去执行，查出create_time，而后转成本身格式化的时间)
models.Article.objects.all().filter(user=current_user).extra(select={"filter_create_date": "strftime('%%Y%%m', create_time)"}).values_list("filter_create_date").annotate(Count("title"))        # 按照查询出来的年份和月份进行分组，而且显示文章个数