Kuidas Django-s on WebSocket töö rakendatud?

Django WebSocket-idega töötamine toimub väliste raamatukogude abil, millest populaarseim on Django Channels. Django Channels laiendab Django võimalusi, lisades toe asünkroonsetele protokollidele, nagu WebSocket.

Peamised komponendid:

1. ASGI (Asynchronous Server Gateway Interface): Standard, mis asendab WSGI ja pakub liidest asünkroonsetele veebiserveritele.
2. Channels: Peamine raamatukogu, mis pakub tööriistu ASGI ja WebSocket-idega töötamiseks.
3. Channel Layers: Komponent sõnumite vahetamiseks Django eksemplaride ja teiste teenuste vahel. Vajalik broadcast-sõnumite ja koordineerimise jaoks erinevate tööprotsesside vahel.

Integratsiooniprotsess:

1. Paigaldamine:

   pip install channels daphne
   

2. settings.py konfiguratsioon:

   // settings.py
   
   INSTALLED_APPS = [
       // ... teised rakendused
       'channels',
   ]
   
   ASGI_APPLICATION = 'your_project_name.asgi.application' // Tee ASGI rakendusele
   

3. Loo asgi.py:

   // your_project_name/asgi.py
   
   import os
   
   from channels.auth import AuthMiddlewareStack // Autentimiseks
   from channels.routing import ProtocolTypeRouter, URLRouter // Marsruutimiseks
   from channels.security.websocket import AllowedHostsOriginValidator // Turvalisuse jaoks
   from django.core.asgi import get_asgi_application // WSGI asendamine
   
   from your_app_name import routing // WebSocket marsruudid
   
   os.environ.setdefault("DJANGO_SETTINGS_MODULE", "your_project_name.settings")
   // Kasutame get_asgi_application WSGI asemel
   django_asgi_app = get_asgi_application()
   
   application = ProtocolTypeRouter({
       "http": django_asgi_app, // HTTP-päringud töödeldakse standardviisil
       "websocket": AllowedHostsOriginValidator( // WebSocket marsruutimine
           AuthMiddlewareStack( // Valikuline, autentimiseks
               URLRouter(routing.websocket_urlpatterns) // WebSocket marsruudid
           )
       ),
   })
   

4. Loo consumers.py: Need on asünkroonilised funktsioonid või klassid, mis töötlevad WebSocket-ühendusi:

   // your_app_name/consumers.py
   
   import json
   
   from channels.generic.websocket import AsyncWebsocketConsumer // Asünkrooniline consumer
   
   class ChatConsumer(AsyncWebsocketConsumer):
       async def connect(self):
           // Ühenduse loomise töötlemine
           self.room_name = self.scope["url_route"]["kwargs"]["room_name"]
           self.room_group_name = f"chat_{self.room_name}"
   
           // Liitumine Channel Layer grupiga
           await self.channel_layer.group_add(self.room_group_name, self.channel_name)
   
           await self.accept() // Ühenduse aktsepteerimine
   
       async def disconnect(self, close_code):
           // Ühenduse sulgemise töötlemine
           await self.channel_layer.group_discard(self.room_group_name, self.channel_name) // Lahkumine grupist
   
       async def receive(self, text_data):
           // Sissetulevate sõnumite töötlemine
           text_data_json = json.loads(text_data)
           message = text_data_json["message"]
   
           // Sõnumi saatmine grupile Channel Layer kaudu
           await self.channel_layer.group_send(
               self.room_group_name, {"type": "chat.message", "message": message}
           )
   
       async def chat_message(self, event):
           // Sõnumite töötlemine, mis on saadud Channel Layer-ist
           message = event["message"]
   
           // Sõnumi saatmine tagasi kliendile WebSocket-i kaudu
           await self.send(text_data=json.dumps({"message": message}))
   

5. Loo routing.py: Marsruutide määratlemine WebSocket-ühenduste jaoks:

   // your_app_name/routing.py
   
   from django.urls import re_path // Regulaaravaldiste kasutamine URL-ides
   
   from . import consumers // Consumer-ite import
   
   websocket_urlpatterns = [
       re_path(r"ws/chat/(?P<room_name>\w+)/$", consumers.ChatConsumer.as_asgi()), // Marsruut WebSocket-ile
   ]
   

6. ASGI-server: Projekti käivitamine ASGI-serveri, näiteks Daphne või Uvicorn, abil:

   daphne your_project_name.asgi:application
   

Seega võimaldab Django Channels töödelda WebSocket-päringuid asünkroonselt, kasutades Consumers-ite loogikat ja Channel Layers sõnumite vahetamiseks.