Apakah class-based views dan generic views?

Question

Accepted Answer

**Class-based views (CBV)** melaksanakan view sebagai kelas Python dan bukannya fungsi, membolehkan penggunaan semula melalui pewarisan dan mixin. **Generic views** ialah CBV terbina dalam yang mengendalikan corak biasa (penyenaraian, perincian, cipta/kemas kini/padam) dengan kod minimum — mengurangkan boilerplate secara dramatik untuk CRUD standard.

## Function-based berbanding class-based

```python
# function-based view (FBV) — explicit, but repetitive for common patterns
def article_list(request):
    articles = Article.objects.all()
    return render(request, "articles.html", {"articles": articles})

# class-based equivalent using a GENERIC view — far less code
from django.views.generic import ListView
class ArticleListView(ListView):
    model = Article                      # Django handles fetching + rendering
    template_name = "articles.html"
    context_object_name = "articles"
```

`ListView` generik secara automatik mengambil semua objek, melakukan penomboran, dan memaparkan templat — menggantikan fungsi manual dengan beberapa atribut.

## Generic views yang biasa (set CRUD)

```python
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView

class ArticleListView(ListView):     model = Article   # list all
class ArticleDetailView(DetailView): model = Article   # show one
class ArticleCreateView(CreateView):                    # a create form + save
    model = Article
    fields = ["title", "body"]
    success_url = "/articles/"
class ArticleUpdateView(UpdateView):                    # edit form + save
    model = Article
    fields = ["title", "body"]
class ArticleDeleteView(DeleteView):                    # confirm + delete
    model = Article
    success_url = "/articles/"
```

Lima generic views ini meliputi keseluruhan kitaran hayat CRUD — senaraikan, perincian, cipta, kemas kini, padam — setiap satu dengan kod yang sangat sedikit. Django mengendalikan penjanaan borang, pengesahan, penyimpanan, dan pemaparan.

## Menyesuaikan melalui penggantian kaedah dan mixin

```python
class ArticleListView(ListView):
    model = Article

def get_queryset(self):                          # override to customize the query
        return Article.objects.filter(published=True).order_by("-created_at")

def get_context_data(self, **kwargs):            # add extra context
        context = super().get_context_data(**kwargs)
        context["categories"] = Category.objects.all()
        return context

# MIXINS add reusable behavior across views
from django.contrib.auth.mixins import LoginRequiredMixin
class ArticleCreateView(LoginRequiredMixin, CreateView):   # require login
    model = Article
    fields = ["title", "body"]
```

CBV disesuaikan dengan menggantikan kaedah tertentu (`get_queryset`, `get_context_data`, `form_valid`) dan digubah dengan **mixin** (cth. `LoginRequiredMixin`) untuk tingkah laku silang yang boleh diguna semula — kelebihan penggunaan semula utama berbanding fungsi.

## Kompromi CBV berbanding FBV

```text
Generic CBVs → minimal code for STANDARD CRUD patterns; reusable via inheritance/mixins
FBVs         → more explicit and readable for CUSTOM/complex logic; easier for beginners
→ Use generic CBVs for standard cases; FBVs (or detailed CBVs) for unusual logic.
  Many teams use both depending on the situation.
```

## Mengapa ia penting

Class-based dan generic views ialah ciri Django yang penting untuk mengurangkan boilerplate dan menggalakkan penggunaan semula, terutamanya untuk operasi CRUD yang amat biasa yang diperlukan oleh kebanyakan aplikasi web.

Memahaminya bernilai kerana **generic views** (`ListView`, `DetailView`, `CreateView`, `UpdateView`, `DeleteView`) melaksanakan corak standard — menyenaraikan rekod, memaparkan perincian, dan mengendalikan borang cipta/kemas kini/padam — dengan hanya beberapa baris setiap satu, di mana function-based view akan memerlukan kod berulang yang banyak (mengambil objek, membina borang, mengesahkan, menyimpan, memaparkan).

Ini ialah kelebihan produktiviti yang besar untuk skrin CRUD asasi yang membentuk sebahagian besar aplikasi Django biasa.

Pendekatan class-based juga membolehkan **penggunaan semula melalui pewarisan dan mixin** — anda menyesuaikan tingkah laku dengan menggantikan kaedah tertentu (`get_queryset`, `get_context_data`) dan menggubah tanggungjawab silang melalui mixin (seperti `LoginRequiredMixin` untuk pengesahan), mengekalkan logik biasa secara DRY merentasi view.

Mengetahui set generic view, cara menyesuaikan CBV, cara mixin berfungsi, dan — yang penting — **kompromi antara CBV dan FBV** (generic CBV untuk corak standard; function-based views untuk logik tersuai atau kompleks di mana keterangan jelas membantu kebolehbacaan) ialah pengetahuan praktikal untuk membina aplikasi Django dengan cekap.

Memilih pendekatan yang betul untuk setiap situasi, dan memanfaatkan generic views untuk mengelakkan mencipta semula CRUD, ialah tanda pembangunan Django yang produktif dan topik yang kerap relevan dalam projek sebenar.