2-TCP 编程示例

应用程序通常通过“套接字”（socket）向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通信。

Python语言提供了两种访问网络服务的功能。

其中低级别的网络服务通过套接字实现，它提供了标准的BSD 套接字 API，可以访问底层操作系统套接字接口的全部方法。

而高级别的网络服务通过模块 SocketServer实现，它提供了服务器中心类，可以简化网络服务器的开发

2-1-socket套接字

2-1-1-什么是套接字

套接字（Socket）是计算机网络中用于在不同计算机之间实现数据传输的一种软件技术。它使得应用程序可以通过网络进行通信。套接字位于应用层和传输层之间，充当一个抽象层，将复杂的网络通信细节隐藏起来，提供给程序员一个简洁的接口来进行网络编程。

套接字可以被看作是网络上的一个端点，由IP地址和端口号组成。通过这种方式，不同的进程或程序就可以通过网络互相连接和通信。

套接字支持多种协议，包括TCP、UDP等，它们分别提供了面向连接和无连接的服务。

2-1-2-socke的主要类型

1. 流式套接字（SOCK_STREAM）：提供可靠的、双向的、基于连接的字节流服务，使用TCP协议。

2. 数据报套接字（SOCK_DGRAM）：提供不可靠的、无连接的数据报服务，使用UDP协议。

3. 原始套接字（SOCK_RAW）：允许直接访问较低层次的协议，如IP协议，通常只在需要执行某些特殊操作时才使用。

2-2-socket 模块

Python 网络编程的基础，它提供了对底层操作系统套接字接口的访问。借助它，你能够创建客户端和服务器程序，实现网络通信

2-2-1-语法

2-2-1-1-语法01

函数socket()能够创建socket对象。此函数是套接字网络编程的基础对象，

socket(socket_family, socket_type,protocol=0)

1. 参数“socket_family”的值是AF_UNIX或AF_INET
1. AF_UNIX用于创建本地套接字，它主要用于同一台主机上不同进程间的通信。使用这种方式的通信速度较快，因为数据无需经过网络协议栈的处理。
2. AF_INET用于创建基于 IPv4 的网络套接字，它能够实现不同主机之间的网络通信
2. 参数“socket_type”是SOCK_STREAM或SOCK_DGRAM
1. SOCK_STREAM表示使用面向连接的 TCP（传输控制协议）套接字。这种套接字提供了可靠的、基于字节流的通信方式，数据会按照发送的顺序准确无误地到达接收方。TCP 会自动处理数据的分段、重传、排序等问题，适用于对数据准确性要求较高的场景，如文件传输、网页浏览等
2. SOCK_DGRAM表示使用无连接的 UDP（用户数据报协议）套接字。UDP 不保证数据的可靠传输，也不保证数据的顺序，它只是简单地将数据报发送出去。不过，UDP 的开销较小，传输速度快，适用于对实时性要求较高、对数据准确性要求相对较低的场景，如视频直播、实时游戏等
3. 参数“protocol”通常省略，默认为0

2-2-1-2-语法02

创建TCP/IP套接字，可以用下面的代码调用socket.socket()。

tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

在创建UDP/IP套接字时需要执行如下所示的代码

udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

2-2-2-常用函数和属性

2-2-2-1-服务器端套接字函数

2-2-2-2-客户端套接字函数

2-2-2-3-公共用途的套接字函数

2-2-2-5-socket模块的属性和异常信息

2-2-3-案例-简单的客户端 - 服务器通信

以下是一个使用 socket 模块实现的简单的客户端

2-2-3-1-服务器通信示例

# 服务器端代码
import socket

# 创建一个 TCP/IP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定地址和端口
server_address = ('localhost', 8888)
server_socket.bind(server_address)

# 开始监听，最大连接数为 1
server_socket.listen(1)

print('Waiting for a connection...')
# 接受客户端连接
connection, client_address = server_socket.accept()

try:
    print(f'Connection from {client_address}')

    # 接收客户端发送的数据
    # data = connection.recv(1024)
    # print(f'Received: {data.decode('utf-8')}')
    while True:  # 连接成功后
        data = connection.recv(1024)  # 实行对话操作（接收/发送）
        print(f'Received: {data.decode()}')  # 显示获取的信息
        if not data:  # 如果没有数据
            break  # 终止循环
        connection.sendall(data)  # 发送数据信息
    # 发送响应给客户端
    message = 'Hello, client!'
    connection.sendall(message.encode())

finally:
    # 关闭连接
    connection.close()

2-2-3-2-客户端示例

示例01

import socket

# 创建一个 TCP/IP 套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 服务器地址和端口
server_address = ('localhost', 8888)

# 连接到服务器
client_socket.connect(server_address)

try:
    # 发送数据到服务器
    message = 'Hello, server!'
    client_socket.sendall(message.encode())

    # 接收服务器响应
    data = client_socket.recv(1024)
    print(f'Received from server: {data.decode()}')

finally:
    # 关闭连接
    client_socket.close()

示例02

import socket

# 创建一个 TCP/IP 套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 服务器地址和端口
server_address = ('localhost', 8888)

# 连接到服务器
client_socket.connect(server_address)

try:
    # 发送数据到服务器
    message = 'Hello, server!'
    while message:
        client_socket.sendall(message.encode('utf-8'))  # 发送数据“你好”
        message = client_socket.recv(512)  # 实行对话操作（接收/发送）
        print("获取服务器信息：\n", message.decode('utf-8'))  # 显示接收到的服务器信息
        message = input('请输入信息：\n')  # 信息输入
finally:
    # 关闭连接
    client_socket.close()

2-3-socketserver 模块

2-3-1-介绍

socketserver 模块提供了高级的服务器类，能简化服务器程序的开发。它支持多种服务器类型，如 TCP 服务器、UDP 服务器、多线程服务器和多进程服务器等，简化了网络服务器的开发步骤。

2-3-2-常用类

其中有TCP字符使用的是TCP协议的服务器类，UDP字符使用的是UDP协议的服务器类，Threading字符使用的是多线程服务器类，Forking字符使用的是多进程服务器类。要想创建不同类型的服务器程序，只须继承其中之一或直接实例化，然后调用服务器类方法serve_forever()即可。这些服务器的构造方法参数主要有以下两个

1. server_address：由IP地址和端口构成的元组。
2. RequestHandlerClass：处理器类，供服务器类调用处理数据。

在socketserver模块中最为常用的处理器类主要有StreamRequestHandler（基于TCP协议）和DatagramRequestHandler（基于UDP协议）。只要继承其中之一，就可以自定义一个处理器类。通过覆盖以下3个方法可以实现自定义功能。

1. setup()：为请求准备请求处理器（请求处理的初始化工作）。
2. handle ()：实现具体的请求处理工作（解析请求、处理数据、发出响应）。
3. finish()：清理请求处理器的相关数据。

2-3-3-案例-简单的 TCP 服务器

以下是一个使用 socketserver 模块实现的简单的 TCP 服务器示例

2-3-3-1-服务端示例

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    """
    处理客户端请求的类
    """

    def handle(self):
        # 接收客户端发送的数据
        self.data = self.request.recv(1024).strip()
        print(f"Received from {self.client_address}: {self.data.decode()}")

        # 发送响应给客户端
        message = 'Hello, client!'
        self.request.sendall(message.encode())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    # 创建一个 TCP 服务器
    with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server:
        print(f"Server is listening on {HOST}:{PORT}")
        # 启动服务器
        server.serve_forever()

2-3-3-2-客户端示例

# 客户端代码
import socket

# 创建一个 TCP/IP 套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 服务器地址和端口
server_address = ('localhost', 9999)

# 连接到服务器
client_socket.connect(server_address)

try:
    # 发送数据到服务器
    message = 'Hello, server!'
    client_socket.sendall(message.encode())

    # 接收服务器响应
    data = client_socket.recv(1024)
    print(f'Received from server: {data.decode()}')

finally:
    # 关闭连接
    client_socket.close()

2-3-4-socketserver模块的工作原理

socketserver 模块是 Python 中用于简化网络服务器编程的高级模块，它基于 `socket` 模块构建，提供了多种服务器类和请求处理机制。下面详细介绍其工作原理：

2-3-4-1-整体架构

socketserver模块采用了一种分层架构，将服务器的核心功能拆分成多个组件，主要包括服务器类（如 TCPServer、UDPServer）和请求处理类（如 BaseRequestHandler），这种设计使得服务器的创建和扩展变得更加容易。

2-3-4-2-工作流程

2-3-4-2-1-创建服务器对象

首先，你需要选择合适的服务器类来创建一个服务器对象。常用的服务器类有：

- TCPServer：用于创建基于 TCP 协议的服务器。

- UDPServer：用于创建基于 UDP 协议的服务器。

创建服务器对象时，需要指定服务器的地址和端口，以及处理客户端请求的请求处理类。例如：

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        pass

server = socketserver.TCPServer(('localhost', 8888), MyTCPHandler)

2-3-4-2-2 -绑定地址和端口

服务器对象创建后，会自动将自身绑定到指定的地址和端口上。这一步是通过 `socket` 模块的 `bind()` 方法实现的，它将服务器套接字与特定的 IP 地址和端口号关联起来，以便接收客户端的连接请求。

2-3-4-2-3-开始监听（仅适用于 TCP 服务器）

对于 TCP 服务器，在绑定地址和端口后，需要调用 `listen()` 方法开始监听客户端的连接请求。该方法会将服务器套接字设置为监听状态，等待客户端的连接。例如：

server.server_activate()

2-3-4-2-4-4-等待客户端连接

服务器进入等待状态，不断监听指定的地址和端口。当有客户端发起连接请求时，服务器会根据协议类型进行相应的处理：

- TCP 服务器：调用 `accept()` 方法接受客户端的连接请求，创建一个新的套接字对象用于与客户端进行通信。

- UDP 服务器：由于 UDP 是无连接的协议，服务器不需要接受连接请求，直接等待客户端发送数据。

2-3-4-2-5-处理客户端请求

当服务器接收到客户端的连接请求或数据后，会创建一个请求处理对象，并调用其 `handle()` 方法来处理客户端的请求。请求处理类是你自定义的，继承自 `BaseRequestHandler` 类，你需要在 `handle()` 方法中实现具体的请求处理逻辑。例如：

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        # 接收客户端发送的数据
        self.data = self.request.recv(1024).strip()
        print(f"Received from {self.client_address}: {self.data.decode()}")
        # 发送响应给客户端
        message = 'Hello, client!'
        self.request.sendall(message.encode())

2-3-4-2-6-关闭连接

当请求处理完成后，服务器会关闭与客户端的连接（对于 TCP 服务器），并继续等待下一个客户端的连接请求。

finally:
    # 关闭连接
    connection.close()

2-3-4-3-并发处理

socketserver模块还支持并发处理客户端请求，提供了以下几种并发处理方式：

多线程处理：使用 ThreadingTCPServer 或 ThreadingUDPServer类，每个客户端请求会在一个单独的线程中处理，从而实现并发处理。

多进程处理：使用 ForkingTCPServer 或 ForkingUDPServer类，每个客户端请求会在一个单独的进程中处理，适用于需要大量计算资源的场景。

例如，使用多线程处理客户端请求的示例：

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        pass
server = socketserver.ThreadingTCPServer(('localhost', 8888), MyTCPHandler)
server.serve_forever()