Advance Serializers

Common Parameters in Serializer Fields

In this section, we will understand the common parameters in Serializer Fields. These core arguments are used in serializer fields to configure the behavior and define how data is serialized or deserialized.

Advanced Serializers

Advanced serializers are one of the key features in the Django REST framework. It enables us to customize the serialization process for complex Python objects. There are many advanced serializers that are used, including:

1. Nested Serializers
    
2. Hyperlinked Serializers
    
3. Sparse Fieldsets Serializers
    

Each of these serializers has its own use cases and ways in which it can be used. Nested Serializers are used for serializing related models, hyperlinked serializers are used for generating hyperlinks to related resources, and sparse fieldset serializers are useful for reducing the size of serialized responses. We will look into each one of them in detail and how they can be implemented in the blog.

Nested Serializers

Definition of Nested Serializers

Nested Serializers is one of the features of Django REST Framework which allows us to serialize or deserialize related models. This becomes very useful when there is a one-to-many or many-to-many relationship between objects, and we wanted to include related objects in the serialized representation.

Implementing Nested Serializers

We will see an example where we use a nested list to serialize a list of “Book” objects with their corresponding “Authors”.

# models.py


from django.db import models


class Author(models.Model):
    name = models.CharField(max_length=100)


class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

You can also try this code with Online Python Compiler

Run Code

So to implement Nested Serializers, we will take an example of the “Book” model where there exists an foreign key relation with the “Author” model. Here we can use a nested serializer to include the “Author” object in the serialized representation of the “Book”.

# serializers.py


from rest_framework import serializers
from .models import Author, Book


class AuthorSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Author
        fields = ['url', 'name']


class BookSerializer(serializers.HyperlinkedModelSerializer):
    author = serializers.HyperlinkedRelatedField(
        view_name='author-detail',
        read_only=True
    )


    class Meta:
        model = Book
        fields = ['url', 'title', 'author']

You can also try this code with Online Python Compiler

Run Code

In this example, we define 2 serializer classes, i.e., AuthorSerializer and BookSerializer. The AuthorSerializer defines how to serialize the Author model, and the BookSerializer defines how to serialize the Book model.

To include the Author object in the serialized representation of the Book, we define an author field in the BookSerializer that uses the AuthorSerializer.

Now, when we serialize a Book object using the BookSerializer, the serialized representation will include the Author object as a nested dictionary:

# views.py


from rest_framework import generics
from .models import Book
from .serializers import BookSerializer


class BookList(generics.ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
In this example, we define a BookList view that uses the BookSerializer to serialize a list of Book objects.

You can also try this code with Online Python Compiler

Run Code

Hyperlinked Serializers

Definition of Hyperlinked Serializers

Django REST Framework's hyperlinked serializers help developers include hyperlinks to related resources in a model's serialized representation.

This indicates that the serializer will include hyperlinks to the related resources rather than attaching the serialized representation of related resources in the serialized representation of a model. The client receives the serialized representation of the relevant resource if it clicks on the hyperlink.

Implementing Hyperlinked Serializers

We use the HyperlinkedRelatedField, one must define a serializer class for each related model in the Django REST Framework, to implement a hyperlinked serializer.

In the below example, we try to execute a hyperlinked serializer for a Book model that includes a Writer model:

# serializers.py


from rest_framework import serializers
from .models import Author, Book


class AuthorSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Author
        fields = ['url', 'name']


class BookSerializer(serializers.HyperlinkedModelSerializer):
    author = serializers.HyperlinkedRelatedField(
        view_name='author-detail',
        read_only=True
    )


    class Meta:
        model = Book
        fields = ['url', 'title', 'author']

You can also try this code with Online Python Compiler

Run Code

We define two serializer classes in this example, i.e., Book Serializer and Author Serializer The AuthorSerializer and the BookSerializer provide instructions on how to use hyperlinks to serialize the Author model and the Book model, respectively.

We use the HyperlinkedRelatedField to create an author field in the BookSerializer that links to the related Author object in the serialized representation of the Book.

The view_name parameter of the HyperlinkedRelatedField is also used to point to the Author detail view's URL. The view that will be utilized in order to obtain the serialized representation of the associated Author object is this one.

Sparse Fieldsets Serializers

Definition of Sparse Fieldsets Serializers

Sparse Fieldset Serializers are one of the key features of Django REST Framework, which let developers choose the fields that are included in a resource's serialized representation.

This indicates that the serializer will only include the fields specified in the request rather than serializing the entire resource. When dealing with a lot of resources, this can boost performance and save network bandwidth.

Implementing Sparse Fieldsets Serializers

To execute a sparse fieldsets serializer in Django REST Structure, you want to characterize a serializer class for the asset and supersede the get_fields technique to just incorporate the fields that are specified in the request.

This is an illustration of the way to execute a scanty fieldsets serializer for a Book model:

# serializers.py - file name


from rest_framework import serializers
from .models import Book


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'description']


    def get_fields(self):
        fields = super().get_fields()
        request_fields = self.context['request'].query_params.get('fields')
        if request_fields:
            allowed = set(request_fields.split(','))
            existing = set(fields.keys())
            for field_name in existing - allowed:
                fields.pop(field_name)
        return fields

You can also try this code with Online Python Compiler

Run Code

In this example, a BookSerializer class with the id, title, author, and description fields is defined. Also, we override the get_fields method to only include the fields specified in the request's fields query parameter.

The serializer will include all fields in the resource's serialized representation if the fields query parameter is not specified. The serializer will only include the fields that are specified in the fields query parameter if it is provided.

Frequently Asked Questions

What is the need for advanced serializers?

For RESTful APIs, advanced serializers are used to customize the serialization of complex Python objects. They can reduce the size of serialized responses and improve API performance, particularly for related models.

What are the different types of Advanced Serizaliers?

Advanced serializers like nested, hyperlinked, sparse fieldsets, and custom serializers are available in the Django REST Framework. These serializers are utilized for related models, creating hyperlinks, decreasing reaction size, and taking care of non-standard prerequisites.

How do hyperlinked serializers differ from regular serializers?

The difference is that in contrast to regular serializers, the hyperlinked serializers in the Django REST Framework produce hyperlinks to related resources. These serializers output URLs rather than primary keys, and also it is simpler to navigate related API resources.

Conclusion

Thus, in this blog, we read about how serializers can efficiently help us convert complex data structures into JSON or XML format so that they can be easily sent on other devices. We also understood the various fields and some of the common parameters in the Django REST Framework. We then saw the various advanced serializers that are used in Django REST Framework to serialize the data, which include Nested, Hyperlinked, and Sparse Field Serializers.
 

If you liked our article, do upvote our article and help other ninjas grow.  You can refer to our Guided Path on Coding Ninjas Studio to upskill yourself in Data Structures and Algorithms, Competitive Programming, System Design, and many more!

Happy Learning!