CRUD REST API létrehozása osztályalapú nézetekkel a Django REST keretrendszerben

A Django Rest Framework (DRF) egy Django keretrendszer, amely támogatja a REST API-k építését. A Djangohoz hasonlóan a DRF is lehetővé teszi az API-nézetek felépítését függvény- vagy osztály-alapú nézetekkel.

Bár az osztályalapú nézetekkel kezdetben nehéz lehet dolgozni, olyan előnyöket kínálnak, mint a jobb kódstruktúra, az újrafelhasználhatóság, az öröklődés és a tömörség.

Hozzon létre egy Receptkezelő API-t a Django REST Framework segítségével

A receptkezelő alkalmazás nagyszerű módja annak, hogy megismerje az osztályalapú nézeteket a DRF-ben. Az olyan szolgáltatások, mint például a receptek hozzáadása, törlése és szerkesztése, segítenek megérteni, hogyan kell végrehajtani a CRUD (Create, Read, Update, Delete) műveleteket. A következő lépések megtanítják Önnek a CRUD API létrehozását.

Az útmutató kódját itt találja meg GitHub.

1. lépés: Telepítse a Django REST Framework-et, és konfigurálja a projektet

1. Hozzon létre egy virtuális környezetet a projekthez, és telepítse a következő függőségeket:

   pip install django djangorestframework
   

2. Hozzon létre egy Django projektet mag a következő paranccsal:

   django-admin startproject core .
   

3. Hozzon létre egy alkalmazást recept_kezelő:

   python manage.py startapp recipe_manager
   

4. Nyissa meg core/settings.py fájlt, és navigáljon a INSTALLED_APPS lista az alkalmazások regisztrálásához:

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

2. lépés: Hozzon létre egy modellt a receptalkalmazáshoz

1. Nyissa meg recept_manager/models.py fájlt, és hozzon létre egy modellt az alkalmazáshoz. Íme egy egyszerű példa egy receptmodellre:

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

2. Hozzon létre migrációt, és migrálja a modellt az adatbázisba ezzel a paranccsal:

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

3. lépés: Hozzon létre egy szerializálót az alkalmazáshoz

A szerializáló egy Django-összetevő, amely segít az összetett adattípusok, például a lekérdezéskészletek olyan formátumokká alakításában, amelyeket megjeleníthet, például JSON vagy XML, és fordítva.

Szerializáló létrehozásához kövesse az alábbi lépéseket:

1. Hozzon létre egy fájlt, melynek neve recept_manager/serializers.py.
2. Importálja a sorozatkészítők modult, valamint a szerializálni kívánt modellt:

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

3. Ugyanabban a fájlban hozzon létre egy sorosító osztályt a modellhez, és határozza meg a Meta osztály benne:

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

   Ebben a kódban a Meta osztály határozza meg a szerializálandó modellt és azokat a konkrét mezőket, amelyeket a sorosítónak kezelnie kell. A mezőket attribútum lehet egy lista vagy egy sor. Ha a modell összes mezőjét sorosítani szeretné, ezt a következőképpen teheti meg:

   classMeta:
    fields = "__all__"
   

4. lépés: Írjon egy nézetet a CREATE művelethez

Osztályalapú nézeteket hozhat létre az alkalmazáshoz a Djangoban elérhető általános nézet importálásával. Ezekről a nézetekrõl olvashat Django hivatalos dokumentációja. A CRUD CREATE műveletének megvalósításához importálnia kell a CreateAPIView. Ezenkívül importálnia kell a szerializálót és a modellt:

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

A CREATE művelet végrehajtásához csak azt a sorosítót kell megadnia, amelyet a nézetnek használnia kell. Íme egy példa:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Ezzel a beállítással POST-kéréseket küldhet az alkalmazásnak.

5. lépés: Írjon egy nézetet a READ művelethez

1. A READ művelet végrehajtásához importálja a ListAPIView a nézeteidhez. Ez a nézet segít a modellobjektumok felsorolásában:

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

2. Hozzon létre egy osztályt a nézeteihez, és adja meg a használandó sorosítót és lekérdezéskészletet:

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

3. Hozzon létre egy nézetet egy adott recept olvasásához. Ehhez szüksége van a RetrieveAPIView így adja hozzá az importált listához:

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

   Ezután hozza létre a kívánt nézetet:

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

6. lépés: Írjon nézeteket az UPDATE és DELETE műveletekhez

Az UPDATE és DELETE műveletek végrehajtásához szükség van a Frissítse APIView és DestroyAPIView tehát importálja őket:

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

Ezután hozza létre a nézeteket, ugyanúgy, mint korábban. Ezúttal nézetei örökölni fognak a Frissítse APIView és DestroyAPIView, illetve:

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

7. lépés: Hozzon létre URL-eket az alkalmazáshoz

1. Add hozzá ezt a kódot core/urls.py az URL-ek konfigurálásához:

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

2. Adja hozzá a következő kódot a sajátjához recept_manager/urls.py fájl:

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

   A fenti kódból láthatja, hogy az osztályalapú nézetek a as_view() funkciót az URL-minták létrehozásához. Arról is olvashatsz különbségek egy projekt és egy alkalmazás között a Django-ban ha megzavarja az itteni használatuk.

8. lépés: Tesztelje API-végpontjait

A projektkönyvtárból futtassa a következőt:

python manage.py runserver

Ennek el kell indítania a szervert, végre kell hajtania néhány ellenőrzést, és ki kell nyomtatnia egy URL-t, amelyen keresztül elérheti.

Most már tesztelheti API-végpontjait, ha a megfelelő URL-címekre navigál (pl. /api/recipes/) és a küldés HTTP kérési módszerek CRUD műveletekhez. Egy ehhez hasonló alapértelmezett felületet kell látnod:

A böngésző használata helyett megteheti tesztelje API-ját a Postman segítségével.

A DRY gyakorlása CRUD API létrehozása közben

DRY (Ne ismételd magad) a programozási elvet kell elfogadnia hogy javítsa a kódja minőségét.

Bár a fent leírt nézetek jól működnek, a sok ismétlést elkerülheti a ListCreateAPIView és a RetrieveUpdateDestroyAPIView általános nézetek.

A ListCreateAPIView egyesíti a ListAPIView és CreateAPIView, míg a RetrieveUpdateDestroyAPIView egyesíti a RetrieveAPIView, Frissítse APIView, és a DestroyAPIView.

Módosíthatja korábbi nézeteit a következőképpen:

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

Ez a megközelítés csökkenti a kód teljes mennyiségét.

Az új nézetekhez a következőképpen hozhat létre URL-eket:

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

Tesztelheti ezeket a végpontokat a Postman vagy bármely más alkalmazással API tesztelő eszköz inkább.

Az általános osztályalapú nézetek megkönnyítik a munkáját

Mint fentebb látható, az általános osztályalapú nézetek felgyorsíthatják a nézetek létrehozásának folyamatát. Most már csak a használati esetnek megfelelő APIView-t kell örökölnie.

Gondoskodnia kell arról is, hogy jó programozási gyakorlatot alkalmazzon, hogy ne írjon rossz kódot.