华人娱乐手机下载客户端

摘要:

“你也是个聪明人。”纪太虚呵呵笑道:“我的意思是,我有能力让你的寿元重新修炼回来。”...

清醒过来的风花小雪心里可是十分的后悔啊,她是后悔自己居然在自己的偶像面前留下了一个不好的印象,如果让刘皓知道风花小雪的想法不知道会不会说一句,追星族真的是什么世界都有,而且偶像的魅力真是大啊。

玖富娱乐92419住管

“难道这个世界上真的有人能将武功修炼到仙人般的地步?缩地成寸的身法,鬼神般的手段,除了传说中的仙人我实在是想不到。”丘处机惊叹一声,旋即想到了什么脸色大变:
“连女神都敢于拼命我们身为她的圣斗士怎么可以退缩!”其他圣斗士看了也纷纷被感染了,完全就是舍生忘死的燃烧自己的生命。

又有一青衣男子拦住去路,虽面露慈悲之相,下手却极为狠辣,他手中那棍子灵巧无比,三招两式便将悟空击倒在地。

中间件

前言

  之前我们给视图函数加装饰器来判断是用户是否登录,把没有登录的用户请求跳转到登录页面。我们通过给几个特定视图函数加装饰器实现了这个需求。但是以后添加的视图函数可能也需要加上装饰器,这样是不是稍微有点繁琐。

  中间件可以实现给所有请求做相同的操作,免去给每一个视图函数加装饰器的工作。

中间件介绍

什么是中间件

  官方说法:中间件是一个用来处理Django的请求和响应的框架级别的钩子。它是一个轻量、低级别的插件系统,用于在全局范围内改变Django的输入和输出。每个中间件组件都负责做一些特定的功能。

  说的真实点,其实中间件就是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作,它本质上就是一个自定义类,类中定义了几个办法,Django框架会在请求的特定的时间去执行这些方法。

  在Django中,其实我们一直都在使用中间件,在Django项目的settings.py文件中,有一项就是中间件的配置:

MIDDLEWARE

 

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",
]

  MIDDLEWARE配置项是一个列表,列表中是一个个字符串,这些字符串其实一个个类,也就是一个个中间件。

自定义中间件

  中间件可以定义五个方法,分别是:(主要的是process_request和process_response)

  1. process_request(self,request)
  2. process_view(self,request,view_func,view_args,view_kwargs)
  3. process_template_response(self,request,response)
  4. process_exception(self,request,exception)
  5. process_response(self,request,response)

  以上方法的返回值可以是None或一个HttpResponse对象,如果是None,则继续按照Django定义的规则向后继续执行,如果是HttpResponse对象,则直接将对象返回给用户。

自定义中间件示例

在项目下单独新建一个  my_middlewares.py  文件,专门放置自定义中间件。

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

process_request

  process_request 有一个参数,就是 request ,这个 request 和视图函数中的 request 是一样的。

  它的返回值可以是None,也可以是HttpResponse对象。返回值是None的话,按正常流程继续走,交给下一个中间件处理,如果是HttpResponse对象,Django将不执行视图函数,而将相应对象返回给浏览器。

  我们来看看多个中间件时,Django是如何执行其中的 process_request方法的。

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

在settings.py的MIDDLEWARE配置项中注册上述两个自定义中间件:

 

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",
    "middlewares.MD1",  # 自定义中间件MD1
    "middlewares.MD2"  # 自定义中间件MD2
]

 

此时,我们访问一个视图,会发现终端中打印如下内容:

 

 

MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图

 

把MD1和MD2的位置调换一下,再访问一个视图,会发现终端中打印的内容如下:

 

 

MD2里面的 process_request
MD1里面的 process_request
app01 中的 index视图

 

看结果我们知道:视图函数还是最后执行的,MD2比MD1先执行自己的process_request方法。

在打印一下两个自定义中间件中process_request方法中的request参数,会发现它们是同一个对象。

由此总结一下:

  1. 中间件的process_request方法是在执行视图函数之前执行的。
  2. 当配置多个中间件时,会按照MIDDLEWARE中的注册顺序,也就是列表的索引值,从前到后依次执行的。
  3. 不同中间件之间传递的request都是同一个对象

process_response

  它有两个参数,一个是request,一个是response,request就是上述例子中一样的对象,response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。

  给上述的M1和M2加上process_response方法:

 

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

 

访问一个视图,看一下终端的输出:

 

 

MD2里面的 process_request
MD1里面的 process_request
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response

 

看结果可知:

  process_response方法是在视图函数之后执行的,并且顺序是MD1比MD2先执行。(此时settings.py中 MD2比MD1先注册)

  多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的,也就是说第一个中间件的process_request方法首先执行,而它的process_response方法最后执行,最后一个中间件的process_request方法最后一个执行,它的process_response方法是最先执行。

process_view

 

process_view(self, request, view_func, view_args, view_kwargs)

 

该方法有四个参数

 

request是HttpRequest对象。

 

view_func是Django即将使用的视图函数。 (它是实际的函数对象,而不是函数的名称作为字符串。)

 

view_args是将传递给视图的位置参数的列表.

 

view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数(request)。

 

Django会在调用视图函数之前调用process_view方法。

 

它应该返回None或一个HttpResponse对象。 如果返回None,Django将继续处理这个请求,执行任何其他中间件的process_view方法,然后在执行相应的视图。 如果它返回一个HttpResponse对象,Django不会调用适当的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

 给MD1和MD2添加process_view方法:

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__)


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD2 中的process_view")
        print(view_func, view_func.__name__)

访问index视图函数,看一下输出结果:

 

 

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x000001DE68317488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x000001DE68317488> index
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response

 

process_view方法是在process_request之后,视图函数之前执行的,执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的。

process_exception

 

process_exception(self, request, exception)

该方法两个参数:

一个HttpRequest对象

一个exception是视图函数异常产生的Exception对象。

  这个方法只有在视图函数中出现异常了才执行,它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象,Django将调用模板和中间件中的process_response方法,并返回给浏览器,否则将默认处理异常。如果返回一个None,则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

 

 给MD1和MD2添加上这个方法:

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD1 中的process_exception")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD2 中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD2 中的process_exception")

如果视图函数中无异常,process_exception方法不执行。

想办法,在视图函数中抛出一个异常:

 

 

def index(request):
    print("app01 中的 index视图")
    raise ValueError("呵呵")
    return HttpResponse("O98K")

 

在MD1的process_exception中返回一个响应对象:

 

 

class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD1 中的process_exception")
        return HttpResponse(str(exception))  # 返回一个响应对象

 

看输出结果:

 

 

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x0000022C09727488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x0000022C09727488> index
app01 中的 index视图
呵呵
MD1 中的process_exception
MD1里面的 process_response
MD2里面的 process_response

 注意,这里并没有执行MD2的process_exception方法,因为MD1中的process_exception方法直接返回了一个响应对象。

process_template_response

 

process_template_response(self, request, response)

 

它的参数,一个HttpRequest对象,response是TemplateResponse对象(由视图函数或者中间件产生)。

 

process_template_response是在视图函数执行完成后立即执行,但是它有一个前提条件,那就是视图函数返回的对象有一个render()方法(或者表明该对象是一个TemplateResponse对象或等价方法)。

class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD1 中的process_exception")
        return HttpResponse(str(exception))

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


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD2 中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD2 中的process_exception")

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

views.py中:

 

 

def index(request):
    print("app01 中的 index视图")

    def render():
        print("in index/render")
        return HttpResponse("O98K")
    rep = HttpResponse("OK")
    rep.render = render
    return rep

 

访问index视图,终端输出的结果:

 

 

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x000001C111B97488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x000001C111B97488> index
app01 中的 index视图
MD1 中的process_template_response
MD2 中的process_template_response
in index/render
MD1里面的 process_response
MD2里面的 process_response

 

从结果看出:

视图函数执行完之后,立即执行了中间件的process_template_response方法,顺序是倒序,先执行MD1的,在执行MD2的,接着执行了视图函数返回的HttpResponse对象的render方法,返回了一个新的HttpResponse对象,接着执行中间件的process_response方法。

总结一下:

   1. process_request(self, request)
    - 视图函数执行之前(在urls.py找对应关系之前)
    - 注册顺序


   2. process_response(self, request, response)
    - 视图函数执行之后
    - 注册顺序的倒序  


   3. process_view(self, view_func, view_args, view_kwargs)
    - 视图函数执行之前(在urls.py中找到对应关系之后)
     此时view_func就是将要执行的视图函数对象!!!
    - 注册顺序


   4. process_exception(self, request, exception)
    - 视图函数执行之后,只有在有异常的时候才执行
    - 注册顺序的倒序
  
   5. process_template_response(self, request, response)
    - 视图函数执行之后,只有在响应对象有render方法的时候才执行
    - 注册顺序的倒序

编辑:密宗陵北

发布时间:2019-04-23 00:00:00

当前文章://20190326/9zx1d.html

天空与彩票同行与你同行 菲特娱乐在线注册开户 澳门美高梅官网网址 宝盈娱乐app 旋乐吧spin8娱乐在线开户 pt游戏客户端网址 bifa88 pt138com客户端下载 

发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。