Erstellen Sie eine CRUD-REST-API mit klassenbasierten Ansichten im Django REST Framework

Django Rest Framework (DRF) ist ein Django-Framework, das Unterstützung für die Erstellung von REST-APIs bietet. Wie Django können Sie mit DRF Ihre API-Ansichten mit funktionsbasierten oder klassenbasierten Ansichten erstellen.

Obwohl die Arbeit mit klassenbasierten Ansichten zunächst schwierig sein kann, bieten sie Vorteile wie eine bessere Codestruktur, Wiederverwendbarkeit, Vererbung und Prägnanz.

Erstellen Sie eine Rezept-Manager-API mit dem Django REST Framework

Eine Rezeptmanager-App ist eine großartige Möglichkeit, mehr über klassenbasierte Ansichten in DRF zu erfahren. Funktionen wie das Hinzufügen, Löschen und Bearbeiten von Rezepten helfen Ihnen zu verstehen, wie CRUD-Vorgänge (Erstellen, Lesen, Aktualisieren, Löschen) implementiert werden. In den folgenden Schritten erfahren Sie, wie Sie eine CRUD-API erstellen.

Den Code für diese Anleitung finden Sie unter GitHub.

Schritt 1: Installieren Sie das Django REST Framework und konfigurieren Sie Ihr Projekt

1. Erstellen Sie eine virtuelle Umgebung für Ihr Projekt und installieren Sie die folgenden Abhängigkeiten:

   pip install django djangorestframework
   

2. Erstellen Sie ein Django-Projekt mit dem Namen Kern mit folgendem Befehl:

   django-admin startproject core .
   

3. Erstellen Sie eine App namens Rezeptmanager:

   python manage.py startapp recipe_manager
   

4. Öffne dein core/settings.py Datei und navigieren Sie zu INSTALLED_APPS Liste zum Registrieren Ihrer Apps:

   INSTALLED_APPS = [
   # custom apps
   'rest_framework',
   'recipe_manager',
   ]
   

Schritt 2: Erstellen Sie ein Modell für Ihre Rezept-App

1. Öffne dein Recipe_manager/models.py Datei und erstellen Sie ein Modell für Ihre App. Hier ist ein einfaches Beispiel eines Rezeptmodells:

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

2. Erstellen Sie Migrationen und migrieren Sie Ihr Modell mit diesem Befehl in die Datenbank:

   python manage.py makemigrations && python manage.py migrate
   

Schritt 3: Erstellen Sie einen Serializer für Ihre App

Ein Serialisierer ist eine Django-Komponente, die Ihnen hilft, komplexe Datentypen, wie Ihren Abfragesatz, in ein Format zu konvertieren, das Sie rendern können, wie JSON oder XML, und umgekehrt.

Gehen Sie folgendermaßen vor, um einen Serialisierer zu erstellen:

1. Erstellen Sie eine Datei mit dem Namen Recipe_manager/serializers.py.
2. Importieren Sie die Serialisierer Modul sowie das Modell, das Sie serialisieren möchten:

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

3. Erstellen Sie in derselben Datei eine Serializer-Klasse für Ihr Modell und definieren Sie die Meta Klasse darin:

   # serializers.py
   classRecipeSerializer(serializers.ModelSerializer):
   classMeta:
    model = Recipe
    fields = ('recipe_name', 'ingredients', 'instructions')
   

   In diesem Code ist die Meta Die Klasse definiert das zu serialisierende Modell und die spezifischen Felder, die der Serialisierer verarbeiten soll. Der Felder Das Attribut kann entweder eine Liste oder ein Tupel sein. Wenn Sie alle Felder in Ihrem Modell serialisieren möchten, können Sie dies folgendermaßen tun:

   classMeta:
    fields = "__all__"
   

Schritt 4: Schreiben Sie eine Ansicht für die CREATE-Operation

Sie können klassenbasierte Ansichten für Ihre App erstellen, indem Sie die in Django verfügbare generische Ansicht importieren. Über diese Ansichten können Sie hier lesen Djangos offizielle Dokumentation. Um die CREATE-Operation von CRUD zu implementieren, sollten Sie die importieren APIView erstellen. Sie sollten auch Ihren Serializer und Ihr Modell importieren:

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

Um die CREATE-Operation zu implementieren, müssen Sie lediglich den Serialisierer angeben, den Ihre Ansicht verwenden soll. Hier ist ein Beispiel:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Mit diesem Setup können Sie POST-Anfragen an Ihre App stellen.

Schritt 5: Schreiben Sie eine Ansicht für die READ-Operation

1. Um die READ-Operation zu implementieren, importieren Sie die ListAPIView zu Ihren Ansichten. Diese Ansicht hilft Ihnen, Modellobjekte aufzulisten:

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

2. Erstellen Sie eine Klasse für Ihre Ansichten und geben Sie den zu verwendenden Serialisierer und Abfragesatz an:

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

3. Erstellen Sie eine Ansicht, um ein bestimmtes Rezept zu lesen. Dazu benötigen Sie die APIView abrufen Fügen Sie es also Ihrer Importliste hinzu:

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

   Erstellen Sie als Nächstes die gewünschte Ansicht:

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

Schritt 6: Ansichten für die UPDATE- und DELETE-Operationen schreiben

Um die UPDATE- und DELETE-Operationen zu implementieren, benötigen Sie die UpdateAPIView Und DestroyAPIView bzw. importieren Sie sie also:

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

Als nächstes erstellen Sie die Ansichten, genau wie zuvor. Dieses Mal erben Ihre Ansichten von UpdateAPIView Und DestroyAPIView, jeweils:

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

Schritt 7: Erstellen Sie URLs für Ihre App

1. Fügen Sie diesen Code hinzu core/urls.py So konfigurieren Sie Ihre URLs:

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

2. Fügen Sie den folgenden Code zu Ihrem hinzu Recipe_manager/urls.py Datei:

   from django.urls import path
   from. import views
   urlpatterns = [
   # 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'),
   ]
   

   Aus dem obigen Code werden Sie erkennen, dass klassenbasierte Ansichten das verwenden as_view() Funktion zum Erstellen ihrer URL-Muster. Sie können auch darüber lesen Unterschiede zwischen einem Projekt und einer App in Django wenn Sie durch deren Verwendung hier verwirrt sind.

Schritt 8: Testen Sie Ihre API-Endpunkte

Führen Sie in Ihrem Projektverzeichnis Folgendes aus:

python manage.py runserver

Dadurch sollte Ihr Server gestartet, einige Überprüfungen durchgeführt und eine URL gedruckt werden, über die Sie darauf zugreifen können.

Sie können jetzt Ihre API-Endpunkte testen, indem Sie zu den entsprechenden URLs navigieren (z. B. /api/recipes/) und senden HTTP-Anfragemethoden für CRUD-Operationen. Sie sollten eine Standardschnittstelle wie diese sehen:

Anstatt Ihren Browser zu verwenden, können Sie dies auch tun Testen Sie Ihre API mit Postman.

Üben Sie DRY beim Erstellen einer CRUD-API

DRY (Don't Repeat Yourself) ist ein Programmierprinzip, das Sie übernehmen sollten um die Qualität Ihres Codes zu verbessern.

Obwohl die oben beschriebenen Ansichten gut funktionieren, können Sie viele Wiederholungen vermeiden, indem Sie die verwenden ListCreateAPIView und das RetrieveUpdateDestroyAPIView generische Ansichten.

Die ListCreateAPIView kombiniert die ListAPIView Und APIView erstellen, während die RetrieveUpdateDestroyAPIView die kombiniert APIView abrufen, UpdateAPIView, und das DestroyAPIView.

Sie können Ihre vorherigen Ansichten so ändern, dass sie wie folgt aussehen:

from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
from .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()

Dieser Ansatz reduziert die Gesamtmenge an Code.

Sie können URLs für die neuen Ansichten wie folgt erstellen:

from django.urls import path
from .views import RecipeListCreateAPIView, RecipeRetrieveUpdateDeleteAPIView
urlpatterns = [
# 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'),
]

Sie können diese Endpunkte mit Postman oder einem anderen testen API-Testtool Sie bevorzugen.

Generische klassenbasierte Ansichten erleichtern Ihre Arbeit

Wie oben gesehen, können generische klassenbasierte Ansichten den Prozess der Ansichtenerstellung beschleunigen. Jetzt müssen Sie nur noch die richtige APIView für Ihren Anwendungsfall erben.

Sie sollten außerdem sicherstellen, dass Sie gute Programmierpraktiken anwenden, damit Sie am Ende keinen schlechten Code schreiben.