ModelSerializer en serializadores – Django REST Framework

ModelSerializer 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 ModelSerializer en serializadores de Django REST Framework.

ModelSerializerModelSerializer

La clase ModelSerializer proporciona un atajo que le permite crear automáticamente una clase Serializer con campos que corresponden a los campos del Modelo.
La clase ModelSerializer es la misma que una clase Serializer regular, excepto que:

• Generará automáticamente un conjunto de campos para usted, según el modelo.
• Generará automáticamente validadores para el serializador, como validadores únicos_juntos.
• Incluye implementaciones predeterminadas simples de .create()y .update().

Sintaxis –

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

Ejemplo –

class AccountSerializer(serializers.ModelSerializer):
    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 ModelSerializer 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, serialicemos los datos y creemos 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.ModelSerializer):
    # specify model and fields
    class Meta:
        model = GeeksModel
        fields = ('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/ ,

One can check that ModelSerializer has created a endpoint with overall CRUD functionality.

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.ModelSerializer):
    class Meta:
        model = Account
        # specify field names
        fields = ['id', 'account_name', 'users', 'created']

o excluir Ejemplo:

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

Especificación de campos explícitamente
Uno puede agregar campos adicionales a un ModelSerializer o anular los campos predeterminados al declarar campos en la clase, tal como lo haría con una clase Serializer.
Por ejemplo,

class AccountSerializer(serializers.ModelSerializer):
    # defining fields manually
    url = serializers.CharField(source ='get_absolute_url', read_only = True)
  
    class Meta:
        # specify model
        model = Account

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.ModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']
        # specify read only fields
        read_only_fields = ['account_name']

Para obtener más información sobre ModelSerializer, visite Documentación de ModelSerializer

Argumentos centrales en los campos del serializador