Zbuduj API REST CRUD z widokami opartymi na klasach w Django REST Framework

Django Rest Framework (DRF) to framework Django oferujący obsługę tworzenia interfejsów API REST. Podobnie jak Django, DRF umożliwia budowanie widoków API z widokami opartymi na funkcjach lub klasach.

Chociaż na początku praca z widokami opartymi na klasach może być trudna, oferują one korzyści, takie jak lepsza struktura kodu, możliwość ponownego użycia, dziedziczenie i zwięzłość.

Utwórz interfejs API menedżera receptur za pomocą Django REST Framework

Aplikacja do zarządzania przepisami to świetny sposób na poznanie widoków opartych na klasach w DRF. Funkcje takie jak dodawanie, usuwanie i edycja receptur pomogą Ci zrozumieć, jak wdrożyć operacje CRUD (Utwórz, Odczytaj, Aktualizuj, Usuń). Poniższe kroki nauczą Cię, jak utworzyć interfejs API CRUD.

Kod tego przewodnika znajdziesz na stronie GitHub.

Krok 1: Zainstaluj Django REST Framework i skonfiguruj swój projekt

1. Utwórz środowisko wirtualne dla swojego projektu i zainstaluj następujące zależności:
   instagram viewer

   pip install django djangorestframework
   

2. Utwórz projekt Django o nazwie rdzeń za pomocą następującego polecenia:

   django-admin startproject core .
   

3. Utwórz aplikację o nazwie menedżer_przepisów:

   python manage.py startapp recipe_manager
   

4. Otwórz swoje core/settings.py plik i przejdź do ZAINSTALOWANE_APLIKACJE lista do rejestracji aplikacji:

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

Krok 2: Utwórz model aplikacji z przepisami

1. Otwórz swoje menedżer_przepisów/models.py plik i utwórz model swojej aplikacji. Oto podstawowy przykład modelu przepisu:

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

2. Utwórz migracje i migruj swój model do bazy danych za pomocą tego polecenia:

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

Krok 3: Utwórz serializator dla swojej aplikacji

Serializator to komponent Django, który pomaga konwertować złożone typy danych, takie jak zestaw zapytań, do formatu, który można renderować, np. JSON lub XML i odwrotnie.

Aby utworzyć serializator, wykonaj następujące kroki:

1. Utwórz plik o nazwie menedżer_przepisów/serializers.py.
2. Zaimportuj serializatory moduł, a także model, który chcesz serializować:

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

3. W tym samym pliku utwórz klasę serializatora dla swojego modelu i zdefiniuj klasę Meta klasa w tym:

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

   W tym kodzie Meta class definiuje model do serializacji i określone pola, które powinien obsługiwać serializator. The pola atrybut może być listą lub krotką. Jeśli chcesz serializować wszystkie pola w swoim modelu, możesz to zrobić w następujący sposób:

   classMeta:
    fields = "__all__"
   

Krok 4: Napisz widok dla operacji CREATE

Możesz tworzyć widoki oparte na klasach dla swojej aplikacji, importując widok ogólny dostępny w Django. O tych poglądach można przeczytać m.in Oficjalna dokumentacja Django. Aby zaimplementować operację CREATE CRUD, należy zaimportować plik UtwórzAPIView. Powinieneś także zaimportować serializator i model:

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

Aby zaimplementować operację CREATE, wystarczy określić serializator, którego powinien używać widok. Oto przykład:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Dzięki tej konfiguracji możesz wysyłać żądania POST do swojej aplikacji.

Krok 5: Zapisz widok dla operacji READ

1. Aby zaimplementować operację READ, zaimportuj plik ListaAPIView do Twoich poglądów. Ten widok pomaga wyświetlić listę obiektów modelu:

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

2. Utwórz klasę dla swoich widoków i określ serializator i zestaw zapytań, których chcesz użyć:

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

3. Utwórz widok, aby przeczytać konkretny przepis. Aby to zrobić, potrzebujesz PobierzAPIView więc dodaj go do swojej listy importów:

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

   Następnie utwórz widok, którego potrzebujesz:

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

Krok 6: Zapisz widoki dla operacji UPDATE i DELETE

Aby zaimplementować operacje UPDATE i DELETE, potrzebujesz ZaktualizujAPIView I ZniszczAPIView odpowiednio, więc zaimportuj je:

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

Następnie utwórz widoki, tak jak robiłeś to wcześniej. Tym razem Twoje widoki zostaną odziedziczone po ZaktualizujAPIView I ZniszczAPIViewodpowiednio:

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

Krok 7: Utwórz adresy URL swojej aplikacji

1. Dodaj ten kod do core/urls.py aby skonfigurować adresy URL:

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

2. Dodaj następujący kod do swojego menedżer_przepisów/urls.py plik:

   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 powyższego kodu zauważysz, że widoki oparte na klasach korzystają z metody as_view() funkcję tworzenia wzorców adresów URL. Można także przeczytać o różnice pomiędzy projektem a aplikacją w Django jeśli jesteś zdezorientowany ich użyciem tutaj.

Krok 8: Przetestuj punkty końcowe interfejsu API

Z katalogu projektu uruchom następujące polecenie:

python manage.py runserver

Powinno to uruchomić serwer, przeprowadzić kilka kontroli i wydrukować adres URL, za pośrednictwem którego można uzyskać do niego dostęp.

Możesz teraz przetestować punkty końcowe interfejsu API, przechodząc do odpowiednich adresów URL (np. /api/recipes/) i wysyłam Metody żądań HTTP dla operacji CRUD. Powinieneś zobaczyć domyślny interfejs taki jak ten:

Zamiast korzystać z przeglądarki, możesz to zrobić przetestuj swoje API za pomocą Postmana.

Ćwiczenie DRY podczas tworzenia interfejsu API CRUD

SUCHE (nie powtarzaj się) to a zasadę programowania, którą powinieneś przyjąć aby poprawić jakość swojego kodu.

Chociaż widoki napisane powyżej działają dobrze, możesz uniknąć wielu powtórzeń, używając ListaUtwórzAPIView i PobierzUpdateDestroyAPIView poglądy ogólne.

ListCreateAPIView łączy w sobie ListaAPIView I UtwórzAPIView, podczas gdy RetrieveUpdateDestroyAPIView łączy PobierzAPIView, ZaktualizujAPIView, oraz ZniszczAPIView.

Możesz zmodyfikować swoje poprzednie widoki, aby wyglądały tak:

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

Takie podejście zmniejsza ogólną ilość kodu.

Możesz utworzyć adresy URL nowych widoków w następujący sposób:

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

Możesz przetestować te punkty końcowe za pomocą Postmana lub dowolnego innego Narzędzie do testowania API ty preferujesz.

Ogólne widoki oparte na klasach ułatwiają pracę

Jak widać powyżej, ogólne widoki oparte na klasach mogą przyspieszyć proces tworzenia widoków. Teraz wystarczy odziedziczyć odpowiedni widok APIView dla swojego przypadku użycia.

Powinieneś także upewnić się, że stosujesz dobre praktyki programistyczne, aby nie napisać złego kodu.