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"))        # 按照查询出来的年份和月份进行分组，并且显示文章个数