Django（信号，缓存，序列化，与性能有关数据库查询）

一，信号：

　　内置信号的引入from django.core.signals import request_finishedfrom 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

对于Django内置信号，只需在项目的__init__.py文件里配置相应的callback函数，并进行注册就可以（放在__init__.py文件是因为该文件是Django项目启动时必经之路，这样只要项目一启动就会纪录信号的状态，并根据信号状态
决定是否执行回调函数
）

除了内置信号，还可以自定制信号函数：
自己定制的信号可以放置在任何地方，只要保证在__init__.py文件里引入就可以，但是函数的callback函数以及注册和信号触发都需要自行写入代码

自定制信号函数：

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

注册信号函数进入回调函数：

from mypizza import pizza_done（信号函数写在该py文件中）

def callback(sender, **kwargs):
    print('xxoo_callback',sender, kwargs)
pizza_done.connect(callback)

信号触发：

def index(request):（这是Django应用里的view视图函数）
    # # 自定制操作，触发pizza_done信号
    from mypizza import pizza_done
    pizza_done.send(sender='seven', toppings=request, size=456)
　　　　user_list = models.UserInfo.objects.all().defer('name')

　　for row in user_list:
   　　 print(row.pwd)


　　return render(request,'index.html',{'user_list':user_list})


二：Django缓存机制（只写以后常用的缓存配置以及应用）

# 配置：（写在配置文件里）

①缓存存储在文件中

CACHES = {
'default': {
　　'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #引擎
　　'LOCATION': '/var/tmp/django_cache',
　　'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】）
　　}
　　}

②缓存按照分布式存储在内存中

# 此缓存使用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',
]
}
}

或者

# 此缓存使用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',
]
}
}

应用有三种：

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

MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',（该中间件在第一层，用于从后端获取未缓存的数据再存入缓存中）
# 其他中间件...
'django.middleware.cache.FetchFromCacheMiddleware',（该中间件在最后一层，用于查找缓存）
]

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

②单独视图缓存

方式一：
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)),
]
③局部视图使用缓存（模板语言）

a. 引入TemplateTag

{% load cache %}

b. 使用缓存

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

　三：序列化

def get_data(request):（视图函数中的get_data函数）


    # 方案一：
    ####################################################################################################################
    #对于方案一，因为使用的是objects.all（对象的操作方法），所以无法连表，也就是说serializer只可以支持单表的序列化
    # queryset[UserInfo对象,]
    # user_list = models.UserInfo.objects.all()
    # from django.core import serializers
    # user_list_str = serializers.serialize("json", user_list)
    # return HttpResponse(user_list_str)
    # 方案二：
    ###################################################################################################################
    #对于方案二，由于使用的是values方法，可以实现连表操作，所以json.dumps,cls=...可以实现跨表查询以及查询结果的序列化，
    # 使用起来更加便捷以及实用
    # querset=[{},{},{}]
    user_list = models.UserInfo.objects.values('name','pwd')
    user_list = list(user_list)
    #cls是json自带的一个处理类，对于无法处理的datetime类型，可以在继承json.JSONEncoder的基础上自定义default方法。
    val = json.dumps(user_list,cls=json.JSONEncoder)
    return HttpResponse(val)

四：与性能有关的数据库查询
数据库表关系如下：

from django.db import models

class UserType(models.Model):
    caption = models.CharField(max_length=32)

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length=64)
    ut = models.ForeignKey(to='UserType',to_field='id',null=True,blank=True)

这里是视图函数：

def index(request):（视图函数中的index函数）
    # [obj,obj,obj]
    # 查询用户表models.UserInfo.objects.all() 1000
    # 把用户表中所有的ut_id拿到, 用户类型ID [1,2,3]
　　再去拿对应外键的表的所有对象组成的Queryset（这两个步骤对应prefetch_related查询方法）
　　对于select_related则是根据外键将两张表连接起来进行连表查询
　　
    # select * from UsetType where id in [1,2,3]
    # user_list = models.UserInfo.objects.all().prefetch_related('ut')
    # for row in user_list:
    #     print(row.name, row.pwd, row.ut.caption)



    # for row in user_list:
    #     print(row.name,row.pwd,row.ut.caption)
    #
    # # [{},{},{}]
    # user_list = models.UserInfo.objects.values('name','pwd','ut__caption')
    # for row in user_list:
    #     print(row['name'],row['pwd'],row['ut__caption'])

    # [obj,obj,obj]
    # user_list = models.UserInfo.objects.all().only('name')
    user_list = models.UserInfo.objects.all().defer('name')
    for row in user_list:
        print(row.pwd)


    return render(request,'index.html',{'user_list':user_list})