RESTful API's maken in Django met Django REST Framework

Django REST Framework (DRF) is een krachtige en flexibele toolkit voor het bouwen van web-API's. Het vereenvoudigt het proces van het maken van RESTful API's en biedt functies zoals serializers, viewsets en authenticatiemechanismen out-of-the-box.

Het Django REST Framework instellen

Voordat u een RESTful API kunt maken, moet u Django REST Framework installeren en toevoegen aan uw project. Voer de volgende opdracht uit om DRF te installeren:

pip install djangorestframework

Voeg vervolgens 'rest_framework' toe aan de INSTALLED_APPS in uw settings.py-bestand:

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

Een eenvoudige API maken

Laten we een API maken voor een eenvoudig model genaamd Book. De eerste stap is om het model te definiëren in 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

Nadat u het model hebt gedefinieerd, voert u migraties uit om de databasetabel te maken:

python manage.py makemigrations
python manage.py migrate

Een serializer maken

Serializers in DRF converteren complexe datatypes zoals Django-modellen naar JSON. Maak een serializer voor het Book-model:

from rest_framework import serializers
from .models import Book

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

Weergaven en URL's bouwen

DRF biedt twee hoofdmanieren om API-weergaven te maken: functiegebaseerde weergaven en klassegebaseerde weergaven. Hier gebruiken we klassegebaseerde weergaven met 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)

Configureer vervolgens de URL's voor deze weergave in urls.py:

from django.urls import path
from .views import BookListCreateAPIView

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

API testen

Met de server draaiende, kunt u de API testen op http://127.0.0.1:8000/books/ met behulp van tools zoals Postman of curl. Een GET-verzoek haalt alle boeken op, en een POST-verzoek stelt u in staat een nieuw boek te maken.

Verbetering van de API met ViewSets

Voor bondigere en herbruikbare code kunt u DRF's ViewSet en Router gebruiken. Hier leest u hoe u de API kunt updaten om een ​​ModelViewSet te gebruiken:

from rest_framework.viewsets import ModelViewSet
from .models import Book
from .serializers import BookSerializer

class BookViewSet(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

Configureer vervolgens de router in urls.py:

from rest_framework.routers import DefaultRouter
from .views import BookViewSet

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

urlpatterns = router.urls

Conclusie

Django REST Framework maakt het eenvoudig om robuuste en flexibele RESTful API's te maken. Door serializers, views en routers te gebruiken, kunt u API's bouwen die complexe datamodellen met gemak verwerken. Met deze basis kunt u nu geavanceerde functies verkennen, zoals aangepaste machtigingen, paginering en authenticatie in DRF.