django-進階
阿新 • • 發佈：2018-11-11
知識預覽:
1分頁
2中介軟體
分頁
Django的分頁器（paginator）
view
from django.shortcuts import render,HttpResponse
# Create your views here.
from app01.models import *
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
def index(request):
'''
批量匯入資料:
Booklist=[]
for i in range(100):
Booklist.append(Book(title="book"+str(i),price=30+i*i))
Book.objects.bulk_create(Booklist)
'''
'''
分頁器的使用:
book_list=Book.objects.all()
paginator = Paginator(book_list, 10)
print("count:",paginator.count) #資料總數
print("num_pages",paginator.num_pages) #總頁數
print("page_range",paginator.page_range) #頁碼的列表
page1=paginator.page(1) #第1頁的page物件
for i in page1: #遍歷第1頁的所有資料物件
print(i)
print(page1.object_list) #第1頁的所有資料
page2=paginator.page(2)
print(page2.has_next()) #是否有下一頁
print(page2.next_page_number()) #下一頁的頁碼
print(page2.has_previous()) #是否有上一頁
print(page2.previous_page_number()) #上一頁的頁碼
# 拋錯
#page=paginator.page(12) # error:EmptyPage
#page=paginator.page("z") # error:PageNotAnInteger
'''
book_list=Book.objects.all()
paginator = Paginator(book_list, 10)
page = request.GET.get('page',1)
currentPage=int(page)
try:
print(page)
book_list = paginator.page(page)
except PageNotAnInteger:
book_list = paginator.page(1)
except EmptyPage:
book_list = paginator.page(paginator.num_pages)
return render(request,"index.html",{"book_list":book_list,"paginator":paginator,"currentPage":currentPage})
index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css"
integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
<div class="container">
<h4>分頁器</h4>
<ul>
{% for book in book_list %}
<li>{{ book.title }} -----{{ book.price }}</li>
{% endfor %}
</ul>
<ul class="pagination" id="pager">
{% if book_list.has_previous %}
<li class="previous"><a href="/index/?page={{ book_list.previous_page_number }}">上一頁</a></li>
{% else %}
<li class="previous disabled"><a href="#">上一頁</a></li>
{% endif %}
{% for num in paginator.page_range %}
{% if num == currentPage %}
<li class="item active"><a href="/index/?page={{ num }}">{{ num }}</a></li>
{% else %}
<li class="item"><a href="/index/?page={{ num }}">{{ num }}</a></li>
{% endif %}
{% endfor %}
{% if book_list.has_next %}
<li class="next"><a href="/index/?page={{ book_list.next_page_number }}">下一頁</a></li>
{% else %}
<li class="next disabled"><a href="#">下一頁</a></li>
{% endif %}
</ul>
</div>
</body>
</html>
擴充套件
def index(request):
book_list=Book.objects.all()
paginator = Paginator(book_list, 15)
page = request.GET.get('page',1)
currentPage=int(page)
# 如果頁數十分多時，換另外一種顯示方式
if paginator.num_pages>30:
if currentPage-5<1:
pageRange=range(1,11)
elif currentPage+5>paginator.num_pages:
pageRange=range(currentPage-5,paginator.num_pages+1)
else:
pageRange=range(currentPage-5,currentPage+5)
else:
pageRange=paginator.page_range
try:
print(page)
book_list = paginator.page(page)
except PageNotAnInteger:
book_list = paginator.page(1)
except EmptyPage:
book_list = paginator.page(paginator.num_pages)
return render(request,"index.html",locals())
自定義分頁器
"""
分頁元件使用示例：
obj = Pagination(request.GET.get('page',1),len(USER_LIST),request.path_info)
page_user_list = USER_LIST[obj.start:obj.end]
page_html = obj.page_html()
return render(request,'index.html',{'users':page_user_list,'page_html':page_html})
"""
class Pagination(object):
def __init__(self,current_page,all_count,base_url,per_page_num=2,pager_count=11):
"""
封裝分頁相關資料
:param current_page: 當前頁
:param all_count: 資料庫中的資料總條數
:param per_page_num: 每頁顯示的資料條數
:param base_url: 分頁中顯示的URL字首
:param pager_count: 最多顯示的頁碼個數
"""
try:
current_page = int(current_page)
except Exception as e:
current_page = 1
if current_page <1:
current_page = 1
self.current_page = current_page
self.all_count = all_count
self.per_page_num = per_page_num
self.base_url = base_url
# 總頁碼
all_pager, tmp = divmod(all_count, per_page_num)
if tmp:
all_pager += 1
self.all_pager = all_pager
self.pager_count = pager_count
self.pager_count_half = int((pager_count - 1) / 2)
@property
def start(self):
return (self.current_page - 1) * self.per_page_num
@property
def end(self):
return self.current_page * self.per_page_num
def page_html(self):
# 如果總頁碼 < 11個：
if self.all_pager <= self.pager_count:
pager_start = 1
pager_end = self.all_pager + 1
# 總頁碼 > 11
else:
# 當前頁如果<=頁面上最多顯示11/2個頁碼
if self.current_page <= self.pager_count_half:
pager_start = 1
pager_end = self.pager_count + 1
# 當前頁大於5
else:
# 頁碼翻到最後
if (self.current_page + self.pager_count_half) > self.all_pager:
pager_end = self.all_pager + 1
pager_start = self.all_pager - self.pager_count + 1
else:
pager_start = self.current_page - self.pager_count_half
pager_end = self.current_page + self.pager_count_half + 1
page_html_list = []
first_page = '<li><a href="%s?page=%s">首頁</a></li>' % (self.base_url,1,)
page_html_list.append(first_page)
if self.current_page <= 1:
prev_page = '<li class="disabled"><a href="#">上一頁</a></li>'
else:
prev_page = '<li><a href="%s?page=%s">上一頁</a></li>' % (self.base_url,self.current_page - 1,)
page_html_list.append(prev_page)
for i in range(pager_start, pager_end):
if i == self.current_page:
temp = '<li class="active"><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)
else:
temp = '<li><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)
page_html_list.append(temp)
if self.current_page >= self.all_pager:
next_page = '<li class="disabled"><a href="#">下一頁</a></li>'
else:
next_page = '<li><a href="%s?page=%s">下一頁</a></li>' % (self.base_url,self.current_page + 1,)
page_html_list.append(next_page)
last_page = '<li><a href="%s?page=%s">尾頁</a></li>' % (self.base_url,self.all_pager,)
page_html_list.append(last_page)
return ''.join(page_html_list)
回到頂部
中介軟體
中介軟體的概念
中介軟體顧名思義，是介於request與response處理之間的一道處理過程，相對比較輕量級，並且在全域性上改變django的輸入與輸出。因為改變的是全域性，所以需要謹慎實用，用不好會影響到效能。
Django的中介軟體的定義：
?| 1 |
Middleware
is
a framework of hooks into Django’s request
/
response processing. <br>It’s a light, low
-
level “plugin” system
for
globally altering Django’s
input
or
output.
|
如果你想修改請求，例如被傳送到view中的HttpRequest物件。 或者你想修改view返回的HttpResponse物件，這些都可以通過中介軟體來實現。
可能你還想在view執行之前做一些操作，這種情況就可以用 middleware來實現。
大家可能頻繁在view使用request.user吧。 Django想在每個view執行之前把user設定為request的屬性，於是就用了一箇中間件來實現這個目標。所以Django提供了可以修改request 物件的中介軟體 AuthenticationMiddleware。
Django預設的Middleware：
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
每一箇中間件都有具體的功能。
自定義中介軟體
中介軟體中一共有四個方法：
process_request process_view process_exception process_response
process_request，process_response
當用戶發起請求的時候會依次經過所有的的中介軟體，這個時候的請求時process_request,最後到達views的函式中，views函式處理後，在依次穿過中介軟體，這個時候是process_response,最後返回給請求者。
上述截圖中的中介軟體都是django中的，我們也可以自己定義一箇中間件，我們可以自己寫一個類，但是必須繼承MiddlewareMixin
需要匯入
| 1 |
from
django.utils.deprecation
import
MiddlewareMixin
|
in views:
def index(request):
print("view函式...")
return HttpResponse("OK")
in Mymiddlewares.py：
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1請求")
def process_response(self,request,response):
print("Md1返回")
return response
class Md2(MiddlewareMixin):
def process_request(self,request):
print("Md2請求")
#return HttpResponse("Md2中斷")
def process_response(self,request,response):
print("Md2返回")
return response
結果：
Md1請求 Md2請求 view函式... Md2返回 Md1返回
注意：如果當請求到達請求2的時候直接不符合條件返回，即return HttpResponse("Md2中斷")，程式將把請求直接發給中介軟體2返回，然後依次返回到請求者，結果如下：
返回Md2中斷的頁面，後臺列印如下：
Md1請求 Md2請求 Md2返回 Md1返回
流程圖如下：
process_view
?| 1 |
process_view(
self
, request, callback, callback_args, callback_kwargs)
|
Mymiddlewares.py修改如下
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1請求")
#return HttpResponse("Md1中斷")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md1view")
class Md2(MiddlewareMixin):
def process_request(self,request):
print("Md2請求")
return HttpResponse("Md2中斷")
def process_response(self,request,response):
print("Md2返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md2view")
結果如下：
Md1請求 Md2請求 Md1view Md2view view函式... Md2返回 Md1返回
下圖進行分析上面的過程：
當最後一箇中間的process_request到達路由關係對映之後，返回到中介軟體1的process_view，然後依次往下，到達views函式，最後通過process_response依次返回到達使用者。
process_view可以用來呼叫檢視函式：
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1請求")
#return HttpResponse("Md1中斷")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
# return HttpResponse("hello")
response=callback(request,*callback_args,**callback_kwargs)
return response
結果如下：
Md1請求 Md2請求 view函式... Md2返回 Md1返回
注意：process_view如果有返回值，會越過其他的process_view以及檢視函式，但是所有的process_response都還會執行。
process_exception
?| 1 |
process_exception(
self
, request, exception)
|
示例修改如下：
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1請求")
#return HttpResponse("Md1中斷")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
# return HttpResponse("hello")
# response=callback(request,*callback_args,**callback_kwargs)
# return response
print("md1 process_view...")
def process_exception(self):
print("md1 process_exception...")
class Md2(MiddlewareMixin):
def process_request(self,request):
print("Md2請求")
# return HttpResponse("Md2中斷")
def process_response(self,request,response):
print("Md2返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("md2 process_view...")
def process_exception(self):
print("md1 process_exception...")
結果如下：
Md1請求 Md2請求 md1 process_view... md2 process_view... view函式... Md2返回 Md1返回
流程圖如下：
當views出現錯誤時：
將md2的process_exception修改如下：
def process_exception(self,request,exception):
print("md2 process_exception...")
return HttpResponse("error")
結果如下：
Md1請求 Md2請求 md1 process_view... md2 process_view... view函式... md2 process_exception... Md2返回 Md1返回