Aprender Django Django REST Framework

Django REST Framework

Django REST Framework (DRF) es una biblioteca que extiende las capacidades de Django para crear APIs REST de forma sencilla y eficiente. Mientras que Django está diseñado principalmente para aplicaciones web tradicionales que renderizan HTML, DRF nos permite construir servicios web que intercambian datos en formato JSON, facilitando la comunicación entre aplicaciones frontend y backend.

¿Qué es una API REST?

Una API REST es un conjunto de reglas que permite a diferentes aplicaciones comunicarse entre sí a través de HTTP. En lugar de devolver páginas HTML completas, una API REST devuelve datos estructurados (normalmente en JSON) que pueden ser consumidos por aplicaciones móviles, sitios web con JavaScript, o cualquier otro cliente que necesite acceder a la información.

Los principios fundamentales de REST incluyen el uso de métodos HTTP estándar:

• GET: Para obtener datos
• POST: Para crear nuevos recursos
• PUT/PATCH: Para actualizar recursos existentes
• DELETE: Para eliminar recursos

Instalación y configuración inicial

Para comenzar a trabajar con Django REST Framework, necesitamos instalarlo en nuestro proyecto Django existente:

pip install djangorestframework

Una vez instalado, debemos agregarlo a la lista de aplicaciones instaladas en settings.py:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',  # Agregamos DRF
    'tu_app',
]

Serializadores: el corazón de DRF

Los serializadores son componentes fundamentales en DRF que se encargan de convertir los datos de Django (como instancias de modelos) en formatos que pueden ser fácilmente renderizados en JSON, y viceversa. Funcionan de manera similar a los formularios de Django, pero están diseñados específicamente para APIs.

Supongamos que tenemos un modelo simple de Producto:

## models.py
from django.db import models

class Producto(models.Model):
    nombre = models.CharField(max_length=100)
    precio = models.DecimalField(max_digits=10, decimal_places=2)
    descripcion = models.TextField()
    fecha_creacion = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.nombre

Para crear una API que maneje este modelo, necesitamos un serializador:

## serializers.py
from rest_framework import serializers
from .models import Producto

class ProductoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Producto
        fields = ['id', 'nombre', 'precio', 'descripcion', 'fecha_creacion']

El ModelSerializer es una clase especial que automáticamente genera campos de serialización basados en el modelo de Django, similar a como ModelForm funciona para formularios.

Vistas basadas en clases

Django REST Framework proporciona vistas especializadas que simplifican enormemente la creación de endpoints de API. Las vistas basadas en clases más comunes incluyen:

ViewSets

Los ViewSets agrupan la lógica relacionada para manejar múltiples acciones sobre un recurso:

## views.py
from rest_framework import viewsets
from rest_framework.response import Response
from .models import Producto
from .serializers import ProductoSerializer

class ProductoViewSet(viewsets.ModelViewSet):
    queryset = Producto.objects.all()
    serializer_class = ProductoSerializer

Un ModelViewSet proporciona automáticamente las siguientes acciones:

• list(): GET /productos/ - Lista todos los productos
• create(): POST /productos/ - Crea un nuevo producto
• retrieve(): GET /productos/{id}/ - Obtiene un producto específico
• update(): PUT /productos/{id}/ - Actualiza un producto completo
• partial_update(): PATCH /productos/{id}/ - Actualiza parcialmente un producto
• destroy(): DELETE /productos/{id}/ - Elimina un producto

Configuración de URLs

Para conectar nuestras vistas con las URLs, DRF proporciona routers que automáticamente generan los patrones de URL:

## urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import ProductoViewSet

router = DefaultRouter()
router.register(r'productos', ProductoViewSet)

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

Esta configuración genera automáticamente todas las URLs necesarias para nuestro CRUD completo de productos.

Respuestas JSON automáticas

Una de las ventajas principales de DRF es que maneja automáticamente la serialización a JSON. Cuando un cliente hace una petición a nuestra API, DRF:

• Deserializa los datos JSON entrantes en objetos Python
• Procesa la lógica de negocio
• Serializa la respuesta de vuelta a JSON

Por ejemplo, una petición GET a /api/productos/ devolvería:

[
    {
        "id": 1,
        "nombre": "Laptop Gaming",
        "precio": "1299.99",
        "descripcion": "Laptop para gaming de alta gama",
        "fecha_creacion": "2024-01-15T10:30:00Z"
    },
    {
        "id": 2,
        "nombre": "Mouse Inalámbrico",
        "precio": "29.99",
        "descripcion": "Mouse ergonómico inalámbrico",
        "fecha_creacion": "2024-01-16T14:20:00Z"
    }
]

Validación de datos

Los serializadores también manejan la validación de datos de entrada, similar a como lo hacen los formularios de Django:

class ProductoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Producto
        fields = ['id', 'nombre', 'precio', 'descripcion', 'fecha_creacion']
    
    def validate_precio(self, value):
        if value <= 0:
            raise serializers.ValidationError("El precio debe ser mayor que cero")
        return value
    
    def validate(self, data):
        if len(data['nombre']) < 3:
            raise serializers.ValidationError("El nombre debe tener al menos 3 caracteres")
        return data

Esta validación automática asegura que los datos cumplan con nuestras reglas de negocio antes de ser guardados en la base de datos.

Django REST Framework transforma Django en una plataforma completa para el desarrollo de APIs modernas, manteniendo la simplicidad y elegancia que caracteriza al framework, mientras proporciona todas las herramientas necesarias para crear servicios web robustos y escalables.