Construa uma API CRUD REST com visualizações baseadas em classe no Django REST Framework

Django Rest Framework (DRF) é um framework Django que oferece suporte para construção de APIs REST. Assim como o Django, o DRF permite que você construa suas visualizações de API com visualizações baseadas em funções ou classes.

Embora as visualizações baseadas em classes possam ser difíceis de trabalhar no início, elas oferecem benefícios como melhor estrutura de código, capacidade de reutilização, herança e concisão.

Crie uma API Recipe Manager com Django REST Framework

Um aplicativo gerenciador de receitas é uma ótima maneira de aprender sobre visualizações baseadas em classes no DRF. Recursos como adicionar, excluir e editar receitas ajudarão você a entender como implementar operações CRUD (Criar, Ler, Atualizar, Excluir). As etapas a seguir ensinarão como criar uma API CRUD.

Você pode encontrar o código deste guia em GitHub.

Etapa 1: Instale o Django REST Framework e configure seu projeto

1. Crie um ambiente virtual para o seu projeto e instale as seguintes dependências:

   pip install django djangorestframework
   

2. Crie um projeto Django chamado essencial com o seguinte comando:

   django-admin startproject core .
   

3. Crie um aplicativo chamado gerenciador de receitas:

   python manage.py startapp recipe_manager
   

4. Abre o teu núcleo/configurações.py arquivo e navegue até o INSTALLED_APPS list para registrar seus aplicativos:

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

Etapa 2: crie um modelo para seu aplicativo de receitas

1. Abre o teu receita_manager/models.py arquivo e crie um modelo para seu aplicativo. Aqui está um exemplo básico de modelo de receita:

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

2. Crie migrações e migre seu modelo para o banco de dados com este comando:

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

Etapa 3: crie um serializador para seu aplicativo

Um serializador é um componente do Django que ajuda a converter tipos de dados complexos, como seu conjunto de consultas, em um formato que você pode renderizar, como JSON ou XML, e vice-versa.

Para criar um serializador, siga estas etapas:

1. Crie um arquivo chamado receita_manager/serializers.py.
2. Importe o serializadores módulo, bem como o modelo que você deseja serializar:

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

3. No mesmo arquivo, crie uma classe serializadora para seu modelo e defina o meta classe nele:

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

   Neste código, o meta class define o modelo a ser serializado e os campos específicos que o serializador deve manipular. O Campos O atributo pode ser uma lista ou uma tupla. Se quiser serializar todos os campos do seu modelo, você pode fazer assim:

   classMeta:
    fields = "__all__"
   

Etapa 4: escrever uma visualização para a operação CREATE

Você pode criar visualizações baseadas em classes para seu aplicativo importando a visualização genérica disponível no Django. Você pode ler sobre essas visualizações em Documentação oficial do Django. Para implementar a operação CREATE do CRUD, você deve importar o CriarAPIView. Você também deve importar seu serializador e modelo:

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

Para implementar a operação CREATE, você só precisa especificar o serializador que sua view deve usar. Aqui está um exemplo:

# Create view
classRecipeCreateView(CreateAPIView):
 serializer_class = RecipeSerializer

Com esta configuração, você pode fazer solicitações POST para seu aplicativo.

Etapa 5: escrever uma visualização para a operação READ

1. Para implementar a operação READ, importe o ListaAPIView às suas opiniões. Esta visualização ajuda você a listar os objetos do modelo:

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

2. Crie uma classe para suas visualizações e especifique o serializador e o conjunto de consultas a serem usados:

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

3. Crie uma visualização para ler uma receita específica. Para fazer isso, você precisa do RecuperarAPIView então adicione-o à sua lista de importações:

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

   Em seguida, crie a visualização necessária:

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

Etapa 6: gravar visualizações para as operações UPDATE e DELETE

Para implementar as operações UPDATE e DELETE, você precisa do AtualizarAPIView e DestruirAPIView respectivamente, então importe-os:

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

Em seguida, crie as visualizações, assim como fez antes. Desta vez, suas opiniões herdarão do AtualizarAPIView e DestruirAPIView, respectivamente:

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

Etapa 7: crie URLs para seu aplicativo

1. Adicione este código a núcleo/urls.py para configurar seus URLS:

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

2. Adicione o seguinte código ao seu receita_manager/urls.py arquivo:

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

   No código acima, você observará que as visualizações baseadas em classe usam o como_view() função para criar seus padrões de URL. Você também pode ler sobre diferenças entre um projeto e um aplicativo no Django se você está confuso com o uso deles aqui.

Etapa 8: teste seus endpoints de API

No diretório do seu projeto, execute o seguinte:

python manage.py runserver

Isso deve iniciar seu servidor, realizar algumas verificações e imprimir uma URL pela qual você pode acessá-lo.

Agora você pode testar seus endpoints de API navegando até os respectivos URLs (por exemplo, /api/recipes/) e enviando Métodos de solicitação HTTP para operações CRUD. Você deverá ver uma interface padrão como esta:

Em vez de usar seu navegador, você pode teste sua API com Postman.

Praticando DRY ao criar uma API CRUD

DRY (Não se repita) é um princípio de programação que você deve adotar para melhorar a qualidade do seu código.

Embora as visualizações escritas acima funcionem bem, você pode evitar muitas repetições usando o ListCreateAPIView e a RecuperarUpdateDestroyAPIView visões genéricas.

O ListCreateAPIView combina o ListaAPIView e CriarAPIView, enquanto o RetrieveUpdateDestroyAPIView combina o RecuperarAPIView, AtualizarAPIView, e a DestruirAPIView.

Você pode modificar suas visualizações anteriores para ficar assim:

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

Essa abordagem reduz a quantidade geral de código.

Você pode criar URLs para as novas visualizações assim:

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

Você pode testar esses endpoints com Postman ou qualquer outro Ferramenta de teste de API você prefere.

Visualizações genéricas baseadas em classe facilitam seu trabalho

Como visto acima, visualizações genéricas baseadas em classes podem acelerar o processo de criação de visualizações. Agora você só precisa herdar o APIView correto para o seu caso de uso.

Você também deve garantir a adoção de boas práticas de programação, para não acabar escrevendo código incorreto.