Django REST_framework 视图类

DRF框架视图类: rest_framework.mixins

from rest_framework.generics import GenericAPIView

提供了mixin类所需要的数据

必须传入queryset(查询的query对象)与serializer_class(序列化的类)

class GenericAPIView(views.APIView):
    """
    Base class for all other generic views.
    """
    # You'll need to either set these attributes,
    # or override `get_queryset()`/`get_serializer_class()`.
    # If you are overriding a view method, it is important that you call
    # `get_queryset()` instead of accessing the `queryset` property directly,
    # as `queryset` will get evaluated only once, and those results are cached
    # for all subsequent requests.
    queryset = None
    serializer_class = None

    # If you want to use object lookups other than pk, set 'lookup_field'.
    # For more complex lookup requirements override `get_object()`.
    lookup_field = 'pk'
    lookup_url_kwarg = None

    # The filter backend classes to use for queryset filtering
    filter_backends = api_settings.DEFAULT_FILTER_BACKENDS

    # The style to use for queryset pagination.
    pagination_class = api_settings.DEFAULT_PAGINATION_CLASS

    # 返回查询的所有数据
    def get_queryset(self):
        """
        Get the list of items for this view.
        This must be an iterable, and may be a queryset.
        Defaults to using `self.queryset`.

        This method should always be used rather than accessing `self.queryset`
        directly, as `self.queryset` gets evaluated only once, and those results
        are cached for all subsequent requests.

        You may want to override this if you need to provide different
        querysets depending on the incoming request.

        (Eg. return a list of items that is specific to the user)
        """
        assert self.queryset is not None, (
            "'%s' should either include a `queryset` attribute, "
            "or override the `get_queryset()` method."
            % self.__class__.__name__
        )

        queryset = self.queryset
        if isinstance(queryset, QuerySet):
            # Ensure queryset is re-evaluated on each request.
            queryset = queryset.all()
        return queryset

    def get_object(self):
        """
        Returns the object the view is displaying.

        You may want to override this if you need to provide non-standard
        queryset lookups.  Eg if objects are referenced using multiple
        keyword arguments in the url conf.
        """
        queryset = self.filter_queryset(self.get_queryset())

        # Perform the lookup filtering.
        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field

        assert lookup_url_kwarg in self.kwargs, (
            'Expected view %s to be called with a URL keyword argument '
            'named "%s". Fix your URL conf, or set the `.lookup_field` '
            'attribute on the view correctly.' %
            (self.__class__.__name__, lookup_url_kwarg)
        )

        filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
        obj = get_object_or_404(queryset, **filter_kwargs)

        # May raise a permission denied
        self.check_object_permissions(self.request, obj)

        return obj

    def get_serializer(self, *args, **kwargs):
        """
        Return the serializer instance that should be used for validating and
        deserializing input, and for serializing output.
        """
        serializer_class = self.get_serializer_class()
        kwargs['context'] = self.get_serializer_context()
        return serializer_class(*args, **kwargs)

    def get_serializer_class(self):
        """
        Return the class to use for the serializer.
        Defaults to using `self.serializer_class`.

        You may want to override this if you need to provide different
        serializations depending on the incoming request.

        (Eg. admins get full serialization, others get basic serialization)
        """
        assert self.serializer_class is not None, (
            "'%s' should either include a `serializer_class` attribute, "
            "or override the `get_serializer_class()` method."
            % self.__class__.__name__
        )

        return self.serializer_class

    def get_serializer_context(self):
        """
        Extra context provided to the serializer class.
        """
        return {
            'request': self.request,
            'format': self.format_kwarg,
            'view': self
        }

    def filter_queryset(self, queryset):
        """
        Given a queryset, filter it with whichever filter backend is in use.

        You are unlikely to want to override this method, although you may need
        to call it either from a list view, or from a custom `get_object`
        method if you want to apply the configured filtering backend to the
        default queryset.
        """
        for backend in list(self.filter_backends):
            queryset = backend().filter_queryset(self.request, queryset, self)
        return queryset

    @property
    def paginator(self):
        """
        The paginator instance associated with the view, or `None`.
        """
        if not hasattr(self, '_paginator'):
            if self.pagination_class is None:
                self._paginator = None
            else:
                self._paginator = self.pagination_class()
        return self._paginator

    def paginate_queryset(self, queryset):
        """
        Return a single page of results, or `None` if pagination is disabled.
        """
        if self.paginator is None:
            return None
        return self.paginator.paginate_queryset(queryset, self.request, view=self)

    def get_paginated_response(self, data):
        """
        Return a paginated style `Response` object for the given output data.
        """
        assert self.paginator is not None
        return self.paginator.get_paginated_response(data)

 

Mixin类中类的查询顺序

Mixin中没有, 去自己定义的找, 自己的没有去GenericAPIView

post对应CreateModelMixin

class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        # self.get_serializer序列化的类
        serializer = self.get_serializer(data=request.data)
        # 序列化的校验
        serializer.is_valid(raise_exception=True)
        # save将数据保存
        self.perform_create(serializer)
        # 返回的错误
        headers = self.get_success_headers(serializer.data)
        # 返回序列化的数据, 状态码
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

 

from rest_framework.mixin import CreateModelMixin

class Publish(CreateModelMixin):
　　queryset = Publish.objects.all()
　　serializer_class = PublishSerializers
　　def post(self, request, *ags, **kwargs):
　　　　return self.create(request, *args, **kwargs)

 

get对应ListModelMixin与RetrieveModelMixin

class ListModelMixin:
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        # 过滤相关
        queryset = self.filter_queryset(self.get_queryset())

        # 分页相关
        page = self.paginate_queryset(queryset)
        if page is not None:
            # 将过滤的数据分页, 再进行序列化
            serializer = self.get_serializer(page, many=True)
            # 返回序列化的数据
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

class RetrieveModelMixin:
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        # 返回单条序列化的数据
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

 

from rest_framework.mixin import ListModelMixin

class Publish(ListModelMixin):
    queryset = Publish.objects.all()
    serializer_class = PublishSerializers
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

from rest_framework.mixin import RetrieveModelMixin

class Publish(RetrieveModelMixin):
    queryset = Publish.object.all()
    serializer_class = PublishSerializers
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

 

put对应UpdateModelMixin

class UpdateModelMixin:
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)

 

from rest_framework.mixin import UpdateModelMixin

class Publish(UpdateModelMixin):
    queryset = Publish.objects.all()
    serializer_class = PublishSerializers
    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

 

delete对应DestroyModelMixin

class DestroyModelMixin:
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

 

from rest_framework.mixin import DestroyModelMixin

class Publish(DestroyModelMixin):
    queryset = Publish.objects.all()
    serializer_class = PublishSerializers
    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

 

精简写法

from rest_framework import generics 

需要用到哪几个方法可以直接在generics中找对应的类

from rest_framework.viewset import ModelViewSet

ModelViewSet继承了所有的方法

ViewSetMixin重写了as_view方法

            for method, action in actions.items():
                handler = getattr(self, action)
                setattr(self, method, handler)

相当于{'get':'list', 'post':'create'}

使用了ViewSetMixin可以在as_view中传递参数

path('publish/',PublishViewSet.as_view({'get':'aaa'})

可以定义http方法所对应的类方法