Följ den här steg-för-steg-guiden så har du kärnan i ett CRUD API att bygga vidare på.

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

Även om klassbaserade vyer kan vara svåra att arbeta med till en början, erbjuder de fördelar som bättre kodstruktur, återanvändbarhet, arv och koncisthet.

Skapa ett Recept Manager API med Django REST Framework

En recepthanterare-app är ett bra sätt att lära sig om klassbaserade vyer i DRF. Funktioner som att lägga till, ta bort och redigera recept hjälper dig att förstå hur du implementerar CRUD-operationer (Create, Read, Update, Delete). Följande steg kommer att lära dig hur du skapar ett CRUD API.

Du hittar koden för den här guiden på GitHub.

Steg 1: Installera Django REST Framework och konfigurera ditt projekt

  1. Skapa en virtuell miljö för ditt projekt och installera följande beroenden:
    pip install django djangorestframework
    2. instagram viewer
  2. Skapa ett Django-projekt som heter kärna med följande kommando:
    django-admin startproject core .
  3. Skapa en app som heter recepthanterare:
    python manage.py startapp recipe_manager
  4. Öppna din core/settings.py fil och navigera till INSTALLERADE_APPAR lista för att registrera dina appar:
    INSTALLED_APPS = [
    # custom apps
    'rest_framework',
    'recipe_manager',
    ]

Steg 2: Skapa en modell för din receptapp

  1. Öppna din recipe_manager/models.py fil 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
    classRecipe(models.Model):
     recipe_name = models.CharField(max_length=255)
     ingredients = models.TextField()
     instructions = models.TextField()
  2. 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 är en Django-komponent som hjälper dig att konvertera komplexa datatyper, som din frågeuppsättning, till ett format som du kan rendera, som JSON eller XML, och vice versa.

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

  1. Skapa en fil som heter recipe_manager/serializers.py.
  2. Importera serialiserare modul samt modellen du vill serialisera:
    # serializers.py
    from rest_framework import serializers
    from .models import Recipe # the model to serialize
  3. Skapa en serialiseringsklass för din modell i samma fil och definiera Meta klass i den:
    # serializers.py
    classRecipeSerializer(serializers.ModelSerializer):
    classMeta:
     model = Recipe
     fields = ('recipe_name', 'ingredients', 'instructions')
    I den här koden är Meta klass definierar modellen som ska serialiseras och de specifika fält som serializern ska hantera. De fält attribut kan antingen vara en lista eller en tupel. Om du vill serialisera alla fält i din modell kan du göra det så här:
    classMeta:
     fields = "__all__"

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

Du kan skapa klassbaserade vyer för din app genom att importera den allmänna vyn som är tillgänglig i Django. Du kan läsa om dessa synpunkter från Djangos officiella dokumentation. För att implementera CREATE-operationen av CRUD bör du importera Skapa APIView. 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 implementera CREATE-operationen behöver du bara ange vilken serializer som din vy ska använda. Här är ett exempel:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Med den här inställningen kan du göra POST-förfrågningar till din app.

Steg 5: Skriv en vy för LÄS-operationen

  1. För att implementera READ-operationen, importera ListAPIView till dina åsikter. Den här vyn hjälper dig att lista ut modellobjekt:
    # views.py
    from rest_framework.generics import CreateAPIView, ListAPIView
  2. Skapa en klass för dina vyer och ange serializer och frågeuppsättning som ska användas:
    # List view
    classRecipeListView(ListAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()
  3. Skapa en vy för att läsa ett specifikt recept. För att göra detta behöver du Hämta APIView 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
    classRecipeRetrieveView(RetrieveAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()

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

För att implementera UPDATE- och DELETE-operationerna behöver du UppdateraAPIView och Förstör APIView så importera dem:

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

Skapa sedan vyerna, precis som du gjorde tidigare. Den här gången kommer dina åsikter att ärva från UppdateraAPIView och Förstör APIView, respektive:

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

Steg 7: Skapa webbadresser för din app

  1. Lägg till denna kod till core/urls.py för att konfigurera dina webbadresser:
    from django.urls import path, include
    urlpatterns = [
     path('api/', include('recipe_manager.urls'))
    ]
  2. Lägg till följande kod till din recepthanterare/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'),
    ]
    Från ovanstående kod kommer du att se att klassbaserade vyer använder as_view() funktion för att skapa deras URL-mönster. Du kan också läsa om skillnader 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

Detta bör starta din server, utföra några kontroller och skriva ut en URL som du kan komma åt den via.

Du kan nu testa dina API-slutpunkter genom att navigera till respektive URL: er (t.ex. /api/recipes/) och skickar HTTP-begäransmetoder för CRUD-verksamhet. Du bör se ett standardgränssnitt så här:

Istället för att använda din webbläsare kan du testa ditt API med Postman.

Öva på DRY samtidigt som du skapar ett CRUD API

DRY (Don't Repeat Yourself) är en programmeringsprincip du bör anta för att förbättra kvaliteten på din kod.

Även om åsikterna som skrivs ovan fungerar bra, kan du undvika många upprepningar genom att använda ListCreateAPIView och den HämtaUpdateDestroyAPIView allmänna synpunkter.

ListCreateAPIView kombinerar ListAPIView och Skapa APIView, medan RetrieveUpdateDestroyAPIView kombinerar Hämta APIView, UppdateraAPIView, och den Förstör APIView.

Du kan ändra dina tidigare vyer så att de ser ut så här:

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

Detta tillvägagångssätt minskar den totala mängden kod.

Du kan skapa webbadresser för de nya vyerna så här:

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 testa dessa slutpunkter med Postman eller någon annan API-testverktyg du föredrar.

Generiska klassbaserade vyer gör ditt arbete enklare

Som framgår ovan kan generiska klassbaserade vyer påskynda processen att skapa vyer. Nu behöver du bara ärva rätt APIView för ditt användningsfall.

Du bör också se till att du använder bra programmeringsmetoder, så att du inte skriver dålig kod.