Zbuduj CRUD REST API z widokami opartymi na klasach w Django REST Framework
Django Rest Framework (DRF) to framework Django, który oferuje wsparcie dla budowania API REST. Podobnie jak Django, DRF pozwala budować widoki API za pomocą widoków opartych na funkcjach lub klasach.
Podczas gdy widoki oparte na klasach mogą początkowo stanowić stromą krzywą uczenia się, charakteryzują się one kilkoma zaletami, takimi jak lepsza organizacja kodu, zwiększona modułowość poprzez dziedziczenie, zwiększona możliwość ponownego użycia i zwięzłość w wyrażaniu.
Create a Recipe Manager API With Django REST Framework
Aplikacja do zarządzania przepisami służy jako doskonała platforma do eksploracji widoków opartych na klasach w Django Rest Framework (DRF). Włączając funkcje takie jak tworzenie, modyfikowanie i usuwanie receptur, można zrozumieć implementację funkcji CRUD (Create, Read, Update, Delete). Ten przewodnik poinstruuje Cię o tworzeniu interfejsu CRUD poprzez serię kolejnych kroków.
Kod źródłowy tego poradnika jest dostępny do pobrania na platformie GitHub, która służy jako centrum dla programistów do współpracy i dzielenia się swoją pracą z innymi w formie repozytoriów open-source.
Krok 1: Zainstaluj Django REST Framework i skonfiguruj swój projekt
⭐ Stwórz wirtualne środowisko dla swojego projektu i zainstaluj następujące zależności:
pip install django djangorestframework
⭐ Utwórz projekt Django o nazwie core za pomocą następującego polecenia:
django-admin startproject core .
⭐ Stwórz aplikację o nazwie recipe_manager :
python manage.py startapp recipe_manager
⭐ Otwórz plik core/settings.py i przejdź do listy INSTALLED_APPS, aby zarejestrować swoje aplikacje:
INSTALLED_APPS = [
# custom apps
'rest_framework',
'recipe_manager',
]
Krok 2: Stwórz model dla swojej aplikacji recipe
⭐ Otwórz plik recipe_manager/models.py i stwórz model dla swojej aplikacji. Oto podstawowy przykład modelu receptury:
# models.py
from django.db import models
class Recipe(models.Model):
recipe_name = models.CharField(max_length=255)
ingredients = models.TextField()
instructions = models.TextField()
⭐ Utwórz migracje i zmigruj swój model do bazy danych za pomocą tego polecenia:
python manage.py makemigrations && python manage.py migrate
Krok 3: Stwórz serializator dla swojej aplikacji
Serializator służy jako integralna część frameworka Django, ułatwiając konwersję skomplikowanych struktur danych, w tym zestawów zapytań, do formatów odpowiednich do renderowania, obejmujących przykłady takie jak JSON lub XML.
Aby utworzyć serializer, wykonaj następujące kroki:
⭐Utwórz plik o nazwierecipe_manager/serializers.py.
⭐ Zaimportuj moduł serializerów oraz model, który chcesz serializować:
# serializers.py
from rest_framework import serializers
from .models import Recipe # the model to serialize
⭐ W tym samym pliku utwórz klasę serializera dla swojego modelu i zdefiniuj w niej klasę Meta:
# serializers.py
class RecipeSerializer(serializers.ModelSerializer):
class Meta:
model = Recipe
fields = ('recipe_name', 'ingredients', 'instructions')
W tym kodzie klasa Meta definiuje model do serializacji i konkretne pola, które serializator powinien obsługiwać. Atrybut fields może być listą lub krotką. Jeśli chcesz serializować wszystkie pola w modelu, możesz to zrobić w następujący sposób:
class Meta:
fields = "__all__"
Krok 4: Napisz widok dla operacji CREATE
Możesz tworzyć widoki oparte na klasach dla swojej aplikacji, importując ogólny widok dostępny w Django. Możesz przeczytać o tych widokach z oficjalnej dokumentacji Django . Aby zaimplementować operację CREATE CRUD, powinieneś zaimportować CreateAPIView . Powinieneś także zaimportować swój serializator i model:
# views.py
from rest_framework.generics import CreateAPIView
from .models import Recipe
from .serializers import RecipeSerializer
Aby zaimplementować proces tworzenia nowej encji w określonym widoku przy użyciu REST API, wystarczy wyznaczyć konkretną metodę serializacji, którą widok powinien zastosować. Przykładowy przykład można zaobserwować poniżej:
# Create view
class RecipeCreateView(CreateAPIView):
serializer_class = RecipeSerializer
Wykorzystanie tej konfiguracji umożliwia wykonywanie żądań POST do aplikacji.
Krok 5: Napisz widok dla operacji READ
⭐ Aby zaimplementować operację READ, zaimportuj ListAPIView do swoich widoków. Ten widok pomaga wyświetlić listę obiektów modelu:
# views.py
from rest_framework.generics import CreateAPIView, ListAPIView
⭐ Utwórz klasę dla swoich widoków i określ serializator oraz zestaw zapytań do użycia:
# List view
class RecipeListView(ListAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
⭐ Utwórz widok, aby odczytać konkretny przepis. Aby to zrobić, potrzebujesz RetrieveAPIView, więc dodaj go do listy importów:
# views.py
from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView
Następnie utwórz potrzebny widok:
# Retrieve view
class RecipeRetrieveView(RetrieveAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
Krok 6: Napisz widoki dla operacji UPDATE i DELETE
Aby wykonać operacje UPDATE i DELETE, konieczne jest wykorzystanie odpowiednich widoków API, a mianowicie UpdateAPIView i DestroyAPIView . Dlatego widoki te muszą zostać odpowiednio zaimportowane.
from rest_framework.generics import (
ListAPIView,
CreateAPIView,
RetrieveAPIView,
UpdateAPIView, # new
DestroyAPIView, # new
)
Następnie zaimplementujemy niezbędne widoki, które będą dziedziczyć odpowiednio po UpdateAPIView i DestroyAPIView :
# Update view
class RecipeUpdateView(UpdateAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
# Delete view
class RecipeDeleteView(DestroyAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
Krok 7: Tworzenie adresów URL dla aplikacji
⭐ Dodaj ten kod do core/urls.py, aby skonfigurować adresy URL:
from django.urls import path, include
urlpatterns = [
path('api/', include('recipe_manager.urls'))
]
⭐ Dodaj następujący kod do pliku recipe_manager/urls.py:
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/<int:pk>/', views.RecipeRetrieveView.as_view(), name='recipe-retrieve'),
# Update view
path('recipes/<int:pk>/update/', views.RecipeUpdateView.as_view(), name='recipe-update'),
# Delete view
path('recipes/<int:pk>/delete/', views.RecipeDeleteView.as_view(), name='recipe-destroy'),
]
Z powyższego kodu można zauważyć, że widoki oparte na klasach używają funkcji as_view() do tworzenia swoich wzorców URL. Możesz także przeczytać o różnicach między projektem a aplikacją w Django, jeśli jesteś zdezorientowany ich użyciem tutaj.
Krok 8: Przetestuj punkty końcowe API
Z katalogu projektu uruchom następujące polecenie:
python manage.py runserver
Oczekuje się, że ta akcja zainicjuje serwer, wykona określone inspekcje i utworzy adres internetowy umożliwiający zdalny dostęp.
Możesz teraz zweryfikować swoje punkty końcowe API, odwiedzając odpowiadające im identyfikatory URI, takie jak “/api/recipes/”, i wykorzystując różne metody żądań HTTP do wykonywania operacji CRUD. Oczekuje się, że napotkasz standardowy interfejs użytkownika podobny do tego przedstawionego poniżej:
Alternatywnie, zamiast korzystać z przeglądarki internetowej, można zdecydować się na wykorzystanie aplikacji Postman do testowania i interakcji z interfejsami API.
Praktykowanie DRY podczas tworzenia API CRUD
Przyjęcie zasady programowania znanej jako “DRY” jest wysoce zalecane w celu zwiększenia ogólnego kalibru kodu. Zasada ta, która oznacza “Nie powtarzaj się”, zachęca programistów do unikania powielania kodu i zamiast tego dążenia do wydajności poprzez ponowne wykorzystanie istniejących komponentów lub tworzenie nowych w razie potrzeby. W ten sposób nie tylko oszczędza się czas, ale także zapewnia, że ich kod pozostaje spójny i możliwy do utrzymania w czasie.
Biorąc pod uwagę wcześniej omówione perspektywy, warto zauważyć, że wykorzystanie widoków generycznych ListCreateAPIView i RetrieveUpdateDestroyAPIView może znacznie zmniejszyć redundancję w kodzie.
ListCreateAPIView jest połączeniem zarówno ListAPIView jak i CreateAPIView, podczas gdy RetrieveUpdateDestroyAPIView łączy funkcjonalność RetrieveAPIView z możliwościami aktualizacji i usuwania, które można znaleźć odpowiednio w UpdateAPIView i DestroyAPIView.
Można zmienić swoje wcześniejsze perspektywy, przyjmując układ przypominający poniższy przykład:
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
from .models import Recipe
from .serializers import RecipeSerializer
class RecipeListCreateAPIView(ListCreateAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
class RecipeRetrieveUpdateDeleteAPIView(RetrieveUpdateDestroyAPIView):
serializer_class = RecipeSerializer
queryset = Recipe.objects.all()
Wykorzystanie tej metody skutkuje bardziej zwięzłą i usprawnioną strukturą kodowania, minimalizując w ten sposób nagromadzenie nadmiernych linii kodu.
Aby wygenerować linki do nowo utworzonych widoków, można wykonać następujące kroki:
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/<int:pk>/', RecipeRetrieveUpdateDeleteAPIView.as_view(), name='recipe-retrieve-update-destroy'),
]
Możesz ocenić te punkty końcowe przy użyciu preferowanego
Widoki oparte na klasach generycznych ułatwiają pracę
Powyżej wykazano, że wykorzystanie widoków opartych na klasach generycznych może przyspieszyć procedurę konstruowania widoków. Obecnie wszystko, co jest wymagane, to dziedziczenie odpowiedniego widoku APIView zgodnie z konkretną aplikacją.
Zaleca się stosowanie rozsądnych technik programowania, aby zapobiec tworzeniu nieoptymalnego kodu.