Was sind Views in Django?

Question

Accepted Answer

Eine **View** ist die Logikschicht von Django – eine Funktion oder Klasse, die eine HTTP-**Anfrage** (Request) entgegennimmt, Logik ausführt (Models abfragen, Eingaben verarbeiten) und eine HTTP-**Antwort** (Response) zurückgibt. Views sind der Ort, an dem Sie festlegen, was passiert, wenn eine URL aufgerufen wird.

## Funktionsbasierte Views (FBVs)

```python
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse, HttpResponse

def article_list(request):
    articles = Article.objects.all()                    # query models
    return render(request, "articles.html", {"articles": articles})  # render a template

def article_detail(request, pk):
    article = get_object_or_404(Article, pk=pk)         # 404 if not found
    return render(request, "detail.html", {"article": article})

def api_articles(request):
    data = list(Article.objects.values("title", "body"))
    return JsonResponse(data, safe=False)               # return JSON instead of HTML
```

Eine funktionsbasierte View empfängt den `request` (plus beliebige URL-Parameter), führt ihre Arbeit aus und gibt eine Antwort zurück – `render()` für HTML, `JsonResponse` für JSON, `HttpResponse` für Rohausgabe.

## Verschiedene HTTP-Methoden und Eingaben verarbeiten

```python
def create_article(request):
    if request.method == "POST":
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect("article_list")             # redirect after a successful POST
    else:
        form = ArticleForm()
    return render(request, "create.html", {"form": form})
```

Views prüfen `request.method` (GET, POST, usw.) und greifen auf Eingaben über `request.POST`, `request.GET`, `request.user` usw. zu.

## Klassenbasierte Views (CBVs) – wiederverwendbar, weniger Boilerplate

```python
from django.views.generic import ListView, DetailView

# generic CBVs handle common patterns with minimal code
class ArticleListView(ListView):
    model = Article                                     # automatically lists all articles
    template_name = "articles.html"

class ArticleDetailView(DetailView):
    model = Article
```

Django bietet auch **klassenbasierte Views** – einschließlich generischer Views (`ListView`, `DetailView`, `CreateView`), die häufige Muster (Auflistung, Detail, CRUD) mit sehr wenig Code implementieren und Boilerplate reduzieren.

## Die Rolle der View im Request-Flow

```text
Request → URL routing → VIEW (logic) → queries models, renders template → Response
The view is the orchestrator: it connects the URL, the data (models), and the
presentation (template) to produce a response.
```

## Warum es wichtig ist

Views sind die Logikschicht von Django (das "V" in MVT, äquivalent zum Controller in MVC) – sie sind der Ort, an dem Sie jede Anfrage verarbeiten und sind daher fundamental für den Aufbau jeder Django-Anwendung.

Views zu verstehen ist essentiell, weil sie die Orchestratoren sind, die alles zusammenbringen: Sie empfangen die Anfrage, wenden Geschäftslogik an, fragen Models für Daten ab, verarbeiten Benutzereingaben (Formulare) und geben die passende Antwort zurück (HTML über Templates oder JSON für APIs).

Es ist wichtig zu wissen, wie man **funktionsbasierte Views** schreibt (explizit, flexibel – gut für benutzerdefinierte Logik), verschiedene HTTP-Methoden verarbeitet und auf Request-Daten zugreift, und wie man **klassenbasierte/generische Views** nutzt (die Boilerplate für häufige Muster wie Auflistung und CRUD dramatisch reduzieren) – dies deckt das praktische Spektrum beim Aufbau von Django-Endpoints ab.

Views sind der Ort, an dem die meiste Request-Handling-Logik einer Anwendung lebt. Die Beherrschung von Views – der Request/Response-Zyklus, die Wahl zwischen funktionsbasierten und klassenbasierten Ansätzen und wie Views URLs mit Models und Templates verbinden – ist fundamentales, alltägliches Wissen für jeden Django-Entwickler und zentral dafür, wie das Framework Requests verarbeitet.