django 知识概括 （三）

什么时候用一对一？

　　当 一张表的某一些字段查询的比较频繁，另外一些字段查询的不是特别频繁
　　把不怎么常用的字段 单独拿出来做成一张表 然后用过一对一关联起来

　　OneToOneField(to="")

 

Django中内置了一个专门处理csrf问题的中间件

django.middleware.csrf.CsrfViewMiddleware

这个中间件做的事情：

在render返回页面的时候，在页面中塞了一个隐藏的input标签

我们在页面上 form表单 里面 写上 {% csrf_token %}

在django中装饰器的用法

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from functools import wraps
# Django提供的工具，把函数装饰器转变成方法装饰器
from django.utils.decorators import method_decorator


def check_login(func):
    @wraps(func)  # 装饰器修复技术
    def inner(request, *args, **kwargs):
        ret = request.session.get("is_login")
        # 1. 获取cookie中的随机字符串
        # 2. 根据随机字符串去数据库取 session_data --> 解密 --> 反序列化成字典
        # 3. 在字典里面 根据 is_login 取具体的数据
        if ret == "1":
            # 已经登陆过的 继续执行
            return func(request, *args, **kwargs)
        # 没有登录过的 跳转到登录页面
        else:
            # 获取当前访问的URL
            next_url = request.path_info
            print(next_url)
            return redirect("/app02/login/?next={}".format(next_url))
    return inner

　　

　

登录时免除csrftoken 验证

@csrf_exempt
def login(request):

　　

在函数和类视图中加装饰器

# @method_decorator(check_login, name="get")
class UserInfo(views.View):

    @method_decorator(check_login)
    def get(self, request):
        return render(request, "app02/userinfo.html")

def logout(request):
    # 只删除session数据
    # request.session.delete()
    # 如何删除session数据和cookie
    request.session.flush()
    return redirect("/app02/login/")

　　

ajax发送请求

$.ajax({
            url: "/test/",
            type: "post",
            dataType: "json",
            traditional: true,
            data: {"name": "小黑", "sb":[1,2,3]},
            success: function (data) {
                // 把后端返回的数据反序列化成JS中的对象
                // var data = JSON.parse(data);
                if (data.status === 0){
                    // 这次请求成功
                    alert(data.data);
                }else {
                    // 请求出错
                    alert(data.error);
                }
            }
        })
    });

　　

　　

中间键

中间件的使用：
    5个固定的方法
        process_request(self, request)
            执行顺序：
                按照注册的顺序（在settings.py里面设置中 从上到下的顺序）
            何时执行：
                请求从wsgi拿到之后
            返回值：
                返回None，继续执行后续的中间件的process_request方法
                返回response , 不执行后续的中间件的process_request方法
                
        process_response
            执行顺序：
                按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
            何时执行：
                请求有响应的时候
            返回值：
                必须返回一个response对象
                
        process_view(self, request, view_func, view_args, view_kwargs):
            执行顺序：
                按照注册的顺序（在settings.py里面设置中 从上到下的顺序）
            何时执行：
                在urls.py中找到对应关系之后 在执行真正的视图函数之前
            返回值：
                返回None，继续执行后续的中间件的process_view方法
                返回response,
                
                
        process_exception(self, request, exception)
            执行顺序：
                按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
            何时执行：
                视图函数中抛出异常的时候才执行
            返回值：
                返回None,继续执行后续中间件的process_exception
                返回response，
                
                
                
        process_template_response(self, request, response)
            执行顺序：
                按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
            何时执行：
                视图函数执行完，在执行视图函数返回的响应对象的render方法之前 
            返回值：
                返回None,继续执行后续中间件的process_exception
                返回response，


    Django调用 注册的中间件里面五个方法的顺序：
        1. process_request
            urls.py
        2. process_view
            view
        3. 有异常就执行 process_exception
        4. 如果视图函数返回的响应对象有render方法,就执行process_template_response
        5. process_response

　

class OoXx(MiddlewareMixin):

    def process_request(self, request):
        print("这是我的第一个中间件：OoXx！")
        print(id(request))
        # print(request.path_info)
        # # 如果用户访问的URL 在 白名单里面
        # if request.path_info in URL:
        #     return
        # # 否则 直接返回一个 响应 不走视图那部分了
        # else:
        #     return HttpResponse("gun!")

    def process_response(self, request, response):
        """
        :param request: 是浏览器发来的请求对象
        :param response: 是视图函数返回的响应对象
        :return:
        """
        print("这是OOXX中间件里面的 process_response")
        # return response
        return HttpResponse("hahahaha")

    def process_view(self, request, view_func, view_args, view_kwargs):
        """

        :param request: 浏览器发来的请求对象
        :param view_func: 将要执行的视图函数的名字
        :param view_args: 将要执行的视图函数的位置参数
        :param view_kwargs: 将要执行的视图函数的关键字参数
        :return:
        """
        print("ooxx里面的process_view")
        print(view_func, type(view_func))
        return HttpResponse("ooxx：process_view")


    def process_exception(self, request, exception):
        print(exception)
        print("ooxx里面的process_exception")
        return redirect("http://www.luffycity.com")

    def process_template_response(self, request, response):
        print("ooxx 中的process_template_response")
        return response

　　

importlib 使用

　　根据字符串导入模 ，通畅用来导入包下面的模块

 

o = importlib.import_module("xx.oo") 
s2 = "Person"