编码与解码：软件系统是如何实现的

本文最后更新于 2025年9月10日 下午

数据是如何被组织、传输和执行的

数据的底层表示

在计算机系统中，所有信息最终都以二进制形式存储在内存中。当我们从硬盘加载数据到内存时，看到的是这样的二进制序列：

1
2
3
4
5
6
11100110 10011100 10001011
11100101 10001111 10001011
11100100 10111101 10100000
11100101 10100101 10111101
00000000

为了便于理解和处理，我们通常用16进制来表示这些数据：

1
2
E6 9C 8B E5 8F 8B E4 BD A0 E5 A5 BD 00

这段数据遵循Unicode UTF-8编码规范。在UTF-8中，中文字符通常占用3个字节（注意：UTF-8是变长编码，不同字符占用的字节数可能不同），数据以00作为字符串结束标志。

下面用C语言演示如何将16进制数据转换为可读字符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>

int main() {
    // 基于 UTF-8 解码 E6 9C 8B E5 8F 8B E4 BD A0 E5 A5 BD 00
    unsigned char utf8_peng[] = { 0xE6, 0x9C, 0x8B, 0};  // 朋
    unsigned char utf8_you[] = { 0xE5, 0x8F, 0x8B, 0} ;  // 友
    unsigned char utf8_ni[] = { 0xE4, 0xBD, 0xA0, 0};    // 你
    unsigned char utf8_hao[] = { 0xE5, 0xA5, 0xBD, 0};   // 好
    unsigned char* utf8_string[] = {utf8_peng, utf8_you, utf8_ni, utf8_hao};

    int len = sizeof(utf8_string)/sizeof(utf8_string[0]);
    for (int i = 0; i < len; i++){
        printf("%s", utf8_string[i]);
    }
    printf("\\n");

    return 0;
}

/* 输出结果：
   朋友你好
*/

同样，我们也可以将字符转换回二进制编码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

int main() {
    const unsigned char* ch = (const unsigned char*)"朋友你好";

    for (int i = 0; ch[i] != '\\0'; i++) {
        for (int b = 7; b >= 0; b--) {
            printf("%d", (ch[i] >> b) & 1);
        }
        printf(" ");
    }
    printf("\\n");
    return 0;
}

/* 输出结果：
   11100110 10011100 10001011 11100101 10001111 10001011 11100100 10111101 10100000 11100101 10100101 10111101
*/

通过这个过程，我们可以清楚地看到编解码的本质：

1
人类可读字符 ←→ 编码规则 ←→ 机器可读数据

这个转换过程是双向的：

  • 编码 ：将人类可理解的符号转换为机器可处理的数据
  • 解码 ：将机器数据按照特定规则还原为人类可理解的信息

需要注意的是，数据的组织形式并不一定要保持字符形式。在无需人类直接参与的系统内部处理中，通常采用更高效的存储形式（如字节码、机器码）来提升性能。

编程语言的内存管理与执行模型

C语言：直接的系统映射

C/C++直接使用系统的内存栈结构。经过预处理→编译→汇编→链接→装载的完整流程后，程序在内存中的布局如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌─────────────────┐
│    内核空间      │
├─────────────────┤
│    用户空间      │
│  ┌─────────────┐│
│  │   栈空间     ││ ← 函数调用、局部变量、参数传递
│  ├─────────────┤│
│  │   堆空间     ││ ← 动态内存分配(malloc/free)
│  ├─────────────┤│
│  │   .BSS段    ││ ← 未初始化或零初始化的全局变量
│  ├─────────────┤│
│  │   数据段     ││ ← 已初始化的全局变量和字符串常量
│  ├─────────────┤│
│  │   代码段     ││ ← 编译后的机器码指令
│  └─────────────┘│
└─────────────────┘

在C语言中，所有数据都以机器码形式存储，可以直接被CPU处理。程序执行遵循”加载→解释→执行”的基本模式，没有中间抽象层的开销。

Java语言：虚拟机抽象层

Java引入了虚拟机(JVM)作为应用程序与操作系统之间的抽象层，其内存结构与C语言的映射关系如下：

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
C++内存结构                    Java内存结构(JVM视角)
┌─────────────────┐          ┌─────────────────────────┐
│    内核空间      │         │                         │
├─────────────────┤          │                        │
│    用户空间      │         │    JVM进程空间          │
│  ┌─────────────┐│          │  ┌─────────────────────┐│
│  │   栈空间     ││  ←→     │  │  Java虚拟机栈        ││
│  ├─────────────┤│          │  │  (栈帧/局部变量表)   ││
│  │   堆空间     ││  ←→     │  ├─────────────────────┤│
│  │             ││          │  │  Java堆             ││
│  │             ││          │  │  ┌─────────────────┐││
│  │             ││          │  │  │   新生代        │││
│  │             ││          │  │  │   (Eden/S0/S1)  │││
│  │             ││          │  │  ├─────────────────┤││
│  │             ││          │  │  │   老年代        │││
│  │             ││          │  │  └─────────────────┘││
│  │             ││          │  ├─────────────────────┤│
│  │             ││          │  │  元空间(Metaspace)  ││
│  │             ││          │  │  (类元数据/常量池)  ││
│  ├─────────────┤│          │  ├─────────────────────┤│
│  │   代码段     ││  ←→     │  │  方法区             ││
│  │             ││          │  │  (字节码/JIT编译码) ││
│  └─────────────┘│          │  └─────────────────────┘│
└─────────────────┘          └─────────────────────────┘

Java的执行流程分为三个关键阶段：

1. 编译时

将 .java源文件编译为遵循严格结构规范的 .class字节码文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ClassFile {
    u4 magic;                        // 魔数(0xCAFEBABE)，校验文件格式
    u2 minor_version;                // 次版本号
    u2 major_version;                // 主版本号
    u2 constant_pool_count;          // 常量池条目数量
    cp_info constant_pool[...];      // 常量池(类、方法、字段引用)
    u2 access_flags;                 // 访问修饰符
    u2 this_class;                   // 当前类在常量池中的索引
    u2 super_class;                  // 父类在常量池中的索引
    u2 interfaces_count;             // 接口数量
    u2 interfaces[...];              // 接口索引数组
    u2 fields_count;                 // 字段数量
    field_info fields[...];          // 字段信息数组
    u2 methods_count;                // 方法数量
    method_info methods[...];        // 方法信息数组
    u2 attributes_count;             // 属性数量
    attribute_info attributes[...];   // 属性信息数组
}

2. 类加载时

JVM将 .class文件加载并解析为内部的 InstanceKlass结构：

  • 验证 ：检查字节码的合法性和安全性
  • 准备 ：为静态变量分配内存并设置默认值
  • 解析 ：将符号引用转换为直接引用

3. 运行时

  • 创建对象时，在堆中分配内存空间
  • 设置对象头(mark word)和类型指针
  • 根据类定义信息初始化实例字段
  • 执行构造方法完成对象创建

让我们通过一个具体示例来观察这个过程：

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
public class Demo {
    private int instanceVar = 42;
    public static final String CONST = "Hello";
    public static int counter = 0;

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.sayHi();
        Demo.sayBye();
        System.out.println(demo.instanceVar);
        System.out.println(Demo.CONST);
        System.out.println(Demo.counter);
    }

    public Demo() {
        instanceVar = 100;  // 覆盖字段初始化值
    }

    public void sayHi() {
        System.out.println("Hi");
    }

    public static void sayBye() {
        System.out.println("Bye");
    }

    static {
        counter = 123;  // 静态初始化块
    }
}

使用 javap -v Demo.class反编译后，可以看到详细的字节码结构，其中包含：

  • 常量池 ：存储字符串字面量、类引用、方法引用等
  • 字段信息 ：访问修饰符、类型描述符、初始值等
  • 方法信息 ：字节码指令序列、局部变量表、操作数栈等
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
  // javap -v Demo.java
  Last modified 2025年6月28日; size 855 bytes   // 文件系统获取的信息
  SHA-256 checksum 73545095324c4d5886edf3477a1e9d340a5e7d5eb940103f0e261063158e44f7  
  Compiled from "Demo.java"
public class Demo                         // 类名
  minor version: 0               
  major version: 65
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER   // 访问控制符
  this_class: #1                          // Demo 对常量池中的索引映射
  super_class: #38                        // java/lang/Object  父类Object
  interfaces: 0, fields: 3, methods: 5, attributes: 1  //接口/属性/方法/元信息统计
Constant pool:
   #1 = Class              #2             // Demo
   #2 = Utf8               Demo
   #3 = Methodref          #1.#4          // Demo."<init>":()V  ()V 即需要被执行的代码
   #4 = NameAndType        #5:#6          // "<init>":()V
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Methodref          #1.#8          // Demo.sayHi:()V
   #8 = NameAndType        #9:#6          // sayHi:()V
   #9 = Utf8               sayHi
  #10 = Methodref          #1.#11         // Demo.sayBye:()V
  #11 = NameAndType        #12:#6         // sayBye:()V
  #12 = Utf8               sayBye
  #13 = Fieldref           #14.#15        // java/lang/System.out:Ljava/io/PrintStream;
  #14 = Class              #16            // java/lang/System
  #15 = NameAndType        #17:#18        // out:Ljava/io/PrintStream;
  #16 = Utf8               java/lang/System
  #17 = Utf8               out
  #18 = Utf8               Ljava/io/PrintStream;
  #19 = Fieldref           #1.#20         // Demo.instanceVar:I
  #20 = NameAndType        #21:#22        // instanceVar:I
  #21 = Utf8               instanceVar
  #22 = Utf8               I
  #23 = Methodref          #24.#25        // java/io/PrintStream.println:(I)V
  #24 = Class              #26            // java/io/PrintStream
  #25 = NameAndType        #27:#28        // println:(I)V
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (I)V
  #29 = String             #30            // Hello
  #30 = Utf8               Hello
  #31 = Methodref          #24.#32        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #32 = NameAndType        #27:#33        // println:(Ljava/lang/String;)V
  #33 = Utf8               (Ljava/lang/String;)V
  #34 = Fieldref           #1.#35         // Demo.counter:I
  #35 = NameAndType        #36:#22        // counter:I
  #36 = Utf8               counter
  #37 = Methodref          #38.#4         // java/lang/Object."<init>":()V
  #38 = Class              #39            // java/lang/Object
  #39 = Utf8               java/lang/Object
  #40 = String             #41            // Hi
  #41 = Utf8               Hi
  #42 = String             #43            // Bye
  #43 = Utf8               Bye
  #44 = Utf8               CONST
  #45 = Utf8               Ljava/lang/String;
  #46 = Utf8               ConstantValue
  #47 = Utf8               main
  #48 = Utf8               ([Ljava/lang/String;)V
  #49 = Utf8               Code
  #50 = Utf8               LineNumberTable
  #51 = Utf8               <clinit>
  #52 = Utf8               SourceFile
  #53 = Utf8               Demo.java
{
  public static final java.lang.String CONST;
    descriptor: Ljava/lang/String;
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    ConstantValue: String Hello

  public static int counter;
    descriptor: I
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #1                  // class Demo
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: invokevirtual #7                  // Method sayHi:()V
        12: invokestatic  #10                 // Method sayBye:()V
        15: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
        18: aload_1
        19: getfield      #19                 // Field instanceVar:I
        22: invokevirtual #23                 // Method java/io/PrintStream.println:(I)V
        25: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
        28: ldc           #29                 // String Hello
        30: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        33: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
        36: getstatic     #34                 // Field counter:I
        39: invokevirtual #23                 // Method java/io/PrintStream.println:(I)V
        42: return
      LineNumberTable:
        line 7: 0
        line 8: 8
        line 9: 12
        line 10: 15
        line 11: 25
        line 12: 33
        line 13: 42

  public Demo();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #37                 // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        42
         7: putfield      #19                 // Field instanceVar:I
        10: aload_0
        11: bipush        100
        13: putfield      #19                 // Field instanceVar:I
        16: return
      LineNumberTable:
        line 15: 0
        line 2: 4
        line 16: 10
        line 17: 16

  public void sayHi();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #40                 // String Hi
         5: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 20: 0
        line 21: 8

  public static void sayBye();
    descriptor: ()V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #42                 // String Bye
         5: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 24: 0
        line 25: 8

  static {};
    descriptor: ()V
    flags: (0x0008) ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_0
         1: putstatic     #34                 // Field counter:I
         4: bipush        123
         6: putstatic     #34                 // Field counter:I
         9: return
      LineNumberTable:
        line 4: 0
        line 28: 4
        line 29: 9
}
SourceFile: "Demo.java"

方法执行过程 ：

  1. JVM从 main方法开始执行字节码指令流
  2. 遇到方法调用指令时，解析常量池中的符号引用
  3. 为目标方法创建新的栈帧(包含局部变量表、操作数栈)
  4. 逐条执行字节码指令：
    • 加载参数和局部变量到操作数栈
    • 执行运算并管理栈中的中间结果
    • 调用其他方法或访问字段
  5. 热点代码通过JIT编译器优化为本地机器码
  6. 方法结束时栈帧出栈，返回值传递给调用者

Python语言：动态对象系统

Python(以CPython实现为例)采用了更加灵活的动态对象系统：

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
C内存结构                     Python内存结构(CPython)
┌─────────────────┐          ┌──────────────────────────┐
│    内核空间      │          │                          │
├─────────────────┤          │                          │
│    用户空间      │          │    CPython进程空间        │
│  ┌─────────────┐│          │  ┌──────────────────────┐│
│  │   栈空间     ││  ←→     │  │  Python调用栈         ││
│  ├─────────────┤│          │  │  (栈帧/局部命名空间)  ││
│  │   堆空间     ││  ←→     │  ├──────────────────────┤│
│  │             ││          │  │  Python对象堆         ││
│  │             ││          │  │  ┌──────────────────┐││
│  │             ││          │  │  │ 小对象池          │││
│  │             ││          │  │  │ (Arena→Pool→Block)│││
│  │             ││          │  │  ├──────────────────┤││
│  │             ││          │  │  │ 大对象区          │││
│  │             ││          │  │  │ (直接malloc)     │││
│  │             ││          │  │  ├──────────────────┤││
│  │             ││          │  │  │ 缓存区            │││
│  │             ││          │  │  │ (整数/字符串)     │││
│  │             ││          │  │  └──────────────────┘││
│  ├─────────────┤│          │  ├──────────────────────┤│
│  │   代码段     ││  ←→     │  │  字节码区            ││
│  │             ││          │  │  (PyCodeObject)      ││
│  └─────────────┘│          │  └──────────────────────┘│
└─────────────────┘          └──────────────────────────┘

Python的对象模型

CPython中所有数据结构都继承自 PyObject基类，包含引用计数和类型信息。内存管理采用分层策略：

  • 小对象 (≤512字节)：使用Arena(256KB)→Pool(4KB)→Block的层次结构
  • 大对象 (>512字节)：直接使用系统malloc分配
  • 缓存机制 ：小整数(-5到256)、单字符、短字符串等常用对象被缓存复用

Python的执行流程

  1. 编译阶段 ：源代码编译为字节码(可选择保存为.pyc文件)
  2. 加载阶段 ：
  • 常量对象(数字、字符串)加载到对应缓存区或堆区
  • 代码对象封装为 PyCodeObject
  • 根据类型进一步封装为 PyFunctionObject、PyTypeObject等
  1. 执行阶段 ：
  • 建立命名空间和作用域链
  • Python解释器逐条执行字节码指令
  • 通过switch语句分派到对应的C函数实现

以一个简单的类定义为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class People:
    description = 'this is a description'  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

# 类加载后，description成为类命名空间的一部分
print(dir(People))  # 可以看到'description'在列表中
print(People.description)  # 直接访问类属性

# 实例化后，name被添加到实例的命名空间
wang = People('wang')
print(dir(wang))  # 可以看到既有'description'也有'name'
print(wang.name)  # 访问实例属性

属性访问的两个层次 ：

  1. Python层 ：建立变量名与对象的映射关系，管理命名空间
  2. C层 ：通过 PyObject结构体查询具体的数据内容

方法调用的两种模式 ：

  1. 内建方法 ：直接调用C函数指针(tp_call)
  2. Python方法 ：解释器解析字节码，通过switch分派执行

网络协议：分布式系统的编解码

在前面的章节中，我们讨论了单机环境下的”数据→编码→执行”过程。网络协议将这个概念扩展到分布式环境，实现跨主机的数据交换和协同处理。

协议的本质：多端协同编解码

网络协议本质上是一套 分布式编解码规范 ，它定义了：

  • 发送端如何将应用数据编码为网络可传输的格式
  • 接收端如何解码网络数据并恢复为应用可理解的信息
  • 双方如何协调处理异常、流控、安全等问题

这个过程可以抽象为：

1
2
3
4
应用数据 → 协议编码 → 网络传输 → 协议解码 → 应用数据
   ↑                                           ↓
发送方应用 ←── 协议握手/协商 ──→ 接收方应用

分层协议栈：逐级编解码

现代网络协议采用分层设计，每一层都有自己的编码格式和处理逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
┌─────────────────┐  ┌──────────────────────────────────┐
│   应用层         │  │ HTTP: 文本/JSON/XML编码          │
├─────────────────┤  ├──────────────────────────────────┤
│   传输层         │  │ TCP: 序列号、确认号、窗口管理     │
├─────────────────┤  ├──────────────────────────────────┤
│   网络层         │  │ IP: 地址路由、分片重组           │
├─────────────────┤  ├──────────────────────────────────┤
│  数据链路层       │  │ Ethernet: MAC地址、帧校验        │
├─────────────────┤  ├──────────────────────────────────┤
│   物理层         │  │ 电信号/光信号: 模数转换          │
└─────────────────┘  └──────────────────────────────────┘

每层协议都会在数据前后添加自己的协议头部和 尾部 ，形成层层封装：

1
2
3
4
5
6
发送时(封装)：
应用数据 → [TCP头|应用数据] → [IP头|TCP头|应用数据] → [以太网头|IP头|TCP头|应用数据|以太网尾]

接收时(解封装)：
[以太网头|IP头|TCP头|应用数据|以太网尾] → [IP头|TCP头|应用数据] → [TCP头|应用数据] → 应用数据

HTTP协议：从文本到二进制的演进

让我们以HTTP协议为例，深入分析协议的编解码过程。

HTTP/1.1：基于文本的协议

HTTP/1.1使用纯文本格式，便于人类阅读和调试：

1
2
3
4
5
6
GET /api/user?id=123 HTTP/1.1
Host: api.example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
Accept: application/json
Connection: keep-alive

编码过程 ：

  1. 应用程序构造HTTP请求对象
  2. 将请求对象序列化为ASCII文本
  3. 通过TCP连接发送文本数据

解码过程 ：

  1. 服务器接收TCP数据流
  2. 按行解析HTTP文本协议
  3. 还原为HTTP请求对象供应用处理

HTTP/2：二进制帧协议

HTTP/2改用二进制格式，提升了解析效率和功能扩展性：

1
2
3
4
5
6
7
8
9
10
11
HTTP/2 Frame Format:
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                 Length (24)                   |   Type (8)    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|   Flags (8)   |R|                 Stream ID (31)             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                   Frame Payload (0...)                      ...
+---------------------------------------------------------------+

关键改进 ：

  • 二进制解析 ：比文本解析更高效、更不容易出错
  • 多路复用 ：单连接上并发处理多个请求/响应
  • 头部压缩 ：使用HPACK算法减少重复头部传输
  • 服务器推送 ：主动向客户端推送资源

TCP协议：可靠传输的实现

TCP作为传输层协议，负责在不可靠的IP网络上提供可靠的数据传输。

TCP报文段结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
TCP Header Format:
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          Source Port          |       Destination Port        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                        Sequence Number                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                    Acknowledgment Number                      |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  Data |           |U|A|P|R|S|F|                               |
| Offset| Reserved  |R|C|S|S|Y|I|            Window             |
|       |           |G|K|H|T|N|N|                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|           Checksum            |         Urgent Pointer        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                    Options                    |    Padding    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                             data                              |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

可靠性保证机制

1. 序列号与确认机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 发送方编码
struct tcp_segment {
    uint32_t seq_num;    // 当前数据的序列号
    uint32_t ack_num;    // 期望收到的下一个序列号
    uint8_t flags;       // ACK, SYN, FIN等控制标志
    // ... 其他字段
};

// 接收方解码并响应
if (received_seq == expected_seq) {
    send_ack(received_seq + data_length);
    expected_seq += data_length;
} else {
    // 乱序或丢失，重传最后正确的ACK
    send_ack(expected_seq);
}

2. 流量控制
通过窗口大小字段实现：

1
2
3
4
5
6
7
8
// 接收方通告可用缓冲区大小
tcp_header.window = available_buffer_size;

// 发送方根据窗口大小控制发送速度
if (bytes_in_flight < advertised_window) {
    send_more_data();
}

3. 拥塞控制
TCP使用多种算法避免网络拥塞：

  • 慢启动 ：指数增长发送窗口
  • 拥塞避免 ：线性增长发送窗口
  • 快速重传 ：收到3个重复ACK时立即重传
  • 快速恢复 ：避免慢启动的性能损失

现代协议的创新：QUIC/HTTP3

QUIC协议代表了网络协议设计的最新发展，它基于UDP构建，但提供了类似TCP的可靠性保证。

核心创新点

1. 连接迁移
传统TCP连接由四元组(源IP, 源端口, 目的IP, 目的端口)标识，网络切换时连接会断开。QUIC使用连接ID标识连接：

1
2
3
4
5
struct quic_connection_id {
    uint8_t length;          // 连接ID长度(0-20字节)
    uint8_t data[20];        // 连接ID数据
};

2. 0-RTT连接建立
QUIC将TLS握手集成到传输协议中，支持0往返时间连接建立：

1
2
3
4
5
6
7
8
9
10
11
12
传统TCP+TLS:
Client → Server: TCP SYN                    (1 RTT)
Client ← Server: TCP SYN-ACK
Client → Server: TCP ACK
Client → Server: TLS ClientHello           (2 RTT)
Client ← Server: TLS ServerHello + Certificate
Client → Server: TLS Finished
Client → Server: HTTP Request              (3 RTT)

QUIC:
Client → Server: QUIC Initial + ClientHello + HTTP Request (0 RTT, 如果有缓存的连接参数)

3. 流级别的多路复用
HTTP/2在TCP上实现多路复用，但TCP的队头阻塞问题依然存在。QUIC在传输层原生支持多流：

1
2
3
4
5
6
struct quic_stream {
    uint64_t stream_id;      // 流标识符
    uint8_t stream_type;     // 双向/单向，客户端/服务端发起
    // ... 流状态和数据
};

协议栈对比

1
2
3
4
5
6
7
8
9
10
11
12
13
传统协议栈              QUIC协议栈
┌─────────────┐        ┌─────────────┐
│   HTTP/2    │        │   HTTP/3    │
├─────────────┤        ├─────────────┤
│     TLS     │        │             │
├─────────────┤        │    QUIC     │
│     TCP     │        │             │
├─────────────┤        ├─────────────┤
│     IP      │        │     UDP     │
└─────────────┘        ├─────────────┤
                       │     IP      │
                       └─────────────┘

协议设计的核心原则

通过对各种网络协议的分析，我们可以总结出几个重要的设计原则：

1. 分层解耦

每层专注于解决特定问题，层间通过标准接口交互：

  • 物理层 ：信号传输
  • 数据链路层 ：点对点可靠传输
  • 网络层 ：端到端路由
  • 传输层 ：进程间通信
  • 应用层 ：业务逻辑

2. 向后兼容性

协议演进时必须考虑与旧版本的兼容：

1
2
3
4
5
6
7
8
9
// HTTP协议版本协商
if (supports_http3) {
    use_quic_connection();
} else if (supports_http2) {
    use_http2_over_tls();
} else {
    use_http1_1();
}

3. 性能与功能的权衡

  • 文本 vs 二进制 ：可读性 vs 解析效率
  • 可靠性 vs 实时性 ：TCP vs UDP的选择
  • 安全性 vs 性能 ：加密开销 vs 数据保护

4. 端到端原则

网络核心保持简单，复杂功能在端点实现：

1
2
3
4
5
6
简单转发 (路由器)     智能处理 (端主机)
      ↓                    ↓
   [路由器] ←→ [路由器] ←→ [主机]
      ↑                    ↑
  只做路由转发          实现所有协议逻辑

实际案例：HTTP请求的完整生命周期

让我们通过一个具体的HTTP请求来观察协议栈各层的编解码过程。

假设我们要访问 https://api.example.com/users/123：

第一阶段：DNS解析

1
2
3
4
5
6
7
8
9
10
11
12
应用层编码:
域名字符串: "api.example.com"
     ↓
DNS协议编码:
+-----+-----+-----+-----+-----+-----+
|  12 |  0  |  0  |  1  |  0  |  0  | DNS Header
+-----+-----+-----+-----+-----+-----+
| 3|a|p|i|7|e|x|a|m|p|l|e|3|c|o|m|0| Query Name
+-----+-----+-----+-----+-----+-----+
|  0  |  1  |  0  |  1  |           | Query Type/Class
+-----+-----+-----+-----+

第二阶段：TCP连接建立

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
应用请求: connect("api.example.com", 443)
     ↓
TCP三次握手编码:

1. SYN包:
TCP Header: [SRC_PORT|DST_PORT|SEQ=100|ACK=0|SYN=1|...]
IP Header:  [SRC_IP|DST_IP|TCP_PROTOCOL|...]
Ethernet:   [SRC_MAC|DST_MAC|IP_TYPE|...|CRC]

2. SYN-ACK包:
TCP Header: [DST_PORT|SRC_PORT|SEQ=200|ACK=101|SYN=1|ACK=1|...]

3. ACK包:
TCP Header: [SRC_PORT|DST_PORT|SEQ=101|ACK=201|ACK=1|...]

第三阶段：TLS握手

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
应用层: 发起HTTPS连接
     ↓
TLS编码过程:

1. ClientHello:
+--------+--------+--------+--------+
|   22   |  3  3  |   Length        | TLS Header
+--------+--------+--------+--------+
|   01   |      Length              | Handshake Header
+--------+--------+--------+--------+
|  3  3  |    Random (32 bytes)    | Client Version + Random
+--------+------------------------+
|SessionID|   Cipher Suites      | Session & Ciphers
+--------+--------+--------+--------+

2. ServerHello + Certificate:
[TLS Header][ServerHello][Certificate Chain][ServerHelloDone]

3. Key Exchange:
[TLS Header][ClientKeyExchange][ChangeCipherSpec][Finished]

第四阶段：HTTP/2请求发送

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
应用层数据:
HTTP请求对象 {
    method: "GET",
    path: "/users/123",
    headers: {
        "Host": "api.example.com",
        "User-Agent": "MyApp/1.0"
    }
}
     ↓
HTTP/2编码:

1. HEADERS帧:
+--------+--------+--------+--------+
|   Length = 25   |   1   |   5     | Frame Header
+--------+--------+--------+--------+
|  0  |      Stream ID = 1          |
+--------+--------+--------+--------+
| HPACK编码的头部数据...           | Frame Payload
+--------------------------------+

HPACK编码示例:
":method": "GET"     → 0x02 (索引表中的值)
":path": "/users/123" → 0x04 + "/users/123" (字面量)
"host": "api.example.com" → 0x01 + "api.example.com"

2. 数据封装到TCP:
TCP Header: [SRC_PORT|DST_PORT|SEQ|ACK|PSH=1|...]
TCP Data: [TLS Application Data [HTTP/2 HEADERS Frame]]

第五阶段：网络传输

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
网络层编码:
IP Header:
+--------+--------+--------+--------+
|Ver=4|HL=5|TOS=0|   Total Length  |
+--------+--------+--------+--------+
|   ID        |Flags|Frag Offset   |
+--------+--------+--------+--------+
| TTL=64| Proto=6|   Checksum      |
+--------+--------+--------+--------+
|          Source IP               |
+--------+--------+--------+--------+
|        Destination IP            |
+--------+--------+--------+--------+

数据链路层编码:
Ethernet Header:
+--------+--------+--------+--------+--------+--------+
|           Destination MAC (6 bytes)              |
+--------+--------+--------+--------+--------+--------+
|             Source MAC (6 bytes)                 |
+--------+--------+--------+--------+--------+--------+
| Type=0x0800 (IP) |
+--------+--------+

第六阶段：服务器处理和响应

1
2
3
4
5
6
7
8
9
10
11
12
服务器接收过程(解码):
Ethernet帧 → IP包 → TCP段 → TLS解密 → HTTP/2帧 → 应用数据

服务器业务逻辑:
1. 路由匹配: "/users/123" → getUserById(123)
2. 数据库查询: SELECT * FROM users WHERE id = 123
3. 业务处理: 验证权限、格式化数据
4. 构造响应: {"id": 123, "name": "John", "email": "john@example.com"}

响应编码:
JSON序列化 → HTTP/2 HEADERS帧 + DATA帧 → TLS加密 → TCP段 → IP包 → Ethernet帧

总结：编解码的统一视角

通过对编程语言实现和网络协议的深入分析，我们可以看到一个统一的模式：

1
2
3
4
5
6
7
8
数据表示 ←→ 编码规则 ←→ 执行/传输环境

单机环境:
源代码 ←→ 编译器/解释器 ←→ 运行时系统

网络环境:
应用数据 ←→ 协议栈 ←→ 网络传输

无论是程序执行还是网络通信，核心都是 如何在不同的表示层之间进行准确、高效的转换 。理解这个本质，有助于我们：

  1. 设计更好的系统架构 : 选择合适的编码方式和传输协议
  2. 优化性能 : 识别编解码瓶颈，采用更高效的实现
  3. 解决兼容性问题 : 理解不同系统间的数据转换需求
  4. 跟上技术发展 : 把握协议演进的内在逻辑和发展方向

技术的发展永远在寻求更好的平衡：性能与功能、简单与强大、兼容与创新。编解码作为信息系统的基础，将继续在这个平衡中发挥关键作用。

计算机
#架构 #编码
编码与解码：软件系统是如何实现的
http://gadoid.io/2025/06/29/编码与解码：软件系统是如何实现的/
作者
Codfish
发布于
2025年6月29日
许可协议