2018-12-03 装饰器、中间件和session

一、装饰器

1.1 什么是装饰器

• 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

• 这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

1.2 装饰器的三个基本点

    1、外层函数内嵌内层函数
    2、外层函数返回内层函数
    3、内层函数调用外层函数的参数

  例如：

# 定义登录验证的装饰器
def is_login(func):
    # func 就是被装饰的函数（function类型）
    def check_status(request):
        token = request.COOKIES.get('token')
        if token:
            token_user = TokenUser.objects.filter(token=token).first()
            if token_user:
                # 返回func(request)表示继续执行被装饰的函数
                return func(request)
            else:
                return HttpResponseRedirect('/login/')
        else:
            return HttpResponseRedirect('/login/')

    return check_status

  注意：在上面的函数中外层函数的形参func指的是饰器装饰的函数，是一个function对象。return func(request)表示继续执行被装饰函数（如果需要继续执行被装饰函数就应该这样写），由于被装饰的函数有一个形参request，所以需要传入这个request参数，根据具体函数情况而定，也可以其他的执行操作。

   装饰器优点：利用装饰器可以替代我们纯手写的登录校验代码，同时装饰器有较高的灵活性，耦合性低，减少代码重复。

   装饰器缺点：多层装饰比较复杂。

二、中间件

2.1 什么是中间件：

  面向切面编程AOP中的中间件是一个最好的例子。官方的说法：中间件是一个用来处理Django的请求和响应的框架级别的钩子。它是一个轻量、低级别的插件系统，用于在全局范围内改变Django的输入和输出。

2.2 中间件Middleware描述

    中间件： 
        1. 是一个轻量级的，底层的插件，可以介入Django的请求和响应的过程（面向切面编程)
        2. 中间件的本质就是一个python类

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

2.3 中间件中的方法

   每个中间j件都是一个独立的类，主要有一下几个方法

    1. process_requeest(self, request)
        该方法是在Django接收到request之后，但仍未解析出url以确定运行哪个视图函数view视图函数之前。
    2. process_view(self, request, view_func, view_args, view_kwargs)
        执行时机在django执行完request预处理函数并确定待执行的view之后, 但在视图函数view之前
        request: HttpRequest对象
        view_fun: 是django将要调用的视图函数, 是真实的函数对象本身
        view_args: 将传入view的位置参数列表, 不包括request参数
        view_kwargs: 将传入view的字典参数
    3. process_response(self, request, response)
        该方法必须返回HttpResponse对象, 可以是原来的, 也可以是修改后的
        调用时机在django执行完view函数并生成response之后, 该中间件能修改response的内容, 常见用途比如压缩内容
        request是request对象
        response是从view中返回的response对象
    4. process_exception(self, request, exception)
        默认不主动调用，该方法只有在request处理过程中出了问题并且view函数抛出了一个未捕获的异常才会被调用, 可以用来发送错误通知, 将相关信息输出到日志文件, 或者甚至尝试从错误中自动恢复。
        参数包括request对象, 还有view函数抛出的异常对象exception
        必须返回None或HttpResponse对象
    5. process_template_response(self, request, response)
        默认不主动调用，在视图执行render()返回后进行调用，必须返回None或HttpResponse对象

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

   具体函数解释：

    1. process_request()函数
    process_request方法中有一个request参数，其表示请求。该方法中可以返回None或不用返回任何参数，或返回HttpResponse对象。如果返回None或不返回任何参数则表示继续执行其余中间件，如果是返回HttpResponse对象则直接返回HttpResponse对象给客户端，而不再执行视图函数。


    2. process_response(self, request, response)函数
    process_ response方法中两个参数，一个是请求request参数，一个是响应response参数，该response参数就是视图函数返回的HttpResponse对象。

   修改中间件TestMiddlware1和TestMiddlware2，修改代码如下：

class TestMiddlware1(MiddlewareMixin):

    def process_request(self, request):
        print('test1 process_request')

    def process_response(self, request, response):
        print('test1 process_response')
        return response

class TestMiddlware2(MiddlewareMixin):

    def process_request(self, request):
        print('test2 process_request')

    def process_response(self, request, response):
        print('test2 process_response')
        return response

   访问inde路由地址，在控制台中可以打印如下的内容:

    test1 process_request
    test2 process_request
    index views
    test2 process_response
    test1 process_response

   从结果中可以发现，中间件的process_request在访问视图函数之前执行，而process_reponse在视图函数之后执行。并且从执行顺序中可以得出以下结论:

    1）  多个中间件的process_request的执行顺序是按照在MIDDLEWARE中定义的先后顺序执行的。
    2）  多个中间件的process_response的执行顺序是按照MIDDLEWARE中定义的顺序逆序执行的。也就是说第一个中间件的process_request先执行，而第一个中间件的process_response最后执行。
    3）  视图函数在process_request之后执行。
    4）  视图函数在process_response之前执行。
    5）  process_response必须返回响应对象。


    3. process_view(self, view_func, view_args, view_kwargs) 讲解及处理流程

   该方法接收四个参数:

    请求request
    view_func: 即将被执行的函数
    view_args：传递给视图函数的列表参数
    view_kwargs：传递给视图函数的字典参数

   修改中间件TestMiddlware1和TestMiddlware2，修改代码如下：

class TestMiddlware1(MiddlewareMixin):

    def process_request(self, request):
        print('test1 process_request')

    def process_response(self, request, response):
        print('test1 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test1 process_view')

class TestMiddlware2(MiddlewareMixin):

    def process_request(self, request):
        print('test2 process_request')

    def process_response(self, request, response):
        print('test2 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test2 process_view')

   访问index路由地址，在控制台中可以打印如下的内容:

    test1 process_request
    test2 process_request
    test1 process_view
    test2 process_view
    index views
    test2 process_response
    test1 process_response

   从结果中可以发现，中间件中的process_view方法在视图函数之前执行，在process_request方法之后执行，process_view执行的顺序按照MIDDLEWARE中定义中间件的顺序执行的。并且从执行的结果中可以得出以下结论:

    1）  process_request执行后才执行process_view
    2）  视图函数在process_view方法执行后执行
    3）  process_view方法在process_response方法之后执行，并且执行的顺序按照MIDDLEWARE中定义中间件的顺序执行

    4. process_template_response(self, request, response) 讲解及处理流程
    该方法中接收两个参数，一个是请求request，一个是响应response，该响应response由视图函数产生。process_template_response方法默认是不执行的，只会在视图函数返回对象有一个render方法时才会被调用。

   修改index视图函数

    rep = HttpResponse()
    rep.render = index_render
    return rep

   修改中间件TestMiddlware1和TestMiddlware2，修改代码如下：

class TestMiddlware1(MiddlewareMixin):

    def process_request(self, request):
        print('test1 process_request')

    def process_response(self, request, response):
        print('test1 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test1 process_view')

    def process_exception(self, request, exception):
        print('test1 process_except')

    def process_template_response(self, request, response):
        print('test1 process_template_response')
        return response

class TestMiddlware2(MiddlewareMixin):

    def process_request(self, request):
        print('test2 process_request')

    def process_response(self, request, response):
        print('test2 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test2 process_view')

    def process_exception(self, request, exception):
        print('test2 process_except')

    def process_template_response(self, request, response):
        print('test2 process_template_response')
        return response

   访问index路由地址，在控制台中可以打印如下的内容:

    test1 process_request
    test2 process_request
    test1 process_view
    test2 process_view
    index views
    test2 process_template_response
    test1 process_template_response
    test2 process_response
    test1 process_response

   从结果中可以得出以下结论:

    1）  process_template_response在视图函数执行完后。并且执行的顺序按照MIDDLEWARE中定义中间件的顺序逆序执行。
    2）  process_response方法是最后执行的，并且执行的顺序按照MIDDLEWARE中定义中间件的顺序逆序执行。

    5. process_exception(self, request, exception) 讲解及处理流程
    该方法中接收两个参数，一个是请求request，一个是异常exception，该exception是视图函数产生的异常Exception对象。process_exception方法默认是不执行的，只会在视图函数出现异常的情况才会执行。

   修改index视图函数，使得index方法抛出一个异常:

def index(request):
    if request.method == 'GET':
        print('index views')
        1/0
        return HttpResponse('我是index方法')

   修改中间件TestMiddlware1和TestMiddlware2，修改代码如下：

class TestMiddlware1(MiddlewareMixin):

    def process_request(self, request):
        print('test1 process_request')

    def process_response(self, request, response):
        print('test1 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test1 process_view')

    def process_exception(self, request, exception):
        print('test1 process_except')

class TestMiddlware2(MiddlewareMixin):

    def process_request(self, request):
        print('test2 process_request')

    def process_response(self, request, response):
        print('test2 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('test2 process_view')

    def process_exception(self, request, exception):
        print('test2 process_except')

   访问index路由地址，在控制台中可以打印如下的内容:

    test1 process_request
    test2 process_request
    test1 process_view
    test2 process_view
    index views
    test2 process_except
    test1 process_except
    test2 process_response
    test1 process_response

   从结果中可以得出以下结论:

    1）  process_request最先执行。并且执行的顺序按照MIDDLEWARE中定义中间件的顺序执行。
    2）  process_view在视图函数之前执行，并且执行的顺序按照MIDDLEWARE中定义中间件的顺序执行。
    3）  视图函数在process_view方法执行后执行，在process_exception方法之前执行。
    4）  process_exception方法在process_response方法之前执行，并且执行的顺序按照MIDDLEWARE中定义中间件的顺序逆序执行。
    5）  process_response方法是最后执行的，并且执行的顺序按照MIDDLEWARE中定义中间件的顺序逆序执行。

三、cookie + session实现登录的保持

   在为引入装饰器和中间件之前，对于登录状态的保持我们都是自己在需要进行登录校验的视图函数中添加登录校验代码，采用的是cookie的形式。这样会产生大量的重复代码，所以我们引入中间和装饰器，减少代码重复。

    由于cookie这种保持登录状态存在安全隐患，所以下面我们才有session和csrf进行登录状态保持

    session指的是回话，是指当用户请求时服务端和客户端会建立一个回话连接，当用户发送其他请求时会携带服务器端返回的session_key（一串随机数）来发送请求，服务端去Django维持的Django_session数据库表中查询是否有该key所对应的数据，有则允许访问，否则不能访问。

   使用request.session向session中写入session值

    # 使用session实现登录操作
    # 1. 向cookie中设置session值，value为随机字符串
    # 2. 向Django_session表中存入sessionid值

        request.session['user_id'] = user.id

   这里设置的session值一般为主键，因为我们可以通过主键获取到一个user对象，方便与我们后面取值，推荐使用。

   结合中间件或者装饰器我们可以减少跟多的代码，下面是采用中间件进行登录校验

class LoginStatusMiddleware(MiddlewareMixin):

    def process_request(self, request):
        # 在访问登录和注册页面的时候都不需要进行登录校验
        if request.path in ['/login/', 'redister']:
            return None

        # 这个函数的return可写可不写，推荐不写
        # 登录校验，当访问需要登录才能访问的页面时就需要进行登录校验，登录了就能访问，未登录就不能访问
        # token校验
        # token = request.COOKIES.get('token')
        # if token:
        #     token_user = TokenUser.objects.filter(token=token).first()
        #     if not token_user:
        #         return HttpResponseRedirect('/login/')
        # else:
        #     return HttpResponseRedirect('/login/')
        # session校验
        # 1. 获取cookie中的值，
        # 2. 查询Django_session表中的session_key字段
        # 查询大数据，则获取session_data中存入的键值对

        user_id = request.session.get('user_id')
        if user_id:
            user = MyUser.objects.get(pk=user_id)
            request.user = user
            return None
        else:
            return HttpResponseRedirect('/login/')

    def process_response(self, request, response):
        print('reponse')
        return response

   在上面定义的中间件类中我们通过request.sessions.get('user_id')进行session校验，如果用户登录就能在Django_session表中获取到相应的session数据,这样一句就相当于我们上面写的token检验等功能，但是代码量更少，可读性跟高。装饰器同样的方式即可。

四、session的常用操作

1. 设置session

    session是键值对的形式存储的，所以可以用以下方法设置session
    request.session['键名'] = value
    如： request.session['user_id'] = user.id

2. 获取session值

    通过request.session.get()获取session值
    格式： request.session.get(key)
    如： request.session.get('user_id')

3. 删除session值

    删除Django_session表中的值
    # 仅仅只删除Django_session表中的数据
    request.session.delete(request.session.session_key)
    # 删除客户端和服务端session表中的值
    # request.session.flush()