Django视图高级笔记

最新推荐文章于 2024-04-21 15:35:25 发布

wuhaiwenpps

最新推荐文章于 2024-04-21 15:35:25 发布

阅读量195

点赞数

文章标签： python django web

本文链接：https://blog.csdn.net/wuhaiwenpps/article/details/108694606

版权

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,*ags,permanent=False,**kwargs)来实现的，to是一个url，permanent代表的是这个重定向是否是一个永久的重定向，默认是False


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

HttpRequest对象

WSGIRequest对象

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

WSGIRequest对象常用属性

WSGIRequest对象上大部分的属性都是只读的，因为这些属性是从客户端上传来的，没有必要做任何的修改。
1、path:请求服务器的完整“路径”，但不包含域名和参数。比如http://www.baidu.com/xxx/yyy,那么path就是/xxx/yyy
2、method：代表当前请求的http方法，比如GET或POST
3、GET：一个django.http.request.QueryDict对象，操作起来类似于字典，这个属性中包含了所有以？xxx=xxx的方式上传上来的参数
4、POST：一个django.http.request.QueryDict对象，这个属性中包含了所有以POST的方式上传上来的参数
5、FILES：一个django.http.request.QueryDict对象，这个属性中包含了所有以上传的文件
6、COOKIES：一个标准的Python字典，包含所有的cookie，键值对都是字符串类型
7、session：一个类似于字典的对象，用来操作服务器的session
8、META：存储的客户端发送上来的所有header信息
CONTENT_LENGTH：请求的正文长度（一个字符串）
CONTENT_TYPE：请求的正文的MIME类型
HTTP_ACCEPT：响应可接受的Content-Type
HTTP_ACCEPT_ENCODING：响应可接受的编码
HTTP_ACCEPT_LANGUAGE：响应可接受的语言
HTTP_HOST：客户端发送胡HOST值
HTTP_PEFERER：在访问这个页面上一个页面的url
QUERY_STRING：单个字符串形式的查询字符串（未解析过的形式）
REMOTE_HOST：kehuduandezhujiming
REQUEST_METHOD：请求方法，一个字符串类似于GET或POST
SERVER_NAME：服务器域名
SERVER_PORT：服务器端口号，是一个字符串类型

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_url:获取请求的完整url

WSGIResponse对象

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):
		person = {"张三","李四","王五"}
		return JsonResponse(persons)

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

return JsonResponse(person,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):   #get请求
				return render(request,'get.html')
		def post(self,request,*args,**kwargs):   #post请求
				return render(request,'post.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(request,*args,**kwargs):
			return 	HttpResponse("请求方法不允许！")

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
urlplatterns = {
	path("",HomePageView.as_view(),name='home')
}

如果在模板中不需要传递任何参数，那么可以直接只在urls.py中使用TemplateView来渲染模板

urlplatterns = {
	path("",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类

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

Page常用属性和方法

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

分页代码示例

list.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>列表测试</title>
</head>
<body>
<div class="container">
    <ul>
        {% for i in articles %}
        <li>{{ i.name }} - {{ i.author }}</li>
        {% endfor %}
    </ul>
</div>
<div class="container">
    <nav aria-label="Page navigation">
        <ul class="pagination pagination-lg">
            {% if page_obj.has_previous %}
            <li>
                <a href="{% url 'page_list' %}?page={{ page_obj.previous_page_number }}" aria-label="Previous">
                    <span aria-hidden="true">&laquo;</span>
                </a>
            </li>
            {% else %}
            <li class="disabled">
                <a href="#" 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 'page_list' %}?page={{ i }}">{{ i }}</a></li>
            {% else %}
            <li><a href="{% url 'page_list' %}?page={{ i }}">{{ i }}</a></li>
            {% endif %}
            {% endfor %}


            {% if page_obj.has_next %}
            <li>
                <a href="{% url 'page_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>
    </nav>
</div>
</body>
</html>

views.py:

class ArticleListView(ListView):
    model = Book
    template_name = '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)
        # for data in context:
        #     print(data)
        return context

    def get_queryset(self):
        return Book.objects.filter()

通用分页代码示例

list.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>列表测试</title>
</head>
<body>
<div class="container">
    <ul>
        {% for i in articles %}
        <li>{{ i.name }} - {{ i.author }}</li>
        {% endfor %}
    </ul>
</div>
<div class="container">
    <nav aria-label="Page navigation">
        <ul class="pagination pagination-lg">
            {% if page_obj.has_previous %}
            <li>
                <a href="{% url 'page_list' %}?page={{ page_obj.previous_page_number }}" aria-label="Previous">
                    <span aria-hidden="true">&laquo;</span>
                </a>
            </li>
            {% else %}
            <li class="disabled">
                <a href="#" aria-label="Previous">
                    <span aria-hidden="true">&laquo;</span>
                </a>
            </li>
            {% endif %}

            {% if left_has_more == True %}
            <li><a href="{% url 'page_list' %}?page">1</a></li>
            <li><a href="{% url 'page_list' %}?page={{ page_obj.number | add:-4 }}">...</a></li>
            {% endif %}

            {% for i in left_range %}
            <li><a href="{% url 'page_list' %}?page={{ i }}">{{ i }}</a></li>
            {% endfor %}

            <li class="active"><a href="">{{ page_obj.number }}</a></li>

            {% for i in right_range %}
            <li><a href="{% url 'page_list' %}?page={{ i }}">{{ i }}</a></li>
            {% endfor %}

            {% if right_has_more == True %}
            <li><a href="{% url 'page_list' %}?page={{ page_obj.number | add:+4 }}">...</a></li>
            <li><a href="{% url 'page_list' %}?page={{ paginator.num_pages }}">{{ paginator.num_pages }}</a></li>
            {% endif %}

            {% if page_obj.has_next %}
            <li>
                <a href="{% url 'page_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>
    </nav>
</div>
</body>
</html>

views.py

from django.views.generic import TemplateView,ListView

class ArticleListView(ListView):
    model = Book
    template_name = '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)
        # for data in context:
        #     print(data)
        paginator = context.get('paginator')
        page_obj = context.get('page_obj')
        paginator_data = self.get_page(paginator,page_obj)
        context.update(paginator_data)
        return context
    def get_page(self,paginator,page_obj,page_offset=2):
        current_page = page_obj.number
        # left_range = range(current_page-page_offset,current_page)
        # right_range = range(current_page+1,current_page+page_offset+1)
        left_has_more=False
        right_has_more=False
        if current_page<=page_offset+page_offset:
            left_range=range(1,current_page)
        else:
            left_has_more = True
            left_range=range(current_page-page_offset,current_page)

        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
        }

    def get_queryset(self):
        return Book.objects.filter()

错误处理

在一些网站开发中，经常会需要捕获一些错误，然后将这些错误返回比较优美的界面，或者是将这个错误的请求做一些日志保存。

常见的错误码

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

自定义错误模板

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

#修改配置文件
DEBUG = False
ALLOWED_HOST = ["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,include
from . import view

urlpatterns = [
		path("405",views.view_405,name="405")

wuhaiwenpps

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Django视图高级笔记

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

扫一扫