使用 Python3 搭建简单 HTTP 服务器 – wiki基地

作者： /

使用 Python 3 搭建简单 HTTP 服务器

引言：为何及如何搭建一个简单的HTTP服务器

在网络通信中，HTTP（超文本传输协议）是应用最广泛的协议之一。无论是浏览网页、调用API，还是文件下载，都离不开HTTP协议。理解HTTP协议以及服务器如何处理请求是进行网络编程的基础。

Python作为一门易学易用且功能强大的脚本语言，天然适合进行网络编程。它提供了丰富的标准库，使得搭建一个简单的HTTP服务器变得异常轻松。本文将详细介绍两种在Python 3中搭建简易HTTP服务器的方法：一种是利用Python内置的http.server模块，另一种是更底层的使用socket模块从零开始构建。通过这两种方法，您将深入理解HTTP服务器的工作原理。

基础概念回顾：HTTP与客户端-服务器模型

在深入代码之前，先快速回顾几个基本概念：

  1. 客户端-服务器模型 (Client-Server Model)： 这是网络应用中最常见的模型。客户端（如浏览器）发起请求，服务器接收请求并发送响应。
  2. HTTP协议： 是一种无状态的请求-响应协议。客户端发送HTTP请求（包含方法、路径、头信息、可选的消息体），服务器返回HTTP响应（包含状态码、头信息、消息体）。常见的HTTP方法有GET、POST、PUT、DELETE等。
  3. 套接字 (Socket)： 是网络通信的基本构件，提供了一种进程间通信的方式。服务器通过监听一个特定的IP地址和端口号来接收客户端的连接请求。

方法一：使用 http.server 模块 (最快的方法)

Python标准库中的 http.server 模块提供了一个开箱即用的简单HTTP服务器功能，尤其适合用于快速共享本地文件。

1. 命令行使用

这是最简单的启动一个HTTP服务器的方式，无需编写任何代码。

打开终端或命令提示符，切换到您想共享文件的目录，然后运行以下命令：

bash
python -m http.server 8000

这条命令的含义是：使用Python解释器运行 http.server 模块，并在端口 8000 上启动服务器。

  • python -m http.server：指定运行 http.server 模块。
  • 8000：可选参数，指定监听的端口号。如果省略，默认为 8000。

现在，您可以在浏览器中访问 http://localhost:8000（或者服务器的IP地址）来访问当前目录下的文件。浏览器会显示当前目录的文件列表，点击文件名即可下载或在新标签页打开（取决于文件类型）。

优点：
* 极其简单，无需写代码。
* 快速搭建一个静态文件服务器。

缺点：
* 功能非常基础，只能提供静态文件服务，不能处理动态请求。
* 不适合生产环境。

2. 脚本中使用 http.server

虽然命令行方便，但通过脚本启动可以更灵活地配置服务器。

“`python
import http.server
import socketserver

PORT = 8000
DIRECTORY = “.” # 服务当前目录

指定请求处理器，这里使用 SimpleHTTPRequestHandler

它默认处理 GET 和 HEAD 请求，并根据请求路径提供文件

Handler = http.server.SimpleHTTPRequestHandler

为了解决 Address already in use 错误，可以设置 allow_reuse_address

socketserver.TCPServer.allow_reuse_address = True

创建一个TCP服务器实例

参数：(监听的地址, 端口), 请求处理器

地址 ” 表示监听所有可用的网络接口 (即本机所有IP，包括 localhost)

with socketserver.TCPServer((“”, PORT), Handler) as httpd:
print(f”服务器正在端口 {PORT} 上运行…”)
# serve_forever() 方法会一直运行服务器，直到接收到停止信号 (如 Ctrl+C)
httpd.serve_forever()

如果不使用 with 语句，需要手动 httpd.server_close() 来关闭服务器

httpd = socketserver.TCPServer((“”, PORT), Handler)

print(f”服务器正在端口 {PORT} 上运行…”)

try:

httpd.serve_forever()

except KeyboardInterrupt:

print(“\n服务器已停止。”)

finally:

httpd.server_close()

“`

保存上述代码为 simple_server.py 并运行 python simple_server.py，效果与命令行方式类似。

代码解释：

  • import http.server 和 import socketserver：导入所需的模块。socketserver 模块提供了构建网络服务器的基类。
  • PORT = 8000：定义服务器监听的端口。
  • Handler = http.server.SimpleHTTPRequestHandler：指定使用 SimpleHTTPRequestHandler 作为请求处理器。这是 http.server 提供的处理静态文件请求的类。它会自动解析请求，查找对应文件，并发送响应。
  • socketserver.TCPServer(("", PORT), Handler)：创建一个 TCP 服务器实例。"" 表示监听所有可用的网络接口，PORT 是端口号，Handler 是处理客户端请求的类。
  • with ... as httpd:：使用 with 语句确保服务器在退出时能正确关闭（即使发生异常）。
  • httpd.serve_forever()：启动服务器的主循环，等待并处理客户端连接。

您还可以通过继承 SimpleHTTPRequestHandler 并覆盖其方法（如 do_GET, do_POST）来定制行为，但这已经超出了”最简单”的范畴。

方法二：使用 socket 模块从零开始构建 (理解原理)

使用 http.server 非常方便，但它隐藏了底层HTTP协议处理和网络通信的细节。为了更深入地理解HTTP服务器的工作原理，我们可以直接使用Python的 socket 模块来构建一个非常基础的服务器。

这个从零开始构建的服务器将只处理最简单的GET请求，并返回一个固定的“Hello, World!”响应。

“`python
import socket
import threading # 用于处理多个客户端连接

HOST = ‘127.0.0.1’ # 监听本地环回地址，也可以用 ‘0.0.0.0’ 监听所有接口
PORT = 8000

def handle_client(client_socket):
“””
处理单个客户端连接的函数
“””
request_data = client_socket.recv(1024) # 接收客户端发送的数据，最大1024字节
# 注意：recv 可能无法一次接收完整的请求，特别是对于大请求体。
# 真实服务器需要更复杂的逻辑来完整接收数据。
print(f”接收到请求:\n{request_data.decode(‘utf-8’)}”)

# 简单的HTTP响应：状态行，响应头，空行，响应体
# 对于GET请求，我们只返回一个固定的简单文本响应
# 状态行: HTTP版本 状态码 状态描述
# 响应头: Content-Type 指明响应体类型，Content-Length 指明响应体长度
# 空行: 必须有，用于分隔响应头和响应体
# 响应体: 实际发送给客户端的内容
response_body = "Hello from simple socket server!"
response_headers = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n"
response_headers += f"Content-Length: {len(response_body.encode('utf-8'))}\r\n\r\n"

response = response_headers.encode('utf-8') + response_body.encode('utf-8')

client_socket.sendall(response) # 将完整的响应发送给客户端
client_socket.close() # 关闭客户端连接

def run_server():
“””
运行服务器主循环
“””
# 1. 创建一个 socket 对象
# socket.AF_INET 表示使用 IPv4 地址族
# socket.SOCK_STREAM 表示使用面向连接的 TCP 协议
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 可选：设置 SO_REUSEADDR 选项，允许端口快速重用
# 避免程序意外退出后端口被占用，需要等待一段时间才能再次启动的问题
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# 2. 绑定地址和端口
server_socket.bind((HOST, PORT))
print(f"服务器已绑定到 {HOST}:{PORT}")

# 3. 开始监听连接
# 参数是等待连接的最大数量 (连接队列的长度)
server_socket.listen(5)
print("服务器正在监听连接...")

# 4. 进入主循环，接受客户端连接并处理
while True:
    try:
        # 接受客户端连接
        # accept() 方法会阻塞，直到有客户端连接
        # 返回一个 tuple: (新的连接 socket 对象, 客户端地址)
        client_socket, client_address = server_socket.accept()
        print(f"接受到来自 {client_address} 的连接")

        # 为每个客户端连接创建一个新的线程来处理
        # 这样服务器就可以同时处理多个客户端连接，不会因为一个连接的阻塞而影响其他连接
        client_handler = threading.Thread(
            target=handle_client,
            args=(client_socket,) # 参数是 client_socket，注意 args 需要是 tuple
        )
        client_handler.start() # 启动线程

    except KeyboardInterrupt:
        # 用户按下 Ctrl+C 停止服务器
        print("\n收到停止信号，服务器正在关闭...")
        break
    except Exception as e:
        # 捕获其他可能的异常
        print(f"服务器运行出错: {e}")
        # 在实际应用中，这里可能需要更详细的日志记录和错误处理

# 循环结束后关闭服务器 socket
server_socket.close()
print("服务器已关闭。")

if name == “main“:
run_server()
“`

保存上述代码为 socket_server.py 并运行 python socket_server.py。然后在浏览器中访问 http://localhost:8000，您将看到“Hello from simple socket server!”的文本。

代码解释：

  • import socket 和 import threading： 导入socket模块用于网络通信，导入threading模块用于实现并发处理。
  • HOST, PORT： 定义服务器监听的地址和端口。
  • run_server() 函数：
    • socket.socket(socket.AF_INET, socket.SOCK_STREAM)：创建一个TCP套接字对象。AF_INET 表示IPv4地址族，SOCK_STREAM 表示使用TCP协议。
    • server_socket.setsockopt(...)：设置套接字选项，SO_REUSEADDR 允许端口重用，避免常见的“Address already in use”错误。
    • server_socket.bind((HOST, PORT))：将套接字绑定到指定的地址和端口。服务器将在此地址和端口上等待连接。
    • server_socket.listen(5)：使服务器开始监听连接。参数 5 是连接队列的最大长度，表示在服务器忙于处理其他连接时，最多可以有多少个待处理的连接请求排队。
    • while True:：服务器的主循环，不断接受新的客户端连接。
    • server_socket.accept()：接受一个客户端连接。这是一个阻塞调用，直到有客户端连接到达。成功连接后，它返回一个新的套接字对象（client_socket），用于与该客户端通信，以及客户端的地址（client_address）。
    • threading.Thread(...)：每接受一个新连接，就创建一个新的线程来处理该连接。这是实现服务器并发处理（同时服务多个客户端）的一种简单方式。target 指定线程执行的函数，args 是传递给该函数的参数。
    • client_handler.start()：启动新创建的线程。
    • try...except KeyboardInterrupt...finally：用于捕获用户中断信号（Ctrl+C），以便优雅地关闭服务器。
    • server_socket.close()：在循环结束后关闭服务器套接字。
  • handle_client(client_socket) 函数：
    • client_socket.recv(1024)：从客户端套接字接收数据。参数指定一次最多接收的字节数。这是一个阻塞调用，直到接收到数据或连接关闭。接收到的数据是字节串（bytes），需要用 .decode('utf-8') 解码成字符串才能处理。
    • print(...)：打印接收到的客户端请求，用于调试。
    • 构建HTTP响应：手动拼接HTTP状态行、头信息和响应体。注意，HTTP头信息和响应体之间必须有一个空行（\r\n\r\n）。
    • response_body.encode('utf-8')：将字符串响应体编码为字节串，因为网络传输的是字节。
    • client_socket.sendall(response)：将完整的字节串响应发送给客户端。sendall 确保发送所有数据，直到数据完全发送或发生错误。
    • client_socket.close()：关闭与该客户端的连接。完成一次请求-响应循环后，通常会关闭连接（对于HTTP/1.0默认如此，HTTP/1.1默认是Keep-Alive，更复杂的服务器需要处理连接保持）。

并发处理说明：

简单的socket服务器在接受一个连接后，处理该连接（接收请求、发送响应）的过程中会阻塞。如果处理时间较长，其他客户端将无法连接，必须等待。使用 threading 模块为每个新连接创建一个独立的线程，可以将处理任务放到单独的线程中执行，主线程可以继续等待并接受新的连接，从而实现并发处理。

这个简单 socket 服务器的局限性：

  • 只处理 GET 请求： 没有解析HTTP方法，无法处理POST、PUT等请求。
  • 不解析请求头和请求体： 无法获取请求中的Cookies、User-Agent、POST数据等信息。
  • 不处理请求路径： 无论请求哪个路径 (/, /about, /images/logo.png)，都返回相同的响应。
  • 基本的错误处理： 没有处理各种可能的HTTP状态码（404 Not Found, 500 Internal Server Error等）。
  • 没有处理 Keep-Alive： HTTP/1.1 默认支持连接保持，以便在同一个连接上发送多个请求。这个服务器每次处理完请求后都关闭连接。
  • 简单的并发： 使用线程虽然实现了并发，但在处理大量连接时，线程开销会变得很高。更高级的服务器通常使用基于事件循环的异步I/O（如 asyncio）或进程池来处理高并发。
  • 安全性： 没有考虑任何安全问题。

总结

本文详细介绍了使用 Python 3 搭建简单 HTTP 服务器的两种方法。

  1. 使用 http.server 模块： 这是 Python 标准库提供的快速搭建静态文件服务器的方式，非常适合临时共享文件或进行简单测试。通过命令行或少量代码即可实现。
  2. 使用 socket 模块从零构建： 通过 socket 模块，我们可以更深入地理解客户端-服务器通信、TCP连接以及HTTP协议的请求和响应结构。虽然代码量更多，功能更基础，但它有助于理解底层原理。结合 threading 模块，我们可以实现简单的并发处理。

从零构建的服务器展示了HTTP服务器的核心逻辑：创建监听套接字 -> 绑定地址端口 -> 监听 -> 循环接受连接 -> 为每个连接接收请求 -> 解析请求（尽管简单） -> 准备HTTP响应 -> 发送响应 -> 关闭连接。

需要注意的是，无论是 http.server 还是我们从零构建的 socket 服务器，它们都是非常基础的实现，不适用于生产环境。生产级的HTTP服务器（如 Nginx, Apache）或基于 Python 的 Web 框架（如 Django, Flask）提供了更完善的HTTP协议处理、路由、模板引擎、数据库集成、安全特性、性能优化和可扩展性。

通过实践本文介绍的代码，您将对HTTP协议和服务器端编程建立起更扎实的理解基础，为学习更高级的Web开发技术打下良好基础。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部