爲何要配置解析模塊
|
1
2
3
4
5
|
"""
1）drf給咱們經過了多種解析數據包方式的解析類
2）咱們能夠經過配置來控制前臺提交的哪些格式的數據後臺在解析，哪些數據不解析
3）全局配置就是針對每個視圖類，局部配置就是針對指定的視圖來，讓它們能夠按照配置規則選擇性解析數據
"""
|
源碼入口
|
1
2
3
4
5
6
7
8
|
# APIView類的dispatch方法中
request
=
self
.initialize_request(request,
*
args,
*
*
kwargs)
# 點進去
# 獲取解析類
parsers
=
self
.get_parsers(),
# 點進去
# 去類屬性(局部配置) 或 配置文件(全局配置) 拿 parser_classes
return
[parser()
for
parser
in
self
.parser_classes]
|
|
1
2
3
4
5
6
7
8
|
REST_FRAMEWORK
=
{
# 全局解析類配置
'DEFAULT_PARSER_CLASSES'
: [
'rest_framework.parsers.JSONParser'
,
# json數據包
'rest_framework.parsers.FormParser'
,
# urlencoding數據包
'rest_framework.parsers.MultiPartParser'
# form-date數據包
],
}
|
局部配置：應用views.py的具體視圖類
|
1
2
3
4
5
|
from
rest_framework.parsers
import
JSONParser
class
Book(APIView):
# 局部解析類配置，只要json類型的數據包才能被解析
parser_classes
=
[JSONParser]
pass
|
異常模塊
爲何要自定義異常模塊
|
1
2
3
4
5
6
|
"""
1）全部通過drf的APIView視圖類產生的異常，均可以提供異常處理方案
2）drf默認提供了異常處理方案(rest_framework.views.exception_handler)，可是處理範圍有限
3）drf提供的處理方案兩種，處理了返回異常現象，沒處理返回None(後續就是服務器拋異常給前臺)
4）自定義異常的目的就是解決drf沒有處理的異常，讓前臺獲得合理的異常信息返回，後臺記錄異常具體信息
"""
|
源碼分析
|
1
2
3
4
5
6
7
8
9
10
11
|
# 異常模塊：APIView類的dispatch方法中
response
=
self
.handle_exception(exc)
# 點進去
# 獲取處理異常的句柄(方法)
# 一層層看源碼，走的是配置文件，拿到的是rest_framework.views的exception_handler
# 自定義：直接寫exception_handler函數，在本身的配置文件配置EXCEPTION_HANDLER指向本身的
exception_handler
=
self
.get_exception_handler()
# 異常處理的結果
# 自定義異常就是提供exception_handler異常處理函數，處理的目的就是讓response必定有值
response
=
exception_handler(exc, context)
|
如何使用：自定義exception_handler函數如何書寫實現體
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# 修改本身的配置文件setting.py
REST_FRAMEWORK
=
{
# 全局配置異常模塊
'EXCEPTION_HANDLER'
:
'api.exception.exception_handler'
,
}
# 1）先將異常處理交給rest_framework.views的exception_handler去處理
# 2）判斷處理的結果(返回值)response，有值表明drf已經處理了，None表明須要本身處理
# 自定義異常處理文件exception，在文件中書寫exception_handler函數
from
rest_framework.views
import
exception_handler as drf_exception_handler
from
rest_framework.views
import
Response
from
rest_framework
import
status
def
exception_handler(exc, context):
# drf的exception_handler作基礎處理
response
=
drf_exception_handler(exc, context)
# 爲空，自定義二次處理
if
response
is
None
:
# print(exc)
# print(context)
print
(
'%s - %s - %s'
%
(context[
'view'
], context[
'request'
].method, exc))
return
Response({
'detail'
:
'服務器錯誤'
}, status
=
status.HTTP_500_INTERNAL_SERVER_ERROR, exception
=
True
)
return
response
|
響應模塊
響應類構造器：rest_framework.response.Response
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def
__init__(
self
, data
=
None
, status
=
None
,
template_name
=
None
, headers
=
None
,
exception
=
False
, content_type
=
None
):
"""
:param data: 響應數據
:param status: http響應狀態碼
:param template_name: drf也能夠渲染頁面，渲染的頁面模板地址（不用瞭解）
:param headers: 響應頭
:param exception: 是否異常了
:param content_type: 響應的數據格式（通常不用處理，響應頭中帶了，且默認是json）
"""
pass
|
使用：常規實例化響應對象
|
1
2
3
4
|
# status就是解釋一堆 數字 網絡狀態碼的模塊
from
rest_framework
import
status就是解釋一堆 數字 網絡狀態碼的模塊
# 通常狀況下只須要返回數據，status和headers都有默認值
return
Response(data
=
{數據}, status
=
status.HTTP_200_OK, headers
=
{設置的響應頭})
|
序列化組件：
知識點：Serializer(偏底層)、ModelSerializer(重點)、ListModelSerializer(輔助羣改)
Serializer
序列化準備：
-
模型層：models.pypython
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class
User(models.Model):
SEX_CHOICES
=
[
[
0
,
'男'
],
[
1
,
'女'
],
]
name
=
models.CharField(max_length
=
64
)
pwd
=
models.CharField(max_length
=
32
)
phone
=
models.CharField(max_length
=
11
, null
=
True
, default
=
None
)
sex
=
models.IntegerField(choices
=
SEX_CHOICES, default
=
0
)
icon
=
models.ImageField(upload_to
=
'icon'
, default
=
'icon/default.jpg'
)
class
Meta:
db_table
=
'old_boy_user'
verbose_name
=
'用戶'
verbose_name_plural
=
verbose_name
def
__str__(
self
):
return
'%s'
%
self
.name
|
-
後臺管理層：admin.py數據庫
|
1
2
3
4
|
from
django.contrib
import
admin
from
.
import
models
admin.site.register(models.User)
|
-
配置層：settings.pydjango
|
1
2
3
4
5
|
# 註冊rest_framework
INSTALLED_APPS
=
[
# ...
'rest_framework'
,
]
|
# 配置數據庫# media資源MEDIA_URL = '/media/' # 後期高級序列化類與視圖類，會使用該配置MEDIA_ROOT = os.path.join(BASE_DIR, 'media') # media資源路徑# 國際化配置LANGUAGE_CODE = 'zh-hans'TIME_ZONE = 'Asia/Shanghai'USE_I18N = TrueUSE_L10N = TrueUSE_TZ = False
-
主路由：項目下urls.pyjson
|
1
2
3
4
5
6
|
urlpatterns
=
[
# ...
url(r
'^api/'
, include(
'api.urls'
)),
url(r
'^media/(?P<path>.*)'
, serve, {
'document_root'
: settings.MEDIA_ROOT}),
]
|
-
子路由：應用下urls.pyapi
|
1
2
3
4
|
urlpatterns
=
[
url(r
'^users/$'
, views.User.as_view()),
url(r
'^users/(?P<pk>.*)/$'
, views.User.as_view()),
]
|
序列化使用
-
序列化層：api/serializers.py安全
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
"""
1）設置須要返回給前臺 那些model類有對應的 字段，不須要返回的就不用設置了
2）設置方法字段，字段名能夠隨意，字段值有 get_字段名 提供，來完成一些須要處理在返回的數據
"""
# 序列化組件 - 爲每個model類經過一套序列化工具類
# 序列化組件的工做方式與django froms組件很是類似
from
rest_framework
import
serializers, exceptions
from
django.conf
import
settings
from
.
import
models
class
UserSerializer(serializers.Serializer):
name
=
serializers.CharField()
phone
=
serializers.CharField()
# 序列化提供給前臺的字段個數由後臺決定，能夠少提供，
# 可是提供的數據庫對應的字段，名字必定要與數據庫字段相同
# sex = serializers.IntegerField()
# icon = serializers.ImageField()
# 自定義序列化屬性
# 屬性名隨意，值由固定的命名規範方法提供:
# get_屬性名(self, 參與序列化的model對象)
# 返回值就是自定義序列化屬性的值
gender
=
serializers.SerializerMethodField()
def
get_gender(
self
, obj):
# choice類型的解釋型值 get_字段_display() 來訪問
return
obj.get_sex_display()
icon
=
serializers.SerializerMethodField()
def
get_icon(
self
, obj):
# settings.MEDIA_URL: 本身配置的 /media/，給後面高級序列化與視圖類準備的
# obj.icon不能直接做爲數據返回，由於內容雖然是字符串，可是類型是ImageFieldFile類型
return
'%s%s%s'
%
(r
'http://127.0.0.1:8000'
, settings.MEDIA_URL,
str
(obj.icon))
|
-
視圖層服務器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
"""
1）從數據庫中將要序列化給前臺的model對象，或是對個model對象查詢出來
user_obj = models.User.objects.get(pk=pk) 或者
user_obj_list = models.User.objects.all()
2）將對象交給序列化處理，產生序列化對象，若是序列化的是多個數據，要設置many=True
user_ser = serializers.UserSerializer(user_obj) 或者
user_ser = serializers.UserSerializer(user_obj_list, many=True)
3）序列化 對象.data 就是能夠返回給前臺的序列化數據
return Response({
'status': 0,
'msg': 0,
'results': user_ser.data
})
"""
class
User(APIView):
def
get(
self
, request,
*
args,
*
*
kwargs):
pk
=
kwargs.get(
'pk'
)
if
pk:
try
:
# 用戶對象不能直接做爲數據返回給前臺
user_obj
=
models.User.objects.get(pk
=
pk)
# 序列化一下用戶對象
user_ser
=
serializers.UserSerializer(user_obj)
# print(user_ser, type(user_ser))
return
Response({
'status'
:
0
,
'msg'
:
0
,
'results'
: user_ser.data
})
except
:
return
Response({
'status'
:
2
,
'msg'
:
'用戶不存在'
,
})
else
:
# 用戶對象列表(queryset)不能直接做爲數據返回給前臺
user_obj_list
=
models.User.objects.
all
()
# 序列化一下用戶對象
user_ser_data
=
serializers.UserSerializer(user_obj_list, many
=
True
).data
return
Response({
'status'
:
0
,
'msg'
:
0
,
'results'
: user_ser_data
})
|
反序列化使用
-
反序列層：api/serializers.py網絡
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
"""
1）設置必填與選填序列化字段，設置校驗規則
2）爲須要額外校驗的字段提供局部鉤子函數，若是該字段不入庫，且不參與全局鉤子校驗，能夠將值取出校驗
3）爲有聯合關係的字段們提供全局鉤子函數，若是某些字段不入庫，能夠將值取出校驗
4）重寫create方法，完成校驗經過的數據入庫工做，獲得新增的對象
"""
class
UserDeserializer(serializers.Serializer):
# 1) 哪些自動必須反序列化
# 2) 字段都有哪些安全校驗
# 3) 哪些字段須要額外提供校驗
# 4) 哪些字段間存在聯合校驗
# 注：反序列化字段都是用來入庫的，不會出現自定義方法屬性，會出現能夠設置校驗規則的自定義屬性(re_pwd)
name
=
serializers.CharField(
max_length
=
64
,
min_length
=
3
,
error_messages
=
{
'max_length'
:
'太長'
,
'min_length'
:
'過短'
}
)
pwd
=
serializers.CharField()
phone
=
serializers.CharField(required
=
False
)
sex
=
serializers.IntegerField(required
=
False
)
# 自定義有校驗規則的反序列化字段
re_pwd
=
serializers.CharField(required
=
True
)
# 小結：
# name，pwd，re_pwd爲必填字段
# phone，sex爲選填字段
# 五個字段都必須提供完成的校驗規則
# 局部鉤子：validate_要校驗的字段名(self, 當前要校驗字段的值)
# 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
def
validate_name(
self
, value):
if
'g'
in
value.lower():
# 名字中不能出現g
raise
exceptions.ValidationError(
'名字非法，是個雞賊！'
)
return
value
# 全局鉤子：validate(self, 系統與局部鉤子校驗經過的全部數據)
# 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
def
validate(
self
, attrs):
pwd
=
attrs.get(
'pwd'
)
re_pwd
=
attrs.pop(
're_pwd'
)
if
pwd !
=
re_pwd:
raise
exceptions.ValidationError({
'pwd&re_pwd'
:
'兩次密碼不一致'
})
return
attrs
# 要完成新增，須要本身重寫 create 方法
def
create(
self
, validated_data):
# 儘可能在全部校驗規則完畢以後，數據能夠直接入庫
return
models.User.objects.create(
*
*
validated_data)
|
-
視圖層函數
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
"""
1）book_ser = serializers.UserDeserializer(data=request_data) # 數據必須賦值data
2）book_ser.is_valid() # 結果爲 經過 | 不經過
3）不經過返回 book_ser.errors 給前臺，經過 book_ser.save() 獲得新增的對象，再正常返回
"""
class
User(APIView):
# 只考慮單增
def
post(
self
, request,
*
args,
*
*
kwargs):
# 請求數據
request_data
=
request.data
# 數據是否合法（增長對象須要一個字典數據）
if
not
isinstance
(request_data,
dict
)
or
request_data
=
=
{}:
return
Response({
'status'
:
1
,
'msg'
:
'數據有誤'
,
})
# 數據類型合法，但數據內容不必定合法，須要校驗數據，校驗(參與反序列化)的數據須要賦值給data
book_ser
=
serializers.UserDeserializer(data
=
request_data)
# 序列化對象調用is_valid()完成校驗，校驗失敗的失敗信息都會被存儲在 序列化對象.errors
if
book_ser.is_valid():
# 校驗經過，完成新增
book_obj
=
book_ser.save()
return
Response({
'status'
:
0
,
'msg'
:
'ok'
,
'results'
: serializers.UserSerializer(book_obj).data
})
else
:
# 校驗失敗
return
Response({
'status'
:
1
,
'msg'
: book_ser.errors,
})
|