Django-分页、中间件和请求的声明周期

一、分页

　　相关连接：https://www.cnblogs.com/kongzhagen/p/6640975.html

一、Django的分页器（paginator）

　　1、view.py 视图

from django.shortcuts import render,HttpResponse

# Create your views here.

from app01.models import *

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

def index(request):

    '''

    批量导入数据:

    Booklist=[]

    for i in range(100):

        Booklist.append(Book(title="book"+str(i),price=30+i*i))

    Book.objects.bulk_create(Booklist)

    '''

    '''

分页器的使用:

    book_list=Book.objects.all()

    paginator = Paginator(book_list, 10)

    print("count:",paginator.count)           #数据总数

    print("num_pages",paginator.num_pages)    #总页数

    print("page_range",paginator.page_range)  #页码的列表

    page1=paginator.page(1) #第1页的page对象

    for i in page1:         #遍历第1页的所有数据对象

        print(i)

    print(page1.object_list) #第1页的所有数据

    page2=paginator.page(2)

    print(page2.has_next())            #是否有下一页

    print(page2.next_page_number())    #下一页的页码

    print(page2.has_previous())        #是否有上一页

    print(page2.previous_page_number()) #上一页的页码

    # 抛错

    #page=paginator.page(12)   # error:EmptyPage

    #page=paginator.page("z")   # error:PageNotAnInteger

    '''

    book_list=Book.objects.all()

    paginator = Paginator(book_list, 10)

    page = request.GET.get('page',1)

    currentPage=int(page)

    try:

        print(page)

        book_list = paginator.page(page)

    except PageNotAnInteger:

        book_list = paginator.page(1)

    except EmptyPage:

        book_list = paginator.page(paginator.num_pages)

    return render(request,"index.html",{"book_list":book_list,"paginator":paginator,"currentPage":currentPage})

　　2、index.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css"

    integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

</head>

<body>

<div class="container">

    <h4>分页器</h4>

    <ul>

        {% for book in book_list %}

             <li>{{ book.title }} -----{{ book.price }}</li>

        {% endfor %}

     </ul>

    <ul class="pagination" id="pager">

                 {% if book_list.has_previous %}

                    <li class="previous"><a href="/index/?page={{ book_list.previous_page_number }}">上一页</a></li>

                 {% else %}

                    <li class="previous disabled"><a href="#">上一页</a></li>

                 {% endif %}

                 {% for num in paginator.page_range %}

                     {% if num == currentPage %}

                       <li class="item active"><a href="/index/?page={{ num }}">{{ num }}</a></li>

                     {% else %}

                       <li class="item"><a href="/index/?page={{ num }}">{{ num }}</a></li>

                     {% endif %}

                 {% endfor %}

                 {% if book_list.has_next %}

                    <li class="next"><a href="/index/?page={{ book_list.next_page_number }}">下一页</a></li>

                 {% else %}

                    <li class="next disabled"><a href="#">下一页</a></li>

                 {% endif %}

            </ul>

</div>

</body>

</html>

　　3、扩展

def index(request):

    book_list=Book.objects.all()

    paginator = Paginator(book_list, 15)

    page = request.GET.get('page',1)

    currentPage=int(page)

    #  如果页数十分多时，换另外一种显示方式

    if paginator.num_pages>30:

        if currentPage-5<1:

            pageRange=range(1,11)

        elif currentPage+5>paginator.num_pages:

            pageRange=range(currentPage-5,paginator.num_pages+1)

        else:

            pageRange=range(currentPage-5,currentPage+5)

    else:

        pageRange=paginator.page_range

    try:

        print(page)

        book_list = paginator.page(page)

    except PageNotAnInteger:

        book_list = paginator.page(1)

    except EmptyPage:

        book_list = paginator.page(paginator.num_pages)

    return render(request,"index.html",locals())

二、自定义分页器

"""

分页组件使用示例：

    obj = Pagination(request.GET.get('page',1),len(USER_LIST),request.path_info)

    page_user_list = USER_LIST[obj.start:obj.end]

    page_html = obj.page_html()

    return render(request,'index.html',{'users':page_user_list,'page_html':page_html})

"""

class Pagination(object):

    def __init__(self,current_page,all_count,base_url,per_page_num=2,pager_count=11):

        """

        封装分页相关数据

        :param current_page: 当前页

        :param all_count:    数据库中的数据总条数

        :param per_page_num: 每页显示的数据条数

        :param base_url: 分页中显示的URL前缀

        :param pager_count:  最多显示的页码个数

        """

        try:

            current_page = int(current_page)

        except Exception as e:

            current_page = 1

        if current_page <1:

            current_page = 1

        self.current_page = current_page

        self.all_count = all_count

        self.per_page_num = per_page_num

        self.base_url = base_url

        # 总页码

        all_pager, tmp = divmod(all_count, per_page_num)

        if tmp:

            all_pager += 1

        self.all_pager = all_pager

        self.pager_count = pager_count

        self.pager_count_half = int((pager_count - 1) / 2)

    @property

    def start(self):

        return (self.current_page - 1) * self.per_page_num

    @property

    def end(self):

        return self.current_page * self.per_page_num

    def page_html(self):

        # 如果总页码 < 11个：

        if self.all_pager <= self.pager_count:

            pager_start = 1

            pager_end = self.all_pager + 1

        # 总页码  > 11

        else:

            # 当前页如果<=页面上最多显示11/2个页码

            if self.current_page <= self.pager_count_half:

                pager_start = 1

                pager_end = self.pager_count + 1

            # 当前页大于5

            else:

                # 页码翻到最后

                if (self.current_page + self.pager_count_half) > self.all_pager:

                    pager_end = self.all_pager + 1

                    pager_start = self.all_pager - self.pager_count + 1

                else:

                    pager_start = self.current_page - self.pager_count_half

                    pager_end = self.current_page + self.pager_count_half + 1

        page_html_list = []

        first_page = '<li><a href="%s?page=%s">首页</a></li>' % (self.base_url,1,)

        page_html_list.append(first_page)

        if self.current_page <= 1:

            prev_page = '<li class="disabled"><a href="#">上一页</a></li>'

        else:

            prev_page = '<li><a href="%s?page=%s">上一页</a></li>' % (self.base_url,self.current_page - 1,)

        page_html_list.append(prev_page)

        for i in range(pager_start, pager_end):

            if i == self.current_page:

                temp = '<li class="active"><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)

            else:

                temp = '<li><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)

            page_html_list.append(temp)

        if self.current_page >= self.all_pager:

            next_page = '<li class="disabled"><a href="#">下一页</a></li>'

        else:

            next_page = '<li><a href="%s?page=%s">下一页</a></li>' % (self.base_url,self.current_page + 1,)

        page_html_list.append(next_page)

        last_page = '<li><a href="%s?page=%s">尾页</a></li>' % (self.base_url,self.all_pager,)

        page_html_list.append(last_page)

        return ''.join(page_html_list)

二、中间件

一、中间件的概念

　　Django中叫中间件，其他框架种有的叫管道。

　　1、中间件的定义

　　中间件，是介于request与response处理之间的一道处理过程，相对比较轻量级，并且在全局上改变Django的输入与输出。因为改变的是全局，所以需要谨慎使用，用不好会影响性能。

　　django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。

　　2、Django中间件的定义

　　Middleware is a framework of hooks into Django’s request/response processing. <br>It’s a light, low-level “plugin” system for globally altering Django’s input or output.

　　中间件是Django请求/响应处理的钩子框架。是一种轻的、低层次的“插件”系统，用于全局修改Django的输入或输出。

　　若你想修改请求，例如被传送到view中的HttpRequest对象；或者你想修改view返回的HttpResponse对象；你还想再view执行之前做一些操作，这些都可以使用middleware中间件来实现。

二、Django默认中间件使用

　　1、Django中间件 settings.py文件

　　Django想在每个view中执行之前把user设置为request的属性，于是就使用一个中间件来实现这个目标。这个修改request对象的中间件是AuthenticationMiddleware。

　　Django中默认的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',

]

　　每一个中间是都有具体的功能。

　　2、中间的执行流程　

　　Django中间件：https://www.cnblogs.com/huchong/p/7819296.html

　　中间件执行流程描述：

执行完所有的request方法到达视图函数。
执行中间件的其他方法
经过所有response方法返回客户端。

　　3、Django内置中间说明

　　https://my.oschina.net/liuyuantao/blog/756778

MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',  #安全中间件

    'django.contrib.sessions.middleware.SessionMiddleware', #会话中间件，放在UpdateCacheMiddleware之后：会修改 大量协议头。

    'django.middleware.common.CommonMiddleware',     #放在任何可能修改相应的中间件之前（因为它会生成ETags）。

    'django.middleware.csrf.CsrfViewMiddleware', #CSRF保护中间件，放在任何假设CSRF攻击被处理的视图中间件之前。

    'django.contrib.auth.middleware.AuthenticationMiddleware',  #认证中间件，放在SessionMiddleware之后：因为它使用会话存储。

    'django.contrib.messages.middleware.MessageMiddleware', #消息中间件，放在SessionMiddleware之后：会使用基于会话的存储。

    'django.middleware.clickjacking.XFrameOptionsMiddleware',  #XFrameOptionsMiddleware代码, 是在response添加X-Frame-Options属性.

]

　　X-Frame-Options有三个值:

DENY: 浏览器拒绝当前页面加载任何frame页面
SAMEORIGIN: frame页面的地址只能为同源域名下的页面
ALLOW-FROM: 允许frame加载的页面地址

　　4、Django中间件可以定义的五个方法

　　https://www.cnblogs.com/huchong/p/7819296.html#_label2

　　5、中间件的应用场景

　　由于中间件工作在视图函数执行前、执行后（像不像所有视图函数的装饰器！）适合所有的请求/一部分请求做批量处理

　　　　1、做IP限制

　　放在中间件类的列表中，阻止某些IP访问了；

　　　　2、URL访问过滤

　　如果用户访问的是login视图（放过）

　　如果访问其他视图（需要检测是不是有session已经有了放行，没有返回login），这样就省得在多个视图函数上写装饰器了！

　　　　3、缓存（还记得CDN吗?）

　　客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层执行视图函数

　　3、django的csrf是如何实现？

　　　　1、process_view方法

　　- 检查视图是否被 @csrf_exempt （免除csrf认证）
　　- 去请求体或cookie中获取token

情况一：

    MIDDLEWARE = [

        'django.middleware.security.SecurityMiddleware',

        'django.contrib.sessions.middleware.SessionMiddleware',

        'django.middleware.common.CommonMiddleware',

        'django.middleware.csrf.CsrfViewMiddleware', # 全站使用csrf认证

        'django.contrib.auth.middleware.AuthenticationMiddleware',

        'django.contrib.messages.middleware.MessageMiddleware',

        'django.middleware.clickjacking.XFrameOptionsMiddleware',

    ]

    from django.views.decorators.csrf import csrf_exempt

    @csrf_exempt # 该函数无需认证

    def users(request):

        user_list = ['alex','oldboy']

        return HttpResponse(json.dumps((user_list)))

情况二：

    MIDDLEWARE = [

        'django.middleware.security.SecurityMiddleware',

        'django.contrib.sessions.middleware.SessionMiddleware',

        'django.middleware.common.CommonMiddleware',

        #'django.middleware.csrf.CsrfViewMiddleware', # 全站不使用csrf认证

        'django.contrib.auth.middleware.AuthenticationMiddleware',

        'django.contrib.messages.middleware.MessageMiddleware',

        'django.middleware.clickjacking.XFrameOptionsMiddleware',

    ]

    from django.views.decorators.csrf import csrf_exempt

    @csrf_protect # 该函数需认证

    def users(request):

        user_list = ['alex','oldboy']

        return HttpResponse(json.dumps((user_list)))

　　　　2、CBV小知识,csrf时需要使用

　　- @method_decorator(csrf_exempt)
　　- 在dispatch方法中（单独方法无效）

        方式一：

        from django.views.decorators.csrf import csrf_exempt,csrf_protect

        from django.utils.decorators import method_decorator

        class StudentsView(View):

            @method_decorator(csrf_exempt)

            def dispatch(self, request, *args, **kwargs):

                return super(StudentsView,self).dispatch(request, *args, **kwargs)

            def get(self,request,*args,**kwargs):

                print('get方法')

                return HttpResponse('GET')

            def post(self, request, *args, **kwargs):

                return HttpResponse('POST')

            def put(self, request, *args, **kwargs):

                return HttpResponse('PUT')

            def delete(self, request, *args, **kwargs):

                return HttpResponse('DELETE')

    方式二：

        from django.views.decorators.csrf import csrf_exempt,csrf_protect

        from django.utils.decorators import method_decorator

        @method_decorator(csrf_exempt,name='dispatch')

        class StudentsView(View):

            def get(self,request,*args,**kwargs):

                print('get方法')

                return HttpResponse('GET')

            def post(self, request, *args, **kwargs):

                return HttpResponse('POST')

            def put(self, request, *args, **kwargs):

                return HttpResponse('PUT')

            def delete(self, request, *args, **kwargs):

                return HttpResponse('DELETE')

总结：

    - 本质，基于反射来实现

    - 流程：路由，view，dispatch(反射)

    - 取消csrf认证（装饰器要加到dispatch方法上且method_decorator装饰）

    扩展：

        - csrf

            - 基于中间件的process_view方法

            - 装饰器给单独函数进行设置（认证或无需认证）

三、Django中请求的声明周期

　　https://www.cnblogs.com/renpingsheng/p/7534897.html

四、Django REST framework的请求生命周期

　　Django REST framework的请求生命周期：https://www.cnblogs.com/renpingsheng/p/7892719.html