So erstellen Sie eine CRUD-App mit klassenbasierten Django-Ansichten

Eines der Hauptmerkmale von Django ist die integrierte Unterstützung für die Erstellung von Projekten zusätzlich zu CRUD-Vorgängen (Erstellen, Lesen, Aktualisieren, Löschen). Während die klassenbasierten Ansichten von Django eine schnelle, einfache und flexible Möglichkeit zum Erstellen von Webanwendungen bieten, verwenden viele Entwickler immer noch funktionsbasierte Ansichten.

Klassenbasierte Ansichten bieten gegenüber funktionsbasierten Ansichten mehrere Vorteile, darunter Vererbung, Codestrukturierung, Wiederverwendbarkeit von Code und mehr. Auch wenn die Implementierung klassenbasierter Ansichten etwas komplex erscheinen mag, hilft Ihnen dieser Leitfaden dabei, das Konzept zu verstehen, indem er eine Task-Manager-App erstellt und Schritt-für-Schritt-Anleitungen bereitstellt.

Was sind klassenbasierte Ansichten in Django?

In Django gibt es Ansichten Python-Funktionen

die eine Webanfrage entgegennehmen und eine Webantwort zurückgeben. Klassenbasierte Ansichten (CBVs) sind eine alternative Möglichkeit, Ansichten in Django mithilfe von Python-Klassen anstelle von Funktionen zu definieren.

CBVs haben mehrere Vorteile, wie z. B. eine bessere Codeorganisation, eine einfachere Wiederverwendung von Code und die Möglichkeit, Vererbung zu nutzen, um Variationen vorhandener Ansichten zu erstellen. CBVs bieten auch integrierte Methoden wie die erhalten() Und Post() Methoden, die Sie für benutzerdefiniertes Verhalten überschreiben können.

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository.

Klassenbasierte Ansichten in Django verfügbar

Django bietet einige integrierte CBVs für beliebte Anwendungsfälle, wie zum Beispiel das Anzeigen von Objektlisten oder das Erstellen neuer Objekte. Einige dieser integrierten CBVs sind:

1. Listenansicht: Diese Ansicht rendert eine Liste der aus einem Modell abgerufenen Objekte. Beispielsweise verwendet eine Seite, die alle in einem Blog verfügbaren Beiträge auflistet, a Listenansicht.
2. Detailansicht: Diese Ansicht rendert eine detaillierte Ansicht eines einzelnen Objekts, das aus einem Modell abgerufen wurde. Sie können a verwenden Detailansicht um die Details bestimmter Beiträge in einer Blog-App anzuzeigen.
3. CreateView: Diese Ansicht rendert ein Formular, um ein neues Objekt zu erstellen, und verarbeitet die Formularübermittlung. In einer Task-Manager-App verwenden Sie diese Ansicht beispielsweise zum Erstellen neuer Aufgaben.
4. Ansicht löschen: Diese Ansicht rendert eine Bestätigungsseite zum Löschen eines Objekts und übernimmt das Löschen der Seite.
5. UpdateView: Diese Ansicht rendert ein Formular, um ein vorhandenes Objekt zu aktualisieren, und verarbeitet die Übermittlung des Formulars.

Django bietet auch andere Ansichten, darunter TemplateView, RedirectView, Und FormView. Sie können darauf verweisen Djangos Dokumentation Ausführliche Informationen zu klassenbasierten Ansichten finden Sie hier.

Erstellen Sie eine Task-Manager-App mit klassenbasierten Django-Ansichten

Durch die Erstellung einer App, beispielsweise einer Task-Manager-App, erfahren Sie, wie Sie CRUD-Vorgänge mit CBVs implementieren. Ein Task-Manager verfügt über Funktionen, mit denen Benutzer Aufgaben erstellen, aktualisieren, löschen und lesen können. Diese Funktionen stehen im Einklang mit CRUD-Operationen. Die folgenden Schritte helfen Ihnen beim Erstellen einer Task-Manager-App mit Django CBVs.

Richten Sie ein Django-Projekt ein

Um eine Task-Manager-App mit Django zu erstellen, sollten Sie zunächst die folgenden Schritte ausführen:

1. Installieren Sie Django in Ihrem Virtuelle Python-Umgebung mit diesem Befehl:

   Pip Django installieren

2. Erstellen Sie ein Django-Projekt. Der folgende Befehl erstellt ein Projekt namens project_core.

   django-admin startprojekt project_core .

3. Erstellen Sie eine App namens Taskmanager.

   python manage.py startapp task_manager

4. In deinem Settings.py Fügen Sie Ihren App-Namen hinzu INSTALLED_APPS Liste.

   INSTALLED_APPS = [
   'Taskmanager',
   ]

5. Öffne das urls.py Datei in Ihrem Projektverzeichnis und konfigurieren Sie die URLs für Ihre Taskmanager App:

   aus django.urls importieren Pfad, einschließen
   URL-Muster = [
    Weg('', enthalten('task_manager.urls')),
   ]

Erstellen Sie ein Modell für Ihre Task-Manager-App

In Ihrem App-Verzeichnis (bzw Taskmanager Ordner), öffnen Sie Ihren models.py Datei und erstellen Sie ein Modell für Ihre Task-Manager-App. Hier ist ein Beispielmodell, das Sie verwenden können:

aus django.db importieren Modelle
KlasseAufgabe(Modelle. Modell):
 Titel = Modelle. CharField (max_length=200)
 Beschreibung = Modelle. Textfeld()
 abgeschlossen = Modelle. BooleanField (Standard=FALSCH)
 erstellt_at = Modelle. DateTimeField (auto_now_add=WAHR)

Migrieren Sie Ihr Modell mit diesem Befehl:

python manage.py makemigrations && python manage.py migrate

Erstellen Sie ein Django-Formular für Ihre App

Sie sollten über ein Formular zur Bearbeitung verfügen Erstellen Und Aktualisieren Operationen. Erstellen Sie in Ihrem App-Verzeichnis eine Datei mit dem Namen Formen.py. Hier ist ein Beispiel:

aus Django importieren Formen
aus .Modelle importieren Aufgabe
KlasseTaskForm(Formen. ModelForm):
KlasseMeta:
 Modell = Aufgabe
 Felder = ['Titel', 'Beschreibung', 'vollendet']
 widgets = {
'Titel': Formen. TextInput (attrs={'Klasse': 'Formkontrolle',}),
'Beschreibung': Formen. Textbereich (attrs={'Klasse': 'Formkontrolle',}),
'vollendet': Formen. CheckboxInput (attrs={'Klasse': 'Formular-Check-Eingabe'}),
 }

Der obige Code hat eine Klasse namens TaskForm welches die Felder und Widgets des Formulars definiert. Außerdem wird das zu verwendende Modell angegeben.

Erstellen Sie Django-Ansichten für jede CRUD-Operation

Eine einfache CRUD-App mit CBVs erfordert mindestens vier Ansichten, um alle Vorgänge effektiv abzuwickeln. Die nächsten Schritte zeigen Ihnen, wie Sie sie erstellen.

Importieren Sie die erforderlichen Module und Pakete

Öffne dein Ansichten.py Datei und führen Sie die folgenden Importe durch:

aus django.views.generic importieren ListView, DetailView, CreateView, UpdateView, DeleteView
aus django.urls importieren reverse_lazy
aus .Modelle importieren Aufgabe
aus .Formen importieren TaskForm

Der obige Code importiert fünf CBVs. Es importiert auch reverse_lazy um den Benutzer nach der Übermittlung eines Formulars zu einer angegebenen URL umzuleiten. Schließlich importiert es die Aufgabe Modell und die TaskForm früher erstellt.

Erstellen Sie eine Ansicht zum Auflisten von Modellobjekten

Eine Task-Manager-App sollte über eine Seite verfügen, auf der alle vom Benutzer erstellten Aufgaben aufgelistet sind. Um hierfür eine Ansicht zu erstellen, sollten Sie die verwenden Listenansicht. Hier ist ein Beispiel:

KlasseTaskListView(Listenansicht):
 Modell = Aufgabe
 template_name = 'task_manager/task_list.html'
 context_object_name = 'Aufgaben'

Die obige Ansicht definiert drei Attribute:

1. Modell: Dieses Attribut definiert, welches Modell für diese bestimmte Ansicht verwendet werden soll.
2. Vorlagenname: Dieses Attribut teilt Django mit, welche Vorlage im Browser gerendert werden soll.
3. context_object_name: Dieses Attribut definiert den Namen, der der Vorlage den Zugriff auf die Liste der Objekte im Modell ermöglicht.

Die meisten CBVs enthalten diese drei Attribute.

Erstellen Sie eine Ansicht zur Bearbeitung von Aufgabendetails

Für jede Aufgabe, die ein Benutzer erstellt, sollte eine Seite mit den zugehörigen Details vorhanden sein. Das ideale CBV, um damit umzugehen, ist DetailVew. Hier ist ein einfaches Beispiel:

KlasseTaskDetailView(Detailansicht):
 Modell = Aufgabe
 template_name = 'task_manager/task_detail.html'

Erstellen Sie eine Ansicht für die Aufgabenerstellung

Erstellen Sie eine Ansicht, um das Erstellen oder Hinzufügen neuer Aufgaben zu verwalten. Dies ist das Erstellen Teil der CRUD-Operationen, und die richtige Ansicht dafür ist die CreateView. So verwenden Sie es:

KlasseTaskCreateView(CreateView):
 Modell = Aufgabe
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('Aufgabenliste')

Der obige Code führt zwei neue Attribute ein: form_class Und success_url.

Der form_class Das Attribut teilt der Ansicht mit, welche Formularklasse gerendert und für ihre Operationen verwendet werden soll.

Der success_url Gibt an, wie der Benutzer nach dem Absenden des Formulars umgeleitet wird. Es nutzt die reverse_lazy Funktion, die den Namen eines URL-Pfads annimmt.

Erstellen Sie eine Ansicht zum Bearbeiten von Aufgaben

Damit Ihre Benutzer ihre Aufgaben bearbeiten oder aktualisieren können, sollten Sie eine Ansicht erstellen, die wie folgt aussieht:

KlasseTaskUpdateView(UpdateView):
 Modell = Aufgabe
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('Aufgabenliste')

Die obige Ansicht ähnelt der TaskCreateView früher erstellt. Der einzige Unterschied besteht in der Verwendung von UpdateView.

Erstellen Sie eine Ansicht zur Verarbeitung von Löschvorgängen

Damit Ihre Benutzer jederzeit Aufgaben löschen können, sollten Sie die verwenden Ansicht löschen CBV. Hier ist ein Beispiel:

KlasseTaskDeleteView(DeleteView):
 Modell = Aufgabe
 template_name = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('Aufgabenliste')

Konfigurieren Sie die URLs Ihrer App

Erstellen Sie in Ihrem App-Verzeichnis eine urls.py Datei und konfigurieren Sie Ihre URL-Muster wie folgt:

aus django.urls importieren Weg
aus .Ansichten importieren TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
URL-Muster = 
 Weg('', TaskListView.as_view(), name='Aufgabenliste'),
 Weg('erstellen/', TaskCreateView.as_view(), name='task_create'),
 Weg('Aufgaben//', TaskDetailView.as_view(), name='task_detail'),
 Weg('Aufgaben//update/', TaskUpdateView.as_view(), name='task_update'),
 Weg('Aufgaben//delete/', TaskDeleteView.as_view(), name='task_delete'),
]

Die oben genannten URL-Muster ähneln URLs, die mit funktionsbasierten Ansichten erstellt wurden. Der Unterschied ist der as_view() Funktion, die am Ende jedes Ansichtsnamens angehängt wird.

Du kannst Verwenden Sie Django-Slugs, um URLs zu erstellen anstelle des oben verwendeten Primärschlüssels.

Erstellen Sie Vorlagen für Ihre Ansichten

Wenn Sie Ihren Benutzern erlauben, die in den oben genannten Ansichten definierten Aktionen auszuführen, legen Sie nahe, dass Sie eine Schnittstelle bereitstellen, mit der sie interagieren können. Aus den zuvor erstellten Ansichten sollte die Task-Manager-App über vier Benutzeroberflächen verfügen.

Erstellen Sie in Ihrem App-Verzeichnis vier HTML-Vorlagen. Sie sollten auch erstellen base.html Datei. Du kannst Gestalten Sie Ihre Django-Vorlagen mit Bootstrap um Zeit zu sparen.

Vorlage für eine Aufgabenliste

Diese Vorlage sollte Code enthalten, der alle Aufgaben im Modell auflistet. Ein grobes Beispiel für den Code ist folgendes:

{% erweitert 'base.html' %}
{% Inhalt blockieren %}
<Center>
<h1>Ihre Aufgabenh1>
<Ahref=„{% url ‚task_create‘ %}“>Aufgabe hinzufügenA>
 {% für Aufgabe in Aufgaben %}
<div>
<div>
<h5>{{ task.title }}h5>
<P>{{ task.description|truncatechars: 50 }}P>
<P>
<stark>Vollendet:stark>
 {% if task.completed %}Ja{% else %}Nein{% endif %}
P>
<Ahref=„{% url ‚task_detail‘ task.pk %}“>
 Weiterlesen
A>
<Ahref=„{% url ‚task_delete‘ task.pk %}“>
 Aufgabe löschen
A>
div>
div>
 {% leer %}
<h3>Noch keine Aufgaben.h3>
<Ahref=„{% url ‚task_create‘ %}“>Aufgabe hinzufügenA>
 {% endfor %}
Center>
{% endblock %}

Mit einigen Bootstrap-Klassen können Sie Ihre Seite wie folgt aussehen lassen:

Aufgabendetailvorlage

Auf dieser Seite sollten die vollständigen Details jeder erstellten Aufgabe angezeigt werden. Hier ist eine Beispielvorlage, die Sie verwenden können:

{% erweitert 'base.html' %}
{% Inhalt blockieren %}
<h1>{{ task.title }}h1>
<P>{{ Aufgabenbeschreibung }}P>
<P>Abgeschlossen: {% if task.completed %}Ja{% else %}Nein{% endif %}P>
<Ahref=„{% url ‚task_update‘ task.pk %}“>Aufgabe bearbeitenA>
<Ahref=„{% url ‚task_delete‘ task.pk %}“>Aufgabe löschenA>
{% endblock %}

Abhängig von Ihrem Styling-Ansatz sollte Ihre Seite so aussehen:

Aufgabenformularvorlage

Diese Vorlage sollte ein Formular enthalten, mit dem der Benutzer eine Aufgabe erstellen oder aktualisieren kann.

{% erweitert 'base.html' %}
{% Inhalt blockieren %}
<h1>Aufgabe erstellenh1>
<formMethode="Post">
 {% csrf_token %}
 {{ form.as_p }}
<TasteTyp="einreichen">SpeichernTaste>
form>
{% endblock %}

Die Vorlage sieht folgendermaßen aus:

Aufgabenvorlage löschen

Diese Vorlage sollte eine Bestätigungsseite sein, um ein versehentliches Löschen von Aufgaben zu verhindern.

{% erweitert 'base.html' %}
{% Inhalt blockieren %}
<h1>Löschen bestätigenh1>
<P>Sind Sie sicher, dass Sie „{{ object.title }}“ löschen möchten?P>
<formMethode="Post">
 {% csrf_token %}
<TasteTyp="einreichen">LöschenTaste>
<Ahref=„{% url ‚task_list‘ %}“>StornierenA>
form>
{% endblock %}

Mit etwas Bootstrap sollte Ihre Seite so aussehen:

Nutzen Sie klassenbasierte Ansichten, um Ihre Produktivität zu steigern

Klassenbasierte Ansichten sind eine großartige Möglichkeit, in kurzer Zeit sauberen, organisierten Code zu schreiben und so Ihre Produktivität zu steigern. Sie sollten sie so oft wie möglich in Ihren Projekten verwenden. Darüber hinaus können Sie Funktionen wie Suchfunktionen, Benachrichtigungen usw. weiter integrieren, um Ihre Task-Manager-App zu einer vollwertigen Funktionsanwendung zu machen.