# WSGI(是一套协议，很多东西比如wsgiref, uwsgiref遵循这一套协议）

    - django系统本质

        别人的socket（wsgiref或者uwsgiref) + django

    - 简单定义

        WSGI（Web Server Gateway Interface）是一种规范，它定义了使用python编写的web app与web server之间接口格式，

        实现web app与web server间的解耦。

    - 更完整的web请求生命周期

        request --> 遵循wsgi的socket服务器(wsgiref)--->django的中间件--->路由系统--->视图函数

        视图函数--->路由系统--->中间件--->wsgi--->客户端

    - django借用的wsgiref服务器的样例

        from wsgiref.simple_server import make_server

        def RunServer(environ, start_response):

            """

                @params: environ 请求的相关信息

                @params: start_response容器，将里面的内容作为消息头返回给用户

                @return  返回的内容作为消息体返回给用户

            """

            start_response('200 OK', [('Content-Type', 'text/html')])

            return [bytes('<h1>Hello, web!</h1>', encoding='utf-8'), ]

        if __name__ == '__main__':

            httpd = make_server('', 8000, RunServer)

            httpd.serve_forever()

            # 等待客服端的socket请求，当请求过来时，执行RunServer函数

    - 一个简单的socket服务器

        import socket

        def handle_request(client):

            buf = client.recv(1024)

            client.send("HTTP/1.1 200 OK\r\n\r\n")

            client.send("Hello, Seven")

        def main():

            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            sock.bind(('localhost',8000))

            sock.listen(5)

            while True:

                connection, address = sock.accept()

                handle_request(connection)

                connection.close()

        if __name__ == '__main__':

            main()

   - django一个请求的生命周期

        简单来说就是： wsgi 和django

        客户端-->request--->wsgi--->所有中间件（middleware的process_request)--->process_view---->views

        views--->urls--->所有中间件(middleware的process_response)--->wsgi--->客户端

        ps: 在中间件的process_request已经知道要执行哪个视图函数了（根据request已经获取url，根据url获取对应视图函数）

# 中间件

    - django一个请求的生命周期

        简单来说就是： wsgi 和django

        客户端-->request--->wsgi--->所有中间件（middleware的process_request)--->process_view---->views

        views--->urls--->所有中间件(middleware的process_response)--->wsgi--->客户端

        ps: 在中间件的process_request已经知道要执行哪个视图函数了（根据request已经获取url，根据url获取对应视图函数）

    - 自己定义中间件Class MyMiddle（中间件是一个类）

        from django.utils.deprecation import MiddlewareMixin

        from django.shortcuts import render,HttpResponse

        class MyMiddle1(MiddlewareMixin):

            def process_request(self, request):

                print('m1.process.request')

            def process_view(self, request,callback, callback_args, callback_kwargs):

                print('m1.process_view')

                print(callback) # 这个callback，就是url对应的视图函数

                # return callback(request, *callback_args, **callback_kwargs)

            def process_response(self, request, response):

                print('m1.processs.response')

                return response  # 一定要有这个，不然会报错

            def process_exception(self, request, exception):

                print('m1.process_exception')

                # print(exception)

        class MyMiddle2(MiddlewareMixin):

            def process_request(self, request):

                print('m2.process.request')

            def process_view(self,request, callback, callback_args, callback_kwargs):

                print('m2.process_view')

            def process_response(self, request, response):

                print('m2.processs.response')

                return response  # 一定要有这个，不然会报错

            def process_exception(self, request, exception):

                print('m2.process_exception')

                # print(exception)

    - 注册中间件

        MIDDLEWARE = [

            #省略前面部分，追加后面两个

            'mid.MyMiddle1',

            'mid.MyMiddle2',

        ]

    - 一个request的完整生命周期

        https://www.processon.com/diagraming/5a0ce2bae4b06bed41d126e1

        正常的流程：

            m1.process.request

            m2.process.request

            m1.process_view

            m2.process_view

            views

            m2.processs.response

            m1.processs.response

        如果有exception:

            m1.process.request

            m2.process.request

            m1.process_view

            m2.process_view

            views

            m2.process_exception

            m1.process_exception

            m2.processs.response

            m1.processs.response

    - 中间件应用

        对所有请求（或一部分请求）做统一操作（比如缓存）--可以用中间件实现

        对每个请求做判断，如果缓存有，就返回，否则就到views读数据库，