request本质就是WSGIRequest的实例对象，父类是from django.http.request import HttpRequest
一.HttpRequest.method
　　获取请求使用的方法（值为纯大写的字符串格式）。例如："GET"、"POST"
   应该通过该属性的值来判断请求方法

   在视图函数中：
   if request.method == "GET":
       ...
   if request.method == "POST":
       ...

二.HttpRequest.GET
　　值为一个类似于字典的QueryDict对象，封装了GET请求的所有参数，可通过HttpRequest.GET.get('键')获取相对应的值
    http://127.0.0.1:8000/app01/login?name=allen&passwd=123
	<QueryDict: {'name': ['allen'], 'passwd': ['123']}>
    QueryDict 是一个经过封装的字典，提供了基本的字典操作，还提供额外的操作给开发者获取字典内部的数据，因为python基本数据类型dict是无法让字典在一个key下指向多个值的情况，所以Django封装了一个新的字典来实现

   在视图函数中：
   request.GET.get('name')

三.HttpRequest.POST
   值为一个类似于字典的QueryDict对象，封装了POST请求所包含的表单数据，可通过HttpRequest.POST.get('键')获取相对应的值

   在视图函数中：
   request.POST.get('name')

   针对表单中checkbox类型的input标签、select标签提交的数据，键对应的值为多个，需要用：HttpRequest.POST.getlist("hobbies")获取存有多个值的列表,同理也有HttpRequest.GET.getlist("键")
   针对有多个值的的情况，也可以用HttpRequest.GET.get("键")，会获取列表中的最后一个值
四. 比如
	request.method	   获取请求动作
    request.path       获取请求地址
    request.path_info  获取请求地址信息
    request.get_port	 获取端口
    

一.HttpRequest.body
  1.1 当浏览器基于http协议的GET方法提交数据时(没有请求体一说),数据会按照k1=v1&k2=v2&k3=v3的格式放到url中，然后发送给django，django会将这些数据封装到request.GET中，注意此时的请求体request.body为空、无用

  1.2 当浏览器基于http协议的POST方法提交数据时，数据会被放到请求体中发送给django，django会将接收到的请求体数据存放于HttpRequest.body属性中.
  但该属性的值为Bytes类型(套接字数据传输都是bytes类型)，而通常情况下直接处理Bytes、并从中提取有用数据的操作是复杂而繁琐的，好在django会对它做进一步的处理与封装以便我们更为方便地提取数据，具体如何处理呢？

  当前端采用POST提交数据时，数据有三种常用编码格式，编码格式不同Django会有不同的处理方式
  # 编码格式1：application/x-www-form-urlencoded，是form表单默认编码格式
  # 编码格式2：multipart/form-data，上传文件专用格式
  # 编码格式2：application/json，提交json格式字符串

  #====》I: 当POST数据的编码格式为application/x-www-form-urlencoded时《====
      HttpRequest.body中的数据格式为b'a=1&b=2&c=3'
      django会将其提取出来封装到request.POST中
      request.FILES此时为空

      如：
      print(request.body) # b'a=1&b=2&c=3'
      print(request.POST) # <QueryDict: {'a': ['1'],'b': ['2'],'c': ['3']}
      print(request.FILES) # <MultiValueDict: {}>


  #====》II: 当POST数据的编码格式为multipart/form-data时《====
      详见：https://my.oschina.net/cnlw/blog/168466?fromerr=aQL9sTI2

      HttpRequest.body中的数据格式为b'------WebKitFormBoundaryKtcwuksQltpNprep\r\nContent-Disposition: form-data;......',注意，文件部分数据是流数据，所以不在浏览器中显示是正常的
      django会将request.body中的非文件数据部分提取出来封装到request.POST中
      将上传的文件部分数据专门提取出来封装到request.FILES属性中

      如：
      print(request.body) # 不要打印它，打印则报错，因为它是数据流
      print(request.POST) # <QueryDict: {'a': ['1'],'b': ['2'],'c': ['3']}
      print(request.FILES) # <MultiValueDict: {'head_img': [<InMemoryUploadedFile: 11111.jpg (image/jpeg)>]}>

      强调：
        1、毫无疑问，编码格式2的数据量要大于编码格式1，如果无需上传文件，还是推荐使用更为精简的编码格式1
        2、FILES will only contain data if the request method was POST and the <form> that posted to the request had enctype="multipart/form-data". Otherwise, FILES will be a blank dictionary-like object.

  #===》III: 当POST数据的编码格式为application/json时《====
      此时在django后台，request.POST和request.FILES中是没有值的，都放到request.body中了，需要用json.loads对其进行反序列化

      如：
      print(request.body) # b'{"a":1,"b":2,"c":3}'
      print(request.POST) # <QueryDict: {}>
      print(request.FILES) # <MultiValueDict: {}>


  1.3 如何设定POST提交数据的编码格式 
    前端往后台POST提交数据，常用技术有form表单和ajax两种
    form表单可以设置的数据编码格式有：编码格式1、编码格式2
    ajax可以设置的数据编码格式有：编码格式1、编码格式2、编码格式3

    我们将在后续章节中介绍ajax技术，此处我们先介绍我们熟知的form表单
    form表单可以通过属性enctype进行设置编码格，如下
      编码格式1(默认的编码格式):enctype="application/x-www-form-urlencoded" 
      编码格式2(使用form表单上传文件时只能用该编码):enctype="multipart/form-data"

一.HttpRequest.path
　　获取url地址的路径部分，只包含路径部分

二.HttpRequest.get_full_path()
　　获取url地址的完整path，既包含路径又包含参数部分

如果请求地址是http://127.0.0.1:8000/order/?name=allen&age=10#_label3，
HttpRequest.path的值为"/order/"
HttpRequest.get_full_path()的值为"/order/?name=allen&age=10"

"""
　　django将请求报文中的请求行、头部信息、内容主体封装成 HttpRequest 类中的属性。
   除了特殊说明的之外，其他均为只读的。
"""
一.HttpRequest.META
 　 值为包含了HTTP协议的请求头数据的Python字典，字典中的key及期对应值的解释如下
    CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
    CONTENT_TYPE —— 请求的正文的MIME类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送数据的目标主机与端口
    HTTP_REFERER —— Referring 页面。
    HTTP_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 的键时，
    都会
    1、将所有字母大写
    2、将单词的连接符替换为下划线
    3、加上前缀HTTP_。
    所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。

注意：下述常用属性暂且了解即可，待我们讲到专门的知识点时再专门详细讲解
二.HttpRequest.COOKIES
　　一个标准的Python 字典，包含所有的cookie。键和值都为字符串。

三.HttpRequest.session
 　一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。

11.HttpRequest.user(用户认证组件下使用)

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

2.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') 装饰你的视图以让响应能够正确地缓存。

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

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

六.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.

    HttpRequest.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。

from django.shortcuts import HttpResponse
from django.shortcuts import redirect
from django.shortcuts import render
from django.http importJsonResponse

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

'''
ps：Content-Type用于指定响应体的MIME类型

MIME类型：
mime类型是多用途互联网邮件扩展类型。是设定某种扩展名的文件用一种应用程序来打开的方式类型,当该扩展名文件被访问的时候,浏览器会自动使用指定应用程序来打开


MIME 类型有非常多种，一般常见的有：

　　text/html：浏览器在获取到这种文件时会自动调用html的解析器对文件进行相应的处理。

　　text/plain：意思是将文件设置为纯文本的形式，浏览器在获取到这种文件时并不会对其进行处理。

　　image/jpeg：JPEG格式的图片

　　image/gif：GIF格式的图片

　　video/quicktime：Apple 的 QuickTime 电影

　　application/vnd.ms-powerpoint：微软的powerpoint文件
'''

>>> response = HttpResponse()
>>> response.write("<p>Here's the text of the Web page.</p>")
>>> response.write("<p>Here's another paragraph.</p>")

## 可以为HttpResponse传递可迭代对象，HttpRespone会将其依次迭代然后存储成字符串，类似文件或者其他带有close()方法的生成器对象，会自动调用close()关闭

def index(request):
    f=open(r'a.txt',mode='r',encoding='utf-8') # a.txt文件内容为111
    response=HttpResponse(f)
    print(response.content) # 打印内容为: b'111'

    # f.read() # 如果执行，则会抛出异常，说明文件已经关闭了，无法读取
    return response

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

HttpResponse.status_code：响应的状态码

HttpResponse.charset：响应内容的编码encode格式

HttpResponse.content：响应内容

def index(request):
    '''相应内容'''
    '''
    通过django.http.response.HttpResponse响应html内容
    return HttpResponse("<h1>HELLO</h1>") 
    content: 响应正文内容
    status： 响应状态码
    content-type: 响应内容的MIME类型
    ret = HttpResponse(content='HELLO',status='206',content_type='text/html')
    return ret
    '''
    # 返回其他格式内容如：图片信息，文件，资源下载。。。
    content=open('qqq.png','rb').read()
    return HttpResponse(content=content,status=206,content_type="image/png")

def wget(request):
    with open(r"C:\Users\User\Downloads\app.zip", 'rb') as f:
        content=f.read()
    return HttpResponse(content=content,content_type="application/x-zip-compressed")

## 编码设定原则：编码格式与解码格式保持一致
response = HttpResponse(charset='gbk',content_type='text/html; charset=gbk')

## 参数charset='gbk'指定响应体内容response.content的编码格式
## 参数content_type='text/html; charset=gbk'是设置响应头，用于告诉浏览器响应体内容response.content应该采用何种解码格式，注意：设置时必须加上内容的类型，如text/html

## 强调：
## 如果在实例化HttpResponse时没有指定charset=gbk'，将会采用与content_type中设定的解码格式一样的编码，这样统一起来就不会出现乱码问题
## 如果也没有指定content_type，那么django默认会读取配置文件中的配置settings.py.DEFAULT_CHARSET来作为默认的编码与解码格式

def index(request):
    response = HttpResponse(charset='gbk',content_type='text/html; charset=gbk')
    response.charset='gbk' # 实例化后，可以对该属性重新赋值，只要是在write内容前，就会以最新赋值的编码格式为准

    response.write("<p>Hello allen美男子</p>")
    response.write("<p>Hello 林sb</p>")

    # 如果实例化处未指定响应头Content-Type，也可以在此处设置，在一处就可以了，无需重复设置
    response['Content-Type']='text/html; charset=gbk'  
    # response['Content-Type']='text/html; charset=UTF-8' 

    print(response.charset)
    print(response.content) 
    return response

def render(request, template_name, context=None, content_type=None, status=None, using=None):
    """
    Return a HttpResponse whose content is filled with the result of calling
    django.template.loader.render_to_string() with the passed arguments.
    """
    content = loader.render_to_string(template_name, context, request, using=using)
    return HttpResponse(content, content_type, status)

参数：
    1、request：用于生成响应的请求对象，固定必须传入的第一个参数

    2、template_name：要使用的模板的完整名称，必须传入，render默认会去templates目录下查找模板文件

    3、context：可选参数，可以传入一个字典用来替换模块文件中的变量，默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。

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

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

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

##启动django，在浏览器中访问url地址http://ip地址:端口号/，会看到{{ name }} {{ tag }}被替换成了allen和dsb

返回重定向对象，返回的状态码为302，第一个参数用来指定浏览器重定向的地址，可以是
##1、一个完全标准的URL地址，如'https://www.yahoo.com/search/'
##2、也可以是一个没有域名的绝对路径，如'/search/'
##3、或者是一个没有域名的相对路径，如'search/',与1、2直接跳转到指定的绝对路径不同，相对路径需要先与当前路径进行拼后才能跳转，例如：如果当前路径为http://127.0.0.1:8080/index/，拼接后的路径为http://127.0.0.1:8080/index/search/

def baidu(request):
    return redirect("https://www.baidu.com")

## redirect重定向等同于下述操作
def baidu(request):
    '''浏览器收到Location和302后就自动跳转'''
    response=HttpResponse("",status=302)	# 自定义响应头
    # response['Location']='/register/'
    response["Location"]="https:/www.baidu.com"	# 发送Location响应信息指定跳转地址 
    return response 

启动django，在浏览器中访问url地址http://ip地址:端口号/index/，跳转到login页面

一、301和302的异同。
   1、相同之处：
   301和302状态码都表示重定向，具体点说就是浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址（浏览器会从响应头Location中获取新地址），用户看到的效果都是输入地址A后瞬间跳转到了另一个地址B

   2、不同之处：
　　301表示永久重定向，旧地址A的资源已经被永久地移除了，即这个资源不可访问了。
　　302表示临时重定向，旧地址A的资源还在，即这个资源仍然可以访问。

    A页面临时重定向到B页面，那搜索引擎收录的就是A页面。
    A页面永久重定向到B页面，那搜索引擎收录的就是B页面。
    从SEO层面考虑，302要好于301

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

def index(request):
    import json
    content={
            "name":"xiaoming",
            "age":30,
            "son":{
                "name":"xiaoxiaoming",
                "age":3
            }
        }
    content=json.dumps(content)
    return HttpResponse(content=content,status=206,content_type="application/json")
  # return HttpResponse(content=content)

def index(request):
    from django.http import JsonResponse
    content={
            "name":"xiaoming",
            "age":30,
            "son":{
                "name":"xiaoxiaoming",
                "age":3
            }
        }
    return JsonResponse(content)
#### 如果是以列表的方式返回会报错
##	TypeError at /app01/index/
##	In order to allow non-dict objects to be serialized set the safe parameter to False.
def index(request):
    from django.http import JsonResponse
    content=[
        {"id":10,"title":"qqqqq","pric":10},
        {"id":11,"title":"wwwwww","pric":10},
    ]
    return JsonResponse(content,safe=False)
    #默认safe=True代表只能序列化字典对象，safe=False代表序列化字典以外的对象

1、400：400 Bad Request 是由于明显的客户端错误（例如，格式错误的请求语法，太大的大小，无效的请求消息或欺骗性路由请求），服务器不能或不会处理该请求。
2、403：用户没有访问某一资源的权限
3、404：请求的url地址不存在
4、500：服务端出错

## 针对上述四种错误，django框架内置了处理异常的视图，如下
from django.views.defaults import bad_request # 用来处理400异常
from django.views.defaults import permission_denied # 用来处理403异常
from django.views.defaults import page_not_found # 用来处理404异常
from django.views.defaults import server_error # 用来处理500异常

## 此处由于篇幅问题，请读者自行查看源码，通过查看源码，可以知道
## 1、内置的异常处理视图会去固定位置找对应的文件名，这就是我们自定制错误页面文件位置与文件名固定的原因
## 2、内置的异常处理视图，针对400和500错误返回的就是静态页面，而针对403和404错误会用异常变量exception来渲染页面，我们在定制403.html、404.html页面时设定一个模板语法{{ exception }}就是用来专门接收异常值的

## settings.py
DEBUG = False # 在生产环境中就应该设置成False

## ps：设置完DEBUG=False后，必须设置ALLOWED_HOSTS才能启动django，设为ALLOWED_HOSTS = ['*']即可
ALLOWED_HOSTS = ['*']

## 在浏览器依次输入下述url地址，会执行对应的视图函数，触发异常，django内置的异常处理视图会捕捉异常并返回我们定制的错误页面
http://127.0.0.1:8002/test/400
http://127.0.0.1:8002/test/403
http://127.0.0.1:8002/test/404
http://127.0.0.1:8002/test/500

1、FBV基于函数的视图（Function base views），我们之前一直介绍的都是FBV

2、CBV基于类的视图(Class base views)，我们本节主要介绍它

1、针对不同的HTTP请求方法(如GET、POST)，CBV可以分别对应到专门的处理方法上，无需采用条件分支，代码更加精简

2、CBV采用面向对象技术，比如mixins（多重继承）可用于将代码转换成可重用的组件。

from django.http import HttpResponse

def my_view(request):
    if request.method == 'GET':
        # <view logic>
        return HttpResponse('GET result')
    elif request.method == 'POST':
        # <view logic>
        return HttpResponse('POST result')

from django.http import HttpResponse
from django.views import View

class MyView(View):
    def get(self, request):
        # <view logic>
        return HttpResponse('GET result')

    def post(self, request):
        # <view logic>
        return HttpResponse('POST result')

1、调用self.setup()方法，用于初始化一系列属性。
2、之后调用self.dispatch(),该方法查看request以确定本次请求是GET还是POST等，如果定义了匹配方法，则将请求转发给匹配方法；如果没有，则引发HttpResponseNotAllowed。本例中将调用我们自定义的get与post方法来响应请求

ps：基于面向对象的知识，上述方法，如果子类MyView未重写，则去父类View中寻找

## urls.py
from django.urls import path
from myapp.views import MyView

urlpatterns = [
    path('about/', MyView.as_view()),
]

from django.views import View

class GreetingView(View):
    greeting = "Good Day"

    def get(self, request):
        return HttpResponse(self.greeting)

## 可以在子类中对属性进行重写
class MorningGreetingView(GreetingView):
    greeting = "Morning to ya"

## 在url配置中使用子类调用as_view()方法即可
from django.urls import path
from myapp.views import MyView

urlpatterns = [
    path('about/', MorningGreetingView.as_view()),
]

urlpatterns = [
    path('about/', GreetingView.as_view(greeting="G'day")),
]

## 注意1：as_view方法只接受已经是类属性的参数，即在类GreetingView中必须已经有greeting属性，as_view只是一种覆盖操作
from django.views import View

class GreetingView(View):
    greeting = "Good Day" # 必须已经有了该属性

    def get(self, request):
        return HttpResponse(self.greeting)

## 注意2：这种覆盖操作只在本条url匹配成功时生效一次
urlpatterns = [
    # 访问结果为覆盖后的属性值:"G'day"
    path('about/', GreetingView.as_view(greeting="G'day")),
    # 访问结果仍为原值:"Good Day"
    path('about1/', views.GreetingView.as_view()),
]

from django.views.generic.base import TemplateResponseMixin

from django.views.generic import View,TemplateView,RedirectView

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

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

from django.urls import path
from django.views.generic import RedirectView
from app01 import views

urlpatterns = [
    path('index/', views.index),
    path('about/', RedirectView.as_view(url="/index/")),
]

from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import MyForm # forms.py内的MyForm表单类

def myview(request):
    if request.method == "POST":
        form = MyForm(request.POST)
        if form.is_valid():
            # <process form cleaned data>
            return HttpResponseRedirect('/success/')
    else:
        form = MyForm(initial={'key': 'value'})

    return render(request, 'form_template.html', {'form': form})

from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.views import View

from .forms import MyForm

class MyFormView(View):
    form_class = MyForm
    initial = {'key': 'value'}
    template_name = 'form_template.html'

    def get(self, request, *args, **kwargs):
        form = self.form_class(initial=self.initial)
        return render(request, self.template_name, {'form': form})

    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST)
        if form.is_valid():
            # <process form cleaned data>
            return HttpResponseRedirect('/success/')

        return render(request, self.template_name, {'form': form})

## 导入内置的装饰器
from django.contrib.auth.decorators import login_required, permission_required 
from django.views.generic import TemplateView

from .views import VoteView

urlpatterns = [
    path('about/', login_required(TemplateView.as_view(template_name="secret.html"))),
    path('vote/', permission_required('polls.can_vote')(VoteView.as_view())),
]

## views.py
from django.shortcuts import render, HttpResponse
from django.views import View
from django.utils.decorators import method_decorator
import time

## 装饰器
def timer(func):
    def wrapper(request, *args, **kwargs):
        start = time.time()
        ret = func(request, *args, **kwargs)
        print("函数执行的时间是{}".format(time.time() - start))
        return ret

    return wrapper

## CBV视图
class LoginView(View):
    #相当于给get,post请求都加上了装饰器
    @method_decorator(timer)
    def dispatch(self, request, *args, **kwargs):
        obj = super().dispatch(request, *args, **kwargs)
        return obj

    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 == 'egon' and password == '123':
            return HttpResponse('登录成功')
        else:
            return HttpResponse('账号或密码错误')

from django.urls import path
from app01.views import *
urlpatterns = [
    path('login/',LoginView.as_view()),
]

......省略代码,同上

class LoginView(View):
    def dispatch(self, request, *args, **kwargs):
        obj = super().dispatch(request, *args, **kwargs)
        return obj

    @method_decorator(timer) # 只装饰get方法
    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 == 'egon' and password == '123':
            return HttpResponse('登录成功')
        else:
            return HttpResponse('账号或密码错误')

## @method_decorator(timer,name='dispatch') # 批量添加
@method_decorator(timer,name='get') # 单独给get方法添加
## @method_decorator(timer,name='post') # 单独给post方法添加
class LoginView(View):
    def dispatch(self, request, *args, **kwargs):
        obj = super().dispatch(request, *args, **kwargs)
        return obj

    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 == 'egon' and password == '123':
            return HttpResponse('登录成功')
        else:
            return HttpResponse('账号或密码错误')

from django.shortcuts import render, HttpResponse
from django.views import View
from django.utils.decorators import method_decorator
import time

## 定义多个装饰
def deco1(func):
    def wrapper(request, *args, **kwargs):
        print('===>deco1')
        ret = func(request, *args, **kwargs)
        return ret
    return wrapper

def deco2(func):
    def wrapper(request, *args, **kwargs):
        print('===>deco2')
        ret = func(request, *args, **kwargs)
        return ret
    return wrapper

## 定义装饰列表
decorators = [deco1, deco2]

@method_decorator(decorators,name='get') # 为get方法添加多个装饰器
class LoginView(View):
    def dispatch(self, request, *args, **kwargs):
        obj = super().dispatch(request, *args, **kwargs)
        return obj

    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 == 'egon' and password == '123':
            return HttpResponse('登录成功')
        else:
            return HttpResponse('账号或密码错误')

......省略代码,同上

@method_decorator(deco1,name='get')
@method_decorator(deco2,name='get')
class LoginView(View):
    def dispatch(self, request, *args, **kwargs):
        obj = super().dispatch(request, *args, **kwargs)
        return obj

    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 == 'egon' and password == '123':
            return HttpResponse('登录成功')
        else:
            return HttpResponse('账号或密码错误')