Créez une API CRUD REST avec des vues basées sur les classes dans Django REST Framework

Suivez ce guide étape par étape et vous aurez le cœur d'une API CRUD sur laquelle vous pourrez continuer à développer.

Django Rest Framework (DRF) est un framework Django qui offre un support pour la création d'API REST. Comme Django, DRF vous permet de créer vos vues API avec des vues basées sur des fonctions ou des classes.

Bien que les vues basées sur les classes puissent être difficiles à utiliser au début, elles offrent des avantages tels qu'une meilleure structure de code, une meilleure réutilisabilité, un héritage et une concision.

Créer une API Recipe Manager avec Django REST Framework

Une application de gestion de recettes est un excellent moyen d’en savoir plus sur les vues basées sur les classes dans DRF. Des fonctionnalités telles que l'ajout, la suppression et la modification de recettes vous aideront à comprendre comment implémenter les opérations CRUD (Créer, Lire, Mettre à jour, Supprimer). Les étapes suivantes vous apprendront comment créer une API CRUD.

Vous pouvez trouver le code de ce guide sur GitHub.

instagram viewer

Étape 1: Installez Django REST Framework et configurez votre projet

Créez un environnement virtuel pour votre projet et installez les dépendances suivantes :
```
pip install django djangorestframework
```
Créez un projet Django appelé cœur avec la commande suivante :
```
django-admin startproject core .
```
Créez une application appelée gestionnaire_de_recettes:
```
python manage.py startapp recipe_manager
```
Ouvrez votre core/settings.py fichier et accédez au INSTALLED_APPS liste pour enregistrer vos applications :
```
INSTALLED_APPS = [
# custom apps
'rest_framework',
'recipe_manager',
]
```

Étape 2: Créez un modèle pour votre application de recettes

Ouvrez votre recette_manager/models.py fichier et créez un modèle pour votre application. Voici un exemple de base de modèle de recette :

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

Créez des migrations et migrez votre modèle dans la base de données avec cette commande :
```
python manage.py makemigrations && python manage.py migrate
```

Étape 3: Créez un sérialiseur pour votre application

Un sérialiseur est un composant Django qui vous aide à convertir des types de données complexes, tels que votre ensemble de requêtes, dans un format que vous pouvez restituer, comme JSON ou XML, et vice versa.

Pour créer un sérialiseur, procédez comme suit :

Créez un fichier appelé recette_manager/serializers.py.

Importer le sérialiseurs module ainsi que le modèle que vous souhaitez sérialiser :

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

Dans le même fichier, créez une classe de sérialiseur pour votre modèle et définissez le Méta classe dedans :
```
# serializers.py
classRecipeSerializer(serializers.ModelSerializer):
classMeta:
 model = Recipe
 fields = ('recipe_name', 'ingredients', 'instructions')
```
Dans ce code, le Méta class définit le modèle à sérialiser et les champs spécifiques que le sérialiseur doit gérer. Le des champs L'attribut peut être une liste ou un tuple. Si vous souhaitez sérialiser tous les champs de votre modèle, vous pouvez le faire comme ceci :
```
classMeta:
 fields = "__all__"
```

Étape 4: écrire une vue pour l'opération CREATE

Vous pouvez créer des vues basées sur les classes pour votre application en important la vue générique disponible dans Django. Vous pouvez lire ces points de vue sur Documentation officielle de Django. Pour implémenter l'opération CREATE de CRUD, vous devez importer le CréerAPIView. Vous devez également importer votre sérialiseur et votre modèle :

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

Pour implémenter l'opération CREATE, il vous suffit de spécifier le sérialiseur que votre vue doit utiliser. Voici un exemple :

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Avec cette configuration, vous pouvez envoyer des requêtes POST à votre application.

Étape 5: écrire une vue pour l'opération READ

Pour implémenter l'opération READ, importez le ListeAPIView à vos opinions. Cette vue vous aide à répertorier les objets du modèle :
```
# views.py
from rest_framework.generics import CreateAPIView, ListAPIView
```

Créez une classe pour vos vues et spécifiez le sérialiseur et l'ensemble de requêtes à utiliser :

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

Créez une vue pour lire une recette spécifique. Pour ce faire, vous avez besoin du RécupérerAPIView alors ajoutez-le à votre liste d'importations :

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

Créez ensuite la vue dont vous avez besoin :

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

Étape 6: Écrire des vues pour les opérations UPDATE et DELETE

Pour implémenter les opérations UPDATE et DELETE, vous avez besoin du Mise à jourAPIView et DétruireAPIView respectivement, alors importez-les :

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

Ensuite, créez les vues, comme vous l'avez fait auparavant. Cette fois, vos opinions hériteront de Mise à jourAPIView et DétruireAPIView, respectivement:

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

Étape 7: créez des URL pour votre application

Ajoutez ce code à core/urls.py pour configurer vos URL :

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

Ajoutez le code suivant à votre recette_manager/urls.py déposer:

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'),
]

À partir du code ci-dessus, vous observerez que les vues basées sur les classes utilisent le as_view() fonction pour créer leurs modèles d’URL. Vous pouvez également lire sur le différences entre un projet et une application dans Django si vous êtes confus par leur utilisation ici.

Étape 8: testez vos points de terminaison d'API

Depuis le répertoire de votre projet, exécutez ce qui suit :

python manage.py runserver

Cela devrait démarrer votre serveur, effectuer quelques vérifications et imprimer une URL via laquelle vous pouvez y accéder.

Vous pouvez désormais tester les points de terminaison de votre API en accédant aux URL respectives (par exemple, /api/recipes/) et envoi Méthodes de requête HTTP pour les opérations CRUD. Vous devriez voir une interface par défaut comme celle-ci :

Au lieu d'utiliser votre navigateur, vous pouvez testez votre API avec Postman.

Pratiquer DRY lors de la création d'une API CRUD

DRY (Ne vous répétez pas) est un principe de programmation à adopter pour améliorer la qualité de votre code.

Bien que les vues écrites ci-dessus fonctionnent bien, vous pouvez éviter beaucoup de répétitions en utilisant le ListeCréerAPIView et le RécupérerUpdateDestroyAPIView vues génériques.

Le ListCreateAPIView combine les ListeAPIView et CréerAPIView, tandis que RetrieveUpdateDestroyAPIView combine les RécupérerAPIView, Mise à jourAPIView, et le DétruireAPIView.

Vous pouvez modifier vos vues précédentes pour ressembler à ceci :

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()

Cette approche réduit la quantité globale de code.

Vous pouvez créer des URL pour les nouvelles vues comme ceci :

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'),
]

Vous pouvez tester ces points de terminaison avec Postman ou n'importe quel autre Outil de test d'API tu préfères.

Les vues génériques basées sur les classes facilitent votre travail

Comme vu ci-dessus, les vues génériques basées sur les classes peuvent accélérer le processus de création de vues. Il ne vous reste plus qu'à hériter de l'APIView adaptée à votre cas d'utilisation.

Vous devez également vous assurer d’adopter de bonnes pratiques de programmation, afin de ne pas finir par écrire du mauvais code.

About Technology - denizatm.com