1
#!/usr/bin/env python3
2
# http2_client.py -- HTTP/2 client for learning
3
import asyncio
4
import httpx
5

6
async def test_http2():
7
    # httpx 支持 HTTP/2，需要安装 httpx[http2]
8
    async with httpx.AsyncClient(http2=True) as client:
9
        # 发送请求到一个支持 HTTP/2 的服务器
10
        response = await client.get("https://nghttp2.org")
11

12
        print(f"HTTP Version: {response.http_version}")
13
        print(f"Status: {response.status_code}")
14
        print(f"Headers: {dict(response.headers)}")
15
        print(f"Content length: {len(response.content)} bytes")
16

17
        # 发送多个并发请求（多路复用）
18
        urls = [
19
            "https://nghttp2.org/httpbin/get",
20
            "https://nghttp2.org/httpbin/headers",
21
            "https://nghttp2.org/httpbin/ip",
22
        ]
23

24
        tasks = [client.get(url) for url in urls]
25
        responses = await asyncio.gather(*tasks)
26

27
        print("\n=== Multiplexed requests ===")
28
        for i, resp in enumerate(responses):
29
            print(f"Request {i+1}: {resp.status_code} ({len(resp.content)} bytes)")
30

31
if __name__ == "__main__":
32
    asyncio.run(test_http2())

1
pip install "httpx[http2]"
2
python http2_client.py

1
#!/usr/bin/env python3
2
# http_comparison.py -- Compare HTTP/1.1 vs HTTP/2 performance
3
import asyncio
4
import time
5
import httpx
6

7
# 测试目标：一个包含多个资源请求的页面
8
BASE_URL = "https://nghttp2.org"
9
# 使用 20 个并发请求，才能体现多路复用的优势
10
# 5 个请求时 HTTP/1.1 和 HTTP/2 差异不大，因为连接开销占比低
11
RESOURCES = [
12
    "/httpbin/get",
13
    "/httpbin/headers",
14
    "/httpbin/ip",
15
    "/httpbin/user-agent",
16
    "/httpbin/cache",
17
    "/httpbin/cookies",
18
    "/httpbin/response-headers",
19
    "/httpbin/anything",
20
    "/httpbin/delay/0",
21
    "/httpbin/delay/0",
22
    "/httpbin/get",
23
    "/httpbin/headers",
24
    "/httpbin/ip",
25
    "/httpbin/user-agent",
26
    "/httpbin/cache",
27
    "/httpbin/cookies",
28
    "/httpbin/response-headers",
29
    "/httpbin/anything",
30
    "/httpbin/delay/0",
31
    "/httpbin/delay/0",
32
]
33

34
async def load_with_http_version(http2: bool, concurrency: int = 20):
35
    """使用指定 HTTP 版本加载资源"""
36
    version = "HTTP/2" if http2 else "HTTP/1.1"
37
    print(f"\n=== Testing with {version} ===")
38

39
    async with httpx.AsyncClient(http2=http2) as client:
40
        start = time.perf_counter()
41

42
        # 并发请求所有资源
43
        tasks = [client.get(f"{BASE_URL}{path}") for path in RESOURCES[:concurrency]]
44
        responses = await asyncio.gather(*tasks)
45

46
        end = time.perf_counter()
47

48
        total_bytes = sum(len(r.content) for r in responses)
49

50
        print(f"  Resources: {len(responses)}")
51
        print(f"  Total bytes: {total_bytes}")
52
        print(f"  Time: {(end - start) * 1000:.2f} ms")
53
        print(f"  All successful: {all(r.status_code == 200 for r in responses)}")
54

55
        return end - start
56

57
async def main():
58
    print("=== HTTP/1.1 vs HTTP/2 Performance Comparison ===")
59
    print(f"Target: {BASE_URL}")
60
    print(f"Resources per test: {len(RESOURCES)}")
61

62
    # 运行多次取平均
63
    runs = 3
64
    http1_times = []
65
    http2_times = []
66

67
    for i in range(runs):
68
        print(f"\n--- Run {i + 1}/{runs} ---")
69
        http1_times.append(await load_with_http_version(http2=False))
70
        http2_times.append(await load_with_http_version(http2=True))
71
        await asyncio.sleep(0.5)  # 冷却
72

73
    avg_http1 = sum(http1_times) / len(http1_times) * 1000
74
    avg_http2 = sum(http2_times) / len(http2_times) * 1000
75

76
    print("\n" + "=" * 50)
77
    print("RESULTS SUMMARY")
78
    print("=" * 50)
79
    print(f"HTTP/1.1 average: {avg_http1:.2f} ms")
80
    print(f"HTTP/2   average: {avg_http2:.2f} ms")
81
    print(f"Speedup: {avg_http1 / avg_http2:.2f}x")
82
    print("=" * 50)
83

84
if __name__ == "__main__":
85
    asyncio.run(main())

1
#!/usr/bin/env python3
2
# http_comparison_v2.py -- Compare HTTP/1.1 vs HTTP/2 in two scenarios
3
import asyncio
4
import time
5
import httpx
6

7
BASE_URL = "https://nghttp2.org"
8

9
# 场景 A：50 个小文件请求
10
RESOURCES_A = ["/httpbin/get"] * 50
11

12
# 场景 B：1 个大文件请求
13
RESOURCES_B = ["/httpbin/image/png"]
14

15

16
async def load_with_http_version(http2: bool, resources: list[str], label: str):
17
    """使用指定 HTTP 版本加载资源"""
18
    version = "HTTP/2" if http2 else "HTTP/1.1"
19
    print(f"\n=== {label} | {version} ===")
20

21
    async with httpx.AsyncClient(http2=http2) as client:
22
        start = time.perf_counter()
23

24
        tasks = [client.get(f"{BASE_URL}{path}") for path in resources]
25
        responses = await asyncio.gather(*tasks)
26

27
        end = time.perf_counter()
28

29
        total_bytes = sum(len(r.content) for r in responses)
30

31
        print(f"  Resources: {len(responses)}")
32
        print(f"  Total bytes: {total_bytes}")
33
        print(f"  Time: {(end - start) * 1000:.2f} ms")
34
        print(f"  All successful: {all(r.status_code == 200 for r in responses)}")
35

36
        return end - start
37

38

39
async def main():
40
    print("=== HTTP/1.1 vs HTTP/2: Two Scenarios ===")
41
    print(f"Target: {BASE_URL}")
42

43
    runs = 3
44

45
    # 场景 A：50 个小文件
46
    print("\n" + "=" * 50)
47
    print("SCENARIO A: 50 small file requests")
48
    print("=" * 50)
49
    a_http1_times = []
50
    a_http2_times = []
51
    for i in range(runs):
52
        print(f"\n--- Run {i + 1}/{runs} ---")
53
        a_http1_times.append(await load_with_http_version(False, RESOURCES_A, "A"))
54
        a_http2_times.append(await load_with_http_version(True, RESOURCES_A, "A"))
55
        await asyncio.sleep(0.5)
56

57
    avg_a_http1 = sum(a_http1_times) / len(a_http1_times) * 1000
58
    avg_a_http2 = sum(a_http2_times) / len(a_http2_times) * 1000
59

60
    # 场景 B：1 个大文件
61
    print("\n" + "=" * 50)
62
    print("SCENARIO B: 1 large file request")
63
    print("=" * 50)
64
    b_http1_times = []
65
    b_http2_times = []
66
    for i in range(runs):
67
        print(f"\n--- Run {i + 1}/{runs} ---")
68
        b_http1_times.append(await load_with_http_version(False, RESOURCES_B, "B"))
69
        b_http2_times.append(await load_with_http_version(True, RESOURCES_B, "B"))
70
        await asyncio.sleep(0.5)
71

72
    avg_b_http1 = sum(b_http1_times) / len(b_http1_times) * 1000
73
    avg_b_http2 = sum(b_http2_times) / len(b_http2_times) * 1000
74

75
    # 汇总
76
    print("\n" + "=" * 50)
77
    print("RESULTS SUMMARY")
78
    print("=" * 50)
79
    print(f"Scenario A (50 small files):")
80
    print(f"  HTTP/1.1 average: {avg_a_http1:.2f} ms")
81
    print(f"  HTTP/2   average: {avg_a_http2:.2f} ms")
82
    print(f"  Speedup: {avg_a_http1 / avg_a_http2:.2f}x")
83
    print(f"\nScenario B (1 large file):")
84
    print(f"  HTTP/1.1 average: {avg_b_http1:.2f} ms")
85
    print(f"  HTTP/2   average: {avg_b_http2:.2f} ms")
86
    print(f"  Speedup: {avg_b_http1 / avg_b_http2:.2f}x")
87
    print("=" * 50)
88

89
if __name__ == "__main__":
90
    asyncio.run(main())

1
pip install hpack

1
#!/usr/bin/env python3
2
# hpack_demo.py -- Demonstrate real HPACK compression
3
import hpack
4

5
# 第一次请求：所有头部都需要编码
6
encoder = hpack.Encoder()
7
headers1 = [
8
    (':method', 'GET'),
9
    (':path', '/index.html'),
10
    (':scheme', 'https'),
11
    (':authority', 'example.com'),
12
    ('user-agent', 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'),
13
    ('accept', 'text/html,application/xhtml+xml'),
14
    ('accept-encoding', 'gzip, deflate, br'),
15
    ('accept-language', 'zh-CN,zh;q=0.9,en;q=0.8'),
16
]
17

18
# 计算等价的 HTTP/1.1 头部大小
19
http1_size = sum(len(k) + len(v) + 4 for k, v in headers1)  # ": " + "\r\n"
20
encoded1 = encoder.encode(headers1)
21
print(f"=== 第一次请求 ===")
22
print(f"HTTP/1.1 头部大小: {http1_size} bytes")
23
print(f"HPACK 编码后:     {len(encoded1)} bytes")
24
print(f"压缩率:           {http1_size / len(encoded1):.1f}x")
25

26
# 第二次请求：动态表已有之前的头部
27
headers2 = [
28
    (':method', 'GET'),
29
    (':path', '/style.css'),
30
    (':scheme', 'https'),
31
    (':authority', 'example.com'),
32
    ('user-agent', 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'),
33
    ('accept', 'text/css'),
34
    ('accept-encoding', 'gzip, deflate, br'),
35
    ('accept-language', 'zh-CN,zh;q=0.9,en;q=0.8'),
36
]
37

38
http1_size2 = sum(len(k) + len(v) + 4 for k, v in headers2)
39
encoded2 = encoder.encode(headers2)
40
print(f"\n=== 第二次请求（动态表已有条目）===")
41
print(f"HTTP/1.1 头部大小: {http1_size2} bytes")
42
print(f"HPACK 编码后:     {len(encoded2)} bytes")
43
print(f"压缩率:           {http1_size2 / len(encoded2):.1f}x")
44
print(f"\n第二次请求的压缩率显著提高，因为动态表已经缓存了 user-agent、accept-encoding 等重复头部。")