Cet article présentera en détail les composants de base de Django REST Framework, y compris les sérialiseurs, les ViewSets, les routeurs, les systèmes d'autorisations et d'authentification, ainsi que les outils de test et de débogage. L'article part des bases et s'approfondit progressivement, dans le but d'aider les lecteurs à maîtriser les compétences de création d'API complexes à l'aide de Django REST Framework.
préface
Définition et objectif du framework Django REST
Le Django REST Framework, souvent abrégé en DRF, est une boîte à outils d'API Web puissante et flexible. À l'aide de DRF, les développeurs peuvent rapidement créer des services d'API RESTful évolutifs et maintenables. DRF fournit un ensemble complet d'outils et de modules, y compris l'authentification, les autorisations, la sérialisation, les vues, le routage, etc., pour nous aider à résoudre de nombreux problèmes courants dans le développement Web.
L'objectif principal de DRF est de permettre aux applications Django de créer et de gérer facilement des API. En outre, DRF prête également attention à la navigabilité et à la facilité d'utilisation de l'API, afin que les développeurs puissent accéder et interagir avec l'API via un navigateur Web.
Comparaison du framework Django REST et d'autres frameworks (tels que Flask)
Bien que le framework Django REST et d'autres frameworks Web Python (tels que Flask) partagent le même objectif d'aider les développeurs à créer des applications Web, ils diffèrent par leurs concepts de conception, leurs fonctions et leurs scénarios d'utilisation.
- Concept de conception : DRF est un cadre relativement "lourd" qui fournit un ensemble complet de solutions, y compris des modèles, des vues, des modèles, des formulaires, le routage, l'authentification, les autorisations, etc. Bien que Flask soit plus léger et flexible, il ne fournit que les outils les plus élémentaires et d'autres fonctions doivent être réalisées en installant des extensions.
# Django view示例
from django.http import HttpResponse
def hello_world(request):
return HttpResponse("Hello, World!")
# Flask view示例
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'Fonctions : DRF fournit de nombreuses fonctions intégrées, telles que l'authentification, les autorisations, la sérialisation, la désérialisation, les vues, le routage, etc., qui ont été soigneusement conçues pour que les développeurs puissent se concentrer davantage sur la logique métier plutôt que sur la construction de l'infrastructure. Flask, en revanche, accorde plus d'attention à la flexibilité, ce qui permet aux développeurs de choisir et de personnaliser les fonctions dont ils ont besoin.
Scénario d'utilisation : si votre projet doit créer rapidement une API RESTful, ou doit être étroitement intégré à d'autres parties de Django (telles que ORM, système de modèles, etc.), alors DRF peut être un meilleur choix. Si vous avez besoin de plus de flexibilité ou si vous avez simplement besoin de créer un service Web simple, alors Flask pourrait être mieux adapté.
partie de base
Installation et configuration du framework Django REST
Avant de commencer à utiliser le framework Django REST, vous devez d'abord installer et configurer l'environnement approprié. En supposant que Python et Django sont déjà installés, vous pouvez utiliser pip pour installer DRF :
pip install djangorestframeworkEnsuite, vous devez rest_frameworkajouter à la configuration de votre projet DjangoINSTALLED_APPS :
# settings.py
INSTALLED_APPS = [
...,
'rest_framework',
]De cette façon, nous avons installé et configuré avec succès le framework Django REST, puis nous pouvons commencer à construire notre premier projet DRF.
Un tutoriel de base sur la construction d'un projet de framework Django REST
Dans ce didacticiel, nous allons créer une API simple pour gérer les informations sur les livres. Tout d'abord, nous devons créer une nouvelle application Django :
python manage.py startapp booksEnsuite, nous devons booksdéfinir notre modèle dans l'application :
# models.py
from django.db import models
class Book(models.Model):
title = models.CharField(max_length=200)
author = models.CharField(max_length=100)
published_date = models.DateField()
def __str__(self):
return self.titleEnsuite, nous devons définir le Serializer et le Viewset correspondant :
# serializers.py
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'title', 'author', 'published_date']
# views.py
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer
class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializerEnfin, nous devons urls.pyajouter la route dans :
# urls.py
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from .views import BookViewSet
router = DefaultRouter()
router.register(r'books', BookViewSet)
urlpatterns = [
path('', include(router.urls)),
]Ce qui précède est le processus de construction d'un projet de framework Django REST de base. Dans cet exemple, nous créons une API d'informations sur les livres qui peut effectuer des opérations CRUD.
Composants de base du framework Django REST : sérialiseurs, ensembles de vues, routeurs
Dans l'exemple ci-dessus, nous avons utilisé trois composants principaux de DRF : les sérialiseurs, les ensembles de vues et les routeurs. Voici une brève introduction à ceux-ci :
Sérialiseurs : responsables de la conversion de types de données complexes (tels que les instances de modèle Django) en types de données Python pouvant être rendus au format JSON, XML, etc. En même temps, il peut également être utilisé pour analyser les données dans le format ci-dessus et les convertir en types de données complexes.
Viewsets : une classe pour encapsuler la logique de vue. Semblable à la vue de classe de Django, mais fournit davantage de fonctionnalités liées à REST, telles que les méthodes par défaut GET, POST, PUT, PATCH et DELETE.
Routeurs : responsables de la génération automatique des routes URL. Semblable à URLconf de Django, mais il prend mieux en charge les ensembles de vues de DRF et peut créer automatiquement les routes correspondantes selon les méthodes de l'ensemble de vues.
Dans les sections suivantes, nous allons plonger dans le fonctionnement de ces trois composants et comment les utiliser.
Sérialiseurs
Dans le framework Django REST, les sérialiseurs jouent un rôle essentiel. Ils sont chargés de transformer des types de données complexes, tels que des instances de modèle Django ou des ensembles de requêtes complexes, afin qu'ils puissent être restitués dans des formats transportables tels que JSON ou XML. Dans le même temps, les sérialiseurs sont également chargés de terminer le travail de désérialisation lorsque les données sont reçues, en convertissant les données reçues en types de données Python.
Qu'est-ce que le sérialiseur ?
Serializer est similaire aux classes Form et ModelForm de Django, mais elles contiennent non seulement des fonctions de validation de données simples, mais également des fonctions de conversion de type complexes. Ils peuvent sérialiser des types de données complexes (convertir en types de données de base Python) et désérialiser des données sérialisées (convertir en types de données complexes).
# serializers.py
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'title', 'author', 'published_date']Dans l'exemple ci-dessus, BookSerializeril s'agit d'un Serializer, qui hérite de la classe ModelSerializer et est utilisé pour sérialiser et désérialiser les instances de modèle Book.
Comment fonctionnent les sérialiseurs
Lors de la sérialisation d'objets, les sérialiseurs convertissent d'abord les objets en types de données intégrés de Python, puis convertissent ces types de données dans un format transportable. Lors de la désérialisation, les sérialiseurs effectuent le processus inverse, en convertissant d'abord les données reçues en types de données intégrés de Python, puis en convertissant ces types de données en types de données complexes.
Voici un exemple simple qui montre comment BookSerializersérialiser et désérialiser en utilisant :
# 使用Serializer进行序列化
book = Book.objects.get(id=1)
serializer = BookSerializer(book)
print(serializer.data)
# 输出：{'id': 1, 'title': 'Django for Beginners', 'author': 'William S. Vincent', 'published_date': '2022-07-01'}
# 使用Serializer进行反序列化
data = {'title': 'REST API with Django', 'author': 'William S. Vincent', 'published_date': '2023-07-01'}
serializer = BookSerializer(data=data)
if serializer.is_valid():
book = serializer.save()
print(book)
# 输出：<Book: REST API with Django>Exemples et utilisation des sérialiseurs
Le cas d'utilisation le plus courant des sérialiseurs concerne les vues, pour la sérialisation et la désérialisation des données traitées par les vues.
Par exemple, nous pouvons utiliser Serializer dans la vue pour traiter la requête POST du client et créer un nouveau livre :
# views.py
from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from .models import Book
from .serializers import BookSerializer
class BookList(APIView):
def post(self, request):
serializer = BookSerializer(data=request.data)
if serializer.is_valid():
book = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)Dans l'exemple ci-dessus, nous l'avons utilisé dans la méthode POST de la vue BookSerializerpour désérialiser les données reçues dans une instance de modèle Book et les enregistrer dans la base de données.
Les sérialiseurs sont largement utilisés. Ils peuvent être utilisés non seulement pour la validation et la conversion de données de base, mais également pour des scénarios complexes, tels que le traitement de données imbriquées, de champs personnalisés, de champs dynamiques, etc. Après avoir maîtrisé l'utilisation de base, vous pouvez explorer davantage diverses utilisations avancées des sérialiseurs en fonction de vos besoins.
Ensembles de vues
Dans le framework Django REST, ViewSets est un composant important qui fournit une abstraction de vue de haut niveau, nous permettant d'implémenter plus facilement des interfaces API basées sur les principes RESTful.
Qu'est-ce qu'un ViewSet ?
ViewSet peut être vu comme une collection de plusieurs vues. Dans le framework Django REST, ViewSet est similaire à la vue de classe (Class-Based Views) dans Django, mais il fournit plus de comportements par défaut et des fonctions plus larges, telles que l'implémentation par défaut des opérations GET, POST, PUT, PATCH et DELETE.
# views.py
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer
class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializerDans l'exemple ci-dessus, BookViewSetil s'agit d'un ViewSet. Il hérite de la classe et implémente un ensemble complet d'opérations CRUD ModelViewSetpour le modèle.Book
Comment fonctionnent les ViewSets
ViewSet fonctionne de manière très similaire à la vue de classe de Django. Il mappe la méthode HTTP à la méthode correspondante dans le ViewSet, par exemple la requête GET sera mappée à la méthode listou retrieve, la requête POST sera mappée à createla méthode, les requêtes PUT et PATCH seront mappées à updatela méthode, et le La demande DELETE sera mappée à destroyla méthode.
Voici un exemple simple qui montre comment BookViewSetgérer les requêtes GET et POST en utilisant :
# 使用ViewSet处理GET请求
from rest_framework.test import APIRequestFactory
factory = APIRequestFactory()
request = factory.get('/books/')
response = BookViewSet.as_view({'get': 'list'})(request)
print(response.status_code)
# 输出：200
# 使用ViewSet处理POST请求
request = factory.post('/books/', {'title': 'Django REST Framework', 'author': 'Tom Christie', 'published_date': '2023-07-01'})
response = BookViewSet.as_view({'post': 'create'})(request)
print(response.status_code)
# 输出：201Instance et utilisation des ViewSets
Le scénario d'utilisation le plus courant de ViewSet est dans URLconf, qui est utilisé pour créer des routes d'URL pour les interfaces API.
Par exemple, nous pouvons utiliser dans l'URLconf BookViewSetpour créer des routes d'URL pour l'API Books :
# urls.py
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from .views import BookViewSet
router = DefaultRouter()
router.register(r'books', BookViewSet)
urlpatterns = [
path('', include(router.urls)),
]Dans l'exemple ci-dessus, nous nous sommes enregistrés dans URLconf BookViewSet, et le framework Django REST créera automatiquement BookViewSetun ensemble de routes d'URL pour celui-ci, correspondant aux diverses opérations définies par celui-ci.
L'utilisation de ViewSet est très flexible. Ils peuvent non seulement être utilisés pour implémenter des opérations CRUD de base, mais peuvent également être utilisés pour implémenter une logique complexe, telle que le contrôle des autorisations, le filtrage, la pagination, etc. Après avoir maîtrisé l'utilisation de base, vous pouvez explorer davantage diverses utilisations avancées de ViewSet en fonction de vos besoins.
Routeurs
Dans le framework Django REST, les routeurs fournissent un moyen concis pour les ViewSets de créer et de gérer les configurations d'URL. Grâce aux routeurs, nous pouvons rapidement créer et configurer des URL, réduisant ainsi le travail répétitif.
Qu'est-ce qu'un routeur ?
Le routeur peut créer automatiquement des configurations d'URL pour les ensembles de vues et fournit un ensemble de configurations d'URL standard pour les opérations CRUD pour chaque ensemble de vues. L'utilisation de Router peut grandement améliorer l'efficacité du développement et éviter le travail fastidieux de création manuelle de chaque URL.
Voici un exemple simple utilisant Router :
# urls.py
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from .views import BookViewSet
router = DefaultRouter()
router.register(r'books', BookViewSet)
urlpatterns = [
path('', include(router.urls)),
]Dans l'exemple ci-dessus, nous utilisons DefaultRouter pour créer un routeur, puis appelons sa méthode register pour enregistrer BookViewSet. Cela crée automatiquement un ensemble standard de configurations d'URL pour le BookViewSet.
Comment fonctionnent les routeurs
Lorsque vous enregistrez un ensemble de vues avec Router, ce dernier crée automatiquement une configuration d'URL pour cet ensemble de vues. Cet ensemble de configuration d'URL correspond à chaque méthode de l'ensemble de vues, comme la liste, la création, la récupération, la mise à jour et la destruction.
router = DefaultRouter()
router.register(r'books', BookViewSet)Dans l'exemple ci-dessus, le routeur créera la configuration d'URL suivante pour BookViewSet :
/books/: Correspondant aux méthodes etBookViewSetde , traitant respectivement les requêtes GET et POST ;listcreate/books/{pk}/: Correspondant auxBookViewSetméthodesretrieve,updateetdestroy, gèrent respectivement les requêtes GET, PUT/PATCH et DELETE.
Instance et utilisation du routeur
Dans le framework Django REST, il existe deux routeurs communs : DefaultRouteret SimpleRouter. DefaultRouterfournit une configuration de routage avec une interface de navigateur supplémentaire, tout en SimpleRouterfournissant une configuration de routage de base simple.
L'utilisation de Router est très flexible. Vous pouvez enregistrer autant d'ensembles de vues que vous le souhaitez et vous pouvez utiliser différents routeurs dans différentes applications Django. Après avoir maîtrisé l'utilisation de base, vous pouvez également vous plonger dans la personnalisation du routeur, comme la configuration d'URL personnalisée, le nom d'URL personnalisé, etc.
Autorisations et authentification
Lors de la création d'une API, les autorisations et l'authentification sont très importantes. Elles déterminent si les utilisateurs peuvent accéder à votre API et ce que les utilisateurs peuvent faire. Django REST Framework fournit un système complet d'autorisation et d'authentification, vous permettant de contrôler facilement l'accès des utilisateurs.
agréé
L'authentification est le processus d'établissement de l'identité d'un utilisateur. Django REST Framework prend en charge plusieurs méthodes d'authentification, telles que SessionAuthentication, TokenAuthentication, BasicAuthentication, etc.
Voici un exemple d'utilisation de TokenAuthentication dans une vue :
# views.py
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer
class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
authentication_classes = [TokenAuthentication]
permission_classes = [IsAuthenticated]Dans cet exemple, nous définissons l'attribut authentication_classes pour le BookViewSet, en spécifiant l'utilisation de TokenAuthentication. Lorsqu'un utilisateur demande un BookViewSet, Django REST Framework vérifie que les en-têtes HTTP de la demande contiennent un jeton valide pour déterminer l'identité de l'utilisateur.
autorisations
Les autorisations sont les règles qui déterminent ce qu'un utilisateur authentifié peut faire. Django REST Framework fournit une variété de méthodes de gestion des autorisations, telles que IsAuthenticated, IsAdminUser, IsAuthenticatedOrReadOnly, etc.
Dans l'exemple ci-dessus, nous définissons l'attribut permission_classes pour le BookViewSet, en spécifiant l'utilisation de IsAuthenticated. Cela signifie que seuls les utilisateurs authentifiés peuvent accéder à BookViewSet.
Authentification et autorisations personnalisées
En plus d'utiliser les méthodes d'authentification et de gestion des autorisations fournies par Django REST Framework, vous pouvez également personnaliser l'authentification et les autorisations. L'authentification et les autorisations personnalisées vous permettent de contrôler de manière plus flexible les droits d'accès des utilisateurs.
Voici un exemple de classe d'autorisation personnalisée qui permet uniquement aux auteurs d'accéder à leurs propres livres :
# permissions.py
from rest_framework import permissions
class IsAuthor(permissions.BasePermission):
def has_object_permission(self, request, view, obj):
return obj.author == request.userEnsuite, vous pouvez utiliser cette autorisation personnalisée dans votre vue :
# views.py
from .permissions import IsAuthor
# 其他导入...
class BookViewSet(viewsets.ModelViewSet):
# 其他代码...
permission_classes = [IsAuthenticated, IsAuthor]Dans cet exemple, la classe d'autorisation IsAuthor vérifie chaque demande, et si l'utilisateur demandeur n'est pas l'auteur du livre, la demande sera refusée.
Test et débogage
Les tests et le débogage sont des étapes importantes pour garantir la qualité du code. Django REST Framework fournit un ensemble d'outils pour tester et déboguer les API.
test
Django REST Framework intègre le framework de test de Django et fournit des fonctionnalités supplémentaires pour tester les API. Vous pouvez utiliser la classe APIClient de Django REST Framework pour simuler une requête API, puis inspecter la réponse.
Voici un exemple de test :
# tests.py
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITestCase, APIClient
from .models import Book
class BookTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.book = Book.objects.create(title='Test Book', author='Test Author')
def test_get_book(self):
url = reverse('book-detail', kwargs={'pk': self.book.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['title'], 'Test Book')
self.assertEqual(response.data['author'], 'Test Author')Dans cet exemple, nous créons d'abord un APIClient et une instance Book dans la méthode setUp. Ensuite, dans la méthode test_get_book, nous utilisons APIClient pour effectuer une requête GET, puis vérifions le code d'état et les données de la réponse.
débogage
Django REST Framework fournit une interface de navigateur pour le débogage de l'API. Vous pouvez accéder à l'API directement dans votre navigateur, afficher les données de réponse ou émettre des requêtes POST, PUT, PATCH et DELETE. L'interface du navigateur est très intuitive et constitue un excellent outil pour déboguer l'API.
Pour utiliser l'interface du navigateur, il vous suffit de l'activer dans settings.py :
# settings.py
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': [
'rest_framework.renderers.BrowsableAPIRenderer',
'rest_framework.renderers.JSONRenderer',
# 其他渲染器...
]
}Dans la configuration ci-dessus, nous avons activé le BrowsableAPIRenderer, qui activera l'interface du navigateur. Vous pouvez maintenant accéder à l'API dans votre navigateur.
Déboguer avec des outils
De nombreux outils peuvent vous aider à déboguer votre API, tels que Postman, Insomnia, etc. Ces outils peuvent simuler diverses requêtes HTTP, afficher les détails des requêtes et des réponses, et enregistrer et organiser les requêtes API. Ces outils peuvent être utiles si vous devez effectuer un débogage d'API complexe.
Bien que les tests et le débogage puissent prendre un certain temps, ils sont essentiels à la qualité du code. Lorsque vous écrivez du code, n'oubliez pas d'écrire des tests et de déboguer.
Résumer
Jusqu'à présent, nous avons donné un aperçu détaillé de Django REST Framework. Nous avons commencé par couvrir les bases de Django REST Framework, puis nous nous sommes plongés dans les sérialiseurs, les ViewSets et les routeurs. Nous avons également discuté du système d'autorisations et d'authentification, et de la manière de le tester et de le déboguer.
Django REST Framework fournit de nombreux outils puissants qui facilitent la création d'API complexes. Cependant, maîtriser ces outils demande du temps et de la pratique. J'espère que cet article vous aidera à démarrer votre voyage Django REST Framework.
Enfin, je tiens à réitérer certains points clés dont nous avons discuté dans l'article :
- Les sérialiseurs sont utilisés pour la sérialisation et la désérialisation des données.
- Les ViewSets sont des classes qui gèrent la logique de vue.
- Les routeurs sont responsables de la génération et de la distribution des URL.
- Django REST Framework fournit un puissant système d'autorisation et d'authentification.
- Vous pouvez utiliser les outils de test et l'interface de débogage de Django REST Framework pour tester et déboguer votre API.
-
Si cela vous est utile, veuillez accorder plus d'attention au compte public WeChat personnel : [Perspective complète de Python] TeahLead_KrisChang, 10+ ans d'expérience dans l'industrie de l'Internet et de l'intelligence artificielle, 10+ ans d'expérience dans la technologie et la gestion d'équipe commerciale, Tongji Software Baccalauréat en ingénierie, maîtrise en gestion de l'ingénierie Fudan, architecte principal du service cloud certifié Aliyun, responsable de l'activité de produits d'IA avec des centaines de millions de revenus.