Qué es Django REST Framework y cómo se instala

Django REST Framework es una herramienta que facilita la construcción de APIs RESTful utilizando el entorno de Django. Proporciona clases y funcionalidades que permiten manejar la serialización de datos, autenticación, permisos y más, integrándose de manera natural con aplicaciones Django existentes.

Para instalar Django REST Framework, asegúrate de tener activado tu entorno virtual con Django previamente instalado. Ejecuta el siguiente comando utilizando pip:

pip install djangorestframework

Una vez completada la instalación, es necesario registrar 'rest_framework' en la lista de INSTALLED_APPS dentro del archivo settings.py de tu proyecto:

INSTALLED_APPS = [
    # Aplicaciones de Django
    'django.contrib.admin',
    'django.contrib.auth',
    # ...

    # Aplicaciones de terceros
    'rest_framework',

    # Aplicaciones locales
    # ...
]

Con estos pasos, Django REST Framework quedará integrado en tu proyecto, permitiéndote comenzar a definir serializadores, vistas y rutas específicas para tu API.

Configuración REST en settings.py

Después de instalar Django REST Framework y agregar 'rest_framework' a INSTALLED_APPS, es fundamental ajustar la configuración en settings.py para personalizar el comportamiento de tu API. Esto se logra mediante el diccionario REST_FRAMEWORK, donde se definen parámetros globales que afectan a todas las vistas de tu proyecto.

Para establecer las clases de autenticación predeterminadas, utiliza la clave 'DEFAULT_AUTHENTICATION_CLASSES'. Por ejemplo, si deseas emplear autenticación básica y por tokens:

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication'
    ],
}

Las clases de permisos se configuran mediante 'DEFAULT_PERMISSION_CLASSES', controlando quién puede acceder a las distintas partes de tu API. Si quieres que solo usuarios autenticados tengan acceso:

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
}

Para especificar los renderizadores y parsers por defecto, utiliza 'DEFAULT_RENDERER_CLASSES' y 'DEFAULT_PARSER_CLASSES'. Si tu API solo manejará datos en formato JSON:

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
    ],
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
    ],
}

La configuración de la paginación es esencial para gestionar grandes conjuntos de datos. Con 'DEFAULT_PAGINATION_CLASS' y 'PAGE_SIZE', puedes definir el tipo de paginador y el número de elementos por página:

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 20,
}

Si requieres implementar filtros globales, 'DEFAULT_FILTER_BACKENDS' te permite especificar los backends de filtrado. Por ejemplo, para habilitar la búsqueda y el filtrado por campos:

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
    ],
}

Es importante recordar que estas configuraciones son globales y se aplicarán a todas las vistas de tu API. No obstante, puedes sobrescribir estos valores en vistas específicas si necesitas comportamientos distintos en ciertos endpoints.

Ruteo de endpoints

El ruteo de endpoints en Django REST Framework es esencial para exponer los recursos de tu API. Utiliza el sistema de enrutamiento de Django para mapear URLs a las vistas que procesarán las solicitudes. Es importante organizar las rutas de manera lógica y estructurada para mantener la escalabilidad y mantenibilidad de tu aplicación.

Para comenzar, en el archivo urls.py de tu proyecto principal, debes incluir las rutas de la aplicación que contiene tus endpoints API. Esto se logra utilizando la función include:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('mi_app.api.urls')),
]

En este ejemplo, cualquier solicitud que comience con 'api/' será dirigida al enrutador de la aplicación 'mi_app'. Es buena práctica utilizar un prefijo como 'api/' para diferenciar claramente las rutas de la API del resto de las rutas de tu proyecto.

Dentro de la aplicación 'mi_app', crea un archivo api/urls.py si aún no existe. Aquí definirás las rutas específicas de tus endpoints REST:

from django.urls import path
from .views import lista_elementos, detalle_elemento

urlpatterns = [
    path('elementos/', lista_elementos, name='lista_elementos'),
    path('elementos/<int:id>/', detalle_elemento, name='detalle_elemento'),
]

En este caso, se definen dos rutas:

• 'elementos/': Dirigida a la vista lista_elementos, que manejará operaciones relacionadas con colecciones de elementos.
• 'elementos/<int:id>/': Dirigida a la vista detalle_elemento, que manejará operaciones sobre un elemento específico identificado por su id.

Las rutas pueden incluir convertidores de URL, como <int:id>, que capturan parámetros de la URL y los pasan a la vista correspondiente. Esto es útil para acceder a recursos específicos de manera dinámica.

Es fundamental que las vistas mencionadas en las rutas estén definidas en el archivo views.py de la misma aplicación. Por ejemplo:

from rest_framework.response import Response
from rest_framework.decorators import api_view

@api_view(['GET'])
def lista_elementos(request):
    # Lógica para listar elementos
    return Response({})

@api_view(['GET'])
def detalle_elemento(request, id):
    # Lógica para obtener un elemento específico
    return Response({})

El decorador @api_view de Django REST Framework se utiliza para especificar los métodos HTTP permitidos en cada vista. En este caso, ambas vistas aceptan únicamente el método GET, pero puedes ajustar esto según las necesidades de tu API.

Al definir las rutas, es recomendable nombrarlas utilizando el parámetro name. Esto permite referenciar las URLs de manera más flexible en otras partes de tu código, facilitando el mantenimiento y evitando errores al cambiar las rutas.

Además, si tu API crece en complejidad, es aconsejable utilizar espacios de nombres (namespaces) para organizar mejor las rutas. Puedes modificar la inclusión de las URLs en el archivo principal urls.py de la siguiente manera:

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include(('mi_app.api.urls', 'mi_app'), namespace='mi_app')),
]

Con esta configuración, puedes referirte a las rutas utilizando el namespace, como 'mi_app:lista_elementos'.

Es importante destacar que, aunque Django REST Framework ofrece herramientas más avanzadas para el enrutamiento, como los routers y ViewSets, en este contexto estamos utilizando vistas basadas en funciones para mantener el enfoque en el ruteo básico de endpoints.

Finalmente, asegúrate de que tus rutas sean claras y sigan las convenciones RESTful. Utiliza nombres de recursos en plural para las colecciones y en singular cuando te refieras a elementos individuales. Esto mejora la legibilidad y facilita la comprensión de tu API por parte de otros desarrolladores.

Métodos GET en controladores REST

Los métodos GET son fundamentales en una API REST, ya que permiten recuperar información de los recursos disponibles. En Django REST Framework, puedes manejar solicitudes GET mediante vistas basadas en funciones o clases. A continuación, exploraremos cómo implementar estos métodos utilizando ambas aproximaciones.

Vistas basadas en funciones

Para manejar una solicitud GET en una vista basada en funciones, puedes utilizar el decorador @api_view especificando los métodos permitidos. Por ejemplo:

from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Libro
from .serializers import LibroSerializer


@api_view(["GET"])
def lista_libros(request):
    libros = Libro.objects.all()
    serializer = LibroSerializer(libros, many=True)
    return Response(serializer.data)

En este ejemplo:

• Producto.objects.all() obtiene todos los objetos del modelo Producto.
• ProductoSerializer convierte los objetos de modelo a formatos JSON.
• Response(serializer.data) devuelve los datos serializados al cliente.

Para obtener un producto específico por su ID:

@api_view(['GET'])
def detalle_libro(request, id):
    try:
        libro = Libro.objects.get(pk=id)
    except Libro.DoesNotExist:
        return Response({'error': 'Libro no encontrado'}, status=404)
    serializer = LibroSerializer(libro)
    return Response(serializer.data)

Aquí, se utiliza un manejo de excepciones para responder adecuadamente si el producto no existe, asegurando una respuesta coherente con el estado HTTP correspondiente.

Vistas basadas en clases

Las vistas basadas en clases ofrecen una forma más estructurada y reutilizable de manejar las solicitudes. Django REST Framework proporciona la clase APIView como base:

from rest_framework.views import APIView

class ListaLibros(APIView):
    def get(self, request):
        libros = Libro.objects.all()
        serializer = LibroSerializer(libros, many=True)
        return Response(serializer.data)

Para el detalle de un producto:

class DetalleLibro(APIView):
    def get(self, request, id):
        try:
            libro = Libro.objects.get(pk=id)
        except Libro.DoesNotExist:
            return Response({"error": "Libro no encontrado"}, status=404)
        serializer = LibroSerializer(libro)
        return Response(serializer.data)

Las vistas basadas en clases permiten aprovechar la herencia y el polimorfismo, facilitando la extensibilidad de la API.

Uso de generics

Django REST Framework incluye vistas genéricas que simplifican aún más la creación de endpoints comunes. Para manejar métodos GET, puedes utilizar ListAPIView y RetrieveAPIView:

from rest_framework.generics import ListAPIView, RetrieveAPIView

class ListaLibros(ListAPIView):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer

class DetalleLibro(RetrieveAPIView):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer

Estas clases genéricas manejan automáticamente las operaciones comunes, reduciendo la cantidad de código necesario. Mantienen un código más limpio y enfatizan la configuración sobre la escritura explícita de lógica.

Serializadores

El serializador es una clave para transformar los objetos de modelo en representaciones JSON. Asegúrate de tener un serializador definido en serializers.py:

from rest_framework import serializers
from .models import Libro

class LibroSerializer(serializers.ModelSerializer):
    class Meta:
        model = Libro
        fields = '__all__'

Este serializador convierte todos los campos del modelo Libro, pero puedes especificar campos individuales si es necesario para controlar la exposición de datos.

Gestión de permisos

Para restringir el acceso a tus endpoints, puedes utilizar las clases de permisos. Por ejemplo, para permitir únicamente a usuarios autenticados acceder a los métodos GET:

from rest_framework.permissions import IsAuthenticated

class ListaLibros(APIView):
    permission_classes = [IsAuthenticated]
    
    def get(self, request):
        # Lógica de obtención de libros

Esto garantiza que solo usuarios con credenciales válidas puedan acceder a la información de la API.

Paginación de resultados

Cuando el conjunto de datos es extenso, es recomendable implementar paginación para mejorar el rendimiento y la usabilidad:

from rest_framework.pagination import PageNumberPagination

class PaginacionLibros(PageNumberPagination):
    page_size = 10

class ListaLibros(ListAPIView):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer
    pagination_class = PaginacionLibros

Con esto, los resultados se entregarán en páginas de 10 elementos, evitando cargar todos los datos de una sola vez.

Filtrado y búsqueda

Para ofrecer una API más flexible, puedes agregar capacidades de filtrado y búsqueda:

from rest_framework import filters

class ListaLibros(ListAPIView):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer
    filter_backends = [filters.SearchFilter, filters.OrderingFilter]
    search_fields = ['titulo', 'descripcion']
    ordering_fields = ['publicacion']

Esto permite a los clientes realizar búsquedas por campos específicos y ordenar los resultados según criterios definidos, mejorando la experiencia del usuario.

Respuestas personalizadas

Puedes ajustar las respuestas para incluir metadatos o estructurarlas según tus necesidades:

from rest_framework.response import Response

class ListaLibros(ListAPIView):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer

    def list(self, request):
        queryset = self.get_queryset()
        serializer = self.get_serializer(queryset, many=True)
        data = {
            'total': queryset.count(),
            'libros': serializer.data
        }
        return Response(data)

Al encapsular los datos dentro de un objeto, proporcionas información adicional que puede ser útil para los clientes de la API.

Ejemplo completo de rutas

Finalmente, asegúrate de configurar las rutas en urls.py para acceder a estos controladores:

from django.urls import path
from .views import ListaLibros, DetalleLibro

urlpatterns = [
    path('productos/', ListaLibros.as_view(), name='lista_libros'),
    path('productos/<int:pk>/', DetalleLibro.as_view(), name='detalle_libros'),
]

Con esta configuración, tus endpoints estarán listos para manejar métodos GET, permitiendo a los usuarios consultar información de manera eficiente y segura.