python 模拟client server端

在网络编程中，客户端和服务器的通信是最基础的操作之一。Python 提供了强大的库，如 socket，可以用来模拟客户端和服务器的交互。本文将详细介绍如何使用 Python 实现一个简单的客户端和服务器程序，并在此基础上进行大量功能扩展，如多线程处理、多客户端支持、加密通信、文件传输等。

一、基础实现：Python 模拟客户端和服务器

1. 服务器端实现

首先，我们实现一个简单的 TCP 服务器，它监听客户端的连接并接收消息。

登录后复制

import socket

def start_server(host='127.0.0.1', port=65432):
    # 创建 socket 对象
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Server started at {host}:{port}, waiting for connection...")

        conn, addr = s.accept()
        with conn:
            print(f"Connected by {addr}")
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                print(f"Received: {data.decode('utf-8')}")
                conn.sendall(data)  # 回传数据给客户端

if __name__ == "__main__":
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.

2. 客户端实现

客户端负责连接服务器，并发送消息。

登录后复制

import socket

def start_client(host='127.0.0.1', port=65432):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((host, port))
        message = "Hello, Server!"
        s.sendall(message.encode('utf-8'))
        data = s.recv(1024)
        print(f"Received from server: {data.decode('utf-8')}")

if __name__ == "__main__":
    start_client()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.

3. 运行和测试

在终端中先运行服务器程序，然后在另一个终端中运行客户端程序。客户端发送的消息会被服务器接收并返回。

登录后复制

python server.py
python client.py

• 1.
• 2.

二、功能扩展

1. 多线程支持

为了让服务器能够同时处理多个客户端连接，我们可以为每个客户端连接启动一个新的线程。

服务器端多线程实现

登录后复制

import socket
import threading

def handle_client(conn, addr):
    print(f"New connection from {addr}")
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            print(f"Received from {addr}: {data.decode('utf-8')}")
            conn.sendall(data)

def start_server(host='127.0.0.1', port=65432):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Server started at {host}:{port}, waiting for connections...")

        while True:
            conn, addr = s.accept()
            client_thread = threading.Thread(target=handle_client, args=(conn, addr))
            client_thread.start()

if __name__ == "__main__":
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.

2. 支持多个客户端

现在，服务器可以同时处理多个客户端连接。只需启动多个客户端实例，就能与服务器同时通信。

3. 数据加密通信

为了保证通信安全，我们可以在数据传输前对其进行加密。这里使用 cryptography 库进行对称加密。

安装依赖

登录后复制

pip install cryptography

• 1.

服务器端和客户端加密实现

服务器端：

登录后复制

from cryptography.fernet import Fernet
import socket
import threading

# 密钥生成（仅运行一次），实际应安全存储
key = Fernet.generate_key()

def handle_client(conn, addr, cipher):
    print(f"New connection from {addr}")
    with conn:
        while True:
            encrypted_data = conn.recv(1024)
            if not encrypted_data:
                break
            data = cipher.decrypt(encrypted_data)
            print(f"Received from {addr}: {data.decode('utf-8')}")
            conn.sendall(cipher.encrypt(data))

def start_server(host='127.0.0.1', port=65432):
    cipher = Fernet(key)
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Server started at {host}:{port}, waiting for connections...")

        while True:
            conn, addr = s.accept()
            client_thread = threading.Thread(target=handle_client, args=(conn, addr, cipher))
            client_thread.start()

if __name__ == "__main__":
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.

客户端：

登录后复制

from cryptography.fernet import Fernet
import socket

# 使用相同的密钥
key = b'your-generated-key'
cipher = Fernet(key)

def start_client(host='127.0.0.1', port=65432):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((host, port))
        message = "Hello, Secure Server!"
        encrypted_message = cipher.encrypt(message.encode('utf-8'))
        s.sendall(encrypted_message)
        encrypted_data = s.recv(1024)
        data = cipher.decrypt(encrypted_data)
        print(f"Received from server: {data.decode('utf-8')}")

if __name__ == "__main__":
    start_client()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

4. 文件传输功能

通过 socket，可以传输文件或其他二进制数据。

服务器端文件接收实现

登录后复制

import socket
import os

def start_server(host='127.0.0.1', port=65432):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Server started at {host}:{port}, waiting for connections...")

        conn, addr = s.accept()
        with conn:
            print(f"Connected by {addr}")
            with open("received_file", "wb") as f:
                while True:
                    data = conn.recv(1024)
                    if not data:
                        break
                    f.write(data)
            print("File received successfully")

if __name__ == "__main__":
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.

客户端文件发送实现

登录后复制

import socket

def start_client(file_path, host='127.0.0.1', port=65432):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((host, port))
        with open(file_path, "rb") as f:
            data = f.read(1024)
            while data:
                s.sendall(data)
                data = f.read(1024)
        print("File sent successfully")

if __name__ == "__main__":
    start_client("path_to_your_file")

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.

5. 心跳检测与断线重连

为了保证长连接的可靠性，可以实现心跳机制，定时发送心跳包，确保连接的有效性。若连接中断，可以尝试重新连接。

服务器端：

登录后复制

def handle_client(conn, addr):
    with conn:
        while True:
            try:
                conn.settimeout(10)  # 设置心跳包超时时间
                data = conn.recv(1024)
                if not data:
                    break
                if data.decode('utf-8') == 'PING':
                    conn.sendall(b'PONG')
                else:
                    conn.sendall(data)
            except socket.timeout:
                print(f"Connection with {addr} lost (timeout).")
                break

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.

客户端：

登录后复制

import time

def start_client(host='127.0.0.1', port=65432):
    while True:
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.connect((host, port))
                while True:
                    s.sendall(b'PING')
                    data = s.recv(1024)
                    if data.decode('utf-8') == 'PONG':
                        print("Server is alive")
                    time.sleep(5)
        except (ConnectionResetError, ConnectionRefusedError):
            print("Server is down, retrying...")
            time.sleep(5)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.

三、总结

本文详细介绍了如何使用 Python 模拟客户端和服务器端的通信。我们从最基础的 TCP 连接开始，逐步扩展功能，涵盖了多线程、多客户端支持、加密通信、文件传输、以及心跳检测和断线重连等高级功能。这些技术在实际的网络应用中非常实用，尤其是在需要高可用性和安全性的场景下。

通过这些扩展功能，我们可以打造一个更健壮和可靠的网络通信系统，能够处理各种复杂的网络环境和需求。

原创作者: u_16554898 转载于: https://blog.51cto.com/u_16554898/11739978