Node、Python、Go中的websocket

零
Python教程评论129字数 8421阅读28分4秒阅读模式

Node、Python、Go中的websocket

在之前的文章中，我们已经多次探讨了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

复制代码
  1. const WebSocket = require('ws');
  3. const server = new WebSocket.Server({ port: 8080 });
  5. server.on('connection', (ws) => {
  6.   console.log('新的客户端已连接');
  8.   ws.on('message', (message) => {
  9.     console.log(`收到消息: ${message}`);
  10.     // 回显收到的消息给客户端
  11.     ws.send(`你说: ${message}`);
  12.   });
  14.   ws.on('close', () => {
  15.     console.log('客户端已断开连接');
  16.   });
  18.   ws.send('欢迎连接到WebSocket服务器！');
  19. });
  21. console.log('WebSocket服务器运行在ws://localhost:8080');

2. 连接管理和消息广播

javascript

复制代码
  1. const WebSocket = require('ws');
  2. const server = new WebSocket.Server({ port: 8080 });
  4. const clients = new Set();
  6. server.on('connection', (ws) => {
  7.   clients.add(ws);
  8.   console.log('新的客户端已连接');
  10.   ws.on('message', (message) => {
  11.     console.log(`收到消息: ${message}`);
  12.     // 将消息广播给所有连接的客户端
  13.     clients.forEach((client) => {
  14.       if (client !== ws && client.readyState === WebSocket.OPEN) {
  15.         client.send(message);
  16.       }
  17.     });
  18.   });
  20.   ws.on('close', () => {
  21.     clients.delete(ws);
  22.     console.log('客户端已断开连接');
  23.   });
  25.   ws.send('欢迎连接到WebSocket服务器！');
  26. });
  28. console.log('WebSocket服务器运行在ws://localhost:8080');

3. 心跳检测和重连机制

javascript

复制代码
  1. const WebSocket = require('ws');
  2. const server = new WebSocket.Server({ port: 8080 });
  4. server.on('connection', (ws) => {
  5.   ws.isAlive = true;
  7.   ws.on('pong', () => {
  8.     ws.isAlive = true;
  9.   });
  11.   ws.on('message', (message) => {
  12.     console.log(`收到消息: ${message}`);
  13.     ws.send(`你说: ${message}`);
  14.   });
  16.   ws.on('close', () => {
  17.     console.log('客户端已断开连接');
  18.   });
  20.   ws.send('欢迎连接到WebSocket服务器！');
  21. });
  23. const interval = setInterval(() => {
  24.   server.clients.forEach((ws) => {
  25.     if (!ws.isAlive) return ws.terminate();
  27.     ws.isAlive = false;
  28.     ws.ping();
  29.   });
  30. }, 30000);
  32. server.on('close', () => {
  33.   clearInterval(interval);
  34. });
  36. console.log('WebSocket服务器运行在ws://localhost:8080');

4. 实时数据推送

javascript

复制代码
  1. const WebSocket = require('ws');
  2. const server = new WebSocket.Server({ port: 8080 });
  4. server.on('connection', (ws) => {
  5.   console.log('新的客户端已连接');
  7.   const sendData = () => {
  8.     if (ws.readyState === WebSocket.OPEN) {
  9.       const data = { timestamp: new Date(), value: Math.random() };
  10.       ws.send(JSON.stringify(data));
  11.     }
  12.   };
  14.   const interval = setInterval(sendData, 1000);
  16.   ws.on('close', () => {
  17.     clearInterval(interval);
  18.     console.log('客户端已断开连接');
  19.   });
  21.   ws.send('欢迎连接到WebSocket服务器！');
  22. });
  24. console.log('WebSocket服务器运行在ws://localhost:8080');

Python实现WebSocket服务器

1. 基本代码示例

python

复制代码
  1. import asyncio
  2. import websockets
  4. async def handler(websocket, path):
  5.     print("新的客户端已连接")
  6.     try:
  7.         async for message in websocket:
  8.             print(f"收到消息: {message}")
  9.             await websocket.send(f"你说: {message}")
  10.     except websockets.exceptions.ConnectionClosed:
  11.         print("客户端已断开连接")
  13. start_server = websockets.serve(handler, "localhost", 8080)
  15. asyncio.get_event_loop().run_until_complete(start_server)
  16. asyncio.get_event_loop().run_forever()
  18. print('WebSocket服务器运行在ws://localhost:8080')

2. 连接管理和消息广播

python

复制代码
  1. import asyncio
  2. import websockets
  4. clients = set()
  6. async def handler(websocket, path):
  7.     clients.add(websocket)
  8.     print("新的客户端已连接")
  9.     try:
  10.         async for message in websocket:
  11.             print(f"收到消息: {message}")
  12.             # 将消息广播给所有连接的客户端
  13.             await asyncio.wait([client.send(message) for client in clients if client != websocket])
  14.     except websockets.exceptions.ConnectionClosed:
  15.         print("客户端已断开连接")
  16.     finally:
  17.         clients.remove(websocket)
  19. start_server = websockets.serve(handler, "localhost", 8080)
  21. asyncio.get_event_loop().run_until_complete(start_server)
  22. asyncio.get_event_loop().run_forever()
  24. print('WebSocket服务器运行在ws://localhost:8080')

3. 心跳检测和重连机制

python

复制代码
  1. import asyncio
  2. import websockets
  4. clients = set()
  6. async def handler(websocket, path):
  7.     clients.add(websocket)
  8.     print("新的客户端已连接")
  9.     try:
  10.         async for message in websocket:
  11.             print(f"收到消息: {message}")
  12.             await websocket.send(f"你说: {message}")
  13.     except websockets.exceptions.ConnectionClosed:
  14.         print("客户端已断开连接")
  15.     finally:
  16.         clients.remove(websocket)
  18. async def heartbeat():
  19.     while True:
  20.         for client in clients.copy():
  21.             try:
  22.                 await client.ping()
  23.             except websockets.exceptions.ConnectionClosed:
  24.                 clients.remove(client)
  25.         await asyncio.sleep(30)
  27. start_server = websockets.serve(handler, "localhost", 8080)
  29. asyncio.get_event_loop().run_until_complete(start_server)
  30. asyncio.get_event_loop().run_until_complete(heartbeat())
  32. print('WebSocket服务器运行在ws://localhost:8080')

4. 实时数据推送

python

复制代码
  1. import asyncio
  2. import websockets
  3. import json
  4. from datetime import datetime
  5. import random
  7. async def handler(websocket, path):
  8.     print("新的客户端已连接")
  9.     try:
  10.         while True:
  11.             data = {"timestamp": datetime.now().isoformat(), "value": random.random()}
  12.             await websocket.send(json.dumps(data))
  13.             await asyncio.sleep(1)
  14.     except websockets.exceptions.ConnectionClosed:
  15.         print("客户端已断开连接")
  17. start_server = websockets.serve(handler, "localhost", 8080)
  19. asyncio.get_event_loop().run_until_complete(start_server)
  20. asyncio.get_event_loop().run_forever()
  22. print('WebSocket服务器运行在ws://localhost:8080')

Golang实现WebSocket服务器

1. 基本代码示例

go

复制代码
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "github.com/gorilla/websocket"
  7. )
  9. var upgrader = websocket.Upgrader{
  10.     ReadBufferSize:  1024,
  11.     WriteBufferSize: 1024,
  12. }
  14. func handler(w http.ResponseWriter, r *http.Request) {
  15.     conn, err := upgrader.Upgrade(w, r, nil)
  16.     if err != nil {
  17.         fmt.Println(err)
  18.         return
  19.     }
  20.     defer conn.Close()
  22.     for {
  23.         messageType, message, err := conn.ReadMessage()
  24.         if err != nil {
  25.             fmt.Println(err)
  26.             break
  27.         }
  28.         fmt.Printf("收到消息: %sn", message)
  29.         if err := conn.WriteMessage(messageType, message); err != nil {
  30.             fmt.Println(err)
  31.             break
  32.         }
  33.     }
  34. }
  36. func main() {
  37.     http.HandleFunc("/", handler)
  38.     fmt.Println("WebSocket服务器运行在ws://localhost:8080")
  39.     http.ListenAndServe(":8080", nil)
  40. }

2. 连接管理和消息广播

go

复制代码
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "sync"
  7.     "github.com/gorilla/websocket"
  8. )
  10. var upgrader = websocket.Upgrader{
  11.     ReadBufferSize:  1024,
  12.     WriteBufferSize: 1024,
  13. }
  15. var clients = make(map[*websocket.Conn]bool)
  16. var mutex = &sync.Mutex{}
  18. func handler(w http.ResponseWriter, r *http.Request) {
  19.     conn, err := upgrader.Upgrade(w, r, nil)
  20.     if err != nil {
  21.         fmt.Println(err)
  22.         return
  23.     }
  24.     defer conn.Close()
  26.     mutex.Lock()
  27.     clients[conn] = true
  28.     mutex.Unlock()
  30.     for {
  31.         _, message, err := conn.ReadMessage()
  32.         if err != nil {
  33.             fmt.Println(err)
  34.             break
  35.         }
  36.         fmt.Printf("收到消息: %sn", message)
  38.         mutex.Lock()
  39.         for client := range clients {
  40.             if client != conn {
  41.                 if err := client.WriteMessage(websocket.TextMessage, message); err != nil {
  42.                     fmt.Println(err)
  43.                     client.Close()
  44.                     delete(clients, client)
  45.                 }
  46.             }
  47.         }
  48.         mutex.Unlock()
  49.     }
  51.     mutex.Lock()
  52.     delete(clients, conn)
  53.     mutex.Unlock()
  54. }
  56. func main() {
  57.     http.HandleFunc("/", handler)
  58.     fmt.Println("WebSocket服务器运行在ws://localhost:8080")
  59.     http.ListenAndServe(":8080", nil)
  60. }

3. 心跳检测和重连机制

go

复制代码
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "time"
  7.     "github.com/gorilla/websocket"
  8. )
  10. var upgrader = websocket.Upgrader{
  11.     ReadBufferSize:  1024,
  12.     WriteBufferSize: 1024,
  13. }
  15. func handler(w http.ResponseWriter, r *http.Request) {
  16.     conn, err := upgrader.Upgrade(w, r, nil)
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  21.     defer conn.Close()
  23.     conn.SetReadLimit(512)
  24.     conn.SetReadDeadline(time.Now().Add(60 * time.Second))
  25.     conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(60 * time.Second)); return nil })
  27.     ticker := time.NewTicker(30 * time.Second)
  28.     defer ticker.Stop()
  30.     done := make(chan struct{})
  32.     go func() {
  33.         defer close(done)
  34.         for {
  35.             _, message, err := conn.ReadMessage()
  36.             if err != nil {
  37.                 fmt.Println(err)
  38.                 return
  39.             }
  40.             fmt.Printf("收到消息: %sn", message)
  41.         }
  42.     }()
  44.     for {
  45.         select {
  46.         case <-done:
  47.             return
  48.         case <-ticker.C:
  49.             if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
  50.                 fmt.Println(err)
  51.                 return
  52.             }
  53.         }
  54.     }
  55. }
  57. func main() {
  58.     http.HandleFunc("/", handler)
  59.     fmt.Println("WebSocket服务器运行在ws://localhost:8080")
  60.     http.ListenAndServe(":8080", nil)
  61. }

4. 实时数据推送

go

复制代码
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "time"
  7.     "math/rand"
  8.     "github.com/gorilla/websocket"
  9. )
  11. var upgrader = websocket.Upgrader{
  12.     ReadBufferSize:  1024,
  13.     WriteBufferSize: 1024,
  14. }
  16. func handler(w http.ResponseWriter, r *http.Request) {
  17.     conn, err := upgrader.Upgrade(w, r, nil)
  18.     if err != nil {
  19.         fmt.Println(err)
  20.         return
  21.     }
  22.     defer conn.Close()
  24.     ticker := time.NewTicker(1 * time.Second)
  25.     defer ticker.Stop()
  27.     for {
  28.         select {
  29.         case <-ticker.C:
  30.             data := fmt.Sprintf(`{"timestamp": "%s", "value": %f}`, time.Now().Format(time.RFC3339), rand.Float64())
  31.             if err := conn.WriteMessage(websocket.TextMessage, []byte(data)); err != nil {
  32.                 fmt.Println(err)
  33.                 return
  34.             }
  35.         }
  36.     }
  37. }
  39. func main() {
  40.     http.HandleFunc("/", handler)
  41.     fmt.Println("WebSocket服务器运行在ws://localhost:8080")
  42.     http.ListenAndServe(":8080", nil)
  43. }

对比总结

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 月
8
【Python教程】DeepSeek-V2-Lite：一款轻量级MoE模型，具备16B参数和2.4B活跃参数，可在40G环境下部署，效率高。
【Python教程】python miniWeb框架搭建过程详解
【Python教程】.format()函数使用方法
【Python教程】深入理解 Python 类中的各种方法
零
  • 转载请务必保留本文链接：https://www.0s52.com/bcjc/pythonjc/16767.html
    本社区资源仅供用于学习和交流，请勿用于商业用途
    未经允许不得进行转载/复制/分享

加载中...

发表评论