Czym są widoki w Django?

Question

Accepted Answer

**Widok** to warstwa logiki w Django — funkcja lub klasa, która przyjmuje **żądanie** HTTP, wykonuje logikę (zapytania do modeli, przetwarzanie danych wejściowych) i zwraca **odpowiedź** HTTP. Widoki to miejsce, gdzie obsługujesz to, co dzieje się po uzyskaniu dostępu do adresu URL.

## Widoki oparte na funkcjach (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
```

Widok oparty na funkcji otrzymuje `request` (wraz z parametrami URL), wykonuje swoją pracę i zwraca odpowiedź — `render()` dla HTML, `JsonResponse` dla JSON, `HttpResponse` dla surowych danych.

## Obsługa różnych metod HTTP i danych wejściowych

```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})
```

Widoki sprawdzają `request.method` (GET, POST, itp.) i uzyskują dostęp do danych wejściowych poprzez `request.POST`, `request.GET`, `request.user`, itp.

## Widoki oparte na klasach (CBVs) — wielokrotnego użytku, mniej kodu standardowego

```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 oferuje również **widoki oparte na klasach** — w tym widoki generyczne (`ListView`, `DetailView`, `CreateView`), które implementują typowe wzorce (listowanie, szczegóły, CRUD) z bardzo małą ilością kodu, zmniejszając kod standardowy.

## Rola widoku w przepływie żądań

```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.
```

## Dlaczego to ważne

Widoki to warstwa logiki Django ("V" w MVT, odpowiednik kontrolera w MVC) — to miejsce, gdzie obsługujesz każde żądanie, co czyni je fundamentalne dla budowy każdej aplikacji Django.

Zrozumienie widoków jest niezbędne, ponieważ są to orkiestratory, które łączą wszystko razem: odbieranie żądania, stosowanie logiki biznesowej, wysyłanie zapytań do modeli w celu pobrania danych, przetwarzanie danych wejściowych użytkownika (formularze) i zwracanie odpowiedniej odpowiedzi (HTML poprzez szablony lub JSON dla API).

Wiedzenie, jak pisać **widoki oparte na funkcjach** (jawne, elastyczne — dobre dla niestandardowej logiki), obsługiwać różne metody HTTP i uzyskiwać dostęp do danych żądania oraz używać **widoki oparte na klasach/generyczne** (które dramatycznie zmniejszają kod standardowy dla typowych wzorców, takich jak listowanie i CRUD), obejmuje praktyczne spektrum budowania endpointów Django.

Widoki to miejsce, gdzie żyje większość logiki obsługi żądań aplikacji, więc opanowanie ich — cyklu żądania/odpowiedzi, wyboru między podejściami oparte na funkcjach a opartymi na klasach oraz sposobu połączenia widoków z URL-ami, modelami i szablonami — jest wiedzą podstawową, codzienną dla każdego programisty Django i jest centralne dla tego, jak framework przetwarza żądania.