Python-Serverprogrammierung: WebSockets mithilfe von Django-Kanälen implementieren

In der heutigen Webentwicklung ist Echtzeitkommunikation eine der unverzichtbaren Funktionen. Da es sich beim HTTP-Protokoll um ein Anforderungs-Antwort-Protokoll handelt, ist es sehr unpraktisch, die herkömmliche Methode von HTTP zu verwenden, um eine Echtzeitkommunikation zu erreichen. Das WebSockets-Protokoll ist ein aufstrebendes Protokoll, das bidirektionale Echtzeit-Kommunikationsfunktionen für Webanwendungen bietet und Daten über dieselbe Verbindung senden und empfangen kann, wodurch es sich sehr gut für Echtzeitanwendungen eignet. In der Python-Serverprogrammierung können WebSockets mithilfe des Django-Channels-Frameworks einfach implementiert werden.

1. Installieren Sie Django-Channels

Bevor Sie Django-Channels verwenden, müssen Sie es zunächst installieren. Es kann mit pip installiert werden:

pip install channels

2. Erstellen Sie ein Django-Projekt

Als nächstes erstellen Sie ein Django-Projekt. In Django 2.x und höher können Sie das Befehlszeilentool verwenden, um ein Projekt zu erstellen:

django-admin startproject myproject

3. Django-Kanäle konfigurieren

Nach der Installation von Django-Kanälen müssen Sie es dem Django-Projekt hinzufügen. Öffnen Sie die Datei „settings.py“ und fügen Sie „channels“ in INSTALLED_APPS hinzu. Darüber hinaus müssen einige Einstellungen für Django-Kanäle konfiguriert werden:

# settings.py

# 添加channels到INSTALLED_APPS
INSTALLED_APPS = [
    # ...
    'channels',
]

# 配置channels
ASGI_APPLICATION = 'myproject.routing.application'
CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels.layers.InMemoryChannelLayer',
    },
}

Im obigen Code gibt ASGI_APPLICATION den Einstiegspunkt der ASGI-Anwendung an, während CHANNEL_LAYERS den Typ und die Parameter der Standardkanalebene angibt. In diesem Beispiel wird InMemoryChannelLayer verwendet, eine Kanalschicht, die einfache Speicherspeicherung implementiert.

4. Route erstellen

Bevor Sie die Django-Channels-Anwendung erstellen, müssen Sie eine Route erstellen, um eingehende WebSocket-Anfragen weiterzuleiten. Eine Route ist eine Zuordnungstabelle, die URL-Pfade bestimmten Verbraucherklassen zuordnet. In Django werden Routen normalerweise in der Datei urls.py definiert, aber in Django-Channels werden die Routen in Routing.py wie folgt definiert, da es das ASGI-Protokoll verwendet:

# myproject/routing.py

from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path

application = ProtocolTypeRouter({
    # WebSocket使用的协议类型是“websocket”，将它放在第一位
    "websocket": URLRouter([
        path("ws/", MyConsumer.as_asgi()),
    ]),
})

Im obigen Code verwenden wir ProtocolTypeRouter erstellt eine Protokollroute und richtet eine WebSocket-basierte Unterroute ein. In diesem Beispiel lautet die vom WebSocket angeforderte URL /ws/ und beim Herstellen der Verbindung wird die MyConsumer-Klasse verwendet.

5. Verbraucher erstellen

In Django-Kanälen ist Consumer eine Klasse, die Netzwerkanfragen verarbeitet. Die Anforderung kann über die Route an den Verbraucher weitergeleitet werden. Anschließend verarbeitet der Verbraucher die Anforderung und gibt die Antwort zurück. Consumer wird im Allgemeinen durch eine asynchrone Def-Methode (d. h. Coroutine) implementiert. Beim Erstellen eines Verbrauchers müssen Sie die Klasse „channels.generic.websocket.WebSocketConsumer“ erben und zwei Methoden implementieren:

• connect(self): django-channels ruft diese Methode auf, wenn eine WebSocket-Verbindung hergestellt wird.
• receive(self, text_data=None, bytes_data=None): Diese Methode wird von Django-Channels aufgerufen, wenn Daten von der WebSocket-Verbindung empfangen werden.

Hier ist ein einfaches Consumer-Beispiel:

# myapp/consumers.py

import asyncio
import json

from channels.generic.websocket import AsyncWebsocketConsumer


class MyConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        """
        WebSocket连接建立时执行。
        """
        await self.accept()

    async def disconnect(self, code):
        """
        WebSocket连接中断时执行。
        """
        pass

    async def receive(self, text_data=None, bytes_data=None):
        """
        当从WebSocket连接接收到数据时执行。
        """
        # 解析WebSocket发送的JSON数据
        data = json.loads(text_data)
        # 从JSON数据中获取请求
        request = data['request']

        # 这里是处理请求的代码
        # ...

        # 发送响应到WebSocket连接
        response = {'status': 'OK', 'data': request}
        await self.send(json.dumps(response))

6. Django-Server starten

Da nun alle Einstellungen abgeschlossen sind, können Sie den Django-Server starten und die WebSocket-Verbindung testen. Geben Sie im Terminal den folgenden Befehl ein, um den Django-Server zu starten:

python manage.py runserver

Wenn alles normal ist, sollten Sie die WebSocket-Verbindung über http://127.0.0.1:8000/ws/ testen können. Die Connect-Methode des WebSocket Consumer wird ausgeführt.

Zusammenfassung:

Die Verwendung von Django-Kanälen zur Implementierung von WebSocket ist sehr einfach und erfordert im Grunde nur wenige Schritte. Zu beachten ist, dass in Django-Channels-Anwendungen häufig Asyncio-Coroutinen verwendet werden, weshalb Python 3.5 und höher erforderlich ist. Darüber hinaus ist auch die Konfiguration der Kanalschicht sehr wichtig. Wenn Sie persistenten Speicher verwenden möchten, können Sie andere Kanalschichten wie RedisChannelLayer verwenden.

Das obige ist der detaillierte Inhalt vonPython-Serverprogrammierung: WebSockets mithilfe von Django-Kanälen implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!