Creación de API RESTful en Django con Django REST Framework

Django REST Framework (DRF) es un conjunto de herramientas potente y flexible para crear API web. Simplifica el proceso de creación de API RESTful, proporcionando funciones como serializadores, conjuntos de vistas y mecanismos de autenticación listos para usar.

Configuración del marco REST de Django

Antes de poder crear una API RESTful, debe instalar Django REST Framework y agregarlo a su proyecto. Ejecute el siguiente comando para instalar DRF:

pip install djangorestframework

Luego, agrega 'rest_framework' a INSTALLED_APPS en tu archivo settings.py:

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

Creando una API sencilla

Vamos a crear una API para un modelo simple llamado Book. El primer paso es definir el modelo en 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

Después de definir el modelo, ejecute las migraciones para crear la tabla de base de datos:

python manage.py makemigrations
python manage.py migrate

Creando un serializador

Los serializadores en DRF convierten tipos de datos complejos, como los modelos de Django, en JSON. Cree un serializador para el modelo Book:

from rest_framework import serializers
from .models import Book

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

Creación de vistas y URL

DRF ofrece dos formas principales de crear vistas de API: vistas basadas en funciones y vistas basadas en clases. Aquí, utilizamos vistas basadas en clases con 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)

A continuación, configure las URL para esta vista en urls.py:

from django.urls import path
from .views import BookListCreateAPIView

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

Probando la API

Con el servidor en funcionamiento, puedes probar la API en http://127.0.0.1:8000/books/ utilizando herramientas como Postman o curl. Una solicitud GET recupera todos los libros y una solicitud POST te permite crear un libro nuevo.

Mejorar la API con ViewSets

Para obtener un código más conciso y reutilizable, puede utilizar ViewSet y Router de DRF. A continuación, se muestra cómo actualizar la API para utilizar un 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

Luego, configure el enrutador en urls.py:

from rest_framework.routers import DefaultRouter
from .views import BookViewSet

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

urlpatterns = router.urls

Conclusión

Django REST Framework simplifica la creación de API RESTful robustas y flexibles. Mediante el uso de serializadores, vistas y enrutadores, puede crear API que gestionen modelos de datos complejos con facilidad. Con esta base, ahora puede explorar funciones avanzadas como permisos personalizados, paginación y autenticación en DRF.