Django的View(視圖)

視圖
    - Django的View(視圖)
        一個視圖函數(類),簡稱視圖,是一個簡單的Python 函數(類),它接受Web請求而且返回Web響應。

        響應能夠是一張網頁的HTML內容,一個重定向,一個404錯誤,一個XML文檔,或者一張圖片。

        不管視圖自己包含什麼邏輯,都要返回響應。代碼寫在哪裏也無所謂,只要它在你當前項目目錄下面。
        除此以外沒有更多的要求了——能夠說「沒有什麼神奇的地方」。爲了將代碼放在某處,你們約定成俗將
        視圖放置在項目(project)或應用程序(app)目錄中的名爲views.py的文件中。 

    - 一個簡單的視圖
        - 下面是一個以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對象。

    - CBV和FBV
        - class based view
        - function base view

        咱們以前寫過的都是基於函數的view,就叫FBV。還能夠把view寫成基於類的。

        就拿咱們以前寫過的添加班級爲例:

        FBV版:
        
        # FBV版添加班級
        def add_class(request):
            if request.method == "POST":
                class_name = request.POST.get("class_name")
                models.Classes.objects.create(name=class_name)
                return redirect("/class_list/")
            return render(request, "add_class.html")
        
        CBV版:
        
        # CBV版添加班級
        from django.views import View

        class AddClass(View):

            def get(self, request):
                return render(request, "add_class.html")

            def post(self, request):
                class_name = request.POST.get("class_name")
                models.Classes.objects.create(name=class_name)
                return redirect("/class_list/")

        注意:
            使用CBV時,urls.py中也作對應的修改:
            # urls.py中
            url(r'^add_class/$', views.AddClass.as_view()),


    - 給視圖加裝飾器
        - 使用裝飾器裝飾FBV
            - FBV自己就是一個函數,因此和給
                def wrapper(func):
                    def inner(*args, **kwargs):
                        start_time = time.time()
                        ret = func(*args, **kwargs)
                        end_time = time.time()
                        print("used:", end_time-start_time)
                        return ret
                    return inner


                # FBV版添加班級
                @wrapper
                def add_class(request):
                    if request.method == "POST":
                        class_name = request.POST.get("class_name")
                        models.Classes.objects.create(name=class_name)
                        return redirect("/class_list/")
                    return render(request, "add_class.html")



        - 使用裝飾器裝飾CBV
            - 類中的方法與獨立函數不徹底相同,所以不能直接將函數裝飾器應用於類中的方法 ,咱們須要先將其轉換爲方法裝飾器。

                Django中提供了method_decorator裝飾器用於將函數裝飾器轉換爲方法裝飾器。

                # CBV版添加班級
                from django.views import View
                from django.utils.decorators import method_decorator

                class AddClass(View):

                    @method_decorator(wrapper)
                    def get(self, request):
                        return render(request, "add_class.html")

                    def post(self, request):
                        class_name = request.POST.get("class_name")
                        models.Classes.objects.create(name=class_name)
                        return redirect("/class_list/")
            - 擴展
                # 使用CBV時要注意,請求過來後會先執行dispatch()這個方法,若是須要批量對具體的請求處理方法,如get,post等作一些操做的時候,這裏咱們能夠手動改寫dispatch方法,這個dispatch方法就和在FBV上加裝飾器的效果同樣。

                class Login(View):
                     
                    def dispatch(self, request, *args, **kwargs):
                        print('before')
                        obj = super(Login,self).dispatch(request, *args, **kwargs)
                        print('after')
                        return obj
                 
                    def get(self,request):
                        return render(request,'login.html')
                 
                    def post(self,request):
                        print(request.POST.get('user'))
                        return HttpResponse('Login.post')

    - Request對象和Response對象
        - request對象
            - 當一個頁面被請求時,Django就會建立一個包含本次請求原信息的HttpRequest對象。
                Django會將這個對象自動傳遞給響應的視圖函數,通常視圖函數約定俗成地使用 request 參數承接這個對象。

            - 請求相關的經常使用值
                path_info     返回用戶訪問url,不包括域名
                method        請求中使用的HTTP方法的字符串表示,全大寫表示。
                GET           包含全部HTTP  GET參數的類字典對象
                POST          包含全部HTTP POST參數的類字典對象
                body          請求體,byte類型 request.POST的數據就是從body裏面提取到的

            - 屬性
                全部的屬性應該被認爲是隻讀的,除非另有說明
                    - request屬性相關
                        屬性:
                            django將請求報文中的請求行、頭部信息、內容主體封裝成 HttpRequest 類中的屬性。
                            除了特殊說明的以外,其餘均爲只讀的。


                            0.HttpRequest.scheme
                               表示請求方案的字符串(一般爲http或https)

                            1.HttpRequest.body

                              一個字符串,表明請求報文的主體。在處理非 HTTP 形式的報文時很是有用,例如:二進制圖片、XML,Json等。

                              可是,若是要處理表單數據的時候,推薦仍是使用 HttpRequest.POST 。

                              另外,咱們還能夠用 python 的類文件方法去操做它,詳情參考 HttpRequest.read() 。

                             

                            2.HttpRequest.path

                              一個字符串,表示請求的路徑組件(不含域名)。

                              例如:"/music/bands/the_beatles/"



                            3.HttpRequest.method

                              一個字符串,表示請求使用的HTTP 方法。必須使用大寫。

                              例如:"GET""POST"

                             

                            4.HttpRequest.encoding

                              一個字符串,表示提交的數據的編碼方式(若是爲 None 則表示使用 DEFAULT_CHARSET 的設置,默認爲 'utf-8')。
                               這個屬性是可寫的,你能夠修改它來修改訪問表單數據使用的編碼。
                               接下來對屬性的任何訪問(例如從 GET 或 POST 中讀取數據)將使用新的 encoding 值。
                               若是你知道表單數據的編碼不是 DEFAULT_CHARSET ,則使用它。

                             

                            5.HttpRequest.GET 

                              一個相似於字典的對象,包含 HTTP GET 的全部參數。詳情請參考 QueryDict 對象。

                             

                            6.HttpRequest.POST

                              一個相似於字典的對象,若是請求中包含表單數據,則將這些數據封裝成 QueryDict 對象。

                              POST 請求能夠帶有空的 POST 字典 —— 若是經過 HTTP POST 方法發送一個表單,可是表單中沒有任何的數據,QueryDict 對象依然會被建立。
                               所以,不該該使用 if request.POST  來檢查使用的是不是POST 方法;應該使用 if request.method == "POST" 

                              另外:若是使用 POST 上傳文件的話,文件信息將包含在 FILES 屬性中。

                             7.HttpRequest.COOKIES

                              一個標準的Python 字典,包含全部的cookie。鍵和值都爲字符串。

                             

                            8.HttpRequest.FILES

                              一個相似於字典的對象,包含全部的上傳文件信息。
                               FILES 中的每一個鍵爲<input type="file" name="" /> 中的name,值則爲對應的數據。

                              注意,FILES 只有在請求的方法爲POST 且提交的<form> 帶有enctype="multipart/form-data" 的狀況下才會
                               包含數據。不然,FILES 將爲一個空的相似於字典的對象。

                             

                            9.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 鍵。

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

                             

                            11.HttpRequest.session

                               一個既可讀又可寫的相似於字典的對象,表示當前的會話。只有當Django 啓用會話的支持時纔可用。
                                完整的細節參見會話的文檔。


                        - 方法
                            - 請求相關方法
                                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') 裝飾你的視圖以讓響應可以正確地緩存。

                            - 注意:鍵值對的值是多個的時候,好比checkbox類型的input標籤,select標籤,須要用:

                                request.POST.getlist("hobby")



        - Response對象
            - 與由Django自動建立的HttpRequest對象相比,HttpResponse對象是咱們的職責範圍了。咱們寫的每一個視圖都須要實例化,填充和返回一個HttpResponse。
                HttpResponse類位於django.http模塊中。


            - 使用
                - 傳遞字符串
                    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:響應的狀態碼


    - JsonRequest對象
        - JsonResponse是HttpResponse的子類,專門用來生成JSON編碼的響應。

            from django.http import JsonResponse

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

            b'{"foo": "bar"}'
            默認只能傳遞字典類型,若是要傳遞非字典類型須要設置一下safe關鍵字參數。

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

    - Django shortcut functions
        - 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))
        
        - redirect()
                參數能夠是:

                一個模型:將調用模型的get_absolute_url() 函數
                一個視圖,能夠帶有參數:將使用urlresolvers.reverse 來反向解析名稱
                一個絕對的或相對的URL,將原封不動的做爲重定向的位置。
                默認返回一個臨時的重定向;傳遞permanent=True 能夠返回一個永久的重定向。

                示例:

                你能夠用多種方式使用redirect() 函數。
                傳遞一個具體的ORM對象(瞭解便可)
                將調用具體ORM對象的get_absolute_url() 方法來獲取重定向的URL:

                from django.shortcuts import redirect
                def my_view(request):
                    ...
                    object = MyModel.objects.get(...)
                    return redirect(object)
                
                傳遞一個視圖的名稱
                def my_view(request):
                    ...
                    return redirect('some-view-name', foo='bar')
                
                傳遞要重定向到的一個具體的網址
                def my_view(request):
                    ...
                    return redirect('/some/url/')
                
                固然也能夠是一個完整的網址

                def my_view(request):
                    ...
                    return redirect('http://example.com/')
                默認狀況下,redirect() 返回一個臨時重定向。以上全部的形式都接收一個permanent 參數;若是設置爲True,將返回一個永久的重定向:

                def my_view(request):
                    ...
                    object = MyModel.objects.get(...)
                    return redirect(object, permanent=True)  
                擴展閱讀: 

                臨時重定向(響應狀態碼:302)和永久重定向(響應狀態碼:301)對普通用戶來講是沒什麼區別的,它主要面向的是搜索引擎的機器人。
                A頁面臨時重定向到B頁面,那搜索引擎收錄的就是A頁面。
                A頁面永久重定向到B頁面,那搜索引擎收錄的就是B頁面。


- 總結
    - CBV 和 FBV
        - class based view
            - 改個人urls用 類名.as_view()
        - function base view

        - CBV流程
            - 定義CBV
                - from djaogo.viwes import View
                - class AddPress(View)
                    def get(self, request, *args, **kwargs):pass
                    def post(self, request, *args, **kwargs):pass
            - 使用
                - 個人urls用 views.類名.as_view()
            - 流程
                - 類名.as_view()  -》 view函數
                - 當請求到來的時候執行view函數
                    - 實例化本身寫的類
                        - self = cls(**initkwargs)
                    - self.request = request
                    - 執行self.dispath(request, *args, **kwargs)
                        - 執行父類中的dispatch方法
                            - 判斷請求方式是否被運行 http_method_names = []
                                - 容許的狀況
                                    - handler = 經過反射獲取get post 方法
                                - 不容許的狀況
                                    - handler = 不容許的方法 http_method_not_allowed()
                                - handler(request, *args, **kwargs)  # 執行這個handler
                        - 返回HttpResponse對象
                    - 返回HttpResponse對象給Django


            - 給CBV方法加裝飾器
                - from django.utils.decorators import method_decorator
                    - 直接在類名上加
                        @method_decorator(timer,name='get')  # 指定類中的具體方法
                        class AddPress(View):pass

                    - 在類中的函數加
                        @method_decorator(timer)  # 直接在方法上寫裝飾器
                        def get(self, request):pass

                    - 注意:
                        與正常的函數加裝飾器不一樣,給Django中的類加裝飾器須要用到Django本身的方法

                - 例子
                    from django.views import View

                    from django.utils.decorators import method_decorator


                    # @method_decorator(timer,name='post')
                    # @method_decorator(timer,name='get')
                    class AddPress(View):
                        # http_method_names = ['get','post']

                        # @method_decorator(timer)
                        def dispatch(self, request, *args, **kwargs):
                            print('執行以前')
                            ret = super().dispatch(request, *args, **kwargs)
                            print('執行以後')
                            return ret

                        # @method_decorator(timer)
                        def get(self, request):
                            print('get')
                            print(self.request)
                            return render(self.request, 'add_press2.html')

                        # @method_decorator(timer)
                        def post(self, request):
                            print('post')
                            press_name = request.POST.get('name')
                            Press.objects.create(name=press_name)
                            return redirect('/press_list/')

            - 給FBV方法加裝飾器
                - 普通加法
                @wapper
                def test(req):pass

    - request
        print(request.method)  8種
        print(request.GET)
        print(request.POST)
        print(request.FILES)

        print(request.path_info)  不包括域名端口和參數
        print(request.body)
        print(request.scheme)
        print(request.path)
        print(request.encoding)
        print(request.META)


        print(request.get_host())  域名和端口
        print(request.get_full_path()) 包括參數沒有域名
        print(request.is_secure())
        print(request.is_ajax())


    - response
        from django.shortcuts import render, HttpResponse, redirect
            1. HttpResponse    HttpResponse('字符串')   
            2. render(request,'html文件名',{})    —— 》 HTML代碼
            3. redirect('跳轉的地址)   Locationn:跳轉的地址
            4. from django.http import JsonResponse
                HttpResponse(json.dumps(ret))  # Content-Type: text/html; charset=utf-8
                ret = {'name': 'ward', 'age': 20}
                JsonResponse(ret)      # Content-Type: application/json
相關文章
相關標籤/搜索