视图组件代码

标签：tor   only   验证   请求方法   demo   port   字段   integer   数据类型   

序列化器代码

# 声明序列化器
from rest_framework import serializers
from djangoDome.models import Book

class 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)


#自定义字段
def my_validate(value):
    if ‘xxoo‘ in value.lower():
        #抛敏感词汇
        raise serializers.ValidationError(‘敏感词汇‘)
    return value


# class BookSerializer(serializers.Serializer):
#     id = serializers.IntegerField(required=False)
#     title = serializers.CharField(max_length=32,)# 自定义的加这个参数 validators=[my_validate,]
#     pub_time = serializers.DateField()
#     category=serializers.CharField(source=‘get_category_display‘,read_only=True) #此处为多选时用
#     #read_only = True 正序查找
#     publisher=PublisherSerializer(read_only=True) #多对一
#     authors=AuthorSerializer(many=True,read_only=True) #多对多用 many=True
#
#     #write_only =True  反序查找  要重新定义
#     post_category = serializers.IntegerField(write_only=True)
#     publisher_id = serializers.IntegerField(write_only=True)
#     author_list = serializers.ListField(write_only=True)
#
#     #重写 create 方法
#     def create(self, validated_data):
#         #validated_data 校验通过的数据 就是book_obj
#         # 通过ORM操作给Book表增加数据
#         book_obj=Book.objects.create(title=validated_data[‘title‘],
#                                      pub_time=validated_data["pub_time"],
#                                      category=validated_data["post_category"],
#                                      publisher_id=validated_data["publisher_id"]
#                                      )
#         book_obj.authors.add(*validated_data[‘author_list‘])
#         return book_obj
#
#     #重写update 方法
#     def update(self, instance, validated_data):
#         # instance 更新的book_obj 对象
#         # validated_data 校验通过的数据
#         # ORM做更新操作 对每个字段进行更新
#         instance.title=validated_data.get(‘title‘,instance.title)
#         instance.pub_time = validated_data.get("pub_time", instance.pub_time)
#         instance.category = validated_data.get("post_category", instance.category)
#         instance.publisher_id = validated_data.get("publisher_id", instance.publisher_id)
#         #此处是对多对多个字段 进行查询
#         if validated_data.get("author_list"):
#             #set 因为是列表多个数据
#             instance.authors.set(validated_data["author_list"])
#         #编辑一定要更新
#         instance.save()
#         return instance
#
#     # 对单个值进行校验
#     def validate_title(self,value):
#         # value就是title的值 对value处理
#         if ‘xxoo‘ not in value.lower():
#             raise serializers.ValidationError(‘少东西了‘)
#         return value
#
#     #对所有字段进行 校验
#     def validate(self, attrs):
#         # attrs 字典有你传过来的所有的字段
#         if ‘xxoo‘ in attrs[‘title‘].lower() and attrs["post_category"] == 1:
#             return attrs
#         else:
#             raise serializers.ValidationError(‘分类或标题不合符要求‘)


class BookSerializer(serializers.ModelSerializer):

    #对多选字段,一对多,多对多字段 进行重新定义  此处为序列化的时候显示
    category_display=serializers.SerializerMethodField(read_only=True)
    publisher_info=serializers.SerializerMethodField(read_only=True)
    authors_info=serializers.SerializerMethodField(read_only=True)
    #多选查找  obj 就是序列化的每个Book对象
    def get_category_display(self,obj):
        return obj.get_category_display()

     #一对多查找
    def get_publisher_info(self,obj):
        #找到查找外键的对象
        publisher_obj=obj.publisher
        #返回publisher表的内容
        return {‘id‘:publisher_obj.id,‘title‘:publisher_obj.title}

    #多对多的查找
    def  get_authors_info(self,obj):
        #找到所有的对象
        authors_obj=obj.authors.all()
        # 返回authors表的内容 推到式
        return [{"id":i.id,‘name‘:i.name}for i in authors_obj]

    class Meta:
        model=Book
        fields=‘__all__‘
        # exclude=["id"]
        # 会让你这些所有的外键关系变成read_only = True 最多4层 不建议用
        # depth = 1

        #相当于extra_kwargs={"默认的字段名称"：{自定义的参数配置信息}}
        #用在反序列化 给表字段添加参数
        extra_kwargs={‘publisher‘:{‘write_only‘:True},
                      "authors": {"write_only": True}}

视图封装代码

from django.shortcuts import render

from rest_framework.views import APIView #视图
from djangoDome.models import Book
from rest_framework.response import Response #相等于django的render等
from SerDemo.serializers import BookSerializer
from rest_framework.viewsets import ViewSetMixin #重做as_view(),可以传参,第三次封装
from rest_framework import viewsets



# 封装为公共的类 都能用
class GenericAPIView(APIView):
    # 此处为面向对象的设置静态变量一样 默认为空对其进行操作
    queryset = None  # 查到表的对象
    serializer_class = None  # 序列器

    #定义方法 来取值
    def get_queryset(self):
        return self.queryset.all()#此处用all()为数据在缓存中,显示全部数据

    def get_serializer(self,*args,**kwargs): #用*接收 意思为有不同的方法
        return self.serializer_class(*args,**kwargs)

#封装所有的 get 请求方法
class ListModelMixin(object):
    def list(self,request):
        queryset=self.get_queryset() #取到所有的值 
        ser_obj=self.get_serializer(queryset,many=True)#用序列化器进行序列化
        return Response(ser_obj.data)


# 封装所有的 post 请求方法
class CreateModelMixin(object):
    def create(self,request):#request.data 是去到前端返回的值
        ser_obj=self.get_serializer(data=request.data)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)
        
# 封装所有的 get  请求方法(获取一条数据)
class RetrieveModelMixin(object):
    def retrieve(self,request,id):
        book_obj=self.get_queryset().filter(id=id).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)
    
# 封装所有的 put请求方法(获取一条数据)
class UpdateModelMixin(object):
    def update(self,request,id):
        book_obj=self.get_queryset().filter(id=id).first()
        ser_obj = self.get_serializer(instance=book_obj, data=request.data, partial=True)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)

#封装删除 delete 的请求方法
class DestroyModelMixin(object):
    def destroy(self,request,id):
        book_obj = self.get_queryset().filter(id=id).first()
        if not book_obj:
            return Response("删除的对象不存在")
        book_obj.delete()
        return Response("")

#第二次封装  ()
class ListCreateAPIView(GenericAPIView, ListModelMixin, CreateModelMixin):
    pass

class RetrieveUpdateDestroyAPIView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    pass


#此处为第二次封装的操作
class BookView(ListCreateAPIView):
    queryset=Book.objects.all()
    serializer_class=BookSerializer
    
    def get(self,request):
        return self.list(request)
    
    def post(self,request):
        return  self.create(request)
        

class BookEditView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self,request,id):
        return self.retrieve(request,id)
    
    def put(self,request,id):
        return self.update(request,id)
    
    def delete(self,request,id):
        return self.destory(request,id)



# 第三次封装 需要之前定义的 请求类
class ModelViewSet(ViewSetMixin,ListCreateAPIView,RetrieveUpdateDestroyAPIView):
    pass

#此处为第三次封装的操作 (自己定义的方法)
class BookModelView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

#此处为第三次封装的操作 (django定义的方法)
class BokModelView(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer


#最原始的操作
# class BookView(APIView):
#     #查看所有数据
#     def get(self,request):
#         book_obj=Book.objects.all()#
#         # [book_obj, ]获取所有数据
#         # 用序列化器进行序列化
#         ser_obj= BookSerializer(book_obj,many=True)#many=True 显示 多条数据 单条数据不用
#         return  Response(ser_obj.data)
# 
#     #新增数据
#     def post(self,request):
#         #先确定数据结构及数据类型
#         #对前端传来的数据进行校验
#         book_obj=request.data
#         ser_obj=BookSerializer(data=book_obj) #data 使用来进行反序的
#         #对虚拟器反序的数据做判断
#         if ser_obj.is_valid():
#             ser_obj.save()
#             #ser_obj.validated_data  为验证通过
#             return  Response(ser_obj.validated_data)
#         #验证不通过 抛异常
#         return  Response(ser_obj.errors)
# 
# 
# class BookEditView(APIView):
#     #获取单条id
#     def get(self,request,id):
#         book_obj=Book.objects.filter(id=id).first()
#         ser_obj=BookSerializer(book_obj)
#         return  Response(ser_obj.data)
# 
#     #更新单挑数据 用put
#     def put(self,request,id):
#         book_obj=Book.objects.filter(id=id).first()
#         #instance=  data= 是反序所用的方法  partial=True 为部分校验,识别更新的
#         ser_obj=BookSerializer(instance=book_obj,data=request.data,
#                                partial=True
#                                )
#         # 对虚拟器反序的数据做判断
#         if ser_obj.is_valid():
#             ser_obj.save()
#             return Response(ser_obj.validated_data)
#         return Response(ser_obj.error)
# 
#     #删除数据
#     def delete(self,request,id):
#         book_obj=Book.objects.filter(id=id).first()
#         if not book_obj:
#             return Response(‘删除的对象不存在‘)
#         book_obj.delete()
#         return Response(‘‘)


url路由

from django.conf.urls import url
from djangoDome import views
from SerDemo import views

from rest_framework.routers import DefaultRouter # 帮助我们生成带参数的路由
router=DefaultRouter() #实例化DsfaultRouter
router.register(‘^book‘,views.BokModelView) # 注册我们的路由以及视图




urlpatterns = [

url(r‘^book/$‘, views.BookView.as_view()),
url(r‘^book/(?P<id>\d+)/$‘, views.BookEditView.as_view()),
    
url(r‘^book/$‘, views.BookModelView.as_view({"get": "list", "post": "create"})),
url(r‘^book/(?P<id>\d+)/$‘, views.BookModelView.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),

django 自己封装的方法 用pk
url(r‘^book/$‘, views.BokModelView.as_view({"get": "list", "post": "create"})),
url(r‘^book/(?P<pk>\d+)/$‘, views.BokModelView.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),
]


urlpatterns += router.urls

视图组件代码

标签：tor   only   验证   请求方法   demo   port   字段   integer   数据类型   

原文地址：https://www.cnblogs.com/xdlzs/p/9971791.html