这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记
概述
本节课一方面主要介绍了Go语言的基础语法知识，包括变量类型，条件语句，标准库的使用以及go的相关特性等内容。另一方面主要结合实际的项目需求，用go实现了猜谜游戏、简单词典和SOCKS5代理三个小项目。
基本语法
因为在语法规则上golang与其他语言也有许多相似的地方，所以有其他语言经验的同学也可以快速上手。关于go的基本语法和标准库使用可以参考学习以下链接，可以快速上手。
学习路线
关于golang的后期学习路线也可以参考Go 语言学习线路图
项目实践
一、猜谜游戏
这应该是一个十分常见的语言学习例子。在本项目中，主要基于golang的标准库math/rand生成随机数，然后循环读取用户输入以达到数字猜谜的效果。例子代码详解如下：
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
maxNum := 100
rand.Seed(time.Now().Unix())
number := rand.Intn(maxNum)
fmt.Println("The secret number is ", number)
guess := 0
for {
_, err := fmt.Scanf("%d", &guess)
if err != nil {
fmt.Println("input error")
}
if guess == number {
fmt.Println("Correct, you Legend!")
break
}else if guess < number {
fmt.Println("Your guess is smaller than the secret number. Please try again")
}else {
fmt.Println("Your guess is bigger than the secret number. Please try again")
}
}
}
二、简单词典
该案例主要是基于golang实现http请求的调用，实现在线翻译api的调用和解析，主要涉及http和json标准库的使用。具体代码详情如下所示：
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"log"
"net/http"
"os"
"sync"
)
// 彩云请求结构体
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"`
}
// 有道响应结构体
type YouDaoResponse struct {
Type string `json:"type"`
ErrorCode int `json:"errorCode"`
ElapsedTime int `json:"elapsedTime"`
TranslateResult [][]YouDaoResult `json:"translateResult"`
}
type YouDaoResult struct {
Src string `json:"src"`
Tgt string `json:"tgt"`
}
// 调用彩云api
func queryCaiYun(word string) {
reqData := DictRequest{
Source: word,
TransType: "en2zh",
}
buf ,err := json.Marshal(reqData)
if err != nil {
log.Fatal(err)
}
request, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", bytes.NewBuffer(buf))
if err != nil {
log.Fatal(err)
}
request.Header.Set("Connection", "keep-alive")
request.Header.Set("DNT", "1")
request.Header.Set("os-version", "")
request.Header.Set("sec-ch-ua-mobile", "?0")
request.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")
request.Header.Set("app-name", "xy")
request.Header.Set("Content-Type", "application/json;charset=UTF-8")
request.Header.Set("Accept", "application/json, text/plain, */*")
request.Header.Set("device-id", "")
request.Header.Set("os-type", "web")
request.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
request.Header.Set("Origin", "https://fanyi.caiyunapp.com")
request.Header.Set("Sec-Fetch-Site", "cross-site")
request.Header.Set("Sec-Fetch-Mode", "cors")
request.Header.Set("Sec-Fetch-Dest", "empty")
request.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
request.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
request.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
resp, err := http.DefaultClient.Do(request)
if err != nil {
log.Fatal(err)
}
bodyText, err := io.ReadAll(resp.Body)
defer resp.Body.Close()
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)
fmt.Println("==================彩云翻译结果=====================")
for _, item := range dictResponse.Dictionary.Explanations {
fmt.Println(item)
}
fmt.Println("==================彩云翻译结果=====================")
}
// 调用有道api
func queryYouDao(word string) {
client := &http.Client{}
req, err := http.NewRequest("GET", "http://fanyi.youdao.com/translate?&doctype=json&type=EN2ZH_CN&i="+word, nil)
if err != nil {
log.Fatal(err)
}
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 response YouDaoResponse
err = json.Unmarshal(bodyText, &response)
if err != nil {
log.Fatal(err)
}
fmt.Println("==================有道翻译结果=====================")
for _, v :=range response.TranslateResult[0]{
fmt.Println(v.Tgt)
}
fmt.Println("==================有道翻译结果=====================")
}
// 主函数，并发调用不同的搜索引擎
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 func() {
defer wg.Done()
queryCaiYun(word)
}()
go func() {
defer wg.Done()
queryYouDao(word)
}()
wg.Wait()
}
值得注意的是，当我们希望基于并行的方式来实现多个请求的调用时，可以结合sync.WaitGroup的使用以达到并发的效果，当然也可以通过channel的配合来实现该效果，本案例较为简单，就主要使用了sync.WaitGroup。
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 func() {
defer wg.Done()
// api1
queryCaiYun(word)
}()
go func() {
defer wg.Done()
// api2
queryYouDao(word)
}()
wg.Wait()
}
三、SOCKS5代理
在本例子中，主要模拟了socks5的代理转发过程，socks5的具体转发细节可以结合下图理解，暂时不做深究，结合改图可以较好的理解相关的代码实现。
具体代码实现如下：
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 {
log.Fatal(err)
}
for {
client, err := server.Accept()
if err != nil {
log.Println(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) 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) 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())
go func() {
_, _ = io.Copy(dest, reader)
cancel()
}()
go func() {
_, _ = io.Copy(conn, dest)
cancel()
}()
<-ctx.Done()
return nil
}
工具推荐
在本次课程中，被安利了两个有趣的工具网站，在此推荐给大家，可以提高开发的效率嘿嘿~
- JSON转Golang 可以实现将json结构快速生成相应的golang struct，在解析api结构的时候可以考虑使用
- Convert curl commands to code 可以将curl请求快速生成相应的golang等语言代码
