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

Django Rest Framework (DRF) é uma estrutura Django que oferece suporte para a construção de APIs REST. Tal como o Django, o DRF permite-lhe construir as suas vistas de API com vistas baseadas em funções ou em classes.

Embora as visualizações baseadas em classe possam apresentar uma curva de aprendizado íngreme inicialmente, elas são caracterizadas por várias vantagens, como organização de código aprimorada, maior modularidade por meio de herança, reutilização aprimorada e sucinta na expressão.

Crie uma API de gerenciamento de receitas com o Django REST Framework

Um aplicativo de gerenciamento de receitas serve como uma excelente plataforma para explorar visualizações baseadas em classe no Django Rest Framework (DRF). Ao incorporar funcionalidades como a criação, modificação e eliminação de receitas, é possível compreender a implementação de funções CRUD (Create, Read, Update, Delete). Este guia irá instruí-lo na conceção de uma interface CRUD através de uma série de passos sequenciais.

O código-fonte deste tutorial está disponível para acesso e download na plataforma GitHub, que serve como um centro para os programadores colaborarem e partilharem o seu trabalho com outros sob a forma de repositórios de código aberto.

Etapa 1: instalar o Django REST Framework e configurar seu projeto

⭐ Crie um ambiente virtual para seu projeto e instale as seguintes dependências:

 pip install django djangorestframework

⭐ Crie um projeto Django chamado core com o seguinte comando:

 django-admin startproject core .

⭐ Crie um aplicativo chamado recipe_manager :

 python manage.py startapp recipe_manager

⭐ Abra seu arquivo core/settings.py e navegue até a lista INSTALLED_APPS para registrar seus aplicativos:

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

Passo 2: Crie um modelo para seu aplicativo de receita

⭐ Abra seu arquivo recipe_manager/models.py e crie um modelo para seu aplicativo. Aqui está um exemplo básico de um modelo de receita:

 # models.py
from django.db import models

class Recipe(models.Model):
    recipe_name = models.CharField(max_length=255)
    ingredients = models.TextField()
    instructions = models.TextField()

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

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

Passo 3: Crie um serializador para seu aplicativo

Um serializador serve como parte integrante do framework Django, facilitando a conversão de estruturas de dados complexas, incluindo conjuntos de consultas, em formatos adequados para renderização, abrangendo exemplos como JSON ou XML.

Para criar um serializador, siga estes passos:

⭐Crie um ficheiro chamadorecipe_manager/serializers.py.

⭐ Importe o módulo de serializadores, bem como o modelo que pretende serializar:

 # serializers.py
from rest_framework import serializers

from .models import Recipe # the model to serialize

⭐ No mesmo ficheiro, crie uma classe de serializador para o seu modelo e defina a classe Meta:

 # serializers.py
class RecipeSerializer(serializers.ModelSerializer):
    class Meta:
        model = Recipe
        fields = ('recipe_name', 'ingredients', 'instructions')

Neste código, a classe Meta define o modelo a serializar e os campos específicos que o serializador deve tratar. O atributo fields pode ser uma lista ou uma tupla. Se quiser serializar todos os campos do seu modelo, pode fazê-lo assim:

 class Meta:
 fields = "__all__"

Passo 4: Escrever uma view para a operação CREATE

Você pode criar views baseadas em classes para seu aplicativo importando a view genérica disponível no Django. Você pode ler sobre essas views na documentação oficial do Django . Para implementar a operação CREATE do CRUD, você deve importar o CreateAPIView . 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 o processo de criação de uma nova entidade dentro de uma view específica usando a API REST, tudo o que é necessário é designar o método de serialização particular que a view deve empregar. Um exemplo demonstrativo disto pode ser observado da seguinte forma:

 # Create view
class RecipeCreateView(CreateAPIView):
    serializer_class = RecipeSerializer

A utilização desta configuração permite a execução de pedidos POST para a sua aplicação.

Etapa 5: Escrever uma view para a operação READ

⭐ Para implementar a operação READ, importe a ListAPIView para suas views. Esta vista ajuda-o a listar os objectos do modelo:

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

⭐ Crie uma classe para as suas vistas e especifique o serializador e o conjunto de consultas a utilizar:

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

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

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

De seguida, crie a vista de que necessita:

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

Passo 6: Escrever vistas para as operações UPDATE e DELETE

Para executar as operações UPDATE e DELETE, é necessário utilizar as respectivas vistas da API, nomeadamente UpdateAPIView e DestroyAPIView . Por conseguinte, estas vistas devem ser importadas em conformidade.

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

Em seguida, implementaremos as exibições necessárias que herdarão tanto de UpdateAPIView quanto de DestroyAPIView , respetivamente:

 # Update view
class RecipeUpdateView(UpdateAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

# Delete view
class RecipeDeleteView(DestroyAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()

Passo 7: Crie URLs para seu aplicativo

⭐ Adicione este código ao core/urls.py para configurar seus URLS:

 from django.urls import path, include

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

⭐ Adicione o seguinte código ao seu arquivo 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'),
]

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

Passo 8: Teste seus endpoints de API

Do seu diretório de projeto, execute o seguinte:

 python manage.py runserver 

Espera-se que essa ação inicie o servidor, execute determinadas inspeções e produza um endereço da Web que permita o acesso remoto.

Pode agora validar os seus pontos de extremidade da API visitando os URIs correspondentes, como “/api/recipes/”, e utilizando vários métodos de pedido HTTP para efetuar operações CRUD. Prevê-se que se depare com uma interface de utilizador padrão semelhante à apresentada abaixo:

Em alternativa, em vez de utilizar um navegador Web, pode optar-se por utilizar a aplicação Postman para testar e interagir com APIs.

Praticando DRY ao criar uma API CRUD

A adoção do princípio de programação conhecido como “DRY” é altamente recomendada para melhorar o calibre geral do seu código. Esse princípio, que significa “Não se repita”, incentiva os desenvolvedores a evitar a duplicação de código e, em vez disso, buscar a eficiência reutilizando componentes existentes ou criando novos quando necessário. Ao fazê-lo, não só se poupa tempo, como também se garante que o código se mantém consistente e passível de manutenção ao longo do tempo.

Considerando as perspectivas discutidas anteriormente, vale a pena notar que a utilização das vistas genéricas ListCreateAPIView e RetrieveUpdateDestroyAPIView pode reduzir significativamente a redundância no seu código.

A ListCreateAPIView é uma combinação da ListAPIView e da CreateAPIView, ao passo que a RetrieveUpdateDestroyAPIView une a funcionalidade de Obtenção da RetrieveAPIView com as capacidades de Atualização e Eliminação encontradas na UpdateAPIView e na DestroyAPIView, respetivamente.

É possível alterar as suas perspectivas anteriores, adoptando um esquema semelhante ao seguinte exemplo:

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

A utilização deste método resulta numa estrutura de codificação mais concisa e simplificada, minimizando assim a acumulação de linhas de código excessivas.

Para gerar ligações para vistas recém-criadas, pode seguir estes passos:

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

Pode avaliar estes pontos de extremidade utilizando um

As vistas genéricas baseadas em classes facilitam o seu trabalho

Acima, foi demonstrado que a utilização de vistas genéricas baseadas em classes pode acelerar o procedimento de construção de vistas. Atualmente, tudo o que é necessário é herdar a APIView apropriada de acordo com a aplicação específica de cada um.

Recomenda-se que siga técnicas de programação correctas para evitar a criação de código não optimizado.