According to William.S.Vincent the Django REST Framework has tools called viewsets and routers that help accelerate the creation of APIs. They sit above views and URLs as an extra layer of abstraction.

The main advantage is that several related views may be replaced by a single viewset. Additionally, a router may provide URLs for developers automatically. For bigger projects with several endpoints, this reduces the amount of code that developers must write. In this article, we will explore these concepts and provide a hands on example to solidify your understanding.

Understanding Viewsets

Imagine that you own a wonderful recipe book that is filled with your best recipes for delectable dishes. Every recipe is similar to a favorite dish you enjoy preparing and eating. Now imagine a viewset as an amazing personal chef that assists you in organising all of your dishes.

You therefore own a viewset of your favorite dessert recipes. This wonderful chef understands how to reveal the recipes when you want to create anything sweet. The viewset makes it easy to locate all the materials (such flour, and sugar) and mixing instructions for making bread.

In simple terms, a viewset is like having a friendly kitchen helper that makes it easy for you to find, organize, and follow your favorite recipes. It's like having a special friend who knows everything about making delicious treats.

The core of Django rest framework's viewset system is used to handle HTTP requests pertaining to your API resources. By encapsulating the logic for CRUD (Create, Read, Update, Delete) activities, they provide an orderly and streamlined method for developing APIs.

Key aspects of Viewsets

1. CRUD Operations:

   Create: Handles the creation of a new resource instance.

   Read (List and Retrieve): Provides a list of all instances (list) or fetches a specific instance (retrieve).

   Update: Modifies an existing instance.

   Delete: Deletes an instance.

2. Methods Mapping:

   Different methods in a viewset (e.g., list, create, retrieve, update, destroy) correspond to HTTP verbs (GET, POST, GET, PUT, DELETE).

3. Serializer Integration:

   Utilizes serializers to convert complex data types (e.g., Django models) into Python data types suitable for rendering in JSON.

4. Queryset:

   The queryset attribute defines the set of records the viewsets operates on, typically a queryset of Django model instances.

Viewset Types

In Django REST Framework, there are several types of viewsets that you can use based on your specific needs. Here are some common types:

1. GenericViewSet:

   • A basic viewsets that doesn't provide any default behavior for HTTP methods.

   • You can mix in individual mixins like ListModelMixin, CreateModelMixin, RetrieveModelMixin, etc., based on your requirements.

2. ModelViewSet:

   • Inherits from GenericViewSet and includes default implementations for CRUD operations.

   • Often used when dealing with Django models, as it provides a straightforward way to handle database models.

3. ReadOnlyModelViewSet:

   • Similar to ModelViewSet but excludes the create, update, and delete operations.

   • Useful when you want to allow only reading from the model instances.

4. ReadOnlyViewSet:

   • A generic read-only viewsets that doesn't allow modification of any data.

   • Useful when your API only needs to provide information without allowing any changes.

5. ModelReadOnlyViewSet:

   • Combines the functionalities of ReadOnlyModelViewSet, providing a read-only interface for Django models.

6. ViewSet:

   • The base class for all viewsets. It doesn't provide any method handlers itself but includes the basic structure for defining and handling actions.

7. GenericViewSet + mixins:

   • You can create custom viewsets by combining the GenericViewSet with various mixins, such as ListModelMixin, CreateModelMixin, etc.

   • This approach allows you to tailor the behavior of your viewsets to specific requirements.

Choosing the right type of viewsets depends on your project's requirements and the level of customization you need for handling different HTTP methods. The ModelViewSet is commonly used in scenarios where you want a default implementation for CRUD operations with Django models.

Unraveling Routers

Imagine you have a fridge that keeps all your favorite snacks and drinks. Inside this fridge, you have different sections for fruits, cookies, and drinks. Now, think of a router as a special food guide that helps you find your snacks and drinks quickly.

Let's say you're in the mood for cookies. The router in your fridge will guide you straight to the cookie section, where you can find chocolate cookies, oatmeal cookies, and all your other favorites. If you decide you want fruit instead, the router will point you to the fruity section where you have apples, oranges, and grapes.

In simple terms, a router is like a food friend in your fridge that shows you where to find different types of snacks. It makes it easy for you to pick exactly what you want to munch on without searching all over the fridge.

Django rest framework routers automate the process of creating URL patterns based on a particular viewsets, hence streamlining the URL setting process. They help your API's structure remain stable and manageable.

Key aspects of Routers

1. Automated URL Configuration:

   • Routers automatically generate URL patterns, reducing the need for manual configuration and enhancing code maintainability.

2. Consistent Patterns:

   • Generate consistent URL patterns for various actions on a resource, promoting an organized API structure.

3. Multiple Routers:

   • Support the use of multiple routers in a project, enabling a modular approach to API design.

Practical example using a Food model

# models.py
from django.db import models

class Food(models.Model):
    name = models.CharField(max_length=100)
    cooked_by = models.CharField(max_length=50)

# serializers.py
from rest_framework import serializers
from .models import Food

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Food
        fields = '__all__'

# views.py
from rest_framework import viewsets
from .models import Food
from .serializers import BookSerializer

class FoodViewSet(viewsets.ModelViewSet):
    queryset = Food.objects.all()
    serializer_class = FoodSerializer

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import FoodViewSet

router = DefaultRouter()
router.register(r'food', FoodViewSet, basename='food')

urlpatterns = [
    path('api/', include(router.urls)),
]

In this example, the FoodViewSet handles CRUD operations for the Food model, and the router automates URL patterns like /api/food/ for listing and creating food, and /api/food/{pk}/ for retrieving, updating, and deleting a specific food.

Conclusion

Creating reliable and scalable Django REST Framework APIs requires a solid understanding of viewsets and routers. By using these ideas, you may streamline your development process and encourage a well-organized, manageable codebase. Viewsets and routers will surely become essential tools in your toolbox as you go deeper into the world of API programming.