模型类的定义
# 定义图书模型类BookInfo
class BookInfo(models.Model):
btitle = models.CharField(max_length=20, verbose_name='名称')
bpub_date = models.DateField(verbose_name='发布日期')
bread = models.IntegerField(default=0, verbose_name='阅读量')
bcomment = models.IntegerField(default=0, verbose_name='评论量')
is_delete = models.BooleanField(default=False, verbose_name='逻辑删除') class Meta:
db_table = 'tb_books' # 指明数据库表名
verbose_name = '图书' # 在admin站点中显示的名称
verbose_name_plural = verbose_name # 显示的复数名称 def __str__(self):
"""定义每个数据对象的显示信息"""
return self.btitle
定义一个序列化器
from rest_framework import serializers # 引入类 class BookInfoSerializer(serializers.Serializer):
""" 图书列表序列化器"""
id = serializers.IntegerField(label="ID", read_only=True)
btitle = serializers.CharField(label="名称", max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
is_delete = serializers.BooleanField(label='逻辑删除', required=False)
heroinfo_set = serializers.PrimaryKeyRelatedField(read_only=True, many=True) # 新增 def create(self, validated_data):
"""新建"""
return BookInfo.objects.create(**validated_data) def update(self, instance, validated_data):
"""更新，instance为要更新的对象实例"""
instance.btitle = validated_data.get('btitle', instance.btitle)
instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
instance.bread = validated_data.get('bread', instance.bread)
instance.bcomment = validated_data.get('bcomment', instance.bcomment)
instance.save()
return instance
django本身的View类来构建一个RESTful风格的API接口的开发；
import json
from django.forms import model_to_dict
from django.http import JsonResponse
from django.shortcuts import HttpResponse
from django.views import View
from rest_framework.viewsets import ModelViewSet from .models import BookInfo class BooksAPIView(View):
def get(self, request):
"""
查询所有图书
:param request:
:return:
"""
queryset = BookInfo.objects.all().values()
book_list = []
book_list = list(queryset) return JsonResponse(book_list, safe=False) def post(self, request):
"""
新增图书
:param request:
:return:
"""
json_bytes = request.body
json_str = json_bytes.decode()
book_dict = json.loads(json_str)
book = BookInfo.objects.create(
**book_dict
) return JsonResponse({
"id": book.id,
"btitle": book.btitle,
'bpub_date': book.bpub_date,
'bread': book.bread,
'bcomment': book.bcomment,
}, status=201) class BookAPIView(View):
"""
获取单个图书的信息
""" def get(self, request, pk):
try:
book = BookInfo.objects.get(id=pk)
except Exception as e:
print(e)
return HttpResponse(status=404) book_dict = model_to_dict(book)
return JsonResponse(book_dict) def put(self, request, pk):
"""
修改图书信息
:param request:
:param pk:
:return:
"""
try:
book = BookInfo.objects.get(id=pk)
except Exception as e:
print(e)
return HttpResponse(status=404) # 校验参数 json_bytes = request.body
json_str = json_bytes.decode()
book_dict = json.loads(json_str) BookInfo.objects.filter(id=pk).update(**book_dict)
book_dict = model_to_dict(BookInfo.objects.get(id=pk))
return JsonResponse(book_dict) def delete(self, request, pk):
"""
删除
:param request:
:param pk:
:return:
"""
try:
book = BookInfo.objects.get(id=pk)
except Exception as e:
print(e)
return HttpResponse(status=404) book.delete()
return HttpResponse(status=204) """
urlpatterns = [
url(r'^books/$', views.BooksAPIView.as_view()),
url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
]
"""
通过（from rest_framework.views import APIView）中的APIView类构建一个RESTful风格的API接口的开发；
from .models import BookInfo from .serializers import BookInfoSerializer
from rest_framework.views import APIView
from rest_framework.response import Response class BooksAPIView(APIView):
"""
与django中的view相比
""" def get(self, request):
# 数据库中取数据；
books = BookInfo.objects.all()
# 序列化器的使用；
serializer = BookInfoSerializer(books, many=True)
# 返回数据
return Response(serializer.data) """
from app001 import views
urlpatterns = [
url(r'^books/$', views.BooksAPIView.as_view()),
]
""" """
此时继承的APIView与django中的view比较；
1,传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象；
2,视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式；
3,任何APIException异常都会被捕获到，并且处理成合适的响应信息；
4,在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。
"""
通过APIView的子类GenericAPIView子类构建一个RESTful风格的API接口的开发；
from .models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework.response import Response
from rest_framework.generics import GenericAPIView class BooksAPIView(GenericAPIView):
"""
与restframework中的APIView相比
"""
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer def get(self, request):
# 数据库中取数据；
qs = self.get_queryset()
# 序列化器的使用；
serializer = self.get_serializer(qs, many=True)
# 返回数据
return Response(serializer.data) class BookDetailView(GenericAPIView):
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer def get(self, request, pk):
# 数据库中取数据；
qs = self.get_object()
# 序列化器的使用；
serializer = self.get_serializer(qs)
# 返回数据
return Response(serializer.data) """
from app001 import views
urlpatterns = [
url(r'^books/$', views.BooksAPIView.as_view()),
url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
]
""" """
获取多个对象时候使用的方法（ qs = self.get_queryset()）
1，在这个视图中需要自己传入要返回的queryset对象；
2，要传来做序列化的类；
3，在定义的具体方法中来使用self.get_queryset()来获取类中的对象；
4，获取序列化的类然后处理数据；
5，将处理后的类返回到接口中； 获取单个对象使用的方法（qs = self.get_object()）
步骤类似 总结：
在GenericAPIView的类中继承需要自己指定模型类；
自己指定方法的映射关系；
自己取对象；
自己取序列化的类；
自己返回数据
"""
（from rest_framework.generics import GenericAPIView）（from rest_framework import mixins）通过这两个子类构建一个RESTful风格的API接口的开发；
from .models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework.generics import GenericAPIView
from rest_framework import mixins class BooksAPIView(mixins.ListModelMixin, GenericAPIView):
"""
与restframework中的APIView相比
"""
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer def get(self, request):
return self.list(request) class BookDetailView(mixins.RetrieveModelMixin, GenericAPIView):
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer def get(self, request, pk):
return self.retrieve(request) """
from app001 import views
urlpatterns = [
url(r'^books/$', views.BooksAPIView.as_view()),
url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
]
""" """
总结：
在mixins.RetrieveModelMixin与GenericAPIView相比较；
1，封装(self.get_queryset()的方法；
2，封装了self.paginate_queryset()的方法；
3，封装了serializer = self.get_serializer(queryset, many=True)的方法；
4，将序列化后的结果返回；
"""
（from rest_framework.generics import ListAPIView）类构建一个RESTful风格的API接口的开发；
from .models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework.generics import ListAPIView class BooksAPIView(ListAPIView):
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer from rest_framework.generics import RetrieveAPIView class BookDetailView(RetrieveAPIView):
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer """
from app001 import views
urlpatterns = [
url(r'^books/$', views.BooksAPIView.as_view()),
url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
]
""" """
总结：
from rest_framework.generics import GenericAPIView
from rest_framework import mixins
等价与
from rest_framework.generics import ListAPIView 调用方式；
在get的方法中指明要调用的类中的封装的方法；
"""
（from rest_framework.viewsets import GenericViewSet）类构建一个RESTful风格的API接口的开发；
from .models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework import mixins
from rest_framework.viewsets import GenericViewSet class BooksAPIViewSet(mixins.ListModelMixin,mixins.RetrieveModelMixin,GenericViewSet):
"""
mixins.ListModelMixin:实现了list的函数；
GenericViewSet(ViewSetMixin, generics.GenericAPIView):
ViewSetMixin 重写了as_view的方法（在url中将请求方式和action对应 queryset,serializer_class两个参数）；
GenericAPIView(views.APIView) 实现了get_queryset()和get_object的方法:
"""
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer """
url的访问形式
urlpatterns = [
url(r'^books/$', views.BooksAPIViewSet.as_view({"get": "list"})),
url(r'^books/(?P<pk>\d+)/$', views.BooksAPIViewSet.as_view({"get": "retrieve"})),
]
""" """
总结：
from rest_framework.generics import GenericAPIView
from rest_framework import mixins
等价与
from rest_framework.generics import ListAPIView
"""
action自定义方法扩张类构建一个RESTful风格的API接口的开发；
from .models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action
from rest_framework.response import Response class BookInfoViewSet(ModelViewSet):
# 取出queryset对象
queryset = BookInfo.objects.all()
# 定义一个序列化器的类
serializer_class = BookInfoSerializer # detail为False 表示不需要处理具体的BookInfo对象
@action(methods=['get'], detail=False)
def latest(self, request):
"""
返回最新的图书信息
"""
book = BookInfo.objects.latest('id')
serializer = self.get_serializer(book)
return Response(serializer.data) # detail为True，表示要处理具体与pk主键对应的BookInfo对象
@action(methods=['put'], detail=True)
def read(self, request, pk):
"""
修改图书的阅读量数据
"""
book = self.get_object()
book.bread = request.data.get('read')
book.save()
serializer = self.get_serializer(book)
return Response(serializer.data) """
url的访问形式
urlpatterns = [
url(r'^books/$', views.BookInfoViewSet.as_view({'get': 'list'})),
url(r'^books/latest/$', views.BookInfoViewSet.as_view({'get': 'latest'})),
url(r'^books/(?P<pk>\d+)/$', views.BookInfoViewSet.as_view({'get': 'retrieve'})),
url(r'^books/(?P<pk>\d+)/read/$', views.BookInfoViewSet.as_view({'put': 'read'})),
]
""" """
总结：
1） ViewSet
继承自APIView，作用也与APIView基本类似，提供了身份认证、权限校验、流量管理等。 在ViewSet中，没有提供任何动作action方法，需要我们自己实现action方法。 2）GenericViewSet
继承自GenericAPIView，作用也与GenericAPIVIew类似，提供了get_object、get_queryset等方法便于列表视图与详情信息视图的开发。 3）ModelViewSet
继承自GenericAPIVIew，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。 4）ReadOnlyModelViewSet
继承自GenericAPIVIew，同时包括了ListModelMixin、RetrieveModelMixin。
"""