[PYTHON] [Django] as_view () Notizen

[Django] as_view () Notizen

Es wird ein Lernnotizartikel für Anfänger sein. Beachten Sie, wie as_view () in der generischen Ansicht von Django funktioniert. Wenn Sie dies verstehen, können Sie wahrscheinlich View verstehen und implementieren, das die Grundlage für allgemeine Ansichten bildet.

Beispiel für die Verwendung von as_view ()

Beschrieben bei Verwendung einer generischen Ansicht beim Schreiben einer Route in die Datei urls.py in Django. Das Folgende ist ein Verwendungsbeispiel.

urls.py

from django.urls import path
from . import views

app_name = 'recipe'

urlpatterns = [
    path('', views.[Name der Klasse].as_view(), name='index'),
]

views.py

from django.views.generic import TemplateView

class RecipeListView(TemplateView):
    """
Klasse der Vorlagenansicht
    """
    template_name = '[Anwendungsname]/index.html'

Bei dieser Implementierung wird der Inhalt von index.html auf der Seite angezeigt, auf die über den Stammpfad zugegriffen wird.

Was ist as_view ()?

In der obigen Implementierung wurde "TemplateView" geerbt, um eine Allzweckansicht zu implementieren, aber "TemplateView" erbt "View". Unten ist die Quelle von "View". (Auszug nur aus der Erklärung)

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 () gibt die Dippatch-Methode als Rückgabewert zurück. Die Dippatch-Methode wird implementiert, um die in http_method_names definierten Methoden (get und post) aufzurufen. Daher rufen as_view () -Aufrufe get () und post () der allgemeinen Ansicht als Antwort auf die vom Client ausgelöste Anforderung auf.

Übrigens hat get () von "TemplateView" den folgenden Inhalt und render_to_response wird als Rückgabewert zurückgegeben.

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)

das ist alles.

Referenz

Grundlegendes zur Implementierung der generischen Django-Klassenansicht Django base.py