HyperlinkedModelSerializer en serializadores – Django REST Framework

HyperlinkedModelSerializer es una capa de abstracción sobre el serializador predeterminado que permite crear rápidamente un serializador para un modelo en Django. Django REST Framework es un contenedor sobre Django Framework predeterminado, básicamente utilizado para crear API de varios tipos. Hay tres etapas antes de crear una API a través del marco REST, convertir los datos de un modelo a formato JSON/XML (serialización), representar estos datos en la vista, crear una URL para mapear al conjunto de vistas. Este artículo gira en torno a HyperlinkedModelSerializer en serializadores de Django REST Framework.

HyperlinkedModelSerializerHyperlinkedModelSerializer

La clase HyperlinkedModelSerializer es similar a la clase ModelSerializer excepto que usa hipervínculos para representar relaciones, en lugar de claves principales. De forma predeterminada, el serializador incluirá un campo de URL en lugar de un campo de clave principal. El campo URL se representará mediante un campo serializador HyperlinkedIdentityField y cualquier relación en el modelo se representará mediante un campo serializador HyperlinkedRelatedField.

Sintaxis –

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

Ejemplo –

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

De forma predeterminada, todos los campos del modelo en la clase se asignarán a los campos del serializador correspondiente.

¿Cómo crear un HyperlinkedModelSerializer usando Django REST Framework?

• Agregue rest_framework a INSTALLED_APPS
• Crear una aplicación y un modelo
• Publicación por entregas
• Creación de un conjunto de vistas
• Definir URL de API
• Ejecute el servidor y verifique la API

Agregue rest_framework a INSTALLED_APPS

Para inicializar REST Framework en su proyecto, vaya a settings.pyy en INSTALLED_APPS agregue ‘rest_framework’ en la parte inferior.

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

Crear una aplicación y un modelo

Ahora, creemos una aplicación usando el comando,

python manage.py startapp apis

Ya se habría registrado una carpeta con el nombre apis. agreguemos esta aplicación a INSTALLED_APPS y urls.py también.
en, 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',
]

Ahora, agregue apis urls en urls.py. En 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"))
]

Crear un modelo
Para demostrar, crear y usar una API, creemos un modelo llamado «GeeksModel». En 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

ahora que nuestra aplicación está lista, vamos a serializar los datos y crear vistas a partir de ellos.

Publicación por entregas

Los serializadores permiten convertir datos complejos, como conjuntos de consultas e instancias de modelos, en tipos de datos nativos de Python que luego se pueden representar fácilmente en JSON, XML u otros tipos de contenido. Los serializadores también brindan deserialización, lo que permite que los datos analizados se vuelvan a convertir en tipos complejos, después de validar primero los datos entrantes. Empecemos a crear un serializador, en 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')

Creación de un conjunto de vistas

Para procesar datos en la interfaz y manejar las requests del usuario, necesitamos crear una vista. En Django REST Framework, los llamamos conjuntos de vistas, así que vamos a crear una vista en 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

Definir URL de API

Especifique la ruta URL de las API a las que se accederá, 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'))
]

Después de que todo esté listo con éxito, ejecutemos algunos comandos para activar el servidor.

Ejecute el servidor y verifique la API

Ejecute los siguientes comandos para crear la base de datos y ejecutar el servidor,

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

Ahora visite http://127.0.0.1:8000/geeks/ ,

Se puede verificar que HyperlinkedModelSerializer haya creado un punto final con la funcionalidad CRUD general.

Para comprobar el código del proyecto, haga clic aquí

Uso avanzado

Especificar qué campos incluir
Si solo desea que se use un subconjunto de los campos predeterminados en un serializador de modelos, puede hacerlo usando campos o opciones de exclusión, tal como lo haría con un ModelForm .
Por ejemplo:

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

o excluir Ejemplo:

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

Especificación de campos de solo lectura
Es posible que desee especificar varios campos como de solo lectura. En lugar de agregar cada campo explícitamente con el atributo read_only=True, puede usar la opción Meta de acceso directo, read_only_fields.
Esta opción debe ser una lista o tupla de nombres de campo y se declara de la siguiente manera:

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

Cambiar el nombre del campo URL
El nombre del campo URL por defecto es ‘url’. Puede anular esto globalmente mediante la configuración de URL_FIELD_NAME.

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'

Para obtener más información sobre HyperlinkedModelSerializer, visite la documentación de HyperlinkedModelSerializer

Argumentos centrales en los campos del serializador