Volg deze stapsgewijze handleiding en u beschikt over de kern van een CRUD API waarop u verder kunt bouwen.

Django Rest Framework (DRF) is een Django-framework dat ondersteuning biedt voor het bouwen van REST API's. Net als Django kunt u met DRF uw API-weergaven bouwen met functie- of klassengebaseerde weergaven.

Hoewel op klassen gebaseerde weergaven in het begin moeilijk kunnen zijn om mee te werken, bieden ze voordelen zoals een betere codestructuur, herbruikbaarheid, overerving en beknoptheid.

Maak een Recept Manager-API met Django REST Framework

Een app voor receptbeheer is een geweldige manier om meer te leren over op klassen gebaseerde weergaven in DRF. Functies zoals het toevoegen, verwijderen en bewerken van recepten helpen u begrijpen hoe u CRUD-bewerkingen (Create, Read, Update, Delete) kunt implementeren. In de volgende stappen leert u hoe u een CRUD API maakt.

De code voor deze handleiding vindt u op GitHub.

Stap 1: Installeer Django REST Framework en configureer uw project

  1. Creëer een virtuele omgeving voor uw project en installeer de volgende afhankelijkheden:
    instagram viewer 
    pip install django djangorestframework
  2. Maak een Django-project met de naam kern met het volgende commando:
    django-admin startproject core .
  3. Maak een app met de naam recept_manager:
    python manage.py startapp recipe_manager
  4. Open je core/settings.py bestand en navigeer naar het GEÏNSTALLEERDE_APPS lijst om uw apps te registreren:
    INSTALLED_APPS = [
    # custom apps
    'rest_framework',
    'recipe_manager',
    ]

Stap 2: Maak een model voor uw recepten-app

  1. Open je recept_manager/modellen.py bestand en maak een model voor uw app. Hier is een eenvoudig voorbeeld van een receptmodel:
    # models.py
    from django.db import models
    classRecipe(models.Model):
     recipe_name = models.CharField(max_length=255)
     ingredients = models.TextField()
     instructions = models.TextField()
  2. Maak migraties en migreer uw 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 Django-component waarmee u complexe gegevenstypen, zoals uw queryset, kunt converteren naar een indeling die u kunt weergeven, zoals JSON of XML, en omgekeerd.

Volg deze stappen om een ​​serializer te maken:

  1. Maak een bestand met de naam recept_manager/serializers.py.
  2. Importeer de serialisatoren module en het model dat u wilt serialiseren:
    # serializers.py
    from rest_framework import serializers
    from .models import Recipe # the model to serialize
  3. Maak in hetzelfde bestand een serialisatieklasse voor uw model en definieer de Meta klasse erin:
    # serializers.py
    classRecipeSerializer(serializers.ModelSerializer):
    classMeta:
     model = Recipe
     fields = ('recipe_name', 'ingredients', 'instructions')
    In deze code wordt de Meta class definieert het model dat moet worden serialiseerd en de specifieke velden die de serializer moet verwerken. De velden attribuut kan een lijst of een tupel zijn. Als u alle velden in uw model wilt serialiseren, kunt u dit als volgt doen:
    classMeta:
     fields = "__all__"

Stap 4: Schrijf een weergave voor de CREATE-bewerking

U kunt op klassen gebaseerde weergaven voor uw app maken door de algemene weergave te importeren die beschikbaar is in Django. U kunt over deze opvattingen lezen op Django's officiële documentatie. Om de CREATE-bewerking van CRUD te implementeren, moet u het bestand MaakAPIView. U moet ook uw serialisator en model importeren:

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

Om de CREATE-bewerking te implementeren, hoeft u alleen de serializer op te geven die uw weergave moet gebruiken. Hier is een voorbeeld:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Met deze configuratie kunt u POST-verzoeken indienen bij uw app.

Stap 5: Schrijf een weergave voor de READ-bewerking

  1. Om de READ-bewerking te implementeren, importeert u het LijstAPIView naar uw mening. Deze weergave helpt u bij het weergeven van modelobjecten:
    # views.py
    from rest_framework.generics import CreateAPIView, ListAPIView
  2. Maak een klasse voor uw weergaven en geef de serializer en queryset op die u wilt gebruiken:
    # List view
    classRecipeListView(ListAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()
  3. Maak een weergave om een ​​specifiek recept te lezen. Om dit te doen heb je de APIView ophalen dus voeg het toe aan uw importlijst:
    # views.py
    from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView
    Maak vervolgens de gewenste weergave:
    # Retrieve view
    classRecipeRetrieveView(RetrieveAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()

Stap 6: Schrijf weergaven voor de UPDATE- en DELETE-bewerkingen

Om de bewerkingen UPDATE en DELETE te implementeren, hebt u de UpdateAPIView En VernietigAPIView respectievelijk, dus importeer ze:

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

Maak vervolgens de weergaven, net zoals u eerder deed. Deze keer nemen uw standpunten over van de UpdateAPIView En VernietigAPIViewrespectievelijk:

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

Stap 7: Maak URL's voor uw app

  1. Voeg deze code toe aan kern/urls.py om uw URL's te configureren:
    from django.urls import path, include
    urlpatterns = [
     path('api/', include('recipe_manager.urls'))
    ]
  2. Voeg de volgende code toe aan uw recept_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//', 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'),
    ]
    Uit de bovenstaande code kun je zien dat op klassen gebaseerde weergaven de as_view() functie om hun URL-patronen te creëren. Ook kunt u lezen over de verschillen tussen een project en een app in Django als je in de war bent door hun gebruik hier.

Stap 8: Test uw API-eindpunten

Voer vanuit uw projectmap het volgende uit:

python manage.py runserver

Dit zou uw server moeten starten, enkele controles moeten uitvoeren en een URL moeten afdrukken waarmee u er toegang toe hebt.

U kunt nu uw API-eindpunten testen door naar de respectievelijke URL's te navigeren (bijv. /api/recipes/) en verzenden HTTP-verzoekmethoden voor CRUD-operaties. Je zou een standaardinterface als deze moeten zien:

In plaats van uw browser te gebruiken, kunt u dat ook doen test uw API met Postman.

DRY oefenen tijdens het maken van een CRUD API

DRY (Do not Repeat Yourself) is een programmeerprincipe dat u moet toepassen om de kwaliteit van uw code te verbeteren.

Hoewel de hierboven beschreven weergaven goed werken, kunt u veel herhaling voorkomen door de LijstCreateAPIView en de OphalenUpdateVernietigenAPIView generieke opvattingen.

De ListCreateAPIView combineert de LijstAPIView En MaakAPIView, terwijl de RetrieveUpdateDestroyAPIView de APIView ophalen, UpdateAPIView, en de VernietigAPIView.

U kunt uw eerdere weergaven wijzigen zodat deze er als volgt uitzien:

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

Deze aanpak vermindert de totale hoeveelheid code.

U kunt als volgt URL's voor de nieuwe weergaven maken:

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

U kunt deze eindpunten testen met Postman of een ander programma API-testtool u verkiest.

Generieke, op klassen gebaseerde weergaven maken uw werk eenvoudiger

Zoals hierboven gezien, kunnen generieke, op klassen gebaseerde weergaven het proces van het maken van weergaven versnellen. Nu hoeft u alleen nog maar de juiste APIView voor uw gebruiksscenario over te nemen.

Je moet er ook voor zorgen dat je goede programmeerpraktijken toepast, zodat je uiteindelijk geen slechte code schrijft.