^-^
【go语言】Golang网络编程
最近更新：2024-12-05   |   字数总计：4.3k   |   阅读估时：23分钟   |   阅读量：次
  1. Go网络编程
    1. TCP网络编程
      1. 案例：上传下载文件
    2. UDP网络编程
      1. 案例：简单收发
      2. 案例：DNS请求
    3. QUIC网络编程
      1. 案例：上传下载文件
    4. HTTP网络编程
      1. 案例：静态资源网站
      2. 案例：请求响应
      3. 案例：上传文件
    5. WebSocket网络编程
      1. 案例：websocket聊天

Go网络编程

TCP网络编程

案例：上传下载文件

  • client
    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
    package main

    import (
    	"flag"
    	"fmt"
    	"io"
    	"log"
    	"net"
    	"os"
    	"path"
    )

    // 上传
    const OP_UPLOAD = 1

    // 下载
    const OP_DOWNLOAD = 0

    var (
    	up       int
    	fileName string
    )

    const DOWNLOAD_DIR = "../download/"
    const SCOURCE_DIR = "../source-file/"

    func getCmdArgs() {
    	flag.IntVar(&up, "up", 1, "0 下载 ，1 上传")
    	flag.StringVar(&fileName, "file", "", "上传或下载的文件名称")
    	flag.Parse()
    }

    func main() {
    	getCmdArgs()
    	conn, err := net.Dial("tcp", "localhost:9090")
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer conn.Close()
    	_, fileName = path.Split(fileName)
    	isUp := byte(1)
    	if up != OP_UPLOAD {
    		isUp = byte(0)
    	}
    	bytes := make([]byte, 0, 512) // 长度为0，512容量
    	bytes = append(bytes, isUp)
    	bytes = append(bytes, byte(len(fileName)))
    	bytes = append(bytes, []byte(fileName)...)
    	fmt.Println(bytes)
    	// ！！！必须切到512大小，不然会被tcp底层从后面的包里面取数据重新组包到这里面，导致处理这个文件头的过程中漏读一部分数据
    	if _, err := conn.Write(bytes[:512]); err != nil {
    		log.Println(err)
    		return
    	}
    	if up == OP_UPLOAD {
    		// 发送文件
    		err := sendFile(conn, SCOURCE_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else if up == OP_DOWNLOAD {
    		// 接收文件
    		err := recvFile(conn, DOWNLOAD_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else {
    		return
    	}
    }

    func recvFile(conn net.Conn, filePath string) (err error) {
    	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	buf := make([]byte, 1024)
    	for {
    		n, err := conn.Read(buf)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		file.Write(buf[:n])
    	}
    	return nil
    }

    func sendFile(conn net.Conn, filePath string) (err error) {
    	src, err := os.Open(filePath)
    	if err != nil {
    		log.Println(err)
    		return err
    	}
    	defer src.Close()
    	buf := make([]byte, 1024)
    	for {
    		n, err := src.Read(buf)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		fmt.Println("读取字节数：", n)
    		nc, err := conn.Write(buf[:n])
    		if err != nil {
    			log.Println(err)
    			return err
    		}
    		fmt.Println("发送字节数：", nc)
    	}
    	return nil
    }

  • server
    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
    package main

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

    // 上传
    const OP_UPLOAD = 1

    // 下载
    const OP_DOWNLOAD = 0

    const UPLOAD_DIR = "../upload/"
    const SCOURCE_DIR = "../source-file/"

    func main() {
    	lis, err := net.Listen("tcp", "127.0.0.1:9090")
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer lis.Close()
    	log.Println("listen on:", lis.Addr().String())
    	for {
    		conn, err := lis.Accept()
    		if err != nil {
    			log.Println(err)
    			return
    		}
    		log.Println("new conn:", conn.RemoteAddr().String())
    		go handle(conn)
    	}
    }

    // 处理请求
    func handle(conn net.Conn) {
    	defer conn.Close()
    	bytes := make([]byte, 512)
    	_, err := conn.Read(bytes)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	op := int(bytes[0])
    	fileNameLen := int(bytes[1])
    	fileName := string(bytes[2 : 2+fileNameLen])
    	if op == OP_UPLOAD {
    		// 上传文件
    		err := recvFile(conn, UPLOAD_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else if op == OP_DOWNLOAD {
    		// 下载文件
    		err := sendFile(conn, SCOURCE_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	}
    }

    func recvFile(conn net.Conn, filePath string) (err error) {
    	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	buf := make([]byte, 2048)
    	for {
    		n, err := conn.Read(buf)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			log.Println("收到结束字节")
    			break
    		}
    		log.Println("收到字节数：", n)
    		file.Write(buf[:n])
    	}
    	return nil
    }

    func sendFile(conn net.Conn, filePath string) (err error) {
    	src, err := os.Open(filePath)
    	if err != nil {
    		log.Println(err)
    		return err
    	}
    	defer src.Close()
    	buf := make([]byte, 2048)
    	for {
    		n, err := src.Read(buf)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		conn.Write(buf[:n])
    	}
    	return nil
    }

UDP网络编程

案例：简单收发

  • server
    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 (
    	"flag"
    	"fmt"
    	"log"
    	"net"
    )

    var (
    	port = flag.Int("port", 8001, "")
    )

    func main() {
    	// 创建udp地址
    	udpaddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", *port))
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 监听地址
    	conn, err := net.ListenUDP("udp", udpaddr)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 无连接，直接处理
    	for {
    		buf := make([]byte, 512)
    		n, clientAddr, err := conn.ReadFromUDP(buf)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    		fmt.Printf("接收到数据：%s, 地址：%s\n", string(buf[:n]), clientAddr)
    		conn.WriteToUDP([]byte("success"), clientAddr)
    	}
    }
  • client
    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 (
    	"flag"
    	"fmt"
    	"log"
    	"net"
    	"os"
    )

    var (
    	addr = flag.String("addr", "127.0.0.1:8001", "")
    )

    func main() {
    	flag.Parse()
    	conn, err := net.Dial("udp", *addr)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer conn.Close()
    	go func() {
    		str := make([]byte, 512)
    		for {
    			n, err := os.Stdin.Read(str)
    			if err != nil {
    				log.Println(err)
    				return
    			}
    			conn.Write(str[:n])
    		}
    	}()
    	buf := make([]byte, 512)
    	for {
    		n, err := conn.Read(buf)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    		fmt.Println("收到回复：", string(buf[:n]))
    	}
    }

案例：DNS请求

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
170
171
172
173
174
175
176
177
178
179
180
package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"log"
	"net"
	"strings"
)

type DNSHeader struct {
	ID            uint16
	Flags         uint16
	Questions     uint16
	AnswerRRS     uint16
	AuthorityRRS  uint16
	AdditionalRRS uint16
}

func (header *DNSHeader) SetFlag(qr, opcode, aa, tc, rd, ra, rcode uint16) {
	header.Flags = qr<<15 + opcode<<11 + aa<<10 + tc<<9 + rd<<8 + ra<<7 + rcode
}

type Query struct {
	Type  uint16
	Class uint16
}

// 域名转字节切片
func domainToBytes(domain string) []byte {
	// 将域名解析成相应的字节数组
	// 通过.切分域名，将每一段的字节数及内容保存到切片
	// 具体结构：长度 + 内容，最后以0x00结尾
	var (
		buf      bytes.Buffer
		segments = strings.Split(domain, ".")
	)
	for _, s := range segments {
		binary.Write(&buf, binary.BigEndian, byte(len(s)))
		binary.Write(&buf, binary.BigEndian, []byte(s))
	}
	binary.Write(&buf, binary.BigEndian, byte(0x00))
	return buf.Bytes()
}

func DigDomain(dnsServerAddr, domain string) (queries, answers []string) {
	header := DNSHeader{}
	header.ID = 0xffff
	header.SetFlag(0, 0, 0, 0, 1, 0, 0)
	header.Questions = 1
	header.AnswerRRS = 0
	header.AuthorityRRS = 0
	header.AdditionalRRS = 0

	query := Query{}
	query.Type = 1
	query.Class = 1

	var (
		conn net.Conn
		err  error
		buf  bytes.Buffer
	)
	binary.Write(&buf, binary.BigEndian, header)
	binary.Write(&buf, binary.BigEndian, domainToBytes(domain))
	binary.Write(&buf, binary.BigEndian, query)

	if conn, err = net.Dial("udp", dnsServerAddr); err != nil {
		log.Println(err)
		return
	}
	defer conn.Close()
	if _, err = conn.Write(buf.Bytes()); err != nil {
		log.Println(err)
		return
	}
	bytes := make([]byte, 1024)
	n, err := conn.Read(bytes)
	if err != nil {
		log.Println(err)
		return
	}
	// fmt.Printf("% x \n", bytes[:n])
	return dNSResponseDecode(bytes[:n])
}

func dNSResponseDecode(res []byte) (queries, answers []string) {
	// res := []byte{255, 255, 129, 128, 0, 1, 0, 3, 0, 0, 0, 0, 3, 119, 119, 119, 5, 98, 97, 105, 100, 117, 3, 99, 111, 109, 0, 0, 1, 0, 1, 192, 12, 0, 5, 0, 1, 0, 0, 3, 31, 0, 18, 3, 119, 119, 119, 1, 97, 6, 115, 104, 105, 102, 101, 110, 3, 99, 111, 109, 0, 192, 43, 0, 1, 0, 1, 0, 0, 1, 47, 0, 4, 180, 101, 50, 242, 192, 43, 0, 1, 0, 1, 0, 0, 1, 47, 0, 4, 180, 101, 50, 188}
	header := res[:12]
	queryNum := uint16(header[4])<<8 + uint16(header[5])
	answerNum := uint16(header[6])<<8 + uint16(header[7])
	data := res[12:]
	index := 0
	queriesBytes := make([][]byte, queryNum)
	answerBytes := make([][]byte, answerNum)

	for i := 0; i < int(queryNum); i++ {
		start := index
		l := 0
		for {
			l = int(data[index])
			if l == 0 {
				break
			}
			index += 1 + l
		}
		queriesBytes[i] = data[start:index]
		index += 5
	}
	if answerNum != 0 {
		for i := 0; i < int(answerNum); i++ {
			start := index
			nums := 2 + 2 + 2 + 4 + 2
			dataLenIndex := start + nums - 2
			dataLen := int(uint16(data[dataLenIndex])<<8 + uint16(data[dataLenIndex+1]))
			index = start + nums + dataLen - 1
			answerBytes[i] = data[start:index]
			index += 1
		}
	}
	queries = make([]string, queryNum)
	for i, bytes := range queriesBytes {
		queries[i] = getQuery(bytes)
	}
	answers = make([]string, answerNum)
	for i, bytes := range answerBytes {
		answers[i] = getAnswer(bytes)
	}
	return queries, answers
}

func getQuery(queryBytes []byte) string {
	return getDomain(queryBytes)
}

func getDomain(domainBytes []byte) string {
	domain := ""
	index := 0
	l := 0
	for {
		if index >= len(domainBytes) {
			break
		}
		l = int(domainBytes[index])
		if l == 0 {
			break
		}
		if index+1+l > len(domainBytes) {
			domain += string(domainBytes[index+1:]) + "."
		} else {
			domain += string(domainBytes[index+1:index+1+l]) + "."
		}
		index += 1 + l
	}
	domain = strings.Trim(domain, ".")
	return domain
}

func getAnswer(answerBytes []byte) string {
	typ := uint16(answerBytes[2])<<8 + uint16(answerBytes[3])
	dataLenIndex := 2 + 2 + 2 + 4
	dataLen := int(uint16(answerBytes[dataLenIndex])<<8 + uint16(answerBytes[dataLenIndex+1]))
	address := answerBytes[dataLenIndex+2 : dataLenIndex+2+dataLen]
	if typ == 1 {
		// IP
		return fmt.Sprintf("%d.%d.%d.%d", address[0], address[1], address[2], address[3])
	} else if typ == 5 {
		// CNAME
		return getDomain(address)
	}
	return ""
}

func main() {
	dnsServerAddr := "114.114.114.114:53"
	domain := "www.baidu.com"
	fmt.Println(DigDomain(dnsServerAddr, domain))
    // [www.baidu.com] [www.a.shifen.com 180.101.50.188 180.101.50.242]
}

QUIC网络编程

  • quic是什么
    1. 有google设计提出，其设计目标是替代tcp成为http/3的数据传输层协议
    2. quic协议是基于udp的基础上进行封装的，其底层依旧是通过udp传输协议
  • 常用术语
    1. package数据包：quic协议中的一个完整的可处理的单元。可以封装在udp数据报文中，多个quic包可以封装在一个udp数据报文中。
    2. frame帧，quic数据包携带的数据的单位，一个包可以存放多个帧
    3. stream流，quic连接中有序的通道，一个quic连接可以同时携带多个流
    4. 连接id，quic连接的标识
  • 可靠性
    1. package头部携带conn id与package number，当数据包丢失时可通过该number精准重传
    2. frame头部携带有stream id与offset字段用于实现有序的字节流
  • 特点优势
    1. 必须使用tls加密通信
    2. 同时具备了tcp的可靠与udp的快速
    3. 协议实现不在内核，方便迭代，可定制化拥塞控制算法
    4. 具备多路复用、连接迁移、建立连接时间短等特性
  • 注意事项
    1. quic连接的关闭，不存在协商过程，任意一端关闭连接huo端关闭连接或关闭流都将直接关闭连接或流
    2. 在关闭连接或流之前，请确保数据已经传输完成，否则将导致数据的丢失
    3. stream.close关闭连接中的流；conn.CloseWithError(0, “”)关闭连接
  • 依赖安装
    1
    go get -u github.com/quic-go/quic-go@v0.33.0

案例：上传下载文件

  • 解决go1.19的依赖问题
    1
    2
    3
    4
    5
    6
    module quic-case

    go 1.19

    require github.com/quic-go/quic-go v0.33.0
    replace golang.org/x/crypto v0.29.0 => golang.org/x/crypto v0.20.0 # 替换掉这个依赖包，否则它会依赖go1.20的一个包
  • cert
    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
    package main

    import (
    	"crypto/rand"
    	"crypto/rsa"
    	"crypto/x509"
    	"crypto/x509/pkix"
    	"encoding/pem"
    	"log"
    	"math/big"
    	"os"
    	"time"
    )

    const CERT_PATH = "cert"

    func main() {
    	generateTLS()
    }

    func generateTLS() {
    	sn, _ := rand.Int(rand.Reader, big.NewInt(time.Now().Unix()))
    	// 创建x509证书模板
    	template := x509.Certificate{
    		SerialNumber: sn,
    		Subject:      pkix.Name{CommonName: "localhost"},
    		NotBefore:    time.Now(),
    		NotAfter:     time.Now().Add(365 * 24 * time.Hour),
    	}
    	// 生成rsa密钥对
    	key, err := rsa.GenerateKey(rand.Reader, 1024)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 根据模板和密钥对生成证书
    	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 将私钥保存到文件
    	privateKeyFile := CERT_PATH + "/private.pem"
    	file, err := os.OpenFile(privateKeyFile, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	keyBlock := &pem.Block{
    		Type:  "RSA PRIVATE KEY",
    		Bytes: x509.MarshalPKCS1PrivateKey(key),
    	}
    	err = pem.Encode(file, keyBlock)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 将证书保存到文件
    	certFile := CERT_PATH + "/cert.pem"
    	file, err = os.OpenFile(certFile, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	certBlock := &pem.Block{
    		Type:  "CERTIFICATE",
    		Bytes: certDER,
    	}
    	err = pem.Encode(file, certBlock)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    }

  • client
    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
    package main

    import (
    	"context"
    	"crypto/tls"
    	"flag"
    	"fmt"
    	"io"
    	"log"
    	"os"
    	"sync"

    	"github.com/quic-go/quic-go"
    )

    var (
    	up   = flag.Int("up", 0, "1表示上传，0表示下载")
    	addr = flag.String("addr", "localhost:4242", "")
    )

    const (
    	// 上传
    	OP_UPLOAD = 1
    	// 下载
    	OP_DOWNLOAD = 0
    	// 下载目录
    	DOWNLOAD_DIR = "../download/"
    	// 源文件目录
    	SOURCE_DIR = "../source-files/"
    )

    func main() {
    	log.SetFlags(log.LstdFlags | log.Llongfile)
    	flag.Parse()
    	tlsConfig := &tls.Config{
    		InsecureSkipVerify: true,
    		NextProtos:         []string{"quic"},
    	}
    	conn, err := quic.DialAddr(*addr, tlsConfig, &quic.Config{EnableDatagrams: true})
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	// 关闭连接前，确保数据已经全部发送完毕
    	defer conn.CloseWithError(0, "") // 直接defer会导致，我们只能确定我们的客户端的协程结束了，但是不能保证服务端已经接收完毕了，这样我们就触发了quic的陷阱，我们没有确认数据已经发送就关闭了流。解法：考虑确认包或者睡眠
    	files := getFiles(SOURCE_DIR)
    	wg := sync.WaitGroup{}
    	for i := 0; i < len(files); i++ {
    		wg.Add(1)
    		go func(fileName string) {
    			defer wg.Done()
    			handleFile(conn, fileName, *up)
    		}(files[i])
    	}
    	wg.Wait()
    }

    func getFiles(dir string) []string {
    	fs, err := os.ReadDir(dir)
    	if err != nil {
    		log.Println(err)
    	}
    	list := make([]string, 0)
    	for _, f := range fs {
    		if f.IsDir() {
    			continue
    		}
    		list = append(list, f.Name())
    	}
    	return list
    }

    func handleFile(conn quic.Connection, fileName string, up int) {
    	stream, err := conn.OpenStreamSync(context.Background())
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer stream.Close() // 这里也是，我们只能确认我们的发送完毕了，但是不能确认服务端接收完毕了，我们就关闭了流
    	fmt.Println("stream id:", stream.StreamID())
    	isUp := byte(1)
    	if up != OP_UPLOAD {
    		isUp = byte(0)
    	}
    	bytes := make([]byte, 0, 512)
    	bytes = append(bytes, isUp, byte(len(fileName)))
    	bytes = append(bytes, []byte(fileName)...)
    	if _, err := stream.Write(bytes[:512]); err != nil {
    		log.Println(err)
    		return
    	}
    	if up == OP_UPLOAD {
    		// 发送文件
    		err := sendFile(stream, SOURCE_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else if up == OP_DOWNLOAD {
    		// 接收文件
    		err := receFile(stream, DOWNLOAD_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else {
    		return
    	}
    }

    func receFile(stream quic.Stream, filePath string) (err error) {
    	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	bytes := make([]byte, 1024)
    	for {
    		n, err := stream.Read(bytes)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		file.Write(bytes[:n])
    	}
    	return nil
    }

    func sendFile(stream quic.Stream, filePath string) (err error) {
    	src, err := os.Open(filePath)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer src.Close()
    	bytes := make([]byte, 1024)
    	for {
    		n, err := src.Read(bytes)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		if _, err := stream.Write(bytes[:n]); err != nil {
    			log.Println(err)
    			return err
    		}
    	}
    	return nil
    }

  • server
    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
    package main

    import (
    	"context"
    	"crypto/tls"
    	"io"
    	"log"
    	"os"

    	"github.com/quic-go/quic-go"
    )

    const (
    	// 上传
    	OP_UPLOAD = 1
    	// 下载
    	OP_DOWNLOAD = 0
    	// 上传目录
    	UPLOAD_DIR = "../upload/"
    	// 源文件目录
    	SOURCE_DIR = "../source-files/"
    )

    func main() {
    	log.SetFlags(log.LstdFlags | log.Llongfile)
    	lis, err := quic.ListenAddr("127.0.0.1:4242", getTLSConfig(), &quic.Config{EnableDatagrams: true})
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer lis.Close()
    	for {
    		conn, err := lis.Accept(context.Background())
    		if err != nil {
    			log.Fatal(err)
    		}
    		log.Println(conn.RemoteAddr().String())
    		go handleConn(conn)
    	}
    }

    func getTLSConfig() *tls.Config {
    	tlsCert, err := tls.LoadX509KeyPair("../cert/cert.pem", "../cert/private.pem")
    	if err != nil {
    		log.Fatal(err)
    	}
    	return &tls.Config{
    		Certificates: []tls.Certificate{tlsCert},
    		NextProtos:   []string{"quic"},
    	}
    }

    func handleConn(conn quic.Connection) {
    	for {
    		stream, err := conn.AcceptStream(context.Background())
    		if err != nil {
    			log.Println(err)
    			break
    		}
    		go handleStream(stream)
    	}
    }

    func handleStream(stream quic.Stream) {
    	defer stream.Close()
    	bytes := make([]byte, 512)
    	_, err := stream.Read(bytes)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	op := int(bytes[0])
    	fileNameLen := int(bytes[1])
    	fileName := string(bytes[2 : 2+fileNameLen])
    	if op == OP_UPLOAD {
    		// 接收文件
    		err := receFile(stream, UPLOAD_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else if op == OP_DOWNLOAD {
    		// 发送文件
    		err := sendFile(stream, SOURCE_DIR+fileName)
    		if err != nil {
    			log.Println(err)
    			return
    		}
    	} else {

    	}
    }

    func receFile(stream quic.Stream, filePath string) (err error) {
    	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer file.Close()
    	bytes := make([]byte, 1024)
    	for {
    		n, err := stream.Read(bytes)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		file.Write(bytes[:n])
    	}
    	return nil
    }

    func sendFile(stream quic.Stream, filePath string) (err error) {
    	src, err := os.Open(filePath)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer src.Close()
    	bytes := make([]byte, 1024)
    	for {
    		n, err := src.Read(bytes)
    		if err != nil && err != io.EOF {
    			log.Println(err)
    			return err
    		}
    		if n == 0 {
    			break
    		}
    		if _, err := stream.Write(bytes[:n]); err != nil {
    			log.Println(err)
    			return err
    		}
    	}
    	return nil
    }

HTTP网络编程

  • http1.1、http2、http3

    1. http1.1 tcp协议 文本传输，tcp连接没有并发能力，频繁的创建连接和关闭连接
    2. http2 tcp协议 报头压缩，二进制传输，tcp多路复用，一个域名创建一个tcp连接
    3. http2 通过引入流和帧概念，实现多请求的并发。请求之间可以乱序发送和乱序相应。
    4. http3 quic协议，同一个物理连接上可以有多个独立的逻辑数据流，实现了数据流的单独传输，解决tcp中队头阻塞问题

  • 浏览器如何使用http3

    1. 首次请求通过http1.1或http2，当发现服务器支持http3那么之后的请求就以http3进行

  • main

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package main

    import (
    	"http-case/http/handler"
    	"net/http"

    	"github.com/quic-go/quic-go/http3"
    )

    func main() {
    	multiplexer := http.NewServeMux()
    	multiplexer.Handle("/static/", handler.StaticFileServer())
    	multiplexer.HandleFunc("/sum", handler.SumHandler)
    	multiplexer.HandleFunc("/upload", handler.UploadHandler)
    	go http.ListenAndServeTLS(":8889", "cert/cert.pem", "cert/private.pem", multiplexer) // http2

    	http.ListenAndServe(":8899", multiplexer) // http 1.1

    	// go http3.ListenAndServeQUIC() // 直接使用http3
    	go http3.ListenAndServe(":8999", "cert/cert.pem", "cert/private.pem", multiplexer) // 会先使用http1.1和http2进行协商

    }

案例：静态资源网站

1
2
3
4
5
6
7
8
package handler

import "net/http"

func StaticFileServer() http.Handler {
	return http.StripPrefix("/static/", http.FileServer(http.Dir("static")))
}

案例：请求响应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package handler

import (
	"fmt"
	"net/http"
	"strconv"
)

func SumHandler(w http.ResponseWriter, req *http.Request) {
	a := req.FormValue("a")
	b := req.FormValue("b")
	intA, _ := strconv.Atoi(a)
	intB, _ := strconv.Atoi(b)
	fmt.Fprintf(w, "a + b = %d", intA+intB)
}

案例：上传文件

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
package handler

import (
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

func UploadHandler(w http.ResponseWriter, req *http.Request) {
	// 上传单个文件
	// file, header, err := req.FormFile("files")
	// if err != nil {
	// 	http.Error(w, err.Error(), http.StatusInternalServerError)
	// 	return
	// }
	// err = saveFile(file, header.Filename)
	// if err != nil {
	// 	http.Error(w, err.Error(), http.StatusInternalServerError)
	// 	return
	// }
	// res := map[string]string{
	// 	"msg":       "上传文件成功",
	// 	"file_name": header.Filename,
	// }
	// bytes, _ := json.Marshal(res)
	// fmt.Fprintf(w, string(bytes))
	// return
	// 多个文件上传
	req.ParseMultipartForm(32 << 20)
	files := req.MultipartForm.File["files"]
	list := []string{}
	for _, fileHeader := range files {
		file, err := fileHeader.Open()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		err = saveFile(file, fileHeader.Filename)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		list = append(list, fileHeader.Filename)
	}
	res := map[string]interface{}{
		"msg":   "上传成功",
		"files": list,
	}
	bytes, _ := json.Marshal(res)
	fmt.Fprintf(w, string(bytes))
	return
}

func saveFile(file multipart.File, fileName string) error {
	filePath := "upload/" + fileName
	targetFile, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return err
	}
	defer targetFile.Close()
	_, err = io.Copy(targetFile, file)
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8">
        <title>title</title>
    </head>
    <body>
        hello world
        <form action="/upload" method="post" enctype="multipart/form-data">
            <label for="file">文件：</label>
            <input type="file" id="file" name="files" multiple ><br><br>
            <button>提交</button>
        </form>
    </body>
</html>

WebSocket网络编程

  • websocket
    1. 是一个持久化的协议，客户端和服务端通过握手后，建立一个持久化的连接，方便客户端与服务端双向通信
  • 解决问题
    1. 解决服务端无法主动向客户端推送消息的问题
  • 应用
    1. 需要服务器主动通知客户端的场景
    2. 聊天场景
  • 注意
    1. 服务端和客户端的websocket连接有可能中断，需要考虑重连接机制
  • 依赖安装
    1
    go get github.com/gorilla/websocket@v1.5.0

案例：websocket聊天

  • server
    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"
    	"log"
    	"net/http"

    	"github.com/gorilla/websocket"
    )

    func main() {
    	http.Handle("/", http.FileServer(http.Dir("www")))
    	http.Handle("/ws", new(wsHandler))
    	http.ListenAndServe(":8899", nil)
    }

    type wsHandler struct {
    }

    func (*wsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    	fmt.Println("call ws handler")
    	var upgrader = websocket.Upgrader{
    		CheckOrigin: func(r *http.Request) bool {
    			// 如有必要，此处添加跨域检查
    			return true
    		},
    	}
    	conn, err := upgrader.Upgrade(w, r, nil)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer conn.Close()
    	for {
    		msgType, msg, err := conn.ReadMessage()
    		if err != nil {
    			log.Println(err)
    			break
    		}
    		if msgType == websocket.CloseMessage {
    			conn.Close()
    			log.Println("连接关闭")
    			break
    		}
    		// 业务处理
    		fmt.Println(msgType, string(msg), err)
    		reply := []byte("服务器收到：")
    		reply = append(reply, msg...)
    		conn.WriteMessage(websocket.TextMessage, reply)
    	}
    }

  • client
    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
    <!DOCTYPE html>
    <html lang="en">
        <head>
            <meta charset="utf-8">
            <title>Title</title>
        </head>
        <body>
            <h1>hello world</h1>
            <div>
                <input id="tex_msg">
                <input type="button" value="发送" onclick="sendMsg()">
                <input type="button" value="关闭" onclick="closeConn()">
                <div>
                    <ul id="ul_msg">

                    </ul>
                </div>
            </div>
        </body>
        <script>
            let socket = new WebSocket("ws://134.175.250.62:8899/ws")
            function closeConn(){
                socket.close()
                addList("正在连接关闭。。")
            }
            socket.onopen = function(e){
                // socket.send("连接成功")
                addList("连接成功...")
            }
            socket.onmessage = function(e){
                let msg = e.data
                addList("服务器回复：" + msg)
            }
            socket.onclose = function(e){
                addList("连接关闭...")
            }
            socket.onerror = function(e){
                console.log(e)
                addList("连接发生错误...")
            }
            function addList(msg){
                let ele = document.createElement("li")
                ele.innerHTML = msg
                document.getElementById("ul_msg").appendChild(ele)
            }
            function sendMsg(){
                let msg = document.getElementById("tex_msg").value
                if ( msg == ""){
                    return
                }
                socket.send(msg)
                addList("客户端发送："+msg)
                document.getElementById("tex_msg").value = ""
            }
        </script>
    </html>
2024-12-03 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go语言】Golang单元测试与性能分析 下一篇：【go语言】Golang并发编程
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题