自动化运维Python系列之Django信号缓存操作

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了自动化运维Python系列之Django信号缓存操作相关的知识，希望对你有一定的参考价值。

Django信号

Django内部提供了一种“信号强度”处理机制，简单理解就是当Django在接收到请求后内部做某些特定操作前发出信号，提醒一些接受者或者做操作，这样的好处就是方便程序定制小功能插件，也是对本身框架的一种节藕操作

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

2）信号使用

Django信号的使用只需要导入我们需要的相信模块就行，我们以一个数据库保存即触发信号为例

URL新建一个测试页面

urlpatterns = [
    url(r‘^signal/$‘, views.signal),
]

app同级目录新建sg.py文件

// 使用前需要导入我们需要的模块
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 f1(sender, **kwargs):
        print("signal_callback")
 
// 注册信号
pre_save.connect(f1)

views视图函数

// 测试前准备好连接数据库
from app01 import models
// views函数
def signal(reuqest):
  
    obj = models.UserInf(user=‘root‘)
    print(‘has create a data...‘)
    obj.save()
  
    obj = models.UserInf(user=‘root‘)
    obj.save()
 
    return HttpResponse(‘ok‘)

这里Django替我们执行了三次信号函数

技术分享

自定义信号

如果觉得Django内部为我们提供的内置信号函数不能满足我们的开发需求，我们还可以自定义信号

1）在sg文件里面

// 定义信号
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)

2）在views视图文件

from sg import pizza_done
  
def signal(reuqest):
  
    obj = models.UserInf(user=‘root‘)
    obj.save()
    // 触发信号
    pizza_done.send(sender="asdfasdf",toppings=123, size=456)
  
    return HttpResponse(‘ok‘)

3）执行结果

技术分享

 

缓存

Django程序在面对大量访问时，如果涉及到数据库操作，必将会增加数据库负担，查询速度收影响严重；最简单的解决办法就是使用缓存，缓存将某个views的返回值保存在内存或者memcache中，5分钟内如果再有人来访问，则不去执行views操作，而是直接从缓存中取并给用户返回数据

Django内部提供了6种缓存方式

// 开发调试
// 内存
// 文件
// 数据库
// Memcache缓存（python-memcached模块）
// Memcache缓存（pylibmc模块）

我们以文件为缓存介质来测试下Django的缓存使用方法

1）新建URL

urlpatterns = [
    url(r‘^cache/$‘, views.cache),
]

2）setting设置cache

CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.filebased.FileBasedCache‘,
        // 设置文件存放位置
        ‘LOCATION‘: os.path.join(BASE_DIR,‘cache‘)
    }
}

3）views视图函数

def cache(request):
    import time
    ctime = time.time()
    return render(request, ‘cache.html‘, {‘ctime‘: ctime})

4）模版文件中引用

{% load cache %}
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>
     
    // 定义缓存时间为10秒钟
     {% cache 10 c1 %}
        <h1>{{ ctime }}</h1>
     {% endcache %}
</body>

5）给特定views函数加缓存装饰器

// 缓存装饰器
@cache_page(10)
def cache(request):
    import time
    ctime = time.time()
    return render(request, ‘cache.html‘, {‘ctime‘: ctime})

页面结果

技术分享

其他缓存配置

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）数据库

// 注意要执行 python manager.py makemigrations
//           python manager/py migrate
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.db.DatabaseCache‘,
        ‘LOCATION‘: ‘my_cache_table‘, # 数据库表
    }
}

4）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‘,
            ]
        }
    }

5）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‘,
        ]
    }
}

缓存全局应用

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



本文出自 “改变从每一天开始” 博客，请务必保留此出处http://lilongzi.blog.51cto.com/5519072/1906557

以上是关于自动化运维Python系列之Django信号缓存操作的主要内容，如果未能解决你的问题，请参考以下文章

自动化运维Python系列之Django路由系统Ajax请求

自动化运维Python系列之Django CSRF跨站请求伪造中间件

自动化运维Python系列之MemcacheRedis操作

python运维开发(二十)----models操作中间件缓存信号分页

Python自动化运维：Django之URL路由

Python自动化运维：Django之View视图和Template