# APIView是drf提供给使用者的一个类,在使用drf写视图类,继承都是这个类及其子类
from django.shortcuts import render
from rest_framework.views import APIView
from .models import Books
from django.http import JsonResponse
class BookView(APIView):
def get(self,request):
books = Books.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)
from rest_framework.response import Response
class BookView(APIView):
def get(self,request):
books = Books.objects.all()
book_list = []
for book in books:
book_list.append({'name':book.name, 'price': book.price, 'publish': book.publish})
return Response(book_list)
# 1.路由中写:
path('books/', views.BookView.as_view()),
现在的as\_view是drf中APIView的as\_view
@classmethod
def as\_view(cls, \*\*initkwargs):
# 调用了父类的as\_view,父类是django原生的View
# 把django原生view的as\_view方法中的闭包函数view拿出来了
view = super().as\_view(\*\*initkwargs)
return csrf\_exempt(view)
def dispatch(self,request,\*args,\*\*kwargs):
# request是django原生的request
# 把原生的request包装成新的request,这个是drf提供的Request类的对象
request = self.initialize\_request(request, \*args, \*\*kwargs)
# 到此,request是新的,request.\_request是老的
# 把新的request放到了self对象\[BookView的对象\]
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
-1.去除了所有的csrf
-2.包装了新的request.以后·再视图类中用的request是新的。而Request类的对象也是新的,原生的Request类对象再新的request._request
-3.在执行视图类的方法之前,执行了3大认证
-4.如果3大认证或视图函数方法执行过程中出了错,会有异常捕获>>>全局异常捕获
-5.以后视图类方法中的request都是新的
def auth() # 装饰器
def add() # 函数
@auth # 本质是 add=auth(add)
def add()
# 老的Request导入:
django.core.handlers.wsgi.WSGIRequest
from rest\_framework.request import Request
-方法 \_\_getattr\_\_
在视图类的方法中,执行request.method,新的request是没有method,所以就会触发新的Request的\_\_getattr\_\_方法的执行
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: 这是个方法,包装成了数据属性
前端提交过来的文件,从这里取
-1.新的request用起来,和之前一样。是因为,新的取不到,会在老的\_\_getattr\_\_取
-2.request.data 无论什么编码。什么请求方式,只要是body中的数据,就从这里取,字典
-3.request.query\_params 就是原来的request.\_request.GET
-4.上传的文件从request.FILES
\_\_str\_\_ :打印对象会调用
\_\_init\_\_:类() 会调用
\_\_call\_\_:对象() 会调用
\_\_getattr\_\_: 对象.属性,如果属性不存在,会触发它的执行
# 1.我们写接口时,需要序列化,也需要反序列化,并且反序列化的过程中需要做数据校验,drf则直接提供多个固定的写法,只要按照drf固定的写法使用,就能完成上面三个需求
我们只需要写自己的类,继承drf提供的序列化类,使用其中的某些方法,就能完成上面的操作
# serializer.py
- BookSerializer类
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段,这里写要序列化的字典
name = serializers.CharField()
publish = serializers.CharField()
- BookView类
class BookView(APIView):
def get(self,request):
print(request.method)
print(request._request)
print(type(self.request))
books = book.objects.all()
# 使用序列化类来完成——>得有个序列化类
# instance要序列化的数据books queryset对象
# many=True 只要是queryset对象,要传many=True, 如果是单个对象就不用传
ser = BookSerializer(instanse=books,many=True)
return Response(ser.data) # 无论是列表还是字典都可以序列化
# 1.序列化类---没有动
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段,这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
# price = serializers.CharField()
publish = serializers.CharField()
class BookDetailView(APIView):
# def get(self, request,pk):
def get(self, request, *args, **kwargs):
book = Book.objects.filter(pk=kwargs.get('pk')).first()
# 序列化
ser = BookSerializer(instance=book)
return Response(ser.data)
urlpatterns = [
path('books/
]
# 序列化类
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
class BookView(APIView):
def post(self, request):
# requset.data # 前端提交的要保存的数据----》校验数据---》存
ser = BookSerializer(data=request.data) # 把前端传入的要保存的数据,给data参数
# 校验数据
if ser.is_valid():
# 保存---->需要自己写,要在序列化类BookSerializer中写----》create方法
ser.save() # 调用ser.save,自动触发咱们写的create,保存起来
return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
else:
return Response({'code': 101, 'msg': ser.errors})
# 序列化类
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 # 不要忘了吧修改后的对象,返回
class BookDetailView(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,所以这报错
return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
else:
return Response({'code': 101, 'msg': ser.errors})
class BookDetailView(APIView):
def delete(self, requset, pk):
Book.objects.filter(pk=pk).delete()
return Response({'code': 100, 'msg': '删除成功'})
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
手机扫一扫
移动阅读更方便
你可能感兴趣的文章