django的其他细节

一，django的一个生命周期

　　客户端发起请求，到达url路由分配文件，找到对应的view视图文件，同时去数据库取对应的数据，去渲染对应的view文件后返回给客户端。

图示：

二，中间件

　　1，定义

　　中间件实质就是一个类，类相当于一个管道，类里有多种方法，这些方法就行入口。

　　2，特点：这些中间件是针对全部url的

　　2，作用

　　有过滤的作用，请求会先经过管道的筛选，在到达url路由的分配文件。管道是重重筛选的。

3，中间件排放顺序是根据SETTING....设置为准的。

from django.utils.deprecation import MiddlewareMinin

class HXL(MiddlewareMixin):
    def process_request(self,request):
        print("hxl_process_request")
    def process_response(self,request,response):
        print("hxl_process_response")
        return response

class gyc(MiddlewareMixin):
    def process_request(self,request):
        print("gyc_process_request")
    def process_response(self,request,response):
        print("gyc_process_response")
        return response

#输出
#hxl_process_request
#gyc_process_request
views#html的内容
#gyc_process_response
#hxl_process_response

4，其他方法的执行顺序：

　　中间件的方法执行顺序
　　1，依次执行每一个process_request
　　2，依次执行每一个process_view
　　3,执行视图函数views
　　4，如果有process_template_response执行，执行顺序是就近原则

class Foo:
    def __init__(self,request,html):
        self.req=request
        self.html=html
    def render(self):
        return render(self.req,self.html)

//views视图处理函数
def test(request,nid):
    print('views')
    return Foo(request,'test.html')

　　5，有异常(注意：这里仅对views视图函数的异常才处理)在执行异常process_exception，执行顺序是就近原则，遇到一个异常返回，余下的异常就不处理了，直接跳到下一部。
　　6，最后用就近原则执行process_response

5，原码：

建议自己写一个自己继承。

#中间件的源代码
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_requsert'):
            #执行当前的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_reponse(request,reponse)
        return reponse

参考： www.cnblogs.com/wupeiqi/articles/5237704.html

二.CSRF跨域跨站请求

一、简介

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

1，get不存在这种情况。

2，post才会出现跨域跨站请求

（1）Form表单

{csrf_token} 在表单传输时多添加一行

（2）Ajax传输

a，直接在Ajax方法里添加

header：{“x-CSRFToken”:$.cookies('csrftoken')}

//请求头的信息：'HTTP_X_CSRFToken':'内容'

b，更新配置方法。

<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}
  
    <input type="button" onclick="Do();"  value="Do it"/>
  
    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');
  
        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){
  
            $.ajax({
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });
  
        }
    </script>
</body>
</html>

（3）局部设置的两个装饰器：

　　1，@csrf_protect：局部设置csrf

@csrf_protect
def login(request):
    pass


@csrf_exempt
def login(request):
    pass

　　2,@csrf_exempt:这个不设置csrf.

参考： 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】）
            }
        }


    # 自定义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',
            }
        }

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

数据库

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

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

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

1，定义：对视图进行渲染后的结果，放到一个地方，避免数据库重复操作；可以以文件，内存，数据库的形式保存，可以放在一台电脑或多台电脑上。

放在多台设备上时会写对应的IP1(10),IP2(60)后面添加参数来指定，缓存的比例

Memorycache

# 此缓存使用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'，10）,
                （'172.19.26.242:11211'，200）,
            ]
        }
    }

2，存放形式：键值对。键：‘KEY_PREFIX’:key的前缀，默认为空；'VERSION'：缓存key的版本，默认为1；

'KEY_function':生成key的函数，默认生成【前缀：版本：key】

3，全局设置缓存：

　　用中间件设置，要两个中间件，一个放在最前面：用来更新缓存的数据；一个放在最后：用来拿缓存数据。

4，对某个页面设置缓存。

@cache_page(10) #参数是设置跟新缓存的时间。

@cache_page(10)
def cache(request):
    import time
    v=time.time()
    return HttpResponse(v)

5，页面局部刷新

{% loaded cache %}
<body>
    <h1>{{v}}</h1>
    {% cache  10 kkkk %}
    <h3>{{  v}}</h3>//局部缓存设置，10秒
{% endcache%}
</body>

四，信号

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、自定义信号

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预留的钩子。

——内置信号：

A.指定信号中注入函数

——自定义信号：

A.创建信号

B.指定信号中注入函数

C.触发函数

参考： www.cnblogs.com/wupeiqi/articles/5246483.html

五.bootstrapt

应用时直接在官网上查询： v3.bootcss.com/complement/