DRF序列化和反序列化（一：Serializer）
一：表关系如下
from django.db import models
# Create your models here.
__all__=['Book','Publisher','Authon']
class Book(models.Model):
title =models.CharField(max_length=32,verbose_name='图书名称')
CHOICES=((1,'python'),(2,'go'),(3,'linux'))
category=models.IntegerField(choices=CHOICES,verbose_name='图书类别')
pub_time=models.DateTimeField(verbose_name='出版日期')
authon=models.ManyToManyField('Authon')
publisher=models.ForeignKey(to='Publisher',on_delete=None)
def __str__(self):
return self.title
class Authon(models.Model):
name= models.CharField(max_length=32, verbose_name='作者姓名')
def __str__(self):
return self.name
class Publisher(models.Model):
title = models.CharField(max_length=32, verbose_name='出版社名称')
def __str__(self):
return self.title
二：使用django编写接口
1:使用jsonResponse模块进行数据序列化。
from django.http import JsonResponse
class Bookview(View):
#使用jsonResponse 当存在外键时，需要自己手动对数据进行处理。
def get(self,request):
book_list=models.Book.objects.values('id','title','pub_time','publisher',"category")
book_list=list(book_list)
for book in book_list:
print(book)
publisher_id = book['publisher']
publisher_obj=models.Publisher.objects.filter(id=publisher_id).first()
book['pulisher']={
'id':publisher_id,
'title':publisher_obj.title
}
return JsonResponse(book_list,safe=False,json_dumps_params={'ensure_ascii':False})
2:使用serialize模块进行数据序列化。
def get(self,request):
book_list=models.Book.objects.all()
book_list=serializers.serialize('json',book_list,ensure_ascii=False )
return HttpResponse(book_list)
3:使用serialize和JsonResponse不方便处
a:遇到外键关系，需要非常繁琐的处理。
三：使用rest_framework 中 serializers进行序列化和反序列化
1:基本准备
a:下载 rest-framewoke模块，pip install rest-framework
b:首先要明白后端展示给前端页面的数据，可能是经过跨表查询的具体值。而前端传送给后端，并不需要传送具体的值，也就是说前端和后端对同一个资源传递的数据类型可能不一样。比如性别，前端展示的是，男，女。但是后端在数据库存储的时候，往往是0，1
c:新建文件serializers.py（用于编写序列化规则）
d:settings中注册app
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'SerDemo',
'rest_framework' #app注册
]
2:serializers序列化
a:设定路由
--注意需要调用as_view方法
from django.urls import path,include
from SerDemo import views
urlpatterns = [
path('list/', views.BookApiView.as_view()),
]
b:在serializes.py编写序列化规则
--注意序列化规则内每一个字段都和models字段相对应。重点，
--外键关系一对多和多对多需要注意
--read_only=True(只进行序列化)，同理write_only=True(该字段只进行反序列化)
from rest_framework import serializers
from SerDemo.models import Book
#一对多外键关系序列化处理
class PublisherSerializers(serializers.Serializer):
id = serializers.IntegerField()
title=serializers.CharField(max_length=32)
#多对多外键关系序列化处理
class AuthonSerializers(serializers.Serializer):
id = serializers.IntegerField()
name=serializers.CharField(max_length=32)
class BookSerializers(serializers.Serializer):
#不需要校验
id = serializers.IntegerField(required=False,)
title = serializers.CharField(max_length=32)
CHOICES = ((1, 'python'), (2, 'go'), (3, 'linux'))
category = serializers.ChoiceField(choices=CHOICES, source="get_category_display",read_only=True)
pub_time = serializers.DateTimeField()
#处理一对多
publisher=PublisherSerializers(read_only=True)
#处理多对多外键关系 many=True
authon=AuthonSerializers(many=True,read_only=True)
c:视图函数的编写
--导包 （APIView,Response）
--视图函数继承APIView
--many默认参数不写默认序列化一个对象，many=True 表示序列化多个对象
--get请求会对应get方法
from SerDemo import models
from rest_framework.views import APIView #视图函数继承APIView 不是View
from rest_framework.response import Response #用于返回值
#BookSerializers 自己定义的序列化规则
from SerDemo.serializers import *
class BookApiView(APIView):
def get(self,request):
book_obj = models.Book.objects.all()
#序列化多组数据 和一个对象，需要many=TRUE 默认一个
ret =BookSerializers(book_obj,many=True)
#序列化的数据在data属性中
return Response(ret.data)
3:serializers反序列化
a:在serializes.py编写反序列化规则
--首先序列化，我们常常需要把外键对象的值获取给前端，而反序列化，后端仅仅需要数据库一个id就能进行数据库值的插入。
--write_only表示该字段只是反序列化使用，前端发送时key也应该和该值对应
--注意一对多，多对多关系，choices的字段
class BookSerializers(serializers.Serializer):
#不需要校验
id = serializers.IntegerField(required=False,)
title = serializers.CharField(max_length=32,validators=[my_validata])
CHOICES = ((1, 'python'), (2, 'go'), (3, 'linux'))
category = serializers.ChoiceField(choices=CHOICES, source="get_category_display",read_only=True)
w_category=serializers.ChoiceField(choices=CHOICES,write_only=True)
pub_time = serializers.DateTimeField()
#处理一对多
publisher=PublisherSerializers(read_only=True)
publisher_id=serializers.IntegerField(write_only=True)
#处理多对多外键关系 many=True
authon=AuthonSerializers(many=True,read_only=True)
authon_id =serializers.ListField(write_only=True)
b:views文件中编写post的请求，对数据进行添加。
--添加数据需要在BookSerializers重新编写create方法
--注意返回值
--所有的数据都在request.data方法中，（与View方法存在request.get,request.post中不同，该方法对这些方法进行封装）
def post(self,request):
# print(request.data)
data = BookSerializers(data=request.data)
#进行数据验证，并且在BookSerializers中重写create方法
if data.is_valid():
data.save()
return Response(data.data)
else:
return Response(data.errors)
c:编写create方法
class BookSerializers(serializers.Serializer):
#不需要校验
id = serializers.IntegerField(required=False,)
title = serializers.CharField(max_length=32,validators=[my_validata])
CHOICES = ((1, 'python'), (2, 'go'), (3, 'linux'))
category = serializers.ChoiceField(choices=CHOICES, source="get_category_display",read_only=True)
w_category=serializers.ChoiceField(choices=CHOICES,write_only=True)
pub_time = serializers.DateTimeField()
#处理一对多
publisher=PublisherSerializers(read_only=True)
publisher_id=serializers.IntegerField(write_only=True)
#处理多对多外键关系 many=True
authon=AuthonSerializers(many=True,read_only=True)
authon_id =serializers.ListField(write_only=True)
#向服务器添加数据，需要实现该方法
def create(self, validated_data):
book =Book.objects.create(title=validated_data['title'],category=validated_data['w_category'],
pub_time=validated_data['pub_time'],
publisher_id=validated_data['publisher_id']
)
#添加多对多关系
book.authon.add(*validated_data['authon_id'])
return book
d:put实现更新
--路由分发 path('retrieve/<int:id>',views.BookEditView.as_view())
--代码编写
--partial参数
def put(self,request,id):
print(request.data)
book_obj = Book.objects.filter(id=id).first()
# partial True 表示可以进行部分字段跟新，Flase 表示全部跟新，默认False
book_serializers = BookSerializers(book_obj,data=request.data,partial=True)
#需要重写 update
if book_serializers.is_valid():
book_serializers.save()
return Response(book_serializers.validated_data)
else:
return Response(book_serializers.errors)
--重写update方法
#数据跟新
def update(self, instance, validated_data):
print(validated_data.get('authon'))
instance.title =validated_data.get('title',instance.title)
instance.category=validated_data.get('category',instance.category)
instance.pub_time =validated_data.get('pub_time',instance.pub_time)
instance.publisher_id =validated_data.get('publisher_id',instance.publisher_id)
if validated_data.get('authon_id'):
instance.authon.set(validated_data.get('authon_id'))
instance.save()
return instance
e:实现delete方法
def delete(self,request,id):
book_obj = Book.objects.filter(id=id).first()
book_obj.delete()
return Response("")
4:serializers字段校验扩展
a:局部钩子校验
--校验字段方法，固定格式validate_字段名
-- 参数value,就是该字段的值
-- 返回值
#单个字段进行校验
def validate_title(self, value):
if 'python' not in value.lower:
return serializers.ValidationError('标题必须含有python')
return value
b:全局钩子多个字段联合校验
--方法 validate为固定方法
--attrs保存联合字段的字段值
--注意返回值
#全局钩子对字段进行联合校验
def validate(self, attrs):
if attrs['category'] =='linux' and attrs['publisher_id']==3:
return attrs
else:
return serializers.ValidationError('类型或出版社错误')
c:自定义钩子验证
#自定义校验
#在需要进行验证的字段引用 title = serializers.CharField(max_length=32,validators=[my_validata])
#优先级大于 validata_title 局部钩子
def my_validata(value):
if value in '敏感信息':
raise serializers.ValidationError('不能含有敏感信息')
return value
