Python学习---Django拾遗180328

Django之生命周期

前台发送URL请求到Django的中间件进行内容校验，完成校验后到达路由映射文件url.py，然后调用视图函数views.py里面的函数进行内容处理【 1.操作数据库进行数据读写  2. 调用前台的模版内容】最后返回字符串给前台进行页面的渲染【这里回去的时候也会经过中间件】。

Django之中间件

【更多参考】http://www.cnblogs.com/wupeiqi/articles/5246483.html

Django中间件类似于Java框架中的拦截器之类的东西，就是在请求到达我们要操作的函数之前添加的一些判断之类的操作。

应用场景： 适用于全局的操作，对所有的用户请求/用户返回数据都需要处理的情况。process_request适用于请求到达之前已经执行的操作，类似防护的操作[例如，csrf中间件，过滤器，自定义请求头]；

Django中间件即类中的方法执行顺序是Django固定的，不能更改执行顺序，函数名称也不能更改【如果自定义了MiddlewareMixin的话，可以不使用固定的名称】

注：这里的函数是不需要全部写的，也就是process_request和process_response可有可无

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

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)

中间件实例

创建中间件路径【文件夹+文件】

settings.py

INSTALLED_APPS = [
   ...
 'app01',   # 注册app
]
STATICFILES_DIRS = (os.path.join(BASE_DIR, "statics"),)  # 现添加的配置,这里是元组，注意逗号
TEMPLATES = [
   ...
   'DIRS': [os.path.join(BASE_DIR, 'templates')],
]
MIDDLEWARE = [
...
# 'django.middleware.csrf.CsrfViewMiddleware',
'plugin.handler.Handler',
'plugin.handler.Handler2',
'plugin.handler.Handler3',
]

urls.py

from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from app01 import views
urlpatterns = [
    url('test/', views.Test),
    url('test/(d+)/', views.Test1),
    # url('test/(?P<nid>d{3})/', views.Test2), # 效果同Test1，只不过nid的名称是固定，kv形式返回
]

views.py

from django.shortcuts import render, redirect, HttpResponse
from app01 import models
# 中间层操作
class Foo:
    def __init__(self, request, html):
        self.req = request
        self.html = html

    def render(self):
        return render(self.req, self.html)

def Test(request):
    print('views')
    return HttpResponse("OK")

def Test1(request,nid):
    print('views1')
    return HttpResponse("OK1")

def Test2(request, nid):
    print('views2')
    return HttpResponse("OK2")

# 测试process_template_response,这里不做细节演示
def Test4(request, nid):
    print('views2')
    return  Foo(request, 'test.html')

plugin/handler.py

# version: python3.2.5
# 中间件测试
# 新的中间件【复制的原类，为了规范起见，所有中间件继承于此】
# 另:继承了自定义的MiddlewareClass就可以自定义函数名了，不一定是process_request
class MiddlewareClass(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareClass, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            # 执行当前中间件的process_request
            response = self.process_request(request)
        if not response:
            # 执行下一个中间件的__call__()方法
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            # 执行当前中间件的process_response
            response = self.process_response(request, response)
        return response

from  django.utils.deprecation import MiddlewareMixin  # 原始的继承类
from django.shortcuts import HttpResponse
class Handler(MiddlewareClass):
    def process_request(self, request):
        print('A  --> process_request')
        # return HttpResponse("Handler的process_response结束了请求...")  #Django2.0.1中此方法会终止后面的中间件请求

    # 根据url.py里面的路由映射获取views.py里面的函数，函数参数
    # view_func: 函数名
    # view_args：参数名
    # view_kwargs： 如果参数名指定了列名，则key-value形式显示
    # 执行的时候会按照A->B->C的顺序依次执行中间件内容，完成后去执行process_exception
    def process_view(self, request, view_func, view_args, view_kwargs):
        print('A  --> process_view')

    # 这个函数只对views.py里面的报错进行处理，其他异常均不处理
    # 异常处理完成后返回到最后一个中间件process_response进行response处理
    def process_exception(self, request, exception):
        print('A  --> process_exception')

    def process_response(self, request, response):
        print('A  --> process_response')
        return response

    # views.py函数如果返回的是HttpResponse("OK1")，则这个函数并不做什么操作
    # views.py函数如果返回的是Render(request, 'index.html')，则这个函数也不做什么操作
    # views.py函数如果返回的对象new Obj()有Render方法，则这个函数会去render函数里面做操作
    def process_template_response(self, request, response):
        print('A  --> process_template_response')
        return response


class Handler2(MiddlewareClass):
    def process_request(self, request):
        print('B  --> process_request')

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('B  --> process_view')
        print('view_func:', view_func)
        print('view_args:', view_args)
        print('view_kwargs:', view_kwargs)

    def process_exception(self, request, exception):
        print('B  --> process_exception')

    def process_response(self, request, response):
        print('B  --> process_response')
        print("Response类型：", response)
        print("Response类型：", type(response))
        return response
    
    def process_template_response(self, request, response):
        print('B  --> process_template_response')
        return response

class Handler3(MiddlewareClass):
    def process_request(self, request):
        print('C  --> process_request')

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('C  --> process_view')

    def process_exception(self, request, exception):
        print('C  --> process_exception')

    def process_response(self, request, response):
        print('C  --> process_response')
        return response

    def process_template_response(self, request, response):
        print('C  --> process_template_response')
        return response

templates/XXX.html

    无

页面显示；

正常访问执行顺序：

中间件request请求中返回response效果：

另外其他的函数执行效果：

Django之CSRF[跨站请求伪造]

Django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。

@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注: from django.views.decorators.csrf import csrf_exempt,csrf_protect

settings.py里面如果未注释掉CSRF验证【即需要CSRF验证】

我们的get请求可以通过，post请求会被拦截

Django里面使用form的post请求发送数据的时候，一定是return了一个render对象，且HTML的form表单内使用了{% csrf_token %}进行标记，此时前台的HTML里面会多出一行csrf的token同时会缓存一份到Cookie里面。同理，如果我们需要ajax发送post请求的时候，是需要从Cookie里面获取token[从截图可以看到Cookie里面token的key是csrftoken]并添加到请求头[request-header]里让Django进行验证的。

Ajax请求CSRF实例

settings.py

INSTALLED_APPS = [
   ...
 'app01',   # 注册app
]
MIDDLEWARE = [
...
'django.middleware.csrf.CsrfViewMiddleware',
      ...
]

STATICFILES_DIRS = (os.path.join(BASE_DIR, "statics"),)  # 现添加的配置,这里是元组，注意逗号
TEMPLATES = [
   ...
   'DIRS': [os.path.join(BASE_DIR, 'templates')],
]

urls.py

from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from app01 import views
urlpatterns = [
    url('login/', views.Login),
]

views.py

from django.shortcuts import render, redirect, HttpResponse
from app01 import models
# SCRF测试
def Login(request):
    # 注意这里的settings是Django默认的
    # 我们看到的写入的settings.py文件会读入并覆盖conf里面的setting
    from django.conf import settings
    print('settings.CSRF_HEADER_NAME: ', settings.CSRF_HEADER_NAME)
    print(request.method)
    return render(request, 'login.html')

templates/login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <form action="/login/" method="post">
        {% csrf_token %}
        姓名：<input type="text" name="username">
        <input type="submit" value="Form提交">
        <input type="button" value="Ajax提交" id="btn">
    </form>
</body>
<script src="/static/jquery-2.1.4.min.js"></script>
<script src="/static/JQuery.Cookies.js"></script>
<script>
    $(function () {
        {# 这里对请求头做统一的处理，发送请求之前进行批量的配置 #}
         $.ajaxSetup({
            beforeSend: function(xhr) {
                    xhr.setRequestHeader("X-CSRFToken", $.cookie('csrftoken'));
            }
        });
        $("#btn").click(function () {
            $.ajax({
                url: '/login/',
                type:'POST',
             {# headers: {'X-CSRFTOKEN': 'hhh'},#}
             {#  headers: {'X-CSRFTOKEN': $.cookie('csrftoken')},  这里是自定义添加token#}
                data: {username: 'root'},
                success: function (args) {
                    console.log(args)
                }
            })
        })
    })
</script>
</html>

PS: 获取request里面的请求信息，可以使用断点打印，我们可以看出我们request里的header经过Django处理后在Meta里面呢，且字段名前添加了HTTP的前缀。

页面显示；

其他

Django之缓存

【更多参考】http://www.cnblogs.com/wupeiqi/articles/5246483.html

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

缓存适用于固定内容且访问量大，大型文件内容，不具有实时性的内容。

缓存方式及配置

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

开发调试 -->  什么都不干

内存

文件

数据库

Memcache缓存（python-memcached模块）   -->在另外一台服务器上

Memcache缓存（pylibmc模块）

配置：

开发调试

# 此为开始调试用，实际内部不做任何操作
    # 配置：
        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】）
            }
        }
注：memache帮我们生成key的时候，会以前缀+版本+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

内存：

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            'default': {
               'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
               'LOCATION': 'unique-snowflake',# 此参数就是标志唯一变量名称用于指引value可任意指定
            }
        }

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

文件:

# 此缓存将内容保存至文件
    # 配置：
        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模块）

Memcache可以理解为另外一个服务器的内存，是内存级别的缓存;

内容以Key-Value形式存储，整体的Memcache就是一个大字典

# 此缓存使用python-memcached模块连接memcache
# 3种连接方式
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': '127.0.0.1:11211',  # 根据IP和端口连接指定机器    
   }
    }
# 此方法只能连接本机信息
    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', 10),              # 连接多个服务器，类似分布式哈~
                ('172.19.26.242:11211', 15),              # 数据存储再多个服务器上...
          ('172.19.26.241:11211,’ 20),     # 设置了权重的连接,用户输入的key会计算hash值，返回一个int数字，后根据取余求算存储位置，根据权重确定服务器。加了权重后的，此时相当于10+15+20个服务器了，写入第三个服务器[有20个]的概率大
            ]
        }
    }

Memcache缓存（pylibmc模块）

# 此缓存使用pylibmc模块连接memcache
# 共3种连接方式
# 解释同上
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',
        ]
    }
}

注：memache中如果有服务器故障，因为memacahe里面没有检测机制，只能自己监控该模块，更改模块里面的接口方法处理

缓存应用

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

全栈使用缓存

单独视图缓存

局部视图使用

A. 全栈使用的配置

settings.py

MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    # 其他中间件...
    'django.middleware.cache.FetchFromCacheMiddleware',
]
CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

B.单独视图缓存

settings.py

方式一：
        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.局部视图缓存

Html文件内写

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

单独视图和局部视图实例

settings.py

INSTALLED_APPS = [
   ...
 'app01',   # 注册app
]
MIDDLEWARE = [
...
# 'django.middleware.csrf.CsrfViewMiddleware',
      ...
]

STATICFILES_DIRS = (os.path.join(BASE_DIR, "statics"),)  # 现添加的配置,这里是元组，注意逗号
TEMPLATES = [
   ...
   'DIRS': [os.path.join(BASE_DIR, 'templates')],
]
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': os.path.join(BASE_DIR, 'cache'),  # 指定文件路径，文件存放位置
    }
}

urls.py

from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from app01 import views
urlpatterns = [
   url('cache/', views.Cache),
 url('part/', views.Cache_part),
]

views.py

from django.shortcuts import render, redirect, HttpResponse
from app01 import models
# 文件缓存之单独视图[views]缓存    -->缓存整个页面及内容
from django.views.decorators.cache import cache_page
@cache_page(10)
def Cache(request):
    import time
    v = time.time()
    return HttpResponse(v)

# 文件缓存之局部视图缓存         -->缓存部分页面内容
def Cache_part(request):
    import time
    v = time.time()
    return render(request, 'part.html', {'v':v})

templates/part.html

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <h1>H1：{{ v }}</h1>
    {% cache 10  time %}
        <h5>H5:  {{ v }}</h5>
    {% endcache %}
</body>
</html>

页面显示；

文件缓存之单独视图缓存 ：

文件缓存之局部视图缓存 ：

全栈使用实例

settings.py

INSTALLED_APPS = [
   ...
 'app01',   # 注册app
]
MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
# 'django.middleware.csrf.CsrfViewMiddleware',
'django.middleware.cache.FetchFromCacheMiddleware',

]

STATICFILES_DIRS = (os.path.join(BASE_DIR, "statics"),)  # 现添加的配置,这里是元组，注意逗号
TEMPLATES = [
   ...
   'DIRS': [os.path.join(BASE_DIR, 'templates')],
]
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': os.path.join(BASE_DIR, 'cache'),  # 指定文件路径，文件存放位置
    }
}

其余同部分的单独的使用...

页面显示；

全栈中间件代码分析：

from django.middleware.cache import FetchFromCacheMiddleware

from django.middleware.cache import UpdateCacheMiddleware

 

Django之bootStrap

bootStrap 一个集成css，js的文件

【bootStrap参考】  http://v3.bootcss.com/getting-started/

 

【更多参考】http://www.cnblogs.com/wupeiqi/articles/5237704.html