Bouw een CRUD REST API met Class-Based Views in Django REST Framework

Django Rest Framework (DRF) is een Django-raamwerk dat ondersteuning biedt voor het bouwen van REST API’s. Net als Django kunt u met DRF uw API-weergaven bouwen met functiegebaseerde of klassegebaseerde weergaven.

Hoewel class-gebaseerde views in het begin een steile leercurve kunnen hebben, worden ze gekenmerkt door verschillende voordelen, zoals verbeterde code-organisatie, verhoogde modulariteit door overerving, verbeterde herbruikbaarheid en beknoptheid in expressie.

Maak een Recept Manager API met Django REST Framework

Een recept management applicatie dient als een uitstekend platform voor het verkennen van class-based views binnen Django Rest Framework (DRF). Door het opnemen van functies zoals het maken, wijzigen en verwijderen van recepten, kan men de implementatie van CRUD (Create, Read, Update, Delete) functies begrijpen. Deze handleiding leert je hoe je een CRUD-interface ontwerpt aan de hand van een reeks opeenvolgende stappen.

De broncode voor deze handleiding is beschikbaar om te downloaden van het GitHub platform, dat dient als een hub voor ontwikkelaars om samen te werken en hun werk te delen met anderen in de vorm van open-source repositories.

Stap 1: Django REST Framework installeren en uw project configureren

⭐ Creëer een virtuele omgeving voor uw project en installeer de volgende afhankelijkheden:

 pip install django djangorestframework

⭐ Maak een Django project genaamd core met de volgende opdracht:

 django-admin startproject core .

⭐ Maak een app genaamd recipe_manager :

 python manage.py startapp recipe_manager

⭐ Open uw core/settings.py bestand en navigeer naar de INSTALLED_APPS lijst om uw apps te registreren:

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

Stap 2: Maak een model voor uw Recept App

⭐ Open uw recipe_manager/models.py bestand en maak een model voor uw app. Hier is een basisvoorbeeld van een receptmodel:

 # models.py
from django.db import models

class Recipe(models.Model):
    recipe_name = models.CharField(max_length=255)
    ingredients = models.TextField()
    instructions = models.TextField()

⭐ Maak migraties en migreer je model naar de database met deze opdracht:

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

Stap 3: Maak een serializer voor uw app

Een serializer is een integraal onderdeel van het Django-raamwerk en vergemakkelijkt de conversie van ingewikkelde gegevensstructuren, waaronder queriesets, naar formaten die geschikt zijn voor weergave, waaronder voorbeelden zoals JSON of XML.

Volg deze stappen om een serializer te maken:

⭐Maak een bestand genaamdrecipe_manager/serializers.py.

⭐ Importeer de module serializers en het model dat je wilt serialiseren:

 # serializers.py
from rest_framework import serializers

from .models import Recipe # the model to serialize

⭐ Maak in hetzelfde bestand een serializer klasse voor je model en definieer de Meta klasse erin:

 # serializers.py
class RecipeSerializer(serializers.ModelSerializer):
    class Meta:
        model = Recipe
        fields = ('recipe_name', 'ingredients', 'instructions')

In deze code definieert de Meta klasse het model om te serialiseren en de specifieke velden die de serializer moet behandelen. Het fields attribuut kan een lijst of een tupel zijn. Als je alle velden in je model wilt serializeren, kun je dat als volgt doen:

 class Meta:
 fields = "__all__"

Stap 4: Schrijf een view voor de CREATE Operation

U kunt op klassen gebaseerde views voor uw app maken door de generieke view te importeren die beschikbaar is in Django. U kunt meer lezen over deze views in Django’s officiële documentatie . Om de CREATE-bewerking van CRUD te implementeren, moet u de CreateAPIView importeren. U moet ook uw serializer en model importeren:

 # views.py
from rest_framework.generics import CreateAPIView

from .models import Recipe
from .serializers import RecipeSerializer

Om het proces van het creëren van een nieuwe entiteit binnen een specifieke view met behulp van de REST API uit te voeren, is het alleen nodig om de specifieke serialisatiemethode aan te wijzen die de view moet gebruiken. Een voorbeeld hiervan kan als volgt worden bekeken:

 # Create view
class RecipeCreateView(CreateAPIView):
    serializer_class = RecipeSerializer

Door deze configuratie te gebruiken, kunnen POST-verzoeken naar je applicatie worden uitgevoerd.

Stap 5: Een view schrijven voor de READ-bewerking

⭐ Om de READ-bewerking te implementeren, importeer je de ListAPIView in je views. Deze view helpt je bij het oplijsten van modelobjecten:

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

⭐ Maak een klasse voor je views en specificeer de serializer en query set om te gebruiken:

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

⭐ Maak een view om een specifiek recept te lezen. Om dit te doen, heb je de RetrieveAPIView nodig, dus voeg deze toe aan je lijst met imports:

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

Maak vervolgens de view die je nodig hebt:

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

Stap 6: Views schrijven voor de UPDATE en DELETE operaties

Om de UPDATE en DELETE operaties uit te voeren, is het noodzakelijk om de respectievelijke API views te gebruiken, namelijk UpdateAPIView en DestroyAPIView . Daarom moeten deze weergaven dienovereenkomstig worden geïmporteerd.

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

Vervolgens zullen we de benodigde views implementeren die zullen erven van zowel UpdateAPIView als DestroyAPIView :

 # Update view
class RecipeUpdateView(UpdateAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

# Delete view
class RecipeDeleteView(DestroyAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

Stap 7: URL’s maken voor je app

⭐ Voeg deze code toe aan core/urls.py om je URLS te configureren:

 from django.urls import path, include

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

⭐ Voeg de volgende code toe aan je recipe_manager/urls.py bestand:

 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/<int:pk>/', views.RecipeRetrieveView.as_view(), name='recipe-retrieve'),

    # Update view
    path('recipes/<int:pk>/update/', views.RecipeUpdateView.as_view(), name='recipe-update'),

    # Delete view
    path('recipes/<int:pk>/delete/', views.RecipeDeleteView.as_view(), name='recipe-destroy'),
]

In de bovenstaande code zul je zien dat class-gebaseerde views de as_view() functie gebruiken om hun URL-patronen aan te maken. U kunt hier ook lezen over de verschillen tussen een project en een app in Django als u in de war bent door hun gebruik.

Stap 8: Test uw API-eindpunten

Voer vanuit uw projectdirectory het volgende uit:

 python manage.py runserver 

Er wordt verwacht dat deze actie de server opstart, bepaalde inspecties uitvoert en een webadres produceert dat toegang op afstand mogelijk maakt.

Je kunt nu je API endpoints valideren door de bijbehorende URI’s te bezoeken, zoals “/api/recipes/”, en verschillende HTTP-verzoekmethoden te gebruiken om CRUD-bewerkingen uit te voeren. Er wordt verwacht dat u een standaard gebruikersinterface zult tegenkomen die lijkt op degene die hieronder is afgebeeld:

In plaats van een webbrowser te gebruiken, kan er ook voor gekozen worden om de Postman applicatie te gebruiken voor het testen van en communiceren met API’s.

DRY toepassen bij het maken van een CRUD API

Het toepassen van het programmeerprincipe “DRY” wordt sterk aangeraden om het algehele kaliber van je code te verbeteren. Dit principe, dat staat voor “Don’t Repeat Yourself”, moedigt ontwikkelaars aan om dubbele code te vermijden en in plaats daarvan te streven naar efficiëntie door bestaande componenten te hergebruiken of nieuwe te maken wanneer dat nodig is. Door dit te doen, bespaart men niet alleen tijd, maar zorgt men er ook voor dat hun code consistent en onderhoudbaar blijft in de loop der tijd.

Gezien de eerder besproken perspectieven is het de moeite waard om op te merken dat het gebruik van de ListCreateAPIView en RetrieveUpdateDestroyAPIView generieke views de redundantie in je code aanzienlijk kan verminderen.

De ListCreateAPIView is een combinatie van zowel de ListAPIView als de CreateAPIView, terwijl de RetrieveUpdateDestroyAPIView de functionaliteit voor ophalen van de RetrieveAPIView verenigt met de mogelijkheden voor bijwerken en verwijderen van respectievelijk de UpdateAPIView en DestroyAPIView.

Je kunt je eerdere perspectieven wijzigen door een lay-out aan te nemen die lijkt op het volgende voorbeeld:

 from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView

from .models import Recipe
from .serializers import RecipeSerializer

class RecipeListCreateAPIView(ListCreateAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

class RecipeRetrieveUpdateDeleteAPIView(RetrieveUpdateDestroyAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

Het gebruik van deze methode resulteert in een beknoptere en gestroomlijnde coderingsstructuur, waardoor de opeenhoping van te veel regels code wordt geminimaliseerd.

Om links naar nieuw aangemaakte weergaven te genereren, kun je de volgende stappen volgen:

 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/<int:pk>/', RecipeRetrieveUpdateDeleteAPIView.as_view(), name='recipe-retrieve-update-destroy'),
]

U kunt deze eindpunten evalueren met behulp van een geprefereerde

Generieke class-based views maken uw werk eenvoudiger

Hierboven is aangetoond dat het gebruik van generieke class-based views de procedure voor het bouwen van views kan versnellen. Op dit moment is het enige dat nodig is het erven van de juiste APIView volgens je specifieke toepassing.

Het wordt aanbevolen om goede programmeertechnieken te gebruiken om te voorkomen dat er suboptimale code wordt gemaakt.