Zostavte CRUD REST API s triednymi zobrazeniami v Django REST Framework

Django Rest Framework (DRF) je rámec Django, ktorý ponúka podporu pre vytváranie REST API. Rovnako ako Django, aj DRF vám umožňuje zostavovať zobrazenia API pomocou zobrazení založených na funkciách alebo triedach.

Hoci práca s pohľadmi založenými na triedach môže byť spočiatku náročná, ponúkajú výhody ako lepšia štruktúra kódu, opätovná použiteľnosť, dedičnosť a stručnosť.

Vytvorte rozhranie Recipe Manager API s Django REST Framework

Aplikácia na správu receptov je skvelý spôsob, ako sa dozvedieť o zobrazeniach založených na triedach v DRF. Funkcie, ako je pridávanie, mazanie a úprava receptov, vám pomôžu pochopiť, ako implementovať operácie CRUD (Create, Read, Update, Delete). Nasledujúce kroky vás naučia, ako vytvoriť CRUD API.

Kód pre túto príručku nájdete na GitHub.

Krok 1: Nainštalujte Django REST Framework a nakonfigurujte svoj projekt

1. Vytvorte virtuálne prostredie pre svoj projekt a nainštalujte nasledujúce závislosti:

   pip install django djangorestframework
   

instagram viewer
2. Vytvorte projekt Django s názvom jadro s nasledujúcim príkazom:

   django-admin startproject core .
   

3. Vytvorte aplikáciu s názvom recept_manager:

   python manage.py startapp recipe_manager
   

4. Otvor tvoj core/settings.py súbor a prejdite na INSTALLED_APPS zoznam na registráciu aplikácií:

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

Krok 2: Vytvorte model pre svoju aplikáciu receptov

1. Otvor tvoj recept_manager/models.py súbor a vytvorte model pre svoju aplikáciu. Tu je základný príklad modelu receptu:

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

2. Vytvorte migrácie a migrujte svoj model do databázy pomocou tohto príkazu:

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

Krok 3: Vytvorte serializátor pre svoju aplikáciu

Serializátor je komponent Django, ktorý vám pomáha konvertovať zložité typy údajov, ako je napríklad sada dotazov, do formátu, ktorý môžete vykresliť, napríklad JSON alebo XML, a naopak.

Ak chcete vytvoriť serializátor, postupujte takto:

1. Vytvorte súbor s názvom recipe_manager/serializers.py.
2. Importovať serializátory modul, ako aj model, ktorý chcete serializovať:

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

3. V tom istom súbore vytvorte triedu serializátora pre váš model a definujte Meta trieda v ňom:

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

   V tomto kóde je Meta trieda definuje model na serializáciu a špecifické polia, ktoré by mal serializátor spracovávať. The poliach atribút môže byť zoznam alebo n-tica. Ak chcete serializovať všetky polia vo svojom modeli, môžete to urobiť takto:

   classMeta:
    fields = "__all__"
   

Krok 4: Napíšte pohľad pre operáciu CREATE

Pre svoju aplikáciu môžete vytvoriť zobrazenia založené na triedach importovaním všeobecného zobrazenia dostupného v Django. O týchto pohľadoch si môžete prečítať z Djangova oficiálna dokumentácia. Ak chcete implementovať operáciu CREATE CRUD, mali by ste importovať súbor CreateAPIView. Mali by ste tiež importovať váš serializátor a model:

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

Ak chcete implementovať operáciu CREATE, stačí zadať serializátor, ktorý by mal váš pohľad používať. Tu je príklad:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Pomocou tohto nastavenia môžete do svojej aplikácie odosielať požiadavky POST.

Krok 5: Napíšte pohľad pre operáciu READ

1. Ak chcete implementovať operáciu READ, importujte súbor ListAPIView k vašim názorom. Toto zobrazenie vám pomôže vypísať zoznam objektov modelu:

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

2. Vytvorte triedu pre svoje zobrazenia a zadajte serializátor a sadu dotazov, ktoré sa majú použiť:

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

3. Vytvorte zobrazenie na prečítanie konkrétneho receptu. K tomu potrebujete RetrieveAPIView tak si ho pridajte do svojho zoznamu importov:

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

   Ďalej vytvorte požadované zobrazenie:

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

Krok 6: Zapíšte zobrazenia pre operácie UPDATE a DELETE

Na implementáciu operácií UPDATE a DELETE potrebujete UpdateAPIView a DestroyAPIView respektíve ich importujte:

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

Potom vytvorte zobrazenia, rovnako ako predtým. Tentoraz budú vaše názory dediť od UpdateAPIView a DestroyAPIView, respektíve:

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

Krok 7: Vytvorte adresy URL pre svoju aplikáciu

1. Pridajte tento kód do core/urls.py na konfiguráciu vašich URL:

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

2. Pridajte nasledujúci kód do svojho recept_manager/urls.py súbor:

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

   Z vyššie uvedeného kódu si všimnete, že zobrazenia založené na triedach používajú as_view() vytvárať vzory adries URL. Môžete si tiež prečítať o rozdiely medzi projektom a aplikáciou v Django ak ste zmätení ich použitím tu.

Krok 8: Otestujte svoje koncové body API

Z adresára projektu spustite nasledovné:

python manage.py runserver

Toto by malo spustiť váš server, vykonať nejaké kontroly a vytlačiť adresu URL, cez ktorú sa k nemu dostanete.

Teraz môžete otestovať svoje koncové body API tak, že prejdete na príslušné adresy URL (napr. /api/recipes/) a odoslanie Metódy požiadaviek HTTP pre operácie CRUD. Mali by ste vidieť predvolené rozhranie, ako je toto:

Namiesto používania prehliadača môžete otestujte svoje API s Postmanom.

Cvičenie DRY pri vytváraní CRUD API

DRY (Neopakujte sa) je a princíp programovania, ktorý by ste si mali osvojiť na zlepšenie kvality vášho kódu.

Hoci pohľady napísané vyššie fungujú dobre, môžete sa vyhnúť mnohým opakovaniam pomocou ListCreateAPIView a RetrieveUpdateDestroyAPIView všeobecné názory.

ListCreateAPIView kombinuje ListAPIView a CreateAPIView, zatiaľ čo RetrieveUpdateDestroyAPIView kombinuje RetrieveAPIView, UpdateAPIView, a DestroyAPIView.

Svoje predchádzajúce zobrazenia môžete upraviť takto:

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

Tento prístup znižuje celkové množstvo kódu.

Adresy URL pre nové zobrazenia môžete vytvoriť takto:

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

Tieto koncové body môžete otestovať pomocou programu Postman alebo iného Nástroj na testovanie API dávate prednosť.

Všeobecné pohľady založené na triedach vám uľahčia prácu

Ako je vidieť vyššie, všeobecné pohľady založené na triedach môžu urýchliť proces vytvárania pohľadov. Teraz už len musíte zdediť ten správny APIView pre váš prípad použitia.

Mali by ste sa tiež uistiť, že si osvojíte dobré programovacie postupy, aby ste neskončili písaním zlého kódu.