Python server programming: Implementing WebSockets using django-channels

In today's Web development, real-time communication is one of the indispensable functions. Since the HTTP protocol is a request-response protocol, it is very inconvenient to use the traditional method of HTTP to achieve real-time communication. The WebSockets protocol is an emerging protocol that provides real-time two-way communication capabilities for Web applications and can send and receive data on the same connection, making it very suitable for real-time applications. In Python server programming, WebSockets can be easily implemented using the django-channels framework.

1. Installing django-channels

Before you start using django-channels, you first need to install it. You can use pip to install:

pip install channels

2. Create a Django project

Next, create a Django project. In Django 2.x and above, you can use the command line tool to create a project:

django-admin startproject myproject

3. Configuring django-channels

After installing django-channels, you need to Add it to the Django project. Open the settings.py file and add 'channels' in INSTALLED_APPS. In addition, some settings need to be configured for django-channels:

# settings.py

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

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

In the above code, ASGI_APPLICATION specifies the entry point of the ASGI application, while CHANNEL_LAYERS specifies the type and parameters of the default channel layer. In this example, InMemoryChannelLayer is used, which is a channel layer that implements simple memory storage.

4. Create Route

Before creating the django-channels application, you need to create a route to route incoming WebSocket requests. A route is a mapping table that maps URL paths to specific Consumer classes. In Django, routes are usually defined in the urls.py file, but in django-channels, since it uses the ASGI protocol, the routes are defined in routing.py as follows:

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

The above code , we created a protocol route using ProtocolTypeRouter and set up a WebSocket-based sub-route. In this example, the URL requested by the WebSocket is /ws/, and the MyConsumer class will be used when connecting.

5. Create Consumer

In django-channels, Consumer is a class that handles network requests. The request can be routed to the consumer in the route, and then the consumer will process the request and return the response. Consumer is generally implemented by an async def method (i.e. coroutine). When building a Consumer, you must inherit the channels.generic.websocket.WebSocketConsumer class and implement two methods:

• connect(self): When a WebSocket connection is established, django-channels calls this method.
• receive(self, text_data=None, bytes_data=None): This method is called by django-channels when data is received from the WebSocket connection.

The following is a simple Consumer example:

# 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. Start the Django server

Now, all settings are completed and can be started Django server and test WebSocket connection. Enter the following command in the terminal to start the Django server:

python manage.py runserver

If everything is normal, you should be able to test the WebSocket connection through http://127.0.0.1:8000/ws/. If the connection is successful, the WebSocket Consumer The connect method will be executed.

Summary:

Using django-channels to implement WebSocket is very simple and basically only requires a few steps. One thing to note is that in django-channels applications, asyncio coroutines are often used, therefore, Python 3.5 and above are required. In addition, the configuration of the channel layer is also very important. If you want to use persistent storage, you can use other channel layers, such as RedisChannelLayer.

The above is the detailed content of Python server programming: Implementing WebSockets using django-channels. For more information, please follow other related articles on the PHP Chinese website!