Oprettelse af RESTful API'er i Django med Django REST Framework

Django REST Framework (DRF) er et kraftfuldt og fleksibelt værktøjssæt til opbygning af web-API'er. Det forenkler processen med at skabe RESTful API'er, og giver funktioner som serializers, visningssæt og autentificeringsmekanismer ud af boksen.

Opsætning af Django REST Framework

Før du kan oprette en RESTful API, skal du installere Django REST Framework og tilføje den til dit projekt. Kør følgende kommando for at installere DRF:

pip install djangorestframework

Tilføj derefter 'rest_framework' til INSTALLED_APPS i din settings.py fil:

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

Oprettelse af en simpel API

Lad os oprette en API til en simpel model kaldet Book. Det første trin er at definere modellen i 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

Efter at have defineret modellen, kør migreringer for at oprette databasetabellen:

python manage.py makemigrations
python manage.py migrate

Oprettelse af en Serializer

Serializers i DRF konverterer komplekse datatyper som Django-modeller til JSON. Opret en serializer til Book-modellen:

from rest_framework import serializers
from .models import Book

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

Byg visninger og URL'er

DRF giver to hovedmåder til at skabe API-visninger: funktionsbaserede visninger og klassebaserede visninger. Her bruger vi klassebaserede visninger med 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)

Konfigurer derefter URL'er for denne visning i urls.py:

from django.urls import path
from .views import BookListCreateAPIView

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

Test af API

Med serveren kørende kan du teste API'et på http://127.0.0.1:8000/books/ ved hjælp af værktøjer som Postman eller curl. En GET-anmodning henter alle bøger, og en POST-anmodning giver dig mulighed for at oprette en ny bog.

Forbedring af API'et med ViewSets

For mere kortfattet og genbrugelig kode kan du bruge DRFs ViewSet og Router. Sådan opdaterer du API'et til at bruge et ModelViewSet:

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

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

Konfigurer derefter routeren i urls.py:

from rest_framework.routers import DefaultRouter
from .views import BookViewSet

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

urlpatterns = router.urls

Konklusion

Django REST Framework gør det nemt at skabe robuste og fleksible RESTful API'er. Ved at bruge serialiseringsprogrammer, visninger og routere kan du bygge API'er, der nemt håndterer komplekse datamodeller. Med dette fundament kan du nu udforske avancerede funktioner som brugerdefinerede tilladelser, paginering og godkendelse i DRF.