channels，一个实用的 Python 库！

大家好，我是涛哥，本文内容来自 涛哥聊Python ，转载请标原创。

更多Python学习内容：http://ipengtao.com

今天为大家分享一个实用的 Python 库 - channels。

Github地址：https://github.com/django/channels

---

随着实时 web 应用程序的兴起，传统的同步 web 框架已经无法满足高并发和实时通信的需求。Django Channels 是 Django 的一个扩展，旨在将 Django 从一个同步 HTTP 框架转变为一个支持 WebSockets、HTTP2 和其他协议的异步框架。它不仅能够处理传统的 HTTP 请求，还可以处理 WebSockets 等长连接，使得 Django 开发者能够更轻松地构建实时 web 应用。本文将详细介绍 Django Channels 库，包括其安装方法、主要特性、基本和高级功能，以及实际应用场景，帮助全面了解并掌握该库的使用。

安装

要使用 Django Channels 库，首先需要安装它。以下是安装步骤：

使用 pip 安装

可以通过 pip 直接安装 Django Channels 及其依赖的 asgiref 和 daphne：

pip install channels

更新 Django 设置

在 Django 项目的 settings.py 文件中，添加 Channels 到已安装的应用程序列表，并设置 ASGI 应用程序：

INSTALLED_APPS = [
    # 其他已安装的应用程序
    'channels',
]

ASGI_APPLICATION = 'myproject.asgi.application'

创建 ASGI 应用程序

在项目根目录创建 asgi.py 文件：

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

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

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

特性

1. 异步支持：将 Django 转变为一个异步框架，支持 WebSockets、HTTP2 等协议。
2. 集成简单：与 Django 无缝集成，保留了 Django 的开发体验。
3. 多协议支持：能够处理 HTTP、WebSockets、gRPC 等多种协议。
4. 扩展性强：支持自定义中间件和路由，能够根据需求扩展功能。
5. 高性能：通过异步处理和高效的事件循环，提升应用程序的性能和响应速度。

基本功能

配置路由

在应用程序目录下创建 routing.py 文件，定义 WebSocket 路由：

from django.urls import path
from myapp import consumers

websocket_urlpatterns = [
    path('ws/chat/', consumers.ChatConsumer.as_asgi()),
]

创建消费者

在应用程序目录下创建 consumers.py 文件，定义 WebSocket 消费者：

import json
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = 'chat_room'
        self.room_group_name = 'chat_%s' % 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):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        # 发送消息到房间组
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message',
                'message': message
            }
        )

    async def chat_message(self, event):
        message = event['message']

        # 发送消息到 WebSocket
        await self.send(text_data=json.dumps({
            'message': message
        }))

配置通道层

在 settings.py 中配置通道层（以 Redis 为例）：

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

高级功能

自定义中间件

可以创建自定义中间件处理 WebSocket 连接：

from channels.middleware.base import BaseMiddleware

class CustomMiddleware(BaseMiddleware):
    async def __call__(self, scope, receive, send):
        # 自定义处理逻辑
        scope['user'] = await self.get_user(scope)
        return await super().__call__(scope, receive, send)

    async def get_user(self, scope):
        # 获取用户逻辑
        return "Anonymous"

# 在 asgi.py 中使用自定义中间件
application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": CustomMiddleware(
        URLRouter(
            myapp.routing.websocket_urlpatterns
        )
    ),
})

使用通道层发送消息

可以在视图或任务中使用通道层发送消息：

from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync

def send_message():
    channel_layer = get_channel_layer()
    async_to_sync(channel_layer.group_send)(
        'chat_chat_room',
        {
            'type': 'chat_message',
            'message': 'Hello from Django view!'
        }
    )

创建任务队列

可以使用通道层创建任务队列，实现异步任务处理：

from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync

def queue_task(task_data):
    channel_layer = get_channel_layer()
    async_to_sync(channel_layer.send)(
        'task_queue',
        {
            'type': 'process_task',
            'task_data': task_data
        }
    )

# 在 consumers.py 中定义任务处理逻辑
class TaskConsumer(AsyncWebsocketConsumer):
    async def process_task(self, event):
        task_data = event['task_data']
        # 处理任务逻辑

实际应用场景

实时聊天应用

在实时聊天应用中，通过 Django Channels 处理 WebSocket 连接，实现消息的实时传输。

# consumers.py
class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = 'chat_room'
        self.room_group_name = 'chat_%s' % 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):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message',
                'message': message
            }
        )

    async def chat_message(self, event):
        message = event['message']
        await self.send(text_data=json.dumps({
            'message': message
        }))

实时通知系统

在实时通知系统中，通过 Django Channels 实现用户通知的实时推送。

# consumers.py
class NotificationConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.user = self.scope['user']
        self.group_name = f'notifications_{self.user.id}'
        await self.channel_layer.group_add(
            self.group_name,
            self.channel_name
        )
        await self.accept()

    async def disconnect(self, close_code):
        await self.channel_layer.group_discard(
            self.group_name,
            self.channel_name
        )

    async def receive(self, text_data):
        # 处理接收到的数据（如果有的话）
        pass

    async def send_notification(self, event):
        notification = event['notification']
        await self.send(text_data=json.dumps({
            'notification': notification
        }))

# 在 views.py 中发送通知
from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync

def notify_user(user_id, notification):
    channel_layer = get_channel_layer()
    async_to_sync(channel_layer.group_send)(
        f'notifications_{user_id}',
        {
            'type': 'send_notification',
            'notification': notification
        }
    )

在线游戏

在多人在线游戏中，通过 Django Channels 实现实时游戏状态的同步和玩家间的通信。

# consumers.py
class GameConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = f'game_{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)
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'game_message',
                'data': data
            }
        )

    async def game_message(self, event):
        data = event['data']
        await self.send(text_data=json.dumps(data))

总结

Django Channels 库是一个功能强大且易于使用的扩展，能够将 Django 从一个同步 HTTP 框架转变为一个支持 WebSockets、HTTP2 和其他协议的异步框架。通过支持异步处理、简单集成、多协议支持、强大的扩展性和高性能，Django Channels 提供了强大的功能和灵活的扩展能力。本文详细介绍了 Django Channels 库的安装方法、主要特性、基本和高级功能，以及实际应用场景。希望本文能帮助大家全面掌握 Django Channels 库的使用，并在实际项目中发挥其优势。无论是在实时聊天、实时通知还是在线游戏中，Django Channels 库都将是一个得力的工具。