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.

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 = (
       
       '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:

    
   from django.db import models
   class Recipe(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:

    
   from rest_framework import serializers
   from .models import Recipe 
    

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

    
   class RecipeSerializer(serializers.ModelSerializer):
       class Meta:
           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:

    class Meta:
   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:

 
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:

 
class RecipeCreateView(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:

    
   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:

    
   class RecipeListView(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:

    
   from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView
    

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

    
   class RecipeRetrieveView(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, 
    DestroyAPIView, 
)
 

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

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

class RecipeDeleteView(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 = (
       
       path('recipes/', views.RecipeListView.as_view(), name='recipe-list'),
       
       path('recipes/create/', views.RecipeCreateView.as_view(), name='recipe-create'),
       
       path('recipes/<int:pk>/', views.RecipeRetrieveView.as_view(), name='recipe-retrieve'),
       
       path('recipes/<int:pk>/update/', views.RecipeUpdateView.as_view(), name='recipe-update'),
       
       path('recipes/<int:pk>/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 as diferenças entre um projeto e um aplicativo no Django se estiver 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/receitas/) e envio de 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 testar sua API com o Postman.

Praticando DRY ao criar uma API CRUD

DRY (Don’t Repeat Yourself) é 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 CriarAPIViewenquanto o RetrieveUpdateDestroyAPIView combina o RecuperarAPIView, AtualizarAPIViewe 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
class RecipeListCreateAPIView(ListCreateAPIView):
    serializer_class = RecipeSerializer
    queryset = Recipe.objects.all()
class RecipeRetrieveUpdateDeleteAPIView(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 = (
    
    path('recipes/', RecipeListCreateAPIView.as_view(), name='recipe-list-create'),
    
    path('recipes/<int:pk>/', RecipeRetrieveUpdateDeleteAPIView.as_view(), name='recipe-retrieve-update-destroy'),
)
 

Você pode testar esses endpoints com Postman ou qualquer ferramenta de teste de API de sua preferência.

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.