Go 网络与协议实现详解（TCP/HTTP/DNS/TCP粘包）

package main

import (
	"bufio"
	"fmt"
	"net"
)

func handleConnection(conn net.Conn) {
	defer conn.Close()
	
	reader := bufio.NewScanner(conn)
	for reader.Scan() {
		line := reader.Text()
		fmt.Fprintf(conn, "ECHO: %s\n", line)
	}
}

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}
	defer listener.Close()
	
	fmt.Println("Echo server started on :8080")
	
	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Printf("accept error: %v\n", err)
			continue
		}
		go handleConnection(conn)
	}
}

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
)

func main() {
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	
	go func() {
		serverReader := bufio.NewScanner(conn)
		for serverReader.Scan() {
			fmt.Println(serverReader.Text())
		}
	}()
	
	reader := bufio.NewScanner(os.Stdin)
	for reader.Scan() {
		fmt.Fprintf(conn, "%s\n", reader.Text())
	}
}

type LengthPrefixCodec struct{}

func (c *LengthPrefixCodec) Encode(msg []byte) ([]byte, error) {
	// 4字节大端整数 + 消息体
	length := len(msg)
	header := make([]byte, 4)
	binary.BigEndian.PutUint32(header, uint32(length))
	return append(header, msg...), nil
}

func (c *LengthPrefixCodec) Decode(conn net.Conn) ([]byte, error) {
	// 先读4字节头
	header := make([]byte, 4)
	if _, err := io.ReadFull(conn, header); err != nil {
		return nil, err
	}
	length := int(binary.BigEndian.Uint32(header))
	
	// 再读消息体
	body := make([]byte, length)
	if _, err := io.ReadFull(conn, body); err != nil {
		return nil, err
	}
	return body, nil
}

type DelimiterCodec struct {
	delimiter []byte
}

func (c *DelimiterCodec) Encode(msg []byte) []byte {
	return append(msg, c.delimiter.

### 应用场景

在实际项目中，这个知识点经常应用于：

1. **典型场景一**：说明具体应用场景
2. **典型场景二**：说明另一个应用场景
3. **面试要点**：提醒面试中可能被问到的点

..)
}

func (c *DelimiterCodec) Decode(data []byte) [][]byte {
	return bytes.Split(data, c.delimiter)
}

const msgSize = 1024

type FixedLengthCodec struct{}

func (c *FixedLengthCodec) Encode(msg []byte) ([]byte, error) {
	if len(msg) > msgSize {
		return nil, fmt.Errorf("message too large")
	}
	buf := make([]byte, msgSize)
	copy(buf, msg)
	return buf, nil
}

func (c *FixedLengthCodec) Decode(data []byte) ([]byte, error) {
	

### 应用场景

在实际项目中，这个知识点经常应用于：

1. **典型场景一**：说明具体应用场景
2. **典型场景二**：说明另一个应用场景
3. **面试要点**：提醒面试中可能被问到的点

// 去除尾部空字节
	return bytes.TrimRight(data, "\x00"), nil
}

type Server struct {
	mux     *ServeMux
	handler Handler
}

type ServeMux struct {
	m     map[string]Handler
	mu    sync.RWMutex
}

func (mux *ServeMux) Handle(pattern string, handler Handler) {
	mux.mu.Lock()
	defer mux.mu.Unlock()
	mux.m[pattern] = handler
}

func (mux *ServeMux) Find(pattern string) (Handler, bool) {
	mux.mu.RLock()
	defer mux.mu.RUnlock()
	if h, ok := mux.m[pattern]; ok {
		return h, true
	}
	// 简单通配符支持
	for p, h := range mux.m {
		if strings.HasSuffix(p, "/*") {
			if strings.HasPrefix(pattern, strings.TrimSuffix(p, "*")) {
				return h, true
			}
		}
	}
	return nil, false
}

type Request struct {
	Method string
	Path   string
	Header http.Header
	Body   []byte
}

type Response struct {
	StatusCode int
	Header     http.Header
	Body       []byte
}

func (s *Server) ServeConn(conn net.Conn) {
	defer conn.Close()
	
	reader := bufio.NewReader(conn)
	method, path, _ := readRequestLine(reader)
	header := readHeaders(reader)
	body, _ := io.ReadAll(reader)
	
	req := &Request{Method: method, Path: path, Header: header, Body: body}
	resp := s.mux.Dispatch(req)
	
	writeResponse(conn, resp)
}

func (mux *ServeMux) Dispatch(req *Request) *Response {
	handler, ok := mux.Find(req.Path)
	if !ok {
		return &Response{StatusCode: 404, Body: []byte("Not Found")}
	}
	resp := handler(req)
	return resp
}

type DNSResolver struct {
	server string // DNS服务器地址
}

func NewDNSResolver(server string) *DNSResolver {
	return &DNSResolver{server: server}
}

func (r *DNSResolver) Resolve(domain string) ([]net.IP, error) {
	// 构造 DNS 查询报文
	query := r.buildQuery(domain)
	
	// 发送到 DNS 服务器
	conn, err := net.Dial("udp", r.server+":53")
	if err != nil {
		return nil, err
	}
	defer conn.Close()
	
	if _, err := conn.Write(query); err != nil {
		return nil, err
	}
	
	// 读取响应
	reply := make([]byte, 512)
	if _, err := conn.Read(reply); err != nil {
		return nil, err
	}
	
	return r.parseResponse(reply)
}

func (r *DNSResolver) buildQuery(domain string) []byte {
	// DNS 报文格式：ID(2) + Flags(2) + QDCount(2) + ANCount(2) + NSCount(2) + ARCount(2) + Question...
	header := make([]byte, 12)
	binary.BigEndian.PutUint16(header[0:], 0x0100) // standard query, recursion desired
	binary.BigEndian.PutUint16(header[4:], 1)      // 1 question
	
	// 编码域名
	var qd []byte
	for _, label := range strings.Split(domain, ".") {
		qd = append(qd, byte(len(label)))
		qd = append(qd, []byte(label)...)
	}
	qd = append(qd, 0) // 终止符
	
	header = append(header, qd...)
	header = append(header, 0, 1) // QTYPE=A, QCLASS=IN
	return header
}

func (r *DNSResolver) parseResponse(reply []byte) ([]net.IP, error) {
	// 解析响应中的 Answer 部分
	// 简化版：实际解析较为复杂
	var ips []net.IP
	// ... 省略详细解析逻辑
	return ips, nil
}

type Ping struct {
	id   int
	seq  int
Conn   net.PacketConn
}

func (p *Ping) Send(target string) error {
	addr, err := net.ResolveIPAddr("ip4:icmp", target)
	if err != nil {
		return err
	}
	
	msg := make([]byte, 8)
	msg[0] = 8  // ICMP Echo Request
	msg[1] = 0  // Code
	binary.BigEndian.PutUint16(msg[2:], uint16(p.id))
	binary.BigEndian.PutUint16(msg[4:], uint16(p.seq))
	checksum := checksum(msg)
	binary.BigEndian.PutUint16(msg[6:], checksum)
	
	_, err = p.Conn.WriteTo(msg, addr)
	return err
}

func checksum(data []byte) uint16 {
	sum := uint32(0)
	for i := 0; i < len(data)-1; i += 2 {
		sum += uint32(data[i])<<8 | uint32(data[i+1])
	}
	if len(data)%2 == 1 {
		sum += uint32(data[len(data)-1]) << 8
	}
	for sum > 0xffff {
		sum = (sum >> 16) + (sum & 0xffff)
	}
	return uint16(^sum)
}

// Go netpoller 伪代码
func epollWait(events []EpollEvent, maxEvents int, timeout int) int {
    return syscall.EpollWait(epfd, events, maxEvents, timeout)
}

// 事件驱动模型
f

### 应用场景

在实际项目中，这个知识点经常应用于：

1. **典型场景一**：说明具体应用场景
2. **典型场景二**：说明另一个应用场景
3. **面试要点**：提醒面试中可能被问到的点

unc poll() {
    for {
        n := epollWait(activeEvents, maxEvents, -1)
        for i := 0; i < n; i++ {
            fd := activeEvents[i].Fd
            if activeEvents[i].Events&EPOLLIN != 0 {
                // 可读事件
                dispatchRead(fd)
            }
            if activeEvents[i].Events&EPOLLOUT != 0 {
                // 可写事件
                dispatchWrite(fd)
            }
        }
    }
}

// HTTP/2 帧结构简化演示
type Frame struct {
    Length uint32
    Type   byte    // 0:DATA, 1:HEADERS, 2:PRIORITY, etc.
    Flags  byte
    StreamID uint32
    Payload []byte
}

// 多路复用的核心思想
// 一个 TCP 连接上并发多个 Stream
// 每个 Stream 有自己的 Stream ID
// 通过 Frame 头部标识属于哪个 Stream