Изградете CRUD REST API с базирани на клас изгледи в Django REST Framework

Django Rest Framework (DRF) е рамка на Django, която предлага поддръжка за изграждане на REST API. Подобно на Django, DRF ви позволява да създавате своите API изгледи с изгледи, базирани на функции или класове.

Въпреки че в началото може да е трудно да се работи с изгледи, базирани на класове, те предлагат предимства като по-добра структура на кода, повторна употреба, наследяване и стегнатост.

Създайте API за управление на рецепти с Django REST Framework

Приложението за управление на рецепти е чудесен начин да научите за базирани на клас изгледи в DRF. Функции като добавяне, изтриване и редактиране на рецепти ще ви помогнат да разберете как да приложите CRUD (създаване, четене, актуализиране, изтриване) операции. Следващите стъпки ще ви научат как да създадете CRUD API.

Можете да намерите кода за това ръководство на GitHub.

Стъпка 1: Инсталирайте Django REST Framework и конфигурирайте вашия проект

1. Създайте виртуална среда за вашия проект и инсталирайте следните зависимости:

   pip install django djangorestframework
   

2. Създайте Django проект, наречен сърцевина със следната команда:

   django-admin startproject core .
   

3. Създайте приложение, наречено мениджър_на_рецепти:

   python manage.py startapp recipe_manager
   

4. Отвори си core/settings.py файл и отидете до INSTALLED_APPS списък за регистриране на вашите приложения:

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

Стъпка 2: Създайте модел за вашето приложение за рецепти

1. Отвори си recipe_manager/models.py файл и създайте модел за вашето приложение. Ето основен пример за модел на рецепта:

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

2. Създайте миграции и мигрирайте вашия модел в базата данни с тази команда:

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

Стъпка 3: Създайте сериализатор за вашето приложение

Сериализаторът е компонент на Django, който ви помага да конвертирате сложни типове данни, като например вашия набор от заявки, във формат, който можете да визуализирате, като JSON или XML, и обратно.

За да създадете сериализатор, изпълнете следните стъпки:

1. Създайте файл, наречен recipe_manager/serializers.py.
2. Импортирайте сериализатори модул, както и модела, който искате да сериализирате:

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

3. В същия файл създайте клас сериализатор за вашия модел и дефинирайте Мета клас в него:

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

   В този код, Мета клас дефинира модела за сериализиране и специфичните полета, които сериализаторът трябва да обработва. The полета атрибутът може да бъде списък или кортеж. Ако искате да сериализирате всички полета във вашия модел, можете да го направите по следния начин:

   classMeta:
    fields = "__all__"
   

Стъпка 4: Напишете изглед за операцията CREATE

Можете да създадете базирани на клас изгледи за вашето приложение, като импортирате общия изглед, наличен в Django. Можете да прочетете за тези изгледи от Официалната документация на Django. За да приложите операцията CREATE на CRUD, трябва да импортирате Създаване на APIView. Трябва също да импортирате своя сериализатор и модел:

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

За да приложите операцията CREATE, трябва само да посочите сериализатора, който вашият изглед трябва да използва. Ето един пример:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

С тази настройка можете да правите POST заявки към вашето приложение.

Стъпка 5: Напишете изглед за операцията READ

1. За да приложите операцията READ, импортирайте ListAPIView на вашите възгледи. Този изглед ви помага да изброите обектите на модела:

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

2. Създайте клас за вашите изгледи и посочете сериализатора и набора от заявки, които да използвате:

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

3. Създайте изглед, за да прочетете конкретна рецепта. За да направите това, имате нужда от RetrieveAPIView така че го добавете към списъка си с внос:

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

   След това създайте изгледа, от който се нуждаете:

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

Стъпка 6: Напишете изгледи за операциите UPDATE и DELETE

За да приложите операциите UPDATE и DELETE, имате нужда от UpdateAPIView и DestroyAPIView съответно, така че ги импортирайте:

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

След това създайте изгледите, както направихте преди. Този път вашите възгледи ще наследят от UpdateAPIView и DestroyAPIView, съответно:

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

Стъпка 7: Създайте URL адреси за вашето приложение

1. Добавете този код към core/urls.py за да конфигурирате вашите URL адреси:

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

2. Добавете следния код към вашия 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//', 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'),
   ]
   

   От горния код ще забележите, че базираните на клас изгледи използват as_view() функция за създаване на техните URL модели. Можете също да прочетете за разлики между проект и приложение в Django ако сте объркани от използването им тук.

Стъпка 8: Тествайте вашите крайни точки на API

От директорията на вашия проект изпълнете следното:

python manage.py runserver

Това трябва да стартира вашия сървър, да извърши някои проверки и да отпечата URL, чрез който можете да получите достъп до него.

Вече можете да тествате вашите крайни точки на API, като отидете до съответните URL адреси (напр. /api/recipes/) и изпращане Методи за HTTP заявка за CRUD операции. Трябва да видите интерфейс по подразбиране като този:

Вместо да използвате браузъра си, можете тествайте своя API с Postman.

Практикуване на DRY при създаване на CRUD API

DRY (Не се повтаряйте) е a принцип на програмиране, който трябва да приемете за да подобрите качеството на вашия код.

Въпреки че изгледите, написани по-горе, работят добре, можете да избегнете многото повторения, като използвате ListCreateAPIView и на RetrieveUpdateDestroyAPIView общи изгледи.

ListCreateAPIView комбинира ListAPIView и Създаване на APIView, докато RetrieveUpdateDestroyAPIView комбинира RetrieveAPIView, UpdateAPIView, и DestroyAPIView.

Можете да промените предишните си изгледи, за да изглеждат така:

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

Този подход намалява общото количество код.

Можете да създадете URL адреси за новите изгледи по следния начин:

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

Можете да тествате тези крайни точки с Postman или друг Инструмент за тестване на API ти предпочиташ.

Общи изгледи, базирани на клас, улесняват работата ви

Както се вижда по-горе, генеричните базирани на клас изгледи могат да ускорят процеса на създаване на изгледи. Сега трябва само да наследите правилния APIView за вашия случай на употреба.

Трябва също така да се уверите, че възприемате добри практики за програмиране, така че да не пишете лош код.