Crea un'API REST CRUD con visualizzazioni basate su classi nel framework REST Django

Django Rest Framework (DRF) è un framework Django che offre supporto per la creazione di API REST. Come Django, DRF ti consente di creare visualizzazioni API con visualizzazioni basate su funzioni o classi.

Sebbene all'inizio possa essere difficile lavorare con le visualizzazioni basate su classi, offrono vantaggi come una migliore struttura del codice, riusabilità, ereditarietà e concisione.

Crea un'API per la gestione delle ricette con il framework REST Django

Un'app per la gestione delle ricette è un ottimo modo per conoscere le visualizzazioni basate su classi in DRF. Funzionalità come l'aggiunta, l'eliminazione e la modifica delle ricette ti aiuteranno a capire come implementare le operazioni CRUD (Crea, Leggi, Aggiorna, Elimina). I seguenti passaggi ti insegneranno come creare un'API CRUD.

Puoi trovare il codice di questa guida su GitHub.

Passaggio 1: installa Django REST Framework e configura il tuo progetto

1. Crea un ambiente virtuale per il tuo progetto e installa le seguenti dipendenze:

   pip install django djangorestframework
   

2. Crea un progetto Django chiamato nucleo con il seguente comando:

   django-admin startproject core .
   

3. Crea un'app chiamata ricetta_manager:

   python manage.py startapp recipe_manager
   

4. Apri i tuoi core/settings.py file e accedere al file APP_INSTALLATE elenco per registrare le tue app:

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

Passaggio 2: crea un modello per la tua app di ricette

1. Apri i tuoi ricetta_manager/models.py file e crea un modello per la tua app. Ecco un esempio base di un modello di ricetta:

   # 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 migrazioni e migra il tuo modello nel database con questo comando:

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

Passaggio 3: crea un serializzatore per la tua app

Un serializzatore è un componente Django che ti aiuta a convertire tipi di dati complessi, come il tuo set di query, in un formato di cui puoi eseguire il rendering, come JSON o XML, e viceversa.

Per creare un serializzatore, attenersi alla seguente procedura:

1. Crea un file chiamato ricetta_manager/serializers.py.
2. Importa il serializzatori modulo e il modello che desideri serializzare:

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

3. Nello stesso file, crea una classe serializzatore per il tuo modello e definisci il file Meta classe in esso:

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

   In questo codice, il Meta La classe definisce il modello da serializzare e i campi specifici che il serializzatore dovrebbe gestire. IL campi l'attributo può essere una lista o una tupla. Se vuoi serializzare tutti i campi nel tuo modello, puoi farlo in questo modo:

   classMeta:
    fields = "__all__"
   

Passaggio 4: scrivere una vista per l'operazione CREATE

Puoi creare visualizzazioni basate su classi per la tua app importando la visualizzazione generica disponibile in Django. Puoi leggere queste opinioni da La documentazione ufficiale di Django. Per implementare l'operazione CREATE di CRUD, dovresti importare il file CreaVisualizzazioneAPI. Dovresti anche importare il tuo serializzatore e modello:

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

Per implementare l'operazione CREATE, devi solo specificare il serializzatore che la tua vista dovrà utilizzare. Ecco un esempio:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Con questa configurazione puoi effettuare richieste POST alla tua app.

Passaggio 5: scrivere una vista per l'operazione READ

1. Per implementare l'operazione READ, importare il file ListAPIView alle tue opinioni. Questa vista ti aiuta a elencare gli oggetti del modello:

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

2. Crea una classe per le tue visualizzazioni e specifica il serializzatore e il set di query da utilizzare:

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

3. Crea una vista per leggere una ricetta specifica. Per fare questo, è necessario il Recupera APIView quindi aggiungilo al tuo elenco di importazioni:

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

   Successivamente, crea la vista che ti serve:

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

Passaggio 6: scrivere visualizzazioni per le operazioni UPDATE e DELETE

Per implementare le operazioni UPDATE e DELETE è necessario il file AggiornaAPIView E Distruggi APIView rispettivamente, quindi importali:

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

Successivamente, crea le visualizzazioni, proprio come hai fatto prima. Questa volta, le tue visualizzazioni erediteranno da AggiornaAPIView E Distruggi APIView, rispettivamente:

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

Passaggio 7: crea URL per la tua app

1. Aggiungi questo codice a core/urls.py per configurare i tuoi URL:

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

2. Aggiungi il seguente codice al tuo ricetta_manager/urls.py file:

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

   Dal codice precedente, noterai che le visualizzazioni basate su classi utilizzano il metodo come_vista() funzione per creare i propri pattern URL. Puoi anche leggere informazioni su differenze tra un progetto e un'app in Django se sei confuso dal loro utilizzo qui.

Passaggio 8: testa i tuoi endpoint API

Dalla directory del progetto, esegui quanto segue:

python manage.py runserver

Questo dovrebbe avviare il tuo server, eseguire alcuni controlli e stampare un URL tramite il quale puoi accedervi.

Ora puoi testare i tuoi endpoint API accedendo ai rispettivi URL (ad es. /api/recipes/) e invio Metodi di richiesta HTTP per le operazioni CRUD. Dovresti vedere un'interfaccia predefinita come questa:

Invece di utilizzare il browser, puoi testa la tua API con Postman.

Praticare DRY durante la creazione di un'API CRUD

DRY (Non ripeterti) è a principio di programmazione che dovresti adottare per migliorare la qualità del tuo codice.

Sebbene le visualizzazioni scritte sopra funzionino bene, puoi evitare molte ripetizioni utilizzando il file ListCreateAPIView e il Recupera aggiornamentoDestroyAPIView visioni generiche.

ListCreateAPIView combina il file ListAPIView E CreaVisualizzazioneAPI, mentre RetrieveUpdateDestroyAPIView combina il Recupera APIView, AggiornaAPIView, e il Distruggi APIView.

Puoi modificare le visualizzazioni precedenti in questo modo:

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

Questo approccio riduce la quantità complessiva di codice.

Puoi creare URL per le nuove visualizzazioni in questo modo:

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

Puoi testare questi endpoint con Postman o qualsiasi altro Strumento di test dell'API preferisci.

Le visualizzazioni generiche basate su classi semplificano il tuo lavoro

Come visto in precedenza, le visualizzazioni generiche basate su classi possono accelerare il processo di creazione delle visualizzazioni. Ora devi solo ereditare l'APIView corretta per il tuo caso d'uso.

Dovresti anche assicurarti di adottare buone pratiche di programmazione, in modo da non finire per scrivere codice errato.