1.RESTful规范

一 面向资源编程　　每个URL代表一种资源，URL中尽量不要用动词，要用名词。二 根据method不同，进行不同的操作　　GET/POST/PUT/DELETE/PATCH三 在URL中体现版本　　https://www.bootcss.com/v1/mycss　　https://v1.bootcss.com/mycss四 在URL中体现是否是API　　https://www.bootcss.com/api/mycss　　https://api.bootcss.com/mycss五 在URL中的过滤条件　　https://www.bootcss.com/v1/mycss？page=3六 尽量使用HTTPS　　https://www.bootcss.com/v1/mycss七 响应时设置状态码　　1** 信息，服务器收到请求，需要请求者继续执行操作　　2** 成功，操作被成功接收并处理　　3** 重定向，需要进一步的操作以完成请求　　4** 客户端错误，请求包含语法错误或无法完成请求　　5** 服务器错误，服务器在处理请求的过程中发生了错误八 返回值　　GET请求 返回查到所有或单条数据　　POST请求 返回新增的数据　　PUT请求 返回更新数据　　PATCH请求 局部更新 返回更新整条数据　　DELETE请求 返回值为空九 返回错误信息　　返回值携带错误信息十 Hypermedia API　　如果遇到需要跳转的情况 携带跳转接口的URL　　ret = { code: 1000, data:{ id:1, name:'小强', depart_id:http://www.luffycity.com/api/v1/depart/8/ } }2.DRF序列化2.1为什么要使用DRF来序列化

当我们做前后端分离的项目~~我们前后端交互一般都选择JSON数据格式，JSON是一个轻量级的数据交互格式。那么我们给前端数据的时候都要转成json格式，那就需要对我们从数据库拿到的数据进行序列化。接下来我们看下django序列化和rest_framework序列化的对比~~2.2Django的序列化

#1.Jsonresponse序列化方式class BooksView(View): def get(self, request): book_list = Book.objects.values("id", "title", "chapter", "pub_time", "publisher") book_list = list(book_list) # 如果我们需要取外键关联的字段信息 需要循环获取外键 再去数据库查然后拼接成我们想要的 ret = [] for book in book_list: pub_dict = {} pub_obj = Publish.objects.filter(pk=book["publisher"]).first() pub_dict["id"] = pub_obj.pk pub_dict["title"] = pub_obj.title book["publisher"] = pub_dict ret.append(book) ret = json.dumps(book_list, ensure_ascii=False, cls=MyJson) return HttpResponse(ret)# json.JSONEncoder.default()# 解决json不能序列化时间字段的问题class MyJson(json.JSONEncoder): def default(self, field): if isinstance(field, datetime.datetime): return field.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, datetime.date): return field.strftime('%Y-%m-%d') else: return json.JSONEncoder.default(self, field)

#2.Django序列化方法from django.core import serializers# 能够得到我们要的效果 结构有点复杂class BooksView(View): def get(self, request): book_list = Book.objects.all() ret = serializers.serialize("json", book_list) return HttpResponse(ret)2.3DRF的序列化2.3.1drf序列化

-- Django我们CBV继承类是View，现在DRF我们要用APIView-- Django中返回的时候我们用HTTPResponse，JsonResponse，render ，DRF我们用Response

from rest_framework import serializersclass BookSerializer(serializers.Serializer): id = serializers.IntegerField() title = serializers.CharField(max_length=32) CHOICES = ((1, "Linux"), (2, "Django"), (3, "Python")) # 这是为了显示choice字段的值 chapter = serializers.ChoiceField(choices=CHOICES, source="get_category_display") pub_time = serializers.DateField()

from rest_framework.views import APIViewfrom rest_framework.response import Responsefrom app.models import Book, Publisherfrom app.serializers import BookSerializerclass BookView(APIView): def get(self, request): book_list = Book.objects.all() ret = BookSerializer(book_list, many=True) return Response(ret.data)

2.3.2外键关系序列化

#serialisers.pyfrom django.db import models# Create your models here.__all__ = ["Book", "Publisher", "Author"]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.DateField(verbose_name="图书的出版日期") publisher = models.ForeignKey(to="Publisher", on_delete=None) author = models.ManyToManyField(to="Author") def __str__(self): return self.title class Meta: verbose_name_plural = "book"class Publisher(models.Model): title = models.CharField(max_length=32, verbose_name="出版社的名称") def __str__(self): return self.title class Meta: verbose_name_plural = "publish"class Author(models.Model): name = models.CharField(max_length=32, verbose_name="作者的姓名") def __str__(self): return self.name class Meta: verbose_name_plural = "author"

#views.pyfrom rest_framework.views import APIViewfrom rest_framework.response import Responsefrom app.models import Book, Publisherfrom app.serializers import BookSerializerclass BookView(APIView): def get(self, request): book_list = Book.objects.all() ret = BookSerializer(book_list, many=True) return Response(ret.data)

2.3.3DRF反序列化

当前端给我们发post的请求的时候~前端给我们传过来的数据~我们要进行一些校验然后保存到数据库~这些校验以及保存工作，DRF的Serializer也给我们提供了一些方法了~~首先~我们要写反序列化用的一些字段~有些字段要跟序列化区分开~Serializer提供了.is_valid() 和.save()方法~~使用write_only=True，read_only=True区别序列化字段和反序列化字段必须重写create方法

from rest_framework import serializersfrom .models import Bookclass PublisherSerializer(serializers.Serializer): id = serializers.IntegerField() title = serializers.CharField(max_length=32)class AuthorSerializer(serializers.Serializer): id = serializers.IntegerField() name = serializers.CharField(max_length=32)book_obj = { "title": "vita的使用教程", "w_category": 1, "pub_time": "2018-10-09", "publisher_id": 1, "author_list": [1, 2] }class BookSerializer(serializers.Serializer): # 插入数据时id自动生成，不需要校验 id = serializers.IntegerField(required=False) title = serializers.CharField(max_length=32) CHOICES = ((1, "Python"), (2, "Go"), (3, "Linux")) # read_only=True只在序列化的时候使用 category = serializers.ChoiceField(choices=CHOICES, source="get_category_display", read_only=True) pub_time = serializers.DateField() # write_only=True反序列化的字段，只在反序列化的时候使用，即保存数据的时候使用 w_category = serializers.ChoiceField(choices=CHOICES, write_only=True) # 只在反序列化的时候使用，插入数据的时候，只需要插入publisher_id就可以了 publisher_id = serializers.IntegerField(write_only=True) # 一定要加上read_only=True,否则在插入数据的时候，提示该字段必须添加 publisher = PublisherSerializer(read_only=True) # 指明是多对多的外键关系 author = AuthorSerializer(many=True, read_only=True) # 同样，只在反序列化，保存数据的时候使用 author_list = serializers.ListField(write_only=True) def create(self, validated_data): """ 反序列化的时候，一定要写create方法 :param validated_data: :return: """ 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.author.add(*validated_data["author_list"]) return book

#views.pyfrom rest_framework.views import APIViewfrom rest_framework.response import Responsefrom app.models import Book, Publisherfrom app.serializers import BookSerializerclass BookView(APIView): def get(self, request): book_list = Book.objects.all() ret = BookSerializer(book_list, many=True) return Response(ret.data) def post(self, request): """ 反序列化，保存数据 :param request: :return: """ print(request.data) serializer = BookSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) else: return Response(serializer.errors)

2.3.5获取单条数据

#urls.pyfrom django.contrib import adminfrom django.urls import path,includefrom app.views import BookView,BookEditViewurlpatterns = [ path('admin/', admin.site.urls), path('list', BookView.as_view()), path('retrieve/<int:id>', BookEditView.as_view()),]

#views.pyclass BookEditView(APIView): def get(self, request, id): """ 获取单条数据的接口 :param request: :param id: :return: """ book_obj = Book.objects.filter(id=id).first() ret = BookSerializer(book_obj) return Response(ret.data)

2.3.6PUT请求的部分验证

# views.pyclass BookEditView(APIView): def get(self, request, id): """ 获取单条数据的接口 :param request: :param id: :return: """ book_obj = Book.objects.filter(id=id).first() ret = BookSerializer(book_obj) return Response(ret.data) def put(self, request, id): """ 用户提交Put请求 :param request: :param id: :return: """ book_obj = Book.objects.filter(id=id).first() # partial=True允许部分校验 serializer = BookSerializer(book_obj, data=request.data, partial=True) if serializer.is_valid(): serializer.save() return Response(serializer.data) else: return Response(serializer.errors)

from rest_framework import serializersfrom .models import Bookclass PublisherSerializer(serializers.Serializer): id = serializers.IntegerField() title = serializers.CharField(max_length=32)class AuthorSerializer(serializers.Serializer): id = serializers.IntegerField() name = serializers.CharField(max_length=32)book_obj = { "title": "vita的使用教程", "w_category": 1, "pub_time": "2018-10-09", "publisher_id": 1, "author_list": [1, 2] }put_data = { "title": "vita的使用教程2"}class BookSerializer(serializers.Serializer): # 插入数据时id自动生成，不需要校验 id = serializers.IntegerField(required=False) title = serializers.CharField(max_length=32) CHOICES = ((1, "Python"), (2, "Go"), (3, "Linux")) # read_only=True只在序列化的时候使用 category = serializers.ChoiceField(choices=CHOICES, source="get_category_display", read_only=True) pub_time = serializers.DateField() # write_only=True反序列化的字段，只在反序列化的时候使用，即保存数据的时候使用 w_category = serializers.ChoiceField(choices=CHOICES, write_only=True) # 只在反序列化的时候使用，插入数据的时候，只需要插入publisher_id就可以了 publisher_id = serializers.IntegerField(write_only=True) # 一定要加上read_only=True,否则在插入数据的时候，提示该字段必须添加 publisher = PublisherSerializer(read_only=True) # 指明是多对多的外键关系 author = AuthorSerializer(many=True, read_only=True) # 同样，只在反序列化，保存数据的时候使用 author_list = serializers.ListField(write_only=True) def create(self, validated_data): """ 反序列化的时候，一定要写create方法 :param validated_data: :return: """ 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.author.add(*validated_data["author_list"]) return book def update(self, instance, validated_data): """ Put请求的方法 :param instance: :param validated_data: :return: """ #如果该字段没有，就使用原来的数据 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("author_list"): instance.author.set(validated_data["author_list"]) instance.save() return instance


2.3.7DRF验证

def my_validate(value): """ 全局验证 :param value: :return: """ if "敏感信息" in value.lower(): raise serializers.ValidationError("不能含有敏感信息") else: return valueclass BookSerializer(serializers.Serializer): # 插入数据时id自动生成，不需要校验 id = serializers.IntegerField(required=False) title = serializers.CharField(max_length=32, validators=[my_validate]) CHOICES = ((1, "Python"), (2, "Go"), (3, "Linux")) # read_only=True只在序列化的时候使用 category = serializers.ChoiceField(choices=CHOICES, source="get_category_display", read_only=True) pub_time = serializers.DateField() # write_only=True反序列化的字段，只在反序列化的时候使用，即保存数据的时候使用 w_category = serializers.ChoiceField(choices=CHOICES, write_only=True) # 只在反序列化的时候使用，插入数据的时候，只需要插入publisher_id就可以了 publisher_id = serializers.IntegerField(write_only=True) # 一定要加上read_only=True,否则在插入数据的时候，提示该字段必须添加 publisher = PublisherSerializer(read_only=True) # 指明是多对多的外键关系 author = AuthorSerializer(many=True, read_only=True) # 同样，只在反序列化，保存数据的时候使用 author_list = serializers.ListField(write_only=True) def create(self, validated_data): """ 反序列化的时候，一定要写create方法 :param validated_data: :return: """ 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.author.add(*validated_data["author_list"]) return book def update(self, instance, validated_data): """ Put请求的方法 :param instance: :param validated_data: :return: """ #如果该字段没有，就使用原来的数据 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("author_list"): instance.author.set(validated_data["author_list"]) instance.save() return instance def validate_title(self, value): """ 单个字段的验证 :param value: :return: """ if "python" not in value.lower(): raise serializers.ValidationError("标题必须含有python") return value def validate(self, attrs): """ 多个字段的验证 :param attrs: :return: """ if attrs["w_category"] == 1 and attrs["publisher_id"] == 1: return attrs else: raise serializers.ValidationError("分类以及标题不符合要求")




2.3.8 ModelSerializer

现在我们已经清楚了Serializer的用法，会发现我们所有的序列化跟我们的模型都紧密相关~那么，DRF也给我们提供了跟模型紧密相关的序列化器~~ModelSerializer~~　　-- 它会根据模型自动生成一组字段　　-- 它简单的默认实现了.update()以及.create()方法2.3.8.1定义一个ModelSerializer序列化器

class BookSerializer(serializers.ModelSerializer): class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段2.3.8.2外键关系的序列化

class BookSerializer(serializers.ModelSerializer): class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 depth = 1# depth 代表找嵌套关系的第几层2.3.8.3自定义字段

我们可以声明一些字段来覆盖默认字段，来进行自定制~比如我们的选择字段，默认显示的是选择的key，我们要给用户展示的是value。

class BookSerializer(serializers.ModelSerializer): chapter = serializers.CharField(source="get_chapter_display", read_only=True) class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 depth = 12.3.8.4meta中其他关键字参数

class BookSerializer(serializers.ModelSerializer): chapter = serializers.CharField(source="get_chapter_display", read_only=True) class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 depth = 1 read_only_fields = ["id"] extra_kwargs = {"title": {"validators": [my_validate,]}}2.3.8.5post以及patch请求

由于depth会让我们外键变成只读，所以我们再定义一个序列化的类，其实只要去掉depth就可以了~~class BookSerializer(serializers.ModelSerializer): chapter = serializers.CharField(source="get_chapter_display", read_only=True) class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 read_only_fields = ["id"] extra_kwargs = {"title": {"validators": [my_validate,]}}2.3.8.6SerializerMethodField

外键关联的对象有很多字段我们是用不到的~都传给前端会有数据冗余~就需要我们自己去定制序列化外键对象的哪些字段~~class BookSerializer(serializers.ModelSerializer): chapter = serializers.CharField(source="get_chapter_display", read_only=True) user = serializers.SerializerMethodField() publisher = serializers.SerializerMethodField() def get_user(self, obj): # obj是当前序列化的book对象 users_query_set = obj.user.all() return [{"id": user_obj.pk, "name": user_obj.name} for user_obj in users_query_set] def get_publisher(self, obj): publisher_obj = obj.publisher return {"id": publisher_obj.pk, "title": publisher_obj.title} class Meta: model = Book fields = "__all__" # fields = ["id", "title", "pub_time"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 read_only_fields = ["id"] extra_kwargs = {"title": {"validators": [my_validate,]}2.3.8.7用ModelSerializer改进上面Serializer的完整版

class BookSerializer(serializers.ModelSerializer): dis_chapter = serializers.SerializerMethodField(read_only=True) users = serializers.SerializerMethodField(read_only=True) publishers = serializers.SerializerMethodField(read_only=True) def get_users(self, obj): # obj是当前序列化的book对象 users_query_set = obj.user.all() return [{"id": user_obj.pk, "name": user_obj.name} for user_obj in users_query_set] def get_publishers(self, obj): publisher_obj = obj.publisher return {"id": publisher_obj.pk, "title": publisher_obj.title} def get_dis_chapter(self, obj): return obj.get_chapter_display() class Meta: model = Book # fields = "__all__" # 字段是有序的 fields = ["id", "title","dis_chapter", "pub_time", "publishers", "users","chapter", "user", "publisher"] # exclude = ["user"] # 分别是所有字段 包含某些字段 排除某些字段 read_only_fields = ["id", "dis_chapter", "users", "publishers"] extra_kwargs = {"title": {"validators": [my_validate,]}, "user": {"write_only": True}, "publisher": {"write_only": True}, "chapter": {"write_only": True}}