go 语言实战入门案例 ｜ 青训营

猜数字

第一个例子里面，我们会使用 Golang 来构建一个猜数字游戏。

在这个游戏里面，程序首先会生成一个介于 1 到 100 之间的随机整数，然后提示玩家进行猜测。玩家每次输入一个数字，程序会告诉玩家这个猜测的值是高于还是低于那个秘密的随机数，并且让玩家再次猜测。如果猜对了，就告诉玩家胜利并且退出程序。

package main

import (
	"fmt"
	"math/rand"
)

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

通过尝试可以发现，每次生成的随机数都是一样的。

通过查看文档，可知随机数的生成会使用到一个随机种子。

否则每一次都会生成相同的随机数序列。一般用启动的时间戳来初始化随机数种子。这里使用 time.now.unix 来初始化随机种子。

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

然后实现用户输入输出，并理解析成数字。

每个程序执行的时候都会打开几个文件，stdin stdout stderr 等，stdin 文件可以用 os.Stdin 来得到。然后直接操作这个文件很不方便，我们会用 bufio.NewReader 把一个文件转换成一个 reader 变量。

reader 变量上有用来操作流的操作，可以用它的 ReadString 方法读取一行。如果失败会打印错误并能退出。ReadString 返回的结果包含结尾的换行符，把它去掉再转换成数字。如果转换失败，我们同样打印错误，退出。

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 {
		// `reader` 变量上有用来操作流的操作，可以用它的 `ReadString` 方法读取一行。
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("An error occured while reading input. Please try again", err)
			continue
		}
		// `ReadString` 返回的结果包含结尾的换行符，把它去掉。
		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
		}
	}
}

命令行排版的词典

先看一下用到的 API ，以彩云科技提供的在线翻译为例。请打开彩云翻译的网页，然后右键检查打开浏览器的开发者工具。

此时我们点一下翻译按钮，浏览器会发送一系列请求，我们能很轻松地找到那个用来查询单词的请求。这是一个 HTTP 的 post 的请求。

请求头是一个 json 里面有两个字段，一个是代表你要你是从什么语言转化成什么语言， source 就是你要查询的单词。

API 的返回结果里面会有 Wiki 和 dictionary 两个字段。我们需要用的结果主要在dictionary.Explanations 字段里面。其他有些字段里面还包括音标等信息。

我们需要在 Golang 里面去发送这个请求。因为这个请求比较复杂，用代码构造很麻烦，实际上我们有一种非常简单的方式来生成代码，我们可以右键浏览器里面的 copy as curl。

copy 完成之后大家可以在终端粘贴一下 curl 命令，应该可以成功返回一大串 json。

然后打开一个代码转换网站： curlconverter.com/go/ 粘贴该 curl 请求，在右边的语言里面选 Golang 就能够看到一串很长的代码，我们直接把它 copy 到我们的编辑器里面。有几个 header 比较复杂，生成代码有转义导致的编译错误，删掉这几行即可。

我们来看一下这生成的代码。

package main

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

func main() {
	// 首先我们创建了一个 HTTP client，创建的时候可以指定很多参数，包括比如请求的超时是否使用 cookie 等。
	client := &http.Client{}
	// 我们用了 strings.NewReader 来把字符串转换成一个流。这样我们就成功构造了一个 HTTP request
	var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
	// 接下来是构造一个 HTTP 请求，这是一个 post 请求，然后会用到 HTTP.NewRequest  ，第一个参数是 http 方法 POST，第二个参数是 URL，最后一个参数是 body ，body 因为可能很大，为了支持流式发送，是一个只读流。
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	// 接下来我们需要对这个 HTTP request 来设置一堆 header。
	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")
	// 接下来我们把我们调用 client.do request ，就能得到 response
	resp, err := client.Do(req)
	// 如果请求失败的话，那么这个 error 会返回非 nil，会打印错误并且退出进程
	if err != nil {
		log.Fatal(err)
	}
	// 在golang里面，为了避免资源泄露，你需要加一个 defer 来手动关闭这个流，这个 defer 会在这个函数运行结束之后去执行。
	defer resp.Body.Close()
	// 接下来我们是用 ioutil.ReadAll 来读取这个流，能得到整个body。我们再用 print 打印出来。
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)
}

首先第 12 行我们创建了一个 HTTP client，创建的时候可以指定很多参数，包括比如请求的超时是否使用 cookie 等。接下来是构造一个 HTTP 请求，这是一个 post 请求，然后会用到 HTTP .NewRequest ，第一个参数是 http 方法 POST，第二个参数是 URL，最后一个参数是 body ，body 因为可能很大，为了支持流式发送，是一个只读流。我们用了 strings. NewReader 来把字符串转换成一个流。这样我们就成功构造了一个 HTTP request ，接下来我们需要对这个 HTTP request 来设置一堆 header。接下来我们把我们调用 client. Do request ，就能得到 response 如果请求失败的话，那么这个 error 会返回非 nil，会打印错误并且退出进程。Response 有它的 HTTP 状态码， response header 和 body。 Body 同样是一个流，在 golang 里面，为了避免资源泄露，你需要加一个 defer 来手动关闭这个流，这个 defer 会在这个函数运行结束之后去执行。接下来我们是用 ioutil. ReadAll 来读取这个流，能得到整个 body。我们再用 print 打印出来。

我们来运行生成的代码，能看到我们已经能够成功地发出请求，把返回的 JSON 打印出来。但是现在那个输入是固定的，我们是要从一个变量来输入，我们需要用到 JSON 序列化。

生成 request body

在 Golang 里面。我们需要生成一段 JSON ，常用的方式是我们先构造出来一个结构体，这个结构体和我们需要生成的 JSON 的结构是一一对应的

在这个case里面， 这个结构体会是这样子的，包含三个字段。我们再来定义一个变量，初始化每个结构体成员，再调用 JSON.marshaler 来得到这个序列化之后的字符串。 不同于之前这里是个字符串，我们这里是个字节数组。所以我们把 strings.newReader 改成 bytes 点 new ready 然后来构造那个 request 上的 body 接下来代码不变。然后我们就能成功地进入一个变量来发送 HTTP 请求。

这一步完成之后，可以再执行一遍，应该结果是完全不变的。

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)
// 在这个case里面， 这个结构体会是这样子的，包含三个字段。再来定义一个变量，初始化每个结构体成员。
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"}
	// 再调用 `JSON.marshaler` 来得到这个序列化之后的字符串
	buf, err := json.Marshal(request)
	if err != nil {
		log.Fatal(err)
	}
	// 不同于之前这里是个字符串，我们这里是个字节数组，把 strings.newReader 改成 bytes.NewReader 然后来构造那个 request 上的 body 接下来代码不变
	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)
	}
	fmt.Printf("%s\n", bodyText)
}

解析 response body

接下来我们要做的是把这个 response body 来解析出来。在 js/Python 这些脚本语言里面，body 是一个字典或者 map 的结构， 可以直接从里面取值。 但是golang是个强类型语言，这种做法并不是最佳实践。

更常用的方式是和 request 的一样，写一个结构体，把返回的 JSON 反序列化到结构体里面。但是我们在浏览器里面可以看到这个 API 返回的结构非常复杂，如果要一一定义结构体字段，非常繁琐并且容易出错。

此时有一个小技巧的是，网上有对应的代码生成工具，我们可以打开如下网站，把 json 字符串粘贴进去，这样我们就能够生成对应结构体。

oktools.net/json2go

在某些时刻，我们如果不需要对这个返回结果，做很多精细的操作，我们可以选择转换嵌套，能让生成的代码更加紧凑。

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"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 {
		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 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)
	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)
	}
	// 先定一个 response 结构体的对象
	var dictResponse DictResponse
	// 用 JSON.unmarshal 把 body 反序列化到 这个结构体里面，再试图打印出来，注意这里要用&
	err = json.Unmarshal(bodyText, &dictResponse)
	if err != nil {
		log.Fatal(err)
	}
	// 这里打印的时候使用了 `%#v` ，这样可以让打印出来的结果比较容易读
	fmt.Printf("%#v\n", dictResponse)
}

这样就得到了一个 response 结构体。接下来修改代码，先定一个 response 结构体的对象，然后用 JSON.unmarshal 把 body 反序列化到这个结构体里面，再试图打印出来。现在再运行一下，这里打印的时候使用了 %#v ，这样可以让打印出来的结果比较容易读。我们现在离最终版本已经很近了，接下来我们需要修改代码为打印 response 里面的特定字段。

打印结果

观察那个网页的 json 可以看出我们需要的结果是在 Dictionary.explanations. 我们用 for range 循环来迭代它，然后直接打印结构，参照一些词典的显示方式，我们可以在那个前面打印出这个单词和它的音标。这里有英式音标和美式音标。同时加一个 StatusCode 的反馈，否则如果出错的话，底下反序列化解析出来的就是空，不方便排查问题。

结构完善

把代码的主体改成一个 query 函数，查询的单词作为参数传递进来。然后我们写一个简单的 main 函数，这个 main 函数首先判断一下命令和参数的个数，如果它不是两个，那么我们就打印出错误信息，退出程序。 否则就获取到用户输入的单词，然后执行 query 函数。

完整代码如下所示：

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)
	// 观察那个网页的 json 可以看出我们需要的结果是在 Dictionary.explanations. 我们用 for range 循环来迭代它，然后直接打印结构
	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)
}

Socks 5 代理

介绍

socks5 协议它虽然是代理协议，但它并不能用来翻，它的协议都是明文传输。 这个协议历史比较久远，诞生于互联网早期。它的用途是， 比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦。socks5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻软件，最终暴露的也是一个 socks5 协议的端口。 例如爬，在爬取过程中很容易会遇到 IP 访问频率超过限制。这个时候很多人就会去网上找一些代理 IP 池，这些代理 IP 池里面的很多代理的协议就是 socks5。

先看一下最终写完的代理服务器的效果。启动程序，然后在浏览器里面配置使用这个代理，此时打开网页。代理服务器的日志，会打印出你访问的网站的域名或者 IP ，这说明我们的网络流量是通过这个代理服务器的。也能在命令行去测试我们的代理服务器。我们可以用 curl -socks5 + 代理服务器地址，后面加一个可访问的 URL，如果代理服务器工作正常的话，那么 curl 命令就会正常返回。

原理

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

如果设置代理服务器之后，流程会变得复杂一些。首先是浏览器和 socks5 代理建立 TCP 连接，代理再和真正的服务器建立 TCP 连接。这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、 relay 阶段。

• 第一个握手阶段，浏览器会向 socks 5 代理发送请求，包的内容包括一个协议的版本号，还有支持的认证的种类，socks 5 服务器会选中一个认证方式，返回给浏览器。如果返回的是 00 的话就代表不需要认证，返回其他类型的话会开始认证流程，这里我们就不对认证流程进行概述了。
• 第三个阶段是请求阶段，认证通过之后浏览器会对 socks 5 服务器发起请求。主要信息包括版本号，请求的类型，一般主要是 connection 请求，就代表代理服务器要和某个域名或者某个 IP 地址某个端口建立 TCP 连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。
• 第四个阶段是 relay 阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边。然后实际上代理服务器并不关心流量的细节，可以是 HTTP 流量，也可以是其它 TCP 流量。

TCP echo server

我们先在 go 里面写一个简单的 TCP echo server。为了方便测试， server 的工作逻辑很简单，你给他发送啥，他就回复啥，代码如下。

package main

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

func main() {
	// 首先在 main 函数里面先用 net.listen 去监听一个端口，会返回一个 server
	server, err := net.Listen("tcp", "127.0.0.1:10803")
	if err != nil {
		panic(err)
	}
	for {
		// 然后在一个死循环里面，每次去 accept 一个请求，成功就会返回一个连接
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		// 接下来的话我们在一个 process 函数里面去处理这个连接。
		// 这前面会有个 go 关键字，这个代表启动一个 goroutinue， 可以暂时类比为其他语言里面的启动一个子线程。只是这里的 goroutinue 的开销会比子线程要小很多，可以很轻松地处理上万的并发。
		go process(client)
	}
}
// 接下来是这个 process 函数的实现。
func process(conn net.Conn) {
	// 首先第一步的话会先加一个 defer connection.close()， defer 是 Golang 里面的一个语法，这一行的含义就是代表在这个函数退出的时候要把这个连接关掉，否则会有资源的泄露。
	defer conn.Close()
	// 用 bufio.NewReader 来创建一个带缓冲的只读流
	reader := bufio.NewReader(conn)
	for {
		// 带缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便是一个字节一个字节的读取，但是底层可能合并成几次大的读取操作。并且带缓冲的流会有更多的一些工具函数用来读取数据。
		// 可以简单地调用 readbyte 函数来读取单个字节。再把这一个字节写进去连接。
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
		_, err = conn.Write([]byte{b})
		if err != nil {
			break
		}
	}
}

我们来简单测试一下我们的第一个 TCP 服务器，然后测试会需要用到 nc 命令。如果没有的话可以进行安装，这里用 nc 127.0.0.1 10803，输入 timerring 然后服务器就会给你返回 timerring。 先运行代码

然后另开一个终端进行测试：

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")
	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)
	// 我们实现一个空的 auth 函数，在 process 函数里面调用，再来编写 auth 函数的代码。
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	log.Println("auth success")
}

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

	// 先用 read bytes 来把版本号读出来
	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	// 然后如果版本号不是 socket 5 的话直接返回报错
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	// 接下来我们再读取 method size ，也是一个字节。
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	// 然后需要我们去 make 一个相应长度的一个 slice ，用 io.ReadFull 把它去填充进去。
	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    |
	// +----+--------+
	// 此时，代理服务器还需要返回一个response， 返回包包括 两个字段，一个是 version 一个是 method，也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00。
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

我们回忆一下认证阶段的逻辑，首先第一步的话，浏览器会给代理服务器发送一个包，然后这个包有三个字段，

• 第一个字段， version 也就是协议版本号，固定是 5
• 第二个字段 methods，认证的方法数目
• 第三个字段每个 method 的编码， 0代表不需要认证， 2 代表用户名密码认证 我们用 curl 命令测试一下当前版本的效果。此时 curl 命令肯定是不成功的，因为我们的协议还没实现完成。

但是我们看日志会发现， version 和 method 可以正常打印，说明当前我们的实现是正确的。

请求阶段

接下来我们开始做第三步，实现请求阶段，我们试图读取到携带 URL 或者 IP 地址+端口的包，然后把它打印出来。

package main

import (
	"bufio"
	"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
	}
	// 我们实现一个和 auth 函数类似的 connect 函数，同样在 process 里面去调用。再来实现 connect 函数的代码。
	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) {
	// 我们来回忆一下请求阶段的逻辑。浏览器会发送一个包，包里面包含如下6个字段
	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05。version 版本号， 还是 5
	// CMD 0x01表示CONNECT请求。CMD 代表请求的类型，我们只支持 connection 请求，也就是让代理服务建立新的TCP连接。
	// RSV 保留字段，值为0x00，不理会。
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。可能是 IPV4 IPV6 或者域名。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值，这个地址的长度是根据 atype 的类型而不同的,port 端口号，两个字节, 我们需要逐个去读取这些字段。
	// DST.PORT 目标端口，固定2个字节

	// 后面这四个字段总共四个字节，我们可以一次性把它读出来。我们定义一个长度为 4 的 buffer 然后把它读满。
	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	// 读满之后，然后第0 个、第1个、第3个、分别是 version cmd 和 type
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	// version 需要判断是 socket 5
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	// cmd 需要判断是 1，这里cmdBind是在前面定义好的
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd:%v", cmd)
	}
	// 下面的 atype，可能是 ipv4 ，ipv6，或者是 host。
	addr := ""
	switch atyp {
	// 如果 IPV4 的话，我们再次读满这个 buffer，因为这个 buffer 长度刚好也是4个字节
	case atypeIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		// 然后逐个字节打印成 IP 地址的格式保存到 addr 变量。
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	// 如果是个 host 的话
	case atypeHOST:
		// 需要先读它的长度
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		// 再 make 一个相应长度的buf 填充它。
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read host failed:%w", err)
		}
		// 再转换成字符串保存到 addr 变量。
		addr = string(host)
	// IPV6 用得比较少，我们就暂时先不支持。
	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 ，我们读取它，然后按协议规定的大端字节序转换成数字。
	// 由于上面的 buffer 已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice ，长度是2用于读取，这样的话最多会只读两个字节回来。
	port := binary.BigEndian.Uint16(buf[:2])
	// 接下来我们把这个地址和端口打印出来用于调试。
	log.Println("dial", addr, port)
	// 收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用。

	// +----+-----+-------+------+----------+----------+
	// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER socks版本，这里为0x05，第一个是版本号还是 socket 5。
	// REP Relay field,内容取值如下 X'00' succeeded，第二个，就是返回的类型，这里是成功就返回0。
	// RSV 保留字段，第三个是保留字段填 0。
	// ATYPE 地址类型，第四个 atype 地址类型填 1。
	// BND.ADDR 服务绑定的地址，第五个，第六个暂时用不到，都填成 0。
	// BND.PORT 服务绑定的端口DST.PORT

	// 一共 4 + 4 + 2 个字节，后面6个字节都是 0 填充。
	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	return nil
}

现在我们来测试一下当前阶段的成果， 简单 curl 一下。

此时请求还是会失败，我们现在已经能看到正常打印出来访问的 IP 地址和端口，这说明我们当前的实现正常，这样我们就可以做最后一步，我们真正和这个端口建立连接，双向转发数据。

我们直接用 net.dial 建立一个 TCP 连接，建立完连接之后，我们同样要加一个 defer 来关闭连接。接下来需要建立浏览器和下游服务器的双向数据转发。

标准库的 io.copy 可以实现一个单向数据转发，双向转发的话，需要启动两个 goroutinue。

现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向 copy 出错的时候，再返回 connect 函数。这里可以使用到标准库里面的一个 context 机制，用 context 连 with cancel 来创建一个 context。

在最后等待 ctx.Done() ，只要 cancel 被调用， ctx.Done 就会立刻返回。然后在上面的两个 goroutinue 里面调用一次 cancel 即可。

完整代码

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)
	}
	// 现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向copy出错的时候，再返回 connect 函数。
	// 可以使用到标准库里面的一个 context 机制，用 context 连 with cancel 来创建一个context。
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// 然后在两个 goroutinue 里面 调用一次 cancel 即可。
	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()
	// 在最后等待 ctx.Done() ， 只要 cancel 被调用， ctx.Done就会立刻返回。
	<-ctx.Done()
	return nil
}

我们可以试着在浏览器里面再测试一下，在浏览器里面测试代理需要安装这个 switchomega 插件，然后里面新建一个情景模式，代理服务器选 socks 5，端口 1080 ，保存并启用。此时你应该还能够正常地访问网站，代理服务器这边会显示出浏览器版本的域名和端口。

学习路线推荐

参考：字节内部课 Go 语言原理与实践