Sestavte CRUD REST API s pohledy na základě tříd v Django REST Framework

Django Rest Framework (DRF) je framework Django, který nabízí podporu pro vytváření REST API. Stejně jako Django vám DRF umožňuje vytvářet pohledy API s pohledy založenými na funkcích nebo třídách.

Ačkoli může být zpočátku obtížné pracovat s pohledy založenými na třídách, nabízejí výhody, jako je lepší struktura kódu, opětovná použitelnost, dědičnost a stručnost.

Vytvořte rozhraní Recipe Manager API pomocí Django REST Framework

Aplikace pro správu receptů je skvělý způsob, jak se dozvědět o pohledech založených na třídách v DRF. Funkce jako přidávání, mazání a úpravy receptů vám pomohou porozumět tomu, jak implementovat operace CRUD (Create, Read, Update, Delete). Následující kroky vás naučí, jak vytvořit CRUD API.

Kód tohoto návodu najdete na GitHub.

Krok 1: Nainstalujte Django REST Framework a nakonfigurujte svůj projekt

1. Vytvořte virtuální prostředí pro svůj projekt a nainstalujte následující závislosti:

   pip install django djangorestframework
   

instagram viewer
2. Vytvořte projekt Django s názvem jádro s následujícím příkazem:

   django-admin startproject core .
   

3. Vytvořte aplikaci s názvem správce_receptů:

   python manage.py startapp recipe_manager
   

4. Otevři tvůj core/settings.py soubor a přejděte na INSTALLED_APPS seznam pro registraci aplikací:

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

Krok 2: Vytvořte model pro svou aplikaci receptů

1. Otevři tvůj recept_manager/models.py soubor a vytvořte model pro vaši aplikaci. Zde je základní příklad modelu receptury:

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

2. Vytvořte migrace a migrujte svůj model do databáze pomocí tohoto příkazu:

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

Krok 3: Vytvořte serializátor pro vaši aplikaci

Serializátor je komponenta Django, která vám pomáhá převádět složité datové typy, jako je sada dotazů, do formátu, který můžete vykreslit, jako je JSON nebo XML, a naopak.

Chcete-li vytvořit serializátor, postupujte takto:

1. Vytvořte soubor s názvem recipe_manager/serializers.py.
2. Importujte serializátory modul a také model, který chcete serializovat:

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

3. Ve stejném souboru vytvořte pro svůj model třídu serializátoru a definujte Meta třída v něm:

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

   V tomto kódu je Meta třída definuje model k serializaci a specifická pole, která by měl serializátor zpracovávat. The pole atribut může být seznam nebo n-tice. Pokud chcete serializovat všechna pole ve vašem modelu, můžete to udělat takto:

   classMeta:
    fields = "__all__"
   

Krok 4: Napište pohled pro operaci CREATE

Zobrazení založené na třídách pro svou aplikaci můžete vytvořit importováním obecného zobrazení dostupného v Django. O těchto pohledech si můžete přečíst z Djangova oficiální dokumentace. Chcete-li implementovat operaci CREATE CRUD, měli byste importovat soubor CreateAPIView. Měli byste také importovat svůj serializátor a model:

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

Chcete-li implementovat operaci CREATE, stačí zadat serializátor, který by měl váš pohled používat. Zde je příklad:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

S tímto nastavením můžete do aplikace zadávat požadavky POST.

Krok 5: Napište pohled pro operaci READ

1. Chcete-li implementovat operaci READ, importujte soubor ListAPIView na vaše názory. Toto zobrazení vám pomůže vytvořit seznam objektů modelu:

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

2. Vytvořte třídu pro své pohledy a zadejte serializátor a sadu dotazů, které se mají použít:

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

3. Vytvořte zobrazení pro čtení konkrétního receptu. K tomu potřebujete RetrieveAPIView tak to přidejte do svého seznamu importů:

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

   Dále vytvořte požadovaný pohled:

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

Krok 6: Zápis pohledů pro operace UPDATE a DELETE

Chcete-li implementovat operace UPDATE a DELETE, potřebujete UpdateAPIView a DestroyAPIView respektive, tak je importujte:

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

Dále vytvořte pohledy stejně jako předtím. Tentokrát vaše názory zdědí od UpdateAPIView a DestroyAPIView, respektive:

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

Krok 7: Vytvořte adresy URL pro svou aplikaci

1. Přidejte tento kód do core/urls.py pro konfiguraci vašich URL:

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

2. Přidejte následující kód do svého recept_manager/urls.py soubor:

   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 výše uvedeného kódu zjistíte, že pohledy založené na třídách používají as_view() vytvářet vzory adres URL. Můžete si také přečíst o rozdíly mezi projektem a aplikací v Django pokud jste zmateni jejich použitím zde.

Krok 8: Otestujte své koncové body API

Z adresáře projektu spusťte následující:

python manage.py runserver

To by mělo spustit váš server, provést některé kontroly a vytisknout adresu URL, přes kterou se k němu dostanete.

Nyní můžete otestovat své koncové body API tak, že přejdete na příslušné adresy URL (např. /api/recipes/) a odeslání Metody požadavků HTTP pro operace CRUD. Měli byste vidět výchozí rozhraní, jako je toto:

Namísto použití prohlížeče můžete otestujte své API s Postmanem.

Cvičení DRY při vytváření CRUD API

DRY (Don't Repeat Yourself) je a princip programování, který byste měli přijmout ke zlepšení kvality vašeho kódu.

Ačkoli výše napsané pohledy fungují dobře, můžete se vyhnout mnoha opakování pomocí ListCreateAPIView a RetrieveUpdateDestroyAPIView obecné názory.

ListCreateAPIView kombinuje ListAPIView a CreateAPIView, zatímco RetrieveUpdateDestroyAPIView kombinuje RetrieveAPIView, UpdateAPIViewa DestroyAPIView.

Svá předchozí zobrazení můžete upravit 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 přístup snižuje celkové množství kódu.

Adresy URL pro nové pohledy můžete vytvořit 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'),
]

Tyto koncové body můžete otestovat pomocí Postman nebo jiného Nástroj pro testování API upřednostňuješ.

Obecná zobrazení založená na třídách vám usnadní práci

Jak je vidět výše, generické pohledy založené na třídách mohou urychlit proces vytváření pohledů. Nyní stačí zdědit to správné APIView pro váš případ použití.

Měli byste se také ujistit, že si osvojíte dobré programovací postupy, abyste nakonec nenapsali špatný kód.