Notes de [Django] as_view ()

Notes de [Django] as_view ()

Ce sera un article de mémo d'apprentissage pour les débutants. Notez comment as_view () utilisé dans la vue générique de Django fonctionne. Si vous pouvez comprendre cela, je pense que vous pouvez comprendre et implémenter View, qui est la base des vues générales.

Exemple d'utilisation de as_view ()

Décrit lors de l'utilisation d'une vue générique lors de l'écriture d'une route vers le fichier urls.py dans Django. Voici un exemple d'utilisation.

urls.py

from django.urls import path
from . import views

app_name = 'recipe'

urlpatterns = [
    path('', views.[nom de la classe].as_view(), name='index'),
]

views.py

from django.views.generic import TemplateView

class RecipeListView(TemplateView):
    """
Classe de vue de modèle
    """
    template_name = '[Nom de l'application]/index.html'

Avec cette implémentation, le contenu de index.html sera affiché sur la page accessible par le chemin racine.

Qu'est-ce que as_view ()?

Dans l'implémentation ci-dessus, "TemplateView" a été hérité pour implémenter une vue à usage général, mais "TemplateView" hérite de "View". Voici la source de "View". (Extrait uniquement de l'explication)

django/django/views/generic/base.py

class View:
    """
    Intentionally simple parent class for all views. Only implements
    dispatch-by-method and simple sanity checking.
    """

    http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

    def __init__(self, **kwargs):
        """
        Constructor. Called in the URLconf; can contain helpful extra
        keyword arguments, and other things.
        """
        # Go through keyword arguments, and either save their values to our
        # instance, or raise an error.
        for key, value in kwargs.items():
            setattr(self, key, value)

    @classonlymethod
    def as_view(cls, **initkwargs):
        """Main entry point for a request-response process."""
        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError(
                    'The method name %s is not accepted as a keyword argument '
                    'to %s().' % (key, cls.__name__)
                )
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            self.setup(request, *args, **kwargs)
            if not hasattr(self, 'request'):
                raise AttributeError(
                    "%s instance has no 'request' attribute. Did you override "
                    "setup() and forget to call super()?" % cls.__name__
                )
            return self.dispatch(request, *args, **kwargs)
        view.view_class = cls
        view.view_initkwargs = initkwargs

        # take name and docstring from class
        update_wrapper(view, cls, updated=())

        # and possible attributes set by decorators
        # like csrf_exempt from dispatch
        update_wrapper(view, cls.dispatch, assigned=())
        return view
            :
            :
    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)

            :
            :

as_view () renvoie la méthode dippatch comme valeur de retour. La méthode dippatch est implémentée pour appeler les méthodes (get et post) définies dans http_method_names. Par conséquent, as_view () appelle get () et post () de la vue générale en réponse à la requête lancée par le client.

Au fait, get () de "TemplateView" a le contenu suivant, et render_to_response est retourné comme valeur de retour.

django/django/views/generic/base.py

class TemplateView(TemplateResponseMixin, ContextMixin, View):
    """Render a template."""
    def get(self, request, *args, **kwargs):
        # RemovedInDjango40Warning: when the deprecation ends, replace with:
        #   context = self.get_context_data()
        context_kwargs = _wrap_url_kwargs_with_deprecation_warning(kwargs)
        context = self.get_context_data(**context_kwargs)
        return self.render_to_response(context)

c'est tout.

référence

Comprendre l'implémentation de la vue de classe générique Django Django base.py