Criando APIs RESTful em Django com Django REST Framework

Django REST Framework (DRF) é um kit de ferramentas poderoso e flexível para construir APIs web. Ele simplifica o processo de criação de APIs RESTful, fornecendo recursos como serializadores, viewsets e mecanismos de autenticação prontos para uso.

Configurando o Django REST Framework

Antes de poder criar uma API RESTful, você precisa instalar o Django REST Framework e adicioná-lo ao seu projeto. Execute o seguinte comando para instalar o DRF:

pip install djangorestframework

Em seguida, adicione 'rest_framework' ao INSTALLED_APPS no seu arquivo settings.py:

INSTALLED_APPS = [
    ...,
    'rest_framework',
]

Criando uma API simples

Vamos criar uma API para um modelo simples chamado Book. O primeiro passo é definir o modelo em models.py:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.CharField(max_length=255)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13)

    def __str__(self):
        return self.title

Após definir o modelo, execute migrações para criar a tabela do banco de dados:

python manage.py makemigrations
python manage.py migrate

Criando um serializador

Serializadores em DRF convertem tipos de dados complexos como modelos Django em JSON. Crie um serializador para o modelo Book:

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'

Construindo visualizações e URLs

O DRF fornece duas maneiras principais de criar visualizações de API: visualizações baseadas em função e visualizações baseadas em classe. Aqui, usamos visualizações baseadas em classe com APIView:

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Book
from .serializers import BookSerializer

class BookListCreateAPIView(APIView):
    def get(self, request):
        books = Book.objects.all()
        serializer = BookSerializer(books, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = BookSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Em seguida, configure URLs para esta visualização em urls.py:

from django.urls import path
from .views import BookListCreateAPIView

urlpatterns = [
    path('books/', BookListCreateAPIView.as_view(), name='book-list-create'),
]

Testando a API

Com o servidor em execução, você pode testar a API em http://127.0.0.1:8000/books/ usando ferramentas como Postman ou curl. Uma solicitação GET recupera todos os livros, e uma solicitação POST permite que você crie um novo livro.

Aprimorando a API com ViewSets

Para um código mais conciso e reutilizável, você pode usar ViewSet e Router do DRF. Veja como atualizar a API para usar um ModelViewSet:

from rest_framework.viewsets import ModelViewSet
from .models import Book
from .serializers import BookSerializer

class BookViewSet(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

Em seguida, configure o roteador em urls.py:

from rest_framework.routers import DefaultRouter
from .views import BookViewSet

router = DefaultRouter()
router.register(r'books', BookViewSet, basename='book')

urlpatterns = router.urls

Conclusão

O Django REST Framework simplifica a criação de APIs RESTful robustas e flexíveis. Ao usar serializadores, visualizações e roteadores, você pode criar APIs que lidam com modelos de dados complexos com facilidade. Com essa base, agora você pode explorar recursos avançados como permissões personalizadas, paginação e autenticação no DRF.