Wie man eine Django-Ansicht für die Webentwicklung erstellt

Einführung

Wenn Sie unsere Django-Entwicklungsreihe verfolgt haben, haben Sie erfolgreich eine Django-Anwendung erstellt, die es Benutzern mit Administratorrechten ermöglicht, über das Django-Admin-Dashboard Kommentare und Beiträge hinzuzufügen. Außerdem haben Sie die Datenspeicherung mithilfe der ORM-Lösungsmodelle von Django und MySQL eingerichtet.

In diesem Tutorial erstellen wir Django-Views, die es unserer Webanwendung ermöglichen, Webanfragen korrekt zu verarbeiten und die erforderlichen Webantworten zurückzugeben. Wie in der Django-Dokumentation definiert, kann eine Webantwort der HTML-Inhalt einer Webseite, eine Weiterleitung oder ein HTTP-Fehler (z. B. 404) sein. Der Code für die View-Funktionen kann sich prinzipiell an beliebiger Stelle in Ihrem Projekt befinden, solange er sich im Python-Pfad befindet. Es gibt jedoch einige gängige Konventionen für die Benennung und den Speicherort der Datei, die diese View-Funktionen enthält, und wir werden diese Schritte befolgen.

Sobald Sie die Schritte in diesem Tutorial abgeschlossen haben, ruft Ihre Django-Blogseite einen aktuellen Beitrag unter Ihrer IP- oder Domain/Beitrags-URL ab.

Voraussetzungen

Dieses Tutorial ist Teil der Django-Entwicklungsreihe und eine Fortsetzung dieser Reihe.

Falls Sie diese Serie bisher nicht verfolgt haben, gehen wir von folgenden Annahmen aus:

• Sie haben Django Version 4 oder höher installiert.
• Sie haben Ihre Django-Anwendung mit einer Datenbank verbunden.
• Sie arbeiten mit einem Unix-basierten Betriebssystem, vorzugsweise einem Ubuntu 22.04 Cloud-Server, da wir mit diesem System getestet haben.
• Sie haben Ihre Django-Verwaltungsoberfläche eingerichtet.

Da sich dieser Leitfaden hauptsächlich mit Django-Views befasst, können Sie ihm möglicherweise auch dann folgen, wenn Sie eine andere Konfiguration verwenden.

Schritt 1 – Anzeigefunktionen erstellen

Im Terminal müssen Sie zunächst in das entsprechende Verzeichnis wechseln und Ihre Python-Umgebung aktivieren. Wenn Sie dieser Artikelserie gefolgt sind, können Sie die folgenden Befehle eingeben. Es ist wichtig, bei der Entwicklung Ihrer Anwendung stets die Python-Entwicklungsumgebung zu verwenden, um sicherzustellen, dass Ihr Code korrekt gekapselt ist und mit den richtigen Einstellungen funktioniert.

cd ~/my_blog_app
. env/bin/activate

Nachdem Ihre virtuelle Umgebung nun aktiviert ist, wechseln wir in das Blog-Verzeichnis der Website, wo wir eine Python-Datei öffnen und unsere erste View-Funktion erstellen.

cd ~/my_blog_app/blog/blogsite

Öffnen Sie die Datei views.py zum Bearbeiten mit nano oder einem Texteditor Ihrer Wahl.

nano views.py

Nach dem Öffnen der Datei sollte diese mit Code gefüllt sein, der in etwa so aussieht:

from django.shortcuts import render
# Create your views here.

Wir behalten die Importanweisung bei, die die Funktion `render()` aus der Bibliothek `django.shortcuts` importiert. Mit der Funktion `render()` können wir eine Vorlage und einen Text kombinieren, um das entsprechende `HttpResponse`-Objekt zurückzugeben. Beachten Sie dies, da wir bei jeder von uns erstellten Ansicht für die Instanziierung, Befüllung und Rückgabe des `HttpResponse`-Objekts verantwortlich sind.

Als Nächstes fügen wir unsere erste Ansicht hinzu, die Benutzer auf der Startseite begrüßt. Dazu importieren wir die Funktion `HttpResponse()` aus der Django-http-Bibliothek. Mithilfe dieser Funktion senden wir einen Text, der beim Aufruf der Webseite angezeigt wird.

from django.shortcuts import render
from django.http import HttpResponse
def index(request):
return HttpResponse('Hello, welcome to the index page.')

Anschließend fügen wir eine weitere Funktion hinzu, die die einzelnen Beiträge anzeigt, die wir später im Tutorial erstellen werden.

...
def individual_post(request):
return HttpResponse('Hi, this is where an individual post will be.')

Unsere endgültige views.py-Datei sieht nun folgendermaßen aus.

from django.http import HttpResponse
from django.shortcuts import render
def index(request):
return HttpResponse('Hello, welcome to the index page.')
def individual_post(request):
return HttpResponse('Hi, this is where an individual post will be.')

Wenn Sie die Bearbeitung der Datei abgeschlossen haben, speichern und beenden Sie das Programm. In nano können Sie dazu STRG und X, dann Y und anschließend die Eingabetaste drücken.

Da diese Funktionen aktuell noch keine spezifische URL haben, müssen wir sie im URL-Musterblock unserer URL-Konfigurationsdatei hinzufügen. Nachdem die Ansichten hinzugefügt wurden, ordnen wir ihnen nun über diese Konfigurationsdatei URLs zu, um die erstellten Seiten anzuzeigen.

Schritt 2 – URLs in Ansichten anzeigen

Mit Django können wir eigene URLs für unsere Anwendung entwerfen. Dies geschieht in reinem Python mithilfe einer Datei, die üblicherweise als URLconf- oder «URL-Konfigurationsdatei» bezeichnet wird.

Um eine Webseite anzuzeigen, muss Django zunächst das zu verwendende URLconf-Modul ermitteln und anschließend nach URL-Mustern suchen. Diese URL-Muster werden in einer Listenstruktur gespeichert. Django durchläuft dann jedes URL-Muster, bis es die erste Übereinstimmung findet. Sobald eine Übereinstimmung gefunden wurde, ermittelt Django die zugehörige Ansicht. Die Funktion dieser Ansicht empfängt die Daten für das URL-Muster und ein HttpRequest-Objekt. Tritt an irgendeiner Stelle dieses Prozesses ein Fehler auf, wird stattdessen eine Fehlerbehandlungsansicht angezeigt.

In diesem Abschnitt werden wir mit zwei verschiedenen urls.py-Dateien in zwei verschiedenen Verzeichnissen unserer Anwendung arbeiten.

Sobald Sie sich im Verzeichnis ~/my_blog_app/blog/blogsite befinden, öffnen Sie die Datei urls.py – auch bekannt als Ihre URL-Konfigurationsdatei – zur Bearbeitung. Hier verwenden wir nano zum Bearbeiten der Datei.

nano urls.py

Ändern Sie die Datei so, dass sie wie die unten stehende Datei mit einer Liste von URL-Mustern aussieht.

from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
path('post/', views.individual_post, name='individual_post')
]

Sobald Sie die oben genannten Zeilen hinzugefügt haben, speichern und schließen Sie die Datei.

Wenn wir die URL-Konfigurationsdatei des Blog-Verzeichnisses aktualisieren, müssen wir sie dort ablegen, da sie sonst nicht erkannt wird. Dies ist notwendig, da sie in unserer Konfigurationsdatei als ROOT_URLCONF festgelegt ist. Das bedeutet, dass Django die URL-Konfigurationsdatei des Blog-Verzeichnisses nach URL-Mustern durchsucht.

Um Ihre Blog-URL-Konfiguration in Ihre Blog-URL-Konfiguration einzubinden, müssen Sie in dieses Verzeichnis wechseln.

cd ~/my_blog_app/blog/blog

Dort angekommen, können Sie die URLconf-Datei mit nano oder einem anderen Texteditor Ihrer Wahl öffnen.

nano urls.py

In dieser Datei fügen wir die folgenden Zeilen hinzu, um die Datei /blogsite/urls.py einzubinden, mit der wir gerade gearbeitet haben und die in der zweiten Zeile angezeigt wird.

from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blogsite.urls'))
]

Datei speichern und schließen.

Öffnen wir nun einen Webbrowser, um die erstellten URLs aufzurufen und zu überprüfen, ob der hinzugefügte Text angezeigt wird. Wir müssen in das übergeordnete Verzeichnis wechseln, um auf die Datei manager.py zuzugreifen, die die Django-Anwendung bereitstellt.

cd ..

Führen Sie folgenden Befehl aus. Ersetzen Sie 0.0.0.0 durch Ihre IP-Adresse (siehe unten).

python manage.py runserver 0.0.0.0:8000

Rufen Sie in Ihrem Webbrowser Ihre IP-Adresse, Port 8000 auf:

your-server-ip:8000

Sie erhalten eine Webseite, die in etwa wie folgt aussieht:

Begeben Sie sich anschließend zu folgender Adresse:

your-server-ip:8000/post/

Von hier aus sollte die folgende Webseite angezeigt werden:

Nachdem wir nun überprüft haben, dass die beiden urls.py-Dateien funktionieren und die Daten genau das anzeigen, was wir erwarten, fügen wir unserem Blog einige echte Daten hinzu.

Schritt 3 – Einen Blogbeitrag erstellen

Nachdem Sie nun die Grundlagen der Funktionsweise von URL-Mustern und Ansichten verstanden haben, fügen wir einen Blogbeitrag hinzu und lassen ihn auf einer Webseite anzeigen, anstatt des Textes, den wir in Python-Dateien codiert haben.

Wir erstellen einen Beitrag über die zuvor eingerichtete Admin-Seite. Während Ihr Server die Django-Anwendung ausführt, navigieren Sie mit einem Webbrowser zur Blog-Admin-Seite unter folgender Adresse:

your-server-ip:8000/admin/blogsite/

Klicken Sie in der Benutzeroberfläche auf den Link „+ Hinzufügen“ in der Zeile „Beiträge“, um die Datenbank mit einem Beispiel-Blogbeitrag zu füllen.

Durch Klicken auf den Link gelangen Sie zu einem Eingabeformular wie dem folgenden:

Wenn Sie einen Beitrag hinzufügen möchten, rufen Sie diese Seite auf. Alternativ können Sie bestehende Beiträge über den Bearbeitungslink bearbeiten.

Im Formular können Sie die folgenden Felder bearbeiten:

• TitelFügen Sie hier Ihren gewünschten Blogbeitragstitel ein, zum Beispiel Mein erster Blogbeitrag.
• SLUG: Dies bezeichnet den Teil der URL, der ein gültiges Webadressenelement mit lesbaren Schlüsselwörtern kennzeichnet. Dieser Teil wird üblicherweise aus dem Seitentitel übernommen, in diesem Fall also „mein erster Blogbeitrag“.
• INHALT: Dies ist der Text Ihres Blogbeitrags. Wir fügen in diesem Beispiel einfach „Hallo Welt!“ hinzu, aber hier können Sie gerne ausführlicher schreiben.
• AUTOR: Tragen Sie hier Ihren Namen oder Benutzernamen ein. Wir verwenden Sami.

Füllen Sie das Blogbeitragsformular nach Ihren Vorstellungen für Ihre Testzwecke aus.

Sobald Sie die Beispieldaten zur Seite hinzugefügt haben, klicken Sie auf die Schaltfläche SPEICHERN. Sie erhalten anschließend die folgende Bestätigungsseite:

Herzlichen Glückwunsch! Sie haben Ihren ersten Blogbeitrag erstellt!

Als Nächstes überprüfen wir, ob eine Zeile in der MySQL-Datenbank hinzugefügt wurde, die die Daten enthält, die wir gerade in die Verwaltungsschnittstelle eingegeben haben.

Schritt 4 – Anzeigen der Datenbankdaten

Nun müssen wir zu MySQL wechseln. Beenden Sie dazu den aktuellen Serverprozess über das Terminal mit Strg + C und öffnen Sie anschließend den MySQL-Interpreter. Der Benutzername für unsere Django-Anwendungsdatenbank ist „djangouser“. Stellen Sie jedoch sicher, dass Sie den für Ihr Projekt passenden Benutzer verwenden.

mysql -u djangouser

Sobald Sie sich an der MySQL-Eingabeaufforderung befinden, navigieren Sie zur Datenbank blog_data (oder zu der für Ihr Projekt geeigneten Datenbank):

use blog_data;

Anschließend wird der Inhalt der Tabelle blogsite_post angezeigt.

select * from blogsite_post;

Sie erhalten eine Ausgabe ähnlich der unten stehenden, die die Informationen anzeigen sollte, die Sie der Admin-Oberfläche hinzugefügt haben.

Output
+----+--------------------+--------------------+---------------+----------------------------+--------+
| id | title | slug | content | created_on | author |
+----+--------------------+--------------------+---------------+----------------------------+--------+
| 1 | My First Blog Post | my-first-blog-post | Hello, World! | 2020-05-14 00:30:03.186564 | Sammy |
+----+--------------------+--------------------+---------------+----------------------------+--------+
1 row in set (0.00 sec)

Wie in der Ausgabe zu sehen ist, gibt es eine Zeile mit den hinzugefügten Beitragsdaten. Nun greifen wir in der View-Funktion für Beiträge auf diese Daten zu. Drücken Sie Strg + D, um den MySQL-Interpreter zu beenden.

Navigieren Sie zum Speicherort der views.py-Datei innerhalb der Blog-Anwendung Ihrer Website.

cd ~/my_blog_app/blog/blogsite

Öffnen Sie nun die Datei, damit wir unsere neuen Informationen hinzufügen können.

nano views.py

Bearbeiten Sie die Datei wie die unten stehende.

from django.shortcuts import render
from django.http import HttpResponse
from .models import Post
def index(request):
return HttpResponse('Hello, welcome to the index page.')
def individual_post(request):
recent_post = Post.objects.get(id__exact=1)
return HttpResponse(recent_post.title + ': ' + recent_post.content)

Im obigen Code haben wir eine zusätzliche Importanweisung für Post hinzugefügt. Außerdem haben wir die Zeichenkette in Anführungszeichen aus der HttpResponse entfernt und durch unsere Blogbeitragsdaten ersetzt. Um auf die Daten eines bestimmten Objekts zuzugreifen, verwenden wir die Blogbeitrags-ID des anzuzeigenden Objekts und speichern diese ID in einer Variable namens `last_post`. Anschließend können wir bestimmte Felder dieses Objekts abrufen, indem wir das Feld mit einem Punkt als Trennzeichen anhängen.

Nach dem Speichern und Schließen der Datei navigieren Sie zum Speicherort der Datei manager.py, um die Django-Anwendung auszuführen.

cd ~/my_blog_app/blog
python manage.py runserver 0.0.0.0:8000

Öffnen Sie einen Webbrowser und rufen Sie folgende Adresse auf:

your-server-ip:8000/post/

Hier sehen wir die vorgenommenen Änderungen. Die Seite wird in etwa so aussehen und den Text anzeigen, den Sie dem Beitrag hinzugefügt haben.

Wenn Sie die Seite vollständig untersucht haben, drücken Sie im Terminal STRG + C, um den Ausführungsprozess zu beenden.

Um Ihre Entwicklungsumgebung zu deaktivieren, können Sie den Befehl disable eingeben und sich anschließend vom Server abmelden.

Ergebnis

In diesem Tutorial haben wir Ansichten erstellt, URL-Muster zugeordnet und Text aus unserer Blog-Beitragsdatenbank auf einer Webseite angezeigt.

Im nächsten Tutorial erfahren Sie, wie Sie mit HTML ein ästhetisch ansprechenderes Django-Template erstellen. Bisher haben wir uns in dieser Reihe mit Django-Modellen und Django-Views beschäftigt. Templates bilden den letzten wichtigen Baustein für die Grundlage einer Django-Anwendung.