标签：serializers 概括 self request book 序列化 data drf

今日内容概要

drf整体内容概括

# 1.入门规范
    -web开发模式
    -api接口
    -接口测试工具
    -restful规范
    -序列化 反序列化
    -drf快速使用
    -APIView，Request类
    -drf把django的好多东西都重写了
    
# 2.序列化组件
    -基本序列化类
    -模型类序列化类
    -如何序列化
    -如何反序列化
    -反序列化的数据校验功能
    
# 3.请求与响应
    -drf的request已经不是原来django的request了
    -指定可以接收请求的编码方式
    -指定响应格式
    
# 4.视图组件
    -两个视图基类
    -五个输入扩展类
    -九个视图子类
    -视图集
  
# 5.路由
    -自动生成路由
   
# 6.三大认证
    -认证(登入认证)，权限，频率
   
# 7.过滤，排序，分页
# 8.自动生成接口文档
-----------------------------------------------------------
# 9.JWT 登入认证的 区别 cookie和session 主流
# 10.后台管理美化(django原生的很丑，simpleui二次开发)
# 11.基于角色的访问控制 权限的控制

APIView执行流程

1.基于APIView+JsonResponse编写接口

# 原来基于jango原生的View编写接口
# drf提供咱们的一个类 以后使用drf写视图类 都是继承这个类及其子类 APIView本身就是继承了Django原生的View

class BookView(APIView):
    def get(self,request):
        books = Boos.objects.all()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
        return JsonResponse(book_list,safe=False)

2.基于APCIView+Response写接口

class BoosView(APIView):
    def get(self, request):
        books = Book.objects.all()
        book_list = []
        for book in books:
			book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
        return Response(book_list)
	"""无论是列表还是字典都可以序列化"""

3.APIView的执行流程

# 路由中写的: path('book/',views.BookView.as_view())
	每当请求来了的时候 执行views.BookView.as_view()()
    """现在的as_view是APIView的as_view"""
 
# APIView的as_view方法: view还是原来的view 但是以后再也没有csrf认证了
	@classmethod
    def as_view(cls,**initwargs):
        # 调用父类的as_view,父类是django原生的View
        # 把django原生View的as_view方法中的闭包函数view拿出来了
        view = super().as_view(**initkwargs)
        # csrf_exempt 排除所有csrf的认证
        # 相当于在所有的方法上面加了这个装饰器
        return csrf_exept(view)
"""
	装饰器的基本：
	def func1():pass
	def func2():pass
	给func2加上装饰器的本质就是：
	@func1	>>>>: 本质就是 func1(func2)
	def func2()
"""
# 路由匹配成功，执行csrf_exempt(view)(requets)--->View的as_view中的闭包函数view--->self.dispatch--->self是视图类的对象--->BookiView--->APIView的dispatch 才能找到
	def dispatch(self, request, *args, **kwargs):
        # request是django原生的request 老的request
        # 把老的request包装成了新的request，这个是drf提供的Request类的对象
        request = self.initialize_request(request, *args,**kwargs)
        # 到此之后 这个request就是新的 request._request这是老的
        
        # 把新的request放到了self对象[此时的self是视图类的对象]
        self.request = request
        try:
            # 执行了三大认证[认证，频率，权限] 使用的是新request
            self.initial(request,*args,**kwargs)
            
            # 和上面一样
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed
            # 把新的request传入 视图类的方法中get的request也是新的
            response = handler(request,*args,**kwargs)
            
		except Exception as exc:
            # 在执行3大认证和视图类方法的过程中 如果出了异常 都能捕获到 ---> 全局异常捕获
            response = self.handle_exception(exc)
		self.response = self.finalize_response(request, response,*args,**kwargs)
        return self.response
    
    
# 总结：APIView的执行流程
    1.去除了所有的csrf
    2.包装了新的request 以后再视图类中用的request是新的request Request类的对象，不是原生的了
    	-原生的再: request._request
    3.在执行视图类的方法发之前 执行了三大认证
    4.如果再三大认证或视图函数方法执行过程中出了错 会有异常捕获
    5.此后使用的视图类中的request都是新的了
    

Resquest对象源码分析

# 新的Request ---> 区别于老的
# 老的：
	django.core.handlers.wsgi.WSGIRequest
# 新的:
	from rest_framework.request import Request
    
# Request源码
	def __getattr__(self,attr):
        try:
            # 从老的request中反射出 要取得属性
            return getattr(self._request,attr)
        except AttributeError:
            return self.__getattribute__(attr)
        
"""
-request.data--->这是个方法，包装成了数据属性
	-以后无论post，put。。放在body中提交的数据，都从request.data中取，取出来就是字典
	-无论是那种编码格式
        
        
-request.query_params--->这是个方法，包装成了数据属性
	-get请求携带的参数，以后从这里面取
	-query_params：查询参数--->restful规范请求地址中带查询参数
        
        
-request.FILES--->这是个方法，包装成了数据属性
	-前端提交过来的文件，从这里取
"""

# Requeest类总结
    1.新的request用起来 和之前一样 因为新的取不到 会取老的__getattr__
    2.request.data 无论什么编码 什么请求方式 只要是body中的数据就从这里取 字典
    3.request.query_params 就是原来的request._request.GET
    4.上传的文件从request.FILIES

序列化器介绍和快速使用

# 因为我们写接口时 需要序列化 需要反序列化 而且反序列化的过程中要做数据校验---> drf直接提供了固定的写法 只要按照固定写法使用 就能完成上面三个需求

# 提供了两个类 Serializer ModelSerializer
	-以后只需要写自己编写的类 继承drf提供的序列化类 使用其中的某些方法 就能完成上面的操作
    
# 使用APIView+序列化类+Response 完成接口的编写

1.序列化类基本使用，序列化多条

serializer.py--BookSerializer类

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段 这里写要序列化的字典
    name = serializers.CharField()
    # serializers下大致和models中的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()
    # 针对不需要序列化的字段直接注释即可

views.py--->BookView类

class BookView(APIView):
    def get(self, request):
        books = book.objects.all()
        # 使用序列化类来完成---> 得要有个序列化类
        # instance要序列化的数据books queryset对象
        # many=True 只要是queryset对象要传many=True，如果是单个对象就不用传
        ser = BookSerializer(instance=books,many=True)
        return Response(ser.data) # 无论是列表还是字典都可以序列化

2.序列化单条

序列化类--没有动

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段 这里写要序列化的字段
    name = serializers.CharField()
    price = serializers.CharField()
    publish = serializers.CharField()
    # 同上不需要序列化的字段可以直接注掉

视图类--> BookDetailView

class BookDetailView(APIView):
    def get(self,request,*args,**kwargs):
        book = Book.objects.filter(pk=kwargs.get('pk')).first()
        # 序列化
        ser = BookSerializer(instance=book)
        return Response(ser.data)

url加了新的路由

urlpatterns = [
    path('boos/<int:pk>/',views.BookDetaiView.as_view()),
]

反序列化

1.序列化的新增

序列化类

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  
    price = serializers.CharField()
    publish = serializers.CharField()
    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据是一个字典的形式
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定要返回新增的对象
        return book

视图类

class BookView(APIView):
    def post(self,request):
        # request.date 前端提交要保存的数据--> 校验数据--> 存
        ser = BookSerializer(data=request.data)
        # 把前端传入的要保存的数据 给data参数
        # 校验数据
        if ser.is_valid():
            #保存 ---> 要在序列化类BookSerializer中写 create方法
            ser.save() # 调用ser.save 自动触发写的create 保存
            return Response({'code':10000,'msg':'新增成功',  'result':ser.data})
        else:
            return Resonse({'code':10001,'msg':ser.errors})

2.反序列化的修改

序列化类

class BookSerializer(serializers.Serializer):
    # 序列化某些字段 这里写要序列化的字典
    name = serializers.CharField()
    price = serializers.CharField()
    publish = serializers.CharField()
    
    def create(self, validated_date):
        # 保存的逻辑
        # validated_data 校验过后的数据
        # 保存到数据库
        book = Book.objects.create(**valideted_data)
        # 一定要返回新增的对象
        return book
    
    def update(self, instance, validated_date):
        # instance 要修改的对象
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()
        # orm的单个对象 修改了单个对象的属性，只要调用对象.save 就能修改保存到数据库
        return instance # 不要忘了把修改后的对象返回

视图类

class BookDatailView(APIView):
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        # 反序列化保存 ---借助于序列化类
        ser = BookSerializer(data=request.data,instance=book)
        if ser.is_valid():
            ser.save() # 由于没有重写update这报错(需先写update)
            return Response({'code':100,'msg':'修改成功', 'result':ser.data})
        else:
            return Response({'code':101,'msg':ser.errors})

3.删除单条

视图类

class BookDetaiView(APIView):
    
    def delete(self, requset, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code':100,'msg':'删除成功'})

反序列化的校验

# 序列化类反序列化 数据校验功能 ---> 类比forms组件
class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要返回新增的对象
        return book

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库

        return instance  # 不要忘了吧修改后的对象，返回

    # 反序列化校验的局部钩子 ，名字不能以sb开头
    def validate_name(self, name):
        # 校验name是否合法
        if name.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb开头')
        else:
            return name

    # 全局钩子
    def validate(self, attrs):
        # 校验过后的数据，书名跟出版社名字不能一致
        if attrs.get('name') == attrs.get('publish'):
            raise ValidationError('书名跟出版社名字不能一致')
        else:
            return attrs

标签：serializers,概括,self,request,book,序列化,data,drf
From： https://www.cnblogs.com/xiaochenxiangchangpang/p/17084188.html