1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import (
	"fmt"
	"net"
)

// net 包是 Go 语言的网络瑞士军刀
// 想象它是你的网络遥控器，按钮包括：
// - TCP/UDP 拨号
// - 域名解析
// - IP 地址处理
// - 邮件协议（SMTP/POP3/IMAP）

func main() {
	fmt.Println("net 包：让程序联网的必备工具")
	fmt.Println("支持：TCP/UDP 连接、DNS 解析、IP 地址处理、邮件协议...")
}

 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

package main

import (
	"fmt"
)

// 想象你在写信
// TCP 像是挂号信：寄出 → 对方签收 → 你收到回执 → 确认送达
// UDP 像是明信片：写完就投，丢不丢、顺序乱不乱全凭运气

func main() {
	fmt.Println("TCP vs UDP 对比：")
	fmt.Println("")
	fmt.Println("TCP（打电话）：")
	fmt.Println("  ✅ 可靠 - 丢包会重传")
	fmt.Println("  ✅ 有序 - 先发的先到")
	fmt.Println("  ✅ 连接 - 先握手再聊天")
	fmt.Println("  ❌ 慢 - 因为要确认来确认去")
	fmt.Println("  ❌ 开销大 - 连接状态要维护")
	fmt.Println("")
	fmt.Println("UDP（寄快递）：")
	fmt.Println("  ✅ 快 - 不用握手，直接发")
	fmt.Println("  ✅ 轻量 - 没有连接状态")
	fmt.Println("  ✅ 省心（对自己）- 发完就不管了")
	fmt.Println("  ❌ 不可靠 - 可能丢包")
	fmt.Println("  ❌ 无序 - 顺序可能乱")
	fmt.Println("  ❌ 无连接 - 不知道对方在不在")
}

 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

package main

import (
	"fmt"
	"net"
)

// ParseIP 将字符串 IP 转换为 net.IP 类型
// 支持 IPv4 和 IPv6

func main() {
	// IPv4 地址解析
	ipv4 := net.ParseIP("192.168.1.100")
	fmt.Printf("解析 IPv4: %v -> 类型: %T\n", ipv4, ipv4)

	// IPv6 地址解析
	ipv6 := net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
	fmt.Printf("解析 IPv6: %v -> 类型: %T\n", ipv6, ipv6)

	// IPv6 简化写法
	ipv6Short := net.ParseIP("2001:db8::8a2e:370:7334")
	fmt.Printf("解析 IPv6（简化）: %v\n", ipv6Short)

	// 格式错误？会返回 nil
	invalid := net.ParseIP("不是一个IP")
	fmt.Printf("无效 IP: %v\n", invalid)
}

 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

package main

import (
	"fmt"
	"net"
)

// IP.To4() 和 IP.To16() 用于 IPv4/IPv6 互转

func main() {
	// 普通 IPv4 地址
	ipv4 := net.ParseIP("192.168.1.100")

	// To4: 如果是 IPv4 映射的 IPv6 地址，提取原始 IPv4
	v4 := ipv4.To4()
	fmt.Printf("To4() = %v (nil? %v)\n", v4, v4 == nil)

	// To16: 返回 16 字节形式（IPv4 也扩展成 16 字节）
	v6 := ipv4.To16()
	fmt.Printf("To16() = %v\n", v6)

	// 纯 IPv6 地址
	ipv6 := net.ParseIP("2001:db8::1")
	fmt.Printf("IPv6 To4() = %v (应该是 nil，因为这不是 IPv4 映射地址)\n", ipv6.To4())
	fmt.Printf("IPv6 To16() = %v\n", ipv6.To16())

	// IPv4 映射的 IPv6 地址（::ffff:192.168.1.100）
	mappedIPv6 := net.ParseIP("::ffff:192.168.1.100")
	v4FromMapped := mappedIPv6.To4()
	fmt.Printf("IPv4映射地址 To4() = %v (提取出原始 IPv4)\n", v4FromMapped)
}

 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

package main

import (
	"fmt"
	"net"
)

// ParseCIDR 解析 "IP/前缀长度" 格式的网段
// 返回：网络地址（IP）、子网掩码（IPMask）、错误

func main() {
	// 解析常见的 /24 网段
	ip, ipNet, err := net.ParseCIDR("192.168.1.0/24")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}

	fmt.Printf("网络地址: %v\n", ip)        // 解析出的 IP（可能不带掩码信息）
	fmt.Printf("完整网段: %v\n", ipNet)     // 包含网络地址和掩码
	fmt.Printf("网络地址: %v\n", ipNet.IP) // 网络地址
	fmt.Printf("子网掩码: %v\n", ipNet.Mask) // 子网掩码（255.255.255.0）

	// 检查一个 IP 是否在网段内
	testIPs := []string{"192.168.1.1", "192.168.2.1", "192.168.1.254"}
	for _, testIP := range testIPs {
		ip := net.ParseIP(testIP)
		contains := ipNet.Contains(ip)
		fmt.Printf("  %s 在网段内? %v\n", testIP, contains)
	}

	fmt.Println("")

	// 解析 /16 网段
	_, ipNet16, _ := net.ParseCIDR("10.0.0.0/8")
	fmt.Printf("网段 %v 包含 %d 个地址\n", ipNet16, 1<<uint(32-ipNet16.Mask.Size()))
}

 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

package main

import (
	"fmt"
	"net/netip"
)

// net/netip 从 Go 1.18 开始引入
// 是处理 IP 地址的现代方式，比 net.IP 更轻量、更安全

func main() {
	fmt.Println("net/netip: 现代化 IP 地址处理")
	fmt.Println("特点：零值可用、固定大小、可以直接比较")

	// netip.Addr 的零值
	var addr netip.Addr
	fmt.Printf("零值 addr: %v, 是否有效: %v\n", addr, addr.IsValid())

	// 从字符串解析
	addr, err := netip.ParseAddr("192.168.1.1")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}
	fmt.Printf("解析成功: %v, Is4: %v, Is6: %v\n", addr, addr.Is4(), addr.Is6())

	// netip.AddrPort：IP + 端口
	ap, err := netip.ParseAddrPort("192.168.1.1:8080")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}
	fmt.Printf("AddrPort: %v, Addr: %v, Port: %v\n", ap, ap.Addr(), ap.Port())
}

 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

package main

import (
	"fmt"
	"net/netip"
)

// netip.Addr vs net.IP 对比

func main() {
	// 旧方式 net.IP 的问题
	ip1 := net.ParseIP("192.168.1.1")
	ip2 := net.ParseIP("192.168.1.1")
	fmt.Printf("net.IP 方式:\n")
	fmt.Printf("  ip1 == ip2: %v (注意：需要用 ip1.String() == ip2.String() 才能正确比较！)\n", ip1 == ip2)
	fmt.Printf("  ip1.String() == ip2.String(): %v\n", ip1.String() == ip2.String())

	// 新方式 net/netip
	fmt.Printf("\nnet/netip 方式:\n")
	addr1, _ := netip.ParseAddr("192.168.1.1")
	addr2, _ := netip.ParseAddr("192.168.1.1")
	fmt.Printf("  addr1 == addr2: %v (直接比较！)\n", addr1 == addr2)

	// 零值可用
	var zeroAddr netip.Addr
	fmt.Printf("\n零值测试:\n")
	fmt.Printf("  var zeroAddr netip.Addr, IsValid: %v\n", zeroAddr.IsValid())
	fmt.Printf("  addr1.IsValid: %v\n", addr1.IsValid())

	// 大小对比
	fmt.Printf("\n类型大小:\n")
	_ = ip1 // 切片，有额外头部
	fmt.Printf("  net.IP (切片): 切片头 + 4/16 字节（GC 有额外开销）\n")
	fmt.Printf("  netip.Addr: 固定 16 字节（无 GC 压力）\n")

	// AddrPort 组合
	addrPort, _ := netip.ParseAddrPort("10.0.0.1:443")
	fmt.Printf("\nAddrPort 示例: %v\n", addrPort)
	fmt.Printf("  Addr: %v\n", addrPort.Addr())
	fmt.Printf("  Port: %v\n", addrPort.Port())
	fmt.Printf("  String: %s\n", addrPort.String())
}

 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

package main

import (
	"fmt"
	"net/netip"
)

// netip.ParseAddr 解析纯 IP 地址（不带端口）

func main() {
	// IPv4 解析
	ipv4, err := netip.ParseAddr("192.168.1.100")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}
	fmt.Printf("IPv4: %v, Is4: %v\n", ipv4, ipv4.Is4())

	// IPv6 解析
	ipv6, err := netip.ParseAddr("2001:db8::1")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}
	fmt.Printf("IPv6: %v, Is6: %v\n", ipv6, ipv6.Is6())

	// 无效格式
	invalid, err := netip.ParseAddr("这根本不是IP")
	if err != nil {
		fmt.Printf("'%s' 解析失败: %v (错误是好事，说明我们识别出来了)\n", invalid, err)
	}

	// 环回地址
	loopback, _ := netip.ParseAddr("127.0.0.1")
	fmt.Printf("环回地址: %v, IsLoopback: %v\n", loopback, loopback.IsLoopback())

	// 未指定地址（0.0.0.0 或 ::）
	unspecified, _ := netip.ParseAddr("0.0.0.0")
	fmt.Printf("未指定地址: %v, IsUnspecified: %v\n", unspecified, unspecified.IsUnspecified())
}

 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

package main

import (
	"fmt"
	"net/netip"
)

// netip.ParseAddrPort 解析 "IP:端口" 格式

func main() {
	// 标准格式
	ap, err := netip.ParseAddrPort("192.168.1.1:8080")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}
	fmt.Printf("AddrPort: %v\n", ap)
	fmt.Printf("  Addr: %v\n", ap.Addr())
	fmt.Printf("  Port: %v\n", ap.Port())

	// IPv6 + 端口（注意 IPv6 两端的方括号）
	ap6, _ := netip.ParseAddrPort("[::1]:443")
	fmt.Printf("IPv6 AddrPort: %v\n", ap6)

	// 端口为零
	apZero, _ := netip.ParseAddrPort("192.168.1.1:0")
	fmt.Printf("端口为零: %v\n", apZero)

	// 无效情况
	_, err = netip.ParseAddrPort("192.168.1.1") // 缺少端口
	fmt.Printf("缺少端口: %v\n", err)

	_, err = netip.ParseAddrPort(":8080") // 缺少 IP
	fmt.Printf("缺少 IP: %v\n", err)

	_, err = netip.ParseAddrPort("192.168.1.1:99999") // 端口超出范围
	fmt.Printf("端口超限: %v\n", err)
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupHost 通过域名查找 IP 地址列表
// 相当于系统调用 gethostbyname

func main() {
	// 解析常见域名
	domains := []string{
		"baidu.com",
		"google.com",
		"github.com",
		"localhost",  // 本机
	}

	for _, domain := range domains {
		ips, err := net.LookupHost(domain)
		if err != nil {
			fmt.Printf("%s -> 解析失败: %v\n", domain, err)
			continue
		}
		fmt.Printf("%s -> %v\n", domain, ips)
	}
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupIP 返回 IP 记录以及 TTL 信息
// 使用 net.Resolver 的 LookupIP 方法可以获取更详细的控制

func main() {
	// 使用默认解析器
	resolver := &net.Resolver{}
	ips, err := resolver.LookupIP(nil, "baidu.com")
	if err != nil {
		fmt.Printf("解析失败: %v\n", err)
		return
	}

	fmt.Printf("baidu.com 解析结果（共 %d 条）:\n", len(ips))
	for i, ip := range ips {
		fmt.Printf("  [%d] IP: %v, 类型: ", i, ip)
		if ip.To4() != nil {
			fmt.Println("IPv4")
		} else {
			fmt.Println("IPv6")
		}
	}

	// 直接用 net.LookupIP（内部也是用 net.Resolver）
	fmt.Println("\n使用 net.LookupIP:")
	directIPs, _ := net.LookupIP("github.com")
	for _, ip := range directIPs {
		fmt.Printf("  %v\n", ip)
	}
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupPTR 反向 DNS 查询：通过 IP 查找域名
// 常用于日志分析、邮件服务器验证（SPF/DKIM 等）

func main() {
	// 常见 DNS 服务商的 IP 反向查询
	testIPs := []string{
		"8.8.8.8",       // Google DNS
		"1.1.1.1",       // Cloudflare DNS
		"114.114.114.114", // 腾讯 DNS
		"127.0.0.1",     // 本地
	}

	for _, ipStr := range testIPs {
		names, err := net.LookupAddr(ipStr)
		if err != nil {
			fmt.Printf("%s -> 查询失败: %v\n", ipStr, err)
			continue
		}
		fmt.Printf("%s -> %v\n", ipStr, names)
	}
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupMX 查询邮件交换记录
// 用于确定邮件应该发到哪个服务器

func main() {
	domains := []string{"gmail.com", "163.com", "qq.com"}

	for _, domain := range domains {
		mxRecords, err := net.LookupMX(domain)
		if err != nil {
			fmt.Printf("%s MX 查询失败: %v\n", domain, err)
			continue
		}
		fmt.Printf("%s MX 记录:\n", domain)
		for _, mx := range mxRecords {
			fmt.Printf("  Host: %s, Preference: %d\n", mx.Host, mx.Pref)
		}
		fmt.Println()
	}
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupTXT 查询 TXT 记录
// 常用于 SPF、DKIM、DMARC 验证

func main() {
	// 微软常用域名的 TXT 记录（通常包含 SPF 信息）
	domains := []string{"microsoft.com", "google.com", "github.com"}

	for _, domain := range domains {
		txtRecords, err := net.LookupTXT(domain)
		if err != nil {
			fmt.Printf("%s TXT 查询失败: %v\n", domain, err)
			continue
		}
		fmt.Printf("%s TXT 记录:\n", domain)
		for _, txt := range txtRecords {
			// TXT 记录可能很长，通常会截断显示
			if len(txt) > 80 {
				fmt.Printf("  %s... (长度: %d)\n", txt[:80], len(txt))
			} else {
				fmt.Printf("  %s\n", txt)
			}
		}
		fmt.Println()
	}
}

 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

package main

import (
	"fmt"
	"net"
)

// LookupNS 查询域名服务器记录
// 告诉你管理这个域名的 DNS 服务器是谁

func main() {
	domains := []string{"baidu.com", "github.com", "cloudflare.com"}

	for _, domain := range domains {
		nsRecords, err := net.LookupNS(domain)
		if err != nil {
			fmt.Printf("%s NS 查询失败: %v\n", domain, err)
			continue
		}
		fmt.Printf("%s NS 记录:\n", domain)
		for _, ns := range nsRecords {
			fmt.Printf("  %s\n", ns.Host)
		}
		fmt.Println()
	}
}

 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

package main

import (
	"fmt"
	"io"
	"net"
	"time"
)

// Dial 连接指定的协议和地址
// 参数格式：network 和 address
// network 可以是："tcp", "tcp4", "tcp6", "udp", "udp4", "udp6", "ip", "ip6" 等

func main() {
	// 连接 TCP 服务（HTTP 服务器就是典型的 TCP 服务）
	// 使用 HTTP 默认端口 80
	conn, err := net.Dial("tcp", "baidu.com:80")
	if err != nil {
		fmt.Printf("连接失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("成功连接到 baidu.com:80 (TCP)")

	// 发送 HTTP 请求
	conn.SetDeadline(time.Now().Add(5 * time.Second)) // 5秒超时
	conn.Write([]byte("GET / HTTP/1.0\r\n\r\n"))       // 发送请求

	// 读取响应（只读一点）
	buf := make([]byte, 200)
	n, _ := io.ReadFull(conn, buf)
	fmt.Printf("收到 %d 字节:\n%s\n", n, string(buf[:n]))
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

// UDP 也可以 Dial，但 UDP 是无连接的
// Dial("udp", ...) 实际上是创建一个 UDP 客户端，可以向不同地址发送数据

func main() {
	// DNS 查询就是典型的 UDP
	// 这里用 8.8.8.8:53（Google DNS）做示例
	conn, err := net.Dial("udp", "8.8.8.8:53")
	if err != nil {
		fmt.Printf("连接失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("UDP 连接已创建（实际上是创建了 UDP 客户端）")

	// 设置超时
	conn.SetDeadline(time.Now().Add(3 * time.Second))

	// 注意：UDP 是无连接的，Write 不会失败
	// 但如果目标不存在，数据会丢失
	n, err := conn.Write([]byte("Hello UDP"))
	if err != nil {
		fmt.Printf("发送失败: %v\n", err)
		return
	}
	fmt.Printf("发送了 %d 字节\n", n)
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

// Dialer 提供了更丰富的拨号配置
// 包括：超时、Keep-alive、本地地址、绑定地址等

func main() {
	// 创建一个自定义的 Dialer
	dialer := &net.Dialer{
		Timeout:   5 * time.Second,  // 连接建立超时
		Deadline:  time.Now().Add(30 * time.Second), // 整体截止时间
		LocalAddr: nil,  // 本地地址，nil 表示自动选择
		// KeepAlive: -1, // 禁用 Keep-alive
	}

	// 使用 Dialer 拨号
	conn, err := dialer.Dial("tcp", "baidu.com:80")
	if err != nil {
		fmt.Printf("拨号失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("通过 Dialer 成功连接！")
	fmt.Printf("  远程地址: %v\n", conn.RemoteAddr())
	fmt.Printf("  本地地址: %v\n", conn.LocalAddr())

	// 测试网络延迟
	start := time.Now()
	conn.SetDeadline(time.Now().Add(2 * time.Second))
	_, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))
	if err != nil {
		fmt.Printf("写入失败: %v\n", err)
	} else {
		elapsed := time.Since(start)
		fmt.Printf("写入耗时: %v\n", elapsed)
	}
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

// 场景1：只设置连接超时
func dialWithTimeout() {
	dialer := &net.Dialer{Timeout: 3 * time.Second}
	conn, err := dialer.Dial("tcp", "192.168.1.1:80")
	if err != nil {
		fmt.Printf("3秒内无法连接: %v\n", err)
	} else {
		conn.Close()
	}
}

// 场景2：限制总操作时间
func dialWithDeadline() {
	dialer := &net.Dialer{
		Deadline: time.Now().Add(10 * time.Second), // 10秒内必须完成
	}
	conn, err := dialer.Dial("tcp", "slow-server:80")
	if err != nil {
		fmt.Printf("10秒内无法完成: %v\n", err)
	} else {
		conn.Close()
	}
}

// 场景3：指定本地端口
func dialWithLocalPort() {
	dialer := &net.Dialer{
		LocalAddr: &net.TCPAddr{Port: 18080}, // 使用本地 18080 端口
	}
	conn, err := dialer.Dial("tcp", "baidu.com:80")
	if err != nil {
		fmt.Printf("绑定本地端口失败: %v\n", err)
	} else {
		fmt.Printf("本地端口: %v\n", conn.LocalAddr())
		conn.Close()
	}
}

func main() {
	fmt.Println("Dialer 配置场景演示：")
	dialWithTimeout()
	dialWithDeadline()
	dialWithLocalPort()
}

 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

package main

import (
	"fmt"
	"net"
)

// Listener 接口是网络服务器的抽象
// 核心方法：
//   - Accept() (Conn, error)  - 等待并接受连接
//   - Close() error           - 关闭监听器
//   - Addr() Addr             - 返回监听地址

func main() {
	// 创建一个 TCP 监听器（下一节会详细讲）
	listener, err := net.Listen("tcp", ":18080")
	if err != nil {
		fmt.Printf("监听失败: %v\n", err)
		return
	}
	defer listener.Close()

	fmt.Printf("服务器监听中: %v\n", listener.Addr())

	// 注意：这里不实际等待连接，只是展示接口
	fmt.Println("\nListener 接口方法：")
	fmt.Println("  Accept() - 等待客户端连接，返回 Conn")
	fmt.Println("  Close()  - 关闭监听器")
	fmt.Println("  Addr()   - 获取监听地址")
}

 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

package main

import (
	"fmt"
	"net"
)

// Listen 创建指定协议和地址的监听器
// 格式：network:host:port 或简写为 :port

func main() {
	// 监听所有网络接口的 18080 端口
	listener, err := net.Listen("tcp", ":18080")
	if err != nil {
		fmt.Printf("监听失败: %v\n", err)
		return
	}
	defer listener.Close()

	fmt.Printf("TCP 服务器启动，监听 %v\n", listener.Addr())
	fmt.Println("等待客户端连接...")

	// 注意：这里是阻塞调用，如果 main 函数结束，监听会停止
	// 实际使用中应该用 goroutine 来处理
}

// 如果要真正运行，需要配合 Accept 使用
// 参考 20.16节的完整示例

 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

package main

import (
	"fmt"
	"net"
)

func main() {
	// 监听指定 IP 和端口
	_, _ = net.Listen("tcp", "192.168.1.100:8080")

	// 监听所有 IP 的指定端口
	_, _ = net.Listen("tcp", ":8080")

	// 监听 IPv6
	_, _ = net.Listen("tcp6", ":8080")

	// 监听 Unix 域套接字
	_, _ = net.Listen("unix", "/tmp/myapp.sock")

	// 查看监听地址
	listener, _ := net.Listen("tcp", ":0") // 0 表示让系统自动分配端口
	fmt.Printf("自动分配的端口: %v\n", listener.Addr())
	listener.Close()
}

 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

package main

import (
	"fmt"
	"log"
	"net"
	"time"
)

// Accept 等待并接受客户端连接
// 返回一个 Conn 对象，用于和客户端通信

func main() {
	// 创建监听器
	listener, err := net.Listen("tcp", ":18080")
	if err != nil {
		log.Fatalf("监听失败: %v", err)
	}
	defer listener.Close()

	fmt.Println("服务器启动，等待客户端连接...")

	// 设置超时，避免永久阻塞
	listener.(*net.TCPListener).SetDeadline(time.Now().Add(10 * time.Second))

	// 接受连接（会阻塞）
	conn, err := listener.Accept()
	if err != nil {
		fmt.Printf("接受连接失败或超时: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Printf("客户端已连接！\n")
	fmt.Printf("  远程地址: %v\n", conn.RemoteAddr())
	fmt.Printf("  本地地址: %v\n", conn.LocalAddr())
}

// 运行这个程序后，用以下命令测试：
//   Windows: telnet localhost 18080
//   Linux/Mac: nc localhost 18080
// 或者再运行一个 Go 程序作为客户端

 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

package main

import (
	"fmt"
	"io"
	"log"
	"net"
)

// 回显服务器：收到什么就返回什么
// 这是网络编程的 "Hello World"

func main() {
	listener, err := net.Listen("tcp", ":18080")
	if err != nil {
		log.Fatalf("监听失败: %v", err)
	}
	defer listener.Close()

	fmt.Println("回显服务器启动 :18080")
	fmt.Println("按 Ctrl+C 停止")

	for {
		// 等待连接
		conn, err := listener.Accept()
		if err != nil {
			fmt.Printf("接受失败: %v\n", err)
			continue
		}

		// 处理连接（并发处理）
		go handleConn(conn)
	}
}

func handleConn(conn net.Conn) {
	defer conn.Close()
	fmt.Printf("客户端连接: %v\n", conn.RemoteAddr())

	// 读取数据并回显
	buf := make([]byte, 1024)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if err != io.EOF {
				fmt.Printf("读取错误: %v\n", err)
			}
			fmt.Printf("客户端 %v 断开连接\n", conn.RemoteAddr())
			return
		}
		fmt.Printf("收到: %s", string(buf[:n]))

		// 回显
		_, err = conn.Write(buf[:n])
		if err != nil {
			fmt.Printf("写入错误: %v\n", err)
			return
		}
	}
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

// Conn 接口是网络连接的抽象
// 核心方法：
//   - Read(b []byte) (n int, err error)    - 读取数据
//   - Write(b []byte) (n int, err error)   - 写入数据
//   - Close() error                        - 关闭连接
//   - LocalAddr() Addr                      - 本地地址
//   - RemoteAddr() Addr                     - 远程地址
//   - SetDeadline(t time.Time) error       - 设置读写截止时间
//   - SetReadDeadline(t time.Time) error   - 设置读取截止时间
//   - SetWriteDeadline(t time.Time) error  - 设置写入截止时间

func main() {
	// 连接到自己（回环地址）
	conn, err := net.Dial("tcp", "127.0.0.1:18080")
	if err != nil {
		fmt.Printf("连接失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("连接已建立")
	fmt.Printf("本地: %v\n", conn.LocalAddr())
	fmt.Printf("远程: %v\n", conn.RemoteAddr())

	// 设置截止时间（防止阻塞）
	conn.SetDeadline(time.Now().Add(5 * time.Second))

	// 写入数据
	n, err := conn.Write([]byte("Hello!\n"))
	if err != nil {
		fmt.Printf("写入失败: %v\n", err)
		return
	}
	fmt.Printf("写入 %d 字节\n", n)

	// 读取响应
	buf := make([]byte, 1024)
	n, err = conn.Read(buf)
	if err != nil {
		fmt.Printf("读取失败: %v\n", err)
		return
	}
	fmt.Printf("读取 %d 字节: %s", n, string(buf[:n]))
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	conn, _ := net.Dial("tcp", "baidu.com:80")
	defer conn.Close()

	// 场景1：设置绝对时间
	conn.SetDeadline(time.Now().Add(2 * time.Second))
	fmt.Println("设置了 2 秒截止时间")

	// 场景2：读取超时
	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
	buf := make([]byte, 1)
	_, err := conn.Read(buf)
	if err != nil {
		fmt.Printf("读取超时: %v\n", err)
	}

	// 场景3：永不过期
	conn.SetDeadline(time.Time{}) // 零时间表示不设置截止时间

	// 场景4：重置已过期的截止时间
	conn.SetWriteDeadline(time.Now().Add(-1 * time.Second)) // -1秒 = 已经过期
	_, err = conn.Write([]byte("test"))
	fmt.Printf("写入已过期的截止时间: %v\n", err)
}

 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

package main

import (
	"fmt"
	"net"
	"time"
)

// UDP 的 "连接" 实际上是设置默认目标地址
// 之后的 Write/Read 会发送到/接收自这个地址

func main() {
	// 创建 UDP 客户端
	conn, err := net.Dial("udp", "8.8.8.8:53")
	if err != nil {
		fmt.Printf("创建 UDP 客户端失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("UDP 客户端已创建（8.8.8.8:53）")

	// 设置超时
	conn.SetDeadline(time.Now().Add(3 * time.Second))

	// 发送数据（DNS 查询包）
	// 这是一个简化的 DNS 查询，实际需要构造完整的 DNS 包
	query := []byte{
		0x00, 0x01, // ID
		0x01, 0x00, // Flags: 标准查询
		0x00, 0x01, // 问题数: 1
		0x00, 0x00, // 回答数: 0
		0x00, 0x00, // 权威数: 0
		0x00, 0x00, // 附加数: 0
		// 问题部分...
	}
	n, err := conn.Write(query)
	if err != nil {
		fmt.Printf("发送失败: %v\n", err)
		return
	}
	fmt.Printf("发送了 %d 字节\n", n)

	// 接收响应
	buf := make([]byte, 512)
	n, err = conn.Read(buf)
	if err != nil {
		fmt.Printf("接收失败: %v\n", err)
		return
	}
	fmt.Printf("收到 %d 字节响应\n", n)
}

 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

package main

import (
	"fmt"
	"log"
	"net"
)

// ListenUDP 创建 UDP 监听器

func main() {
	// 创建 UDP 监听器
	addr, err := net.ResolveUDPAddr("udp", ":18080")
	if err != nil {
		log.Fatalf("解析地址失败: %v", err)
	}

	conn, err := net.ListenUDP("udp", addr)
	if err != nil {
		log.Fatalf("监听失败: %v", err)
	}
	defer conn.Close()

	fmt.Printf("UDP 服务器监听 %v\n", conn.LocalAddr())

	// UDP 没有 Accept，直接 Read 即可
	buf := make([]byte, 1024)
	for {
		n, remoteAddr, err := conn.ReadFromUDP(buf) // 注意：返回发送者地址
		if err != nil {
			fmt.Printf("读取失败: %v\n", err)
			continue
		}
		fmt.Printf("收到来自 %v 的 %d 字节: %s\n", remoteAddr, n, string(buf[:n]))

		// 回复（UDP 可以向任意地址发送，不一定是刚才收到的地址）
		msg := []byte("Hello from UDP server!")
		_, err = conn.WriteToUDP(msg, remoteAddr)
		if err != nil {
			fmt.Printf("回复失败: %v\n", err)
		}
	}
}

 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

package main

import (
	"fmt"
	"net"
)

func main() {
	// UDP 读写方法对比

	// ReadFromUDP - 读取数据并获取发送者地址
	// addr, data, err := conn.ReadFromUDP(buf)

	// WriteToUDP - 向指定地址发送数据
	// n, err := conn.WriteToUDP(data, addr)

	// 也可以用 Conn 的方法（但不知道发送者地址）
	// n, err := conn.Read(buf)
	// n, err := conn.Write(data)

	conn, _ := net.ListenUDP("udp", &net.UDPAddr{Port: 18081})
	defer conn.Close()

	fmt.Println("ReadFromUDP vs Read 对比：")
	fmt.Println("  ReadFromUDP: 知道数据是谁发的（返回 addr）")
	fmt.Println("  Read: 不知道谁发的，但可以用 Write 回复到默认地址")
	fmt.Println("  WriteToUDP: 主动向指定地址发，不需要先收到数据")
}

 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

package main

import (
	"fmt"
	"io"
	"log"
	"net"
	"os"
	"time"
)

// Unix 域套接字是本机进程间通信的高效方式
// 比 TCP 快，因为不需要网络协议栈

const socketPath = "/tmp/myapp.sock"

func main() {
	// 清理旧的套接字文件
	os.Remove(socketPath)

	// 创建 Unix 域套接字监听器
	listener, err := net.Listen("unix", socketPath)
	if err != nil {
		log.Fatalf("监听失败: %v", err)
	}
	defer listener.Close()
	defer os.Remove(socketPath)

	fmt.Println("Unix 域套接字服务器启动:", socketPath)

	// 等待连接
	conn, err := listener.Accept()
	if err != nil {
		log.Fatalf("接受连接失败: %v", err)
	}
	defer conn.Close()

	fmt.Println("客户端已连接")

	// 通信
	go readFromClient(conn)
	conn.SetDeadline(time.Now().Add(5 * time.Second))
	_, err = conn.Write([]byte("Hello from Unix socket server!\n"))
	if err != nil {
		fmt.Printf("写入失败: %v\n", err)
	}

	// 模拟客户端
	time.Sleep(100 * time.Millisecond)
}

func readFromClient(conn net.Conn) {
	defer conn.Close()
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil && err != io.EOF {
		fmt.Printf("读取失败: %v\n", err)
		return
	}
	fmt.Printf("收到: %s", string(buf[:n]))
}