DjangoRestFramework学习二之序列化组件

 

本节目录

一 序列化组件

　　首先按照restful规范咱们创建一些api接口，按照下面这些形式写吧：

　　　　courses --- get ---> 查看数据----->返回所有数据列表[{},{},]

　　　　courses--- post --->添加数据 -----> 返回添加的数据{ }

　　　　courses/1 ---put---> 更新pk=1的数据 ----->返回更新后的数据{ }

　　　　courses/1 --- delete---> 删除pk=1的数据 -----> 返回空

　　　　courses/1 --- get --->查看单条数据 -----> 返回单条数据 { }

　　这样，我们先看一个drf给我们提供的一个类似于postman功能的页面，首先我们创建一个django项目，创建一个course表，然后添加一些数据，然后按照下面的步骤操作，

　　　　第一步：引入drf的response对象　　

from django.shortcuts import render,httpresponse,redirect
import json
from django.views import view
from app01 import models
from rest_framework.views import apiview

#引用drf提供的response对象
from rest_framework.response import response

#写我们的cbv视图
class courseview(apiview):
　　#返回所有的course数据
    def get(self,request):
        course_obj_list = models.course.objects.all()
        ret = []
        for course_obj in course_obj_list:
            ret.append({
                "title":course_obj.title,
                "desc":course_obj.desc,
            })
        # return httpresponse(json.dumps(ret, ensure_ascii=false))
        return response(json.dumps(ret, ensure_ascii=false)) #这里使用response来返回消息

    def post(self,request):
        print(request.data)
        return httpresponse('post')

　　　　第二步：配置app，在我们的settings配置文件中配置

installed_apps = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.app01config',
    'rest_framework',  #将它注册成app
]

　　　　第三步，配置我们的路由

"""
from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^courses/', views.courseview.as_view(),name='courses'),
]

　　　　第四步：启动项目，通过浏览器访问我们的路由(必须是浏览器访问才能看到对应的功能)，看效果：

　　　　　　

　　　　这里面我们可以发送不同类型的请求，看到对应的返回数据，类似于postman，但是没有postman好用，所以以后调试我们还是用postman工具，但是我们知道一下昂。

　　上面的数据，我们通过json自己进行的序列化，其实django也给我们提供了一个简单的序列化组件，看用法：

from django.shortcuts import render,httpresponse,redirect
import json
from django.views import view
from app01 import models
from rest_framework.views import apiview
from django.core.serializers import serialize  #django的序列化组件，不是我们要学的drf的序列化组件昂

#不用json自己来序列化了，太麻烦，我们使用drf提供的序列化组件
from rest_framework.response import response

class courseview(apiview):

    def get(self,request):
        course_obj_list = models.course.objects.all()
        # ret = []
        # for course_obj in course_obj_list:
        #     ret.append({
        #         "title":course_obj.title,
        #         "desc":course_obj.desc,
        #     })
        # return httpresponse(json.dumps(ret, ensure_ascii=false))
        # return response(json.dumps(ret, ensure_ascii=false)
        se_data = serialize('json',course_obj_list,ensure_ascii=false)
        print(se_data)#也拿到了序列化之后的数据，简洁很多
        #[{"model": "app01.course", "pk": 1, "fields": {"title": "python", "desc": "666"}}, {"model": "app01.course", "pk": 2, "fields": {"title": "linux", "desc": "\u4e5f\u5f88\u597d"}}, {"model": "app01.course", "pk": 3, "fields": {"title": "go", "desc": "\u5c06\u6765\u53ef\u80fd\u5f88\u597d"}}]

        return response(se_data)

　　那么我们知道了两个序列化方式了，这个序列化是不是就简单很多啊，但是drf给我们做了一个更牛逼的序列化组件，功能更强大，而且不仅仅能做序列化，还能做其他的事情，所以呢，做api的时候，我们还是用drf提供的序列化组件。

import json
from datetime import datetime
from datetime import date

#对含有日期格式数据的json数据进行转换
class jsoncustomencoder(json.jsonencoder):
    def default(self, field):
        if isinstance(field,datetime):
            return field.strftime('%y-%m-%d %h:%m:%s')
        elif isinstance(field,date):
            return field.strftime('%y-%m-%d')
        else:
            return json.jsonencoder.default(self,field)


d1 = datetime.now()

dd = json.dumps(d1,cls=jsoncustomencoder)
print(dd)

 

　　接下来重点到了，我们玩一下drf提供的数据序列化组件：

　　1.我们通过get方法，来查看所有的course数据。

from django.shortcuts import render,httpresponse,redirect
import json
from django.views import view
from app01 import models
from rest_framework.views import apiview
from django.core.serializers import serialize  #django的序列化组件，不是我们要学的drf的序列化组件昂

from rest_framework.response import response

# 序列化方式3，1.引入drf序列化组件
from rest_framework import serializers

# 2.首先实例化一个类，继承drf的serializers.serializer，类似于我们的form组件和models的用法
class courseserializers(serializers.serializer):
    #这里面也要写对应的字段，你写了哪些字段，就会对哪些字段的数据进行序列化，没有被序列化的字段，不会有返回数据，你可以注释掉一个，然后看返回的数据是啥
    title = serializers.charfield(max_length=32) #序列化的时候还能校验字段
    desc = serializers.charfield(max_length=32)

class courseview(apiview):

    def get(self,request):
        course_obj_list = models.course.objects.all()
        # 3.使用我们创建的序列化类
        cs = courseserializers(course_obj_list, many=true)  # 序列化多个对象的时候，需要些many=true参数
        #4.通过返回对象的data属性就能拿到序列化之后的数据
        se_data = cs.data
        print(se_data) #[ordereddict([('title', 'python'), ('desc', '666')]), ordereddict([('title', 'linux'), ('desc', '也很好')]), ordereddict([('title', 'go'), ('desc', '将来可能很好')])] 列表嵌套的有序字典。

        #还记得创建字典的另外一种写法吗？这个没啥用昂，给大家回顾一下之前的知识
        # d1 = {'name':'chao'}
        # d2 = dict([('name','chao'),('age',18)])
        # print(d1) #{'name': 'chao'}
        # print(d2) #{'age': 18, 'name': 'chao'}
        # # 有序字典
        # from collections import ordereddict
        # d3 = ordereddict([('name','jaden'),('age',22)])
        # print(d3) #ordereddict([('name', 'jaden'), ('age', 22)])

        return response(se_data) #drf的response如果返回的是drf序列化之后的数据，那么客户端拿到的是一个有格式的数据，不再是一行显示了

 　　看效果：

　　　　

　　2.通过post方法来添加一条数据：

from django.shortcuts import render,httpresponse,redirect
from django.views import view
from app01 import models
from rest_framework.views import apiview

from rest_framework.response import response

from rest_framework import serializers

class courseserializers(serializers.serializer):
    title = serializers.charfield(max_length=32)
    desc = serializers.charfield(max_length=32)

class courseview(apiview):

    def get(self,request):
        course_obj_list = models.course.objects.all()
        cs = courseserializers(course_obj_list, many=true)
        se_data = cs.data
        return response(se_data)

    def post(self,request):
        # print(request.data) #{'desc': 'java也挺好', 'title': 'java'}
        #发送过来的数据是不是要进行验证啊，drf的序列化组件还能校验数据
        cs = courseserializers(data=request.data,many=false) #注意必须是data=这种关键字参数,注意，验证单条数据的时候写上many=false参数,而且我们还要序列化这个数据，因为我们要给客户端返回这个数据
        # print(cs.is_valid()) #true ，如果少数据，得到的是false
        if cs.is_valid():
            print(cs.data)
            models.course.objects.create(**cs.data)#添加数据
            return response(cs.data) #按照post添加数据的api规则，咱们要返回正确的数据
        else:
            # 假如客户端发送过来的数据是这样的，少title的数据
            # {
            #     "desc": "java也挺好"
            # }
            cs_errors = cs.errors
            # print(cs_errors) #{'title': ['this field is required.']}
            return response(cs_errors)
            # postman上我们看到的效果是下面这样的
            # {
            #     "title": [
            #         "this field is required."
            #     ]
            # }

　　然后添加一些数据，好，接下来我们玩一些有关联关系的表

class author(models.model): 
    nid = models.autofield(primary_key=true)
    name=models.charfield( max_length=32)
    age=models.integerfield()

class authordetail(models.model):

    nid = models.autofield(primary_key=true)
    birthday=models.datefield()
    telephone=models.bigintegerfield()
    addr=models.charfield( max_length=64)

class publish(models.model):
    nid = models.autofield(primary_key=true)
    name=models.charfield( max_length=32)
    city=models.charfield( max_length=32)
    email=models.emailfield()

class book(models.model):

    nid = models.autofield(primary_key=true)
    title = models.charfield( max_length=32)
    publishdate=models.datefield()
    price=models.decimalfield(max_digits=5,decimal_places=2)
    publish=models.foreignkey(to="publish",to_field="nid",on_delete=models.cascade) #多对一到publish表
    authors=models.manytomanyfield(to='author',) #多对多到author表

　　看序列化代码：　

from django.shortcuts import render,httpresponse,redirect
from django.views import view
from app01 import models

from rest_framework.views import apiview
from rest_framework.response import response
from rest_framework import serializers


class bookserializers(serializers.serializer):
    #我们先序列化写两个字段的数据，别忘了这里面的字段和model表中的字段变量名要一样
    title = serializers.charfield(max_length=32)
    price = serializers.decimalfield(max_digits=5, decimal_places=2)

    #一对多的处理
    # publish = serializers.charfield(max_length=32)  #返回对象
    publish_email = serializers.charfield(max_length=32, source='publish.email')  # source指定返回的多对一的那个publish对象的email数据，并且我们现在找到书籍的email，所以前面的字段名称就可以不和你的publish对应好了，随便取名字
    publish_name = serializers.charfield(max_length=32, source='publish.email')  # source指定返回的多对一的那个publish对象的其他字段数据，可以接着写字段,也就是说关联的所有的字段的数据都可以写在这里进行序列化

    #对多对的处理
    # authors = serializers.charfield(max_length=32) #bookobj.authors拿到的类似于一个models.authors.object，打印的时候这是个none
    # authors = serializers.charfield(max_length=32,source="authors.all") #这样写返回的是queryset类型的数据，这样给前端肯定是不行的，所以按照下面的方法写
    authors = serializers.serializermethodfield() #序列化方法字段，专门给多对多字段用的，然后下面定义一个方法，方法名称写法是这样的get_字段名,名字必须是这样
    def get_authors(self,obj): #参数写一个obj，这个obj是一个一个的书籍对象，然后我们通过书籍对象来返回对应的数据
        # author_list_values = obj.authors.all().values() #返回这样类型的数据也行,那么具体你要返回什么结构的数据，需要和前端人员沟通清楚，然后这里对数据进行加工
        #假如加工成的数据是这种类型的[ {},{} ],就可以按照下面的逻辑来写，我简单写的，肯定有更好的逻辑来加工这些数据
        author_list_values = []
        author_dict = {}
        author_list = obj.authors.all()
        for i in author_list:
            author_dict['name'] = i.name
            author_list_values.append(author_dict)
        return author_list_values


class bookview(apiview):
    def get(self,request):
        book_obj_list = models.book.objects.all()
        s_books = bookserializers(book_obj_list,many=true)
        return response(s_books.data)

    def post(self,request):
        pass

　　其实serializer在内部就做了这点事儿，伪代码昂。

　　　　

　　urls.py是这样写的：

urlpatterns = [
    #url(r'^admin/', admin.site.urls),
    #做一些针对书籍表的接口
    url(r'^books/', views.bookview.as_view(),),

]

 　　然后看postman返回的数据：

　　　　

　　那么我们就能够完成各种数据的序列化了，但是你会发现，这样写太累啦，这只是一张表啊，要是上百张表咋整啊，所以还有一个更简单的方式(类似于form和modelform的区别)。

　　我们使用modelserializer，看代码：

#modelserializer
class bookserializers(serializers.modelserializer):
    class meta:
        model=models.book
        # fields=['title','price','publish','authors']
        fields = "__all__"
        # 如果直接写all，你拿到的数据是下面这样的，但是如果人家前端和你要的作者的id和名字，你是不是要处理一下啦
        # [
        #     {
        #         "nid": 3,
        #         "title": "go",
        #         "publishdate": null,
        #         "price": "122.00",
        #         "publish": 2,
        #         "authors": [
        #             2,
        #             1
        #         ]
        #     }
        # ]
    #那么没办法，只能自己再进行加工处理了，按照之前的方式
    authors = serializers.serializermethodfield()
    def get_authors(self,obj):
        author_list_values = []
        author_dict = {}
        author_list = obj.authors.all()
        for i in author_list:
            author_dict['id'] = i.pk
            author_dict['name'] = i.name
            author_list_values.append(author_dict)
        return author_list_values #这个数据就会覆盖上面的序列化的authors字段的数据
    # 那么前端拿到的数据就这样了
    # [
    #     {
    #         "nid": 3,
    #         "authors": [
    #             {
    #                 "name": "chao",
    #                 "id": 1
    #             },
    #             {
    #                 "name": "chao",
    #                 "id": 1
    #             }
    #         ],
    #         "title": "go",
    #         "publishdate": null,
    #         "price": "122.00",
    #         "publish": 2
    #     }
    # ]
    # 那如果一对多关系的那个publish，前端想要的数据是名字怎么办呢？还是老办法，source
    # publish_name = serializers.charfield(max_length=32, source='publish.name')#但是你会发现序列化之后的数据有个publish:1对应个id值，如果我不想要他怎么办，那么可以起个相同的变量名来覆盖它，比如下面的写法
    publish = serializers.charfield(max_length=32, source='publish.name')

class bookview(apiview):
    def get(self,request):
        book_obj_list = models.book.objects.all()
        s_books = bookserializers(book_obj_list,many=true)
        return response(s_books.data)

    def post(self,request):
        pass

　　上面我们完成了get请求来查看所有的书籍信息，接下来我们玩一个post请求添加一条book数据，直接上代码吧：

class bookserializers(serializers.modelserializer):
    class meta:
        model=models.book
        fields = "__all__"
　　 # 注意先把下面这些注释掉
    # authors = serializers.serializermethodfield()
    # def get_authors(self,obj):
    #     author_list_values = []
    #     author_dict = {}
    #     author_list = obj.authors.all()
    #     for i in author_list:
    #         author_dict['id'] = i.pk
    #         author_dict['name'] = i.name
    #         author_list_values.append(author_dict)
    #     return author_list_values
    # publish = serializers.charfield(max_length=32, source='publish.name')

class bookview(apiview):
    def get(self,request):
        book_obj_list = models.book.objects.all()
        s_books = bookserializers(book_obj_list,many=true)
        return response(s_books.data)


    def post(self,request):

        b_serializer = bookserializers(data=request.data,many=false)
        if b_serializer.is_valid():
            print('xxxx')
            b_serializer.save() #因为这个序列化器我们用的modelserializer，并且在bookserializers类中我们指定了序列化的哪个表，所以直接save，它就知道我们要将数据保存到哪张表中,其实这句话执行的就是个create操作。
            return response(b_serializer.data) #b_serializer.data这就是个字典数据

        else:
            return response(b_serializer.errors)

　　上面我们完成了get和post请求的接口写法，下面我们来完成put、delete、get查看单条数据的几个接口。

　　urls.py内容如下：

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # url(r'^courses/', views.courseview.as_view()),
    #做一些针对书籍表的接口
    #get和post接口的url
    url(r'^books/$', views.bookview.as_view(),), #别忘了$符号结尾

    #put、delete、get请求接口
    url(r'^books/(\d+)/', views.sbookview.as_view(),),

]

　　views.py代码如下：

from django.shortcuts import render,httpresponse,redirect
from django.views import view
from app01 import models

from rest_framework.views import apiview
from rest_framework.response import response
from rest_framework import serializers

class bookserializers(serializers.modelserializer):
    class meta:
        model=models.book
        fields = "__all__"

class bookview(apiview):
    def get(self,request):
        '''
        查看所有书籍
        :param request:
        :return:
        '''
        book_obj_list = models.book.objects.all()
        s_books = bookserializers(book_obj_list,many=true)
        return response(s_books.data)

    def post(self,request):
        '''
        添加一条数据
        :param request:
        :return:
        '''
        b_serializer = bookserializers(data=request.data,many=false)
        if b_serializer.is_valid():
            b_serializer.save()
            return response(b_serializer.data)
        else:
            return response(b_serializer.errors)

#因为更新一条数据，删除一条数据，获取一条数据，都有个单独的参数(获取一条数据的，一般是id，所以我将put、delete、get写到了一个视图类里面，也就是说结合上面那个bookview视图类，完成了我们的那些接口)
class sbookview(apiview):
    def get(self,request,id):
        '''
        获取单条数据
        :param request:
        :param id:
        :return:
        '''
        book_obj = models.book.objects.get(pk=id)#获取这条数据对象
        #接下来序列化单个model对象，序列化单个对象返回的是一个字典结构 {},序列化多个对象返回的是[{},{}]这种结构
        book_serializer = bookserializers(book_obj,many=false)
        return response(book_serializer.data)


    def put(self,request,id):
        '''
        更新一条数据
        :param request:request.data更新提交过来的数据
        :param id:
        :return:
        '''
        book_obj = models.book.objects.get(pk=id)
        b_s = bookserializers(data=request.data,instance=book_obj,many=false) #别忘了写instance,由于我们使用的modelserializer，所以前端提交过来的数据必须是所有字段的数据，当然id字段不用
        if b_s.is_valid():
            b_s.save() #翻译成的就是update操作
            return response(b_s.data) #接口规范要求咱们要返回更新后的数据
        else:
            return response(b_s.errors)

    def delete(self,request,id):
        '''
        删除一条数据
        :param request:
        :param id:
        :return:
        '''
        book_obj = models.book.objects.get(pk=id).delete()
        return response("") #别忘了接口规范说最好返回一个空

 

　　好，五个接口写完，咱们的序列化组件就算是讲完了。

 

 

 

二 xxx

　　

 

 

 

三 xxx

 

 

 

 

 

四 xxx

 

 

 

 

 

五 xxx

 

 

 

 

 

 

六 xxx

 

 

 

 

七 xxx

 

 

 

 

八 xxx