Python Django Channels: WebSocket 구현에 대한 종합 가이드

            django-admin startproject myproject
cd myproject
            

              
                Copy
              
            
          

            python3 -m venv venv
source venv/bin/activate  # On Linux/macOS
.\venv\Scripts\activate  # On Windows
            

              
                Copy
              
            
          

            pip install channels daphne
            

              
                Copy
              
            
          

            INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'channels',
    # Your other apps
]
            

              
                Copy
              
            
          

            ASGI_APPLICATION = 'myproject.asgi.application'
            

              
                Copy
              
            
          

            CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            "hosts": [('127.0.0.1', 6379)],
        },
    },
}
            

              
                Copy
              
            
          

            pip install channels_redis
            

              
                Copy
              
            
          

            # myproject/asgi.py
import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing  # Import your app's routing

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

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
})
            

              
                Copy
              
            
          

            python manage.py startapp chat
            

              
                Copy
              
            
          

            INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'channels',
    'chat',
    # Your other apps
]
            

              
                Copy
              
            
          

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

              
                Copy
              
            
          

            # chat/consumers.py
import json

from channels.generic.websocket import AsyncWebsocketConsumer
from asgiref.sync import sync_to_async

from django.contrib.auth.models import User

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}'

        # Join room group
        await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )

        await self.accept()

    async def disconnect(self, close_code):
        # Leave room group
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )

    # Receive message from WebSocket
    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
        username = text_data_json['username'] # Extract username from the received data

        # Send message to room group
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat.message',
                'message': message,
                'username': username,
            }
        )

    # Receive message from room group
    async def chat_message(self, event):
        message = event['message']
        username = event['username']

        # Send message to WebSocket
        await self.send(text_data=json.dumps({
            'message': message,
            'username': username,
        }))

            

              
                Copy
              
            
          

            <!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>Chat Room</title>
</head>
<body>
    <h1>Chat Room: {{ room_name }}</h1>
    <div id="chat-log"></div>
    <input type="text" id="chat-message-input" size="100"/><br/>
    <input type="text" id="chat-username-input" size="100" placeholder="Enter your username"/><br/>
    <button id="chat-message-submit">Send</button>

    <script>
        const roomName = {{ room_name|json_script:"room-name" }};
        const chatSocket = new WebSocket(
            'ws://'
            + window.location.host
            + '/ws/chat/'
            + roomName
            + '/'
        );

        chatSocket.onmessage = function(e) {
            const data = JSON.parse(e.data);
            document.querySelector('#chat-log').value += (data.username + ': ' + data.message + '\n');
        };

        chatSocket.onclose = function(e) {
            console.error('Chat socket closed unexpectedly');
        };

        document.querySelector('#chat-message-input').focus();
        document.querySelector('#chat-message-input').onkeyup = function(e) {
            if (e.keyCode === 13) {  // enter, return
                document.querySelector('#chat-message-submit').click();
            }
        };

        document.querySelector('#chat-message-submit').onclick = function(e) {
            const messageInputDom = document.querySelector('#chat-message-input');
            const usernameInputDom = document.querySelector('#chat-username-input');
            const message = messageInputDom.value;
            const username = usernameInputDom.value;  // Get the username
            chatSocket.send(JSON.stringify({
                'message': message,
                'username': username
            }));
            messageInputDom.value = '';
        };
    </script>
</body>
</html>
            

              
                Copy
              
            
          

            # chat/views.py
from django.shortcuts import render

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

              
                Copy
              
            
          

            # myproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('chat/', include('chat.urls')),
]
            

              
                Copy
              
            
          

            # chat/urls.py
from django.urls import path

from . import views

urlpatterns = [
    path('<str:room_name>/', views.room, name='room'),
]
            

              
                Copy
              
            
          

            python manage.py runserver
            

              
                Copy
              
            
          

            # chat/consumers.py
from channels.generic.websocket import AsyncWebsocketConsumer

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

              
                Copy
              
            
          

            # chat/tests.py
import pytest
from channels.testing.websocket import WebsocketCommunicator
from chat.consumers import ChatConsumer

@pytest.mark.asyncio
async def test_chat_consumer():
    communicator = WebsocketCommunicator(ChatConsumer.as_asgi(), "ws/chat/testroom/")
    connected, subprotocol = await communicator.connect()
    assert connected

    await communicator.send_to(text_data={"message": "Hello", "username": "TestUser"})
    response = await communicator.receive_from()
    assert response == '{"message":"Hello","username":"TestUser"}'

    await communicator.disconnect()
            

              
                Copy
              
            
          

            # chat/consumers.py
import json
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def receive(self, text_data):
        try:
            text_data_json = json.loads(text_data)
            message = text_data_json['message']
            username = text_data_json['username']

            await self.channel_layer.group_send(
                self.room_group_name,
                {
                    'type': 'chat.message',
                    'message': message,
                    'username': username
                }
            )
        except Exception as e:
            await self.send(text_data=json.dumps({
                'error': str(e)
            }))
            

              
                Copy