Django ist ein beliebtes Python -Framework, das zur Entwicklung von Web -Apps verwendet wird Wgsi (Webserver -Gateway -Schnittstelle) und Asgi (Asynchronous Server Gateway Interface) Serverspezifikationen. WGSI wird zur Entwicklung synchroner Python -Apps verwendet, und AGSI wird zur Entwicklung asynchroner und synchroner Web -Apps verwendet. Kanal ist eine nützliche Funktion von Django, mit der Websocket, Chat -Protokoll usw. verarbeitet wird. neben dem HTTP -Protokoll. Der Kanal basiert auf den ASGI -Serverspezifikationen. Eine interaktive Kommunikationssitzung auf zwei Wege zwischen dem Browser des Benutzers und dem Server kann mithilfe der Eröffnung geöffnet werden ein Websocket. Der Kunde initiiert die Websocket Verbindung und der Server reagieren mit einem akzeptieren oder schließen Nachricht. Der Websocket Nachrichten werden in den Kanal mit verwendet Produzenten und an die gesendet Verbraucher das hört auf den Kanal. Dieses Tutorial zeigt Ihnen, wie Sie verwendet werden Kanäle zu handhaben Websocket Mitteilungen.

Voraussetzungen

Bevor Sie das in diesem Tutorial gezeigte Skript üben.

• Installieren Sie Django Version 3+ auf Ubuntu 20+ (vorzugsweise)
• Erstellen Sie ein Django -Projekt
• Führen Sie den Django -Server aus, um zu überprüfen, ob der Server ordnungsgemäß funktioniert

Richten Sie eine Django -App ein

Führen Sie den folgenden Befehl aus, um eine Django -App mit dem Namen zu erstellen Socketapp:

$ python3 verwalten.PY StartApp Socketapp

Führen Sie den folgenden Befehl aus, um den Kanal zu installieren:

$ pip Installieren Sie Kanäle

Fügen Sie den Kanälen und den App -Namen dem hinzu Installed_app Teil der Einstellungen.py Datei:

Installed_apps = [
…
"Kanäle",
'Socketapp'
]

Definieren Sie den Wert der ASGI_Application in der Einstellungen.py Datei:

ASGI_Application = 'Channel_Pro.Asgi.Anwendung'

Erstellen Sie einen Ordner mit dem Namen Vorlagen in der Socketapp Ordner und setzen Sie den Speicherort der App der App in der Vorlagen Teil der Einstellungen.py Datei:

Vorlagen = [

… .
'Dirs': ['/home/fahmida/Channel_Pro/Socketapp/Templates'],
… .
,
]

Nach dem Ausführen des Django -Servers wird die folgende Ausgabe im Terminal angezeigt. Die Ausgabe zeigt, dass ASGI/Kanäle Version 3.0.3 läuft.

Erstellen Sie eine Vorlagendatei mit dem Namen Index.html In der definierten Vorlagespeicherort, um die vom WebSocket gesendeten Daten anzuzeigen. Das Socket -Objekt, das mit JavaScript erstellt wird.Parse () Methode, dann den Wert in den Inhalt des

Tag, das den ID -Wert enthält, 'msg.''

Index.html

text

Modifiziere den Ansichten.py Datei der Socketapp mit dem folgenden Inhalt. Der Index.html Die Vorlagendatei wird im Browser mit dem angezeigt Text Variable, wenn die Index() Die Methode dieses Skripts wird aus dem aufgerufen URLs.py Datei. Wenn keine Nachricht aus der Socket übertragen wird, dann der Text 'LinuxHint'wird im Browser angezeigt.

Ansichten.py

# Rendermodul aus Django importieren
von django.Verknüpfungen importieren Render
# Erstellen Sie die Indexfunktion, um die HTML -Datei im Browser anzuzeigen
Def Index (Anfrage):
Rückgabe rendern (Anfrage, "Index.html ", context = 'text': 'LinuxHint')

Modifiziere den URLs.py Datei der Socketapp mit dem folgenden Inhalt. Zwei Pfade sind im Skript definiert: das ''Administrator/'Pfad wird verwendet, um das Django Administration Dashboard und das' zu öffnenNachricht/'Pfad wird verwendet, um die WebSocket -Nachricht zu lesen.

URLs.py

von django.Import Administrator beibringen
von django.URLS -Importweg
aus SocketApp -Importansichten
urlpatterns = [
Pfad ('Admin/', Administrator.Grundstück.URLs),
Pfad ('msg/', Ansichten.Index)
]

Wenn die folgende URL ausgeführt wird, ohne die Verbraucher- und Routing -Dateien zu definieren, funktioniert das HTTP -Protokoll und die folgende Ausgabe wird angezeigt.

http: // localhost: 8000/msg

Erstellen Sie jetzt eine Verbraucher.py Datei in der Socketapp Ordner mit dem folgenden Skript. Der verbinden() Methode von WS_CONSUMER Wird verwendet, um die Socket -Verbindung zu akzeptieren, den aktuellen Zeitwert jede Sekunde zu lesen und die aktuelle Zeit im JSON -Format über WebSocket zu senden, wenn diese Methode aus der Routing -Datei aufgerufen wird.

Verbraucher.py

# JSON -Modul importieren
JSON importieren
# WebSocketConsumer importieren
Aus Kanälen.generisch.WebSocket importieren WebSocketConsumer
# Das DateTime -Modul importieren
Aus der DateTime -Importdatetime importieren
# Schlafmodul importieren
Zum Zeitpunkt des Imports
# Definieren Sie die Verbraucherklasse, um die Daten über WebSocketConsumer zu senden
Klasse WS_CONSUMER (WebSocketConsumer):
Def Connect (Selbst):
selbst.akzeptieren()
während (wahr):
jetzt = datetime.Jetzt()
selbst.Senden (JSON.Dumps ('TimeValue': Jetzt.Strftime ("%H:%m:%s")))
Schlaf (1)

Erstellen die Routing.py in der Socketapp Ordner mit dem folgenden Skript. Der 'Nachricht/'Pfad wird im Skript definiert, um den Verbraucher für das Senden der Daten an den Socket anzurufen.

Routing.py

von django.URLS -Importweg
aus .Verbraucher importieren WS_Consumer
# Setzen Sie den Pfad, den Verbraucher anzurufen
WS_URLPATTERNS = [
Path ('msg/', WS_Consumer.As_asgi ())
]

Modifiziere den Asgi.py Datei mit dem folgenden Skript. Die Module, die zur Behandlung von HTTP- und WebSocket -Anfragen erforderlich sind, werden im Skript importiert.

Asgi.py

# Betriebssystemmodul importieren
OS importieren
# Importieren Sie Get_asgi_Application, um das HTTP -Protokoll zu verarbeiten
von django.Kern.ASGI importieren get_asgi_application
# Protokollyperouter und Urlrouter importieren, um das WebSocket -Routing festzulegen
Aus Kanälen.Routing -Importprotokollyperouter, Urlrouter
# Authmiddlewarestack importieren, um WebSocket zu verarbeiten
Aus Kanälen.Auth Import Authmiddlewarestack
# Websocket -Routing importieren
von Socketapp.Routing importieren ws_urlpatterns
# Wert für django_Setings_module zuweisen
Betriebssystem.Umwelt.setDefault ('Django_Setings_Module', 'Channel_Pro.Einstellungen')
# Definieren Sie die Anwendungsvariable, um HTTP und WebSocket zu verarbeiten
application = protocoltyperouter (
'http': get_asgi_application ()),
'WebSocket': AuthMiddleWarestack (Urlrouter (WS_URLPATTERNS))
)

Führen Sie nun die folgende URL erneut aus dem Browser aus, um die Daten aus dem WebSocket zu lesen.

http: // localhost: 8000/msg/

Wenn Verbraucher und Router ordnungsgemäß funktionieren, wird die folgende digitale Uhr im Browser angezeigt. Hier hat der Router die WebSocket -Anfrage mit der 'gesendet' gesendet 'Nachricht/'Pfad zum Verbraucher, der die Anforderung akzeptiert und die Daten an die Vorlage gesendet hat, um die digitale Uhr im Browser anzuzeigen, in der der zweite Wert der aktuellen Zeit die gesamte Sekunde aktualisiert.

Abschluss

Dieses Tutorial hat Ihnen gezeigt. Andere Arten von Echtzeitanwendungen können auch mit Django und Kanälen wie Online-Chat-Systemen implementiert werden. Die in diesem Tutorial verwendeten Skripte funktionieren nur für Django -Versionen 3+ und Kanalversionen 3+. Wenn Sie also eine frühere Django- oder Kanalversion verwenden, müssen Sie die Version aktualisieren, bevor Sie das in diesem Tutorial bereitgestellte Skript testen.