pip install djangorestframework

class BookSerializer(serializers.Serializer):
    """图书数据序列化器"""
    id = serializers.IntegerField( read_only=True)
    title = serializers.CharField( max_length=20)

serializer.data

serializer = BookSerializer(books, many=True)
serializer.data

heroes = HeroInfoSerializer(many=True)  # 根据指定的HeroSerialzier序列化中指定的字段返回

class BookView(View):
    # 更新操作
    def put(self, request, pk):
        data = json.loads(request.body.decode())
        try:
            # 从模型取数据
            book = BookInfo.objects.get(pk=pk)
        except Exception:
            return JsonResponse({'errors': '未找到该书'})
        
        ser = BookInfoSerializer(book, data=data)
        ser.is_valid(raise_exception=True)

class BookSerializer(serializers.Serializer):
    def validated_title(self, value):
        if value == 'python':
            raise serializers.ValidationError('书名python错误')
        return value

class BookSerializer(serializers.Serializer):
    ...     
    def validate(self, attrs):
        bread = attrs['bread']
        bcomment = attrs['bcomment']
        if bread < bcomment:
            raise serializers.ValidationError('阅读量小于评论量')
        return attrs

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = '__all__' # 返回所有字段

model 指明参照哪个模型类
fields 指明为模型类的哪些字段生成

>>> from booktest.serializers import BookSerializer # 导入
>>> serializer = BookSerializer() # 序列化
>>> serializer
BookSerializer():
    id = IntegerField(label='ID', read_only=True)

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo # 指定根据哪个模型类来序列化
        fields = ('id', 'btitle', 'bpub_date')

class HeroInfoSerializer(serializers.ModelSerializer):
    hbook = BookInfoSerializer()
    class Meta:
        model = HeroInfo
        fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
        extra_kwargs = {
            'bread': {'min_value': 0, 'required': True},
            'bcomment': {'min_value': 0, 'required': True},
        }

from .models import *
from .serializer import *

from rest_framework.decorators import api_view
from rest_framework.response import Response # Response
from rest_framework import status # status


@api_view(http_method_names=['get','post'])
def index(request):
    '''
    展示所有图书
    :param request:
    :return:
    '''
    if request.method == 'GET':
        serializer = BookSerializer(Book.objects.all(), many=True)
        return Response(serializer.data)
    if request.method == 'POST':
        serializer = BookSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            # 自定义状态码
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)

rest_framework.views.APIView

from rest_framework.views import APIView
from rest_framework.response import Response

# url(r'^books/$', views.BookListView.as_view()),
class BookListView(APIView):
    def get(self, request):
        books = BookInfo.objects.all()
        serializer = BookInfoSerializer(books, many=True)
        return Response(serializer.data)

def get_queryset(self):
    user = self.request.user
    return user.accounts.all()

def get_serializer_class(self):
    if self.request.user.is_staff:
        return FullAccountSerializer
    return BasicAccountSerializer

from rest_framework.generics import  GenericAPIView

class BooksView(GenericAPIView):
    queryset = BookInfo.objects.all() #指定查询集
    serializer_class = BookInfoSerializer # 指定序列化器

    def get(self, request):
        '''查询所有图书'''
        books = self.get_queryset() 获取查询集
        # book = self.get_object() 获取单一数据对象
        serializer = self.get_serializer(books, many = True) #获取序列化器
        return Response(serializer.data)
    
      def post(self, request):
        """
         保存图书
        """
        # 1、获取前端数据
        data = request.data
        # 2、验证数据
        ser = self.get_serializer(data=data)
        ser.is_valid(raise_exception=True)
        # 3、保存数据
        ser.save()
        # 4、返回结果
        return Response(ser.data)

from rest_framework import mixins
from rest_framework import generics

class BookView(
    generics.GenericAPIView,
    mixins.ListModelMixin, # 列表视图扩展类
    mixins.RetrieveModelMixin, # 详情视图扩展类
    mixins.CreateModelMixin, # 创建视图扩展类
    mixins.UpdateModelMixin, # 更新视图扩展类
    mixins.DestroyModelMixin # 删除视图扩展类
):
    '''
        图书控制层
        列表 /book
        新增 /book/
        详情 /book/pk/
        修改 /book/pk
        删除 /book/pk
    '''
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    def get(self, request, pk=None):
        if pk:
            return self.retrieve(request)
        else:
            return self.list(request)
    def post(self, request):
        return self.create(request)
    def put(self, request, pk=None):
        return self.update(request)
    def delete(self, request):
        return self.delete(request)

from rest_framework.mixins import ListModelMixin

class BooksView(ListModelMixin, GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request):
        return self.list(request)

from rest_framework.mixins import CreateModelMixin

class BooksView(CreateModelMixin, GenericAPIView):    
    serializer_class = BookInfoSerializer

    def post(self, request):
        return self.create(request)

class BooksView(RetrieveModelMixin, GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request, pk):
        return self.retrieve(request)

from rest_framework import generics

class BookView(
    generics.CreateAPIView,
    generics.UpdateAPIView,
    generics.DestroyAPIView,
    generics.RetrieveAPIView
):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

class BookInfoViewSet(viewsets.ViewSet):
    # 展示所有
    def list(self, request):
        ...
    # 展示单个
    def retrieve(self, request, pk=None):
        ...

urlpatterns = [
    url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),
    url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
]

def get_serializer_class(self):
    if self.action == 'create':
        return OrderCommitSerializer
    else:
        return OrderDataSerializera

#  路由层
url(r'^books/$', view_set.BooksModelViewSet.as_view({'get': 'list', 'post': 'create'})),
url(r'^books/(?P<pk>\d+)/$', view_set.BooksModelViewSet.as_view({'get': 'retrieve','put':'update','delete':'destroy'})),

from rest_framework import viewsets

class UserViewSet(viewsets.ReadOnlyModelViewSet):
    """
    只读API
    """
    queryset = User.objects.all()
    serializer_class = UserSerializer

from rest_framework import routers
from django.conf.urls import include,url


# 创造和定义路由地址 
route = routers.DefaultRouter()

# 注册路由地址
route.register("book", views.BookView)
route.register('tag',views.TagView)

urlpatterns = [
]+route.urls

1） 创建router对象，并注册视图集
from rest_framework import routers

router = routers.SimpleRouter()
router.register(r'books', BookInfoViewSet, base_name='book')
##############################
register(prefix, viewset, base_name)
- prefix 该视图集的路由前缀
- viewset 视图集
- base_name 路由名称的前缀

# 上述代码会形成的路由如下
^books/$    name: book-list
^books/{pk}/$   name: book-detail

2）添加路由数据
urlpatterns = [    ...]
urlpatterns += router.urls
# 或者
urlpatterns = [    ...,    url(r'^', include(router.urls))] 

...
from rest_framework.decorators import action

class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    @action(methods=['get'], detail=False) #detail = False不生成正则匹配
    def latest(self, request, pk):
        ...

    @action(methods=['put'], detail=True)#detail = True生成正则匹配
    def read(self, request, pk):
        ...

from rest_framework.authentication import BaseAuthentication
from rest_framework.authentication import SessionAuthentication
from rest_framework.authentication import TokenAuthentication
from rest_framework.authentication import RemoteUserAuthentication
from rest_framework.authentication import BasicAuthentication

from .models import *
from .serializer import *

from rest_framework.views import APIView
from rest_framework import viewsets

from rest_framework.authentication import BasicAuthentication
from rest_framework.permissions import IsAuthenticated
class BookView(viewsets .ModelViewSet):
    '''
        图书控制层
    '''
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    
    # 类属性
    # 验证用户是否已经成功登录
    authentication_classes = [BasicAuthentication]
    # 验证用户的权限来限制访问
    permission_classes = [IsAuthenticated]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',   # 基本表单认证
        'rest_framework.authentication.SessionAuthentication',  # session认证
    )
}

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    ...

from rest_framework.permissions import IsAuthenticated

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated', # 授权访问
    )
}

'DEFAULT_PERMISSION_CLASSES': (
   'rest_framework.permissions.AllowAny', 
)

from rest_framework.permissions import IsAuthenticated
from rest_framework.viewsets import ModelViewSet

BooksModelViewSet(ModelViewSet):
    permission_classes = (IsAuthenticated,) #登录授权用户
    ...

from rest_framework.authentication import SessionAuthentication # Session 认证
from rest_framework.permissions import IsAuthenticated # 权限
from rest_framework.generics import RetrieveAPIView

class BookListView(RetrieveAPIView):
    queryset = BookInfo.objects.all() # 查询
    serializer_class = BookInfoSerializer # 序列化
    authentication_classes = [SessionAuthentication]
    permission_classes = [IsAuthenticated]

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle'
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '4/day', # 匿名用户每天访问4次
        'user': '100/day'  # 登录用户访问100次
    }
}

from rest_framework.throttling import UserRateThrottle
from rest_framework.views import APIView # 视图

class BookListView(APIView):    
    throttle_classes = (UserRateThrottle,)
    ...

class AdminRateThrottle(UserRateThrottle):
 scope = 'admin'

'DEFAULT_THROTTLE_RATES':{
 'normal': '60/day',
 'admin': '1000/day'
}

class ConListView(APIView):
 throttle_scope =  'uploads'
 ...

from rest_framework.authentication import SessionAuthentication # Session认证
from rest_framework.permissions import IsAuthenticated # 权限
from rest_framework.generics import RetrieveAPIView # 视图
from rest_framework.throttling import UserRateThrottle # 限速

class BooksView(RetrieveAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    authentication_classes = [SessionAuthentication]
    permission_classes = [IsAuthenticated]
    throttle_classes = (UserRateThrottle,) 
    
...
REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.ScopedRateThrottle',
    ),
    'DEFAULT_THROTTLE_RATES': {
        'contacts': '1000/day',
        'uploads': '20/day'
    }
}

pip install django-filter 

> 2.2.0

INSTALLED_APPS = [
    ...
    'django_filters',  # 需要注册应用，
]

REST_FRAMEWORK = {
    ...
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}

from django_filters.rest_framework import DjangoFilterBackend


class BookView(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    filter_backends = [DjangoFilterBackend]
    filter_fields = ('id',)

http://127.0.0.1:8888/book/?id=3

from rest_framework.filters import OrderingFilter

class StudentListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    
    filter_backends = [OrderingFilter]
    #ordering_fields = ('id', 'age')
    ordering_fields = '__all__'
    

# 127.0.0.1:8000/books/?ordering=-id
# -id 表示针对id字段进行倒序排序
# id  表示针对id字段进行升序排序

# 如果有ordering_fields
    # url输入的是该字段，就按该字段排序（ordering_fields必须是可以参与order_by()的字段，否则会报错）否则不排序
    
# 如果ordering_fields = '__all__':
    # 1. 如 url:/ordering = -sdfsfd，则 ordering = None，不排序
    # 2. 如 url:/ordering = -price, 则 ordering = -price，按-price排序
    
# 如果没有指定ordering_fields,
    # 1. 不参与序列化，如：sdsadf。则 ordering = None，不排序
    # 2. 参与序列化且是表字段，如：price，则 ordering = price, 按price排序，
    # 3. 参与序列化不是表字段，如：brand_name, 则 ordering = brand_name,报错（order_by(brand_name)出错

from rest_framework.generics import ListAPIView
from students.models import Student
from .serializers import StudentModelSerializer
from django_filters.rest_framework import DjangoFilterBackend

class Student3ListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    
    filter_fields = ('age', 'sex')
    
    # 因为局部配置会覆盖全局配置,所以需要重新把过滤组件核心类再次声明,
    # 否则过滤功能会失效
    filter_backends = [OrderingFilter,DjangoFilterBackend]
    ordering_fields = ('id', 'age')

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100  # 每页数目
}

from rest_framework.pagination import PageNumberPagination  #分页


class LargeResultsSetPagination(PageNumberPagination):
    """
        配置分页规则
    """
    page_size = 5 # 每页数目
    page_size_query_param = 'page_size' # 前端发送的页数关键字名，默认为"page"
    page_query_param = 'page' # 前端发送的每页数目关键字名，默认为None
    max_page_size = 10000 # 前端最多能设置的每页数量
    
class BookDetailView(RetrieveAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    
    pagination_class = LargeResultsSetPagination # 应用到视图函数中

pagination_class = None

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination'
}

from rest_framework.pagination import LimitOffsetPagination

class BookListView(ListAPIView):
    queryset = BookInfo.objects.all().order_by('id')
    serializer_class = BookInfoSerializer
    pagination_class = LimitOffsetPagination

# 127.0.0.1:8000/books/?offset=3&limit=2

from rest_framework.views import exception_handler

def custom_exception_handler(exc, context):
    # 先调用REST framework默认的异常处理方法获得标准错误响应对象
    response = exception_handler(exc, context)

    # 在此处补充自定义的异常处理
    if response is not None:
        response.data['status_code'] = response.status_code

    return response

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler'#定义处理异常的路径，以项目实际为准
}

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler' 
}