这是我参与「第五届青训营」笔记创作活动的第3天

Go 语言从入门到实操~

前言：

在学习了 Golang 基础后，本次课程通过三个实战案例：猜谜游戏、在线词典、SOCKS5 代理，带领我们从入门到实操，快速上手 Go 语言。

猜谜游戏

本案例是一个使用 Golang 实现的猜数字小游戏。游戏开始时会生成 0 ~ 100 的随机整数 $n$ ，每次玩家输入一个数字，程序会告诉玩家输入的数字是高于 $n$ 还是低于 $n$ ，并且告诉玩家继续进行猜测，如果猜对了的话就提示玩家胜利并退出程序。

版本迭代 - V1：

先来实现在屏幕上打印生成的随机数，代码如下：

package main

import (
   "fmt"
   "math/rand"
)

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

多运行几次会发现这个代码存在一个很离谱的问题，每次运行生成的随机数都是同一个！！

上面的代码使用了标准库中的 rand 包来生成随机数，查看官方文档可以发现我们生成的随机数值和随机数种子有关，一般用时间戳来初始化随机数种子。

版本迭代 - V2：

在代码中加入 rand.Seed() 函数来设置一个随机数种子，多运行几次查看结果。

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

这会每次运行都是不同的随机数了。

版本迭代 - V3：

接下来要实现用户的输入、输出，并解析成数字。读取用户的输入需要用到 I/O 流，涉及 os 与 bufio 两个包，将字符串解析成数字可以使用之前学过的 strconv 包中的方法来实现。

Go 语言从控制台读取用户输入的方法有很多，本次课程使用了 I/O 的方式，首先通过bufio.NewReader(os.Stdin) 来创建一个只读的流，然后调用 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)    // 读取用户输入
   input, err := reader.ReadString('\n')
   if err != nil {    // 错误处理
      fmt.Println("An error occured while reading input. Please try again", err)
      return
   }
   input = strings.Trim(input, "\r\n")    // 去掉末尾多读入的换行

   guess, err := strconv.Atoi(input)    // 字符转数字
   if err != nil {    // 错误处理
      fmt.Println("Invalid input. Please enter an integer value")
      return
   }
   fmt.Println("You guess is", guess)
}

这里用 I/O 流来获取用户输入的方式其实比较繁琐，主要考虑到后续的课程中会使用 bufio 包，Go 语言可以直接使用 scanf() 方法。

版本迭代 - V4：

在上一个版本代码的后面加上猜数字游戏的判断逻辑：

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

版本迭代 - V5：

猜数字游戏的逻辑部分代码已经都搞定了，此时程序还只能读取和输出一次，我们再给代码套上一个 for 循环就实现了整个猜谜游戏。

猜谜游戏完整代码：

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)
   input, err := reader.ReadString('\n')
   if err != nil {
      fmt.Println("An error occured while reading input. Please try again", err)
      return
   }
   input = strings.Trim(input, "\r\n")

   guess, err := strconv.Atoi(input)
   if err != nil {
      fmt.Println("Invalid input. Please enter an integer value")
      return
   }
   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!")
   }
}

在线词典

这是一个 Go 语言编写的查词程序，用户在命令行输入一个单词，会得到该单词的音标和注释。该案例主要是通过调用第三方 API 来查询单词并打印出来，通过这个案例我们会学习如何使用 Go 语言发送 Http 请求、解析 Json 以及如何使用代码生成工具来简化开发。

1. 第三方 API - 抓包：

浏览器访问彩云翻译的主页：🚀彩云小译 - 在线翻译 (caiyunapp.com)，查询一个单词，按下 F12 键打开开发者工具，可以在 NetWork（网络）标签下找到本次翻译对应的 Post 请求，继续查看它的 PayLoad 或者 Response，该 Post 请求的 Response（响应）类似于下面这个样子：

可以看到响应体中包含了查询单词的翻译和注释，接下来我们要尝使用 Go 语言来发送查询请求。

2. 代码生成：

用代码构造上面的 Response 非常复杂，本次课程介绍了一种简单的方式可以快速生成请求代码。

浏览器中右键这个 POST 请求，点击 Copy 中的 Copy as cURL 复制为 cURL 请求。接下来打开代码生成的网址：🚀Convert curl to Go (curlconverter.com)，粘贴刚刚的 cURL 命令即可生成对应的 Go 语言代码。

直接运行生成好的代码，会打印出一个很长的 Json 字符串。

3. 生成 reques body：

生成的代码中是以 json 格式来请求响应的，我们希望从一个变量输入而不是从一个 json 字符串输入，这里要用到 json 序列化将输入转换为 json 字符串。

参考第一节课学到的 json 序列化方式，首先写一个和 json 请求对应的结构体：

type DictRequest struct {
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
    UserID    string `json:"user_id"`
}

修改生成代码的开头部分，由直接 json 请求改成先将结构体变量序列化为 json 再进行请求，方便我们后面读取用户的输入：

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

紧接着要处理 response 响应的反序列化，从返回的 json 中打印出我们需要的翻译信息。同样的要先编写一个和 json 返回相对应的结构体，将 json 反序列化为结构体并从中获取翻译的字段信息。由于返回的 json 内容非常多，对应的结构体也很巨大，这里还是用代码生成工具来实现。

浏览器打开网站：🚀JSON转Golang Struct - 在线工具 - OKTools，将浏览器开发者工具 Response 响应标签中的 json 字符串粘贴进去，点击 “转换-嵌套” 就可以生成对应的 Go 语言结构体代码。

将生成的代码拷贝到我们的程序代码中，修改代码，将响应的 json 字符串反序列成结构体：

// ...
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)
}
var dictResponse DictResponse
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%#v\n", dictResponse)

4. 打印结果 & 完善代码：

整个代码的主体部分已经弄好了，接下来只需要读取用户的输入，并将需要的结果打印出来即可，同时为了程序更加完善，再加上错误处理的代码来 response 请求返回出错的情况就实现了一个完整的“命令行在线词典”案例。最后，我们可以将调用彩云 API 查词的代码封装在 query(word string) 函数中，让代码更加工程化。

💻完整的在线词典代码：

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

SOCKS5 代理

💬 本次课程的最后一个例子要实现一个 SOCKS5 代理服务器，整体难度比较大，代码也有些复杂，这里只做一个简短的笔记作为了解，就不深究代码的实现细节了~

什么是 SOCKS5 代理？

SOCKS5 是一个代理协议，它在使用 TCP/IP 协议通讯的前端机器和服务器机器之间扮演一个中介角色，使得内部网中的前端机器变得能够访问 Internet 网中的服务器，让通讯更加安全。使用 SOCKS5 代理访问网络，目标网站会认为请求的 IP 来自代理服务器从而隐藏自己的真实 IP 来保证访问是匿名的。

虽然提到 SCOCKS5 会把它和“翻墙”联系起来，不过 SCOCKS5 代理并不能像 VPN 那样加密流量，因此任何人都能窥探到网络流量。

实现流程：

监听端口：标准库中的 net 包提供了监听端口的方法 net.Listen()，使用该函数可以返回一个 server 对象，调用 server.Accept() 会返回和端口的链接。

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

用户鉴权：实现一个 auth() 函数来进行鉴权，主要是告诉浏览器使用了哪种鉴权方式。
请求阶段：实现 connect() 函数，读取浏览器发送的报文来获取用户访问的 url、IP 地址和端口等信息。
relay 阶段：得到用户的请求报文，接下来要和用户真正访问的服务器建立双向连接，实现两个协程，一个将用户的浏览器数据拷贝到服务器，另一个将服务器返回的数据拷贝到用户浏览器。

案例代码：

package main

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

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 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", ver)
   }
   addr := ""
   switch atyp {
   case atypIPV4:
      _, 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
}

运行代码，使用 curl 命令可以对实现的 SCOKS5 代理进行测试：

用户访问网站时会在程序会打印出链接的建立时间与 IP 地址。

Go 语言实战案例 | 青训营笔记