Django學習筆記5

時間  2019-12-10
標籤 django 學習 筆記 欄目 Python 简体版
原文   原文鏈接

視圖系統（從屬於視圖層）

 Django的view（視圖）

一個視圖函數（類），簡稱視圖，是一個簡單的Python 函數（類），它接受Web請求而且返回Web響應。html

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

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

CBV和FBV

FBV和CBVajax

FBV（function base views） 就是在視圖裏使用函數處理請求。 
在以前django的學習中，咱們一直使用的是這種方式，因此再也不贅述。django

CBV（class base views） 就是在視圖裏使用類處理請求。 
Python是一個面向對象的編程語言，若是隻用函數來開發，有不少面向對象的優勢就錯失了（繼承、封裝、多態）。因此Django在後來加入了Class-Based-View。可讓咱們用類寫View。這樣作的優勢主要下面兩種：編程

  • 提升了代碼的複用性，可使用面嚮對象的技術，好比Mixin（多繼承） 
  • 能夠用不一樣的函數針對不一樣的HTTP方法處理，而不是經過不少if判斷，提升代碼可讀性

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/")

注意：json

使用CBV時，urls.py中也作對應的修改：瀏覽器

# urls.py中
url(r'^add_class/$', views.AddClass.as_view()),

cbv流程及源碼分析

class View(object):
    """
    Intentionally simple parent class for all views. Only implements
    dispatch-by-method and simple sanity checking.
    """

    http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

    def __init__(self, **kwargs):
        """
        Constructor. Called in the URLconf; can contain helpful extra
        keyword arguments, and other things.
        """
        # Go through keyword arguments, and either save their values to our
        # instance, or raise an error.
        for key, value in six.iteritems(kwargs):
            setattr(self, key, value)

    @classonlymethod
    def as_view(cls, **initkwargs):
        """
        Main entry point for a request-response process.
        """
        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))

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            return self.dispatch(request, *args, **kwargs)
        view.view_class = cls
        view.view_initkwargs = initkwargs

        # take name and docstring from class
        update_wrapper(view, cls, updated=())

        # and possible attributes set by decorators
        # like csrf_exempt from dispatch
        update_wrapper(view, cls.dispatch, assigned=())
        return view

    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.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)

    def http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning(
            'Method Not Allowed (%s): %s', request.method, request.path,
            extra={'status_code': 405, 'request': request}
        )
        return http.HttpResponseNotAllowed(self._allowed_methods())

    def options(self, request, *args, **kwargs):
        """
        Handles responding to requests for the OPTIONS HTTP verb.
        """
        response = http.HttpResponse()
        response['Allow'] = ', '.join(self._allowed_methods())
        response['Content-Length'] = '0'
        return response

    def _allowed_methods(self):
        return [m.upper() for m in self.http_method_names if hasattr(self, m)]
CBV源碼

cbv執行流程：瀏覽器向服務器發送一個get請求，基於類的視圖執行流程緩存

首先，django啓動，會執行視圖類下的as_view()：安全

urlpatterns = [
    url(r'^admin/', admin.site.urls),

    # as_view()  執行類的as_view()   
    url(r'books/',views.BookView.as_view()),
]

　　as_view():因爲BookView沒有實現as_view()方法，會調用父類(View)中的as_view()方法：

@classonlymethod
    def as_view(cls, **initkwargs):
        """
        請求響應過程的主要入口點
        """
        ......
        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            
            #view方法返回self.dispatch()方法的返回值
            return self.dispatch(request, *args, **kwargs)
        view.view_class = cls
        view.view_initkwargs = initkwargs
        update_wrapper(view, cls, updated=())
        update_wrapper(view, cls.dispatch, assigned=())
        
        #返回view方法內存地址,當用戶訪問books/的時候，會調用改view()方法
        return view

　　self.dispatch():因爲BookView沒有實現dispatch()，因此會調用View類的dispatch()

dispatch的主要做用：view視圖的一部分 - 接受request 參數和參數的方法，並返回HTTP響應。

檢測HTTP請求方法，並嘗試委託給匹配HTTP方法的方法，一個GET將被委託給get()，一POST來post()，等等。

def dispatch(self, request, *args, **kwargs):
    # 嘗試把用戶請求分發到正確的方法，若是方法不存在，聽從錯誤的處理程序
    # 若是請求方法不在已批准的列表中，也會聽從錯誤的處理程序
    if request.method.lower() in self.http_method_names:
        # 使用反射，例如用戶訪問是get請求
        # handler = getattr(BookView,"get",錯誤處理程序)
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    else:
        handler = self.http_method_not_allowed
        
    # return get(request,*args, **kwargs)
    return handler(request, *args, **kwargs)

　　URLconf中能夠變化爲：

此時URLconf的配置
 url(r'books/',views.BookView.as_view()),
 等價於
 url(r'books/',view) # 因爲view return self.dispatch()
 等價於
 url(r'books/',self.dispatch())
 等價於
 url(r'books/',handler(request,*args,**kwargs)
 --> url(r'books/',get(request,*args,**kwargs)
 --> url(r'books/',post(request,*args,**kwargs)
 等等

dispatch()的獨特做用：

上面的CBV執行流程能夠簡化爲請求來--url分發給dispatch()--dispatch()經過反射分發給各函數--獲得各函數的返回值，經過dispatch()返還response

因此dispatch的一個做用能夠給每個CBV中的函數當作裝飾器，能夠拆分出來做爲基類而後繼承，以下

給視圖加裝飾器

使用裝飾器裝飾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/")

Request對象和Response對象

Django 使用Request 對象和Response 對象在系統間傳遞狀態，具體實現通常都是HttpRequest和HttpResponse。

當請求一個頁面時，Django會創建一個包含請求元數據的 HttpRequest 對象。 當Django 加載對應的視圖時，HttpRequest 對象將做爲視圖函數的第一個參數。 每一個視圖會返回一個HttpResponse 對象。

本文檔對HttpRequest 和HttpResponse 對象的API 進行說明，這些API 定義在django.http 模塊中，具體位置見下圖

request對象

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

請求相關的經常使用屬性值

全部屬性應被視爲只讀，除非另有說明。

  • HttpRequest.scheme

一個字符串，表示請求的方案（一般是http 或https）。

  • HttpRequest.body

一個字節字符串，表示原始HTTP 請求的正文。 它對於處理非HTML 形式的數據很是有用：二進制圖像、XML等。 若是要處理常規的表單數據，應該使用HttpRequest.POST。

你還可使用相似文件的接口從HttpRequest中讀取數據。 參見HttpRequest.read()。

  • HttpRequest.path

    表示請求頁面的完整路徑的字符串，不包括方案或域。

    例如："/music/bands/the_beatles/"

  • HttpRequest.path_info

    在某些Web 服務器配置下，主機名後的URL 部分被分紅腳本前綴部分和路徑信息部分。 path_info 屬性將始終包含路徑信息部分，不論使用的Web 服務器是什麼。 使用它代替path 可讓代碼在測試和開發環境中更容易地切換。

    例如，若是應用的WSGIScriptAlias 設置爲"/music/bands/the_beatles/"，那麼當"/minfo" 是"/minfo/music/bands/the_beatles/" 時path_info 將是path。

  • HttpRequest.method

一個字符串，表示請求使用的HTTP 方法。 必須使用大寫。 像這樣：

if request.method == 'GET': do_something() elif request.method == 'POST': do_something_else()
  • HttpRequest.encoding

一個字符串，表示提交的數據的編碼方式（若是爲None 則表示使用DEFAULT_CHARSET 設置）。 這個屬性是可寫的，你能夠修改它來修改訪問表單數據使用的編碼。 任何隨後的屬性訪問（例如從GET或POST讀取）將使用新的encoding值。 若是你知道表單數據的編碼不在DEFAULT_CHARSET 中，則使用它。

  • HttpRequest.content_type
Django 1.10中新增。

表示從CONTENT_TYPE頭解析的請求的MIME類型的字符串。

  • HttpRequest.content_params
Django 1.10中新增。

包含在CONTENT_TYPE標題中的鍵/值參數字典。

  • HttpRequest.GET

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

  • HttpRequest.POST

一個包含全部給定的HTTP POST參數的類字典對象，提供了包含表單數據的請求。 詳情請參考下面的QueryDict 文檔。 若是須要訪問請求中的原始或非表單數據，可使用HttpRequest.body 屬性。

POST請求可能帶有一個空的POST字典 — 若是經過HTTP POST方法請求一個表單可是沒有包含表單數據。 因此，你不該該使用if request.POST來檢查使用的是不是POST方法；請使用if request.method == "POST"（參見HttpRequest.method）。

POST 不包含文件上傳信息。 參見FILES。

  • HttpRequest.COOKIES

包含全部Cookie的字典。 鍵和值都爲字符串。

  • HttpRequest.FILES

一個相似於字典的對象，包含全部上傳的文件。 FILES中的每一個鍵爲<input type="file" name="" />中的name。 FILES中的每一個值是一個UploadedFile。

更多信息參見管理文件。

若是請求方法是POST且請求的<form>帶有enctype="multipart/form-data"，那麼FILES將只包含數據。 不然，FILES將爲一個空的相似於字典的對象。

  • HttpRequest.META

包含全部可用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 頭部轉換爲HTTP_ 的鍵時，都會將全部字母大寫並將鏈接符替換爲下劃線最後加上META 前綴。 因此，一個叫作X-Bender 的頭部將轉換成META 中的HTTP_X_BENDER 鍵。

請注意，runserver將名稱中帶有下劃線的全部標題剝離，所以您將不會在META中看到它們。 這能夠根據WSGI環境變量中下劃線的標點和下劃線之間的歧義來防止標題欺騙。 它匹配像Nginx和Apache 2.4+之類的Web服務器的行爲。

HttpRequest. resolver_match

表明已解析的URL的ResolverMatch的實例。 此屬性僅在URL解析發生後設置，這意味着它能夠在全部視圖中使用，但不能在URL解析以前執行的中間件（您能夠在process_view()中使用它）。

  • HttpRequest.session

從SessionMiddleware：一個可讀寫的，相似字典的對象，表示當前會話。

  • HttpRequest.site

從CurrentSiteMiddleware：表明當前站點的get_current_site()返回的Site或RequestSite的實例。

  •  HttpRequest.user

來自AuthenticationMiddleware：表示當前登陸的用戶的AUTH_USER_MODEL的實例。 若是用戶當前未登陸，則user將被設置爲AnonymousUser的實例。 您可使用is_authenticated將它們分開，以下所示：

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

　　user 只有當Django 啓用 AuthenticationMiddleware 中間件時纔可用。

上傳文件示例

上傳表單界面

<form action="/upload/" method="post" enctype="multipart/form-data">  必定要加enctype="multipart/form-data"才能傳文件
    <input type="file" name="upload_file">
    <input type="submit" value="開始上傳">
</form>

上傳處理函數

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")

上傳文件示例代碼

　　主要方法

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

請求相關方法 

response響應對象

與由Django自動建立的HttpRequest 對象相比，HttpResponse 對象由程序員建立. 您編寫的每一個視圖都負責實例化，填充和返回一個HttpResponse。

HttpResponse 類是在django.http模塊中定義的。

主要屬性

  • HttpResponse.content

一個用來代替content的字節字符串，若是必要，則從一個Unicode對象編碼而來。

  • HttpResponse.charset

一個字符串，用來表示response將會被編碼的字符集。 若是沒有在HttpResponse實例化的時候給定這個字符集，那麼將會從content_type 中解析出來。而且當這種解析成功的時候，DEFAULT_CHARSET選項將會被使用。

  • HttpResponse.status_code

響應的 HTTP status code。

除非明確設置了reason_phrase，不然在構造函數以外修改status_code的值也會修改reason_phrase的值。

  • HttpResponse.reason_phrase

響應的HTTP緣由短語。 它使用 HTTP standard’s默認緣由短語。

除非明確設置，不然reason_phrase由status_code的值決定。

  • HttpResponse.streaming

這個選項老是False。

因爲這個屬性的存在，使得中間件（middleware）可以區別對待流式response和常規response。

  • HttpResponse.closed

True若是響應已關閉。

方法參考：官方文檔

傳遞字符串

典型的應用是傳遞一個字符串做爲頁面的內容到HttpResponse 構造函數:

>>> 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 看作一個類文件對象

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

　　設置或刪除響應頭信息

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

JsonResponse對象

JsonResponse是HttpResponse的子類，專門用來生成JSON編碼的響應。

def json_test(request):
    data = {"name": "weilianxin", "age": 18}
    # import json
    # data_json = json.dumps(data)  # 把data序列化轉化成json格式的字符串
    # return HttpResponse(data_json)
    # 這幾行至關於下面兩行
    
    from django.http import JsonResponse
    return JsonResponse(data)

默認只能傳遞字典類型，若是要傳遞非字典類型須要設置一下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頁面。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程