Django緩存和信號

Django進階之緩存和信號


一、緩存

簡介

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


Django提供了6種緩存方式:

1、    開發調試

2、    內存

3、    文件

4、    數據庫

5、    Memcache緩存(python-memcached模塊)

6、    Memcache緩存(pylibmc模塊)


通用配置

                '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】)

這部分是通用的配置,不上面6中方法中都可以使用


開發調試

    # 此爲開始調試用,實際內部不做任何操作
    # 配置:
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
              通用配置
            }
        }

內存

    # 此緩存將內容保存至內存的變量中
    # 配置:
        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
    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',
            ]
        }
    }

緩存的應用


單獨視圖緩存

from django.views.decorators.cache import cache_page
@cache_page(60 * 15)
def my_view(request):

            ...

即通過裝飾器的方式實現,導入模塊之後,在需要緩存的函數前加@cache_page(60 * 15) 60*15表示緩存時間是15分鐘


例子如下:

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})

前端頁面如下:

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

這樣在前端頁面在獲取的ctime的時候就會被緩存10秒鐘,10秒鐘之後纔會變化,但是這樣的話就相當月所有的調用ctime的地方都被緩存了


局部緩存

引入TemplateTag
{% load cache %}
使用緩存
{% cache 5000 緩存key %}
緩存內容
{% endcache %}

更改前端代碼如下:

{% load cache %}
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>
    {% cache 10 c1 %}
    <h1>{{ ctime }}</h1>
    {% endcache %}
</body>
</html>

這樣就實現了最後一個ctime緩存,其他兩個不緩存


全站緩存


全站緩存的時候,需要在中間件的最上面添加:


'django.middleware.cache.UpdateCacheMiddleware',

在中間件的最下面添加:

'django.middleware.cache.FetchFromCacheMiddleware',

 


其中'django.middleware.cache.UpdateCacheMiddleware'裏面只有process_response方法,在'django.middleware.cache.FetchFromCacheMiddleware'中只有process_request方法,所以最開始是直接跳過UpdateCacheMiddleware,然後從第一個到最後一箇中間件的resquest,第一次沒有緩存座椅匹配urls路由關係依次進過中間件的process_view,到達views函數,再經過process_exception最後經過response,到達FetchFromCacheMiddleware


 


通過畫圖進行理解:

997599-20170113092526181-1706820293.png



二、信號

簡介

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等,而callback就是你要註冊的函數


如果我們把導入信號以及將註冊函數都寫到一個單獨的文件裏,爲了在程序啓動的時候執行信號中的註冊函數,可以在於項目同名的文件中的init文件中導入該文件即可


自定義信號


自定義信號一共需要三步驟:定義信號,註冊信號,觸發信號


定義信號


import django.dispatch
pizza_done=django.dispatch.Signal(providing_args=["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)


發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章