Byg en CRUD REST API med klassebaserede visninger i Django REST Framework

Django Rest Framework (DRF) er en Django-ramme, der tilbyder understøttelse af opbygning af REST API'er. Ligesom Django giver DRF dig mulighed for at bygge dine API-visninger med funktionsbaserede eller klassebaserede visninger.

Selvom klassebaserede visninger kan være svære at arbejde med i starten, tilbyder de fordele som bedre kodestruktur, genbrugelighed, nedarvning og kortfattethed.

Opret en Recipe Manager API med Django REST Framework

En receptmanager-app er en fantastisk måde at lære om klassebaserede visninger i DRF. Funktioner såsom tilføjelse, sletning og redigering af opskrifter hjælper dig med at forstå, hvordan du implementerer CRUD-operationer (Create, Read, Update, Delete). De følgende trin vil lære dig, hvordan du opretter en CRUD API.

Du kan finde koden til denne guide på GitHub.

Trin 1: Installer Django REST Framework og konfigurer dit projekt

1. Opret et virtuelt miljø til dit projekt og installer følgende afhængigheder:

   pip install django djangorestframework
   

instagram viewer
2. Opret et Django-projekt kaldet kerne med følgende kommando:

   django-admin startproject core .
   

3. Opret en app kaldet opskriftsmanager:

   python manage.py startapp recipe_manager
   

4. Åben din core/settings.py fil og naviger til INSTALLERET_APPS liste for at registrere dine apps:

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

Trin 2: Opret en model til din opskriftsapp

1. Åben din recipe_manager/models.py fil og opret en model til din app. Her er et grundlæggende eksempel på en opskriftsmodel:

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

2. Opret migreringer og migrér din model til databasen med denne kommando:

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

Trin 3: Opret en Serializer til din app

En serializer er en Django-komponent, der hjælper dig med at konvertere komplekse datatyper, såsom dit forespørgselssæt, til et format, som du kan gengive, som JSON eller XML, og omvendt.

Følg disse trin for at oprette en serializer:

1. Opret en fil kaldet recipe_manager/serializers.py.
2. Importer serializers modul samt den model, du vil serialisere:

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

3. I den samme fil skal du oprette en serializer-klasse til din model og definere Meta klasse i det:

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

   I denne kode er Meta klasse definerer modellen, der skal serialiseres, og de specifikke felter, som serializeren skal håndtere. Det felter attribut kan enten være en liste eller en tupel. Hvis du vil serialisere alle felterne i din model, kan du gøre det sådan her:

   classMeta:
    fields = "__all__"
   

Trin 4: Skriv en visning til CREATE-handlingen

Du kan oprette klassebaserede visninger til din app ved at importere den generiske visning, der er tilgængelig i Django. Du kan læse om disse synspunkter fra Djangos officielle dokumentation. For at implementere CREATE-operationen af ​​CRUD skal du importere Opret APIView. Du bør også importere din serializer og model:

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

For at implementere CREATE-operationen behøver du kun at angive den serializer, din visning skal bruge. Her er et eksempel:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Med denne opsætning kan du lave POST-anmodninger til din app.

Trin 5: Skriv en visning til READ-handlingen

1. For at implementere READ-handlingen skal du importere ListeAPIView til dine synspunkter. Denne visning hjælper dig med at liste modelobjekter:

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

2. Opret en klasse til dine visninger og angiv den serializer og forespørgselssæt, der skal bruges:

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

3. Opret en visning for at læse en bestemt opskrift. For at gøre dette skal du bruge Hent APIView så føj det til din liste over import:

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

   Opret derefter den visning, du har brug for:

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

Trin 6: Skriv visninger for OPDATERING og SLET-operationerne

For at implementere OPDATERING og SLET-operationerne skal du bruge Opdater APIView og Ødelæg APIView henholdsvis, så importer dem:

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

Opret derefter visningerne, ligesom du gjorde før. Denne gang vil dine synspunkter arve fra Opdater APIView og Ødelæg APIView, henholdsvis:

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

Trin 7: Opret URL'er til din app

1. Tilføj denne kode til core/urls.py for at konfigurere dine URL'er:

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

2. Tilføj 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 ovenstående kode vil du se, at klassebaserede visninger bruger as_view() funktion til at oprette deres URL-mønstre. Du kan også læse om forskelle mellem et projekt og en app i Django hvis du er forvirret over deres brug her.

Trin 8: Test dine API-endepunkter

Kør følgende fra din projektmappe:

python manage.py runserver

Dette bør starte din server, udføre nogle kontroller og udskrive en URL, som du kan få adgang til den via.

Du kan nu teste dine API-endepunkter ved at navigere til de respektive URL'er (f.eks. /api/recipes/) og sender HTTP-anmodningsmetoder til CRUD-operationer. Du bør se en standardgrænseflade som denne:

I stedet for at bruge din browser, kan du test din API med Postman.

Øvelse i DRY, mens du opretter en CRUD API

DRY (Don't Repeat Yourself) er en programmeringsprincip, du bør vedtage for at forbedre kvaliteten af ​​din kode.

Selvom synspunkterne skrevet ovenfor fungerer godt, kan du undgå en masse gentagelser ved at bruge ListCreateAPIView og HentUpdateDestroyAPIView generiske synspunkter.

ListCreateAPIView kombinerer ListeAPIView og Opret APIView, mens RetrieveUpdateDestroyAPIView kombinerer Hent APIView, Opdater APIView, og Ødelæg APIView.

Du kan ændre dine tidligere visninger til at se sådan ud:

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 tilgang reducerer den samlede mængde kode.

Du kan oprette webadresser til de nye visninger på denne måde:

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 endepunkter med Postman eller andre API-testværktøj du foretrækker.

Generiske klassebaserede visninger gør dit arbejde nemmere

Som det ses ovenfor, kan generiske klassebaserede visninger fremskynde processen med at oprette visninger. Nu mangler du kun at arve den rigtige APIView til din use case.

Du bør også sikre dig, at du anvender god programmeringspraksis, så du ikke ender med at skrive dårlig kode.