青训营X豆包MarsCode 技术训练营第一课|Go语言实战案例

碳铕卿
86 阅读15分钟

​

实战案例

​

内容整理自字节内部课--Go语言的实战案例,是基础语法学习后的三个小实践task，分别为猜数交互机，在线词典，Socket5代理服务器

内容繁多，主要从理解代码和整理核心重点的角度记录笔记

一、猜数交互器1.1 核心Go技能点1.2 完整代码如下：二、在线词典2.1 核心Go（or其他）技能点2.2 完整代码如下：三、Socket5代理服务器3.1 前言&基础3.2 echo3.2 正式实现3.2.1 Auth阶段3.2.2 请求阶段3.2.3 relay阶段四、总结

一、猜数交互器

主要功能：一个简单的程序，首先随机生成一个目标数，用户输入猜测值，系统返回猜测值相对目标值大or小，猜对时给予正确反馈。

主要目的在于进一步熟悉Go语法，并使用Go语言的标准输入输出。

1.1 核心Go技能点

  • 随机数获取

  • 标准输入/输出

     reader := bufio.NewReader(os.Stdin)     //初始化读取器，类似Scanner
 input, err := reader.ReadString('\n')   //读取到\n停止
 input = strings.Trim(input, "\r\n")     //字符串操作，去掉后缀

  • 循环写法

         //写出死循环，循环体内定义终止条件
     for {
         input, err := reader.ReadString('\n')
         if err != nil {
             fmt.Println("An error occured while reading input. Please try again", err)
             continue
         }
         input = strings.Trim(input, "\r\n")
 ​
         guess, err := strconv.Atoi(input)
         if err != nil {
             fmt.Println("Invalid input. Please enter an integer value")
             continue
         }
         fmt.Println("You guess is", guess)
         if guess > secretNumber {
             fmt.Println("Your guess is bigger than the secret number. Please try again")
         } else if guess < secretNumber {
             fmt.Println("Your guess is smaller than the secret number. Please try again")
         } else {
             fmt.Println("Correct, you Legend!")
             break
         }
     }

1.2 完整代码如下：

 package main
 ​
 import (
     "bufio"
     "fmt"
     "math/rand"
     "os"
     "strconv"
     "strings"
     "time"
 )
 ​
 func main() {
     maxNum := 100
     rand.Seed(time.Now().UnixNano())
     secretNumber := rand.Intn(maxNum)
     // fmt.Println("The secret number is ", secretNumber)
 ​
     fmt.Println("Please input your guess")
     reader := bufio.NewReader(os.Stdin)
     for {
         input, err := reader.ReadString('\n')
         if err != nil {
             fmt.Println("An error occured while reading input. Please try again", err)
             continue
         }
         input = strings.Trim(input, "\r\n")
 ​
         guess, err := strconv.Atoi(input)
         if err != nil {
             fmt.Println("Invalid input. Please enter an integer value")
             continue
         }
         fmt.Println("You guess is", guess)
         if guess > secretNumber {
             fmt.Println("Your guess is bigger than the secret number. Please try again")
         } else if guess < secretNumber {
             fmt.Println("Your guess is smaller than the secret number. Please try again")
         } else {
             fmt.Println("Correct, you Legend!")
             break
         }
     }
 }
 ​

二、在线词典

主要功能：借助翻译网站接口，用户输入一个英语词汇，返回该词的音标和释义。

主要目的在于学习Go语言如何与网址建立连接，发送http请求并解析返回值

2.1 核心Go（or其他）技能点

  • 需要编写程序（脚本）模拟某种访问操作时，需要在网站获取相关请求和返回值的详细信息（检查网页：Headers，Payload，Preview）

  • 可以在**curlconverter.com/#go**中将网页检查中获取的请求头转换为Go语言代码

  • 在Go语言中，建立客户端，向指定url定义请求，加入请求头，发送请求，接收返回值

         client := &http.Client{}  // 设立客户端实例
     var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`) //strings.NewReader函数接受一个字符串参数，并返回一个io.Reader接口的实现
     // 声明请求
     req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
     if err != nil {
         log.Fatal(err)
     }
     // 为请求设立请求头
     req.Header.Set("Connection", "keep-alive")
     // 省略中间部分请求头
     req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
     resp, err := client.Do(req)
     if err != nil {
         log.Fatal(err)
     }
     // 划重点，后面说
     defer resp.Body.Close()
     // 读取返回值，可能有更好的调整方案
     bodyText, err := ioutil.ReadAll(resp.Body)
     if err != nil {
         log.Fatal(err)
     }

  • 上一层的进一步优化，将输入做好结构化，以将结构体Marshal序列化的方式构建输入序列，注意Marshal()的返回值是一个字节切片 []byte，包含序列化后的JSON数据

     type DictRequest struct {
     TransType string `json:"trans_type"`
     Source    string `json:"source"`
     UserID    string `json:"user_id"`
 }
 ​
 func main() {
     client := &http.Client{}
     request := DictRequest{TransType: "en2zh", Source: "good"}
     buf, err := json.Marshal(request)
     if err != nil {
         log.Fatal(err)
     }
     var data = bytes.NewReader(buf)
     req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
     ...
     ...
     }

  • 解析返回的response body，Go语言的工程最佳实践是类似上一步的做法，定义结构体，将返回的JSON反序列化到结构体对象中，可以通过OKTools网站工具将网站检查中预览的返回值转换为结构体定义代码，最后执行反序列化操作，并且进一步可以获取指定数据

         defer resp.Body.Close()
     bodyText, err := ioutil.ReadAll(resp.Body)
     if err != nil {
         log.Fatal(err)
     }
     if resp.StatusCode != 200 {
         log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
     }
     var dictResponse DictResponse
     err = json.Unmarshal(bodyText, &dictResponse)
     if err != nil {
         log.Fatal(err)
     }
     fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
     for _, item := range dictResponse.Dictionary.Explanations {
         fmt.Println(item)
     }

2.2 完整代码如下：

 package main
 ​
 import (
     "bytes"
     "encoding/json"
     "fmt"
     "io/ioutil"
     "log"
     "net/http"
     "os"
 )
 ​
 type DictRequest struct {
     TransType string `json:"trans_type"`
     Source    string `json:"source"`
     UserID    string `json:"user_id"`
 }
 ​
 type DictResponse struct {
     Rc   int `json:"rc"`
     Wiki struct {
         KnownInLaguages int `json:"known_in_laguages"`
         Description     struct {
             Source string      `json:"source"`
             Target interface{} `json:"target"`
         } `json:"description"`
         ID   string `json:"id"`
         Item struct {
             Source string `json:"source"`
             Target string `json:"target"`
         } `json:"item"`
         ImageURL  string `json:"image_url"`
         IsSubject string `json:"is_subject"`
         Sitelink  string `json:"sitelink"`
     } `json:"wiki"`
     Dictionary struct {
         Prons struct {
             EnUs string `json:"en-us"`
             En   string `json:"en"`
         } `json:"prons"`
         Explanations []string      `json:"explanations"`
         Synonym      []string      `json:"synonym"`
         Antonym      []string      `json:"antonym"`
         WqxExample   [][]string    `json:"wqx_example"`
         Entry        string        `json:"entry"`
         Type         string        `json:"type"`
         Related      []interface{} `json:"related"`
         Source       string        `json:"source"`
     } `json:"dictionary"`
 }
 ​
 func query(word string) {
     client := &http.Client{}
     request := DictRequest{TransType: "en2zh", Source: word}
     buf, err := json.Marshal(request)
     if err != nil {
         log.Fatal(err)
     }
     var data = bytes.NewReader(buf)
     req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
     if err != nil {
         log.Fatal(err)
     }
     req.Header.Set("Connection", "keep-alive")
     req.Header.Set("DNT", "1")
     req.Header.Set("os-version", "")
     req.Header.Set("sec-ch-ua-mobile", "?0")
     req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
     req.Header.Set("app-name", "xy")
     req.Header.Set("Content-Type", "application/json;charset=UTF-8")
     req.Header.Set("Accept", "application/json, text/plain, */*")
     req.Header.Set("device-id", "")
     req.Header.Set("os-type", "web")
     req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
     req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
     req.Header.Set("Sec-Fetch-Site", "cross-site")
     req.Header.Set("Sec-Fetch-Mode", "cors")
     req.Header.Set("Sec-Fetch-Dest", "empty")
     req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
     req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
     req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
     resp, err := client.Do(req)
     if err != nil {
         log.Fatal(err)
     }
     defer resp.Body.Close()
     bodyText, err := ioutil.ReadAll(resp.Body)
     if err != nil {
         log.Fatal(err)
     }
     if resp.StatusCode != 200 {
         log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
     }
     var dictResponse DictResponse
     err = json.Unmarshal(bodyText, &dictResponse)
     if err != nil {
         log.Fatal(err)
     }
     fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
     for _, item := range dictResponse.Dictionary.Explanations {
         fmt.Println(item)
     }
 }
 ​
 func main() {
     if len(os.Args) != 2 {
         fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
 example: simpleDict hello
         `)
         os.Exit(1)
     }
     word := os.Args[1]
     query(word)
 }
 ​

三、Socket5代理服务器

3.1 前言&基础

主要功能：为本地浏览器请求设立代理服务器

该内容涉及部分计算机网络知识，本人尚未学习，只能根据老师的讲解初步理解代码含义

首先是基础计网知识：如图（图源来自王克纯老师PPT）

image-20241103204444381.png 即建立代理服务器后，一个完整的网络服务流程包括：（浏览器与代理服务器）握手阶段、代理服务器对浏览器认证（本案例不关注），浏览器向代理服务器发起请求，代理服务器向指定域名/IP地址建立TCP、收到对方的响应后会向浏览器返回一个响应，relay阶段、即数据的流转传送；我们就按照这个流程逐渐实现代码：

3.2 echo

首先书写一个简单样例程序

 package main
 ​
 import (
     "bufio"
     "log"
     "net"
 )
 ​
 func main() {
     server, err := net.Listen("tcp", "127.0.0.1:1080")
     if err != nil {
         panic(err)
     }
     for {
         client, err := server.Accept()
         if err != nil {
             log.Printf("Accept failed %v", err)
             continue
         }
         go process(client)
     }
 }
 ​
 func process(conn net.Conn) {
     defer conn.Close()
     reader := bufio.NewReader(conn)
     for {
         b, err := reader.ReadByte()
         if err != nil {
             break
         }
         _, err = conn.Write([]byte{b})
         if err != nil {
             break
         }
     }
 }
 ​

笔者累了，这里引用豆包MarsCode的解读：

当前的程序是一个简单的TCP服务器，它监听本地的1080端口，接受客户端的连接请求，并为每个连接启动一个新的goroutine来处理。处理逻辑是读取客户端发送的字节，并将其原样写回客户端，直到读取错误或客户端关闭连接。

以下是对程序的详细解读：

  1. 主函数main：

    func main() {
  server, err := net.Listen("tcp", "127.0.  0.1:1080")
  if err!= nil {
    panic(err)
  }
  for {
    client, err := server.Accept()
    if err!= nil {
      log.Printf("Accept failed %v", err)
      continue
    }
    go process(client)
  }
}

  • net.Listen("tcp", "127.0.0.1:1080")：创建一个TCP监听器，监听本地的1080端口。

  • for循环：不断接受客户端的连接请求。

  • server.Accept()：接受客户端的连接请求，如果接受失败，会记录错误并继续循环。

  • go process(client)：为每个客户端连接启动一个新的goroutine来处理，这样可以同时处理多个客户端请求。

  1. 处理函数process：

    func main() {
    server, err := net.Listen("tcp", "127.0.0.1:1080")
    if err!= nil {
        panic(err)
    }
    for {
        client, err := server.Accept()
        if err!= nil {
            log.Printf("Accept failed %v", err)
            continue
        }
        go process(client)
    }
}
  • defer conn.Close()：确保在函数结束时关闭客户端连接，释放资源。
  • bufio.NewReader(conn)：创建一个新的bufio.Reader，用于从客户端连接中读取数据。
  • for循环：不断读取客户端发送的字节，并将其原样写回客户端，直到读取错误或客户端关闭连接。
  • reader.ReadByte()：从bufio.Reader中读取一个字节。
  • conn.Write([]byte{b})：将读取的字节写回客户端连接。

总的来说，这个程序实现了一个简单的TCP回显服务器，它接受客户端的连接，读取客户端发送的数据，并将其原样返回给客户端。

3.2 正式实现

下面我们一次完成Auth阶段，请求阶段和relay阶段，这里引用老师的注记和MarsCode的解释

  • 完整代码：
package main

import (
	"bufio"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

func main() {
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
	for {
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		go process(client)
	}
}

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	err = connect(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
}

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+----------+----------+
	// |VER | NMETHODS | METHODS  |
	// +----+----------+----------+
	// | 1  |    1     | 1 to 255 |
	// +----+----------+----------+
	// VER: 协议版本，socks5为0x05
	// NMETHODS: 支持认证的方法数量
	// METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
	// X’00’ NO AUTHENTICATION REQUIRED
	// X’02’ USERNAME/PASSWORD

    
    //   先来编写 auth 函数的代码
	//	我们回忆一下认证阶段的逻辑，首先第一步的话，浏览器会给代理服务器发送一个包，然后这个包有三个字段，第一个字段，verion 也就是协议版本号,固定是5 第二个字段 methods，认证的方法数目 第三个字段 每个 method的编码，0代表不需要认证，2代表用户名密码认证
    //	我们先用 read bytes 米把版本号读出来，然后如果版本号不是sodet5的话直接返回报错，接下来我们再速取 method size，也是一个字节，然后我们需要去 make 一个相应长度的一个slice，用io.ReadFull川把它去填充进去
    //	写到这里，我们把获取到的版本号和认证方式打印一下，
	//	此时，代理服务器还需要返回-个response，返回包括两个字段，一个是 version 一个是 method，也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00

	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	method := make([]byte, methodSize)
	_, err = io.ReadFull(reader, method)
	if err != nil {
		return fmt.Errorf("read method failed:%w", err)
	}

	// +----+--------+
	// |VER | METHOD |
	// +----+--------+
	// | 1  |   1    |
	// +----+--------+
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05
	// CMD 0x01表示CONNECT请求
	// RSV 保留字段，值为0x00
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值
	// DST.PORT 目标端口，固定2个字节

	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd:%v", cmd)
	}
	addr := ""
	switch atyp {
	case atypeIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	case atypeHOST:
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read host failed:%w", err)
		}
		addr = string(host)
	case atypeIPV6:
		return errors.New("IPv6: no supported yet")
	default:
		return errors.New("invalid atyp")
	}
	_, err = io.ReadFull(reader, buf[:2])
	if err != nil {
		return fmt.Errorf("read port failed:%w", err)
	}
	port := binary.BigEndian.Uint16(buf[:2])

	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	if err != nil {
		return fmt.Errorf("dial dst failed:%w", err)
	}
	defer dest.Close()
	log.Println("dial", addr, port)

	// +----+-----+-------+------+----------+----------+
	// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER socks版本，这里为0x05
	// REP Relay field,内容取值如下 X’00’ succeeded
	// RSV 保留字段
	// ATYPE 地址类型
	// BND.ADDR 服务绑定的地址
	// BND.PORT 服务绑定的端口DST.PORT
	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()

	<-ctx.Done()
	return nil
}

3.2.1 Auth阶段

当前代码实现了 SOCKS5 协议中的认证（Authentication）部分。SOCKS5 是一种网络协议，它允许客户端通过代理服务器来访问网络资源。认证部分是在客户端和代理服务器之间建立连接时进行的，目的是验证客户端的身份和确定使用的认证方法。

以下是对代码的详细解释：

  1. 函数 auth:

    • 该函数负责处理客户端的认证请求。
    • 首先，它从 reader 中读取 1 个字节的数据，这个数据包含了 SOCKS5 协议的版本号（ver）。
    • 然后，它检查版本号是否为 socks5Ver（即 0x05），如果不是，它会返回相应的错误。
    • 接着，它从 reader 中读取 1 个字节的数据，这个数据包含了支持认证的方法数量（methodSize）。
    • 然后，它根据 methodSize 读取相应数量的字节，这些字节包含了支持的认证方法（method）。
    • 最后，它向客户端发送一个响应，表示使用的认证方法为 NO AUTHENTICATION REQUIRED（即 0x00）。

  2. 错误处理:

    • 在整个函数中，错误处理使用了 fmt.Errorf 来包装错误信息，这样可以提供更多的上下文信息。
    • 例如，在读取 ver 失败时，它会返回 fmt.Errorf("read ver failed:%w", err)，这样可以清楚地知道是在读取 ver 时发生了错误。

  3. 并发处理:

    • 由于代码中没有涉及到并发处理，所以这里没有相关的解释。

  4. 日志记录:

    • 代码中没有使用 log.Println 来记录日志，但是在实际应用中，可能会在错误处理时记录日志，以便跟踪和调试问题。

总的来说，这段代码实现了 SOCKS5 协议中的认证部分，包括协议解析、错误处理和认证方法的选择等功能。

3.2.2 请求阶段

当前代码实现了一个 SOCKS5 代理服务器的连接处理逻辑。SOCKS5 是一种网络协议，它允许客户端通过代理服务器来访问网络资源。以下是对代码的详细解释：

  1. 函数 connect:

    • 该函数负责处理客户端的连接请求。
    • 首先，它从 reader 中读取 4 个字节的数据，这些数据包含了 SOCKS5 协议的版本号、命令和目标地址类型。
    • 然后，它检查版本号是否为 socks5Ver（即 0x05），以及命令是否为 cmdBind（即 0x01）。如果不是，它会返回相应的错误。
    • 接着，它根据目标地址类型来解析目标地址和端口。如果是 IPv4 地址，它会读取 4 个字节的数据来构建地址；如果是域名，它会读取一个字节来获取域名长度，然后读取相应长度的域名数据；如果是 IPv6 地址，它会返回一个错误，因为当前代码不支持 IPv6。
    • 解析出目标地址和端口后，它会尝试通过 net.Dial 函数连接到目标服务器。如果连接失败，它会返回相应的错误。
    • 如果连接成功，它会向客户端发送一个响应，表示连接已经建立。这个响应包含了 SOCKS5 协议的版本号、成功的响应码、保留字段、地址类型和绑定的地址和端口。
    • 最后，它会启动两个 goroutine，分别用于将客户端的数据复制到目标服务器，以及将目标服务器的数据复制到客户端。这两个 goroutine 会在上下文 ctx 被取消时退出。

  2. 错误处理:

    • 在整个函数中，错误处理使用了 fmt.Errorf 来包装错误信息，这样可以提供更多的上下文信息。
    • 例如，在读取 header 失败时，它会返回 fmt.Errorf("read header failed:%w", err)，这样可以清楚地知道是在读取 header 时发生了错误。

  3. 并发处理:

    • 使用了 context.WithCancel 来创建一个可取消的上下文，这样可以在连接关闭或发生错误时，取消所有的 goroutine。
    • 启动了两个 goroutine 来处理数据的双向复制，这样可以实现并发的数据传输。

  4. 日志记录:

    • 使用了 log.Println 来记录连接的建立和目标地址信息，这样可以方便地跟踪服务器的运行状态。

总的来说，这段代码实现了一个简单的 SOCKS5 代理服务器的连接处理逻辑，包括协议解析、错误处理、并发处理和日志记录等功能。

3.2.3 relay阶段

程序中该阶段借助 io.Copy()方法实现，包含在了Connect中

	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	
 	...
	...
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()

	<-ctx.Done()

四、总结

针对每个程序，在项目实践中需要牢记的两点有：

  • 注意每个函数值的返回值都有error，需要正确编写处理代码
  • deter

在Go语言中，defer语句用于延迟函数的执行，直到包含该defer语句的函数执行完毕。这种机制通常用于确保资源（如文件、网络连接等）在不再需要时被正确释放，无论函数是如何退出的（正常返回或发生异常）。

在你提供的代码片段中：

defer resp.Body.Close()

这行代码的作用是确保在main函数执行完毕后，无论是否发生错误，resp.Body都会被关闭。这是因为http.Response的Body字段是一个io.ReadCloser接口，它需要在使用完毕后被关闭，以释放相关资源。

具体来说，defer语句的执行过程如下：

  1. 当resp, err := client.Do(req)执行完毕后，resp.Body的关闭操作被注册到一个栈中。
  2. 当main函数执行完毕时，或者在main函数中发生异常导致函数返回时，栈中的所有defer语句会按照后进先出（LIFO）的顺序执行。
  3. 在这个例子中，resp.Body.Close()会被执行，从而关闭HTTP响应的Body部分，释放相关资源。

这种机制可以避免资源泄露，并确保代码的健壮性。即使在函数执行过程中发生了异常，defer语句也会保证资源被正确释放。

  • 缓冲流
avatar
文章
阅读
粉丝