码迷，mamicode.com
首页 > 其他好文 > 详细

Django进阶篇（二）

时间：2016-08-31 12:01:06      阅读：244      评论：0      收藏：0      [点我收藏+]

标签：

中间件

　　解析

django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，

django会根据自己的规则在合适的时机执行中间件中相应的方法。

在django项目的settings模块中，有一个 MIDDLEWARE_CLASSES 变量，

其中每一个元素就是一个中间件，

MIDDLEWARE = [
    ‘django.middleware.security.SecurityMiddleware‘,
    ‘django.contrib.sessions.middleware.SessionMiddleware‘,
    ‘django.middleware.common.CommonMiddleware‘,
    # ‘django.middleware.csrf.CsrfViewMiddleware‘,  # 跨站请求伪造
    ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
    ‘django.contrib.messages.middleware.MessageMiddleware‘,
    ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
]

以上方法的返回值可以是None和HttpResonse对象，如果是None，则继续按照django定义的规则向下执行，

如果是HttpResonse对象，则直接将该对象返回给用户。

　　流程图

技术分享

上面的流程图可能有些乱，为了解流程花的草图；

技术分享

上面是Django 1.9版本的流程图，到django 1.10就变了；

变成了request在相对应的response中找。

技术分享

技术分享 
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.shortcuts import HttpResponse


class test1Middleware(object):

    def process_request(self, request):
        print(‘11111111‘)

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print(‘process_view1‘)

    def process_response(self, request, response):
        print(‘response 111111‘)
        return response

    def process_template_response(self, request, response):
        print(‘template1‘)

        return response

    def process_exception(self, request, exception):
        print(‘ex1‘)



class test2Middleware(object):

    def process_request(self, request):

        #if request.META[‘REMOTE_ADDR‘] in [‘1.1.1.1‘,‘1.1.1.2‘]:
        #    return HttpResponse(‘SB‘)
        # return HttpResponse(‘SB‘)
        print(‘22222‘)

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print(‘process_view2‘)

    def process_template_response(self, request, response):
        print(‘template2‘)

        return response
    def process_exception(self, request, exception):
        print(‘ex2‘)


class test3Middleware(object):

    def process_request(self, request):
        print(‘33333‘)

    def process_response(self, request, response):
        print(‘response 33333‘)
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print(‘process_view3‘)

    def process_template_response(self, request, response):
        print(‘template3‘)
        return response

    def process_exception(self, request, exception):
        print(‘ex3‘)
        return HttpResponse(‘500‘)
test.py

 

　　自定义中间件

1、创建中间件的类

class RequestExeute(object):
      
    def process_request(self,request):
        pass
    def process_view(self, request, callback, callback_args, callback_kwargs):
        i =1
        pass
    def process_exception(self, request, exception):
        pass
      
    def process_response(self, request, response):
        return response

2、注册中间件

MIDDLEWARE_CLASSES = (
    ‘django.contrib.sessions.middleware.SessionMiddleware‘,
    ‘django.middleware.common.CommonMiddleware‘,
    ‘django.middleware.csrf.CsrfViewMiddleware‘,
    ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
    ‘django.contrib.auth.middleware.SessionAuthenticationMiddleware‘,
    ‘django.contrib.messages.middleware.MessageMiddleware‘,
    ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
    ‘wupeiqi.middleware.auth.RequestExeute‘,
)

　　

缓存

　　解析

由于Django是动态网站，一般来说需要实时地生成访问的网页，展示给访问者，这样内容可以随时变化，

但是从数据库读多次把所需要的数据取出来，要比从内存或者硬盘中读出来 付出的成本大很多。

最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者Redis中，一定时间内再有人来访问时，

则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供6种缓存方式：

　　开发调试

　　内存

　　文件

　　数据库

　　Memcache缓存（python-memcached模块）

　　Memcache缓存（pylibmc模块）

　　配置

a、开发调试

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

b、内存

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            ‘default‘: {
                ‘BACKEND‘: ‘django.core.cache.backends.locmem.LocMemCache‘,
                ‘LOCATION‘: ‘unique-snowflake‘,
            }
        }

    # 注：其他配置同开发调试版本

c、文件

# 此缓存将内容保存至文件
    # 配置：

        CACHES = {
            ‘default‘: {
                ‘BACKEND‘: ‘django.core.cache.backends.filebased.FileBasedCache‘,
                ‘LOCATION‘: ‘/var/tmp/django_cache‘,
            }
        }
    # 注：其他配置同开发调试版本

d、数据库

# 此缓存将内容保存至数据库

    # 配置：
        CACHES = {
            ‘default‘: {
                ‘BACKEND‘: ‘django.core.cache.backends.db.DatabaseCache‘,
                ‘LOCATION‘: ‘my_cache_table‘, # 数据库表
            }
        }

    # 注：执行创建表命令 python manage.py createcachetable

e、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‘,
            ]
        }
    }

f、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‘,
            ]
        }
    }

　　应用　

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):
            ...

    方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r‘^foo/([0-9]{1,2})/$‘, cache_page(60 * 15)(my_view)),
        ]

　　示例：

技术分享 
from django.shortcuts import render,HttpResponse,HttpResponseRedirect
import time
# from django_nanian import pizza_done
from django.views.decorators.cache import cache_page


class Response:
    def __init__(self, request, html, *args, **kwargs):
        self.request = request
        self.args = args
        self.html = html
        self.kwargs = kwargs

    def render(self, *args, **kwargs):
        return render(self.request, self.html, *self.args, **self.kwargs)
# Create your views here.


def index(request):
    print(‘views‘)
    return Response(request, ‘index.html‘)


@cache_page(10)  # 使用装饰器进行局部缓存,生效时间十秒
def cache1(request, page):
    t = time.time()
    return render(request, ‘cache.html‘, {‘t‘: t})


def cache2(request):
    t = time.time()
    # pizza_done.send(sender=‘cache2‘, toppings=1, size=3)
    return render(request, ‘cache.html‘, {‘t‘: t})
Views.py
技术分享 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {{ t }}
</body>
</html>
cache.html

c、局部模板使用

在前端页面

a. 引入TemplateTag

        {% load cache %}

b. 使用缓存

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

　　示例：

技术分享 
def cache3(request):  # 局部视图缓存
    print(type(request))
    t = time.time()
    from app01 import models
    print(‘before‘)
    # models.UserInfo.objects.create(name=‘test‘)
    print(‘after‘)
    # pizza_done.send(sender=‘cache3‘, toppings=123, size=456)
    return render(request, ‘cache3.html‘, {‘t‘: t})
Views.py
技术分享 
{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {{ t }}
    <hr />
     {% cache 10 nnn %}  {# 缓存十秒 #}
         {{ t }}
     {% endcache %}

</body>
</html>
cache3.html

 

信号

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

from django.core.signals import request_finished
from django.dispatch import receiver

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

　　自定义信号

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中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。

 

上传文件

技术分享upload.html
技术分享 
from django.shortcuts import render,HttpResponse

# Create your views here.


def upload_file(request):
    if request.method == "POST":  # 以POST 的方式
        file_name = request.FILES
        file_obj = file_name.get("file_name_1")  # 获取到封装了文件操作的对象
        f = open(file_obj.name, "wb")
        for line in file_obj.chunks():   # 循环取数据
            f.write(line)
        f.close()
        return HttpResponse("上传成功")
    else:
        return render(request, "upload.html")
Views.py

 

序列化

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。

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)

由于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)

　　

更多详见：http://www.cnblogs.com/wupeiqi/articles/5246483.html

Django进阶篇（二）

标签：

原文地址：http://www.cnblogs.com/kongqi816-boke/p/5816155.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！