Bygg et CRUD REST API med klassebaserte visninger i Django REST Framework

Django Rest Framework (DRF) er et Django-rammeverk som tilbyr støtte for å bygge REST APIer. I likhet med Django lar DRF deg bygge API-visninger med funksjonsbaserte eller klassebaserte visninger.

Selv om klassebaserte visninger kan være vanskelige å jobbe med i begynnelsen, tilbyr de fordeler som bedre kodestruktur, gjenbrukbarhet, arv og konsisthet.

Lag en Recipe Manager API med Django REST Framework

En app for oppskriftsbehandler er en fin måte å lære om klassebaserte visninger i DRF. Funksjoner som å legge til, slette og redigere oppskrifter vil hjelpe deg å forstå hvordan du implementerer CRUD-operasjoner (Create, Read, Update, Delete). De følgende trinnene vil lære deg hvordan du lager en CRUD API.

Du finner koden for denne veiledningen på GitHub.

Trinn 1: Installer Django REST Framework og konfigurer prosjektet ditt

1. Lag et virtuelt miljø for prosjektet ditt og installer følgende avhengigheter:

   pip install django djangorestframework
   

instagram viewer
2. Lag et Django-prosjekt kalt kjerne med følgende kommando:

   django-admin startproject core .
   

3. Lag en app som heter reseptbehandler:

   python manage.py startapp recipe_manager
   

4. Åpne din core/settings.py fil og naviger til INSTALLED_APPS liste for å registrere appene dine:

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

Trinn 2: Lag en modell for oppskriftsappen din

1. Åpne din recipe_manager/models.py fil og lag en modell for appen din. Her er et grunnleggende eksempel på en oppskriftsmodell:

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

2. Opprett migreringer og migrer modellen til databasen med denne kommandoen:

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

Trinn 3: Lag en Serializer for appen din

En serializer er en Django-komponent som hjelper deg med å konvertere komplekse datatyper, slik som spørringssettet ditt, til et format du kan gjengi, som JSON eller XML, og omvendt.

Følg disse trinnene for å lage en serializer:

1. Lag en fil som heter recipe_manager/serializers.py.
2. Importer serializers modul samt modellen du vil serialisere:

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

3. I samme fil oppretter du en serialiseringsklasse for modellen din og definerer Meta klasse i den:

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

   I denne koden er Meta klasse definerer modellen som skal serialiseres og de spesifikke feltene som serializeren skal håndtere. De Enger attributt kan enten være en liste eller en tuppel. Hvis du vil serialisere alle feltene i modellen din, kan du gjøre det slik:

   classMeta:
    fields = "__all__"
   

Trinn 4: Skriv en visning for CREATE-operasjonen

Du kan opprette klassebaserte visninger for appen din ved å importere den generelle visningen som er tilgjengelig i Django. Du kan lese om disse synspunktene fra Djangos offisielle dokumentasjon. For å implementere CREATE-operasjonen til CRUD, bør du importere Opprett APIView. Du bør også importere serializer og modell:

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

For å implementere CREATE-operasjonen trenger du bare å spesifisere serializeren visningen din skal bruke. Her er et eksempel:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Med dette oppsettet kan du sende POST-forespørsler til appen din.

Trinn 5: Skriv en visning for READ-operasjonen

1. For å implementere READ-operasjonen, importer ListAPIView til dine synspunkter. Denne visningen hjelper deg med å liste opp modellobjekter:

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

2. Opprett en klasse for visningene dine og spesifiser serializeren og spørringssettet som skal brukes:

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

3. Lag en visning for å lese en spesifikk oppskrift. For å gjøre dette trenger du Hent APIView så legg den til i listen over importer:

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

   Deretter oppretter du visningen du trenger:

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

Trinn 6: Skriv visninger for OPPDATERING og SLETT-operasjoner

For å implementere OPPDATERING og SLETT-operasjoner, trenger du Oppdater APIView og Ødelegg APIView henholdsvis, så importer dem:

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

Deretter oppretter du visningene, akkurat som du gjorde før. Denne gangen vil dine synspunkter arve fra Oppdater APIView og Ødelegg APIView, henholdsvis:

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

Trinn 7: Lag nettadresser for appen din

1. Legg til denne koden til core/urls.py for å konfigurere URL-ene dine:

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

2. Legg til følgende kode til din recipe_manager/urls.py fil:

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

   Fra koden ovenfor vil du se at klassebaserte visninger bruker as_view() funksjon for å lage URL-mønstrene deres. Du kan også lese om forskjeller mellom et prosjekt og en app i Django hvis du er forvirret over bruken deres her.

Trinn 8: Test API-endepunktene dine

Kjør følgende fra prosjektkatalogen din:

python manage.py runserver

Dette bør starte serveren din, utføre noen kontroller og skrive ut en URL du kan få tilgang til den via.

Du kan nå teste API-endepunktene dine ved å navigere til de respektive URL-ene (f.eks. /api/recipes/) og sender HTTP-forespørselsmetoder for CRUD-operasjoner. Du bør se et standardgrensesnitt som dette:

I stedet for å bruke nettleseren, kan du test API-en din med Postman.

Øver på DRY mens du lager et CRUD API

DRY (Don't Repeat Yourself) er en programmeringsprinsippet du bør ta i bruk for å forbedre kvaliteten på koden din.

Selv om synspunktene som er skrevet ovenfor fungerer bra, kan du unngå mange repetisjoner ved å bruke ListCreateAPIView og HentUpdateDestroyAPIView generiske synspunkter.

ListCreateAPIView kombinerer ListAPIView og Opprett APIView, mens RetrieveUpdateDestroyAPIView kombinerer Hent APIView, Oppdater APIView, og Ødelegg APIView.

Du kan endre dine tidligere visninger slik at de ser slik ut:

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

Denne tilnærmingen reduserer den totale mengden kode.

Du kan opprette nettadresser for de nye visningene slik:

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

Du kan teste disse endepunktene med Postman eller andre API-testverktøy du foretrekker.

Generiske klassebaserte visninger gjør arbeidet ditt enklere

Som sett ovenfor, kan generiske klassebaserte visninger fremskynde prosessen med å opprette visninger. Nå trenger du bare å arve riktig APIView for din brukssituasjon.

Du bør også sørge for at du vedtar god programmeringspraksis, slik at du ikke ender opp med å skrive dårlig kode.