[Django REST framework - 序列化元件、source、鉤子函式]
序列化器-Serializer
什麼是rest_framework序列化？
在寫前後端不分離的專案時：
我們有form元件幫我們去做資料校驗
我們有模板語法，從資料庫取出的queryset物件不需要人為去轉格式
當我們寫前後端分離專案的時：
我們需要自己去做資料校驗
我們需要手動去轉資料格式，因為跨平臺資料傳輸都用json字串，不能直接jsonqueryset物件
序列化器的作用
1 序列化：把python中的物件轉成json格式字串
序列化器會把模型物件轉換成字典,經過response以後變成json字串
2 反序列化：把json格式字串轉成python中的物件
把客戶端傳送過來的資料,經過request以後變成字典,序列化器可以把字典轉成模型
3 注意：drf的序列化元件（序列化器）
把物件（Book，queryset物件）轉成字典
因為有字典，直接丟到Response中就可以了
序列化，反序列化
-物件----》json
-json---》物件
序列化器
-定義一個類，繼承Serializer
-在類內些欄位（常用欄位，和非常用欄位）（欄位引數）
-在檢視類中，例項化得到一個序列化類的物件，傳入要序列化的資料
-物件.data---》就是字典
-source
序列化器的基本使用
from rest_framework.serializers import Serializer,ModelSerializer
from rest_framework import serializers
Serializer是rest_framework原生的序列化元件
ModelSerializer是rest_framework在原生的序列化元件的基礎上封裝了一層的序列化元件
用法：1、在用我們的rest_framework序列化元件的時候，我們的檢視層都必須寫檢視類，不能再寫檢視函式
2、我們需要針對每一張模型表寫一個類來繼承Serailizer或者ModelSerailizer類，
注：當我們在檢視類裡需要對資料進行序列化或者反序列化的時候，在自己定義的類傳入需要序列化的資料例項化，
呼叫.data即可拿到序列化或者校驗後的資料了
Django REST framework中的Serializer使用類來定義，須繼承自rest_framework.serializers.Serializer
1 寫一個序列化的類，繼承Serializer
class BookSerializer(serializers.Serializer):
# 在這裡寫要序列化的欄位
# 序列化欄位類(有很多，常用的就幾個，等同於models中的欄位類)
# 欄位類，有很多欄位引數（）
name = serializers.CharField()
price = serializers.IntegerField()
# publish = serializers.CharField()
2 在類中寫要序列化的欄位（常用欄位，和非常用欄位）（欄位引數）
name = serializers.CharField()
price = serializers.IntegerField()
3 在檢視類中使用（例項化得到一個序列化類的物件，傳入要序列化的資料）
class BookView(APIView):
def get(self, request):
book_list = models.Book.objects.all()
# instance=None, 要序列化的資料
# data=empty ,要反序列化的資料（目前data先不用）
# many=True 如果序列化多條，一定要寫many=True
book_ser = BookSerializer(instance=book_list, many=True)
# book_ser.data就是序列化後的資料
return Response(book_ser.data)
4 得到序列化後的資料,返回（物件.data---》就是字典）
book_ser.data
5 欄位引數，source,指定要序列化表中的哪個欄位
##########具體操作步驟見下方詳細操作#########
路由層 urls.py
from django.urls import path
from app import views
urlpatterns = [
path('admin/', admin.site.urls),
# 獲取所有的書籍資訊
path('books_new/', views.BookView.as_view()),
# 對某本書進行操作
path('books_new/<int:id>/', views.BookViewId.as_view()),
]
模型層 models.py
from django.db import models
class Book(models.Model):
name = models.CharField(max_length=32, verbose_name='書名')
publish = models.CharField(max_length=32, verbose_name='出版社')
price = models.IntegerField(verbose_name='價格')
序列化器層 serializer.py
from rest_framework import serializers
from app import models
# 新建序列化類，繼承Serializer
class BookSerializer(serializers.Serializer):
# 類中定義和模型表一一對應的欄位，在這裡寫要序列化的欄位
# 序列化欄位類(有很多，常用的就幾個，等同於models中的欄位類)
# 欄位類，有很多欄位引數（）
name = serializers.CharField()
price = serializers.IntegerField()
publish = serializers.CharField()
檢視層 views.py
# 獲取所有書籍資訊
class BookView(APIView):
def get(self, request):
book_list = models.Book.objects.all()
book_ser = BookSerializer(instance=book_list, many=True)
# book_ser.data就是序列化後的資料
return Response(book_ser.data)
"""
instance=None, 要序列化的資料
data=empty ,要反序列化的資料（目前data先不用）
many=True 如果序列化多條，一定要寫many=True
"""
# 對某一本書進行操作
class BookViewId(APIView):
# 對某一個進行操作需要帶上id
def get(self, request, id):
book = models.Book.objects.all().filter(pk=id).first()
book_ser = BookSerializer(instance=book)
return Response(book_ser.data)
source
1 指定要序列化的欄位（資料表中欄位）
publish = serializers.CharField(source='publish.city') # 拿到出版社所在的城市
2 用的最多：只有一個欄位（也可以跨表）
SerializerMethodField
用的最多：跨表查（(來定製返回的欄位)要麼是列表，要麼是字典）
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
print(obj)
# return {'name':'sss','city':'sss'}
return {'name':obj.publish.name,'city':obj.publish.city,'email': obj.publish.email}
在模型表中寫方法
# models.py 表模型中寫的
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField()
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
def __str__(self):
return self.name
# def publish_name(self):
# return self.publish.name
def publish_name(self):
return {'name':self.publish.name,'city':self.publish.city}
@property
def author_list(self): # 列表推導式
return [{'name':author.name,'age':author.age,'id':author.nid} for author in self.authors.all()]
# serializers.py 序列化類中
class BookSerializer(serializers.Serializer):
name = serializers.CharField()
price = serializers.IntegerField()
publish_name = serializers.DictField()
author_list = serializers.ListField()
注意：serializer不是隻能為資料庫模型類定義，也可以為非資料庫模型類的資料定義。serializer是獨立於資料庫之外的存在。
序列化類常用欄位型別及屬性
欄位引數針對性分類
# 針對charfield
max_length 最大長度
min_lenght 最小長度
allow_blank 是否允許為空
# 針對interfield
max_value 最小值
min_value 最大值
# 通用的，大家都有
# 這兩個最重要
read_only 表明該欄位僅用於序列化輸出，預設False（序列化）
write_only 表明該欄位僅用於反序列化輸入，預設False（反序列化）
required 表明該欄位在反序列化時必須輸入，預設True
default 反序列化時使用的預設值
allow_null 表明該欄位是否允許傳入None，預設False
error_messages 包含錯誤編號與錯誤資訊的字典
validators 該欄位使用的驗證器（瞭解）
反序列化，區域性鉤子，全域性鉤子
使用序列化器進行反序列化時，需要對資料進行驗證後，才能獲取驗證成功的資料或儲存成模型類物件。
在獲取反序列化的資料前，必須呼叫is_valid()方法進行驗證，驗證成功返回True，否則返回False。
驗證失敗，可以通過序列化器物件的errors屬性獲取錯誤資訊，返回字典，包含了欄位和欄位的錯誤。如果是非欄位錯誤，可以通過修改REST framework配置中的NON_FIELD_ERRORS_KEY來控制錯誤字典中的鍵名。
驗證成功，可以通過序列化器物件的validated_data屬性獲取資料。
在定義序列化器時，指明每個欄位的序列化型別和選項引數，本身就是一種驗證行為。
1 如果要反序列化，繼承了Serializer，必須重寫create方法
2 使用
# 檢視類
def post(self, request):
publish_ser = serializer.PublishSerializer(data=request.data)
if publish_ser.is_valid(): # 校驗資料
# 直接儲存，儲存到哪個表裡？需要重寫save
publish_ser.save()
return Response(publish_ser.data)
else:
print(publish_ser.errors)
return Response('資料有問題啊')
# 序列化類
def create(self, validated_data):
# 校驗過後的資料
res = models.Publish.objects.create(**validated_data)
return res
"""
父類的save內部呼叫了create，所以我們重寫create
return res 給了self.instance以後，instance就有值了
publish_ser.data，instance就有值呼叫data就能拿到序列化後的資料
is_valid()方法還可以在驗證失敗時丟擲異常serializers.ValidationError，可以通過傳遞raise_exception=True引數開啟，
REST framework接收到此異常，會向前端返回HTTP 400 Bad Request響應。
"""
區域性和全域性鉤子
# validate_欄位名
def validate_name(self, data):
# data就是當前欄位的值
if data.startswith('sb'):
raise ValidationError('不能以sb開頭')
else:
return data
# 在序列化器中需要同時對多個欄位進行比較驗證時，可以定義validate方法來驗證
def validate(self, attrs):
if attrs.get('name') == attrs.get('city'):
raise ValidationError('city和名字不能一樣')
else:
return attrs
模型類序列化器
如果我們想要使用序列化器對應的是Django的模型類，DRF為我們提供了ModelSerializer模型類序列化器來幫助我們快速建立一個Serializer類
ModelSerializer與常規的Serializer相同，但提供了：
- 基於模型類自動生成一系列欄位
- 基於模型類自動為Serializer生成validators，比如unique_together
- 包含預設的create()和update()的實現
檢視類 views.py
class BookView(APIView):
def get(self,request):
qs=models.Book.objects.all()
ser=serializer.BookModelSerializer(instance=qs,many=True)
return Response(ser.data)
def post(self,request):
ser = serializer.BookModelSerializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
class BookDetailView(APIView):
def get(self,request,id):
book = models.Book.objects.filter(pk=id).first()
ser = serializer.BookModelSerializer(instance=book)
return Response(ser.data)
def put(self,request,id):
book = models.Book.objects.filter(pk=id).first()
ser = serializer.BookModelSerializer(instance=book,data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
def delete(self,request,id):
res = models.Book.objects.filter(pk=id).delete()
if res[0] > 0:
return Response('')
else:
return Response('要刪的不存在')
序列化類 serializers.py
"""
ModelSerializer
使用步驟：
1、新建序列化類，繼承ModelSerializer
2、類中定義和模型表一一對應的欄位，這裡可以定義class Meta() 然後指定模型表model和 對映欄位fields，比Serializer更簡潔
-其中類中的名字可以改變，需要在serializers.CharField()的括號中指定source=某個欄位，建議對映關係
-外來鍵關係的欄位可以用serializers.SerializerMethodField()，需要在下方固定寫 get_欄位名 的方法，
這裡可以寫具體邏輯，最終返回結果就是該欄位的結果
3、當新增資料的時候不需要重寫父類的create方法，這裡ModelSerializer做了封裝
4、當修改資料的時候不需要重寫父類的update方法，這裡ModelSerializer做了封裝
5、當完成這些配置後就可以在檢視類中例項化呼叫了，序列化的時候序列化，反序列化的時候校驗
"""
from rest_framework import serializers
from app import models
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = models.Book # model 指明參照哪個模型類
fields = '__all__' # fields 指明為模型類的哪些欄位生成，__all__表名包含所有欄位
# 給欄位類加屬性
extra_kwargs = {
'publish': {'required': True, 'write_only': True},
'authors': {'required': True, 'write_only': True},
}
publish_detail = PublishSerializer(source='publish',read_only=True)
author_list=serializers.ListField(read_only=True)
# 欄位自己的校驗，全域性鉤子，區域性鉤子
"""
使用fields來明確欄位，__all__表名包含所有欄位，也可以寫明具體哪些欄位，如
使用exclude可以明確排除掉哪些欄位
使用extra_kwargs引數為ModelSerializer新增或修改原有的選項引數
"""
表模型 models.py
這是完整的模型表，上面的檢視和序列化類只展示了部分表的增刪改查演示
from django.db import models
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='書名')
price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name='價格')
publish_date = models.DateField(verbose_name='出版時間')
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
class Meta:
verbose_name_plural = '書籍表'
def __str__(self):
return self.name
# 表模型寫方法，展示更多欄位
# def publish_name(self):
# return self.publish.name
# def publish_name(self):
# return {'name':self.publish.name,'city':self.publish.city}
#
# @property
# def author_list(self):
# return [{'name':author.name,'age':author.age,'id':author.nid} for author in self.authors.all()]
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='名字')
age = models.IntegerField(verbose_name='年齡')
author_detail = models.OneToOneField(to='AuthorDetail',to_field='nid',unique=True,on_delete=models.CASCADE)class Meta:
verbose_name_plural = '作者表'
def __str__(self):
return self.name
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
telephone = models.BigIntegerField(verbose_name='電話')
birthday = models.DateField(verbose_name='生日')
addr = models.CharField(max_length=64, verbose_name='地址')
class Meta:
verbose_name_plural = '作者詳情表'
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='社名')
city = models.CharField(max_length=32, verbose_name='地址')
email = models.EmailField(verbose_name='郵箱')
class Meta:
verbose_name_plural = '出版社表'
def __str__(self):
return self.name
路由urls.py
urlpatterns = [
path('books/',views.BookView.as_view()),
path('books/<int:id>/',views.BookDetailView.as_view()),
]
序列化高階用法
ModelSerializer用的基本就是下面這個方法
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = models.Book
fields = "__all__"
"""
如果想讓欄位更豐富些,可以採用任意一種方法實現（方法有很多種）
第一種方法：source
publish = serializers.CharField(source='publish.city')
第二種方法：SerializerMethodField
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
return {'name':obj.publish.name,'city':obj.publish.city,'email': obj.publish.email}
第三種方法：在表模型寫方法
def publish_name(self):
return {'name':self.publish.name,'city':self.publish.city}
@property
def author_list(self):
return [{'name':author.name,'age':author.age,'id':author.nid} for author in self.authors.all()]
第四種方法：子序列化
publish = Publishserializer()
"""