Django基础（5）：views视图函数

1|0一、Django的视图函数view

　　一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。

　　响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。

　　无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。

1|11.1 一个简单的视图

　　下面是一个以HTML文档的形式返回当前日期和时间的视图：

from django.http import HttpResponse
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

 　　让我们来逐行解释下上面的代码：

  • 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。

  • 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。

    注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。

  • 这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。

　　Django使用请求和响应对象来通过系统传递状态。

　　当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

　　每个视图负责返回一个HttpResponse对象。

　　视图层，熟练掌握两个对象即可：请求对象(request)和响应对象(HttpResponse)。

2|0二、请求对象request

2|12.1 简单过程

当一个页面被请求时，Django就会创建一个包含本次请求原信息（请求报文中的请求行、首部信息、内容主体等）的HttpRequest对象。Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

　　官方文档

2|22.2 请求相关的常用值

 
path_info     返回用户访问url，不包括域名
method        请求中使用的HTTP方法的字符串表示，全大写表示。
GET           包含所有HTTP  GET参数的类字典对象
POST          包含所有HTTP POST参数的类字典对象
body          请求体，byte类型 request.POST的数据就是从body里面提取到的

2|32.3 属性

　　所有的属性应该被认为是只读的，除非另有说明。

属性：
　　django将请求报文中的请求行、头部信息、内容主体封装成 HttpRequest 类中的属性。
   除了特殊说明的之外，其他均为只读的。

HttpRequest.scheme（后面再学）
   表示请求方案的字符串（通常为http或https）

HttpRequest.body(后面再学)

　　get请求时为b''；post请求时一般为提交的数据比如：b'username=taibai' 但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。

　　一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。


　　另外，我们还可以用 python 的类文件方法去操作它，详情参考 HttpRequest.read() 。

 
HttpRequest.path 或者 HttpRequest.path_info 这两个没有本质的区别

　　一个字符串，表示请求的路径组件（不含域名）。

　　例如："/music/bands/the_beatles/"
HttpRequest.get_full_path 
　　请求路径和查询参数（提交的数据）
　　例如："/index/?username=taibai&password=123"

HttpRequest.method

　　一个字符串，表示请求使用的HTTP 方法。必须使用大写。

　　例如："GET"、"POST"

 
HttpRequest.encoding

　　一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
   这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
   接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
   如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。

 
HttpRequest.GET 

　　一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。

 

HttpRequest.POST

　　一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。

　　POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的数据，QueryDict 对象依然会被创建。
   因此，不应该使用 if request.POST  来检查使用的是否是POST 方法；应该使用 if request.method == "POST" 

　　另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。


 HttpRequest.COOKIES

　　一个标准的Python 字典，包含所有的cookie。键和值都为字符串。

 
HttpRequest.FILES

　　一个类似于字典的对象，包含所有的上传文件信息。
   FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。

　　注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
   包含数据。否则，FILES 将为一个空的类似于字典的对象。

 
HttpRequest.META

 　　一个标准的Python 字典，包含所有的HTTP 首部（请求头信息）。具体的头部信息取决于客户端和服务器，下面是一些示例：

    CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
    CONTENT_TYPE —— 请求的正文的MIME 类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送的HTTP Host 头部。
    HTTP_REFERER —— Referring 页面。
    HTTP_USER_AGENT —— 客户端的user-agent 字符串。
    QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
    REMOTE_ADDR —— 客户端的IP 地址。
    REMOTE_HOST —— 客户端的主机名。
    REMOTE_USER —— 服务器认证后的用户。
    REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
    SERVER_NAME —— 服务器的主机名。
    SERVER_PORT —— 服务器的端口（是一个字符串）。
 　　从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 的键时，
    都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。
    所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。

 

HttpRequest.user

　　一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。

　　如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。

    例如：

    if request.user.is_authenticated():
        # Do something for logged-in users.
    else:
        # Do something for anonymous users.
     

     　　user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。

     -------------------------------------------------------------------------------------

    匿名用户
    class models.AnonymousUser

    django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：

    id 永远为None。
    username 永远为空字符串。
    get_username() 永远返回空字符串。
    is_staff 和 is_superuser 永远为False。
    is_active 永远为 False。
    groups 和 user_permissions 永远为空。
    is_anonymous() 返回True 而不是False。
    is_authenticated() 返回False 而不是True。
    set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
    New in Django 1.8:
    新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。

 
HttpRequest.session

 　　一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
    完整的细节参见会话的文档。

上传文件示例

def upload(request):
    """
    保存上传文件前，数据需要存放在某个位置。默认当上传文件小于2.5M时，django会将上传文件的全部内容读进内存。从内存读取一次，写磁盘一次。
    但当上传文件很大时，django会把上传文件写到临时文件中，然后存放到系统临时文件夹中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
        filename = request.FILES["file"].name
        # 在项目目录下新建一个文件
        with open(filename, "wb") as f:
            # 从上传的文件对象中一点一点读
            for chunk in request.FILES["file"].chunks():
                # 写入本地文件
                f.write(chunk)
        return HttpResponse("上传OK")

2|42.4 方法

 
1.HttpRequest.get_host()

　　根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST 头部信息返回请求的原始主机。
   如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描述。

　　USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在代理设置了该首部的情况下，才可以被使用。

　　例如："127.0.0.1:8000"

　　注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。

 

2.HttpRequest.get_full_path()

　　返回 path，如果可以将加上查询字符串。

　　例如："/music/bands/the_beatles/?print=true"

 

3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

　　返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。

　　如果提供 default 参数，将不会引发异常并返回 default 的值。

　　可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。

        复制代码
        >>> request.get_signed_cookie('name')
        'Tony'
        >>> request.get_signed_cookie('name', salt='name-salt')
        'Tony' # 假设在设置cookie的时候使用的是相同的salt
        >>> request.get_signed_cookie('non-existing-cookie')
        ...
        KeyError: 'non-existing-cookie'    # 没有相应的键时触发异常
        >>> request.get_signed_cookie('non-existing-cookie', False)
        False
        >>> request.get_signed_cookie('cookie-that-was-tampered-with')
        ...
        BadSignature: ...    
        >>> request.get_signed_cookie('name', max_age=60)
        ...
        SignatureExpired: Signature age 1677.3839159 > 60 seconds
        >>> request.get_signed_cookie('name', False, max_age=60)
        False
        复制代码
         


4.HttpRequest.is_secure()

　　如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。

 

5.HttpRequest.is_ajax()

　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware， 
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

可以按照下面的练习一下：

from django.shortcuts import render,HttpResponse,redirect

# Create your views here.

def index(request):
    print(request.method) #请求方式
    print(request.path)   #请求路径，不带参数的
    print(request.POST)   #post请求数据  字典格式
    print(request.GET)    #get的请求数据  字典格式
    print(request.META)   #请求头信息,将来用到哪个咱们再说哪个
    print(request.get_full_path())   #获取请求路径带参数的，/index/?a=1
    print(request.is_ajax())   #判断是不是ajax发送的请求，True和False
    '''
        Django一定最后会响应一个HttpResponse的示例对象
        三种形式：
HttpResponse('字符串') 最简单

render(页面)   最重要
                2.1 两个功能
                    -- 读取文件字符串
                    -- 嵌入变量(模板渲染) html里面：{{ name }} ， {'name':'太白'}作为render的第三个参数，想写多个变量{'name':'太白','hobby':['篮球','羽毛球']....}

redirect() 重定向  最难理解,某个网站搬家了，网址变了，访问原来的网址就重定向到一个新网址，就叫做重定向，网站自己做的重定向，你访问还是访问的你之前的，
你自己啥也不用做，浏览器发送请求，然后服务端响应，然后服务端告诉浏览器，你直接跳转到另外一个网址上，那么浏览器又自动发送了另外一个请求，发送到服务端，
服务端返回一个页面，包含两次请求，登陆成功后跳转到网站的首页，网站首页的网址和你login登陆页面的网址是不用的。
                
    '''

    return render(request,'index.html',{'name':'太白'})
    # return HttpResponse('ok')

注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：

request.POST.getlist("hobby")

3|0三、响应对象HttpResponse

　　与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。

　　HttpResponse类位于django.http模块中。

3|13.1 简单使用

　　传递字符串

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

　　设置或删除响应头信息

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

　　属性

HttpResponse.content：响应内容
HttpResponse.charset：响应内容的编码
HttpResponse.status_code：响应的状态码

3|23.2 JsonResponse对象（后面再学）

　　JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

from django.http import JsonResponse

response = JsonResponse({'foo': 'bar'})
print(response.content)

b'{"foo": "bar"}'

class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None,**kwargs)

　　这个类是HttpRespon的子类，它主要和父类的区别在于：

　　　　1. 它的默认Content-Type 被设置为： application/json

　　　　2. 第一个参数，data应该是一个字典类型，当 safe 这个参数被设置为：False ,那data可以填入任何能被转换为JSON格式的对象，比如list, tuple, set。 默认的safe 参数是 True. 如果你传入的data数据类型不是字典类型，那么它就会抛出 TypeError的异常。

　　　　3. json_dumps_params参数是一个字典,它将调用json.dumps()方法并将字典中的参数传入给该方法。

#如果这样返回，ajax还需要进行json解析
#views.py
return HttpResponse(json.dumps({"msg":"ok!"}))

#index.html
var data=json.parse(data)
console.log(data.msg);

　　使用HttpResponse对象来响应数据的时候，还可以通过content_type指定格式：

return HttpResponse(json.dumps(data),content_type="application/json")

 　　　　前端调试窗口就可以看到这个类型

 　　

　　　　如果不写这个参数是这个类型：长得像json格式的字符串，当然也可以转换成json的

 

　　看下面这种，JsonResponse默认就是content_type="application/json"。

#如果这样返回，两边都不需要进行json的序列化与反序列化，ajax接受的直接是一个对象
#views.py
from django.http import JsonResponse
return JsonResponse({"msg":"ok!"})

#index.html
console.log(data.msg);

 　　默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

response = JsonResponse([1, 2, 3], safe=False)

3|33.3 具体响应方法

响应对象主要有三种形式：

  • HttpResponse()
  • render()
  • redirect() 

1|03.3.1 HttpResponse

　　HttpResponse()括号内直接跟一个具体的字符串作为响应体，比较直接很简单，所以这里主要介绍后面两种形式。

1|03.3.2 render

　　结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

　　参数： 

request： 用于生成响应的请求对象。

template_name：要使用的模板的完整名称，可选的参数

context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。

content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为'text/html'

status：响应的状态码。默认为200。

useing: 用于加载模板的模板引擎的名称。

　　一个简单的例子：

from django.shortcuts import render

def my_view(request):
    # 视图的代码写在这里
    return render(request, 'myapp/index.html', {'foo': 'bar'})

 　　上面的代码等于（了解）：

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

def my_view(request):
    # 视图代码写在这里
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

1|03.3.3 redirect

给浏览器了一个30x的状态码。

引子

比如登录成功之后，跳转到别的页面，这不是你操作的而是后台帮你操作的，为的是用户体验。还有一种情况：web网站每一段时间代码就需要更新，但是有时候更新不了了，就需要重新写一个页面，这样就会自动给你跳转到新的url上，老得网站不会维护了，还有你经常访问的网址由于某种不可描述的原因有危险了，这是需要我们重定向新的网址 哈哈。

那么为什么不给他新的？原来的老用户只是知道你的老网站。当然这只是一些情况，其实redirect具体用法还有很多，他的参数可以是：

　　1. 一个模型：将调用模型的get_absolute_url() 函数

　　2.一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称

　　3.一个绝对的或相对的URL，将原封不动的作为重定向的位置。

　　默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

示例

　你可以用多种方式使用redirect() 函数。

1. 传递一个具体的ORM对象（了解即可）

　　将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

from django.shortcuts import redirect
 
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

2. 传递一个视图的名称

# views 示例
def my_view(request):
    ...
    return redirect('home')

def home(request):
　　return HttpResponse('跳转成功！')
 
# urls示例：
urlpatterns = [
    url(r'home/', views.home, name='home'),  # 起别名，这样以后无论url如何变化，访问home直接可以映射到home函数

]

3. 传递要重定向到的一个具体的网址

def my_view(request):
    ...
    return redirect('/index')

4. 当然也可以是一个完整的网址

def my_view(request):
    ...
    return redirect('http://example.com/')

　　接下来我们做一个登录成功跳转的例子。

　　先说一下需求：我们先要写一个登录的页面，如果登录成功之后，返回此网站的主页。这个需求比较简单，之前我们已经做过，主要是对比登录成功之后：返回页面、跳转页面哪个用户体验感更好。

配置项目的urls：

rom django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'login/', views.login),
    url(r'home/', views.home, name='home'),  # 这个url映射的是跳转的页面

]

配置views函数：

def login(request):

    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        if username == 'taibai' and password == '123':
            # return render(request, 'home.html')  不改变url 只是返回了一个新页面
            return redirect('/home/')
            
        else:
            return HttpResponse('登录失败')
    else:
        return render(request, 'login.html')


def home(request):
    return render(request, 'home.html')

配置html：

login.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>你好 欢迎来到plus会所，请先登录</h1>

<form action="" method="post">
    <input type="text" name="username">
    <p></p>
    <input type="text" name="password">
    <p></p>
    <input type="submit">
</form>

</body>
</html>

home.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>登录成功，欢迎来到首页</h1>


</body>
</html>

　　如果使用render，url不变，只是返回一个新页面：

 

　　如果使用redirect，这个是直接跳转一个新的url并且返回一个新页面：

 

　　显然，登录成功之后，利用redirect跳转页面更合理并且用户体验感会更好一些，因为url含有login本身就是与登录相关的，首页放在这个url不合适。市面上基本上所有的登录成功之后都是重定向url的。

　　接下来我们在看看重定向的网络请求是什么过程的：

　　当我登录成功之后，重定向的页面出现了两次网络请求，请看下面的图：

 

　　当我提交login页面时，login页面发出了一个location：home，location我们前端讲过这个就是页面跳转呀！这里有一个状态码，302.然后又发送了一个对/home/ 路径的请求，后端接收到此请求，返回了一个页面。

# return render(request,'index.html')
如果直接用render来返回页面，是一次响应就返回了页面，两者是有区别的，并且如果你用render返回index.html页面，那么这个页面里面的模板渲染语言里面需要的数据你怎么搞，如果这些数据就是人家index那个函数里面独有的呢，你怎么搞，有人可能就响了，我把所有的数据都拿过来不就行了吗，首先如果数据量很大的话，是不是都重复了，并且你想想如果用户登陆完成之后，你们有进行跳转，那么如果网速不太好，卡一下，你想刷新一下你的页面，你是不是相当于又发送了一个login请求，你刷新完之后，是不是还要让你输入用户名和密码，你想想是不是，所有咱们一般在登陆之后都做跳转。
并且大家注意一个问题昂：redirect('/login/')如果你重定向到你当前这个函数对应的路径下，你想想是什么想过，一直重定向自己的这个网址，浏览器会报错，当然这个注册登陆页面不会出现这个报错的情况，因为需要你用户点击提交才发送请求。你可以试试那个index函数，里面返回一个redirect('/index/')
#redirect本质上也是一个HttpResponse的操作，看看源码就知道了

　　redirect：告诉浏览器给这个网址在发送一个请求。后面真正做登录的时候，我们在详细说一下这个重定向。响应相关还有一个方法叫做JsonResponse,这个我们后面会讲到。

重定向状态码

　　接下来我们讨论一下这个重定向的状态码301，302。这个两个状态码面试经常问到。

1）301和302的区别。

　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
  （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。

　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；

　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 SEO302好于301

 

2）重定向原因：
（1）网站调整（如改变网页目录结构）；
（2）网页被移到一个新地址；
（3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
        这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；再者某些注册了多个域名的
    网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。

对普通用户来说是没什么区别的，它主要面向的是搜索引擎的机器人。

　　A页面临时重定向到B页面，那搜索引擎收录的就是A页面。

　　A页面永久重定向到B页面，那搜索引擎收录的就是B页面。

用redirect可以解释APPEND_SLASH的用法！这个不讲~~

4|0四、 CBV和FBV

　　FBV（function base views） 就是在视图里使用函数处理请求。之前都是FBV模式写的代码，所以就不写例子了。

　　CBV（class base views） 就是在视图里使用类处理请求。

　　Python是一个面向对象的编程语言，如果只用函数来开发，有很多面向对象的优点就错失了（继承、封装、多态）。所以Django在后来加入了Class-Based-View。可以让我们用类写View。这样做的优点主要下面两种：

  1. 提高了代码的复用性，可以使用面向对象的技术，比如Mixin（多继承）
  2. 可以用不同的函数针对不同的HTTP方法处理，而不是通过很多if判断，提高代码可读性

4|14.1 CBV演示简单登录流程

CBV与FBV在url、views写法上有一些不同，下面有一些细节一定要注意。

views视图函数

from django.shortcuts import render,HttpResponse
from django.views import View  # 从django.views模块中引用View类



class Login(View):
    """
    自己定义get post方法，方法名不能变。这样只要访问此url，get请求自动执行get方法，post请求自动执行post方法，与我们写的FBV 
if request.method == 'GET' or 'POST' 一样。
    """
    def get(self, request):

        return render(request, 'login.html')

    def post(self, request):

        username = request.POST.get('username')
        password = request.POST.get('password')

        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

urls路由

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^login/', views.Login.as_view()),
    # 引用views函数重的Login类，然后调用父类的as_view()方法
]

CBV传参，和FBV类似，有名分组，无名分组

url写法：无名分组的

url(r'^cv/(\d{2})/', views.Myd.as_view(),name='cv'),
url(r'^cv/(?P<n>\d{2})/', views.Myd.as_view(name='xxx'),name='cv'),#如果想给类的name属性赋值，前提你的Myd类里面必须有name属性（类属性，定义init方法来接受属性行不通，但是可以自行研究一下，看看如何行通，意义不大），并且之前类里面的name属性的值会被覆盖掉

templates的html

login.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>你好 欢迎来到plus会所，请先登录</h1>

<form action="" method="post">
    <input type="text" name="username">
    <p></p>
    <input type="text" name="password">
    <p></p>
    <input type="submit">
</form>

</body>
</html>

　　别忘了settings中间件注释掉。这样启动项目之后，我们就完成了一个简单的登录功能。

 

补充一个类的写法

类写法：

class Myd(View):
    name = 'sb'

    def get(self,request,n):
        print('get方法执行了')
        print('>>>',n)
        return render(request,'cvpost.html',{'name':self.name})

    def post(self,request,n):
        print('post方法被执行了')
        return HttpResponse('post')

 　　添加类的属性可以通过两种方法设置，第一种是常见的Python的方法，可以被子类覆盖。

from django.http import HttpResponse
from django.views import View
  
class GreetingView(View):
    name = "yuan"
    def get(self, request):
         return HttpResponse(self.name)
  
# You can override that in a subclass
  
class MorningGreetingView(GreetingView):
    name= "alex"

　　第二种方法，你也可以在url中指定类的属性：

　　在url中设置类的属性Python

urlpatterns = [
   url(r'^index/$', GreetingView.as_view(name="egon")), #类里面必须有name属性，并且会被传进来的这个属性值给覆盖掉
]

4|24.2 执行流程的源码解析

1. 请求发送到这里，先要执行as_view()方法。

　　views.py里面的Login是一个类，类.方法(),那么这个as_view()方法肯定是静态方法或者类方法，但是我们定义Login类时没有定义这个方法，只能从父类查找，也就是查找源码的View。

2. 执行父类View里面的as_view()方法。

--

我将部分源码拿来，咱们去分析：

第一部分：

        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

第一个框框出来的就是各种主动抛异常，cls肯定就是我们Login类名了，http_method_names从源码中可以获取到是一个列表：
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']
虽然我们现在不知道initkwargs是什么，但是我们可以大概分析出来，如果你的请求方式不是这个列表中的任意一个，我就会给你抛出一个异常。

第二部分是定义了一个view函数，但是现在还没有执行此函数的执行，所以我们直接跳过分析。

第三部分：

view.view_class = cls
view.view_initkwargs = initkwargs
# 上面两行是给函数view封装两个属性：之前我们没有说过函数也可以封装属性，python中一些皆对象，view函数也是一个对象，这个对象是从function类实例化得来的，我通过dir(view)可知，他有'__setattr__'方法，有这个方法，给view封装属性时，就会执行这个方法不报错，那么这个方法就是实现了给一个函数封装一个属性的功能，你可以随意定义一个函数试一试。
view_class = cls cls 也就是Login类
view_initkwargs  = initkwargs initkwargs目前我不确定是什么，但是我可以猜到他应该是与请求方式相关的。

# take name and docstring from class
update_wrapper(view, cls, updated=())
# 这里源码给了解释：这个update_wrapper函数就是从类中获取名字和类的描述消息

# and possible attributes set by decorators
# like csrf_exempt from dispatch
update_wrapper(view, cls.dispatch, assigned=())
# 这个大概意思就是从装饰器中获取设置的属性，
# 上面这两个函数对我们研究流程来说没有什么影响所以我们可以暂不考虑

这样三部分我们分析完成了，至此源码中的as_view()函数执行完毕，但是千万别忘了，他有个返回值就是此as_view()函数中的view函数地址。其实你自己看一下，as_view函数就是一个闭包。

3. 程序又跳转到url路由

　　此时url路由就变成了这个样子：

　　这个我们是不是似曾相识？ 我们之前一直写FBV时，你没有过疑问么？当你发送一个请求时，通过url映射到相应的函数，函数是不是就直接执行了？？？下面是一个FBV模式，对应函数直接就会执行了。

　　所以！对应的view函数也会自动执行。

4. 执行源码中的view函数

源码中的view函数如下：

def view(request, *args, **kwargs):
    self = cls(**initkwargs)  # 对Login函数实例化对象为self
    if hasattr(self, 'get') and not hasattr(self, 'head'):  # 判断self对象是否有get并且没有head方法，条件给self对象设置head属性为self.get
        self.head = self.get
　　# 下面给self对象设置三个属性，我们就关注第一个self.request = request，将请求相应相关的内容封装到request属性中
    self.request = request
    self.args = args
    self.kwargs = kwargs
    return self.dispatch(request, *args, **kwargs)  # 最关键的两步：第一步：先执行dispath方法，得到返回值；第二步，在返回给view方法的调用者。

5. 执行源码中dispath方法。

源码中的dispatch函数如下：

def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
　　　　　''' 
　　　　　　　上面源码给的解释很清楚了，如果请求的方法不存在则执行错误的handler，如果请求的方法正确且存在http_method_names列表中，执行正确的方法。
　　　　　'''

        if request.method.lower() in self.http_method_names:
　　　　　　　# self就是自己在views文件中定义的Login类的对象，这里假如是get请求，此请求正确且存在，则执行Login类中的get方法，如果是post请求则执行post方法。
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs) 
　　　　 # 最后将handler()函数的返回值返回。handler函数是什么？假如我们是get请求，hander()就是我们在Login类中的get(),我们get()是给浏览器返回的html页面，则其实你的页面最终是url这里面返回的。

仔细想想下面的图：

 

　　至此，整个流程我们就算较为详细的走完了。

1|0思考题

　　这里，面试有问过，如果你用CBV模式，你的get或者post方法是从哪里执行的？ 能否在get执行之前或者之后做一些特殊的操作？

5|0五、视图函数的装饰器 

　　其实对于上面的思考题，如果你对我讲的这个流程整清楚，那么就好实现，你的get或者post方法都是在源码的dispatch方法中执行的，我们可以利用重写父类的dispatch方法，就能够对get和post请求搞事情了。但是如果我想单独对某个请求方法搞事情，那么只能加上装饰器了。也就是我们本节所讲到的功能。

5|15.1 FBV装饰器

　　对于FBV这种开发方式，加上装饰器很简单，就是我们之前讲过的方式。这种比较简单，我直接展示view视图函数的代码即可。

def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner

@wrapper
def home(request):
    print('执行home函数')
    return render(request, 'home.html')

　　这样你后端的代码为：

请求来了！
执行home函数
请求走了！

　　所以，对于FBV模式来说，加上装饰器对我们来说易如反掌。

5|25.2 CBV装饰器

　　由于CBV模式是面向对象的开发方式，之前一直没有提过是否能给类的方法加上装饰器，其实是可以的。列举出以下给类的方法加装饰器的几种方式。

1.方法一：直接加装饰器。

　　这里我们就只是展示views函数，因为template、urls都非常简单，而且上面也有代码示例，所以就不在这里展示了。

　　views视图函数

def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner


class Login(View):

    @wrapper
    def get(self, request):
        print('get 方法')
        return render(request, 'login.html')

    def post(self, request):

        username = request.POST.get('username')
        password = request.POST.get('password')

        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

'''
执行流程：
请求来了！
执行home函数
请求走了！
'''

2.方法二：借助method_decorator模块。

from django.utils.decorators import method_decorator
def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner


class Login(View):

    @method_decorator(wrapper)
    def get(self, request):
        print('get 方法')
        return render(request, 'login.html')

    def post(self, request):

        username = request.POST.get('username')
        password = request.POST.get('password')

        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

　　那么这两种方式都可以，为什么还要用引用模块去加装饰器呢？这里就要说一下他们的区别了，method_decorator模块相当于给你自己写的装饰器又套了一层，他与我们自己写的装饰器唯一的区别就是传递给wrapper装饰器的内层的inner函数的参数有所不同。这里我们可以在wrappr装饰器的inner函数里面打印一下参数：

def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！', args,**kwargs)
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner

　　通过我们对比测试，说一下不同：

　　将自定义的装饰器装饰类中的方法：传给inner闭包函数的参数与该方法中的参数一致：在我们的例子中有：self，request。引用method_decorator包装的装饰器装饰类中的方法：传给inner闭包函数的参数不会传递self，在我们的例子中：只有request。

3. 方式三：给所有的方法都加上装饰器

　　我们上面两种方法都是单独给某个方法加上装饰器，那么我们如何给这个类的所有方法都加上装饰器呢？有同学说这个你给每个方法上面加上@wrapper不就行了，这样太low了。有没有更简单的方式呢？那就要想到我们的源码dispatch方法。我们可以在子类中重写父类的dispatch方法，因为无论执行什么请求方法（post，get，push，delete等等）都是dispatch方法利用反射调用的。所以，我们给此方法加上装饰器即可。

class Login(View):
   
    @wrapper
    def dispatch(self, request, *args, **kwargs):
        ret = super().dispatch(request, *args, **kwargs)
        return ret
    ......

4. 方式四：直接在类上加装饰器（不常用）。

@method_decorator(wrapper,name='get')
class Login(View):
    ......

# 这种方式，只能给某个方法加上装饰器，如果想给多个方法加上装饰器，需要多层嵌套，不常用。

注意：

　　注意csrf-token装饰器的特殊性，在CBV模式下它只能加在dispatch上面(后面再说)

　　下面这是csrf_token的装饰器：

　　@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置csrfToken全局中间件。

　　@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

　　注意：from django.views.decorators.csrf import csrf_exempt,csrf_protect

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


__EOF__

本文作者：😎
本文链接：https://www.cnblogs.com/dongye95/p/13436184.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @   dongye95  阅读(547)  评论(0)  编辑  收藏  举报
编辑推荐：
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！
点击右上角即可分享
微信分享提示