【Go入门】Go语言基础&小项目练习 | 青训营笔记

白速龙王的回眸
166 阅读7分钟

这是我参与「第三届青训营 -后端场」笔记创作活动的的第一篇笔记。

【课程一】Go基础

主要内容

第一节课主要介绍了go的语法基础，包括变量、循环分支、数组切片、函数方法、错误处理、字符串、格式化处理、json模块、time模块、strconv类型转换和env环境变量等知识点

项目一：猜谜游戏


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.TrimSuffix(input, "\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!")
   }
}

此diamagnetic通过bufio.NewReader(os.Stdin)、reader.ReadString('\n')、strings.TrimSuffix(input, "\n")、strconv.Atoi(input)进行繁杂的输入流获取以及输入的类型转换 实际上我们这里可以采取Scanf进行输入优化：


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)

   fmt.Println("Please input your guess")
   //reader := bufio.NewReader(os.Stdin)
   for {
      var guess int
      _, err := fmt.Scanf("%d", &guess)

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

这也就完成了作业的第一个问题

项目二：英文翻译

主要的思路是通过在翻译网站的“开发者工具”进行抓包，并对相关响应的XHR进行copy as curl(bash)

  1. 利用 curlconverter.com/#go 实现curl命令的go语言转化 快速得到响应内容

image.png

  1. 得到上图所示的go post代码后，我们可以把post的data抽象出来，生成一个结构体存储对应的变量，以及更改响应的代码：

image.png

image.png

3.在进行上述的request结构体抽象后，我们要接着进行response结构体的抽象，然而由于response的内容非常复杂，直接手动创建结构体是成本很高且效率很低的。因此，我们将response的内容copy下来，扔到如下网址 oktools.net/json2go 中进行go结构体的获取：

image.png

4.在获得post请求代码，以及将request和response的结构抽象出来之后，我们就可以从response结构体中抽取我们所需要的内容了：

image.png

根据上图的response信息，我们应该抽丝剥茧地从words,pos_list,explanations,text中逐层深入并获取县官地信息，对应的go代码如下：

image.png

  1. 至此我们已经成功获得火山翻译的相关信息，可以看一下输入命令行之后的结果：

image.png

6.为了利用多核并行的优势，我们可以采用waitGroup + goroutine的方式，让主协程等待两个goroutine完成才结束即可，主函数可参考如下：

image.png

当然，我们也要对两个query函数的参数列表稍加修改，并在结束前加上一个wg.Done()释放资源

  1. 通过time.Now()对两个搜索分别进行计时，并看看两者的搜索时间区别，通过fmt.Println打印

image.png

  1. 可以发现，两者的搜索时间相近，但通过goroutine的方式我们可以并行执行，节省了将近一半的时间！

9.完整源码如下：

package main

import (
   "bytes"
   "encoding/json"
   "fmt"
   "io/ioutil"
   "log"
   "net/http"
   "os"
   "sync"
   "time"
)

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 queryCaiyun(word string, wg *sync.WaitGroup) {
   start := time.Now()
   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("Caiyunai:")
   fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
   for _, item := range dictResponse.Dictionary.Explanations {
      fmt.Println(item)
   }
   finish := time.Now()
   fmt.Println("Caiyun Runtime: ", finish.Sub(start))
   fmt.Println()

   wg.Done()
}

type DictRequest2 struct {
   Text string `json:"text"`
   Language string `json:"language"`
}

type DictResponse2 struct {
   Words []struct {
      Source int `json:"source"`
      Text string `json:"text"`
      PosList []struct {
         Type int `json:"type"`
         Phonetics []struct {
            Type int `json:"type"`
            Text string `json:"text"`
         } `json:"phonetics"`
         Explanations []struct {
            Text string `json:"text"`
            Examples []struct {
               Type int `json:"type"`
               Sentences []struct {
                  Text string `json:"text"`
                  TransText string `json:"trans_text"`
               } `json:"sentences"`
            } `json:"examples"`
            Synonyms []interface{} `json:"synonyms"`
         } `json:"explanations"`
         Relevancys []interface{} `json:"relevancys"`
      } `json:"pos_list"`
   } `json:"words"`
   Phrases []interface{} `json:"phrases"`
   BaseResp struct {
      StatusCode int `json:"status_code"`
      StatusMessage string `json:"status_message"`
   } `json:"base_resp"`
}


func queryHuoshan(word string, wg *sync.WaitGroup) {
   start := time.Now()
   client := &http.Client{}
   // 通过结构体传入翻译内容
   request := DictRequest2{Text: word, Language: "en"}
   // 序列化为string
   buf, err := json.Marshal(request)
   if err != nil {
      log.Fatal(err)
   }
   // 再转为bytes
   var data = bytes.NewReader(buf)
   //var data = strings.NewReader(`{"text":"good\n","language":"en"}`)
   req, err := http.NewRequest("POST", "https://translate.volcengine.com/web/dict/match/v1/?msToken=&X-Bogus=DFSzswVLQDVBKzG0SWaqEF9WX7jM&_signature=_02B4Z6wo00001xod3egAAIDDmh8nq0smXksaHdlAAKUHQH1Vh8tNCHkedGFMD-QcUnOfevAwBMoRVMnX32tSrVF12NmsZE7np1haN5QV-9db9tTQRzIMvNThU.5Di.8qiK5SGSqB28xxEqu364", data)
   if err != nil {
      log.Fatal(err)
   }
   req.Header.Set("authority", "translate.volcengine.com")
   req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="98", "Google Chrome";v="98"`)
   req.Header.Set("accept", "application/json, text/plain, */*")
   req.Header.Set("content-type", "application/json")
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   req.Header.Set("origin", "https://translate.volcengine.com")
   req.Header.Set("sec-fetch-site", "same-origin")
   req.Header.Set("sec-fetch-mode", "cors")
   req.Header.Set("sec-fetch-dest", "empty")
   req.Header.Set("referer", "https://translate.volcengine.com/translate?category=&home_language=zh&source_language=detect&target_language=zh&text=good%0A")
   req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
   req.Header.Set("cookie", "x-jupiter-uuid=16521717160593380; i18next=zh-CN; s_v_web_id=verify_9ee5cfbc7da4332702124644a695e0e7; _tea_utm_cache_2018=undefined; ttcid=3bea2de0171748ff8afafa24de02c4c615; tt_scid=X-WQFPZGdMMILVTs.Vl6C-W7n6ZTe6R5rRA3.cjgNzb.7pA9LfkZnyJSOGxmrAdX3664")
   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 DictResponse2
   err = json.Unmarshal(bodyText, &dictResponse)
   if err != nil {
      log.Fatal(err)
   }

   fmt.Println("Huoshan:")
   // 嵌套遍历
   for _, words := range dictResponse.Words {
      for _, post_list := range words.PosList {
         for _, explanations := range post_list.Explanations {
            println(explanations.Text)
         }
      }
   }
   finish := time.Now()
   fmt.Println("Huoshan Runtime: ", finish.Sub(start))
   fmt.Println()
   wg.Done()
}

func main() {
   if len(os.Args) != 2 {
      fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
      `)
      os.Exit(1)
   }
   word := os.Args[1]

   wg := sync.WaitGroup{}
   // 两个搜索方式
   wg.Add(2)
   go queryCaiyun(word, &wg)
   go queryHuoshan(word, &wg)
   // 等到两个都执行完毕
   wg.Wait()
}

项目三：Socks5代理

  1. Socks5原理

image.png

协议明文存储

企业内网为了确保安全性，配置很严格的防火墙策略

导致甚至管理员访问某些资源也很麻烦

sockets5相当于在防火墙内部开了一个口子

让授权的用户可以通过单个端口访问所有资源

翻墙软件也是暴露sockets5端口给一些浏览器使用

代理ip池里面的ip协议很多就是sockets5协议

总的来说，就是某个服务器可以访问外面的世界，我们将请求发给代理服务器，代理服务器将会请求我们指定的网站并将相关的数据发送给我们的浏览器，这样我们就感觉自己也能访问外面的世界了。。。

2.主要逻辑： main函数开启一个tcp的端口监听请求 对于每个新来的client对齐进行Accept，并拉起一个process协程进行处理 对于process函数里面，主要分为两步，一个是对reader连接的验证（也就是auth），另一个部分是进行连接（此部分应该是SERVER访问外面的世界，并将信息返还给client）

3.auth函数

对版本号、方法大小、方法进行常规性检验、最终将该server支持的Ver和method信息写回给client

4.connect函数 还是首先进行若干字段的验证，对于不同的版本采用不同的方法

image.png

然后使用io.Copy 的两个goroutine应该以及context的并发处理，应该是完成Proxy和client以及目标Server的信息交互

5.测试阶段，环境：Ubuntu 18，因为curl命令在wins下经常出错，所以我用云主机跑了一下测试结果：

afa40e837051c6873558a9dd75ac6ea.png

可以看到www.qq.com 这里会重定位(302)到www.qq.com 我们直接改一下，改成访问www.qq.com 即可看到有效的响应信息

image.png

可以看到我们这次获得一大堆的html代码

最后我们在看看百度

image.png

确实就是“百度一下”的那个界面哦~

总结

第一节课主要熟悉了go的基础语法以及对其网络流信息交互有了更深一层的理解 学会了go的api爬虫抓包，还有学会了socks5的原理以及响应的验证、连接步骤和对应go函数

感想1：go的json太不智能了，python获取resp之后直接用括号解析方便多了

感想2：go是真的快，比python快好多倍

感想3：我要继续好好学习go！

avatar
文章
阅读
粉丝