嘿，我明白你现在的困惑——你想让同一个端口同时处理TCP流和UDP数据包，现在能读到UDP但发不回去，核心问题其实是TCP和UDP是完全独立的协议，哪怕共用端口，也得用各自的套接字来处理读写，不能指望用net.TCPConn来搞定UDP的回发。

为什么会出现这种情况？ #

当你用net.ListenTCP()绑定端口后，系统确实会把发送到该端口的UDP数据包递交给TCP套接字，所以你能通过TCPConn.Read()读到数据，但TCPConn没有UDP协议所需的客户端地址管理能力，自然没法正确回发UDP数据包。要处理UDP的读写，必须使用net.UDPConn。

正确的实现思路 #

我们需要同时创建TCP监听器和UDP套接字，并通过端口复用选项让它们绑定同一个端口。这样TCP连接走TCP套接字处理，UDP数据包走UDP套接字处理，各自分工明确。

完整代码示例 #

package main

import (
    "context"
    "io"
    "log"
    "net"
    "syscall"
)

func main() {
    port := ":8080"

    // 1. 配置TCP监听器，开启端口复用
    tcpAddr, err := net.ResolveTCPAddr("tcp", port)
    if err != nil {
        log.Fatalf("Resolve TCP addr failed: %v", err)
    }

    listenConfig := &net.ListenConfig{
        Control: func(network, address string, c syscall.RawConn) error {
            return c.Control(func(fd uintptr) {
                // 允许端口复用，让TCP和UDP套接字能绑定同一端口
                syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
                syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEPORT, 1)
            })
        },
    }

    tcpListener, err := listenConfig.Listen(context.Background(), "tcp", tcpAddr.String())
    if err != nil {
        log.Fatalf("Start TCP listener failed: %v", err)
    }
    defer tcpListener.Close()
    log.Printf("TCP listener started on %s", port)

    // 启动goroutine处理TCP连接
    go handleTCPConnections(tcpListener)

    // 2. 创建UDP套接字，绑定同一端口
    udpAddr, err := net.ResolveUDPAddr("udp", port)
    if err != nil {
        log.Fatalf("Resolve UDP addr failed: %v", err)
    }

    udpConn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        log.Fatalf("Start UDP listener failed: %v", err)
    }
    defer udpConn.Close()
    log.Printf("UDP listener started on %s", port)

    // 处理UDP数据包
    handleUDPData(udpConn)
}

// 处理TCP连接的逻辑
func handleTCPConnections(listener net.Listener) {
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("TCP accept error: %v", err)
            continue
        }
        log.Printf("New TCP connection from %s", conn.RemoteAddr())
        go handleSingleTCPConn(conn)
    }
}

func handleSingleTCPConn(conn net.Conn) {
    defer conn.Close()
    buf := make([]byte, 1024)

    for {
        n, err := conn.Read(buf)
        if err != nil {
            if err != io.EOF {
                log.Printf("TCP read error from %s: %v", conn.RemoteAddr(), err)
            }
            log.Printf("TCP connection closed from %s", conn.RemoteAddr())
            return
        }

        received := string(buf[:n])
        log.Printf("Received TCP data from %s: %s", conn.RemoteAddr(), received)

        // 回发TCP响应
        _, err = conn.Write([]byte("TCP response: " + received))
        if err != nil {
            log.Printf("TCP write error to %s: %v", conn.RemoteAddr(), err)
            return
        }
    }
}

// 处理UDP数据包的逻辑
func handleUDPData(conn *net.UDPConn) {
    buf := make([]byte, 1024)

    for {
        // 读取UDP数据包，同时获取客户端地址
        n, clientAddr, err := conn.ReadFromUDP(buf)
        if err != nil {
            log.Printf("UDP read error: %v", err)
            continue
        }

        received := string(buf[:n])
        log.Printf("Received UDP data from %s: %s", clientAddr, received)

        // 回发UDP响应，使用WriteToUDP指定客户端地址
        response := []byte("UDP response: " + received)
        _, err = conn.WriteToUDP(response, clientAddr)
        if err != nil {
            log.Printf("UDP write error to %s: %v", clientAddr, err)
        }
    }
}

关键细节说明 #

• 端口复用：通过SO_REUSEADDR和SO_REUSEPORT选项，让TCP和UDP套接字可以绑定同一个端口，这是实现共用端口的核心。不同操作系统对这两个选项的支持略有差异，但同时设置兼容性更好。
• UDP读写：用ReadFromUDP读取UDP数据包时，会返回客户端的UDP地址，之后用WriteToUDP就能精准回发数据给对应的客户端。如果你是用DialUDP创建的连接型UDP套接字，可以直接用Write，但监听场景下ReadFromUDP+WriteToUDP更灵活，能处理多个客户端的请求。
• 分离处理：TCP和UDP的逻辑完全分离在各自的goroutine里，互不干扰，符合Go的并发模型。

内容的提问来源于stack exchange，提问作者Rob