18. September 2025Deutsch

Lernen Sie, wie Sie Ihre Django REST Framework-APIs mithilfe von ViewSets effektiv organisieren. Dieser Leitfaden behandelt alles von der grundlegenden Verwendung bis zur erweiterten Anpassung.

Django REST Framework ViewSets: Meisterhafte Organisation von API-Endpunkten

In der modernen Webentwicklung ist die Erstellung robuster und gut strukturierter APIs entscheidend. Django REST Framework (DRF) ist ein leistungsstarkes Toolkit zum Erstellen von RESTful APIs mit Django. Während DRF verschiedene Werkzeuge zum Erstellen von API-Endpunkten bietet, bieten ViewSets eine elegante Möglichkeit, zusammengehörige Views in einer einzigen Klasse zu organisieren, was zu saubererem und besser wartbarem Code führt. Dieser umfassende Leitfaden behandelt ViewSets im Detail, einschließlich ihrer Vorteile, Verwendung und fortgeschrittener Anpassungstechniken.

Was sind ViewSets?

Ein ViewSet ist eine klassenbasierte View, die Implementierungen für Standardoperationen wie list, create, retrieve, update und destroy bereitstellt. Anstatt separate Views für jede Operation zu definieren, kombiniert ein ViewSet diese in einer einzigen Klasse, was die API-Struktur vereinfacht und Code-Duplizierung reduziert. ViewSets sind besonders nützlich, wenn mit modellbasierten APIs gearbeitet wird, bei denen diese Standardoperationen üblicherweise benötigt werden. Betrachten Sie ein ViewSet als eine logische Gruppierung von Operationen für eine bestimmte Ressource.

Vorteile der Verwendung von ViewSets

Code-Wiederverwendbarkeit: ViewSets fördern die Code-Wiederverwendbarkeit, indem sie gängige API-Logik in einer einzigen Klasse kapseln. Dies reduziert Redundanzen und erleichtert die Wartung des Codes.
Vereinfachtes Routing: ViewSets vereinfachen das Routing, indem sie zusammengehörige Views unter einem einzigen URL-Präfix gruppieren. Dies führt zu einer saubereren und besser organisierten URL-Struktur.
Reduzierter Boilerplate-Code: ViewSets reduzieren den Boilerplate-Code, indem sie Standardimplementierungen für gängige API-Operationen bereitstellen. Dies ermöglicht es Entwicklern, sich auf die Implementierung benutzerdefinierter Logik zu konzentrieren, die für ihre Anwendung spezifisch ist.
Verbesserte Lesbarkeit: ViewSets verbessern die Lesbarkeit des Codes, indem sie zusammengehörige Views in einer einzigen Klasse organisieren. Dies macht die API-Struktur leichter verständlich und navigierbar.
Konsistenz: ViewSets helfen, die Konsistenz über die API hinweg sicherzustellen, indem sie einen standardmäßigen Satz von Operationen und Konventionen erzwingen. Dies macht die API vorhersehbarer und einfacher zu verwenden.

Grundlegende Verwendung von ViewSets

Beginnen wir mit einem einfachen Beispiel für die Verwendung von ViewSets zur Erstellung einer API zur Verwaltung von Produkten. Definieren Sie zuerst ein Modell:

            # models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return self.name

Definieren Sie als Nächstes einen Serializer für das Product-Modell:

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

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

Erstellen Sie nun ein ViewSet für das Product-Modell:

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

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

Konfigurieren Sie schließlich das URL-Routing:

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

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

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

Diese Konfiguration generiert automatisch die folgenden API-Endpunkte:

/products/ (GET: list, POST: create)
/products/{id}/ (GET: retrieve, PUT: update, PATCH: partial_update, DELETE: destroy)

Das ModelViewSet bietet Standardimplementierungen für alle gängigen CRUD-Operationen. Das Attribut queryset gibt die Menge der Objekte an, auf denen das ViewSet operieren soll, und das Attribut serializer_class gibt den Serializer an, der zum Serialisieren und Deserialisieren von Daten verwendet wird.

Arten von ViewSets

DRF bietet mehrere integrierte ViewSet-Klassen, die auf unterschiedliche Anwendungsfälle zugeschnitten sind:

ViewSet: Die Basisklasse für alle ViewSets. Sie bietet die grundlegende Infrastruktur für die Verarbeitung von Anfragen und Antworten.
ReadOnlyModelViewSet: Ein ViewSet, das schreibgeschützte Operationen (list und retrieve) bereitstellt. Dies ist nützlich für APIs, die nur den Datenabruf zulassen.
ModelViewSet: Ein ViewSet, das alle Standard-CRUD-Operationen (list, create, retrieve, update und destroy) bereitstellt. Dies ist das am häufigsten verwendete ViewSet für modellbasierte APIs.
GenericViewSet: Ein ViewSet, das eine generische Implementierung für gängige API-Operationen bietet. Dies kann als Basisklasse zum Erstellen benutzerdefinierter ViewSets verwendet werden.

Die Wahl des richtigen ViewSets hängt von den spezifischen Anforderungen Ihrer API ab. Wenn Sie nur schreibgeschützte Operationen benötigen, verwenden Sie ReadOnlyModelViewSet. Wenn Sie alle Standard-CRUD-Operationen benötigen, verwenden Sie ModelViewSet. Wenn Sie mehr Kontrolle über das Verhalten der API benötigen, können Sie ein benutzerdefiniertes ViewSet erstellen, indem Sie von GenericViewSet oder ViewSet erben.

Anpassung von ViewSets

Während die integrierten ViewSets eine bequeme Möglichkeit zur Erstellung von APIs bieten, müssen Sie möglicherweise deren Verhalten anpassen, um spezifische Anforderungen zu erfüllen. DRF bietet verschiedene Möglichkeiten, ViewSets anzupassen, einschließlich der Überschreibung von Methoden, dem Hinzufügen benutzerdefinierter Aktionen und der Verwendung benutzerdefinierter Serializer.

Überschreiben von Methoden

Sie können die Standardimplementierungen der Standard-API-Operationen überschreiben, indem Sie Methoden mit denselben Namen in Ihrer ViewSet-Klasse definieren. Sie können beispielsweise die Methode create überschreiben, um benutzerdefinierte Logik hinzuzufügen, bevor ein neues Objekt erstellt wird:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.response import Response
from rest_framework import status

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

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        # Fügen Sie hier benutzerdefinierte Logik hinzu, bevor das Objekt erstellt wird
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

In diesem Beispiel überschreibt die Methode create die Standardimplementierung und fügt benutzerdefinierte Logik hinzu, bevor das Objekt erstellt wird. Die Methode perform_create wird aufgerufen, um das Objekt tatsächlich zu erstellen, und die Antwort wird mit dem Statuscode 201 Created zurückgegeben.

Hinzufügen benutzerdefinierter Aktionen

Sie können Ihrer ViewSet mithilfe des Dekorators @action benutzerdefinierte Aktionen hinzufügen. Benutzerdefinierte Aktionen ermöglichen es Ihnen, neue API-Endpunkte zu definieren, die bestimmte Operationen auf den vom ViewSet verwalteten Ressourcen ausführen. Sie können beispielsweise eine Aktion hinzufügen, um ein Produkt alsFeatured zu kennzeichnen:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status

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

    @action(detail=True, methods=['post'])
    def feature(self, request, pk=None):
        product = self.get_object()
        product.is_featured = True
        product.save()
        serializer = self.get_serializer(product)
        return Response(serializer.data)

In diesem Beispiel definiert der Dekorator @action einen neuen API-Endpunkt /products/{id}/feature/, der ein Produkt als Featured kennzeichnet. Das Argument detail=True gibt an, dass die Aktion auf einer bestimmten Instanz des Modells operiert. Das Argument methods=['post'] gibt an, dass die Aktion nur POST-Anfragen akzeptiert.

Verwendung benutzerdefinierter Serializer

Sie können benutzerdefinierte Serializer verwenden, um die Art und Weise anzupassen, wie Daten vom ViewSet serialisiert und deserialisiert werden. Dies ist nützlich, wenn Sie komplexe Datenstrukturen verarbeiten oder benutzerdefinierte Validierungen durchführen müssen. Sie können beispielsweise einen benutzerdefinierten Serializer verwenden, um verwandte Daten in der API-Antwort einzuschließen:

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

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name']

class ProductSerializer(serializers.ModelSerializer):
    category = CategorySerializer(read_only=True)

    class Meta:
        model = Product
        fields = '__all__'

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

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

In diesem Beispiel enthält der ProductSerializer einen CategorySerializer, um die verwandten Kategoriedaten zu serialisieren. Dies ermöglicht es Ihnen, die Kategorieinformationen zusammen mit den Produktinformationen in einer einzigen API-Anfrage abzurufen.

Fortgeschrittene ViewSet-Techniken

Über die grundlegende Verwendung und Anpassung hinaus bieten ViewSets fortgeschrittene Techniken zum Erstellen anspruchsvoller APIs:

Filterung

DRF bietet leistungsstarke Filterfunktionen, mit denen Sie den QuerySet basierend auf Anfrageparametern filtern können. Sie können das Attribut filter_backends verwenden, um die zu verwendenden Filter-Backends anzugeben. Sie können beispielsweise SearchFilter verwenden, um Benutzern zu ermöglichen, nach Produkten anhand von Name oder Beschreibung zu suchen:

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

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['name', 'description']

In diesem Beispiel gibt das Attribut filter_backends an, dass SearchFilter verwendet werden soll. Das Attribut search_fields gibt die Felder an, die durchsucht werden sollen.

Paginierung

DRF bietet Paginierungsfunktionen, mit denen Sie den QuerySet in kleinere Seiten aufteilen können. Dies ist nützlich, wenn Sie mit großen Datensätzen arbeiten. Sie können das Attribut pagination_class verwenden, um die zu verwendende Paginierungsklasse anzugeben. Sie können beispielsweise PageNumberPagination verwenden, um die Ergebnisse anhand von Seitenzahlen zu paginieren:

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

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

In diesem Beispiel gibt das Attribut pagination_class an, dass PageNumberPagination verwendet werden soll. Sie können das Paginierungsverhalten auch anpassen, indem Sie Ihre eigene Paginierungsklasse erstellen.

Authentifizierung und Berechtigungen

DRF bietet flexible Authentifizierungs- und Berechtigungsmechanismen, mit denen Sie den Zugriff auf Ihre API-Endpunkte steuern können. Sie können die Attribute authentication_classes und permission_classes verwenden, um die zu verwendenden Authentifizierungs- und Berechtigungsklassen anzugeben. Sie können beispielsweise TokenAuthentication verwenden, um Benutzer mit Tokens zu authentifizieren, und die Berechtigung IsAuthenticated, um nur authentifizierten Benutzern den Zugriff auf die API zu gestatten:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [IsAuthenticated]

In diesem Beispiel gibt das Attribut authentication_classes an, dass TokenAuthentication verwendet werden soll, und das Attribut permission_classes gibt an, dass die Berechtigung IsAuthenticated verwendet werden soll.

Bewährte Praktiken für die Verwendung von ViewSets

Um sicherzustellen, dass Ihre ViewSets gut konzipiert und wartbar sind, befolgen Sie diese bewährten Praktiken:

Halten Sie ViewSets fokussiert: Jedes ViewSet sollte für die Verwaltung einer einzelnen Ressource oder einer eng verwandten Gruppe von Ressourcen verantwortlich sein. Vermeiden Sie die Erstellung übermäßig komplexer ViewSets, die mehrere nicht zusammenhängende Operationen verarbeiten.
Verwenden Sie geeignete ViewSet-Typen: Wählen Sie den ViewSet-Typ, der am besten zu den Anforderungen Ihrer API passt. Verwenden Sie ReadOnlyModelViewSet für schreibgeschützte APIs, ModelViewSet für CRUD-APIs und GenericViewSet oder ViewSet für benutzerdefinierte APIs.
Befolgen Sie RESTful-Prinzipien: Entwerfen Sie Ihre API-Endpunkte gemäß den RESTful-Prinzipien. Verwenden Sie Standard-HTTP-Methoden (GET, POST, PUT, PATCH, DELETE), um Operationen auf Ressourcen auszuführen.
Verwenden Sie Serializer zur Datenvalidierung: Verwenden Sie Serializer zur Validierung der Daten, die an die API gesendet und von ihr empfangen werden. Dies trägt zur Gewährleistung der Datenintegrität bei und verhindert Fehler.
Implementieren Sie ordnungsgemäße Authentifizierung und Berechtigungen: Sichern Sie Ihre API-Endpunkte durch die Implementierung ordnungsgemäßer Authentifizierung und Berechtigungen. Dies schützt Ihre Daten vor unbefugtem Zugriff.
Schreiben Sie umfassende Tests: Schreiben Sie umfassende Tests, um sicherzustellen, dass Ihre ViewSets korrekt funktionieren. Dies hilft, Regressionen zu verhindern und erleichtert die Wartung des Codes.

Überlegungen zu Internationalisierung (i18n) und Lokalisierung (l10n)

Beim Erstellen von APIs für ein globales Publikum ist es unerlässlich, Internationalisierung (i18n) und Lokalisierung (l10n) zu berücksichtigen. ViewSets können angepasst werden, um mehrere Sprachen und Regionen zu unterstützen:

Serializer-Felder: Verwenden Sie DRF-Serializer-Felder mit geeigneten Übersetzungsfunktionen (z. B. gettext aus dem i18n-Framework von Django), um übersetzte Feldbezeichnungen und Hilfetexte anzuzeigen.
Fehlermeldungen: Stellen Sie sicher, dass die von der API zurückgegebenen Fehlermeldungen in die bevorzugte Sprache des Benutzers übersetzt werden.
Datums- und Zeitformatierung: Verwenden Sie die entsprechende Datums- und Zeitformatierung basierend auf dem Gebietsschema des Benutzers. DRF bietet Optionen zur Anpassung von Datums- und Zeitformaten.
Währungsformatierung: Formatieren Sie Währungswerte entsprechend dem Gebietsschema des Benutzers. Erwägen Sie die Verwendung von Bibliotheken wie babel zur Währungsformatierung. Beispielsweise kann ein Preis von 1234,56 USD in den USA als $1,234.56 formatiert werden, in einigen europäischen Ländern jedoch als 1.234,56 $.
Zeitzonen: Behandeln Sie Zeitzonen korrekt. Speichern Sie Daten und Zeiten in UTC und konvertieren Sie sie in die lokale Zeitzone des Benutzers, wenn Sie sie anzeigen.

Beispielsweise könnte ein Produkt eine Beschreibung haben, die übersetzt werden muss. Sie würden das Übersetzungssystem von Django innerhalb des Serializers verwenden:

            # serializers.py
from rest_framework import serializers
from django.utils.translation import gettext_lazy as _
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    description = serializers.CharField(help_text=_("Product description"))

    class Meta:
        model = Product
        fields = '__all__'

Und in Ihren Vorlagen oder dem Code, der diesen Serializer verwendet, stellen Sie sicher, dass die richtige Sprache aktiviert ist.

Beispiel: E-Commerce-API mit internationaler Unterstützung

Stellen Sie sich eine E-Commerce-API vor, die Produkte weltweit verkauft. Das Product-Modell könnte Felder wie name, description, price und image enthalten. Die API muss mehrere Sprachen und Währungen unterstützen.

Das ViewSet würde die grundlegenden CRUD-Operationen für Produkte behandeln. Die Serializer würden angepasst, um die Übersetzung von Produktname und -beschreibung zu unterstützen. Die API würde auch Endpunkte zum Abrufen von Produkten nach Kategorie, zum Filtern von Produkten nach Preisspanne und zum Suchen von Produkten nach Schlüsselwörtern enthalten. Diese Funktionen müssten die Internationalisierung berücksichtigen, insbesondere bei Suchbegriffen und Produktbeschreibungen, die je nach Sprache variieren können.

Beispiel-URLs:

/en/products/ - Liste der Produkte auf Englisch
/fr/products/ - Liste der Produkte auf Französisch
/en/products/?currency=USD - Liste der Produkte in USD
/fr/products/123/?currency=EUR - Details von Produkt 123 auf Französisch, Preis in EUR angezeigt

Schlussfolgerung

Django REST Framework ViewSets bieten eine leistungsstarke und elegante Möglichkeit, Ihre API-Endpunkte zu organisieren. Durch die Kapselung zusammengehöriger Views in einer einzigen Klasse fördern ViewSets die Code-Wiederverwendbarkeit, vereinfachen das Routing und verbessern die Lesbarkeit des Codes. Mit der Möglichkeit, ViewSets durch Überschreiben von Methoden, Hinzufügen benutzerdefinierter Aktionen und Verwenden benutzerdefinierter Serializer anzupassen, können Sie diese an die spezifischen Anforderungen Ihrer API anpassen. Durch die Befolgung der in diesem Leitfaden beschriebenen bewährten Praktiken stellen Sie sicher, dass Ihre ViewSets gut konzipiert, wartbar und skalierbar sind, was zu robusten und effizienten APIs führt.

Denken Sie daran, Internationalisierung und Lokalisierung zu berücksichtigen, wenn Sie APIs für ein globales Publikum erstellen. Passen Sie Ihre ViewSets und Serializer an, um mehrere Sprachen, Währungen und Zeitzonen zu unterstützen, um eine nahtlose Erfahrung für Benutzer auf der ganzen Welt zu bieten.

Durch die Beherrschung von ViewSets können Sie Ihre Django REST Framework-Fähigkeiten auf die nächste Stufe heben und APIs erstellen, die sowohl leistungsfähig als auch wartbar sind. Dies trägt zu qualitativ hochwertiger Software und einer positiven Benutzererfahrung für Ihr globales Publikum bei.

Dieser Leitfaden sollte als solide Grundlage für das Verständnis und die Implementierung von ViewSets in Ihren Django REST Framework-Projekten dienen. Üben Sie weiter, experimentieren Sie und erkunden Sie die DRF-Dokumentation, um ein wahrer ViewSet-Meister zu werden!