HTTP/1.0：扩展协议

在上一篇实验中，我们亲手实现了一个 HTTP/0.9 服务器，体验了它「极简到极致」的设计哲学。但 0.9 的局限也暴露得很清楚：浏览器收到一串二进制字节，不知道是什么文件类型；请求失败了，服务器没法告诉客户端到底出了什么错；每个资源都要新建 TCP 连接，性能很差。1996 年，HTTP/1.0 作为 RFC 1945 正式发布，逐一解决了这些问题。

元信息的缺失：HTTP/1.0 引入了请求头和响应头，客户端可以告诉服务器自己能接受什么类型的内容，服务器也可以告诉客户端返回内容的 MIME 类型、长度、编码方式等。这就像在寄快递时，寄出物品本身的同时，还附上一份清单说明「这是照片，A4 大小，共 10 页」。

状态表达的缺失：HTTP/1.0 引入了状态码体系，服务器用三位数字明确告诉客户端请求的处理结果：成功了？重定向了？还是出错了？这让客户端程序能够自动化地处理各种情况。

方法的单一：HTTP/1.0 定义了 GET、POST、HEAD 三种方法，不再局限于「获取文档」，还支持「提交数据」「只获取头信息」等操作。这为 Web 应用的发展奠定了基础。

一、新增特性详解#

1.1 请求行与请求头#

HTTP/1.0 的请求格式发生了重大变化。首先是请求行：现在包含了 HTTP 版本号。

1
GET /index.html HTTP/1.0\r\n

紧接着请求行之后，可以附加多行请求头，每个头占一行，格式为 Header-Name: Header-Value。请求头与请求行之间、请求头与请求体之间都用空行分隔。

1
GET /index.html HTTP/1.0\r\n
2
Host: localhost:8080\r\n
3
User-Agent: MyBrowser/1.0\r\n
4
Accept: text/html\r\n
5
\r\n

Note

最后的 \r\n 是空行，表示请求头结束。如果请求有 body（比如 POST 请求），body 就跟在空行后面。

这种设计让协议具备了「协商能力」。客户端通过 Accept 头告诉服务器「我能接受 HTML 格式」，服务器通过检查这个头来决定返回什么内容。如果客户端发送 Accept: application/json，服务器就知道应该返回 JSON 而不是 HTML。

1.2 响应头与状态行#

HTTP/1.0 的响应也变得结构化了。首先是状态行：

1
HTTP/1.0 200 OK\r\n

状态行由三部分组成：HTTP 版本号、状态码（三位数字）、状态描述（人类可读的短语）。状态码是机器处理的关键，状态描述则是给人看的。

状态行之后是响应头，格式与请求头相同：

1
HTTP/1.0 200 OK\r\n
2
Content-Type: text/html\r\n
3
Content-Length: 1234\r\n
4
Server: MyServer/1.0\r\n
5
\r\n
6
<html>...

响应头结束后是一个空行，然后才是响应体。

这里最关键的两个头是 Content-Type 和 Content-Length。Content-Type 告诉客户端返回内容的 MIME 类型，浏览器据此决定是渲染 HTML、显示图片、还是下载文件。Content-Length 则告诉客户端响应体有多少字节，客户端可以据此判断是否接收完整，而不再依赖 TCP 连接关闭来判断结束。

1.3 状态码体系#

HTTP/1.0 定义了状态码的分类规则，第一位数字表示类别：

类别	范围	含义	常见例子
2xx	200-299	成功	200 OK, 201 Created, 204 No Content
3xx	300-399	重定向	301 Moved Permanently, 302 Found
4xx	400-499	客户端错误	400 Bad Request, 404 Not Found, 403 Forbidden
5xx	500-599	服务器错误	500 Internal Server Error, 503 Service Unavailable

这个分类在 30 年后的今天还在用，足以说明设计的合理性。浏览器看到 301 就自动跳转，看到 404 就显示”页面未找到”，看到 500 就提示”服务器错误”。程序可以自动处理，无需人工干预。在 0.9 时代，这些情况只能靠人眼阅读响应内容来判断。

1.4 三种请求方法#

HTTP/1.0 定义了三种请求方法：

GET：获取资源。这是最常用的方法，请求体通常为空。GET 请求应该是「幂等」的，即多次请求同一资源应该得到相同结果，且不会改变服务器状态。

POST：提交数据。客户端可以在请求体中发送数据给服务器处理。比如提交表单、上传文件。POST 请求可能会改变服务器状态（比如创建新记录）。CGI 时代的刚需：表单提交、文件上传，没有 POST 就没有 Web 应用，只有静态文档。

HEAD：只获取响应头。与 GET 类似，但服务器只返回状态行和响应头，不返回响应体。检查链接是否还活着、获取文件大小决定是否下载、验证缓存是否有效，HEAD 让这些操作不用下载完整内容。

二、实验一：用 Python 实现 HTTP/1.0 服务器#

现在我们来实现一个支持 HTTP/1.0 的服务器。相比上一篇的 HTTP/0.9 服务器，这个版本需要解析请求头、生成响应头、正确处理状态码。

核心逻辑只有两个函数。parse_request 负责解析请求：

1
def parse_request(data):
2
    """解析 HTTP/1.0 请求，返回 (method, path, headers, body)"""
3
    try:
4
        # 分离请求头和请求体
5
        if b'\r\n\r\n' in data:
6
            header_part, body = data.split(b'\r\n\r\n', 1)
7
        else:
8
            header_part = data
9
            body = b''
10

11
        lines = header_part.decode('iso-8859-1').split('\r\n')
12
        if not lines:
13
            return None, None, {}, b''
14

15
        # 解析请求行：GET /path HTTP/1.0
16
        request_line = lines[0]
17
        parts = request_line.split()
18
        if len(parts) < 2:
19
            return None, None, {}, b''
20

21
        method = parts[0].upper()
22
        path = parts[1]
23
        # HTTP 版本号（可能是 HTTP/1.0 或 HTTP/0.9 无版本）
24
        version = parts[2] if len(parts) > 2 else 'HTTP/0.9'
25

26
        # 解析请求头
27
        headers = {}
28
        for line in lines[1:]:
29
            if ': ' in line:
30
                key, value = line.split(': ', 1)
31
                headers[key.lower()] = value
32

33
        return method, path, headers, body
34
    except Exception as e:
35
        print(f"Error parsing request: {e}")
36
        return None, None, {}, b''

先按 \r\n\r\n 把原始数据切成「头部」和「体」两部分，再逐行解析请求行和各个头字段。iso-8859-1 是 HTTP 协议的默认编码，可以安全处理任意字节。

build_response 负责构建响应：

1
def build_response(status_code, status_text, headers, body):
2
    """构建 HTTP/1.0 响应"""
3
    response = f"HTTP/1.0 {status_code} {status_text}\r\n"
4
    for key, value in headers.items():
5
        response += f"{key}: {value}\r\n"
6
    response += "\r\n"
7
    return response.encode('iso-8859-1') + body

状态行、响应头、空行、响应体，按顺序拼接成字节序列。最后的空行 \r\n 必不可少，它分隔响应头和响应体。

完整服务器实现（http10_server.py）

1
#!/usr/bin/env python3
2
# http10_server.py -- HTTP/1.0 server for learning
3
import socket
4
import threading
5
import os
6
from datetime import datetime
7

8
HOST = '0.0.0.0'
9
PORT = 8080
10
WWW = 'www'
11

12
def parse_request(data):
13
    """解析 HTTP/1.0 请求，返回 (method, path, headers, body)"""
14
    try:
15
        # 分离请求头和请求体
16
        if b'\r\n\r\n' in data:
17
            header_part, body = data.split(b'\r\n\r\n', 1)
18
        else:
19
            header_part = data
20
            body = b''
21

22
        lines = header_part.decode('iso-8859-1').split('\r\n')
23
        if not lines:
24
            return None, None, {}, b''
25

26
        # 解析请求行：GET /path HTTP/1.0
27
        request_line = lines[0]
28
        parts = request_line.split()
29
        if len(parts) < 2:
30
            return None, None, {}, b''
31

32
        method = parts[0].upper()
33
        path = parts[1]
34
        # HTTP 版本号（可能是 HTTP/1.0 或 HTTP/0.9 无版本）
35
        version = parts[2] if len(parts) > 2 else 'HTTP/0.9'
36

37
        # 解析请求头
38
        headers = {}
39
        for line in lines[1:]:
40
            if ': ' in line:
41
                key, value = line.split(': ', 1)
42
                headers[key.lower()] = value
43

44
        return method, path, headers, body
45
    except Exception as e:
46
        print(f"Error parsing request: {e}")
47
        return None, None, {}, b''
48

49
def build_response(status_code, status_text, headers, body):
50
    """构建 HTTP/1.0 响应"""
51
    response = f"HTTP/1.0 {status_code} {status_text}\r\n"
52
    for key, value in headers.items():
53
        response += f"{key}: {value}\r\n"
54
    response += "\r\n"
55
    return response.encode('iso-8859-1') + body
56

57
def get_mime_type(path):
58
    """根据文件扩展名返回 MIME 类型"""
59
    ext = os.path.splitext(path)[1].lower()
60
    mime_types = {
61
        '.html': 'text/html',
62
        '.htm': 'text/html',
63
        '.css': 'text/css',
64
        '.js': 'application/javascript',
65
        '.json': 'application/json',
66
        '.png': 'image/png',
67
        '.jpg': 'image/jpeg',
68
        '.jpeg': 'image/jpeg',
69
        '.gif': 'image/gif',
70
        '.ico': 'image/x-icon',
71
        '.txt': 'text/plain',
72
    }
73
    return mime_types.get(ext, 'application/octet-stream')
74

75
def handle_conn(conn, addr):
76
    try:
77
        # 读取请求数据（简单实现：读取直到遇到空行）
78
        data = b''
79
        while b'\r\n\r\n' not in data:
80
            chunk = conn.recv(1024)
81
            if not chunk:
82
                break
83
            data += chunk
84

85
        if not data:
86
            return
87

88
        method, path, headers, body = parse_request(data)
89

90
        if method is None:
91
            response = build_response(400, "Bad Request",
92
                {"Content-Type": "text/html", "Content-Length": "11"},
93
                b"Bad Request")
94
            conn.sendall(response)
95
            return
96

97
        print(f"[{addr}] {method} {path} HTTP/1.0")
98

99
        # 处理路径
100
        if path == '/':
101
            path = '/index.html'
102

103
        # 安全处理：防止路径遍历攻击
104
        safe_path = os.path.normpath(path).lstrip(os.sep)
105
        full_path = os.path.join(WWW, safe_path)
106

107
        # 处理 HEAD 请求
108
        if method == 'HEAD':
109
            if os.path.isfile(full_path):
110
                mime = get_mime_type(full_path)
111
                size = os.path.getsize(full_path)
112
                response = build_response(200, "OK",
113
                    {"Content-Type": mime, "Content-Length": str(size)},
114
                    b'')
115
            else:
116
                not_found_body = b'<html><body><h1>404 Not Found</h1><p>The requested resource was not found.</p></body></html>'
117
                response = build_response(404, "Not Found",
118
                    {"Content-Type": "text/html", "Content-Length": str(len(not_found_body))},
119
                    b'')
120
            conn.sendall(response)
121
            return
122

123
        # 处理 GET 请求
124
        if method == 'GET':
125
            if os.path.isfile(full_path):
126
                with open(full_path, 'rb') as f:
127
                    content = f.read()
128
                mime = get_mime_type(full_path)
129
                response = build_response(200, "OK",
130
                    {"Content-Type": mime, "Content-Length": str(len(content))},
131
                    content)
132
            else:
133
                body = b'<html><body><h1>404 Not Found</h1><p>The requested resource was not found.</p></body></html>'
134
                response = build_response(404, "Not Found",
135
                    {"Content-Type": "text/html", "Content-Length": str(len(body))},
136
                    body)
137
            conn.sendall(response)
138
            return
139

140
        # 处理 POST 请求（简单示例）
141
        if method == 'POST':
142
            # 这里只是演示，返回收到的数据
143
            response_body = f"<html><body><h1>POST Received</h1><p>Path: {path}</p><p>Body length: {len(body)}</p></body></html>".encode()
144
            response = build_response(200, "OK",
145
                {"Content-Type": "text/html", "Content-Length": str(len(response_body))},
146
                response_body)
147
            conn.sendall(response)
148
            return
149

150
        # 不支持的方法
151
        body = b'<html><body><h1>501 Not Implemented</h1></body></html>'
152
        response = build_response(501, "Not Implemented",
153
            {"Content-Type": "text/html", "Content-Length": str(len(body))},
154
            body)
155
        conn.sendall(response)
156

157
    except Exception as e:
158
        print(f"Error handling connection: {e}")
159
    finally:
160
        conn.close()
161

162
def main():
163
    os.makedirs(WWW, exist_ok=True)
164

165
    # 创建测试文件
166
    idx = os.path.join(WWW, 'index.html')
167
    if not os.path.exists(idx):
168
        with open(idx, 'w') as f:
169
            f.write('<!DOCTYPE html>\n<html>\n<head><title>HTTP/1.0 Demo</title></head>\n'
170
                    '<body>\n<h1>HTTP/1.0 Demo Server</h1>\n'
171
                    '<p>This is a simple HTTP/1.0 server for learning.</p>\n'
172
                    '<ul>\n<li><a href="/page1.html">Page 1</a></li>\n'
173
                    '<li><a href="/data.json">JSON Data</a></li>\n</ul>\n</body>\n</html>')
174

175
    page1 = os.path.join(WWW, 'page1.html')
176
    if not os.path.exists(page1):
177
        with open(page1, 'w') as f:
178
            f.write('<!DOCTYPE html>\n<html>\n<head><title>Page 1</title></head>\n'
179
                    '<body>\n<h1>Page 1</h1>\n<p><a href="/">Back to index</a></p>\n</body>\n</html>')
180

181
    json_file = os.path.join(WWW, 'data.json')
182
    if not os.path.exists(json_file):
183
        with open(json_file, 'w') as f:
184
            f.write('{"name": "HTTP/1.0 Demo", "version": "1.0", "items": ["a", "b", "c"]}')
185

186
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
187
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
188
    s.bind((HOST, PORT))
189
    s.listen(5)
190
    print(f"HTTP/1.0 server listening on {HOST}:{PORT}")
191
    print(f"Serving files from: {os.path.abspath(WWW)}")
192

193
    try:
194
        while True:
195
            conn, addr = s.accept()
196
            threading.Thread(target=handle_conn, args=(conn, addr), daemon=True).start()
197
    except KeyboardInterrupt:
198
        print("\nShutting down.")
199
    finally:
200
        s.close()
201

202
if __name__ == '__main__':
203
    main()

get_mime_type 是一个简单的 MIME 类型映射表。实际生产环境应该用 mimetypes 标准库模块，但手动实现有助于理解原理。handle_conn 是请求处理的主逻辑：解析请求后根据方法类型分发处理，HEAD 只返回头部，GET 返回完整内容，POST 演示如何接收请求体。每个响应都包含 Content-Type 和 Content-Length，这正是 HTTP/1.0 相比 0.9 的关键进步。

三、实验二：用 nc 观察请求/响应的完整格式#

启动服务器后，用 nc（netcat）来手动发送 HTTP/1.0 请求，观察完整的协议格式。

实验 2.1：GET 请求获取 HTML 页面

1
printf 'GET /index.html HTTP/1.0\r\nHost: localhost:8080\r\n\r\n' | nc localhost 8080

你会看到类似这样的输出：

1
HTTP/1.0 200 OK
2
Content-Type: text/html
3
Content-Length: 268
4

5
<!DOCTYPE html>
6
<html>
7
<head><title>HTTP/1.0 Demo</title></head>
8
<body>
9
<h1>HTTP/1.0 Demo Server</h1>
10
<p>This is a simple HTTP/1.0 server for learning.</p>
11
<ul>
12
<li><a href="/page1.html">Page 1</a></li>
13
<li><a href="/data.json">JSON Data</a></li>
14
</ul>
15
</body>
16
</html>

注意观察：响应的第一行是状态行 HTTP/1.0 200 OK，接着是两个响应头 Content-Type 和 Content-Length，然后是一个空行，最后是 HTML 内容。

实验 2.2：GET 请求获取 JSON 文件

1
printf 'GET /data.json HTTP/1.0\r\nHost: localhost:8080\r\nAccept: application/json\r\n\r\n' | nc localhost 8080

输出：

1
HTTP/1.0 200 OK
2
Content-Type: application/json
3
Content-Length: 69
4

5
{"name": "HTTP/1.0 Demo", "version": "1.0", "items": ["a", "b", "c"]}

这里的 Content-Type 是 application/json，浏览器看到这个头就会按照 JSON 格式处理内容。

实验 2.3：HEAD 请求（只获取响应头）

1
printf 'HEAD /index.html HTTP/1.0\r\nHost: localhost:8080\r\n\r\n' | nc localhost 8080

输出：

1
HTTP/1.0 200 OK
2
Content-Type: text/html
3
Content-Length: 268

HEAD 请求的响应只有状态行和响应头，没有响应体。注意 Content-Length 仍然标注了资源的大小，方便客户端判断是否需要获取完整内容。这在检查文件是否存在、获取文件大小、验证缓存是否有效时非常有用。

实验 2.4：POST 请求（发送数据）

1
printf 'POST /submit HTTP/1.0\r\nHost: localhost:8080\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 19\r\n\r\nname=test&value=123' | nc localhost 8080

输出：

1
HTTP/1.0 200 OK
2
Content-Type: text/html
3
Content-Length: 90
4

5
<html><body><h1>POST Received</h1><p>Path: /submit</p><p>Body length: 19</p></body></html>

POST 请求需要在请求头中指定 Content-Type 和 Content-Length，请求体跟在空行后面。我们的演示服务器会返回收到的数据信息。

实验 2.5：404 错误

1
printf 'GET /nonexistent.html HTTP/1.0\r\nHost: localhost:8080\r\n\r\n' | nc localhost 8080

输出：

1
HTTP/1.0 404 Not Found
2
Content-Type: text/html
3
Content-Length: 92
4

5
<html><body><h1>404 Not Found</h1><p>The requested resource was not found.</p></body></html>

状态码 404 明确告诉客户端资源不存在，客户端程序可以根据这个状态码自动处理错误情况，而不用依赖解析 HTML 内容来判断。

对比 0.9 的 nc 输出，这里你能看到三个关键变化：状态行 HTTP/1.0 200 OK 明确告诉客户端请求成功；Content-Type: text/html 让浏览器知道这是 HTML 而不是图片或 JSON；Content-Length: 268 让客户端知道响应有多少字节，不用等连接关闭才判断结束。这些在 0.9 里都不存在。

实验 2.6：用 curl 验证

现代的 curl 默认使用 HTTP/1.1，但可以通过参数指定 HTTP/1.0：

1
# GET 请求
2
curl --http1.0 http://localhost:8080/index.html
3

4
# HEAD 请求
5
curl --http1.0 -I http://localhost:8080/index.html
6

7
# POST 请求
8
curl --http1.0 -X POST -d "name=test" http://localhost:8080/submit

curl -I（或 curl --head）会发送 HEAD 请求并只显示响应头。

实验 2.7：用 tcpdump 观察网络包

在另一个终端运行 tcpdump，观察完整的 HTTP 请求和响应：

1
sudo tcpdump -A -s 0 'tcp port 8080'

然后在第一个终端发送请求。你会清晰地看到请求和响应的完整格式：请求行/状态行、请求头/响应头、空行、请求体/响应体。这对于理解 HTTP 协议的工作原理非常有帮助。

四、局限性：每次请求重新建立 TCP 连接#

HTTP/1.0 虽然相比 0.9 有了巨大进步，但它仍然有一个严重的性能问题：每个请求都需要建立新的 TCP 连接。

在 HTTP/1.0 中，默认的行为是 Connection: close。这意味着：

客户端建立 TCP 连接（三次握手）

发送 HTTP 请求

接收 HTTP 响应

服务器关闭连接

如果需要请求另一个资源，重复步骤 1-4

想象一下，一个网页有 10 张图片、3 个 CSS 文件、2 个 JavaScript 文件。加载这个页面需要建立 16 次 TCP 连接！每次 TCP 连接都需要三次握手，这增加了显著的延迟。

你可以用 time 命令来观察这个行为：

1
# 连续请求两个资源
2
time (printf 'GET /index.html HTTP/1.0\r\n\r\n' | nc localhost 8080 > /dev/null && \
3
      printf 'GET /data.json HTTP/1.0\r\n\r\n' | nc localhost 8080 > /dev/null)

你会发现每次请求都是独立的 TCP 连接。

HTTP/1.0 有一个非标准的扩展 Connection: keep-alive，允许复用 TCP 连接。但这是可选的，不同实现之间可能不兼容。这个问题直到 HTTP/1.1 才真正解决，HTTP/1.1 默认使用持久连接（persistent connection），一个 TCP 连接可以发送多个请求。

五、HTTP/1.0 特性速查表#

5.1 影响评估矩阵#

特性	解决了什么	没有它会怎样	常见误区
请求头/响应头	客户端和服务器可以传递元信息	浏览器猜 MIME 类型，无法缓存	以为头部只是”附加信息”，其实是协议协商的基础
状态码	程序可以自动判断请求结果	只能靠人眼阅读响应内容区分成功和失败	404 是状态码不是页面内容，很多人混淆
Content-Type	浏览器正确处理各类文件	收到二进制字节只能猜类型	以为文件扩展名就够了，但 HTTP 传输不看扩展名
Content-Length	无需等连接关闭即可判断结束	无法复用连接，性能差	和”文件大小”是两回事，动态内容可以没有
POST 方法	支持提交数据，Web 应用成为可能	只有 GET，无法提交表单	POST 不是”更安全的 GET”，语义完全不同
HEAD 方法	只获取元信息，节省带宽	检查资源必须下载完整内容	HEAD 响应的 Content-Length 是 GET 时的值，不是 0

详细参考数据

5.2 HTTP/1.0 新增的核心请求头#

请求头	用途	示例
`User-Agent`	标识客户端类型	`User-Agent: Mozilla/5.0`
`Accept`	声明可接受的 MIME 类型	`Accept: text/html, application/json`
`Accept-Language`	声明偏好的自然语言	`Accept-Language: zh-CN, en`
`Accept-Encoding`	声明支持的压缩算法	`Accept-Encoding: gzip`
`Content-Type`	请求体的 MIME 类型	`Content-Type: application/x-www-form-urlencoded`
`Content-Length`	请求体的字节长度	`Content-Length: 42`
`Authorization`	身份验证凭证	`Authorization: Basic xxx`
`If-Modified-Since`	条件请求（缓存验证）	`If-Modified-Since: Wed, 20 Mar 2026 10:00:00 GMT`

5.3 HTTP/1.0 新增的核心响应头#

响应头	用途	示例
`Content-Length`	响应体的字节长度	`Content-Length: 1234`
`Server`	服务器软件标识	`Server: Apache/2.4`
`Location`	重定向目标 URL	`Location: https://example.com/new`
`WWW-Authenticate`	身份验证要求	`WWW-Authenticate: Basic realm="Admin"`
`Expires`	缓存过期时间	`Expires: Thu, 01 Dec 2026 16:00:00 GMT`
`Last-Modified`	资源最后修改时间	`Last-Modified: Wed, 20 Mar 2026 10:00:00 GMT`

5.4 HTTP/1.0 状态码速查#

类别	状态码	含义	典型场景
	201	Created	POST 请求成功创建资源
	204	No Content	成功但无返回内容（如 DELETE）
3xx 重定向	301	Moved Permanently	资源永久移动到新 URL
	302	Found	资源临时移动到新 URL
	304	Not Modified	缓存有效，无需重新传输
4xx 客户端错误	400	Bad Request	请求格式错误
	401	Unauthorized	需要身份验证
	403	Forbidden	拒绝访问
	404	Not Found	资源不存在
5xx 服务器错误	500	Internal Server Error	服务器内部错误
	501	Not Implemented	不支持该请求方法
	503	Service Unavailable	服务暂时不可用

5.5 HTTP/1.0 vs HTTP/1.1 关键差异预览#

特性	HTTP/1.0	HTTP/1.1
Host 头	可选	必须
分块传输	不支持	`Transfer-Encoding: chunked`
管道化	不支持	支持（但实际部署较少）
缓存控制	`Expires` 等简单机制	`ETag`、`Cache-Control` 等增强机制
方法支持	GET, POST, HEAD	新增 PUT, DELETE, OPTIONS, TRACE, CONNECT

这些差异正是下一篇 HTTP/1.1 的核心内容。

参考资料#

RFC 1945 - HTTP/1.0 协议规范