Python Socket 详解，最全教程

python的websocket方法教程

2024-11-26

所有,python

Python的WebSocket方法教程

WebSocket 是一种通信协议，允许客户端和服务器之间的双向实时通信。它常用于需要实时交互的应用场景，例如在线聊天、实时数据更新和在线游戏。在 Python 中，有多种库支持 WebSocket，其中 websockets 是一款简单易用的库。

本文将全面介绍 WebSocket 的基本原理、安装配置以及 Python 中 WebSocket 的使用方法，配以代码示例和图解，帮助你快速掌握 WebSocket 的开发。

一、WebSocket简介

1. 什么是WebSocket？

WebSocket 是一种在单个 TCP 连接上实现全双工通信的协议。
它的通信方式不同于传统 HTTP 请求-响应模式，WebSocket 建立后，客户端和服务器可以随时互发消息。

传统 HTTP 和 WebSocket 的区别：

特性	HTTP	WebSocket
通信模式	请求-响应	全双工
连接保持	每次请求建立连接，完成后断开	连接建立后持续
实时性	较差	高
场景	静态数据传输	实时互动应用

2. WebSocket 工作流程

客户端向服务器发送 WebSocket 握手请求。
服务器返回响应，确认协议升级。
握手成功后，客户端和服务器可以进行双向通信。
双方可以在连接期间随时发送消息。
连接关闭后，通信结束。

图解：WebSocket工作流程

客户端               服务器
  |----握手请求----->|
  |<----握手确认-----|
  |<====建立连接====>|
  |<====数据交换====>|
  |<----关闭连接---->|

二、Python 中的 WebSocket 使用

1. 安装依赖

我们使用 websockets 库，它是 Python 中功能强大且易用的 WebSocket 库。

安装方式：

pip install websockets

2. 创建 WebSocket 服务器

下面是一个简单的 WebSocket 服务器示例，监听客户端连接并与之通信。

示例代码

import asyncio
import websockets

# 处理客户端连接
async def echo(websocket, path):
    print("客户端已连接")
    try:
        async for message in websocket:
            print(f"收到消息: {message}")
            await websocket.send(f"服务端回复: {message}")
    except websockets.ConnectionClosed:
        print("客户端断开连接")

# 启动服务器
start_server = websockets.serve(echo, "localhost", 12345)

print("WebSocket服务器已启动，监听端口12345")

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

运行说明

服务端会监听 localhost:12345，并等待客户端连接。
当客户端发送消息时，服务端会回显消息。

3. 创建 WebSocket 客户端

我们用客户端连接服务器并发送消息。

示例代码

import asyncio
import websockets

async def communicate():
    uri = "ws://localhost:12345"
    async with websockets.connect(uri) as websocket:
        await websocket.send("你好，服务器！")
        response = await websocket.recv()
        print(f"收到服务端回复: {response}")

# 运行客户端
asyncio.run(communicate())

运行说明

客户端连接到 ws://localhost:12345。
客户端发送消息后接收服务端的回显。

三、WebSocket 实战应用

1. 实现简单聊天室

通过 WebSocket 实现一个多人聊天的服务器。

服务端代码

import asyncio
import websockets

connected_users = set()

async def chat_handler(websocket, path):
    connected_users.add(websocket)
    print(f"新用户加入，当前用户数: {len(connected_users)}")
    try:
        async for message in websocket:
            print(f"收到消息: {message}")
            # 广播消息给所有用户
            for user in connected_users:
                if user != websocket:
                    await user.send(message)
    except websockets.ConnectionClosed:
        print("用户断开连接")
    finally:
        connected_users.remove(websocket)

start_server = websockets.serve(chat_handler, "localhost", 12345)

print("聊天服务器启动中...")
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

客户端代码

import asyncio
import websockets

async def chat_client():
    uri = "ws://localhost:12345"
    async with websockets.connect(uri) as websocket:
        print("已连接到聊天室。输入消息并按回车发送：")
        while True:
            message = input("你：")
            await websocket.send(message)
            response = await websocket.recv()
            print(f"其他人：{response}")

# 运行客户端
asyncio.run(chat_client())

2. 服务端性能优化

心跳检测：定期发送 Ping 来检测连接状态。
连接限流：限制并发用户数。
日志记录：记录每个连接的活动。

四、WebSocket 常见问题与解决

1. 为什么连接会失败？

服务端未启动或地址错误。
网络不通或防火墙阻断。

2. 如何处理连接中断？

在客户端设置重连机制。
使用 try...except 捕获 ConnectionClosed 异常。

示例：客户端重连机制

async def reconnect(uri):
    while True:
        try:
            async with websockets.connect(uri) as websocket:
                print("已连接到服务器")
                while True:
                    message = input("请输入消息：")
                    await websocket.send(message)
                    print(await websocket.recv())
        except websockets.ConnectionClosed:
            print("连接断开，尝试重连...")
            await asyncio.sleep(5)

五、WebSocket 应用场景

实时聊天：支持多人实时聊天功能。
实时数据更新：如股票价格、物联网数据监控。
游戏通信：实现低延迟的多人在线游戏。
通知推送：服务端主动推送消息到客户端。

六、总结

WebSocket 是实现实时通信的重要工具，Python 提供了功能强大的库来帮助我们快速开发 WebSocket 应用。通过 websockets，我们可以轻松实现双向通信、多人聊天和实时数据更新等功能。

学习要点：

掌握 WebSocket 的基本原理和通信流程。
学会搭建 WebSocket 服务器和客户端。
理解 WebSocket 的实战应用场景。

希望本文对你学习 WebSocket 的方法和技巧有所帮助！如果你有更多问题，欢迎交流讨论！

SpringBoot使用WebSocket

2024-09-09

在Spring Boot中使用WebSocket可以通过Spring的WebSocket支持来实现。以下是一个简单的例子，展示了如何在Spring Boot应用程序中设置WebSocket端点。

添加依赖到你的pom.xml：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

配置WebSocket：

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

创建WebSocket控制器：

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class WebSocketController {

    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public String greeting(String message) {
        return "Hello, " + message + "!";
    }
}

前端使用WebSocket的例子（使用JavaScript和SockJS客户端）：

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.7.0/dist/sockjs.min.js"></script>
<script>
    var socket = new SockJS('/ws');
    var stompClient = Stomp.over(socket);
    stompClient.connect({}, function(frame) {
        console.log('Connected: ' + frame);
        stompClient.subscribe('/topic/greetings', function(greeting){
            console.log(greeting.body);
        });
    });

    function sendName() {
        var name = document.getElementById('name').value;
        stompClient.send("/app/hello", {}, name);
    }
</script>

<input type="text" id="name" />
<button onclick="sendName()">Send</button>

这个例子展示了如何在Spring Boot应用程序中设置WebSocket端点，并使用SockJS和STOMP协议与客户端进行通信。在前端，用户可以在文本框输入名字，点击发送按钮，将消息发送到后端，后端处理这个消息并通过WebSocket发送回客户端。

Spring Boot集成websocket实现webrtc功能

2024-09-09

在Spring Boot中集成WebSocket以实现WebRTC功能，你可以使用Spring的@EnableWebSocketMessageBroker注解来配置WebSocket作为信息代理。以下是一个简化的例子：

添加Maven依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

配置WebSocketMessageBroker：

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

创建WebSocket控制器处理WebRTC信令：

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class WebSocketController {

    @MessageMapping("/webrtc/offer")
    @SendTo("/topic/webrtc/offers")
    public String handleOffer(String offer) {
        // 处理Offer信令并返回应答信令
        return "应答信令";
    }

    // 其他WebRTC信令处理方法...
}

在这个例子中，我们定义了一个WebSocket端点/ws，并且配置了一个简单的代理，将应用程序目标前缀设置为/app。然后，我们创建了一个控制器，其中包含处理WebRTC Offer信令的方法。这个例子展示了如何使用Spring Boot和WebSocket实现WebRTC信令服务的基本框架。在实际应用中，你需要实现完整的WebRTC信令处理逻辑，以及任何必要的安全措施。

2024-09-09

解释：

Spring Cloud Gateway是Spring Cloud生态中的一个项目，它提供了一个API网关，用于转发请求。当Spring Cloud Gateway尝试转发WebSocket请求时，如果遇到404错误，通常意味着Gateway没有正确配置来处理WebSocket请求，或者目标WebSocket端点不存在。

解决方法：

确保你的Gateway路由配置正确。你需要为WebSocket流量指定正确的路由，并确保路径匹配是正确的。例如：

spring:
  cloud:
    gateway:
      routes:
        - id: websocket_route
          uri: ws://websocket-service:8080
          predicates:
            - Path=/ws/**

确保WebSocket服务是可达的。Gateway需要能够连接到配置的WebSocket服务地址。
如果你使用的是Spring WebFlux，确保你的WebSocket处理是基于WebFlux的。
检查安全配置。如果你使用了Spring Security，确保WebSocket端点不被安全规则阻止。
如果你使用的是HTTP来代理WebSocket请求，确保你没有在Gateway中配置任何只适用于HTTP请求的过滤器或者路由策略，因为WebSocket是一个持久化的连接，可能需要不同的处理流程。
查看日志文件，以获取更多关于404错误的详细信息，这可能会提供额外的线索。
如果你已经确认以上配置都没有问题，但问题依然存在，可以考虑检查WebSocket服务是否已经正确启动并且监听在预期的端口上。

总结，解决Spring Cloud Gateway转发WebSocket时出现404错误，需要检查路由配置、WebSocket服务可达性、WebFlux支持以及安全配置。如果问题依然存在，检查服务启动状态和日志文件。

WebSocket解决方案(springboot 基于Redis发布订阅)

2024-09-09

所有,redis

以下是一个简化的Spring Boot WebSocket解决方案示例，使用Redis作为消息代理进行发布/订阅：

import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.*;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    private final RedisConnectionFactory connectionFactory;
    private final StringRedisTemplate redisTemplate;

    public WebSocketConfig(RedisConnectionFactory connectionFactory, StringRedisTemplate redisTemplate) {
        this.connectionFactory = connectionFactory;
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic", "/queue"); // 客户端订阅地址前缀
        config.setApplicationDestinationPrefixes("/app"); // 客户端发送信息的地址前缀
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS(); // 注册STOMP协议的节点，并映射指定的URL，并指定使用SockJS协议
    }

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(new ChatMessageInterceptor()); // 注册客户端发往服务端的通道的拦截器
    }

    @Override
    public void configureClientOutboundChannel(ChannelRegistration registration) {
        // 注册服务端发往客户端的通道的拦截器
    }

    @Override
    public void configureMessageConverters(List<MessageConverter> converters) {
        // 配置消息转换器
    }

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        // 配置WebSocket传输
    }

    // 使用RedisMessageListenerContainer来监听Redis订阅频道
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer() {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(new ChatMessageListener(), topic());
        return container;
    }

    // 定义订阅的Redis频道
    @Bean
    public Topic topic() {
        return new ChannelTopic("

2024-09-09

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpHeaderUtil;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketSession;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class WebSocketHandler {

    private static final Map<String, Channel> sessionMap = new ConcurrentHashMap<>();

    @Autowired
    private ApplicationContext applicationContext;

    public void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
        if (!req.decoderResult().isSuccess()
                || (!"websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }

        String sessionId = req.headers().get("Sec-WebSocket-Key");
        ctx.channel().attr(WebSocketSessionManager.SESSION_KEY).set(sessionId);
        WebSocketSessionManager.addSession(sessionId, ctx.channel());

        // 这里省略了WebSocket握手相关代码
    }

    public void sendMessageToClient(String sessionId, String message) {
        Channel channel = sessionMap.get(sessionId);
        if (channel == null) {
            return;
        }

        ByteBuf byteBuf = Unpooled.buffer();
        byteBuf.writeCharSequence(message, StandardCharsets.UTF_8);
        channel.writeAndFlush(byteBuf);
    }

    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, DefaultFullHttpResponse res) {
        if (res.status().code() != 200) {
            ByteBuf byteBuf = Unpooled.copiedBuffer(res.status().toString(), StandardCharsets.UTF_8);
            res.content().writeBytes(byteBuf);
            byteBuf.release();

WebSocket 两个实现方式 (Spring Boot)

2024-09-06

在Spring Boot中，有两种常见的WebSocket实现方式：使用Spring的@EnableWebSocketMessageBroker注解和使用WebSocketServletFactory。

使用@EnableWebSocketMessageBroker注解

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.*;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

使用WebSocketServletFactory

import org.eclipse.jetty.websocket.api.WebSocketServlet;
import org.eclipse.jetty.websocket.api.WebSocketServletFactory;
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;

public class WebSocketEndpoint extends WebSocketServlet {

    @Override
    public void configure(WebSocketServletFactory factory) {
        factory.register(MyWebSocket.class);
    }
}

在这个例子中，MyWebSocket是一个继承自WebSocket的类，用于处理WebSocket连接的打开、关闭和消息接收。

注意：第二种方式使用的是org.eclipse.jetty.websocket.api包中的WebSocket API，这是Jetty项目提供的WebSocket实现。如果你使用的是Tomcat作为你的Servlet容器，那么你可能需要使用Spring的@EnableWebSocketMessageBroker注解方式。

2024-09-06

报错问题描述不够详细，无法提供精确的解决方案。但是，我可以给出一般性的建议来解决Spring Cloud Nacos Gateway集成Netty Websocket不成功的问题。

检查Websocket配置：确保你的Websocket路由配置正确，包括路径匹配、转发的服务地址等。
检查Netty Websocket实现：确保Netty Websocket服务端实现正确，并且能够接收和处理Websocket请求。
检查Nacos Gateway配置：确保Nacos Gateway的路由配置没有问题，并且Netty Websocket服务已经注册到Nacos。
查看日志：检查Spring Cloud Gateway和Netty服务的日志，查找可能的错误信息或异常。
版本兼容性：确保Spring Cloud Gateway和Netty的版本之间兼容。
网络配置：检查是否有防火墙或网络策略阻止了Websocket的连接。
测试环境：如果可能，尝试在测试环境中重现问题，以便于进一步调试。

解决方法通常涉及排查配置、代码实现、网络环境等多个方面。如果你能提供详细的错误信息或日志，我可以给出更具体的解决方案。

2024-09-06

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.concurrent.atomic.AtomicLong;

@Controller
@RequestMapping("/logs")
public class LogController {

    private static final AtomicLong userCounter = new AtomicLong();

    @GetMapping("/stream")
    public SseEmitter streamLog() {
        SseEmitter emitter = new SseEmitter();

        // 在新线程中运行日志读取逻辑
        new Thread(() -> {
            try {
                BufferedReader reader = Files.newBufferedReader(Paths.get("/path/to/logfile.log"));
                String line;
                while ((line = reader.readLine()) != null) {
                    emitter.send(line); // 发送日志行到客户端
                }
                emitter.complete();
            } catch (IOException e) {
                emitter.completeWithError(e);
            }
        }).start();

        return emitter;
    }
}

这个简化的代码示例展示了如何在Spring Boot应用程序中实现类似的日志文件实时流式传输功能。它使用了SseEmitter来创建服务器发送事件，在一个独立的线程中持续读取日志文件，并将新的日志行发送到客户端。这个例子假设你已经有了一个日志文件的路径，并且服务器有足够的权限去读取这个文件。