Bygg ett CRUD REST API med klassbaserade vyer i Django REST Framework

Django Rest Framework (DRF) är ett Django-ramverk som erbjuder stöd för att bygga REST API:er. Precis som Django kan du med DRF bygga dina API-vyer med funktionsbaserade eller klassbaserade vyer.

Medan klassbaserade vyer kan ha en brant inlärningskurva i början, kännetecknas de av flera fördelar, såsom förbättrad kodorganisation, ökad modularitet genom arv, förbättrad återanvändbarhet och kortfattat uttryck.

Skapa ett API för recepthanterare med Django REST Framework

En applikation för recepthantering fungerar som en utmärkt plattform för att utforska klassbaserade vyer inom Django Rest Framework (DRF). Genom att införliva funktioner som att skapa, ändra och eliminera recept kan man förstå implementeringen av CRUD-funktioner (Skapa, Läs, Uppdatera, Radera). I den här guiden får du lära dig hur du skapar ett CRUD-gränssnitt genom en rad sekventiella steg.

Källkoden för denna handledning är tillgänglig för åtkomst och nedladdning från GitHub-plattformen, som fungerar som ett nav för utvecklare att samarbeta och dela sitt arbete med andra i form av öppna källkodsarkiv.

Steg 1: Installera Django REST Framework och konfigurera ditt projekt

⭐ Skapa en virtuell miljö för ditt projekt och installera följande beroenden:

 pip install django djangorestframework

⭐ Skapa ett Django-projekt som heter core med följande kommando:

 django-admin startproject core .

⭐ Skapa en app som heter recipe_manager :

 python manage.py startapp recipe_manager

⭐ Öppna filen core/settings.py och navigera till listan INSTALLED_APPS för att registrera dina appar:

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

Steg 2: Skapa en modell för din receptapp

⭐ Öppna filen recipe_manager/models.py och skapa en modell för din app. Här är ett grundläggande exempel på en receptmodell:

 # models.py
from django.db import models

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

⭐ Skapa migreringar och migrera din modell till databasen med det här kommandot:

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

Steg 3: Skapa en serializer för din app

En serializer fungerar som en integrerad del av Django-ramverket och underlättar omvandlingen av komplicerade datastrukturer, inklusive frågeuppsättningar, till format som är lämpliga för rendering, vilket omfattar exempel som JSON eller XML.

Följ dessa steg för att skapa en serializer:

⭐Skapa en fil som heterrecipe_manager/serializers.py.

⭐ Importera serializers-modulen samt den modell du vill serialisera:

 # serializers.py
from rest_framework import serializers

from .models import Recipe # the model to serialize

⭐ I samma fil skapar du en serializer-klass för din modell och definierar Meta-klassen i den:

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

I den här koden definierar Meta-klassen den modell som ska serialiseras och de specifika fält som serialiseraren ska hantera. Attributet fields kan antingen vara en lista eller en tupel. Om du vill serialisera alla fält i din modell kan du göra så här:

 class Meta:
 fields = "__all__"

Steg 4: Skriv en vy för CREATE-operationen

Du kan skapa klassbaserade vyer för din app genom att importera den generiska vyn som finns tillgänglig i Django. Du kan läsa om dessa vyer i Djangos officiella dokumentation . För att implementera CREATE-operationen i CRUD bör du importera CreateAPIView . Du bör också importera din serializer och modell:

 # views.py
from rest_framework.generics import CreateAPIView

from .models import Recipe
from .serializers import RecipeSerializer

För att genomföra processen att skapa en ny entitet i en specifik vy med hjälp av REST API, är allt som krävs att ange den specifika serialiseringsmetod som vyn ska använda. Ett exempel på detta kan ses enligt följande:

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

Genom att använda denna konfiguration kan POST-förfrågningar skickas till din applikation.

Steg 5: Skriv en vy för READ-operationen

⭐ För att implementera READ-operationen importerar du ListAPIView till dina vyer. Den här vyn hjälper dig att lista ut modellobjekt:

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

⭐ Skapa en klass för dina vyer och ange vilken serializer och query set som ska användas:

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

⭐ Skapa en vy för att läsa ett specifikt recept. För att göra detta behöver du RetrieveAPIView så lägg till den i din lista över importer:

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

Skapa sedan den vy du behöver:

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

Steg 6: Skriv vyer för UPDATE- och DELETE-operationerna

För att kunna utföra UPDATE- och DELETE-operationerna är det nödvändigt att använda respektive API-vyer, nämligen UpdateAPIView och DestroyAPIView . Därför måste dessa vyer importeras i enlighet med detta.

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

Därefter ska vi implementera de nödvändiga vyerna som kommer att ärva från både UpdateAPIView och DestroyAPIView , i enlighet med detta:

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

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

Steg 7: Skapa webbadresser för din app

⭐ Lägg till den här koden i core/urls.py för att konfigurera dina webbadresser:

 from django.urls import path, include

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

⭐ Lägg till följande kod i 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/<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'),
]

I koden ovan kan du se att klassbaserade vyer använder funktionen as_view() för att skapa sina URL-mönster. Du kan också läsa om skillnaderna mellan ett projekt och en app i Django om du är förvirrad av deras användning här.

Steg 8: Testa dina API-slutpunkter

Kör följande från din projektkatalog:

 python manage.py runserver 

Denna åtgärd förväntas initiera servern, utföra vissa inspektioner och producera en webbadress som möjliggör fjärråtkomst.

Du kan nu validera dina API-slutpunkter genom att besöka deras motsvarande URI:er, t.ex. “/api/recipes/”, och använda olika HTTP-förfrågningsmetoder för att utföra CRUD-operationer. Det förväntas att du kommer att stöta på ett standardanvändargränssnitt som liknar det som visas nedan:

Istället för att använda en webbläsare kan man välja att använda Postman-applikationen för att testa och interagera med API:er.

Tillämpa DRY när du skapar ett CRUD API

Att tillämpa programmeringsprincipen som kallas “DRY” rekommenderas starkt för att förbättra den övergripande kalibern på din kod. Denna princip, som står för “Don’t Repeat Yourself”, uppmuntrar utvecklare att undvika att duplicera kod och istället sträva efter effektivitet genom att återanvända befintliga komponenter eller skapa nya när det behövs. På så sätt sparar man inte bara tid utan ser också till att koden förblir konsekvent och underhållbar över tid.

Med tanke på de tidigare diskuterade perspektiven är det värt att notera att användning av de generiska vyerna ListCreateAPIView och RetrieveUpdateDestroyAPIView kan minska redundansen i din kod avsevärt.

ListCreateAPIView är en kombination av både ListAPIView och CreateAPIView, medan RetrieveUpdateDestroyAPIView förenar RetrieveAPIViews hämtningsfunktionalitet med uppdaterings- och raderingsfunktionerna i UpdateAPIView respektive DestroyAPIView.

Man kan ändra sina tidigare perspektiv genom att anta en layout som liknar följande exempel:

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

Genom att använda denna metod får man en mer koncis och strömlinjeformad kodningsstruktur, vilket minimerar ackumuleringen av överdrivna kodrader.

För att generera länkar till nyskapade vyer kan du följa dessa steg:

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

Du kan utvärdera dessa ändpunkter med hjälp av en

Generiska klassbaserade vyer gör ditt arbete enklare

Ovan visas att användning av generiska klassbaserade vyer kan påskynda proceduren för att konstruera vyer. För närvarande är allt som krävs att ärva lämplig APIView enligt ens specifika tillämpning.

Det rekommenderas att du följer sunda programmeringstekniker för att förhindra att du skapar suboptimal kod.