Django框架-高级视图部分

最新推荐文章于 2023-08-04 17:41:35 发布

凉梨汁儿

最新推荐文章于 2023-08-04 17:41:35 发布

阅读量198

点赞数

文章标签： python django

本文链接：https://blog.csdn.net/weixin_45568391/article/details/113114297

版权

Django限制请求方法

请求method
1.GET请求：GET请求一般用来向服务器索取数据，但不会向服务器提交数据，不会对服务器的状态进行更改。比如向服务器获取某篇文章的详情。
2.POST请求：POST请求一般是用来向服务器提交数据，会对服务器的状态进行更改。比如提交一篇文章给服务器。
限制请求服务器
Django内置的视图装饰器可以给视图提供一些限制。比如这个视图只能通过GET的method访问等。以下将介绍一些常用的内置视图装饰器
1.django.views.decorators.http.require_http_methods：

这个装饰器需要传递一个允许访问的方法列表

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来访问视图

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来访问视图

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不会对服务器产生增删改的行为

from django.views.decorators.http import require_safe

@require_safe
def my_view(request):
     pass

重定向

重定向分为永久重定向和暂时性重定向，在页面上体现的操作就是浏览器会从一个页面自动跳转到另外一个页面。比如用户访问了一个需要权限的页面，但是该用户当前并没有登录，因此我们应该给他重定向到登录页面

永久性重定向：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

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

HttpRequest对象

WSGIRequset对象
Django在接收到http请求之后，会根据http请求携带的参数以及报文信息创建一个WSGIRequest对象，并且作为视图函数第一个参数传给视图函数。也就是我们经常看到的request参数。在这个对象上我们可以找到客户端上传上来的所有信息。这个对象的完整路径是django.core.handlers.wsgi.WSGIRequest

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：请求的正文的长度（是一个字符串）。
CONTENT_TYPE：请求的正文的MIME类型。
HTTP_ACCEPT：响应可接收的Content-Type。
HTTP_ACCEPT_ENCODING：响应可接收的编码。
HTTP_ACCEPT_LANGUAGE：响应可接收的语言。
HTTP_HOST：客户端发送的HOST值。
HTTP_REFERER：在访问这个页面上一个页面的url。
QUERY_STRING：单个字符串形式的查询字符串（未解析过的形式）
REMOTE_HOST：客户端的主机名。
REQUEST_METHOD：请求方法。一个字符串类似于GET或者POST。
SERVER_NAME：服务器域名。
SERVER_PORT：服务器端口号，是一个字符串类型

WSGIRequest对象常用方法

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

HttpResponse对象

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

常用属性
1.content：返回的内容。

response = HttpResponse()
response.content = "首页"
return response

2.status_code：返回的HTTP响应状态码。

3.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文件）

4.设置请求头
response[‘X-Access-Token’] = ‘xxxx’。

常用方法

1.set_cookie：用来设置cookie信息。

2.delete_cookie：用来删除cookie信息。

3.write：HttpResponse是一个类似于文件的对象，可以用来写入数据到数据体（content）中。

JsonResponse类

用来对象dump成json字符串，然后返回将json字符串封装成Response对象返回给浏览器。并且他的Content-Type是application/json。

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

默认情况下JsonResponse只能对字典进行dump，如果想要对非字典的数据进行dump，那么需要给JsonResponse传递一个safe=False参数。

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

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

return JsonResponse(persons,safe=False,json_dumps_params={'ensure_ascii':False})

类视图

类视图
在写视图的时候，Django除了使用函数作为视图，也可以使用类作为视图。使用类视图可以使用类的一些特性，比如继承等
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')

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'] = "juran"
        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")),
]

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：如果你提取数据的时候，并不是要把所有数据都返回，那么你可以重写这个方法。将一些不需要展示的数据给过滤掉。

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

Paginator常用属性和方法

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

Page常用属性和方法

has_next：是否还有下一页。
has_previous：是否还有上一页。
next_page_number：下一页的页码。
previous_page_number：上一页的页码。
number：当前页。
start_index：当前这一页的第一条数据的索引值。
end_index：当前这一页的最后一条数据的索引值。

示例分页代码
bootstrap组件
https://v3.bootcss.com/components/#pagination

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
    <ul>
        {% for i in articles %}
        <li>{{ i.id }}-{{ i.name }}</li>
        {% endfor %}
    </ul>

    <ul class="pagination">
        {% if page_obj.has_previous %}
        <li>
          <a href="{% url 'list' %}?page={{ page_obj.previous_page_number }}" aria-label="Previous">
            <span aria-hidden="true">&laquo;</span>
          </a>
        </li>
        {% else %}
        <li class="disabled">
          <a href="javascript:void(0)" aria-label="Previous">
            <span aria-hidden="true">&laquo;</span>
          </a>
        </li>
        {% endif %}
        {% for i in paginator.page_range %}
            {% if page_obj.number == i %}
                <li class="active"><a href="{% url 'list' %}?page={{ i }}">{{ i }}</a></li>
            {% else %}
                <li><a href="{% url 'list' %}?page={{ i }}">{{ i }}</a></li>
            {% endif %}
        {% endfor %}
        <!--<li><a href="#">2</a></li>-->
        <!--<li><a href="#">3</a></li>-->
        <!--<li><a href="#">4</a></li>-->
        <!--<li><a href="#">5</a></li>-->
        {% if page_obj.has_next %}
        <li>
          <a href="{% url 'list' %}?page={{ page_obj.next_page_number }}" aria-label="Next">
            <span aria-hidden="true">&raquo;</span>
          </a>
        </li>
        {% else %}
        <li class="disabled">
          <a href="#" aria-label="Next">
            <span aria-hidden="true">&raquo;</span>
          </a>
        </li>
        {% endif %}
    </ul>
</body>
</html>

分页代码

<!--article.html-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
    <ul>
        {% for i in articles %}
        <li>{{ i.id }}-{{ i.name }}</li>
        {% endfor %}
    </ul>
    <ul class="pagination">
        {% if page_obj.has_previous %}
        <li>
          <a href="{% url 'list' %}?page={{ page_obj.previous_page_number }}" aria-label="Previous">
            <span aria-hidden="true">&laquo;</span>
          </a>
        </li>
        {% else %}
        <li class="disabled">
          <a href="javascript:void(0)" aria-label="Previous">
            <span aria-hidden="true">&laquo;</span>
          </a>
        </li>
        {% endif %}
        {% if left_has_more %}
            <li><a href="{% url 'list' %}?page=1">1</a></li>
            <li><a href="javascript:void(0)">...</a></li>
        {% endif %}
        {% for i in left_range %}
            <li><a href="{% url 'list' %}?page={{ i }}">{{ i }}</a></li>
        {% endfor %}
        <li><a href="">{{ page_obj.number }}</a></li>
        {% for i in right_range %}
            <li><a href="{% url 'list' %}?page={{ i }}">{{ i }}</a></li>
        {% endfor %}
        {% if right_has_more %}
            <li><a href="javascript:void(0)">...</a></li>
            <li><a href="{% url 'list' %}?page={{ paginator.num_pages }}">{{ paginator.num_pages }}</a></li>
        {% endif %}
        {% if page_obj.has_next %}
        <li>
          <a href="{% url 'list' %}?page={{ page_obj.next_page_number }}" aria-label="Next">
            <span aria-hidden="true">&raquo;</span>
          </a>
        </li>
        {% else %}
        <li class="disabled">
          <a href="#" aria-label="Next">
            <span aria-hidden="true">&raquo;</span>
          </a>
        </li>
        {% endif %}
    </ul>
</body>
</html>

# views.py
class ArticleListVies(ListView):
    model = Publisher
    template_name = 'article_list1.html'
    paginate_by = 5
    context_object_name = 'articles'
    # ordering = 'create_time'
    page_kwarg = 'page'
    def get_context_data(self, *, object_list=None, **kwargs):
        context = super(ArticleListVies, self).get_context_data(**kwargs)
        paginator = context.get("paginator")
        page_obj = context.get("page_obj")
        # print(paginator.count)
        # print(page_obj.has_next())
        paginator_date = self.get_page(paginator,page_obj)
        context.update(paginator_date)
        return context
    def get_page(self,paginator,page_obj,page_offset=2):
        current_page = page_obj.number
        left_has_more = False
        right_has_more = False
        # 3 4 5 6 7
        if current_page <= page_offset + 2:
            left_range = range(1,current_page)
        else:
            left_has_more = True
            left_range = range(current_page-page_offset,current_page)
        #  7     10
        if current_page >= paginator.num_pages - page_offset - 1:
            right_range = range(current_page+1, paginator.num_pages+1)
        else:
            right_has_more = True
            right_range = range(current_page+1,current_page+page_offset+1)
        return {
            'left_range':left_range,
            'right_range':right_range,
            'right_has_more':right_has_more,
            'left_has_more':left_has_more
        }

错误处理

在网站开发中，会捕捉一些错误，然后将这些错误返回比较好看的界面，或是将这个错误的请求做一些日志的保存

常见的错误码

404：服务器没有指定的url。
403：没有权限访问相关的数据。
405：请求的method错误。
400：bad request，请求的参数错误。
500：服务器内部错误，一般是代码出bug了。
502：一般部署的时候见得比较多，一般是nginx启动了，然后uwsgi有问题

自定义错误模板
在碰到比如404，500错误的时候，想要返回自己定义的模板。那么可以直接在templates文件夹下创建相应错误代码的html模板文件。那么以后在发生相应错误后，会将指定的模板返回回去

修改配置文件

DEBUG = False
ALLOWED_HOSTS = ["127.0.0.1"]

错误处理的解决方案
对于404和500这种自动抛出的错误。我们可以直接在templates文件夹下新建相应错误代码的模板文件。而对于其他的错误，我们可以专门定义一个app，用来处理这些错误

views.py
from django.http import HttpResponse
from django.shortcuts import render
def view_405(request):
    return render(request,"errors/405.html",status=405)

urls.py
from django.urls import path
from . import views
urlpatterns = [
    path("405",views.view_405,name="405")
]

凉梨汁儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Django框架-高级视图部分

Django限制请求方法请求method1.GET请求：GET请求一般用来向服务器索取数据，但不会向服务器提交数据，不会对服务器的状态进行更改。比如向服务器获取某篇文章的详情。2.POST请求：POST请求一般是用来向服务器提交数据，会对服务器的状态进行更改。比如提交一篇文章给服务器。限制请求服务器Django内置的视图装饰器可以给视图提供一些限制。比如这个视图只能通过GET的method访问等。以下将介绍一些常用的内置视图装饰器1.django.views.decorators.http.re
复制链接

扫一扫