HyperlinkedModelSerializer in serializers – Django REST Framework

HyperlinkedModelSerializer is a layer of abstraction over the default serializer that allows to quickly create a serializer for a model in Django. Django REST Framework is a wrapper over default Django Framework, basically used to create APIs of various kinds. There are three stages before creating a API through REST framework, Converting a Model’s data to JSON/XML format (Serialization), Rendering this data to the view, Creating a URL for mapping to the viewset. This article revolves around HyperlinkedModelSerializer in serializers of Django REST Framework.

HyperlinkedModelSerializer

The HyperlinkedModelSerializer class is similar to the ModelSerializer class except that it uses hyperlinks to represent relationships, rather than primary keys. By default the serializer will include a url field instead of a primary key field. The url field will be represented using a HyperlinkedIdentityField serializer field, and any relationships on the model will be represented using a HyperlinkedRelatedField serializer field.

Syntax –

class SerializerName(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = ModelName
        fields = List of Fields

Example –

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']

By default, all the model fields on the class will be mapped to a corresponding serializer fields.

How to create a HyperlinkedModelSerializer using Django REST Framework ?

• Add rest_framework to INSTALLED_APPS
• Create a app and model
• Serialization
• Creating a viewset
• Define URLs of API
• Run server and check API

Add rest_framework to INSTALLED_APPS

To initialize REST Framework in your project, go to

settings.py

, and in INSTALLED_APPS add

‘rest_framework’

at the bottom.

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
]

Using serializers effectively is vital in building APIs with Django . To dive deeper into Django and Django REST Framework, the Complete Django Web Development Course – Basics to Advance course offers detailed insights into serializers and more advanced topics.

Create a app and model

Now, let’s create a app using command,

python manage.py startapp apis

A folder with name apis would have been registered by now. let’s add this app to

INSTALLED_APPS

and urls.py also. In,

settings.py

,

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'apis',
]

Now, add apis urls in urls.py. In

geeksforgeeks.urls.py

,

from django.contrib import admin
# include necessary libraries
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    # add apis urls
    path('', include("apis.urls"))
]

Create a model

To demonstrate, creating and using an API, let’s create a model named “GeeksModel”. In apis/models.py

from django.db import models

class GeeksModel(models.Model):
    title = models.CharField(max_length = 200)
    description = models.TextField()

    def __str__(self):
        return self.title

now our app is ready, let’s serialize the data and create views from the same.

Serialization

Serializers allow complex data such as querysets and model instances to be converted to native Python datatypes that can then be easily rendered into JSON, XML or other content types. Serializers also provide deserialization, allowing parsed data to be converted back into complex types, after first validating the incoming data. Let’s start creating a serializer, in file

apis/serializers.py

,

# import serializer from rest_framework
from rest_framework import serializers

# import model from models.py
from .models import GeeksModel

# Create a model serializer 
class GeeksSerializer(serializers.HyperlinkedModelSerializer):
    # specify model and fields
    class Meta:
        model = GeeksModel
        fields = ('url', 'id', 'title', 'description')

Creating a viewset

To render data into frontend, and handle requests from user, we need to create a view. In Django REST Framework, we call these as viewsets, so let’s create a view in

apis/views.py

,

# import viewsets
from rest_framework import viewsets

# import local data
from .serializers import GeeksSerializer
from .models import GeeksModel

# create a viewset
class GeeksViewSet(viewsets.ModelViewSet):
    # define queryset
    queryset = GeeksModel.objects.all()
    
    # specify serializer to be used
    serializer_class = GeeksSerializer

Define URLs of API

Specify the url path of APIs to be accessed, In

apis/urls.py

,

# basic URL Configurations
from django.urls import include, path
# import routers
from rest_framework import routers

# import everything from views
from .views import *

# define the router
router = routers.DefaultRouter()

# define the router path and viewset to be used
router.register(r'geeks', GeeksViewSet)

# specify URL Path for rest_framework
urlpatterns = [
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls'))
]

After everything is successfully ready, let’s run some commands to activate the server.

Run server and check API

Run following commands to create the database, and run server,

python manage.py makemigrations
python manage.py migrate
python manage.py runserver

Now visit

,

One can check that HyperlinkedModelSerializer has created a endpoint with overall CRUD functionality. To check the code for the project,

Advanced Usage

Specifying which fields to include

If you only want a subset of the default fields to be used in a model serializer, you can do so using fields or exclude options, just as you would with a

. For example:

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        # specify field names
        fields = ['id', 'account_name', 'users', 'created']

or exclude Example :

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        # specify field names
        exclude = ['id']

Specifying read only fields

One may wish to specify multiple fields as read-only. Instead of adding each field explicitly with the read_only=True attribute, you can use the shortcut Meta option, read_only_fields. This option should be a list or tuple of field names, and is declared as follows:

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']
        # specify read only fields
        read_only_fields = ['account_name']

Changing the URL field name

The name of the URL field defaults to ‘url’. You can override this globally, by using the URL_FIELD_NAME setting.

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'newurl', 'account_name', 'users', 'created']
        # specify read only fields
        read_only_fields = ['account_name']
        URL_FIELD_NAME = 'newurl'

To check more about HyperlinkedModelSerializer, visit

Core arguments in serializer fields