Django cache, serialized signal

Django cache, serialized signal

A cache

Because Django is a dynamic website, all requests will go to each data corresponding operation, when the program access to large, time-consuming certainly more evident, the easiest solution is to use: cache, the cache will return a certain views value saved in memory or in memcache, and then when someone accesses, not again perform the operation in view within five minutes, but Redis from memory or cache content is brought directly before and returned.

Django provides six kinds of cache ways:

• Development and debugging
• RAM
• file
• database
• Memcache cache (python-memcached module)
• Memcache cache (pylibmc module)

1, the configuration

1. Development and debugging

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

   # 此缓存将内容保存至内存的变量中
       # 配置：
           CACHES = {
               'default': {
                   'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                   'LOCATION': 'unique-snowflake',
               }
           }
   
       # 注：其他配置同开发调试版本

   
   

3. file

   # 此缓存将内容保存至文件
       # 配置：
   
           CACHES = {
               'default': {
                   'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                   'LOCATION': '/var/tmp/django_cache',
               }
           }
       # 注：其他配置同开发调试版本

   
   

4. database

   # 此缓存将内容保存至数据库
   
       # 配置：
           CACHES = {
               'default': {
                   'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                   'LOCATION': 'my_cache_table', # 数据库表
               }
           }
   
       # 注：执行创建表命令 python manage.py createcachetable

   
   

5. Memcache cache (python-memcached module)

   # 此缓存使用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 cache (pylibmc module)

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

   
   

7. Redis cache (dependent: pip3 install django-redis)

   CACHES = {
       "default": {
           "BACKEND": "django_redis.cache.RedisCache",
           "LOCATION": "redis://127.0.0.1:6379",
           "OPTIONS": {
               "CLIENT_CLASS": "django_redis.client.DefaultClient",
               "CONNECTION_POOL_KWARGS": {"max_connections": 100}
               # "PASSWORD": "密码",
           }
       }
   }

   
   

   View and manipulate Link

   from django_redis import get_redis_connection
   conn = get_redis_connection("default")

   
   

2, application

1. Full stop using

   使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存
   
       MIDDLEWARE = [
           'django.middleware.cache.UpdateCacheMiddleware',
           # 其他中间件...
           'django.middleware.cache.FetchFromCacheMiddleware',
       ]
   
       CACHE_MIDDLEWARE_ALIAS = ""
       CACHE_MIDDLEWARE_SECONDS = ""
       CACHE_MIDDLEWARE_KEY_PREFIX = ""

   
   

2. Individual view cache

   方式一：
           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. Use partial view

   a. 引入TemplateTag
   
           {% load cache %}
   
       b. 使用缓存
   
           {% cache 5000 缓存key %}
               缓存内容
           {% endcache %}

   
   

Second, serialization

Serialization Django main application on a database in the retrieved data back to the client user, a special request is typically returned to Ajax Json format.

1、serializers

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

2、json.dumps

import json
 
#ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('caption')
 
ret=list(ret)
 
result = json.dumps(ret)

Can not be processed due date datetime json.dumps, the processor can be done by custom extensions, such as:

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

Third, the signal

Django provides a "signal scheduling", an operation is performed for decoupling frame. Popular terms, it is time some action occurs, signals allow specific senders to remind some of the recipients.

1, Django built-in signal

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          # 创建数据库连接时，自动触发

For Django built-in signal, only register designation signal, a corresponding operation when the program is executed, automatically trigger registration function:

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指上述导入的内容

# 方法二：
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

Note: After registration is complete signal should be placed in __init__ file

2, custom signal

1. Defined signal

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

   
   

2. Sign up signal

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

   
   

3. Trigger

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

   
   

   Because those who built the trigger signal has been integrated into Django, so it will automatically call, and for custom developers trigger signal is required at any location.