Ce sunt view-urile în Django?

Question

Accepted Answer

Un **view** este stratul de logică al Django — o funcție sau clasă care primește un **request** HTTP, execută logică (interogare modele, prelucrare input) și returnează un **response** HTTP. View-urile sunt locul în care gestionezi ce se întâmplă atunci când o URL este accesată.

## View-uri bazate pe funcții (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
```

Un view bazat pe funcție primește `request` (plus orice parametri din URL), execută munca și returnează un response — `render()` pentru HTML, `JsonResponse` pentru JSON, `HttpResponse` pentru output brut.

## Gestionarea diferitelor metode HTTP și input

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

View-urile inspectează `request.method` (GET, POST, etc.) și accesează input prin `request.POST`, `request.GET`, `request.user`, etc.

## View-uri bazate pe clase (CBVs) — reutilizabile, mai puțin 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 oferă, de asemenea, **view-uri bazate pe clase** — inclusiv view-uri generice (`ListView`, `DetailView`, `CreateView`) care implementează modele comune (enumerare, detalii, CRUD) cu foarte puțin cod, reducând boilerplate.

## Rolul view-ului în fluxul request

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

## De ce este important

View-urile sunt stratul de logică al Django ("V" în MVT, echivalent cu controllerul din MVC) — sunt locul în care gestionezi fiecare request, fapt ce le face fundamentale pentru construirea oricărei aplicații Django.

Înțelegerea view-urilor este esențială deoarece sunt orchestratorii care leagă totul: primesc request-ul, aplică logica de business, interogează modele pentru date, prelucrează input de utilizator (formulare) și returnează response-ul corespunzător (HTML prin template-uri sau JSON pentru API-uri).

Cunoașterea modului de scriere a **view-urilor bazate pe funcții** (explicit, flexibil — bun pentru logică personalizată), gestionarea diferitelor metode HTTP și accesarea datelor request, și utilizarea **view-urilor bazate pe clase/view-uri generice** (care reduc dramatic boilerplate-ul pentru modele comune cum ar fi enumerare și CRUD) acoperă spectrul practic de construire a endpoint-urilor Django.

View-urile sunt locul în care trăiește cea mai mare parte a logicii de gestionare a request-urilor unei aplicații, deci stăpânirea lor — ciclul request/response, alegerea între abordări bazate pe funcții și pe clase, și modul în care view-urile conectează URL-uri la modele și template-uri — este cunoștință fundamentală, zilnică pentru orice dezvoltator Django și centrală pentru modul în care framework-ul procesează request-urile.