Django
Generische Ansichten
Suche…
Einführung
Generische Ansichten sind Ansichten, die eine bestimmte vordefinierte Aktion ausführen, z. B. Objekte erstellen, bearbeiten oder löschen oder einfach eine Vorlage anzeigen.
Generische Ansichten müssen von funktionalen Ansichten unterschieden werden, die immer von Hand geschrieben werden, um die erforderlichen Aufgaben auszuführen. Zusammenfassend kann gesagt werden, dass generische Ansichten konfiguriert werden müssen, während funktionale Ansichten programmiert werden müssen.
Generische Ansichten sparen viel Zeit, insbesondere wenn Sie viele standardisierte Aufgaben haben.
Bemerkungen
Diese Beispiele zeigen, dass generische Ansichten standardisierte Aufgaben im Allgemeinen erheblich vereinfachen. Anstatt alles von Grund auf zu programmieren, konfigurieren Sie, was andere Personen bereits für Sie programmiert haben. Dies ist in vielen Situationen sinnvoll, da Sie sich mehr auf das Design Ihrer Projekte als auf die Prozesse im Hintergrund konzentrieren können.
Solltest du sie immer benutzen? Nein. Sie sind nur sinnvoll, wenn Ihre Aufgaben relativ standardisiert sind (Laden, Bearbeiten, Löschen von Objekten) und je mehr sich Ihre Aufgaben wiederholen. Die Verwendung einer bestimmten generischen Ansicht nur einmal und das Überschreiben aller Methoden zum Ausführen sehr spefischer Aufgaben ist unter Umständen nicht sinnvoll. Mit einer funktionalen Ansicht können Sie hier besser aufgehoben sein.
Wenn Sie jedoch über viele Ansichten verfügen, für die diese Funktionalität erforderlich ist, oder wenn Ihre Aufgaben genau mit den definierten Aufgaben einer bestimmten generischen Ansicht übereinstimmen, sind generische Ansichten genau das, was Sie benötigen, um Ihr Leben einfacher zu gestalten.
Minimales Beispiel: Funktionale vs. generische Ansichten
Beispiel für eine Funktionsansicht zum Erstellen eines Objekts. Ohne Kommentare und Leerzeilen benötigen wir 15 Codezeilen:
# imports
from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect
from .models import SampleObject
from .forms import SampleObjectForm
# view functioon
def create_object(request):
# when request method is 'GET', show the template
if request.method == GET:
# perform actions, such as loading a model form
form = SampleObjectForm()
return render_to_response('template.html', locals())
# if request method is 'POST', create the object and redirect
if request.method == POST:
form = SampleObjectForm(request.POST)
# save object and redirect to success page if form is valid
if form.is_valid:
form.save()
return HttpResponseRedirect('url_to_redirect_to')
# load template with form and show errors
else:
return render_to_response('template.html', locals())
Beispiel für eine 'klassenbasierte generische Sicht', um dieselbe Aufgabe auszuführen. Wir benötigen nur 7 Zeilen Code, um dieselbe Aufgabe zu erreichen:
from django.views.generic import CreateView
from .models import SampleObject
from .forms import SampleObjectForm
class CreateObject(CreateView):
model = SampleObject
form_class = SampleObjectForm
success_url = 'url_to_redirect_to'
Generische Ansichten anpassen
Das obige Beispiel funktioniert nur, wenn es sich bei Ihren Aufgaben ausschließlich um Standardaufgaben handelt. Sie fügen hier beispielsweise keinen zusätzlichen Kontext hinzu.
Lassen Sie uns ein realistischeres Beispiel geben. Angenommen, wir möchten der Vorlage einen Seitentitel hinzufügen. In der funktionalen Ansicht würde dies so funktionieren - mit nur einer zusätzlichen Zeile:
def create_object(request):
page_title = 'My Page Title'
# ...
return render_to_response('template.html', locals())
Dies ist mit generischen Ansichten schwieriger zu erreichen (oder: gegen Intutitive). Da sie klassenbasiert sind, müssen Sie eine oder mehrere Methoden der Klasse überschreiben, um das gewünschte Ergebnis zu erzielen. In unserem Beispiel müssen wir die Methode get_context_data der Klasse wie folgt überschreiben:
class CreateObject(CreateView):
model = SampleObject
form_class = SampleObjectForm
success_url = 'url_to_redirect_to'
def get_context_data(self, **kwargs):
# Call class's get_context_data method to retrieve context
context = super().get_context_data(**kwargs)
context['page_title'] = 'My page title'
return context
Hier brauchen wir vier zusätzliche Zeilen anstelle von nur einer - zumindest für die erste zusätzliche Kontextvariable, die wir hinzufügen möchten.
Generische Ansichten mit Mixins
Die wahre Kraft der allgemeinen Ansichten entfaltet sich, wenn Sie sie mit Mixins kombinieren. Ein Mixin ist eine weitere von Ihnen definierte Klasse, deren Methoden von Ihrer Ansichtsklasse vererbt werden können.
Angenommen, Sie möchten, dass in jeder Ansicht die zusätzliche Variable 'page_title' in der Vorlage angezeigt wird. Anstatt die Methode get_context_data jedes Mal zu überschreiben, wenn Sie die Ansicht definieren, erstellen Sie mit dieser Methode ein Mixin und lassen Ihre Ansichten von diesem Mixin erben. Klingt komplizierter als es eigentlich ist:
# Your Mixin
class CustomMixin(object):
def get_context_data(self, **kwargs):
# Call class's get_context_data method to retrieve context
context = super().get_context_data(**kwargs)
context['page_title'] = 'My page title'
return context
# Your view function now inherits from the Mixin
class CreateObject(CustomMixin, CreateView):
model = SampleObject
form_class = SampleObjectForm
success_url = 'url_to_redirect_to'
# As all other view functions which need these methods
class EditObject(CustomMixin, EditView):
model = SampleObject
# ...
Das Schöne daran ist, dass Ihr Code viel strukturierter wird, als dies bei funktionalen Ansichten der Fall ist. Ihre gesamte Logik hinter bestimmten Aufgaben befindet sich an einem Ort und nur an einem Ort. Außerdem sparen Sie enorm viel Zeit, insbesondere wenn Sie über viele Ansichten verfügen, die immer dieselben Aufgaben ausführen, außer bei unterschiedlichen Objekten
