Node、Python、Go中的websocket

2024 年 7 月 8 日15:19:47Python教程评论82字数 8421阅读28分4秒阅读模式2024 年 7 月 8 日

在之前的文章中，我们已经多次探讨了WebSocket的各种实现和应用，尤其是使用Node.js生态系统来演示。然而，为了让大家更全面地了解不同编程语言在实现WebSocket服务器时的特点和优势，今天我们将使用Node.js、Python和Golang这三种流行的编程语言，分别对比实现同样的需求。文章源自灵鲨社区-https://www.0s52.com/bcjc/pythonjc/16767.html

本文将通过具体的代码示例，展示如何在这些语言中进行连接管理、消息广播、心跳检测和实时数据推送等常见任务。最后，我们还将对这三种语言的实现进行对比，分析它们的优缺点和适用场景。无论你是初学者还是有经验的开发者，希望通过这篇文章，你能掌握在不同编程语言中实现WebSocket服务器的技巧和最佳实践，从而为你的实时通信应用奠定坚实的技术基础。文章源自灵鲨社区-https://www.0s52.com/bcjc/pythonjc/16767.html

Node.js实现WebSocket服务器

1. 基本代码示例

javascript

复制代码

const WebSocket = require('ws');

const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (ws) => {
  console.log('新的客户端已连接');

  ws.on('message', (message) => {
    console.log(`收到消息: ${message}`);
    // 回显收到的消息给客户端
    ws.send(`你说: ${message}`);
  });

  ws.on('close', () => {
    console.log('客户端已断开连接');
  });

  ws.send('欢迎连接到WebSocket服务器！');
});

console.log('WebSocket服务器运行在ws://localhost:8080');

2. 连接管理和消息广播

javascript

复制代码

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

const clients = new Set();

server.on('connection', (ws) => {
  clients.add(ws);
  console.log('新的客户端已连接');

  ws.on('message', (message) => {
    console.log(`收到消息: ${message}`);
    // 将消息广播给所有连接的客户端
    clients.forEach((client) => {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(message);
      }
    });
  });

  ws.on('close', () => {
    clients.delete(ws);
    console.log('客户端已断开连接');
  });

  ws.send('欢迎连接到WebSocket服务器！');
});

console.log('WebSocket服务器运行在ws://localhost:8080');

3. 心跳检测和重连机制

javascript

复制代码

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (ws) => {
  ws.isAlive = true;

  ws.on('pong', () => {
    ws.isAlive = true;
  });

  ws.on('message', (message) => {
    console.log(`收到消息: ${message}`);
    ws.send(`你说: ${message}`);
  });

  ws.on('close', () => {
    console.log('客户端已断开连接');
  });

  ws.send('欢迎连接到WebSocket服务器！');
});

const interval = setInterval(() => {
  server.clients.forEach((ws) => {
    if (!ws.isAlive) return ws.terminate();

    ws.isAlive = false;
    ws.ping();
  });
}, 30000);

server.on('close', () => {
  clearInterval(interval);
});

console.log('WebSocket服务器运行在ws://localhost:8080');

4. 实时数据推送

javascript

复制代码

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (ws) => {
  console.log('新的客户端已连接');

  const sendData = () => {
    if (ws.readyState === WebSocket.OPEN) {
      const data = { timestamp: new Date(), value: Math.random() };
      ws.send(JSON.stringify(data));
    }
  };

  const interval = setInterval(sendData, 1000);

  ws.on('close', () => {
    clearInterval(interval);
    console.log('客户端已断开连接');
  });

  ws.send('欢迎连接到WebSocket服务器！');
});

console.log('WebSocket服务器运行在ws://localhost:8080');

Python实现WebSocket服务器

1. 基本代码示例

python

复制代码

import asyncio
import websockets

async def handler(websocket, path):
    print("新的客户端已连接")
    try:
        async for message in websocket:
            print(f"收到消息: {message}")
            await websocket.send(f"你说: {message}")
    except websockets.exceptions.ConnectionClosed:
        print("客户端已断开连接")

start_server = websockets.serve(handler, "localhost", 8080)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

print('WebSocket服务器运行在ws://localhost:8080')

2. 连接管理和消息广播

python

复制代码

import asyncio
import websockets

clients = set()

async def handler(websocket, path):
    clients.add(websocket)
    print("新的客户端已连接")
    try:
        async for message in websocket:
            print(f"收到消息: {message}")
            # 将消息广播给所有连接的客户端
            await asyncio.wait([client.send(message) for client in clients if client != websocket])
    except websockets.exceptions.ConnectionClosed:
        print("客户端已断开连接")
    finally:
        clients.remove(websocket)

start_server = websockets.serve(handler, "localhost", 8080)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

print('WebSocket服务器运行在ws://localhost:8080')

3. 心跳检测和重连机制

python

复制代码

import asyncio
import websockets

clients = set()

async def handler(websocket, path):
    clients.add(websocket)
    print("新的客户端已连接")
    try:
        async for message in websocket:
            print(f"收到消息: {message}")
            await websocket.send(f"你说: {message}")
    except websockets.exceptions.ConnectionClosed:
        print("客户端已断开连接")
    finally:
        clients.remove(websocket)

async def heartbeat():
    while True:
        for client in clients.copy():
            try:
                await client.ping()
            except websockets.exceptions.ConnectionClosed:
                clients.remove(client)
        await asyncio.sleep(30)

start_server = websockets.serve(handler, "localhost", 8080)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_until_complete(heartbeat())

print('WebSocket服务器运行在ws://localhost:8080')

4. 实时数据推送

python

复制代码

import asyncio
import websockets
import json
from datetime import datetime
import random

async def handler(websocket, path):
    print("新的客户端已连接")
    try:
        while True:
            data = {"timestamp": datetime.now().isoformat(), "value": random.random()}
            await websocket.send(json.dumps(data))
            await asyncio.sleep(1)
    except websockets.exceptions.ConnectionClosed:
        print("客户端已断开连接")

start_server = websockets.serve(handler, "localhost", 8080)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

print('WebSocket服务器运行在ws://localhost:8080')

Golang实现WebSocket服务器

1. 基本代码示例

复制代码

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            break
        }
        fmt.Printf("收到消息: %sn", message)
        if err := conn.WriteMessage(messageType, message); err != nil {
            fmt.Println(err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("WebSocket服务器运行在ws://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

2. 连接管理和消息广播

复制代码

package main

import (
    "fmt"
    "net/http"
    "sync"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

var clients = make(map[*websocket.Conn]bool)
var mutex = &sync.Mutex{}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    mutex.Lock()
    clients[conn] = true
    mutex.Unlock()

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            break
        }
        fmt.Printf("收到消息: %sn", message)

        mutex.Lock()
        for client := range clients {
            if client != conn {
                if err := client.WriteMessage(websocket.TextMessage, message); err != nil {
                    fmt.Println(err)
                    client.Close()
                    delete(clients, client)
                }
            }
        }
        mutex.Unlock()
    }

    mutex.Lock()
    delete(clients, conn)
    mutex.Unlock()
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("WebSocket服务器运行在ws://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

3. 心跳检测和重连机制

复制代码

package main

import (
    "fmt"
    "net/http"
    "time"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    conn.SetReadLimit(512)
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(60 * time.Second)); return nil })

    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()

    done := make(chan struct{})

    go func() {
        defer close(done)
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                fmt.Println(err)
                return
            }
            fmt.Printf("收到消息: %sn", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-ticker.C:
            if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                fmt.Println(err)
                return
            }
        }
    }
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("WebSocket服务器运行在ws://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

4. 实时数据推送

复制代码

package main

import (
    "fmt"
    "net/http"
    "time"
    "math/rand"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            data := fmt.Sprintf(`{"timestamp": "%s", "value": %f}`, time.Now().Format(time.RFC3339), rand.Float64())
            if err := conn.WriteMessage(websocket.TextMessage, []byte(data)); err != nil {
                fmt.Println(err)
                return
            }
        }
    }
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("WebSocket服务器运行在ws://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

对比总结

1. 代码简洁性

Node.js:
- 使用ws库，代码简洁，适合快速开发。
- 异步处理比较直观，适合处理大量并发连接。
Python:
- 使用websockets库，代码清晰易读。
- 通过asyncio进行异步处理，适合高并发场景。
Golang:
- 使用gorilla/websocket库，代码稍微复杂一些，但性能优越。
- 原生支持并发处理，适合高性能需求。

2. 性能

Node.js:
- 单线程异步I/O，适合I/O密集型应用。
- 由于是单线程，需要注意CPU密集型任务的处理。
Python:
- 异步处理性能较好，适合I/O密集型和高并发应用。
- 对于CPU密集型任务，可能需要借助多进程或其他优化手段。
Golang:
- 原生支持多线程和并发处理，性能优越。
- 适合高并发、高性能的应用场景。

3. 开发体验

Node.js:
- 丰富的社区资源和第三方库，开发体验良好。
- 需要掌握异步编程模型。
Python:
- 代码简洁，语法易于理解，开发体验良好。
- 需要掌握异步编程和asyncio库。
Golang:
- 语法简洁，编译型语言，开发体验良好。
- 需要掌握并发编程和Goroutine的使用。

4. 适用场景

Node.js:
- 适合构建实时通信应用、聊天应用和WebSocket服务器。
- 适合快速开发和原型设计。
Python:
- 适合构建实时数据推送、WebSocket服务器和高并发应用。
- 适合数据处理和科学计算场景。
Golang:
- 适合构建高性能WebSocket服务器和实时通信应用。
- 适合高并发、高性能的企业级应用。

总结来说，选择哪种语言实现WebSocket服务器取决于具体的应用场景和性能需求。Node.js适合快速开发和I/O密集型应用，Python适合高并发和数据处理应用，而Golang则适合高性能和高并发的应用场景。希望这些代码示例和对比总结对你有所帮助。文章源自灵鲨社区-https://www.0s52.com/bcjc/pythonjc/16767.html 文章源自灵鲨社区-https://www.0s52.com/bcjc/pythonjc/16767.html

历史上的今天

7 月

Node、Python、Go中的websocket

Node.js实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

Python实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

Golang实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

对比总结

1. 代码简洁性

2. 性能

3. 开发体验

4. 适用场景

历史上的今天

Python进阶技巧二三事（七）：字符串、python版本控制

python中的包管理器:pip使用小结

Python进阶技巧二三事（六）：字典解包与外键

python实现椭圆检测

计算机视觉的基础概念与入门

Python 性能分析的几个方法，找到你代码中的那个她

40个IPython的使用技巧整理

12种增强Python代码的函数式编程技术

探索LlamaIndex：如何用Django打造高效知识库检索

AI开发者构建RESTful：从 Flask 转换到 FastAPI

加载中...

发表评论

热门搜索

Node.js实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

Python实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

Golang实现WebSocket服务器

1. 基本代码示例

2. 连接管理和消息广播

3. 心跳检测和重连机制

4. 实时数据推送

对比总结

1. 代码简洁性

2. 性能

3. 开发体验

4. 适用场景

历史上的今天

发表评论