Le développement Web moderne s'appuie de plus en plus sur une séparation nette entre le frontend et le backend. Django REST Framework (DRF) est la bibliothèque de référence pour construire des API robustes avec Django.

1. Paradigmes de développement Web

Il existe deux approches principales :

• Développement hybride (Monolithique) : Le backend génère directement le HTML via des templates (Django Templates).
• Séparation Frontend/Backend : Le back end agit comme un fournisseur de données (souvent au format JSON) via des interfaces de programmation (API).

2. Les 10 principes de l'architecture RESTful

Pour concevoir une API standardisée et intuitive, il est recommandé de suivre ces règles :

1. Sécurité : Utiliser impérativement le protocole HTTPS pour chiffrer les échanges.
2. Identification de l'API : Inclure le mot-clé api dans l'URL (ex: https://api.monsite.com ou /api/).
3. Versionnage : Indiquer la version dans l'URL pour assurer la compatibilité (ex: /v1/, /v2/).
4. Ressources comme Noms : Les points de terminaison doivent utiliser des noms (souvent au pluriel) et non des verbes. Correct : /products/ - Incorrect : /get-all-products/.
5. Méthodes HTTP : Utiliser les verbes standards pour définir l'action :
   • GET : Récupérer des données.
   • POST : Créer une ressource.
   • PUT : Remplacer totalement une ressource.
   • PATCH : Modification partielle.
   • DELETE : Supprimer une ressource.
6. Filtrage et Pagination : Passer les paramètres de recherche via la query string (ex: ?page=2&limit=20).
7. Codes de statut : Retourner les codes HTTP appropriés (200 OK, 201 Created, 400 Bad Request, 403 Forbidden, 404 Not Founnd, 500 Error).
8. Messages d'erreur : Fournir une description claire dans le corps de la réponse en cas d'échec.
9. Format de réponse : Adapter le retour selon l'action (une liste pour un GET sur une collection, un objet pour un POST).
10. Hypermedia (HATEOAS) : Inclure des liens vers les ressources liées pour guider l'utilisateur de l'API.

3. Mise en œuvre rapide avec DRF

Installation du package :

pip install djangorestframework

Configuration dans settings.py :

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

Définition d'un modèle et de son sérialiseur :

# models.py
from django.db import models

class Product(models.Model):
   title = models.CharField(max_length=100)
   cost = models.DecimalField(max_digits=10, decimal_places=2)
   stock = models.IntegerField()

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

class ProductSerializer(serializers.ModelSerializer):
   class Meta:
       model = Product
       fields = '__all__'

Création de la vue et des routes :

# views.py
from rest_framework.viewsets import ModelViewSet
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(ModelViewSet):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer

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

router = DefaultRouter()
router.register(r'products', ProductViewSet)

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

4. Analyse interne : De View à APIView

Dans Django classique, la classe View gère le cycle requête/réponse de base via la méthode dispatch(). DRF introduit APIView, qui étend cette logique pour le monde des API.

Le processus APIView

Lorsqu'une requête arrive sur une vue héritant de APIView :

• Exemption CSRF : Par défaut, APIView désactive la vérification CSRF pour faciliter l'accès programmatique.
• Initialisation de la requête : L'objet HttpRequest de Django est encapsulé dans un objet Request de DRF.
• Composants initiaux : DRF exécute automatiquement trois couches de vérification :
  1. Authentification : Qui est l'utilisateur ?
  2. Permissions : A-t-il le droit d'accéder à cette ressource ?
  3. Limitation (Throttling) : A-t-il dépassé son quota de requêtes ?
• Gestion des erreurs : Toute exception levée est interceptée pour retourner une réponse JSON formatée.

L'objet Request de DRF

L'objet request fourni par DRF est plus puissant que celui de Django :

• request.data : Contient les données envoyées dans le corps de la requête (JSON, form-data), quel que soit le verbe HTTP.
• request.query_params : Un alias plus explicite pour request.GET.
• Accès transparent : DRF utilise __getattr__ pour rediriger les appels vers l'objet HttpRequest original si nécessaire.

# Exemple d'utilisation dans une APIView
from rest_framework.views import APIView
from rest_framework.response import Response

class SampleView(APIView):
   def post(self, request):
       # request.data remplace avantageusement request.POST et la gestion manuelle du JSON
       data = request.data
       return Response({"received_data": data})