一、緩存

　　由於Django是動態網站，所以每次請求均會去取到數據進行相應的操作，當程序訪問量大時，耗時必然會更加明顯，最簡單的解決方式就是使用緩存，緩存將某個views返回的值保存至內存或者memcache中，5分鐘內再有人來訪問時，則不再去執行view中的操作，而是直接從內存或者redis中把之前緩存的內容拿到，並返回。

Django中提供了6中緩存方式：

• 開發調試
• 內存
• 文件
• 數據庫
• Memcache緩存（python-memcached模塊）
• Memcache緩存（pylibmc模塊）

1、由於其他的不常用，所以我們在這裏只介紹文件，memcache兩種配置：

　　a、文件

        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】）
            }
        }    

　　b、memcache緩存

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

2、應用

　　a、全站使用（粒度大）

   使用中間件，經過一系列的認證等操作，如果內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶，當返回給用戶之前，判斷緩存中是否已經存在，如果不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存

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

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""  #設置緩存失效時間
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

　　b、單獨視圖緩存（添加裝飾器，粒度適中）

from django.views.decorators.cache import cache_page

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

　　c、局部視圖使用（粒度小）

    a. 引入TemplateTag

        {% load cache %}

    b. 使用緩存

        {% cache 5000 緩存key %}
            緩存內容
        {% endcache %}

PS：5000代表緩存的秒數

二、序列化

　　以下幾種方式中，我們一般使用json格式。

　　1.seriallzers

from django.core import serializers
 
ret = models.BookType.objects.all()
 
data = serializers.serialize("json", ret)

ps：這種方法拿到的是queryset列表中有一個個的對象，致命的是會取到表名，而我們不能讓
用戶看到我們的表名，還有一個缺點是不能跨表

　　2.json.dumps

import json

user_list = UserInfo.objects.values(‘name‘,‘pwd‘)

user_list = list(user_list)

val = json.dumps(user_list)

return HttpResponse(val)

　　由於json.dumps時無法處理datetime日期，所以可以通過自定義處理器來做擴展，如

import json 
from datetime import date 
from datetime import datetime 
   
class JsonCustomEncoder(json.JSONEncoder): 
    
    def default(self, field): 
     
        if isinstance(field, datetime): 
            return o.strftime(‘%Y-%m-%d %H:%M:%S‘) 
        elif isinstance(field, date): 
            return o.strftime(‘%Y-%m-%d‘) 
        else: 
            return json.JSONEncoder.default(self, field) 
   
   
# ds = json.dumps(d, cls=JsonCustomEncoder) 

三、信號

　　1.內置信號：散布在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          # 創建數據庫連接時，自動觸發

　　對於內置信號，僅需註冊指定信號，當程序執行相應操作時，自動觸發註冊函數：

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指上述導入的內容

　　2.自定義信號

　　a、定義信號

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

　　b、註冊信號

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

　　c、觸發信號

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

　　由於內置信號的觸發者已經集成到Django中，所以其會自動調用，而對於自定義信號則需要開發者在任意位置觸發。

【前端框架】Django補充