Skapa RESTful API:er i Django med Django REST Framework

Django REST Framework (DRF) är en kraftfull och flexibel verktygslåda för att bygga webb-API:er. Det förenklar processen att skapa RESTful API:er, och tillhandahåller funktioner som serialiserare, visningsuppsättningar och autentiseringsmekanismer direkt.

Konfigurera Django REST Framework

Innan du kan skapa ett RESTful API måste du installera Django REST Framework och lägga till det i ditt projekt. Kör följande kommando för att installera DRF:

pip install djangorestframework

Lägg sedan till 'rest_framework' till INSTALLED_APPS i filen settings.py:

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

Skapa ett enkelt API

Låt oss skapa ett API för en enkel modell som heter Book. Det första steget är att definiera 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 att ha definierat modellen, kör migreringarna för att skapa databastabellen:

python manage.py makemigrations
python manage.py migrate

Skapa en Serializer

Serializers i DRF konverterar komplexa datatyper som Django-modeller till JSON. Skapa en serializer för Book-modellen:

from rest_framework import serializers
from .models import Book

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

Bygga vyer och webbadresser

DRF tillhandahåller två huvudsakliga sätt att skapa API-vyer: funktionsbaserade vyer och klassbaserade vyer. Här använder vi klassbaserade vyer 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)

Konfigurera sedan webbadresser för den här vyn i urls.py:

from django.urls import path
from .views import BookListCreateAPIView

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

Testar API

Med servern igång kan du testa API:t på http://127.0.0.1:8000/books/ med hjälp av verktyg som Postman eller curl. En GET-begäran hämtar alla böcker, och en POST-begäran låter dig skapa en ny bok.

Förbättra API:t med ViewSets

För mer kortfattad och återanvändbar kod kan du använda DRF:s ViewSet och Router. Så här uppdaterar du API:et för att använda en 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

Konfigurera sedan routern 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

Slutsats

Django REST Framework gör det enkelt att skapa robusta och flexibla RESTful API:er. Genom att använda serialiserare, vyer och routrar kan du bygga API:er som enkelt hanterar komplexa datamodeller. Med den här grunden kan du nu utforska avancerade funktioner som anpassade behörigheter, paginering och autentisering i DRF.