Programmation serveur Python : implémentation de WebSockets à l'aide de canaux Django

Dans le développement Web d'aujourd'hui, la communication en temps réel est l'une des fonctionnalités indispensables. Le protocole HTTP étant un protocole requête-réponse, il est très peu pratique d'utiliser la méthode HTTP traditionnelle pour établir une communication en temps réel. Le protocole WebSockets est un protocole émergent qui offre des capacités de communication bidirectionnelle en temps réel pour les applications Web et peut envoyer et recevoir des données sur la même connexion, ce qui le rend très adapté aux applications en temps réel. Dans la programmation serveur Python, les WebSockets peuvent être facilement implémentés à l'aide du framework django-channels.

1. Installer Django-channels

Avant de commencer à utiliser Django-channels, vous devez d'abord l'installer. Il peut être installé en utilisant pip :

pip install channels

2. Créez un projet Django

Ensuite, créez un projet Django. Dans Django 2.x et supérieur, vous pouvez utiliser l'outil de ligne de commande pour créer un projet :

django-admin startproject myproject

3. Configurer les canaux Django

Après avoir installé les canaux Django, vous devez l'ajouter au projet Django. Ouvrez le fichier settings.py et ajoutez des « canaux » dans INSTALLED_APPS. De plus, certains paramètres doivent être configurés pour Django-channels :

# settings.py

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

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

Dans le code ci-dessus, ASGI_APPLICATION spécifie le point d'entrée de l'application ASGI, tandis que CHANNEL_LAYERS spécifie le type et les paramètres de la couche de canal par défaut. Dans cet exemple, InMemoryChannelLayer est utilisé, qui est une couche de canal qui implémente un stockage mémoire simple.

4. Créer une route

Avant de créer l'application django-channels, vous devez créer une route pour acheminer les requêtes WebSocket entrantes. Une route est une table de mappage qui mappe les chemins d'URL à des classes de consommateurs spécifiques. Dans Django, les routes sont généralement définies dans le fichier urls.py, mais dans Django-channels, puisqu'il utilise le protocole ASGI, les routes sont définies dans router.py comme suit :

# 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()),
    ]),
})

Dans le code ci-dessus, nous utilisons ProtocolTypeRouter crée une route de protocole et configure une sous-route basée sur WebSocket. Dans cet exemple, l'URL demandée par le WebSocket est /ws/, et la classe MyConsumer sera utilisée lors de la connexion.

5. Créer un consommateur

Dans les canaux Django, Consumer est une classe qui gère les requêtes réseau. La demande peut être acheminée vers le consommateur sur l'itinéraire, puis le consommateur traitera la demande et renverra la réponse. Le consommateur est généralement implémenté par une méthode de définition asynchrone (c'est-à-dire une coroutine). Lors de la création d'un Consumer, vous devez hériter de la classechannels.generic.websocket.WebSocketConsumer et implémenter deux méthodes :

• connect(self) : django-channels appelle cette méthode lorsqu'une connexion WebSocket est établie.
• receive(self, text_data=None, bytes_data=None) : Cette méthode est appelée par Django-channels lorsque les données sont reçues de la connexion WebSocket.

Voici un exemple consommateur simple :

# 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. Démarrez le serveur Django

Maintenant que tous les paramètres sont terminés, vous pouvez démarrer le serveur Django et tester la connexion WebSocket. Entrez la commande suivante dans le terminal pour démarrer le serveur Django :

python manage.py runserver

Si tout est normal, vous devriez pouvoir tester la connexion WebSocket via http://127.0.0.1:8000/ws/. La méthode connect du WebSocket Consumer sera exécutée.

Résumé :

Utiliser les canaux Django pour implémenter WebSocket est très simple et ne nécessite fondamentalement que quelques étapes. Une chose à noter est que dans les applications de canaux Django, les coroutines asyncio sont souvent utilisées, par conséquent, Python 3.5 et supérieur est requis. De plus, la configuration de la couche canal est également très importante. Si vous souhaitez utiliser un stockage persistant, vous pouvez utiliser d'autres couches canal, telles que RedisChannelLayer.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!