Django's class-based views are a welcome departure from the old-style views.
REST framework provides anAPIView class, which subclasses Django'sView class.
APIView classes are different from regularView classes in the following ways:
Request instances, not Django'sHttpRequest instances.Response, instead of Django'sHttpResponse. The view will manage content negotiation and setting the correct renderer on the response.APIException exceptions will be caught and mediated into appropriate responses.Using theAPIView class is pretty much the same as using a regularView class, as usual, the incoming request is dispatched to an appropriate handler method such as.get() or.post(). Additionally, a number of attributes may be set on the class that control various aspects of the API policy.
For example:
from rest_framework.views import APIViewfrom rest_framework.response import Responsefrom rest_framework import authentication, permissionsfrom django.contrib.auth.models import Userclass ListUsers(APIView): """ View to list all users in the system. * Requires token authentication. * Only admin users are able to access this view. """ authentication_classes = [authentication.TokenAuthentication] permission_classes = [permissions.IsAdminUser] def get(self, request, format=None): """ Return a list of all users. """ usernames = [user.username for user in User.objects.all()] return Response(usernames)Note: The full methods, attributes on, and relations between Django REST Framework'sAPIView,GenericAPIView, variousMixins, andViewsets can be initially complex. In addition to the documentation here, theClassy Django REST Framework resource provides a browsable reference, with full methods and attributes, for each of Django REST Framework's class-based views.
The following attributes control the pluggable aspects of API views.
The following methods are used by REST framework to instantiate the various pluggable API policies. You won't typically need to override these methods.
The following methods are called before dispatching to the handler method.
The following methods are called directly by the view's.dispatch() method.These perform any actions that need to occur before or after calling the handler methods such as.get(),.post(),put(),patch() and.delete().
Performs any actions that need to occur before the handler method gets called.This method is used to enforce permissions and throttling, and perform content negotiation.
You won't typically need to override this method.
Any exception thrown by the handler method will be passed to this method, which either returns aResponse instance, or re-raises the exception.
The default implementation handles any subclass ofrest_framework.exceptions.APIException, as well as Django'sHttp404 andPermissionDenied exceptions, and returns an appropriate error response.
If you need to customize the error responses your API returns you should subclass this method.
Ensures that the request object that is passed to the handler method is an instance ofRequest, rather than the usual DjangoHttpRequest.
You won't typically need to override this method.
Ensures that anyResponse object returned from the handler method will be rendered into the correct content type, as determined by the content negotiation.
You won't typically need to override this method.
Saying [that class-based views] is always the superior solution is a mistake.
REST framework also allows you to work with regular function based views. It provides a set of simple decorators that wrap your function based views to ensure they receive an instance ofRequest (rather than the usual DjangoHttpRequest) and allows them to return aResponse (instead of a DjangoHttpResponse), and allow you to configure how the request is processed.
Signature:@api_view(http_method_names=['GET'])
The core of this functionality is theapi_view decorator, which takes a list of HTTP methods that your view should respond to. For example, this is how you would write a very simple view that just manually returns some data:
from rest_framework.decorators import api_viewfrom rest_framework.response import Response@api_view()def hello_world(request): return Response({"message": "Hello, world!"})This view will use the default renderers, parsers, authentication classes etc specified in thesettings.
By default onlyGET methods will be accepted. Other methods will respond with "405 Method Not Allowed". To alter this behavior, specify which methods the view allows, like so:
@api_view(['GET', 'POST'])def hello_world(request): if request.method == 'POST': return Response({"message": "Got some data!", "data": request.data}) return Response({"message": "Hello, world!"})To override the default settings, REST framework provides a set of additional decorators which can be added to your views. These must comeafter (below) the@api_view decorator. For example, to create a view that uses athrottle to ensure it can only be called once per day by a particular user, use the@throttle_classes decorator, passing a list of throttle classes:
from rest_framework.decorators import api_view, throttle_classesfrom rest_framework.throttling import UserRateThrottleclass OncePerDayUserThrottle(UserRateThrottle): rate = '1/day'@api_view(['GET'])@throttle_classes([OncePerDayUserThrottle])def view(request): return Response({"message": "Hello for today! See you tomorrow!"})These decorators correspond to the attributes set onAPIView subclasses, described above.
The available decorators are:
@renderer_classes(...)@parser_classes(...)@authentication_classes(...)@throttle_classes(...)@permission_classes(...)Each of these decorators takes a single argument which must be a list or tuple of classes.
To override the default schema generation for function based views you may usethe@schema decorator. This must comeafter (below) the@api_viewdecorator. For example:
from rest_framework.decorators import api_view, schemafrom rest_framework.schemas import AutoSchemaclass CustomAutoSchema(AutoSchema): def get_link(self, path, method, base_url): # override view introspection here...@api_view(['GET'])@schema(CustomAutoSchema())def view(request): return Response({"message": "Hello for today! See you tomorrow!"})This decorator takes a singleAutoSchema instance, anAutoSchema subclassinstance orManualSchema instance as described in theSchemas documentation.You may passNone in order to exclude the view from schema generation.
@api_view(['GET'])@schema(None)def view(request): return Response({"message": "Will not appear in schema!"})