网络各层

为什么网络协议要采用分层设计？

网络协议分层设计是计算机网络中最重要的设计原则之一，它将复杂的网络通信过程分解为多个相对独立的层次。

核心优势：

1. 关注点分离（Separation of Concerns）

   • 每层专注解决特定的网络问题
   • 物理层关注信号传输，传输层关注可靠性

2. 抽象封装（Abstraction & Encapsulation）

   • 上层不需要了解下层的实现细节
   • 下层为上层提供服务接口

3. 可替换性（Pluggability）

   • 某一层的实现可以独立更换
   • 例如：以太网可以替换为WiFi，应用层无感知

在软件工程中的借鉴意义：

// 分层架构示例：Web应用程序
type Handler struct {
    service Service
}

type Service struct {
    repository Repository
}

type Repository struct {
    db Database
}

// 表现层（Handler）
func (h *Handler) GetUser(w http.ResponseWriter, r *http.Request) {
    user, err := h.service.GetUser(userID)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(user)
}

// 业务层（Service）
func (s *Service) GetUser(userID string) (*User, error) {
    return s.repository.FindByID(userID)
}

// 数据层（Repository）
func (r *Repository) FindByID(userID string) (*User, error) {
    return r.db.Query("SELECT * FROM users WHERE id = ?", userID)
}

这种分层设计模式在现代软件架构中广泛应用，如MVC、六边形架构、洋葱架构等。

OSI七层模型详解

OSI（Open Systems Interconnection）模型是网络通信的理论参考模型，但在实际应用中，TCP/IP四层模型更为实用。

OSI模型的价值在于理论指导，但TCP/IP模型更贴近实际实现。

TCP/IP四层模型与主要协议

应用层（Application Layer）

职责：为用户应用提供网络服务接口

主要协议：

// 应用层协议示例
func applicationLayerExamples() {
    // HTTP - Web服务
    resp, _ := http.Get("https://api.github.com/users/octocat")
    
    // DNS - 域名解析
    ips, _ := net.LookupIP("github.com")
    
    // SMTP - 邮件发送（伪代码）
    // smtp.SendMail("smtp.gmail.com:587", auth, from, to, msg)
    
    // FTP - 文件传输（伪代码）
    // ftp.Connect("ftp.example.com:21")
}

传输层（Transport Layer）

职责：提供端到端的数据传输服务

主要协议：

协议	特点	适用场景	端口示例
TCP	可靠、面向连接、流控制	Web、邮件、文件传输	80(HTTP), 443(HTTPS), 22(SSH)
UDP	快速、无连接、开销小	视频直播、DNS查询、游戏	53(DNS), 67/68(DHCP)
SCTP	多流、面向消息	电信信令	-

// 传输层协议示例
func transportLayerExamples() {
    // TCP - 可靠连接
    conn, _ := net.Dial("tcp", "example.com:80")
    defer conn.Close()
    conn.Write([]byte("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"))
    
    // UDP - 快速传输
    udpConn, _ := net.Dial("udp", "8.8.8.8:53")
    defer udpConn.Close()
    udpConn.Write([]byte("DNS query"))
}

网络层（Internet Layer）

职责：处理数据包的路由和转发

主要协议：

详细说明：

• IP (Internet Protocol)：负责数据包的寻址和路由

  • IPv4：32位地址，如 192.168.1.1
  • IPv6：128位地址，如 2001:db8::1

• ICMP (Internet Control Message Protocol)：网络诊断和错误报告

  • Ping命令使用ICMP Echo Request/Reply
  • 目标不可达、超时等错误消息

• ARP (Address Resolution Protocol)：IP地址到MAC地址的映射

// 网络层操作示例
func networkLayerExamples() {
    // IP地址解析
    ip := net.ParseIP("192.168.1.1")
    
    // ICMP - Ping功能（简化）
    // 实际需要原始套接字权限
    cmd := exec.Command("ping", "-c", "1", "8.8.8.8")
    output, _ := cmd.Output()
    fmt.Println(string(output))
    
    // 路由表查看
    interfaces, _ := net.Interfaces()
    for _, iface := range interfaces {
        addrs, _ := iface.Addrs()
        for _, addr := range addrs {
            fmt.Printf("接口: %s, 地址: %s\n", iface.Name, addr)
        }
    }
}

网络接口层（Network Interface Layer）

职责：处理物理网络的访问

主要协议：

详细说明：

• Ethernet：有线局域网标准

  • 帧格式、MAC地址、CSMA/CD访问控制
  • 速率：10M/100M/1G/10G/40G/100G

• 802.11 (WiFi)：无线局域网标准

  • 802.11a/b/g/n/ac/ax 不同标准
  • WPA/WPA2/WPA3 安全协议

• PPP：点对点连接协议

  • 拨号上网、VPN连接

// 网络接口层信息获取
func networkInterfaceExamples() {
    // 获取网络接口信息
    interfaces, err := net.Interfaces()
    if err != nil {
        log.Fatal(err)
    }
    
    for _, iface := range interfaces {
        fmt.Printf("接口名: %s\n", iface.Name)
        fmt.Printf("MAC地址: %s\n", iface.HardwareAddr)
        fmt.Printf("状态: %v\n", iface.Flags)
        fmt.Printf("MTU: %d\n", iface.MTU)
        
        // 获取接口地址
        addrs, _ := iface.Addrs()
        for _, addr := range addrs {
            switch v := addr.(type) {
            case *net.IPNet:
                fmt.Printf("IP地址: %s\n", v.IP)
                fmt.Printf("子网掩码: %s\n", v.Mask)
            }
        }
        fmt.Println("---")
    }
}

协议栈交互示例

// 完整的网络通信示例
func fullStackExample() {
    // 应用层：构造HTTP请求
    request := "GET /api/users HTTP/1.1\r\n" +
              "Host: api.example.com\r\n" +
              "User-Agent: Go-Client/1.0\r\n" +
              "\r\n"
    
    // 传输层：建立TCP连接
    conn, err := net.Dial("tcp", "api.example.com:80")
    if err != nil {
        log.Fatal("TCP连接失败:", err)
    }
    defer conn.Close()
    
    // 发送数据（传输层处理分段、网络层处理路由、接口层处理帧传输）
    _, err = conn.Write([]byte(request))
    if err != nil {
        log.Fatal("数据发送失败:", err)
    }
    
    // 接收响应
    buffer := make([]byte, 4096)
    n, err := conn.Read(buffer)
    if err != nil {
        log.Fatal("数据接收失败:", err)
    }
    
    // 应用层：解析HTTP响应
    response := string(buffer[:n])
    fmt.Println("HTTP响应:")
    fmt.Println(response)
}

TCP/IP模型与OSI模型的区别

主要区别：

特征	OSI模型	TCP/IP模型
层数	7层	4层
设计时间	理论先行	实践驱动
应用广泛性	理论标准	实际应用
灵活性	严格分层	实用性强

为什么TCP/IP更实用？

1. 历史优势：互联网基于TCP/IP发展
2. 实现简单：层数较少，实现复杂度低
3. 性能优化：减少层间开销
4. 生态完善：大量成熟的实现和工具

// TCP/IP在Go中的体现
// 应用层：HTTP客户端
resp, err := http.Get("https://api.example.com/users")

// 传输层：TCP连接
conn, err := net.Dial("tcp", "example.com:80")

// 网络层：IP地址解析
ips, err := net.LookupIP("example.com")

// 网络接口层：由操作系统处理

数据的封装和传输过程

数据在网络各层间的传输遵循封装（Encapsulation）和解封装（Decapsulation）的过程。

详细封装过程：

// 应用层数据示例
type HTTPRequest struct {
    Method  string
    URL     string
    Headers map[string]string
    Body    []byte
}

// 传输层封装（TCP段）
type TCPSegment struct {
    SourcePort      uint16
    DestinationPort uint16
    SequenceNumber  uint32
    AckNumber       uint32
    Flags           uint8
    WindowSize      uint16
    Checksum        uint16
    Data            []byte  // 来自应用层的数据
}

// 网络层封装（IP包）
type IPPacket struct {
    Version        uint8
    HeaderLength   uint8
    TypeOfService  uint8
    TotalLength    uint16
    Identification uint16
    Flags          uint8
    FragmentOffset uint16
    TimeToLive     uint8
    Protocol       uint8   // TCP=6, UDP=17
    HeaderChecksum uint16
    SourceIP       [4]byte
    DestinationIP  [4]byte
    Data           []byte  // TCP段
}

// 数据链路层封装（以太网帧）
type EthernetFrame struct {
    DestinationMAC [6]byte
    SourceMAC      [6]byte
    EtherType      uint16  // IP=0x0800
    Data           []byte  // IP包
    FCS            uint32  // 帧校验序列
}

PDU（协议数据单元）命名：

• 应用层：消息（Message）
• 传输层：段（Segment）- TCP，数据报（Datagram）- UDP
• 网络层：包（Packet）
• 数据链路层：帧（Frame）
• 物理层：比特（Bit）

Golang网络编程与网络层的交互

Go语言提供了丰富的网络编程接口，让开发者能够在不同层次上与网络协议栈交交道。

应用层编程

// HTTP服务器（应用层）
func httpServer() {
    http.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        users := []User{{Name: "张三", Age: 25}}
        json.NewEncoder(w).Encode(users)
    })
    
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// HTTP客户端（应用层）
func httpClient() {
    resp, err := http.Get("http://localhost:8080/api/users")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    var users []User
    json.NewDecoder(resp.Body).Decode(&users)
}

传输层编程

// TCP服务器（传输层）
func tcpServer() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        return
    }
    
    // 处理数据
    response := processData(buffer[:n])
    conn.Write(response)
}

// UDP编程（传输层）
func udpServer() {
    addr, err := net.ResolveUDPAddr("udp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    
    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    buffer := make([]byte, 1024)
    for {
        n, clientAddr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            continue
        }
        
        response := processUDPData(buffer[:n])
        conn.WriteToUDP(response, clientAddr)
    }
}

网络层操作

// IP地址操作（网络层）
func networkLayerOps() {
    // 解析IP地址
    ip := net.ParseIP("192.168.1.1")
    if ip == nil {
        log.Fatal("无效的IP地址")
    }
    
    // 查找IP地址
    ips, err := net.LookupIP("google.com")
    if err != nil {
        log.Fatal(err)
    }
    
    for _, ip := range ips {
        fmt.Printf("IP: %s\n", ip.String())
    }
    
    // 网络接口信息
    interfaces, err := net.Interfaces()
    if err != nil {
        log.Fatal(err)
    }
    
    for _, iface := range interfaces {
        addrs, _ := iface.Addrs()
        for _, addr := range addrs {
            fmt.Printf("接口: %s, 地址: %s\n", iface.Name, addr.String())
        }
    }
}

低级网络编程

// 原始套接字编程（更接近数据链路层）
func rawSocket() {
    // 创建原始套接字（需要root权限）
    fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
    if err != nil {
        log.Fatal(err)
    }
    defer syscall.Close(fd)
    
    // 构造ICMP包
    icmpPacket := buildICMPPacket()
    
    // 目标地址
    addr := syscall.SockaddrInet4{
        Port: 0,
        Addr: [4]byte{8, 8, 8, 8}, // Google DNS
    }
    
    // 发送数据
    err = syscall.Sendto(fd, icmpPacket, 0, &addr)
    if err != nil {
        log.Fatal(err)
    }
}

func buildICMPPacket() []byte {
    // ICMP Echo Request
    packet := make([]byte, 8)
    packet[0] = 8  // Type: Echo Request
    packet[1] = 0  // Code
    // ... 构造完整的ICMP包
    return packet
}

网络分层对性能优化的帮助

理解网络分层有助于定位性能瓶颈和进行针对性优化。

应用层优化

// HTTP客户端优化
func optimizedHTTPClient() *http.Client {
    return &http.Client{
        Timeout: 30 * time.Second,
        Transport: &http.Transport{
            // 连接池配置
            MaxIdleConns:        100,
            MaxIdleConnsPerHost: 10,
            IdleConnTimeout:     90 * time.Second,
            
            // 连接建立超时
            DialContext: (&net.Dialer{
                Timeout:   5 * time.Second,
                KeepAlive: 30 * time.Second,
            }).DialContext,
            
            // TLS配置
            TLSHandshakeTimeout: 5 * time.Second,
            
            // 启用HTTP/2
            ForceAttemptHTTP2: true,
            
            // 禁用压缩（如果数据已压缩）
            DisableCompression: false,
        },
    }
}

// 连接复用示例
func connectionReuse() {
    client := optimizedHTTPClient()
    
    // 多个请求会复用连接
    for i := 0; i < 10; i++ {
        resp, err := client.Get("https://api.example.com/data")
        if err != nil {
            log.Printf("请求失败: %v", err)
            continue
        }
        resp.Body.Close()
    }
}

传输层优化

// TCP连接优化
func optimizedTCPServer() {
    config := &net.ListenConfig{
        // 设置连接控制参数
        Control: func(network, address string, c syscall.RawConn) error {
            return c.Control(func(fd uintptr) {
                // 启用地址重用
                syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, 
                    syscall.SO_REUSEADDR, 1)
                
                // 设置接收缓冲区大小
                syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, 
                    syscall.SO_RCVBUF, 65536)
                
                // 设置发送缓冲区大小
                syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, 
                    syscall.SO_SNDBUF, 65536)
            })
        },
    }
    
    listener, err := config.Listen(context.Background(), "tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        
        // 设置连接级别的优化
        if tcpConn, ok := conn.(*net.TCPConn); ok {
            // 禁用Nagle算法（对于低延迟应用）
            tcpConn.SetNoDelay(true)
            // 启用keep-alive
            tcpConn.SetKeepAlive(true)
            tcpConn.SetKeepAlivePeriod(30 * time.Second)
        }
        
        go handleOptimizedConnection(conn)
    }
}

// 缓冲区优化
func handleOptimizedConnection(conn net.Conn) {
    defer conn.Close()
    
    // 使用缓冲读写
    reader := bufio.NewReaderSize(conn, 4096)
    writer := bufio.NewWriterSize(conn, 4096)
    
    for {
        // 读取数据
        data, err := reader.ReadBytes('\n')
        if err != nil {
            break
        }
        
        // 处理数据
        response := processData(data)
        
        // 写入响应
        writer.Write(response)
        writer.Flush() // 确保数据发送
    }
}

网络层监控和优化

// 网络状态监控
func networkMonitoring() {
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()
    
    for range ticker.C {
        // 监控网络接口状态
        interfaces, err := net.Interfaces()
        if err != nil {
            continue
        }
        
        for _, iface := range interfaces {
            if iface.Flags&net.FlagUp == 0 {
                continue // 跳过关闭的接口
            }
            
            stats := getInterfaceStats(iface.Name)
            log.Printf("接口 %s: RX=%d bytes, TX=%d bytes", 
                iface.Name, stats.RxBytes, stats.TxBytes)
        }
    }
}

type InterfaceStats struct {
    RxBytes uint64
    TxBytes uint64
    RxPackets uint64
    TxPackets uint64
}

func getInterfaceStats(ifaceName string) InterfaceStats {
    // 从 /proc/net/dev 读取统计信息 (Linux)
    // 这里是简化版本，实际需要解析系统文件
    return InterfaceStats{
        RxBytes: 1000000,
        TxBytes: 500000,
    }
}

性能测试和分析

// 网络性能测试
func networkPerformanceTest() {
    // 延迟测试
    start := time.Now()
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    connectTime := time.Since(start)
    log.Printf("连接建立时间: %v", connectTime)
    
    // 吞吐量测试
    data := make([]byte, 1024*1024) // 1MB数据
    start = time.Now()
    
    _, err = conn.Write(data)
    if err != nil {
        log.Fatal(err)
    }
    
    transferTime := time.Since(start)
    throughput := float64(len(data)) / transferTime.Seconds() / 1024 / 1024
    log.Printf("吞吐量: %.2f MB/s", throughput)
}

// 使用pprof进行性能分析
func enableProfiling() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
}

// 内存池优化减少GC压力
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}

func optimizedHandler(conn net.Conn) {
    defer conn.Close()
    
    // 从池中获取缓冲区
    buffer := bufferPool.Get().([]byte)
    defer bufferPool.Put(buffer)
    
    n, err := conn.Read(buffer)
    if err != nil {
        return
    }
    
    // 处理数据...
    processDataOptimized(buffer[:n])
}

基于分层模型的故障诊断

网络故障诊断时，分层模型提供了系统化的排查思路。

Go语言实现的网络诊断工具

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "os/exec"
    "time"
)

// 网络诊断器
type NetworkDiagnostic struct {
    target string
    port   string
}

func NewNetworkDiagnostic(target, port string) *NetworkDiagnostic {
    return &NetworkDiagnostic{
        target: target,
        port:   port,
    }
}

// 1. 网络层诊断 - Ping测试
func (nd *NetworkDiagnostic) PingTest() error {
    fmt.Printf("🔍 测试网络层连通性 (ping %s)...\n", nd.target)
    
    cmd := exec.Command("ping", "-c", "4", nd.target)
    output, err := cmd.Output()
    if err != nil {
        return fmt.Errorf("ping失败: %v", err)
    }
    
    fmt.Printf("✅ Ping成功:\n%s\n", output)
    return nil
}

// 2. 传输层诊断 - TCP连接测试
func (nd *NetworkDiagnostic) TCPConnectTest() error {
    fmt.Printf("🔍 测试传输层连接 (TCP %s:%s)...\n", nd.target, nd.port)
    
    timeout := 5 * time.Second
    conn, err := net.DialTimeout("tcp", nd.target+":"+nd.port, timeout)
    if err != nil {
        return fmt.Errorf("TCP连接失败: %v", err)
    }
    defer conn.Close()
    
    fmt.Printf("✅ TCP连接成功: %s\n", conn.RemoteAddr())
    return nil
}

// 3. DNS解析测试
func (nd *NetworkDiagnostic) DNSResolveTest() error {
    fmt.Printf("🔍 测试DNS解析 (%s)...\n", nd.target)
    
    ips, err := net.LookupIP(nd.target)
    if err != nil {
        return fmt.Errorf("DNS解析失败: %v", err)
    }
    
    fmt.Printf("✅ DNS解析成功:\n")
    for _, ip := range ips {
        fmt.Printf("  - %s\n", ip.String())
    }
    return nil
}

// 4. 路由跟踪（简化版）
func (nd *NetworkDiagnostic) TracerouteTest() error {
    fmt.Printf("🔍 路由跟踪到 %s...\n", nd.target)
    
    cmd := exec.Command("traceroute", nd.target)
    output, err := cmd.Output()
    if err != nil {
        return fmt.Errorf("路由跟踪失败: %v", err)
    }
    
    fmt.Printf("✅ 路由跟踪结果:\n%s\n", output)
    return nil
}

// 5. 端口扫描
func (nd *NetworkDiagnostic) PortScan(ports []string) {
    fmt.Printf("🔍 扫描端口 (%s)...\n", nd.target)
    
    for _, port := range ports {
        conn, err := net.DialTimeout("tcp", nd.target+":"+port, 2*time.Second)
        if err != nil {
            fmt.Printf("❌ 端口 %s: 关闭或不可达\n", port)
            continue
        }
        conn.Close()
        fmt.Printf("✅ 端口 %s: 开放\n", port)
    }
}

// 6. HTTP应用层测试
func (nd *NetworkDiagnostic) HTTPTest() error {
    fmt.Printf("🔍 测试HTTP应用层 (http://%s)...\n", nd.target)
    
    client := &http.Client{
        Timeout: 10 * time.Second,
    }
    
    resp, err := client.Get("http://" + nd.target)
    if err != nil {
        return fmt.Errorf("HTTP请求失败: %v", err)
    }
    defer resp.Body.Close()
    
    fmt.Printf("✅ HTTP响应: %s\n", resp.Status)
    return nil
}

// 完整的网络诊断流程
func (nd *NetworkDiagnostic) FullDiagnosis() {
    fmt.Printf("🚀 开始网络诊断: %s:%s\n", nd.target, nd.port)
    fmt.Println(strings.Repeat("=", 50))
    
    // 1. DNS解析测试
    if err := nd.DNSResolveTest(); err != nil {
        log.Printf("❌ DNS解析失败: %v\n", err)
        return
    }
    
    // 2. 网络层测试
    if err := nd.PingTest(); err != nil {
        log.Printf("❌ 网络层测试失败: %v\n", err)
        // 可能是ICMP被阻挡，继续其他测试
    }
    
    // 3. 传输层测试
    if err := nd.TCPConnectTest(); err != nil {
        log.Printf("❌ 传输层测试失败: %v\n", err)
        return
    }
    
    // 4. 应用层测试
    if nd.port == "80" || nd.port == "8080" {
        if err := nd.HTTPTest(); err != nil {
            log.Printf("❌ 应用层测试失败: %v\n", err)
        }
    }
    
    // 5. 路由跟踪
    if err := nd.TracerouteTest(); err != nil {
        log.Printf("❌ 路由跟踪失败: %v\n", err)
    }
    
    // 6. 端口扫描
    commonPorts := []string{"22", "80", "443", "3306", "6379"}
    nd.PortScan(commonPorts)
    
    fmt.Println("🎉 网络诊断完成！")
}

// 网络接口信息获取
func GetNetworkInterfaceInfo() {
    fmt.Println("🔍 本地网络接口信息:")
    
    interfaces, err := net.Interfaces()
    if err != nil {
        log.Printf("获取网络接口失败: %v", err)
        return
    }
    
    for _, iface := range interfaces {
        fmt.Printf("\n接口: %s\n", iface.Name)
        fmt.Printf("  硬件地址: %s\n", iface.HardwareAddr)
        fmt.Printf("  状态: %s\n", iface.Flags.String())
        
        addrs, err := iface.Addrs()
        if err != nil {
            continue
        }
        
        for _, addr := range addrs {
            fmt.Printf("  地址: %s\n", addr.String())
        }
    }
}

func main() {
    // 使用示例
    diagnostic := NewNetworkDiagnostic("google.com", "80")
    diagnostic.FullDiagnosis()
    
    fmt.Println()
    GetNetworkInterfaceInfo()
}

常见故障排查场景

// 连接超时故障排查
func diagnoseConnectionTimeout(target string, port string) {
    fmt.Printf("🔍 排查连接超时故障: %s:%s\n", target, port)
    
    // 1. 检查DNS解析
    start := time.Now()
    ips, err := net.LookupIP(target)
    dnsTime := time.Since(start)
    
    if err != nil {
        fmt.Printf("❌ DNS解析失败: %v\n", err)
        return
    }
    fmt.Printf("✅ DNS解析成功 (%v): %v\n", dnsTime, ips)
    
    // 2. 检查TCP连接（分步骤）
    for _, ip := range ips {
        addr := fmt.Sprintf("%s:%s", ip.String(), port)
        
        // 尝试建立连接
        start = time.Now()
        conn, err := net.DialTimeout("tcp", addr, 5*time.Second)
        connectTime := time.Since(start)
        
        if err != nil {
            fmt.Printf("❌ 连接 %s 失败 (%v): %v\n", addr, connectTime, err)
            continue
        }
        defer conn.Close()
        
        fmt.Printf("✅ 连接 %s 成功 (%v)\n", addr, connectTime)
        
        // 3. 测试数据传输
        testMessage := []byte("Hello, Server!\n")
        start = time.Now()
        _, err = conn.Write(testMessage)
        writeTime := time.Since(start)
        
        if err != nil {
            fmt.Printf("❌ 数据发送失败 (%v): %v\n", writeTime, err)
            continue
        }
        
        fmt.Printf("✅ 数据发送成功 (%v)\n", writeTime)
        break
    }
}

// SSL/TLS连接诊断
func diagnoseTLSConnection(target string, port string) {
    fmt.Printf("🔍 排查TLS连接故障: %s:%s\n", target, port)
    
    // TLS连接测试
    config := &tls.Config{
        ServerName: target,
    }
    
    conn, err := tls.Dial("tcp", target+":"+port, config)
    if err != nil {
        fmt.Printf("❌ TLS握手失败: %v\n", err)
        
        // 分析具体错误
        if strings.Contains(err.Error(), "certificate") {
            fmt.Println("🔍 可能的证书问题:")
            fmt.Println("  - 证书过期")
            fmt.Println("  - 证书域名不匹配")
            fmt.Println("  - 证书链不完整")
        }
        return
    }
    defer conn.Close()
    
    // 获取证书信息
    state := conn.ConnectionState()
    fmt.Printf("✅ TLS连接成功:\n")
    fmt.Printf("  版本: %s\n", tlsVersionName(state.Version))
    fmt.Printf("  密码套件: %s\n", tls.CipherSuiteName(state.CipherSuite))
    
    if len(state.PeerCertificates) > 0 {
        cert := state.PeerCertificates[0]
        fmt.Printf("  证书主体: %s\n", cert.Subject)
        fmt.Printf("  证书有效期: %s - %s\n", 
            cert.NotBefore.Format("2006-01-02"), 
            cert.NotAfter.Format("2006-01-02"))
    }
}

func tlsVersionName(version uint16) string {
    switch version {
    case tls.VersionTLS10:
        return "TLS 1.0"
    case tls.VersionTLS11:
        return "TLS 1.1"
    case tls.VersionTLS12:
        return "TLS 1.2"
    case tls.VersionTLS13:
        return "TLS 1.3"
    default:
        return fmt.Sprintf("Unknown (%x)", version)
    }
}

网络分层模型不仅是理论概念，更是实际开发和运维中的重要工具。通过理解各层的职责和相互关系，我们能够：

1. 设计更好的网络应用：选择合适的协议和优化策略
2. 进行有效的性能调优：定位瓶颈并针对性优化
3. 快速诊断网络故障：系统化地排查问题
4. 编写高质量的代码：遵循分层设计原则，提高代码的可维护性

这些原则和实践在Go语言的网络编程中都有很好的体现，帮助我们构建高性能、可靠的网络应用。