Djanjo中级篇（下）

中间件

django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。

MIDDLEWARE_CLASSES = [
    # ‘ZHONGJIANJIAN.text.text1Middleware‘,   #自定义中间件
    ‘django.middleware.security.SecurityMiddleware‘,
    ‘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‘,
]

中间件中可以定义四个方法，分别是：

process_request(self,request)
process_view(self, request, callback, callback_args, callback_kwargs)
process_template_response(self,request,response)
process_exception(self, request, exception)
process_response(self, request, response)

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

djanjo 中间件版本差异报错处理：

1.9.x版本以下djanjo中间件定义规则

class CommonMiddleware(object):
    def process_request(self, request):
        return None

    def process_response(self, request, response):
        return response

最新的1.10.x版本djanjo中间件定义规则----------不是执行的类下的方法，而是执行MiddlewareMixin对象的__call__方法（方法中调用，process_request等方法）

from djanjo.utils.deprecation import MiddlewareMixin
class CommonMiddleware(MiddlewareMixin):
    def process_request(self, request):
        return None

    def process_response(self, request, response):
        return response

下面的方法就可以让 中间件 兼容 Django新版本和旧版本------------上面俩种的合并

__call__ 方法会先调用 self.process_request(request)，接着执行 self.get_response(request) 然后调用 self.process_response(request, response)

try:
    from django.utils.deprecation import MiddlewareMixin  # Django 1.10.x
except ImportError:
    MiddlewareMixin = object  # Django 1.4.x - Django 1.9.x

class SimpleMiddleware(MiddlewareMixin):
    def process_request(self, request):
        pass

    def process_response(request, response):
        pass

新版本中 django.utils.deprecation.MiddlewareMixin 的 源代码 如下：

class MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareMixin, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, ‘process_request‘):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, ‘process_response‘):
            response = self.process_response(request, response)
        return response

功效：

比如我们要做一个 拦截器，比如统计一分钟访问页面数，太多就把他的 IP 加入到黑名单 BLOCKED_IPS，发现有恶意访问网站的人，就拦截他！

class BlockedIpMiddleware(object):
    def process_request(self, request):
        if request.META[‘REMOTE_ADDR‘] in getattr(settings, "BLOCKED_IPS", []):
            return http.HttpResponseForbidden(‘<h1>Forbidden</h1>‘)

中间件生命周期（1.9.x版本以下）：

1>正常情况（有俩个中间件的情况）

process_request1---->process_request2---->process_view1------process_view2----->url---->views---> process_response2----->process_response1

2>在任意一个process_request中只要有return直接跳到process_response

process_request1---->process_request2----> process_response2----->process_response1

3>如果返回值中有render的话走process_template_response

process_request1---->process_request2---->process_view1------process_view2----->url---->views--->process_template_response2---->

process_template_response1--->process_response2----->process_response1

4>views中出现错误的时候走process_exceptionprocess_response

process_request1---->process_request2---->process_view1--->process_view2----->url---->views---> process_exceptionprocess_response2--->

process_exceptionprocess_response1

自定义中间件

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的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回

Django中提供了6种缓存方式：

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

1、配置

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

Memcache缓存（python-memcached模块）

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

Memcache缓存（pylibmc模块）

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

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

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

c、局部视图使用

    a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

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

局部

信号

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

对于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!")

----注册的时候我们可以给上面的代码放到我们创建的project下的__init__.py文件中（或新建一.py文件，最后在__init__中导入）就注册成功了

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中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的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)  

# ds = json.dumps(d, cls=JsonCustomEncoder)

分页

一、Django内置分页

Paginator

二、自定义分页

分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置。

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

4、在数据表中根据起始位置取值，页面上输出数据


需求又来了，需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、设定显示多少页号

4、获取当前数据总条数

5、根据设定显示多少页号和数据总条数计算出，总页数

6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

7、在数据表中根据起始位置取值，页面上输出数据

8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.utils.safestring import mark_safe

class PageInfo(object):
    def __init__(self,current,totalItem,peritems=5):
        self.__current=current
        self.__peritems=peritems
        self.__totalItem=totalItem
    def From(self):
        return (self.__current-1)*self.__peritems
    def To(self):
        return self.__current*self.__peritems
    def TotalPage(self):  #总页数
        result=divmod(self.__totalItem,self.__peritems)
        if result[1]==0:
            return result[0]
        else:
            return result[0]+1

def Custompager(baseurl,currentPage,totalpage):  #基础页，当前页，总页数
    perPager=11
    #总页数<11
    #0 -- totalpage
    #总页数>11
        #当前页大于5 currentPage-5 -- currentPage+5
            #currentPage+5是否超过总页数,超过总页数，end就是总页数
        #当前页小于5 0 -- 11
    begin=0
    end=0
    if totalpage <= 11:
        begin=0
        end=totalpage
    else:
        if currentPage>5:
            begin=currentPage-5
            end=currentPage+5
            if end > totalpage:
                end=totalpage
        else:
            begin=0
            end=11
    pager_list=[]
    if currentPage<=1:
        first="<a href=‘‘>首页</a>"
    else:
        first="<a href=‘%s%d‘>首页</a>" % (baseurl,1)
    pager_list.append(first)

    if currentPage<=1:
        prev="<a href=‘‘>上一页</a>"
    else:
        prev="<a href=‘%s%d‘>上一页</a>" % (baseurl,currentPage-1)
    pager_list.append(prev)

    for i in range(begin+1,end+1):
        if i == currentPage:
            temp="<a href=‘%s%d‘ class=‘selected‘>%d</a>" % (baseurl,i,i)
        else:
            temp="<a href=‘%s%d‘>%d</a>" % (baseurl,i,i)
        pager_list.append(temp)
    if currentPage>=totalpage:
        next="<a href=‘#‘>下一页</a>"
    else:
        next="<a href=‘%s%d‘>下一页</a>" % (baseurl,currentPage+1)
    pager_list.append(next)
    if currentPage>=totalpage:
        last="<a href=‘‘>末页</a>"
    else:
        last="<a href=‘%s%d‘>末页</a>" % (baseurl,totalpage)
    pager_list.append(last)
    result=‘‘.join(pager_list)
    return mark_safe(result)   #把字符串转成html语言

分页

总结，分页时需要做三件事：

  • 创建处理分页数据的类
  • 根据分页数据获取数据
  • 输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］

文件上传

a、自定义上传

def upload_file(request):
    if request.method == "POST":
        obj = request.FILES.get(‘fafafa‘)
        f = open(obj.name, ‘wb‘)
        for chunk in obj.chunks():
            f.write(chunk)
        f.close()
    return render(request, ‘file.html‘)

b、Form上传文件实例

class FileForm(forms.Form):
    ExcelFile = forms.FileField()

from django.db import models

class UploadFile(models.Model):
    userid = models.CharField(max_length = 30)
    file = models.FileField(upload_to = ‘./upload/‘)
    date = models.DateTimeField(auto_now_add=True)

def UploadFile(request):
    uf = AssetForm.FileForm(request.POST,request.FILES)
    if uf.is_valid():
            upload = models.UploadFile()
            upload.userid = 1
            upload.file = uf.cleaned_data[‘ExcelFile‘]
            upload.save()

            print upload.file

时间： 2024-08-24 05:39:01

Djanjo中级篇（下）的相关文章

Djanjo中级篇之模板语言

模板 一.引用变量 模版的创建过程,对于模版,其实就是读取模版(其中嵌套着模版标签),然后将 Model 中获取的数据插入到模版中,最后将信息返回给用户. {{ xxx }} 二.标签 用{%  %}表示,用于处理一些逻辑 常用的几个标签 {% if 条件 %} 内容 {% endif %} {% for xxx in 条件 %} {{xxx}} {% endfor %} 1.for标签 1>每一次循环中,模板系统会渲染在 {% for %} 和 {% endfor %} 之间的所有内容 2>

Djanjo中级篇

ORM 就是用面向对象的方式去操作数据库的创建表以及增删改查等操作 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetList(sql): db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')

白话Spring（中级篇）---拦截器（下）

[一知半解,就是给自己挖坑] 上文我们介绍了Spring中过滤器的基本用法,本文我们来介绍多个拦截器的执行情况,另外一种拦截器的实现方式,以及拦截器与java过滤器的区别.特别的,在本文中,我们将不在演示具体的拦截的实例,请读者们参照上文的实现以及配置方式自行实现. --------------------------------------------------------------------------------------------------------------------

Farseer.net轻量级开源框架 中级篇：数据库切换

导航 目   录:Farseer.net轻量级开源框架 目录 上一篇:Farseer.net轻量级开源框架 中级篇: 动态数据库访问 下一篇:Farseer.net轻量级开源框架 中级篇: SQL执行报告 上文中讲述了,在项目运行过程中,如何通过代码动态改变数据库的访问,这种方式更加倾向于实体类相同,有多个相同的表结构. 本篇中讲述的是,如何快速切换不同的数据库.比如你现在使用在使用SqlServer 哪天数据库老板心血来潮,让你换成Oracle了,怎么办? 这种数据库的切换在ORM中能明显突出

Android中级篇之百度地图SDK v3.5.0-一步一步带你仿各大主流APP地图定位移动选址功能

定位+移动选址 百学须先立志-学前须知: 我们经常在各大主流APP上要求被写上地址,如百度外卖.爱鲜蜂收货地址等等:其中他们大多数是可以让我们在地图上移动选址.就如下面这段GIF演示的一样: 尽信书,不如无书-能学到什么? 1.地图状态MapStatus类及监听setOnMapStatusChangeListener 2.定位LocationClient类 3.反地理编码GeoCoder类 工欲善其事必先利其器-申请Key 百度地图访问应用(AK)申请地址:http://lbsyun.baidu

Farseer.net轻量级开源框架 中级篇：动态数据库访问

导航 目   录:Farseer.net轻量级开源框架 目录 上一篇:Farseer.net轻量级开源框架 中级篇: 自定义配置文件 下一篇:Farseer.net轻量级开源框架 中级篇: 数据库切换 说到动态数据库的访问,不得不说的是,我们的实体类,是如何找到数据库配置并访问的呢? 回顾下我们的Users类: 1 [DB(Name = "Members_User")] 2 public class Users : BaseModel<Users>; 这里有个DB的特性,其

Canvas画图之中级篇

前段时间介绍了canvas画图的初级篇,今天接着介绍中级篇了... 一．绘制形状 绘制图形不仅仅是利用线条来实现绘图, 还可以有快捷的绘制图形的办法 1.绘制矩形 2.绘制圆弧 1 绘制矩形 绘制矩形的方法 CanvasRenderingContext2D.strokeRect CanvasRenderingContext2D.fillRect CanvasRenderingContext2D.rect 注意: rect 方法就是矩形路径, 还需要使用 fill 或 stroke 才可以看到效果

Entity Framework学习中级篇

1-EF支持复杂类型的实现 本节,将介绍如何手动构造复杂类型(ComplexType)以及复杂类型的简单操作. 通常,复杂类型是指那些由几个简单的类型组合而成的类型.比如:一张Customer表,其中有FristName和LastName字段,那么对应的Customer实体类将会有FristName和LastName这两个属性.当我们想把FirstName和LastName合成一个名为CustomerName属性时,此时,如果要在EF中实现这个目的,那么我们就需要用到复杂类型. 目前,由于EF不

第8章 三路由不同网段互通实验（中级篇）

第8章三路由不同网段互通实验( 中级篇) 一实验目的 学习如何给路由器接口配置网关.子网掩码 学习如何给路由器配置静态路由 学习如何在路由器上配置环回口 二实验工具 GNS3软件   http://yunpan.cn/cwkDa4MWJwiiV  访问密码 9b1a 思科IOS     http://yunpan.cn/cjDjwg4CXMxpw  访问密码 9c14 三实验描述 需要实现当192.168.20.0/24访问192.168.30.0/24网段时,数据是从R2到R3. 当192.1