【字节跳动青训营】后端笔记整理-2 | Go实践记录：猜谜游戏，在线词典，Socks5代理服务器-阿里云开发者社区

**本人是第六届字节跳动青训营（后端组）的成员。本文由博主本人整理自该营的日常学习实践，首发于稀土掘金：🔗Go实践记录：猜谜游戏，在线词典，Socks5代理服务器 | 青训营

我的go开发环境：

*本地IDE：GoLand 2023.1.2

*go：1.20.6

一、猜谜游戏

猜数字游戏也算是入门一门编程语言必写的程序了。通过这个程序，我们可以熟悉Go语言中的输入输出、流程控制与随机函数的调用。

1、生成随机数

在Go语言中，标准库math/rand下的一系列方法可以用来生成随机数。

math/rand库的官方文档：https://pkg.go.dev/math/rand

通过调用库中的rand.Intn(n)函数，可以生成一个 [0,n) 的随机整数：

//Go 1.20
package main

import (
    "fmt"
    "math/rand"
)

func main() {
    maxNum := 100
    for i := 0; i < 10; i++ {    //生成10个随机整数
       secretNum := rand.Intn(maxNum)        //每次生成的随机数在 [0,100)
       fmt.Println("随机数是", secretNum)
    }
}

注意：生成的这10个随机整数是否相同呢？

在我所使用的 Go 1.20.6 下，生成的10个随机数是各不相同的。也就是说，从 Go 1.20 开始，rand.Intn()生成的是真随机数，不需要设定Seed()。

依照官方的说法，math/rand 已弃用 rand.Seed(…) 全局函数，现在自动为全局随机数生成器Int生成一个随机值，并且顶级Seed函数已被弃用。因此，每次运行程序时会生成不同的随机数。

但如果在 Go 1.20 版本之前，如培训中王克纯老师演示的（Go 1.18），在调用rand.Intn()之前必须先通过 rand.Seed()设置随机数种子，这样才能让每次运行生成的随机数值不同，否则，由于随机数种子固定，每次运行生成的随机数也是固定的一个值，并不“随机”。

通常，用时间戳来作为随机数的种子。（这一点特性和C语言的rand()是类似的。）

//Go 1.20 之前

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    secretNumber := rand.Intn(maxNum)
    fmt.Println("The secret number is ", secretNumber)
}

2、读取用户输入

这里直接用 fmt.Scan() 来读取用户的输入。

fmt.Scan() 函数用于从标准输入中读取数据，并根据提供的格式字符串将输入解析为相应的变量。这个函数会一直等待用户输入，直到按下回车键，并尝试将输入解析为指定的变量类型：

package main

import (
        "fmt"
)

func main() {
        var num int
        fmt.Print("请输入一个整数: ")
        _, err := fmt.Scan(&num)
        if err != nil {
                fmt.Println("输入错误:", err)
                return
        }
        fmt.Println("您输入的整数是:", num)
}

在这个示例中，fmt.Scan(&num) 会等待用户输入，并将输入解析为整数，并将其存储到 num 变量中。如果输入无法解析为整数，将会返回错误。

注意，fmt.Scan() 函数需要提供变量的地址作为参数，以便将解析后的值存储到变量中。也可以在 fmt.Scan() 中使用格式字符串来匹配特定的输入格式，以及处理多个变量的读取。

通过 fmt.Scan() 完善猜数字的代码：

maxNum := 100
secretNum := rand.Intn(maxNum)
fmt.Println("随机数是", secretNum)

fmt.Println("请输入你猜测的数字:>")
var guess int
_, err := fmt.Scan(&guess)
if err != nil {
    fmt.Println("输入出错！", err)
    return
}

3、实现逻辑判断与循环游戏

加上 if-else 对输入的 guess 与随机数 secretNum 进行值的校验，来得出用户是否猜中数字；加上循环，实现多次游戏。这样，猜数字游戏的程序就完成了。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    maxNum := 100
    secretNum := rand.Intn(maxNum)
    //fmt.Println("随机数是", secretNum)

    for {
       fmt.Println("请输入你猜测的数字:>")
       var guess int
       _, err := fmt.Scan(&guess)
       if err != nil {
          fmt.Println("输入出错！", err)
          continue    //输入出错不能直接退出程序，而是进入下一次输入
       }

       if guess > secretNum {
          fmt.Println("猜大了！")
       } else if guess < secretNum {
          fmt.Println("猜小了！")
       } else {
          fmt.Println("恭喜你！猜中了！")
          break
       }
    }
}

二、在线词典

第二个案例是一个命令行词典。效果是输入一个单词，命令行中会显示这个单词的发音和注释。

原理是调用第三方的API去查询结果，并且其打印出来。

实现这个程序的关键在于，如何用Go语言发送HTTP请求和解析JSON。

1、抓包

以彩云小译为例：https://fanyi.caiyunapp.com/#/

分析这个请求：

2、代码自动生成

我们要实现在Golang里发送这个请求。

但这个请求很复杂，直接用代码来构造很麻烦，所以我们可以用另一种简单的方式来生成请求。

右键浏览器中的请求：

点击 Copy as cURL(bash) 后，打开这个网址：https://curlconverter.com/go/

把刚才复制的东西粘贴进去，自动会生成响应的请求代码：

将这些代码复制到Goland：

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "strings"
)

func main() {
    client := &http.Client{}
    var data = strings.NewReader(`{"trans_type":"en2zh","source":"hello"}`)
    req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
    if err != nil {
       log.Fatal(err)
    }
    req.Header.Set("authority", "api.interpreter.caiyunai.com")
    req.Header.Set("accept", "application/json, text/plain, */*")
    req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
    req.Header.Set("app-name", "xy")
    req.Header.Set("cache-control", "no-cache")
    req.Header.Set("content-type", "application/json;charset=UTF-8")
    req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")
    req.Header.Set("origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("os-type", "web")
    req.Header.Set("os-version", "")
    req.Header.Set("pragma", "no-cache")
    req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    req.Header.Set("sec-fetch-dest", "empty")
    req.Header.Set("sec-fetch-mode", "cors")
    req.Header.Set("sec-fetch-site", "cross-site")
    req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")
    req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
    resp, err := client.Do(req)
    if err != nil {
       log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.ReadAll(resp.Body)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Printf("%s\n", bodyText)
}

代码解读：

这里特别解释一下上图中第40行的 defer 关键字。

在 Go 语言中，defer 是一个用于延迟函数调用执行的关键字。通过使用 defer，可以在函数返回之前（无论这个函数是正常结束还是发生了异常），推迟某个函数的执行。这在编写代码时可以很有用，特别是在需要确保资源释放或清理操作的情况下。

defer 语句的语法是：

defer functionCall(arguments)

当在一个函数内部使用 defer 时，被推迟执行的函数调用会被添加到一个栈中，而不会立即执行。在函数执行完毕并即将返回之前，栈中的函数调用会按照逆序执行。因此，如果有多个 defer 语句，它们会按照后进先出（LIFO）的顺序执行，即最后一个推迟的函数调用会最先执行，而最早的推迟的函数调用会最后执行。

以下示例演示了有三个 defer 的情况：

package main

import "fmt"

func main() {
    defer fmt.Println("第一个defer")
    defer fmt.Println("第二个defer")
    defer fmt.Println("第三个defer")
    fmt.Println("正常的函数调用")
}

在这个示例中，尽管 fmt.Println("正常的函数调用") 在代码中位于三个 defer 语句之前，但它会最先执行。然后，defer 语句会按照后进先出的顺序执行，所以先执行第三个 defer，然后是第二个 defer，最后是第一个 defer。这就是 defer 的执行顺序。

defer 的设计是为了在函数返回前执行一些清理工作，或者确保一些资源被正确释放。通过使用 defer，我们可以更方便地管理代码，并确保清理操作不会被遗漏。

运行自动生成得到的代码块，成功输出一大串JSON：

说明请求成功。

但是，这片请求代码是固定的，传入的data也是固定的 data = strings.NewReader(`{"trans_type":"en2zh","source":"hello"}`)

我们肯定希望用户能通过一个变量进行输入，想翻译什么单词，就翻译什么单词，而不是固定的只能输入JSON字符串。因此，我们要用到JSON序列化。

3、生成request body

如何进行JSON序列化？在上一篇文章中提到过：https://juejin.cn/post/7265577455208955938#heading-62

只需要构造一个结构体，让这个结构体的字段名称和JSON的结构一一对应，然后直接调用 json.Marshal() 即可。

因此这里，我们也需要构造出一个结构体，然后将结构体序列化，通过这样的方式，让data中的值是可变的：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
)

//构建结构体
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: "hello"}
    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("authority", "api.interpreter.caiyunai.com")
    req.Header.Set("accept", "application/json, text/plain, */*")
    req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
    req.Header.Set("app-name", "xy")
    req.Header.Set("cache-control", "no-cache")
    req.Header.Set("content-type", "application/json;charset=UTF-8")
    req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")
    req.Header.Set("origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("os-type", "web")
    req.Header.Set("os-version", "")
    req.Header.Set("pragma", "no-cache")
    req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    req.Header.Set("sec-fetch-dest", "empty")
    req.Header.Set("sec-fetch-mode", "cors")
    req.Header.Set("sec-fetch-site", "cross-site")
    req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")
    req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
    resp, err := client.Do(req)
    if err != nil {
       log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.ReadAll(resp.Body)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Printf("%s\n", bodyText)
}

上述代码中，手动将要翻译的类型（“en2zh”）和单词（“hello”）传入了结构体。

此时代码的运行结果应与一开始的代码运行结果完全相同。对请求的序列化的逻辑就完成了。

4、解析 response body

完成了请求的序列化后，我们还要进行响应的反序列化，这样才能得到结果。这我们要解析出这一堆响应，并且获取到其中的一些关键信息如"explanations"等。

如果是python或者js，返回的会是一个字典的结构，可以直接通过 [] 或 . 去取值。但是Go是一种强类型的语言，这种方式并不是最佳实践（虽然也可以做到）。

更常见的方式是和处理request body一样，写一个结构体，这个结构体的字段和返回的response是一一对应的。再把返回的 json 反序列化（json.Unmarshal()）到结构体里面。

但是，我们看到，浏览器里返回的这个response结构非常复杂，手动一一创建结构体去对应显然不是好的做法。所以我们还是用代码生成的方式来实现。

打开这个工具网站：https://oktools.net/json2go

然后，把彩云小译界面的 response 的json粘贴进去：

点击“转换-嵌套”，就会生成一个结构体。（如果点击“转换-展开”，会生成独立的多个结构体。）

将生成的结构体代码粘贴到Goland中，将结构体改名为 DictResponse，然后修改最后处理响应的部分代码：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
)

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 {
    } `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      []interface{} `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 main() {
    client := &http.Client{}
    request := DictRequest{TransType: "en2zh", Source: "hello"}
    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("authority", "api.interpreter.caiyunai.com")
    req.Header.Set("accept", "application/json, text/plain, */*")
    req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
    req.Header.Set("app-name", "xy")
    req.Header.Set("cache-control", "no-cache")
    req.Header.Set("content-type", "application/json;charset=UTF-8")
    req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")
    req.Header.Set("origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("os-type", "web")
    req.Header.Set("os-version", "")
    req.Header.Set("pragma", "no-cache")
    req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    req.Header.Set("sec-fetch-dest", "empty")
    req.Header.Set("sec-fetch-mode", "cors")
    req.Header.Set("sec-fetch-site", "cross-site")
    req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")
    req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
    resp, err := client.Do(req)
    if err != nil {
       log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.ReadAll(resp.Body)
    if err != nil {
       log.Fatal(err)
    }
    
    //处理响应
    var dictResponse DictResponse
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
       log.Fatal(err)
    }
    //用 %#v 会以最详细的方式来打印结构体，包括结构体的名字和字段的名字
    fmt.Println("%#v\n", dictResponse)
}

我们需要从response中筛选出我们需要的信息：如“音标”，“解释”：

//fmt.Println("%#v\n", dictResponse)
fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En,
    "US:", dictResponse.Dictionary.Prons.EnUs)
for _, item := range dictResponse.Dictionary.Explanations {
    fmt.Println(item)
}

最终经过调整，完整的程序代码如下：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "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 {
    } `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 main() {
    //检查命令行传入的参数个数（第一个参数是程序名称本身，第二个参数是传入的单词，因此必须是两个参数）
    if len(os.Args) != 2 {
       fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)
       os.Exit(1)
    }
    //将第二个命令行参数也就是单词传给变量 word
    word := os.Args[1]
    query(word)
}

// 将程序的主要代码封装为query()函数，传入要翻译的单词
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("authority", "api.interpreter.caiyunai.com")
    req.Header.Set("accept", "application/json, text/plain, */*")
    req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
    req.Header.Set("app-name", "xy")
    req.Header.Set("cache-control", "no-cache")
    req.Header.Set("content-type", "application/json;charset=UTF-8")
    req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")
    req.Header.Set("origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("os-type", "web")
    req.Header.Set("os-version", "")
    req.Header.Set("pragma", "no-cache")
    req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    req.Header.Set("sec-fetch-dest", "empty")
    req.Header.Set("sec-fetch-mode", "cors")
    req.Header.Set("sec-fetch-site", "cross-site")
    req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")
    req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
    resp, err := client.Do(req)
    if err != nil {
       log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.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("%#v\n", dictResponse)
    fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En,
       "US:", dictResponse.Dictionary.Prons.EnUs)
    for _, item := range dictResponse.Dictionary.Explanations {
       fmt.Println(item)
    }
}

在命令行运行：输入要翻译的单词，可以调用接口实现在线翻译

三、SOCKS5代理服务器

对于大家来说，一提到代理服务器，第一想到的是翻墙。不过遗憾的是， socks5 协议它虽然是代理协议，但它并不能用来翻墙，它的协议都是明文传输。这个协议历史比较久远，诞生于互联网早期。

它的用途是，比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用是访问某些资源会很麻烦。socks5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻墙软件，最终暴露的也是一个 socks5 协议的端口。

在爬虫开发中，爬虫的爬取过程中很容易会遇到IP访问频率超过限制的问题，这个时候很多人就会去网上找一些代理IP池，这些代理IP池里面的很多代理的协议也就是 socks5。

**socks5协议的原理

正常浏览器访问一个网站，如果不经过代理服务器的话，会先和对方的网站建立 TCP 连接，然后三次握手。握手完之后发起 HTTP 请求，然后服务返回 HTTP 响应。

如果设置代理服务器之后，流程会变得复杂一些：

首先是浏览器和 socks5 代理建立 TCP 连接，代理再和真正的服务器建立 TCP 连接。这里可以分成四个阶段：

握手阶段

认证阶段

请求阶段

relay 阶段

第一个握手阶段，浏览器会向 socks5 代理发送请求，包的内容包括一个协议的版本号和支持的认证的种类。

socks5 服务器会选中一个认证方式，返回给浏览器。如果返回的是 00 的话就代表不需要认证，返回其他类型的话会开始认证流程。

第三个阶段是请求阶段，认证通过之后浏览器会 socks5 服务器发起请求。主要信息包括版本号，请求的类型。一般主要是 connection 请求，代表代理服务器要和某个域名或者某个 IP 地址某个端口建立 TCP 连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。

第四个阶段是 relay 阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边。实际代理服务器并不关心流量的细节，可以是 HTTP流量，也可以是其它 TCP 流量。

这个就是 socks5 协议的工作原理，接下来我们尝试去简单地实现它。

1、TCP echo server

在实现代理服务器之前，我们先实现一个简单的回显服务器，以测试我们的server写的对不对。

当运行时，此代码将创建一个简单的 TCP 服务器，监听在 127.0.0.1 的 1080 端口上，接受客户端连接并将客户端发送的数据原样返回。以下是逐句加注释的代码解释：

package main

import (
        "bufio"
        "log"
        "net"
)

func main() {
        // 在本地的 127.0.0.1:1080 地址上创建一个 TCP 服务器
        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
                }
                // 启动一个新的 goroutine 处理客户端连接
                go process(client)
        }
}

func process(conn net.Conn) {
        // 在函数退出时关闭客户端连接
        defer conn.Close()
        // 创建一个用于读取客户端数据的 bufio.Reader
        reader := bufio.NewReader(conn)
        for {
                // 从客户端读取一个字节
                b, err := reader.ReadByte()
                if err != nil {
                        break
                }
                // 将读取的字节原样发送回客户端
                _, err = conn.Write([]byte{b})
                if err != nil {
                        break
                }
        }
}

这是一个基本的 TCP 服务器，用于接受客户端连接并将接收到的数据返回给客户端。每当客户端发送一个字节，服务器会将相同的字节返回。

我们通过nc命令来进行测试。首先需要下载netcat，地址及教程：https://blog.csdn.net/BoomLee/article/details/102563472

安装配置完毕后，Goland中启动echo-server程序（直接启动或用命令go run echo-server.go）。启动后，另开一个cmd窗口，在其中输入nc命令：nc 127.0.0.1 1080

输入什么就显示什么，一个简单的回显服务器就搞定了。

2、认证阶段：auth

package main

import (
        "bufio"
        "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") // 在 127.0.0.1 的 1080 端口上创建 TCP 服务器
        if err != nil {
                panic(err)
        }
        for {
                client, err := server.Accept() // 接受客户端连接
                if err != nil {
                        log.Printf("Accept failed %v", err)
                        continue
                }
                go process(client) // 启动一个新的 goroutine 处理客户端连接
        }
}

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
        }
        log.Println("auth success")
}




// +----+----------+----------+
// |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
func auth(reader *bufio.Reader, conn net.Conn) (err error) {
        // 解析客户端发送的认证请求
        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)
        }
        log.Println("ver", ver, "method", method)

        // 发送认证响应给客户端
        // +----+--------+
        // |VER | METHOD |
        // +----+--------+
        // | 1  |   1    |
        // +----+--------+
        _, err = conn.Write([]byte{socks5Ver, 0x00}) // 发送无需认证的响应给客户端
        if err != nil {
                return fmt.Errorf("write failed:%w", err)
        }
        return nil
}

这段代码演示了一个简单的 SOCKS5 服务器，用于处理客户端的认证请求，并向客户端发送响应。现在我们用 curl 命令进行一下测试。首先还是一样，在Goland运行项目程序。然后在另一个终端执行curl命令：

curl --socks5 127.0.0.1:1080 -v http://www.qq.com

此时curl 命令肯定是不成功的，因为协议还没实现完成。但是看日志会发现， version和method 可以正常打印，说明当前我们的实现是正确的。

3、请求阶段

接下来我们开始做第三步：请求阶段。

我们试图读取到携带 URL 或 IP 地址+端口的包，然后把它打印出来。auth 函数和 connect 函数类似，同样在 process 里去调用。

再实现 connect 函数的代码。根据请求阶段的逻辑，浏览器会发送一个包，包里面包含如下6个字段：

VER 版本号，socks5的值为0x05

CMD 0x01表示CONNECT请求

RSV 保留字段，值为0x00

ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。

0x01表示IPv4地址，DST.ADDR为4个字节

0x03表示域名，DST.ADDR是一个可变长度的域名

DST.ADDR 一个可变长度的值

DST.PORT 目标端口，固定2个字节

接下来我们要挨个去把这6个字段读出来。

面这四个字段总共四个字节，我们可以一次性把它读出来。创建一个长度为4的缓冲区，然后用io.ReadFull()把它整个填充满。

//connect()

buf := make([]byte, 4)
_, err = io.ReadFull(reader, buf)
if err != nil {
    return fmt.Errorf("read header failed:%w", err)
}

这样就能一次性读取到前面4个字段，它们是定长的。对于每个字段，都要验证合法性：

//connect()

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")
}

最后还有两个字节是 port ，我们读取它，然后按协议规定的大端字节序转换成数字。

由于上面的 buffer 已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice ，长度是2，用于读取，这样的话最多会只读两个字节回来。接下来我们把这个地址和端口打印出来用于调试。

//connect()

_, err = io.ReadFull(reader, buf[:2])
if err != nil {
    return fmt.Errorf("read port failed:%w", err)
}
port := binary.BigEndian.Uint16(buf[:2])

log.Println("dial", addr, port)

收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用：

运行测试：虽然还没有完全成功，但是能够打印出IP地址和端口号了，说明实验还是成功的。

4、relay阶段

直接用 net.Dial 建立一个 TCP 连接。建立完连接之后，同样要加一个 defer 来关闭连接。

接下来需要建立浏览器和下游服务器的双向数据转发。标准库的 io.Copy 可以实现一个单向数据转发。完成双向转发还需启动两个 goroutinue。

完整代码如下

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

    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
}

到此，socks5代理服务器就实现完成了。

也可以在浏览器中进行测试。Chrome浏览器只需安装SwitchyOmega插件：

可以在浏览器里面再测试一下，在插件中新建一个情景模式，代理服务器选 socks5，端口 1080 ，保存并启用。此时你正常地访问其它网站，代理服务器这边会显示出浏览器版本的域名和端口。

至此，Go语言入门的三个实战项目就完成了。

【字节跳动青训营】后端笔记整理-2 | Go实践记录：猜谜游戏，在线词典，Socks5代理服务器

一、猜谜游戏

2、读取用户输入

3、实现逻辑判断与循环游戏

二、在线词典

1、抓包

2、代码自动生成

三、SOCKS5代理服务器

2、认证阶段：auth

热门文章

最新文章

相关课程

相关电子书

相关实验场景