Cosa sono le views in Django?

Question

Accepted Answer

Una **view** è il livello logico di Django — una funzione o classe che riceve una **request** HTTP, esegue la logica (interrogazione di modelli, elaborazione dell'input) e restituisce una **response** HTTP. Le views sono dove gestisci cosa accade quando si accede a un URL.

## Function-based 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
```

Una function-based view riceve la `request` (più i parametri URL), svolge il suo lavoro e restituisce una response — `render()` per HTML, `JsonResponse` per JSON, `HttpResponse` per output raw.

## Gestire diversi metodi HTTP e 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})
```

Le views ispezionano `request.method` (GET, POST, ecc.) e accedono all'input tramite `request.POST`, `request.GET`, `request.user`, ecc.

## Class-based views (CBVs) — riutilizzabili, meno 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 offre anche **class-based views** — incluse le generic views (`ListView`, `DetailView`, `CreateView`) che implementano pattern comuni (listing, dettaglio, CRUD) con pochissimo codice, riducendo il boilerplate.

## Il ruolo della view nel flusso di 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.
```

## Perché è importante

Le views sono il livello logico di Django (la "V" in MVT, equivalente al controller di MVC) — sono dove gestisci ogni request, rendendole fondamentali per costruire qualsiasi applicazione Django.

Comprendere le views è essenziale perché sono gli orchestratori che legano tutto insieme: ricevono la request, applicano la logica di business, interrogano i modelli per i dati, elaborano l'input dell'utente (form) e restituiscono la response appropriata (HTML tramite template, o JSON per API).

Sapere come scrivere **function-based views** (esplicite, flessibili — buone per logica personalizzata), gestire diversi metodi HTTP e accedere ai dati della request, e usare **class-based/generic views** (che riducono drasticamente il boilerplate per pattern comuni come listing e CRUD) copre lo spettro pratico della costruzione di endpoint Django.

Le views sono dove vive la maggior parte della logica di gestione delle request di un'applicazione, quindi padroneggiarle — il ciclo request/response, la scelta tra approcci function-based e class-based, e come le views collegano URL a modelli e template — è conoscenza fondamentale, quotidiana per qualsiasi sviluppatore Django ed è centrale a come il framework elabora le request.