Django
Vues génériques
Recherche…
Introduction
Les vues génériques sont des vues qui effectuent une action prédéfinie, telle que la création, la modification ou la suppression d'objets, ou simplement l'affichage d'un modèle.
Les vues génériques doivent être distinguées des vues fonctionnelles, qui sont toujours écrites à la main pour effectuer les tâches requises. En bref, on peut dire que les vues génériques doivent être configurées, alors que les vues fonctionnelles doivent être programmées.
Les vues génériques peuvent gagner beaucoup de temps, en particulier lorsque vous avez de nombreuses tâches normalisées à effectuer.
Remarques
Ces exemples montrent que les vues génériques simplifient généralement les tâches standardisées. Au lieu de tout programmer à partir de zéro, vous configurez ce que les autres personnes ont déjà programmé pour vous. Cela a du sens dans de nombreuses situations, car cela vous permet de vous concentrer davantage sur la conception de vos projets plutôt que sur les processus en arrière-plan.
Alors, devriez-vous toujours les utiliser? Non, ils n'ont de sens que si vos tâches sont assez standardisées (chargement, édition, suppression d'objets) et que vos tâches sont répétitives. Utiliser une seule vue générique spécifique une seule fois, puis remplacer toutes ses méthodes pour effectuer des tâches très spécifiques peut ne pas avoir de sens. Vous pouvez être mieux avec une vue fonctionnelle ici.
Cependant, si vous avez beaucoup de vues qui requièrent cette fonctionnalité ou si vos tâches correspondent exactement aux tâches définies pour une vue générique spécifique, alors les vues génériques sont exactement ce dont vous avez besoin pour vous simplifier la vie.
Exemple minimum: vues fonctionnelle vs vues génériques
Exemple de vue fonctionnelle pour créer un objet. En excluant les commentaires et les lignes vierges, nous avons besoin de 15 lignes de code:
# 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())
Exemple pour une "vue générique basée sur les classes" pour effectuer la même tâche. Nous avons seulement besoin de 7 lignes de code pour accomplir la même tâche:
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'
Personnalisation des vues génériques
L'exemple ci-dessus ne fonctionne que si vos tâches sont des tâches entièrement standard. Vous n’ajoutez pas de contexte supplémentaire ici, par exemple.
Faisons un exemple plus réaliste. Supposons que nous voulions ajouter un titre de page au modèle. Dans la vue fonctionnelle, cela fonctionnerait comme cela - avec une seule ligne supplémentaire:
def create_object(request):
page_title = 'My Page Title'
# ...
return render_to_response('template.html', locals())
Ceci est plus difficile (ou: contre-intuitif) à réaliser avec des vues génériques. Comme ils sont basés sur des classes, vous devez remplacer une ou plusieurs méthodes de la classe pour obtenir le résultat souhaité. Dans notre exemple, nous devons remplacer la méthode get_context_data de la classe comme suit :
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
Ici, nous avons besoin de coder quatre lignes supplémentaires au lieu d'une seule - du moins pour la première variable de contexte supplémentaire à ajouter.
Vues génériques avec des mixins
Le véritable pouvoir des vues génériques se manifeste lorsque vous les combinez avec des mixins. Un mixin est juste une autre classe définie par vous dont les méthodes peuvent être héritées par votre classe de vue.
Supposons que vous souhaitiez que chaque vue affiche la variable supplémentaire 'page_title' dans le modèle. Au lieu de remplacer la méthode get_context_data à chaque fois que vous définissez la vue, vous créez un mixin avec cette méthode et laissez vos vues hériter de ce mixin. Cela semble plus compliqué qu'il ne l'est en réalité:
# 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
# ...
La beauté de ceci est que votre code devient beaucoup plus structuré que ce n'est le cas pour les vues fonctionnelles. Toute votre logique derrière des tâches spécifiques se trouve dans un seul endroit et un seul endroit. En outre, vous économiserez énormément de temps, en particulier lorsque vous avez de nombreuses vues qui effectuent toujours les mêmes tâches, sauf avec des objets différents.