Urmați acest ghid pas cu pas și veți avea nucleul unui API CRUD pe care să construiți în continuare.

Django Rest Framework (DRF) este un cadru Django care oferă suport pentru construirea de API-uri REST. La fel ca Django, DRF vă permite să vă construiți vizualizările API cu vederi bazate pe funcții sau pe clase.

Deși vizualizările bazate pe clasă pot fi dificil de lucrat la început, ele oferă beneficii precum o mai bună structură a codului, reutilizabilitate, moștenire și concizie.

Creați un API Recipe Manager cu Django REST Framework

O aplicație de gestionare a rețetelor este o modalitate excelentă de a afla despre vizualizările bazate pe clasă în DRF. Caracteristici precum adăugarea, ștergerea și editarea rețetelor vă vor ajuta să înțelegeți cum să implementați operațiunile CRUD (Creare, Read, Update, Delete). Următorii pași vă vor învăța cum să creați un API CRUD.

Puteți găsi codul pentru acest ghid pe GitHub.

Pasul 1: Instalați Django REST Framework și configurați-vă proiectul

  1. Creați un mediu virtual pentru proiectul dvs. și instalați următoarele dependențe:
    instagram viewer 
    pip install django djangorestframework
  2. Creați un proiect Django numit miez cu următoarea comandă:
    django-admin startproject core .
  3. Creați o aplicație numită manager_rețete:
    python manage.py startapp recipe_manager
  4. Deschide-ți core/settings.py fișier și navigați la INSTALLED_APPS listă pentru a vă înregistra aplicațiile:
    INSTALLED_APPS = [
    # custom apps
    'rest_framework',
    'recipe_manager',
    ]

Pasul 2: Creați un model pentru aplicația dvs. de rețete

  1. Deschide-ți recipe_manager/models.py fișier și creați un model pentru aplicația dvs. Iată un exemplu de bază de model de rețetă:
    # models.py
    from django.db import models
    classRecipe(models.Model):
     recipe_name = models.CharField(max_length=255)
     ingredients = models.TextField()
     instructions = models.TextField()
  2. Creați migrații și migrați modelul în baza de date cu această comandă:
    python manage.py makemigrations && python manage.py migrate

Pasul 3: Creați un serializator pentru aplicația dvs

Un serializator este o componentă Django care vă ajută să convertiți tipuri de date complexe, cum ar fi setul de interogări, într-un format pe care îl puteți reda, cum ar fi JSON sau XML și invers.

Pentru a crea un serializator, urmați acești pași:

  1. Creați un fișier numit recipe_manager/serializers.py.
  2. Importă serializatoare modul, precum și modelul pe care doriți să îl serializați:
    # serializers.py
    from rest_framework import serializers
    from .models import Recipe # the model to serialize
  3. În același fișier, creați o clasă de serializare pentru modelul dvs. și definiți Meta clasa in ea:
    # serializers.py
    classRecipeSerializer(serializers.ModelSerializer):
    classMeta:
     model = Recipe
     fields = ('recipe_name', 'ingredients', 'instructions')
    În acest cod, Meta clasa definește modelul de serializat și câmpurile specifice pe care serializatorul ar trebui să le gestioneze. The câmpuri atributul poate fi fie o listă, fie un tuplu. Dacă doriți să serializați toate câmpurile din modelul dvs., puteți face acest lucru astfel:
    classMeta:
     fields = "__all__"

Pasul 4: Scrieți o vizualizare pentru operațiunea CREATE

Puteți crea vizualizări bazate pe clasă pentru aplicația dvs. importând vizualizarea generică disponibilă în Django. Puteți citi despre aceste opinii din Documentația oficială a lui Django. Pentru a implementa operația CREATE a CRUD, ar trebui să importați fișierul CreateAPIView. De asemenea, ar trebui să importați serializatorul și modelul dvs.:

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

Pentru a implementa operația CREATE, trebuie doar să specificați serializatorul pe care ar trebui să-l folosească vizualizarea dvs. Iată un exemplu:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Cu această configurare, puteți face solicitări POST către aplicația dvs.

Pasul 5: Scrieți o vizualizare pentru operațiunea READ

  1. Pentru a implementa operația READ, importați fișierul ListAPIView la opiniile tale. Această vizualizare vă ajută să enumerați obiectele model:
    # views.py
    from rest_framework.generics import CreateAPIView, ListAPIView
  2. Creați o clasă pentru vizualizările dvs. și specificați serializatorul și setul de interogări de utilizat:
    # List view
    classRecipeListView(ListAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()
  3. Creați o vizualizare pentru a citi o anumită rețetă. Pentru a face acest lucru, aveți nevoie de PreluațiAPIView așa că adăugați-l la lista dvs. de importuri:
    # views.py
    from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView
    Apoi, creați vizualizarea de care aveți nevoie:
    # Retrieve view
    classRecipeRetrieveView(RetrieveAPIView):
     serializer_class = RecipeSerializer
     queryset = Recipe.objects.all()

Pasul 6: Scrieți vizualizările pentru operațiunile UPDATE și DELETE

Pentru a implementa operațiunile UPDATE și DELETE, aveți nevoie de ActualizațiAPIView și DestroyAPIView respectiv, deci importați-le:

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

Apoi, creați vizualizările, așa cum ați făcut înainte. De data aceasta, opiniile voastre vor moșteni de la ActualizațiAPIView și DestroyAPIView, respectiv:

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

Pasul 7: creați adrese URL pentru aplicația dvs

  1. Adăugați acest cod la core/urls.py pentru a vă configura URL-urile:
    from django.urls import path, include
    urlpatterns = [
     path('api/', include('recipe_manager.urls'))
    ]
  2. Adăugați următorul cod la dvs recipe_manager/urls.py fişier:
    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'),
    ]
    Din codul de mai sus, veți observa că vizualizările bazate pe clasă folosesc ca_view() funcția de a-și crea modelele URL. Puteți citi și despre diferențele dintre un proiect și o aplicație în Django dacă sunteți confuz de utilizarea lor aici.

Pasul 8: Testați punctele finale API

Din directorul de proiect, rulați următoarele:

python manage.py runserver

Aceasta ar trebui să pornească serverul dvs., să efectueze câteva verificări și să imprime o adresă URL prin care o puteți accesa.

Acum puteți testa punctele finale API navigând la adresele URL respective (de ex., /api/recipes/) și trimiterea Metode de solicitare HTTP pentru operațiuni CRUD. Ar trebui să vedeți o interfață implicită ca aceasta:

În loc să-ți folosești browserul, poți testați-vă API-ul cu Postman.

Practicarea DRY în timp ce creați un API CRUD

DRY (Nu te repeta) este a principiul de programare pe care ar trebui să îl adoptați pentru a îmbunătăți calitatea codului dvs.

Deși opiniile scrise mai sus funcționează bine, puteți evita o mulțime de repetare folosind ListCreateAPIView si PreluațiUpdateDestroyAPIView vederi generice.

ListCreateAPIView combină ListAPIView și CreateAPIView, în timp ce RetrieveUpdateDestroyAPIView combină PreluațiAPIView, ActualizațiAPIView, si DestroyAPIView.

Puteți modifica vizualizările anterioare astfel încât să arate astfel:

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

Această abordare reduce cantitatea totală de cod.

Puteți crea adrese URL pentru noile vizualizări astfel:

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

Puteți testa aceste puncte finale cu Postman sau oricare Instrument de testare API tu preferi.

Vizualizările generice bazate pe clasă vă fac munca mai ușoară

După cum sa văzut mai sus, vizualizările generice bazate pe clasă pot accelera procesul de creare a vizualizărilor. Acum trebuie doar să moșteniți APIView potrivit pentru cazul dvs. de utilizare.

De asemenea, ar trebui să vă asigurați că adoptați bune practici de programare, astfel încât să nu ajungeți să scrieți cod prost.