Django使用Channels实现websocket开发者社区

Django使用Channels实现websocket

$ pip install channels

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'channels',
)

CHANNEL_LAYERS  =  { 
    “default” ： { 
        “BACKEND” ： “asgiref.inmemory.ChannelLayer” ，
        # 这里是路由的路径，怎么填写都可以，只要能找到
        “ROUTING” ： “你的工程名.routing.channel_routing” ，
}

CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "asgi_redis.RedisChannelLayer",
        "CONFIG": {
            "hosts": [os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379/2')],
        # 配置路由的路径
        "ROUTING": "你的工程名.routing.channel_routing",
}

def ws_message(message):
    # ASGI WebSocket packet-received and send-packet message types
    # both have a "text" key for their textual data.
    message.reply_channel.send({
        "text": message.content['text'],
    })

from channels.routing import route
from .consumers import ws_message
channel_routing = [
    route("websocket.receive", ws_message),
]

// Note that the path doesn't matter for routing; any WebSocket
// connection gets bumped over to WebSocket consumers
socket = new WebSocket("ws://127.0.0.1:8000/chat/");
socket.onmessage = function(e) {
    consoe.log(e.data);
socket.onopen = function() {
    socket.send("hello world");
// Call onopen directly if socket is already open
if (socket.readyState == WebSocket.OPEN) socket.onopen();

from channels import Group
# Connected to websocket.connect
def ws_add(message):
    # Accept the connection
    message.reply_channel.send({"accept": True})
    # Add to the chat group
    Group("chat").add(message.reply_channel)
# Connected to websocket.receive
def ws_message(message):
    Group("chat").send({
        "text": "[user] %s" % message.content['text'],
# Connected to websocket.disconnect
def ws_disconnect(message):
    Group("chat").discard(message.reply_channel)

from channels.routing import route
from .consumers import ws_add, ws_message, ws_disconnect
channel_routing = [
    route("websocket.connect", ws_add),
    route("websocket.receive", ws_message),
    route("websocket.disconnect", ws_disconnect),
]

// Note that the path doesn't matter right now; any WebSocket
// connection gets bumped over to WebSocket consumers
socket = new WebSocket("ws://127.0.0.1:8000/chat/");
socket.onmessage = function(e) {
     consoe.log(e.data);
socket.onopen = function() {
    socket.send("hello world");
// Call onopen directly if socket is already open
if (socket.readyState == WebSocket.OPEN) socket.onopen();

from channels import Channel, Group
from channels.sessions import channel_session
from channels.auth import channel_session_user, channel_session_user_from_http
# Connected to websocket.connect
@channel_session_user_from_http
def ws_add(message):
    # Accept connection
    message.reply_channel.send({"accept": True})
    # Add them to the right group
    Group("chat-%s" % message.user.username[0]).add(message.reply_channel)
# Connected to websocket.receive
@channel_session_user
def ws_message(message):
    Group("chat-%s" % message.user.username[0]).send({
        "text": message['text'],
# Connected to websocket.disconnect
@channel_session_user
def ws_disconnect(message):
    Group("chat-%s" % message.user.username[0]).discard(message.reply_channel)

# coding=utf-8
from functools import wraps
from django.utils.translation import ugettext_lazy as _
from rest_framework import exceptions
from channels.handler import AsgiRequest
import jwt
from django.contrib.auth import get_user_model
from rest_framework_jwt.settings import api_settings
import logging
logger = logging.getLogger(__name__)  # 为loggers中定义的名称
User = get_user_model()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
jwt_decode_handler = api_settings.JWT_DECODE_HANDLER
jwt_get_username_from_payload = api_settings.JWT_PAYLOAD_GET_USERNAME_HANDLER
def token_authenticate(token, message):
    Tries to authenticate user based on the supplied token. It also checks
    the token structure and validity.
    payload = check_payload(token=token, message=message)
    user = check_user(payload=payload, message=message)
    """Other authenticate operation"""
    return user, token
# 检查负载
def check_payload(token, message):
    payload = None
        payload = jwt_decode_handler(token)
    except jwt.ExpiredSignature:
        msg = _('Signature has expired.')
        logger.warn(msg)
        # raise ValueError(msg)
        _close_reply_channel(message)
    except jwt.DecodeError:
        msg = _('Error decoding signature.')
        logger.warn(msg)
        _close_reply_channel(message)
    return payload
# 检查用户
def check_user(payload, message):
    username = None
        username = payload.get('username')
    except Exception:
        msg = _('Invalid payload.')
        logger.warn(msg)
        _close_reply_channel(message)
    if not username:
        msg = _('Invalid payload.')
        logger.warn(msg)
        _close_reply_channel(message)
        return
        # Make sure user exists
        user = User.objects.get_by_natural_key(username)
    except User.DoesNotExist:
        msg = _("User doesn't exist.")
        logger.warn(msg)
        raise exceptions.AuthenticationFailed(msg)
    if not user.is_active:
        msg = _('User account is disabled.')
        logger.warn(msg)
        raise exceptions.AuthenticationFailed(msg)
    return user
# 关闭websocket
def _close_reply_channel(message):
    message.reply_channel.send({"close": True})
# 验证request中的token
def ws_auth_request_token(func):
    Checks the presence of a "token" request parameter and tries to
    authenticate the user based on its content.
    The request url must include token.
    eg: /v1/channel/1/?token=abcdefghijklmn
    @wraps(func)
    def inner(message, *args, **kwargs):
            if "method" not in message.content:
                message.content['method'] = "FAKE"
            request = AsgiRequest(message)
        except Exception as e:
            raise ValueError("Cannot parse HTTP message - are you sure this is a HTTP consumer? %s" % e)
        token = request.GET.get("token", None)
        print request.path, request.GET
        if token is None:
            _close_reply_channel(message)
            raise ValueError("Missing token request parameter. Closing channel.")
        # user, token = token_authenticate(token)
        user, token = token_authenticate(token, message)
        message.token = token
        message.user = user
        return func(message, *args, **kwargs)
    return inner

from channels import Group
from .ws_authentication import ws_auth_request_token
# Connected to websocket.connect
@ws_auth_request_token
def ws_add(message):
    # Accept the connection
    message.reply_channel.send({"accept": True})
    # Add to the chat group
    Group("chat").add(message.reply_channel)
# Connected to websocket.receive
def ws_message(message):
    Group("chat").send({
        "text": "[user] %s" % message.content['text'],
# Connected to websocket.disconnect
def ws_disconnect(message):
    Group("chat").discard(message.reply_channel)

from channels.generic.websockets import WebsocketConsumer
class MyConsumer(WebsocketConsumer):
    # Set to True to automatically port users from HTTP cookies
    # (you don't need channel_session_user, this implies it)
    http_user = True
    # Set to True if you want it, else leave it out
    strict_ordering = False
    def connection_groups(self, **kwargs):
        Called to return the list of groups to automatically add/remove
        this connection to/from.
        return ["test"]
    def connect(self, message, **kwargs):
        Perform things on connection start
        # Accept the connection; this is done by default if you don't override
        # the connect function.
        self.message.reply_channel.send({"accept": True})
    def receive(self, text=None, bytes=None, **kwargs):
        Called when a message is received with either text or bytes
        filled out.
        # Simple echo
        self.send(text=text, bytes=bytes)
    def disconnect(self, message, **kwargs):
        Perform things on connection close
        pass

channel_session_user = True

http_user = True

from . import consumers
channel_routing = [
    consumers.ChatServer.as_route(path=r"^/chat/"),
]

class MyConsumer(WebsocketConsumer):
    # Set to True if you want it, else leave it out
    strict_ordering = False
    http_user = True
    # 由于使用的是token方式，需要使用session将user传递到receive中
    channel_session_user = True
    def connection_groups(self, **kwargs):
        Called to return the list of groups to automatically add/remove
        this connection to/from.
        return ['test']
        def connect(self, message, **kwargs):
        Perform things on connection start
            request = AsgiRequest(message)
        except Exception as e:
            self.close()
            return
        token = request.GET.get("token", None)
        if token is None:
            self.close()
            return
        user, token = token_authenticate(token, message)
        message.token = token
        message.user = user
        message.channel_session['user']=user
        self.message.reply_channel.send({"accept": True})
        print '连接状态', message.user
    def receive(self, text=None, bytes=None, **kwargs):
        print '接收到消息', text, self.message.channel_session['user']
        Called when a message is received with decoded JSON content
        # Simple echo
        value = cache.get('test')
        print value
        while True:
            if cache.get('test') is not None and cache.get('test') != value:
                value = cache.get('test')
                break
            time.sleep(1)
        self.send(json.dumps({
            "text": cache.get('test')
    def disconnect(self, message, **kwargs):
        Perform things on connection close
        pass

socket = new WebSocket("ws://127.0.0.1:8000"+
            "/chat/?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InRlc3QxMjMiLCJvcmlnX2lhdCI6MTUwMzA3Mzg0NiwidXNlcl9pZCI6MSwiZW1haWwiOiIxNzkxNTM4NjA5QHFxLmNvbSIsImV4cCI6MTUwMzE2MDI0Nn0.Za0BlGKn2JMpFoU0GYVZXIC-rwi8uWN420bIwy0bUFc"
        socket.onmessage = function (e) {
            console.log(e.data);
            // socket.send("test")
        socket.onopen = function () {

Django使用Channels实现websocket

Django使用Channels实现websocket

Channels

安装配置

安装channels

配置channels

在INSTALLED_APPS中添加channels

配置channels路由和通道后端

使用channels

最简单的例子

利用组的概念实现多个浏览器(用户)之间的交互

channels的认证

Json Web Token认证

使用类视图

在channels类视图中使用token认证