Cree una API CRUD REST con vistas basadas en clases en Django REST Framework

Siga esta guía paso a paso y tendrá el núcleo de una API CRUD sobre la cual seguir desarrollando.

Django Rest Framework (DRF) es un marco de Django que ofrece soporte para crear API REST. Al igual que Django, DRF le permite crear sus vistas API con vistas basadas en funciones o clases.

Aunque puede resultar difícil trabajar con las vistas basadas en clases al principio, ofrecen beneficios como una mejor estructura de código, reutilización, herencia y concisión.

Cree una API de administrador de recetas con Django REST Framework

Una aplicación de administrador de recetas es una excelente manera de aprender sobre las vistas basadas en clases en DRF. Funciones como agregar, eliminar y editar recetas lo ayudarán a comprender cómo implementar operaciones CRUD (Crear, Leer, Actualizar, Eliminar). Los siguientes pasos le enseñarán cómo crear una API CRUD.

Puede encontrar el código de esta guía en GitHub.

Paso 1: instale Django REST Framework y configure su proyecto

Cree un entorno virtual para su proyecto e instale las siguientes dependencias:
```
pip install django djangorestframework
```

instagram viewer

Crea un proyecto Django llamado centro con el siguiente comando:
```
django-admin startproject core .
```
Crea una aplicación llamada administrador_de_recetas:
```
python manage.py startapp recipe_manager
```
Abre tu núcleo/settings.py archivo y navegue hasta el INSTALLED_APPS lista para registrar sus aplicaciones:
```
INSTALLED_APPS = [
# custom apps
'rest_framework',
'recipe_manager',
]
```

Paso 2: crea un modelo para tu aplicación de recetas

Abre tu administrador_recetas/modelos.py archivo y cree un modelo para su aplicación. A continuación se muestra un ejemplo básico de un modelo de receta:

# models.py
from django.db import modelsclassRecipe(models.Model):
 recipe_name = models.CharField(max_length=255)
 ingredients = models.TextField()
 instructions = models.TextField()

Cree migraciones y migre su modelo a la base de datos con este comando:
```
python manage.py makemigrations && python manage.py migrate
```

Paso 3: cree un serializador para su aplicación

Un serializador es un componente de Django que te ayuda a convertir tipos de datos complejos, como tu conjunto de consultas, a un formato que puedas representar, como JSON o XML, y viceversa.

Para crear un serializador, siga estos pasos:

Crea un archivo llamado administrador_recetas/serializadores.py.

Importar el serializadores módulo así como el modelo que desea serializar:

# serializers.py
from rest_framework import serializersfrom .models import Recipe # the model to serialize

En el mismo archivo, cree una clase de serializador para su modelo y defina el Meta clase en él:
```
# serializers.py
classRecipeSerializer(serializers.ModelSerializer):
classMeta:
 model = Recipe
 fields = ('recipe_name', 'ingredients', 'instructions')
```
En este código, el Meta La clase define el modelo a serializar y los campos específicos que el serializador debe manejar. El campos El atributo puede ser una lista o una tupla. Si desea serializar todos los campos de su modelo, puede hacerlo así:
```
classMeta:
 fields = "__all__"
```

Paso 4: escribir una vista para la operación CREATE

Puedes crear vistas basadas en clases para tu aplicación importando la vista genérica disponible en Django. Puedes leer sobre estas vistas en Documentación oficial de Django. Para implementar la operación CREATE de CRUD, debe importar el CrearAPIView. También debes importar tu serializador y modelo:

# views.py
from rest_framework.generics import CreateAPIViewfrom .models import Recipe
from .serializers import RecipeSerializer

Para implementar la operación CREATE, solo necesita especificar el serializador que debe usar su vista. He aquí un ejemplo:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Con esta configuración, puede realizar solicitudes POST a su aplicación.

Paso 5: escribir una vista para la operación READ

Para implementar la operación READ, importe el ListaAPIView a tus puntos de vista. Esta vista le ayuda a enumerar los objetos del modelo:
```
# views.py
from rest_framework.generics import CreateAPIView, ListAPIView
```

Cree una clase para sus vistas y especifique el serializador y el conjunto de consultas que se utilizarán:

# List view
classRecipeListView(ListAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()

Crea una vista para leer una receta específica. Para hacer esto, necesitas el RecuperarAPIView así que agréguelo a su lista de importaciones:

# views.py
from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView

A continuación, cree la vista que necesita:

# Retrieve view
classRecipeRetrieveView(RetrieveAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()

Paso 6: escribir vistas para las operaciones ACTUALIZAR y ELIMINAR

Para implementar las operaciones ACTUALIZAR y ELIMINAR, necesita el ActualizarAPIView y DestruirAPIView respectivamente, así que importalos:

from rest_framework.generics import (
 ListAPIView,
 CreateAPIView,
 RetrieveAPIView,
 UpdateAPIView, # new
 DestroyAPIView, # new
)

A continuación, cree las vistas, tal como lo hizo antes. Esta vez, sus puntos de vista heredarán del ActualizarAPIView y DestruirAPIView, respectivamente:

# Update view
classRecipeUpdateView(UpdateAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()# Delete view
classRecipeDeleteView(DestroyAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()

Paso 7: cree URL para su aplicación

Añade este código a núcleo/urls.py para configurar sus URL:

from django.urls import path, includeurlpatterns = [
 path('api/', include('recipe_manager.urls'))
]

Añade el siguiente código a tu administrador_recetas/urls.py archivo:

from django.urls import path
from. import viewsurlpatterns = [
# List view (Read all)
 path('recipes/', views.RecipeListView.as_view(), name='recipe-list'),
# Create view
 path('recipes/create/', views.RecipeCreateView.as_view(), name='recipe-create'),
# Retrieve view (Read one)
 path('recipes//', views.RecipeRetrieveView.as_view(), name='recipe-retrieve'),
# Update view
 path('recipes//update/', views.RecipeUpdateView.as_view(), name='recipe-update'),# Delete view
 path('recipes//delete/', views.RecipeDeleteView.as_view(), name='recipe-destroy'),
]

En el código anterior, observará que las vistas basadas en clases utilizan el como_vista() función para crear sus patrones de URL. También puedes leer sobre el diferencias entre un proyecto y una aplicación en Django si está confundido por su uso aquí.

Paso 8: Pruebe sus puntos finales API

Desde el directorio de su proyecto, ejecute lo siguiente:

python manage.py runserver

Esto debería iniciar su servidor, realizar algunas comprobaciones e imprimir una URL a través de la cual pueda acceder.

Ahora puede probar los puntos finales de su API navegando a las URL respectivas (por ejemplo, /api/recipes/) y enviando Métodos de solicitud HTTP para operaciones CRUD. Deberías ver una interfaz predeterminada como esta:

En lugar de utilizar su navegador, puede prueba tu API con Postman.

Practicando DRY mientras se crea una API CRUD

DRY (No te repitas) es un Principio de programación que debes adoptar. para mejorar la calidad de su código.

Aunque las vistas escritas arriba funcionan bien, puedes evitar muchas repeticiones usando el ListaCrearAPIView y el RecuperarActualizarDestroyAPIView vistas genéricas.

ListCreateAPIView combina la ListaAPIView y CrearAPIView, mientras que RetrieveUpdateDestroyAPIView combina el RecuperarAPIView, ActualizarAPIView, y el DestruirAPIView.

Puede modificar sus vistas anteriores para que se vean así:

from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIViewfrom .models import Recipe
from .serializers import RecipeSerializer
classRecipeListCreateAPIView(ListCreateAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()classRecipeRetrieveUpdateDeleteAPIView(RetrieveUpdateDestroyAPIView):
 serializer_class = RecipeSerializer
 queryset = Recipe.objects.all()

Este enfoque reduce la cantidad total de código.

Puede crear URL para las nuevas vistas como esta:

from django.urls import path
from .views import RecipeListCreateAPIView, RecipeRetrieveUpdateDeleteAPIViewurlpatterns = [
# List and Create view
 path('recipes/', RecipeListCreateAPIView.as_view(), name='recipe-list-create'),# Retrieve, Update, and Delete view
 path('recipes//', RecipeRetrieveUpdateDeleteAPIView.as_view(), name='recipe-retrieve-update-destroy'),
]

Puede probar estos puntos finales con Postman o cualquier herramienta de prueba API prefieres.

Las vistas genéricas basadas en clases facilitan su trabajo

Como se vio anteriormente, las vistas genéricas basadas en clases pueden acelerar el proceso de creación de vistas. Ahora solo necesita heredar la APIView adecuada para su caso de uso.

También debe asegurarse de adoptar buenas prácticas de programación para no terminar escribiendo código incorrecto.

About Technology - denizatm.com