Как в Django реализована работа с WebSocket?

# Как в Django реализована работа с WebSocket?

Django не имеет встроенной поддержки WebSocket в основном фреймворке. Однако есть несколько способов добавить WebSocket функциональность.

Почему Django не поддерживает WebSocket из коробки?

Django основан на WSGI (Web Server Gateway Interface), который работает по модели request-response. WebSocket требует долгоживущих соединений (persistent connections), что требует ASGI (Asynchronous Server Gateway Interface).

Способы реализации WebSocket в Django

1. Django Channels (самый популярный)

Django Channels добавляет ASGI поддержку и позволяет работать с WebSocket.

Установка

pip install channels channels-redis daphne

Настройка (settings.py)

INSTALLED_APPS = [
    'daphne',  # WebSocket сервер
    'channels',
    'django.contrib.auth',
    # ...
]

# Использовать ASGI вместо WSGI
ASGI_APPLICATION = 'myproject.asgi.application'

# Message broker для распределённых систем
CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            'hosts': [('127.0.0.1', 6379)],
        },
    }
}

ASGI конфигурация (asgi.py)

import os
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from django.core.asgi import get_asgi_application
import myapp.routing

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

application = ProtocolTypeRouter({
    'http': get_asgi_application(),  # HTTP запросы
    'websocket': AuthMiddlewareStack(  # WebSocket подключения
        URLRouter(
            myapp.routing.websocket_urlpatterns
        )
    ),
})

Маршруты WebSocket (routing.py)

from django.urls import re_path
from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
]

Consumer (обработчик WebSocket)

import json
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        """Когда клиент подключается"""
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = f'chat_{self.room_name}'
        
        # Добавляем в группу
        await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )
        
        # Принимаем соединение
        await self.accept()
    
    async def disconnect(self, close_code):
        """Когда клиент отключается"""
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )
    
    async def receive(self, text_data):
        """Когда получаем сообщение от клиента"""
        data = json.loads(text_data)
        message = data['message']
        
        # Отправляем сообщение всем в группе
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message',  # Вызовет метод chat_message
                'message': message
            }
        )
    
    async def chat_message(self, event):
        """Отправляем сообщение клиенту"""
        message = event['message']
        
        await self.send(text_data=json.dumps({
            'message': message
        }))

JavaScript клиент

const chatSocket = new WebSocket(
    'ws://' + window.location.host + '/ws/chat/room-name/'
);

chatSocket.onopen = function(e) {
    console.log('WebSocket соединение установлено');
};

chatSocket.onmessage = function(e) {
    const data = JSON.parse(e.data);
    console.log('Сообщение:', data.message);
};

chatSocket.onerror = function(error) {
    console.error('WebSocket ошибка:', error);
};

// Отправить сообщение
function sendMessage(message) {
    chatSocket.send(JSON.stringify({
        'message': message
    }));
}

Запуск

# Вместо runserver используем daphne
python manage.py daphne -b 0.0.0.0 -p 8000 myproject.asgi:application

2. Синхронный Consumer (тоже Channels)

Если не хочешь писать async код:

from channels.generic.websocket import WebsocketConsumer
import json

class ChatConsumer(WebsocketConsumer):
    def connect(self):
        """Подключение"""
        self.accept()
    
    def disconnect(self, close_code):
        """Отключение"""
        pass
    
    def receive(self, text_data):
        """Получение сообщения"""
        data = json.loads(text_data)
        message = data['message']
        
        # Отправить обратно
        self.send(text_data=json.dumps({
            'message': message
        }))

3. Альтернативы Django Channels

Socket.IO с Flask/FastAPI

from fastapi import FastAPI
from fastapi_socketio import SocketManager

app = FastAPI()
sio = SocketManager(app=app, cors_allowed_origins='*')

@sio.on('connect')
async def connect(sid, environ):
    print(f'Client {sid} connected')

@sio.on('message')
async def message(sid, data):
    await sio.emit('response', data, to=sid)

Uvicorn + ASGI приложение

pip install uvicorn
uvicorn myapp:app --reload

Пример: простой чат с Channels

Структура проекта

project/
├── asgi.py
├── settings.py
├── manage.py
└── chat/
    ├── consumers.py
    ├── routing.py
    ├── views.py
    └── templates/
        └── chat.html

chat/views.py

from django.shortcuts import render

def chat_room(request, room_name):
    return render(request, 'chat.html', {
        'room_name': room_name
    })

chat/templates/chat.html

<!DOCTYPE html>
<html>
<head>
    <title>Chat: {{ room_name }}</title>
</head>
<body>
    <div id="messages"></div>
    <input id="message-input" type="text" placeholder="Сообщение...">
    <button onclick="sendMessage()">Отправить</button>
    
    <script>
        const roomName = '{{ room_name }}';
        const chatSocket = new WebSocket(
            'ws://' + window.location.host + '/ws/chat/' + roomName + '/'
        );
        
        chatSocket.onmessage = function(e) {
            const data = JSON.parse(e.data);
            const messagesDiv = document.getElementById('messages');
            messagesDiv.innerHTML += '<p>' + data.message + '</p>';
        };
        
        function sendMessage() {
            const input = document.getElementById('message-input');
            chatSocket.send(JSON.stringify({
                'message': input.value
            }));
            input.value = '';
        }
    </script>
</body>
</html>

Сравнение подходов

Лучшие практики

1. Используй группы для broadcast

await self.channel_layer.group_send(
    'notifications',
    {'type': 'notify.message', 'text': 'Hello'}
)

2. Аутентификация

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.user = self.scope['user']
        if not self.user.is_authenticated:
            await self.close()

3. Масштабируемость

CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
    }
}

Итоги

• Django не имеет встроенной поддержки WebSocket (требует ASGI, а Django это WSGI)
• Django Channels — стандартное решение для WebSocket в Django
• Consumer — обработчик WebSocket соединения (как view для HTTP)
• Группы — способ отправить сообщение многим клиентам сразу
• Redis — нужен для масштабируемости на несколько серверов