Django pogledi, ki temeljijo na razredih: Obvladovanje prilagajanja generičnih pogledov

Djangojevi pogledi, ki temeljijo na razredih (CBV), zagotavljajo zmogljiv in ponovno uporaben način za izgradnjo spletnih aplikacij. Generični pogledi, podskupina CBV-jev, ponujajo vnaprej pripravljene rešitve za pogosta opravila, kot so prikazovanje seznamov, podrobni pogledi, ustvarjanje, posodabljanje in brisanje objektov. Medtem ko so ti generični pogledi izjemno priročni, pogosto zahtevajo prilagoditev, da se popolnoma prilegajo specifičnim potrebam vaše aplikacije. Ta obsežen vodnik raziskuje različne tehnike za prilagajanje Djangojevih generičnih pogledov, s čimer vas opolnomoči za izgradnjo učinkovitih in vzdržljivih spletnih aplikacij.

Razumevanje Djangojevih pogledov, ki temeljijo na razredih

Preden se potopimo v prilagajanje, ponovimo osnove CBV-jev in generičnih pogledov. Tradicionalni pogledi, ki temeljijo na funkcijah (FBV), obravnavajo HTTP zahteve neposredno znotraj ene same funkcije. CBV-ji pa organizirajo logiko pogledov v razrede, kar zagotavlja bolj strukturiran in objektno usmerjen pristop. To vodi do boljše organizacije kode, ponovne uporabnosti in testiranja.

Generični pogledi so vnaprej pripravljeni CBV-ji, zasnovani za obravnavo pogostih opravil spletnega razvoja. Podedujejo od osnovnih razredov, kot sta View in TemplateView, in ponujajo specializirane funkcionalnosti. Pogosti generični pogledi vključujejo:

• ListView: Prikaže seznam objektov.
• DetailView: Prikaže podrobnosti posameznega objekta.
• CreateView: Obravnava ustvarjanje objektov z uporabo obrazca.
• UpdateView: Obravnava posodabljanje objektov z uporabo obrazca.
• DeleteView: Obravnava brisanje objektov.

Ti generični pogledi zagotavljajo trdne temelje, vendar realne aplikacije pogosto zahtevajo prilagajanje njihovega vedenja. Raziščimo različne tehnike prilagajanja.

Tehnike prilagajanja

Obstaja več načinov za prilagajanje Djangojevih generičnih pogledov, od preprostih prepisov atributov do bolj kompleksnih prepisov metod. Primerna tehnika je odvisna od zahtevane ravni prilagajanja.

1. Prepis atributov

Najenostavnejša oblika prilagajanja vključuje prepis atributov razreda generičnega pogleda. To je idealno za spreminjanje osnovnih lastnosti, kot so model, ime predloge ali ime kontekstnega objekta.

Primer: Prilagajanje ListView

Recimo, da želite prikazati seznam člankov, vendar želite uporabiti predlogo po meri in drugačno ime kontekstnega objekta.

from django.views.generic import ListView
from .models import Article

class ArticleListView(ListView):
    model = Article
    template_name = 'articles/article_list.html'
    context_object_name = 'articles'

    def get_queryset(self):
        return Article.objects.filter(is_published=True).order_by('-publication_date')

V tem primeru smo prepisali atribute model, template_name in context_object_name. Prepisali smo tudi metodo get_queryset, da filtriramo članke in jih razvrstimo po datumu objave. Metoda get_queryset vam omogoča nadzor nad tem, kateri objekti so vključeni v pogled seznama. To je uporabno za implementacijo filtriranja, razvrščanja in paginacije.

2. Prepis metode

Prepis metode vam omogoča, da spremenite vedenje obstoječih metod v razredu generičnega pogleda. To zagotavlja več nadzora nad logiko pogleda. Pogoste metode za prepis vključujejo:

• get_queryset(): Nadzoruje nabor poizvedb, ki ga uporablja pogled.
• get_context_data(): Doda podatke v kontekst predloge.
• form_valid(): Obravnava uspešno oddajo obrazca.
• form_invalid(): Obravnava neveljavno oddajo obrazca.
• get_success_url(): Določa URL, na katerega se preusmeri po uspešni oddaji obrazca.
• get_object(): Pridobi objekt za DetailView, UpdateView in DeleteView

Primer: Prilagajanje DetailView

Recimo, da želite prikazati podrobnosti članka, vendar želite v kontekst predloge vključiti tudi povezane komentarje.

from django.views.generic import DetailView
from .models import Article, Comment

class ArticleDetailView(DetailView):
    model = Article
    template_name = 'articles/article_detail.html'
    context_object_name = 'article'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['comments'] = Comment.objects.filter(article=self.object, is_approved=True)
        return context

Tukaj smo prepisali metodo get_context_data(), da dodamo spremenljivko comments v kontekst predloge. To vam omogoča enostaven dostop in prikaz povezanih komentarjev v predlogi article_detail.html.

3. Uporaba Mixinov

Mixini so razredi za ponovno uporabo, ki zagotavljajo specifično funkcionalnost. Lahko jih kombinirate z generičnimi pogledi, da dodate funkcije, ne da bi spreminjali osnovno logiko pogleda. Django ponuja več vgrajenih mixinov, lahko pa ustvarite tudi svoje.

Primer: Uporaba LoginRequiredMixin

LoginRequiredMixin zagotavlja, da lahko do določenega pogleda dostopajo samo prijavljeni uporabniki.

from django.views.generic import CreateView
from django.contrib.auth.mixins import LoginRequiredMixin
from .models import Article
from .forms import ArticleForm

class ArticleCreateView(LoginRequiredMixin, CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'articles/article_form.html'
    success_url = '/articles/' # Replace with your desired success URL

    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

V tem primeru smo uporabili LoginRequiredMixin, da omejimo dostop do ArticleCreateView samo prijavljenim uporabnikom. Prepisali smo tudi metodo form_valid, da samodejno nastavimo avtorja članka na trenutnega uporabnika. To ponazarja, kako je mogoče mixine kombinirati s prepisom metode za doseganje kompleksnega prilagajanja.

Ustvarjanje Mixinov po meri

Ustvarite lahko tudi svoje mixine za zajemanje logike za ponovno uporabo. Na primer, lahko ustvarite mixin, ki samodejno nastavi trenutnega uporabnika kot avtorja instance modela, ali mixin, ki obravnava preverjanje dovoljenj.

from django.contrib.auth.mixins import UserPassesTestMixin

class AuthorRequiredMixin(UserPassesTestMixin):
    def test_func(self):
        return self.request.user.is_staff or (self.request.user == self.get_object().author)

    def handle_no_permission(self):
        # Replace with your desired redirection or error handling
        return redirect('permission_denied') # Or raise an exception

Ta AuthorRequiredMixin omogoča dostop samo zaposlenim ali avtorju objekta. Ta mixin lahko uporabite z UpdateView ali DeleteView, da zagotovite, da lahko samo pooblaščeni uporabniki spreminjajo ali brišejo objekte.

4. Prilagajanje predlog

Medtem ko se zgornje tehnike osredotočajo na spreminjanje logike pogleda, je prilagajanje predloge ključnega pomena za nadzor nad predstavitvijo podatkov. Generični pogledi uporabljajo predloge za upodabljanje izhodne kode HTML. Te predloge lahko prilagodite, da ustrezajo zasnovi in blagovni znamki vaše aplikacije.

Konvencije za poimenovanje predlog

Generični pogledi sledijo specifičnim konvencijam za poimenovanje predlog. Na primer:

• ListView: <ime_aplikacije>/<ime_modela>_list.html (npr. articles/article_list.html)
• DetailView: <ime_aplikacije>/<ime_modela>_detail.html (npr. articles/article_detail.html)
• CreateView/UpdateView: <ime_aplikacije>/<ime_modela>_form.html (npr. articles/article_form.html)
• DeleteView: <ime_aplikacije>/<ime_modela>_confirm_delete.html (npr. articles/article_confirm_delete.html)

Atribut template_name v razredu pogleda lahko prepišete, da uporabite drugo predlogo. Znotraj predloge lahko dostopate do podatkov, ki jih zagotavlja pogled, prek kontekstnega objekta. Privzeto ime kontekstnega objekta je običajno mala različica imena modela (npr. article za Article). To lahko spremenite z atributom context_object_name.

Primer: Prilagajanje predloge ListView

V predlogi articles/article_list.html lahko ponovite spremenljivko konteksta articles (kot je določeno v zgornjem primeru ArticleListView), da prikažete seznam člankov.

<h1>Članki</h1>

<ul>
  {% for article in articles %}
    <li><a href="{% url 'article_detail' article.pk %}">{{ article.title }}</a></li>
  {% endfor %}
</ul>

5. Prilagajanje obrazcev (CreateView & UpdateView)

CreateView in UpdateView se za obravnavo uporabniškega vnosa zanašata na Djangojeve obrazce. Prilagajanje teh obrazcev vam omogoča nadzor nad prikazanimi polji, njihovimi pravili preverjanja veljavnosti in njihovim videzom.

Uporaba form_class

Razred obrazca, ki ga želite uporabiti, lahko določite z atributom form_class v razredu pogleda. Če ne določite razreda obrazca, bo Django samodejno ustvaril ModelForm na podlagi modela, povezanega s pogledom.

Prepisovanje metod obrazca

Lahko prepišete metode v svojem razredu obrazca, da prilagodite njegovo vedenje. Pogoste metode za prepis vključujejo:

• __init__(): Inicializira obrazec in spremeni njegova polja.
• clean(): Izvede preverjanje veljavnosti po meri v več poljih.
• clean_<ime_polja>(): Izvede preverjanje veljavnosti po meri za določeno polje.

Primer: Prilagajanje obrazca za članek

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content', 'is_published']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['content'].widget = forms.Textarea(attrs={'rows': 5})

    def clean_title(self):
        title = self.cleaned_data['title']
        if len(title) < 5:
            raise forms.ValidationError("Naslov mora biti dolg vsaj 5 znakov.")
        return title

V tem primeru smo prilagodili ArticleForm tako, da smo nastavili atribut fields v razredu Meta, da določimo, katera polja naj bodo vključena v obrazec. Prepisali smo tudi metodo __init__(), da prilagodimo pripomoček polja content, in metodo clean_title(), da dodamo preverjanje veljavnosti po meri za polje title.

6. Dinamično obravnavanje obrazcev

Včasih morate dinamično prilagoditi obrazec glede na uporabnika ali druge dejavnike. To lahko dosežete s prepisom metode get_form_kwargs() v razredu pogleda. Ta metoda vam omogoča, da konstruktorju obrazca posredujete dodatne argumente ključnih besed.

Primer: Posredovanje uporabnika v obrazec

from django.views.generic import CreateView
from .models import Article
from .forms import ArticleForm

class ArticleCreateView(CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'articles/article_form.html'
    success_url = '/articles/' # Replace with your desired success URL

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs

Nato lahko v svojem ArticleForm dostopate do uporabnika prek argumenta ključne besede user v metodi __init__().

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content', 'is_published']

    def __init__(self, *args, **kwargs):
        self.user = kwargs.pop('user', None)
        super().__init__(*args, **kwargs)
        if self.user and not self.user.is_staff:
            del self.fields['is_published'] # Only staff can publish

V tem primeru posredujemo trenutnega uporabnika v obrazec in dinamično odstranimo polje is_published, če uporabnik ni zaposlen. To ponazarja, kako lahko dinamično prilagodite obrazec glede na uporabnikova dovoljenja.

Napredno prilagajanje: Uporaba naborov pogledov

Za bolj kompleksne aplikacije, zlasti tiste, ki vključujejo API-je, razmislite o uporabi naborov pogledov (ViewSet) Django REST Framework (DRF). Nabori pogledov združujejo povezane poglede (npr. seznam, ustvarjanje, pridobivanje, posodabljanje, brisanje) v en sam razred, kar zagotavlja čistejši in bolj organiziran način za upravljanje končnih točk API-ja.

Primer: Ustvarjanje nabora pogledov za članek

from rest_framework import viewsets
from .models import Article
from .serializers import ArticleSerializer

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

Ta preprost ArticleViewSet ponuja vse standardne operacije CRUD (Create, Read, Update, Delete) za članke. Nabori pogledov lahko prilagodite z uporabo podobnih tehnik kot generični pogledi, na primer s prepisovanjem metod, kot so get_queryset(), perform_create() in perform_update().

Globalni vidiki za prilagajanje generičnih pogledov

Pri prilagajanju generičnih pogledov za globalno občinstvo upoštevajte naslednje vidike:

• Lokalizacija in internacionalizacija (L10n/I18n): Zagotovite, da vaše predloge in obrazci podpirajo več jezikov in regionalnih formatov. Uporabite Djangove vgrajene funkcije i18n/l10n.
• Časovni pasovi: Pravilno obravnavajte pretvorbe časovnih pasov, da prikažete datume in ure v lokalnem času uporabnika. Uporabite Djangov modul timezone.
• Oblikovanje valut: Oblikujte valutne vrednosti ustrezno za različne regije. Razmislite o uporabi knjižnice, kot je babel, za oblikovanje valut.
• Oblikovanje datuma in števil: Uporabite ustrezne oblike datuma in števil na podlagi uporabnikovega jezika.
• Dostopnost: Zagotovite, da so vaši prilagojeni pogledi in predloge dostopni uporabnikom s posebnimi potrebami. Upoštevajte smernice za dostopnost, kot je WCAG.
• Odzivna zasnova: Prepričajte se, da so vaše predloge odzivne in se prilagajajo različnim velikostim zaslona in napravam, ki jih uporabljajo uporabniki po vsem svetu.
• Kulturna občutljivost: Bodite pozorni na kulturne razlike pri oblikovanju svojih pogledov in predlog. Izogibajte se uporabi slik ali jezika, ki bi lahko bil žaljiv za nekatere kulture. Na primer, barvne asociacije in simboli imajo lahko zelo različne pomene v različnih kulturah.

Primer: Obravnavanje časovnih pasov

Če želite prikazati datum objave v lokalnem časovnem pasu uporabnika, lahko v svoji predlogi uporabite oznako timezone:

{% load tz %}

<p>Objavljeno dne: {% timezone article.publication_date %}</p>

Prepričajte se, da imate v svoji nastavitveni datoteki Django USE_TZ = True.

Najboljše prakse za prilagajanje generičnih pogledov

Upoštevajte te najboljše prakse, da zagotovite, da bodo vaše prilagoditve vzdržljive in učinkovite:

• Naj bo preprosto: Izogibajte se pretiranemu zapletanju svojih prilagoditev. Uporabite najpreprostejšo tehniko, ki doseže želeni rezultat.
• Dokumentirajte svojo kodo: Dodajte komentarje, da pojasnite svoje prilagoditve in zakaj so bile potrebne.
• Temeljito testirajte: Napišite enotne teste, da zagotovite, da vaše prilagoditve delujejo pravilno.
• Pametno uporabljajte mixine: Ustvarite mixine za ponovno uporabo, da zajamete pogosto funkcionalnost.
• Upoštevajte Djangove konvencije: Upoštevajte Djangov slog kodiranja in konvencije za poimenovanje.
• Upoštevajte varnost: Bodite pozorni na morebitne varnostne ranljivosti pri prilagajanju pogledov. Sanirajte uporabniški vnos in se zaščitite pred pogostimi napadi, kot so Cross-Site Scripting (XSS) in SQL Injection.

Zaključek

Djangojevi generični pogledi, ki temeljijo na razredih, zagotavljajo zmogljiv in prilagodljiv način za izgradnjo spletnih aplikacij. Z obvladovanjem tehnik prilagajanja, opisanih v tem vodniku, lahko prilagodite generične poglede svojim specifičnim potrebam in ustvarite učinkovite, vzdržljive in globalno dostopne spletne aplikacije. Od preprostih prepisov atributov do kompleksnega prepisovanja metod in uporabe mixinov, možnosti so neskončne. Ne pozabite upoštevati globalnih perspektiv in najboljših praks, da zagotovite, da bodo vaše aplikacije ustrezale raznolikemu mednarodnemu občinstvu.