视图高级

时间  2019-11-10
标签 视图 高级 繁體版
原文   原文链接

目标

  • 限制请求method
  • 页面重定向
  • HttpRequest 对象
  • HttpResponse 对象
  • 生产CVS 文件
  • 类视图
  • 错误处理

一 限制请求method

1-1 经常使用的请求method

1. GET请求：GET请求通常用来向服务器索取数据，但不会向服务器提交数据，不会对服务器的状态进行更改。好比向服务器获取某篇文章的详情。javascript

2. POST请求 ：POST请求通常是用来向服务器提交数据，会对服务器的状态进行更改。好比提交一篇文章给服务器。css

 

1-2 限制请求装饰器

　　Django内置的视图装饰器能够给视图提供一些限制。好比这个视图只能经过GET的method访问等。如下将介绍一些经常使用的内置视图装饰器。html

1.  django.http.decorators.http.require_http_methods：这个装饰器须要传递一个容许访问的方法的列表。好比只能经过GET的方式访问。那么示例代码以下：java

from django.views.decorators.http import require_http_methods

@require_http_methods(["GET"])
def my_view(request):
    pass

2. django.views.decorators.http.require_GET：这个装饰器至关因而require_http_methods(['GET'])的简写形式，只容许使用GET的method来访问视图。示例代码以下：python

from django.views.decorators.http import require_GET

@require_GET
def my_view(request):
    pass

3. django.views.decorators.http.require_POST：这个装饰器至关因而require_http_methods(['POST'])的简写形式，只容许使用POST的method来访问视图。示例代码以下：nginx

from django.views.decorators.http import require_POST

@require_POST
def my_view(request):
    pass

4. django.views.decorators.http.require_safe：这个装饰器至关因而require_http_methods(['GET','HEAD'])的简写形式，只容许使用相对安全的方式来访问视图。由于GET和HEAD不会对服务器产生增删改的行为。所以是一种相对安全的请求方式。示例代码以下：ajax

from django.views.decorators.http import require_safe

@require_safe
def my_view(request):
    pass

 

二 页面重定向

　　重定向分为永久性重定向和暂时性重定向，在页面上体现的操做就是浏览器会从一个页面自动跳转到另一个页面。好比用户访问了一个须要权限的页面，可是该用户当前并无登陆，所以咱们应该给他重定向到登陆页面。django

  • 永久性重定向：http的状态码是301，多用于旧网址被废弃了要转到一个新的网址确保用户的访问，最经典的就是京东网站，你输入www.jingdong.com的时候，会被重定向到www.jd.com，由于jingdong.com这个网址已经被废弃了，被改为jd.com，因此这种状况下应该用永久重定向。
  • 暂时性重定向：http的状态码是302，表示页面的暂时性跳转。好比访问一个须要权限的网址，若是当前用户没有登陆，应该重定向到登陆页面，这种状况下，应该用暂时性重定向。

　　在Django中，重定向是使用redirect(to, *args, permanent=False, **kwargs)来实现的。to是一个url，permanent表明的是这个重定向是不是一个永久的重定向，默认是False。关于重定向的使用。请看如下例子：json

from django.shortcuts import reverse,redirect
def profile(request):
    if request.GET.get("username"):
        return HttpResponse("%s，欢迎来到我的中心页面！")
    else:
        return redirect(reverse("user:login"))

 

三 HttpRequest 对象

3-1 WSGIRequest 对象

　　Django在接收到http请求以后，会根据http请求携带的参数以及报文信息建立一个WSGIRequest对象，而且做为视图函数第一个参数传给视图函数。也就是咱们常常看到的request参数。在这个对象上咱们能够找到客户端上传上来的全部信息。这个对象的完整路径是django.core.handlers.wsgi.WSGIRequest。浏览器

3-1-1 WSGIRequest对象经常使用属性：

　　WSGIRequest对象上大部分的属性都是只读的。由于这些属性是从客户端上传上来的，不必作任何的修改。如下将对一些经常使用的属性进行讲解：

  • path：请求服务器的完整“路径”，但不包含域名和参数。好比http://www.baidu.com/xxx/yyy/，那么path就是/xxx/yyy/。
  • method：表明当前请求的http方法。好比是GET仍是POST。
  • GET：一个django.http.request.QueryDict对象。操做起来相似于字典。这个属性中包含了全部以?xxx=xxx的方式上传上来的参数。
  • POST：也是一个django.http.request.QueryDict对象。这个属性中包含了全部以POST方式上传上来的参数。
  • FILES：也是一个django.http.request.QueryDict对象。这个属性中包含了全部上传的文件。
  • COOKIES：一个标准的Python字典，包含全部的cookie，键值对都是字符串类型。
  • session：一个相似于字典的对象。用来操做服务器的session。
  • META：存储的客户端发送上来的全部header信息。
  • CONTENT_LENGTH：请求的正文的长度（是一个字符串）。
  • HTTP_ACCEPT：响应可接收的Content-Type。
  • HTTP_ACCEPT_ENCODING：响应可接收的编码。
  • HTTP_ACCEPT_LANGUAGE： 响应可接收的语言。
  • HTTP_HOST：客户端发送的HOST值。
  • HTTP_REFERER：在访问这个页面上一个页面的url。
  • QUERY_STRING：单个字符串形式的查询字符串（未解析过的形式）。
  • REMOTE_ADDR：客户端的IP地址。若是服务器使用了nginx作反向代理或者负载均衡，那么这个值返回的是127.0.0.1，这时候可使用HTTP_X_FORWARDED_FOR来获取，因此获取ip地址的代码片断以下：
if request.META.has_key('HTTP_X_FORWARDED_FOR'):  
    ip =  request.META['HTTP_X_FORWARDED_FOR']  
else:  
    ip = request.META['REMOTE_ADDR']
  • REMOTE_HOST：客户端的主机名。
  • REQUEST_METHOD：请求方法。一个字符串相似于GET或者POST。
  • SERVER_NAME：服务器域名。
  • SERVER_PORT：服务器端口号，是一个字符串类型。

3-1-2 WSGIRequest对象经常使用方法

  1. is_secure()：是不是采用https协议。
  2. is_ajax()：是否采用ajax发送的请求。原理就是判断请求头中是否存在X-Requested-With:XMLHttpRequest。
  3. get_host()：服务器的域名。若是在访问的时候还有端口号，那么会加上端口号。好比www.baidu.com:9000。
  4. get_full_path()：返回完整的path。若是有查询字符串，还会加上查询字符串。好比/music/bands/?print=True。
  5. get_raw_uri()：获取请求的完整url。

 

3-2 QueryDict 对象

　　咱们平时用的request.GET和request.POST都是QueryDict对象，这个对象继承自dict，所以用法跟dict相差无几。其中用得比较多的是get方法和getlist方法。

  1. get方法：用来获取指定key的值，若是没有这个key，那么会返回None。
  2. getlist方法：若是浏览器上传上来的key对应的值有多个，那么就须要经过这个方法获取。

 

四 HttpResponse 对象

 　　Django服务器接收到客户端发送过来的请求后，会将提交上来的这些数据封装成一个HttpRequest对象传给视图函数。那么视图函数在处理完相关的逻辑后，也须要返回一个响应给浏览器。而这个响应，咱们必须返回HttpResponseBase或者他的子类的对象。而HttpResponse则是HttpResponseBase用得最多的子类。那么接下来就来介绍一下HttpResponse及其子类。

4-1 经常使用属性

  • content：返回的内容。
  • status_code：返回的HTTP响应状态码。
  • content_type：返回的数据的MIME类型，默认为text/html。浏览器会根据这个属性，来显示数据。若是是text/html，那么就会解析这个字符串，若是text/plain，那么就会显示一个纯文本。经常使用的Content-Type以下
    • text/html（默认的，html文件）
    • text/plain（纯文本）
    • text/css（css文件）
    • text/javascript（js文件）
    • multipart/form-data（文件提交）
    • application/json（json传输）
    • application/xml（xml文件）
  • 设置请求头：response['X-Access-Token'] = 'xxxx'。

 

4-2 经常使用方法

  1. set_cookie：用来设置cookie信息。后面讲到受权的时候会着重讲到。
  2. delete_cookie：用来删除cookie信息。
  3. write：HttpResponse是一个相似于文件的对象，能够用来写入数据到数据体（content）中。

 

4-3 JsonResponse 类

　　用来对象dump成json字符串，而后返回将json字符串封装成Response对象返回给浏览器。而且他的Content-Type是application/json。示例代码以下：

from django.http import JsonResponse
def index(request):
    return JsonResponse({"username":"zhiliao","age":18})

　　默认状况下JsonResponse只能对字典进行dump，若是想要对非字典的数据进行dump，那么须要给JsonResponse传递一个safe=False参数。示例代码以下：

from django.http import JsonResponse
def index(request):
    persons = ['张三','李四','王五']
    return HttpResponse(persons)

　　以上代码会报错，应该在使用HttpResponse的时候，传入一个safe=False参数，示例代码以下：

return HttpResponse(persons,safe=False)

 

五 生产 CVS 文件

 　　有时候咱们作的网站，须要将一些数据，生成有一个CSV文件给浏览器，而且是做为附件的形式下载下来。如下将讲解如何生成CSV文件。

5-1 生成小的CSV文件

　　这里将用一个生成小的CSV文件为例，来把生成CSV文件的技术要点讲到位。咱们用Python内置的csv模块来处理csv文件，而且使用HttpResponse来将csv文件返回回去。示例代码以下：

import csv
from django.http import HttpResponse

def csv_view(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'

    writer = csv.writer(response)
    writer.writerow(['username', 'age', 'height', 'weight'])
    writer.writerow(['zhiliao', '18', '180', '110'])

    return response

　　这里再来对每一个部分的代码进行解释：

  1. 咱们在初始化HttpResponse的时候，指定了Content-Type为text/csv，这将告诉浏览器，这是一个csv格式的文件而不是一个HTML格式的文件，若是用默认值，默认值就是html，那么浏览器将把csv格式的文件按照html格式输出，这确定不是咱们想要的。
  2. 第二个咱们还在response中添加一个Content-Disposition头，这个东西是用来告诉浏览器该如何处理这个文件，咱们给这个头的值设置为attachment;，那么浏览器将不会对这个文件进行显示，而是做为附件的形式下载，第二个filename="somefilename.csv"是用来指定这个csv文件的名字。
  3. 咱们使用csv模块的writer方法，将相应的数据写入到response中。

5-2 将csv文件定义成模板

 　　咱们还能够将csv格式的文件定义成模板，而后使用Django内置的模板系统，并给这个模板传入一个Context对象，这样模板系统就会根据传入的Context对象，生成具体的csv文件。示例代码以下：

模板文件：

{% for row in data %}"{{ row.0|addslashes }}", "{{ row.1|addslashes }}", "{{ row.2|addslashes }}", "{{ row.3|addslashes }}", "{{ row.4|addslashes }}"
{% endfor %}

视图函数：

from django.http import HttpResponse
from django.template import loader, Context

def some_view(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'


    csv_data = (
        ('First row', 'Foo', 'Bar', 'Baz'),
        ('Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"),
    )

    t = loader.get_template('my_template_name.txt')
    response.write(t.render({"data": csv_data}))
    return response

 

5-3 生成大的CSV文件

 　　以上的例子是生成的一个小的csv文件，若是想要生成大型的csv文件，那么以上方式将有可能会发生超时的状况（服务器要生成一个大型csv文件，须要的时间可能会超过浏览器默认的超时时间）。这时候咱们能够借助另一个类，叫作StreamingHttpResponse对象，这个对象是将响应的数据做为一个流返回给客户端，而不是做为一个总体返回。示例代码以下：

class Echo:
    """
    定义一个能够执行写操做的类，之后调用csv.writer的时候，就会执行这个方法
    """
    def write(self, value):
        return value

def large_csv(request):
    rows = (["Row {}".format(idx), str(idx)] for idx in range(655360))
    pseudo_buffer = Echo()
    writer = csv.writer(pseudo_buffer)
    response = StreamingHttpResponse((writer.writerow(row) for row in rows),content_type="text/csv")
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'
    return response

　　这里咱们构建了一个很是大的数据集rows，而且将其变成一个迭代器。而后由于StreamingHttpResponse的第一个参数只能是一个生成器，所以咱们使用圆括号(writer.writerow(row) for row in rows)，而且由于咱们要写的文件是csv格式的文件，所以须要调用writer.writerow将row变成一个csv格式的字符串。而调用writer.writerow又须要一个中间的容器，所以这里咱们定义了一个很是简单的类Echo，这个类只实现一个write方法，之后在执行csv.writer(pseudo_buffer)的时候，就会调用Echo.writer方法。
注意：StreamingHttpResponse会启动一个进程来和客户端保持长链接，因此会很消耗资源。因此若是不是特殊要求，尽可能少用这种方法。

 

 5-4 关于StreamingHttpResponse

　　这个类是专门用来处理流数据的。使得在处理一些大型文件的时候，不会由于服务器处理时间过长而到时链接超时。这个类不是继承自HttpResponse，而且跟HttpResponse对比有如下几点区别：

  1. 这个类没有属性content，相反是streaming_content。
  2. 这个类的streaming_content必须是一个能够迭代的对象。
  3. 这个类没有write方法，若是给这个类的对象写入数据将会报错。

注意：StreamingHttpResponse会启动一个进程来和客户端保持长链接，因此会很消耗资源。因此若是不是特殊要求，尽可能少用这种方法。

 

六 类视图

　　在写视图的时候，Django除了使用函数做为视图，也可使用类做为视图。使用类视图可使用类的一些特性，好比继承等。

6-1 View

　　django.views.generic.base.View是主要的类视图，全部的类视图都是继承自他。若是咱们写本身的类视图，也能够继承自他。而后再根据当前请求的method，来实现不一样的方法。好比这个视图只能使用get的方式来请求，那么就能够在这个类中定义get(self,request,*args,**kwargs)方法。以此类推，若是只须要实现post方法，那么就只须要在类中实现post(self,request,*args,**kwargs)。示例代码以下：

from django.views import View
class BookDetailView(View):
    def get(self,request,*args,**kwargs):
        return render(request,'detail.html')

　　类视图写完后，还应该在urls.py中进行映射，映射的时候就须要调用View的类方法as_view()来进行转换。示例代码以下：

urlpatterns = [        
    path("detail/<book_id>/",views.BookDetailView.as_view(),name='detail')
]

　　除了get方法，View还支持如下方法['get','post','put','patch','delete','head','options','trace']

　　若是用户访问了View中没有定义的方法。好比你的类视图只支持get方法，而出现了post方法，那么就会把这个请求转发给http_method_not_allowed(request,*args,**kwargs)。示例代码以下：

class AddBookView(View):
    def post(self,request,*args,**kwargs):
        return HttpResponse("书籍添加成功！")

    def http_method_not_allowed(self, request, *args, **kwargs):
        return HttpResponse("您当前采用的method是：%s，本视图只支持使用post请求！" % request.method)

　　urls.py中的映射以下：

path("addbook/",views.AddBookView.as_view(),name='add_book')

　　若是你在浏览器中访问addbook/，由于浏览器访问采用的是get方法，而addbook只支持post方法，所以以上视图会返回您当前采用的method是：GET，本视图只支持使用post请求！。

　　其实不论是get请求仍是post请求，都会走dispatch(request,*args,**kwargs)方法，因此若是实现这个方法，将可以对全部请求都处理到。

 

6-2 TemplateView

　　django.views.generic.base.TemplateView，这个类视图是专门用来返回模版的。在这个类中，有两个属性是常常须要用到的，一个是template_name，这个属性是用来存储模版的路径，TemplateView会自动的渲染这个变量指向的模版。另一个是get_context_data，这个方法是用来返回上下文数据的，也就是在给模版传的参数的。示例代码以下：

from django.views.generic.base import TemplateView

class HomePageView(TemplateView):

    template_name = "home.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['username'] = "黄勇"
        return context

　　在urls.py中的映射代码以下：

from django.urls import path

from myapp.views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
]

　　若是在模版中不须要传递任何参数，那么能够直接只在urls.py中使用TemplateView来渲染模版。示例代码以下：

from django.urls import path
from django.views.generic import TemplateView

urlpatterns = [
    path('about/', TemplateView.as_view(template_name="about.html")),
]

 

6-3 ListView

　　在网站开发中，常常会出现须要列出某个表中的一些数据做为列表展现出来。好比文章列表，图书列表等等。在Django中可使用ListView来帮咱们快速实现这种需求。示例代码以下：

class ArticleListView(ListView):
    model = Article
    template_name = 'article_list.html'
    paginate_by = 10
    context_object_name = 'articles'
    ordering = 'create_time'
    page_kwarg = 'page'

    def get_context_data(self, **kwargs):
        context = super(ArticleListView, self).get_context_data(**kwargs)
        print(context)
        return context

    def get_queryset(self):
        return Article.objects.filter(id__lte=89)

　　对以上代码进行解释：

  1. 首先ArticleListView是继承自ListView
  2. model：重写model类属性，指定这个列表是给哪一个模型的
  3. template_name：指定这个列表的模板
  4. paginate_by：指定这个列表一页中展现多少条数据
  5. context_object_name：指定这个列表模型在模板中的参数名称
  6. ordering：指定这个列表的排序方式
  7. page_kwarg：获取第几页的数据的参数名称。默认是page
  8. get_context_data：获取上下文的数据
  9. get_queryset：若是你提取数据的时候，并非要把全部数据都返回，那么你能够重写这个方法。将一些不须要展现的数据给过滤掉

 

6-4 Paginator和Page类

 　　Paginator和Page类都是用来作分页的。他们在Django中的路径为django.core.paginator.Paginator和django.core.paginator.Page。如下对这两个类的经常使用属性和方法作解释：

6-4-1 Paginator经常使用属性和方法

  1. count：总共有多少条数据
  2. num_pages：总共有多少页
  3. page_range：页面的区间。好比有三页，那么就range(1,4)

6-4-2 Page经常使用属性和方法

  1. has_next：是否还有下一页
  2. has_previous：是否还有上一页
  3. next_page_number：下一页的页码
  4. previous_page_number：上一页的页码
  5. number：当前页
  6. start_index：当前这一页的第一条数据的索引值
  7. end_index：当前这一页的最后一条数据的索引值

6-4-3 分页案例

1）定义视图类

from django.views.generic import ListView,View
from django.core.paginator import Paginator,Page

class ArticleListView(ListView):
    model = Article
    template_name = 'article_list1.html'
    context_object_name = 'articles'
    paginate_by = 10
    ordering = 'create_time'
    page_kwarg = 'p'

    def get_context_data(self, **kwargs):
        context = super(ArticleListView, self).get_context_data(**kwargs)
        context['username'] = 'zhiliao'
        paginator = context.get('paginator')
        page_obj = context.get('page_obj')
        pagination_data = self.get_pagination_data(paginator, page_obj, 3)
        context.update(pagination_data)
        return context

    def get_pagination_data(self,paginator,page_obj,around_count=2):
        current_page = page_obj.number
        num_pages = paginator.num_pages

        left_has_more = False
        right_has_more = False

        if current_page <= around_count + 2:
            left_pages = range(1,current_page)
        else:
            left_has_more = True
            left_pages = range(current_page-around_count,current_page)

        if current_page >= num_pages - around_count - 1:
            right_pages = range(current_page+1,num_pages+1)
        else:
            right_has_more = True
            right_pages = range(current_page+1,current_page+around_count+1)

        return {
            'left_pages': left_pages,
            'right_pages': right_pages,
            'current_page': current_page,
            'left_has_more': left_has_more,
            'right_has_more': right_has_more,
            'num_pages': num_pages
        }

2）模板页面

<ul>
        {% for article in articles %}
            <li>{{ article.title }}</li>
        {% endfor %}
        <ul class="pagination">
{#             上一页#}
            {% if page_obj.has_previous %}
                <li><a href="{% url 'front:article_list' %}?p={{ page_obj.previous_page_number }}">上一页</a></li>
            {% else %}
                <li class="disabled"><a href="javascript:void(0);">上一页</a></li>
            {% endif %}

            {% if left_has_more %}
                <li><a href="{% url 'front:article_list' %}?p=1">1</a></li>
                <li><a href="javascript:void(0);">...</a></li>
            {% endif %}

            {# 左边的页码 #}
            {% for left_page in left_pages %}
                <li><a href="{% url 'front:article_list' %}?p={{ left_page }}">{{ left_page }}</a></li>
            {% endfor %}

            {# 当前的页面 #}
            <li class="active"><a href="{% url 'front:article_list' %}?p={{ current_page }}">{{ current_page }}</a></li>

            {# 右边的页码 #}
            {% for right_page in right_pages %}
                <li><a href="{% url 'front:article_list' %}?p={{ right_page }}">{{ right_page }}</a></li>
            {% endfor %}

            {% if right_has_more %}
                <li><a href="javascript:void(0);">...</a></li>
                <li><a href="{% url 'front:article_list' %}?p={{ num_pages }}">{{ num_pages }}</a></li>
            {% endif %}

{#             下一页#}
            {% if page_obj.has_next %}
                <li><a href="{% url 'front:article_list' %}?p={{ page_obj.next_page_number }}">下一页</a></li>
            {% else %}
                <li class="disabled"><a href="javascript:void(0);">下一页</a></li>
            {% endif %}

        </ul>
    </ul>

 

6-5 给类视图添加装饰器

 　　在开发中，有时候须要给一些视图添加装饰器。若是用函数视图那么很是简单，只要在函数的上面写上装饰器就能够了。可是若是想要给类添加装饰器，那么能够经过如下两种方式来实现：

6-5-1 装饰dispatch方法

from django.utils.decorators import method_decorator

def login_required(func):
    def wrapper(request,*args,**kwargs):
        if request.GET.get("username"):
            return func(request,*args,**kwargs)
        else:
            return redirect(reverse('index'))
    return wrapper


class IndexView(View):
    def get(self,request,*args,**kwargs):
        return HttpResponse("index")

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        super(IndexView, self).dispatch(request,*args,**kwargs)

6-5-2 直接装饰在整个类上

from django.utils.decorators import method_decorator
def login_required(func):
    def wrapper(request,*args,**kwargs):
        if request.GET.get("username"):
            return func(request,*args,**kwargs)
        else:
            return redirect(reverse('login'))
    return wrapper


@method_decorator(login_required,name='dispatch')
class IndexView(View):
    def get(self,request,*args,**kwargs):
        return HttpResponse("index")

    def dispatch(self, request, *args, **kwargs):
        super(IndexView, self).dispatch(request,*args,**kwargs)

　　

七 错误处理

　　在一些网站开发中。常常会须要捕获一些错误，而后将这些错误返回比较优美的界面，或者是将这个错误的请求作一些日志保存。那么咱们本节就来说讲如何实现。

7-1 经常使用的错误码

  1. 400：bad request，请求的参数错误
  2. 403：没有权限访问相关的数据
  3. 404：服务器没有指定的url
  4. 405：请求的method错误
  5. 500：服务器内部错误，通常是代码出bug了
  6. 502：通常部署的时候见得比较多，通常是nginx启动了，而后uwsgi有问题

 

7-2 自定义错误模板

　　在碰到好比404，500错误的时候，想要返回本身定义的模板。那么能够直接在templates文件夹下建立相应错误代码的html模板文件。那么之后在发生相应错误后，会将指定的模板返回回去。 

 

7-3 错误处理的解决方案

 　　对于404和500这种自动抛出的错误。咱们能够直接在templates文件夹下新建相应错误代码的模板文件。而对于其余的错误，咱们能够专门定义一个app，用来处理这些错误。 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程