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

一、本堂课重点内容

1. go语言简介

go语言具有如下特点：高性能、高并发、语法简单易懂、丰富的标准库、完整的工具链、静态链接、快速编译、跨平台、垃圾回收

2. go语言入门

1. 变量的声明定义
2. 循环于分支结构
3. 数组
4. 切片
5. map映射
6. 函数
7. 指针
8. 结构体、结构体方法
9. 错误处理
10. 常用标准库：strings、fmt、json、time、strconv
11. go环境变量

3. 实例操作

1. 猜数字游戏
2. 对接网络在线词典翻译
3. Socks5代理服务器实现

二、详细知识点介绍：

go基本语法

1. 变量的声明与定义： 变量通过var关键字来进行声明，如var a int(a为变量名、int为变量类型)；变量的定义可以通过声明类型后赋值，如：var a int = 1就会声明一个整型变量a并赋值为1；也可以通过直接赋值的方式，省略类型关键字：var a = 1；进一步可以省略var关键字：a := 1这三种初始化方式都达到一个效果

2. 循环与分支结构： go的循环与分支在语法上与Java不同点在于，go的条件部分不需要括号，如if a>1 {}，在条件部分都可以使用:=来声明新的变量，声明变量和条件部分使用分号隔开，switch分支是默认没有switch穿透的，也就是不需要使用break来跳出switch，如果要穿透则使用fallthrough关键字；go的循环只有for循环，但for循环可以像while一样使用即：for n<10 {}，使用for+range可以实现对数组、字符串等的遍历：for index,value := range str

3. 数组： go中声明方式是按照go的声明方式来的，即数组名在前，数组大小和类型在后，数组的大小是数组类型的一部分，不同于Java数组的length是数组对象的一个属性

4. 切片： go的切片类似于Java中的ArrayList，都是底层维护了一个数组，并且是动态容量的；切片的初始化由通过数组如var slice = arr[0:3]//将数组索引[0,3)部分切片返回，同样对切片也可以使用相同的语法进行切片(冒号前面不写表示从头开始，后面不写表示一直到最后)，还能通过一个内置函数make：var slice = make([]int,5)//参数分别为切片类型和切片初始容量，这里的类型的指定类似于Java中使用泛型，或者像数组一样直接初始化一个切片：var slice = []int{1,2,3}

5. map： map的定义通过直接初始化和make两种方式进行，语法如：var map = [string]int{"one":1}中括号里面是键、外面是值

6. 函数： go的函数类似于Java中的方法，但是Java中的方法都有一个调用的对象，这是go与之不同的地方(只有结构体方法会使用结构体对象打点调用)，go中的函数不能够重载，一个包内不能有多个同名函数，函数的声明为：func 函数名(参数列表) (返回值列表){}函数的返回值可以有多个，这是Java不支持的；而且go的函数传参是传值，对参数的任何改动不会影响源数据

7. 指针： go中函数的传参是按值传递，不同于Java中可以通过引用修改原值，如果需要修改原值就要用到指针，传入指针后通过地址找到值进行修改，指针相关的运算符：&取地址、*取值；*Type指针变量的类型

8. 结构体、结构体方法： go中的结构体类似于Java的对象，结构体方法就和Java中调用方法的方式很类似，结构体的声明：type 结构体名 struct{变量}，结构体方法：func (结构体对象) 方法名(参数列表) (返回值列表)，这样对应对象的结构体就可以打点调用这个方法了；实际上Java中调用方法的对象叫做隐式参数，但是Java语法的声明方式容易让人忽略这一点，这里的声明方式内涵也就是如此，即调用的对象也属于参数；结构体中的访问控制通过首字母大写来控制，如果首字母大写表示能够被外界访问，否则不能

9. 错误处理： go的错误处理不同于Java的抛出异常，而是在返回值列表中添加一个error对象，这个error对象通过errors.New(错误信息)来创建，然后调用方通过判断error是否为空来判断是否有错误出现，然后通过panic函数来停止程序的继续运行，在上层使用defer关键字+recover来进行错误处理

10. 常用的标准库： strings库类似于Java中的String，但是Java中String是一个类，可以创建一个对象，这里的strings更像Java中的一个工具类只是提供一些函数的调用；fmt库用于格式化，如fmt.Println()将参数格式化拼接输出；json库用于json转换，结构体对象转json：json.Marshal(结构体对象)得到的是一个字节数组，可以通过string(arr)的方式转换成字符串；结构体转json同时缩进：json.MarshalIndent(结构体对象，缩进偶每行的前缀，缩进字符)；time时间日期库，时间字符串的转化不同于其他语言的yyyy-MM-dd，而是用一个固定的时间：2006-01-02 15:04:05；strconv用于字符串与其他类型的转化，类似于Java中的String.valueOf等

11. 环境变量 go通过os库获取和写入系统的环境变量，还可以通exec包执行指令

三、实践练习例子：

1. 猜数字游戏

package main

import (
	"fmt"
	"math/rand"
	"time"
	"bufio"
	"os"
	"strings"
	"strconv"

)
func main(){
	//最大猜数的范围
	maxNum := 100
	//获取当前时间戳
	timeStamp := time.Now().UnixNano()
	//使用当前时间戳作为种子，保证每次获取的随机数不同；如果没有这一步，每次就相当于调用了rand.Seed(1)获取一次之后获取的随机数都相同
	rand.Seed(timeStamp)
	//获取随机数
	secretNumber := rand.Intn(maxNum)

	//创建一个缓冲读取流，用于从命令行读取
	reader := bufio.NewReader(os.Stdin)
	
	//进入循环不断的猜直到才猜对
	for{
		fmt.Println("请输入您猜的数字")
		//读取一个字符串，直到遇到指定的字符\n
		input,error := reader.ReadString('\n')

		if error != nil {
			fmt.Println("输入有误")
			fmt.Println(error)
			return
		}

		//去除字符串后面的后缀回车和换行
		input = strings.TrimSuffix(input,"\r\n")

		guessNumer,error := strconv.Atoi(input)
		if error != nil {
			fmt.Println("输入错误",error)
			return
		}
		if guessNumer > secretNumber {
			fmt.Println("猜大了")
			continue
		}
		if guessNumer == secretNumber {
				fmt.Println("猜对了，正确答案就是",secretNumber)
			break
		}
		fmt.Println("猜小了")
	}
}

2. 命令行词典

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"encoding/json"
	"bytes"
	"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) {
	//创建请求参数
	request := DictRequest{Source:"中国",TransType:"zh2en"}
	//json转换，得到转换后的字节缓冲区
	var buf,error = json.Marshal(request)
	if error!=nil {
		log.Fatal(error)
	}
	
	//将字节读取存入data中
	var data = bytes.NewReader(buf)
	//创建一个http.Client对象，取地址存到client中，client是一个指针；Client是一个结构体，里面可以存入很多参数，类似于axios的实例
	client := &http.Client{}
	//创建一个请求
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	
	//设置请求的http头
	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() {
	//获取运行命令参数，作为word（go run 文件 参数）
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
		`)
	}
	word := os.Args[1]
	query(word)
}

3. Socks5代理

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

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

func main(){
	//创建一个服务，监听tcp/1080端口
	server,err := net.Listen("tcp","127.0.0.1:1080")

	if err != nil {
		panic(err)
	}
	
	//无限循环开始接收请求
	for {
		//程序会阻塞在这里，直到接收到一个请求才继续往下执行
		//得到的client是一个指针，表示一个连接的地址
		client,err := server.Accept()
		if err != nil {
			log.Printf("Accept Failed %v",err)
			continue
		}
		//go关键字类似于Java中开启一个新的线程，但是消耗比线程要低的多，而且没有Java中那么复杂
		go process(client)
	}
}

//对请求进行连接，传入一个只读流和一个连接
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 {
		//ipv4类型
	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)
		//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 := 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)
	}
	//context机制，创建一个context，只有cancel()调用才会结束
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	//创建一个线程来进行数据转发，从reader到dest
	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	//创建一个数据转发，从dest到conn
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()

	//任何一个方向的copy失败才会结束
	<-ctx.Done()
	return nil
}
//鉴权
//参数为一个只读流和一个原始的tcp连接
func auth(reader *bufio.Reader,conn net.Conn) (err error) {
	//浏览器会发送一个报文，含有三个字段，分别为：
	//1.VER:协议版本号，固定为5
	//2.NMETHODS:METHODS部分的长度
	//3.METHODS:认证方式列表
	// X’00’ NO AUTHENTICATION REQUIRED
	// X’02’ USERNAME/PASSWORD

	//读取报文第一个字节得到版本号
	ver,err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed",err)
	}
	//如果协议不是sockes5则返回错误
	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)
	}

	//写入不鉴权
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}
//线程处理,传入一个连接对象
func process(conn net.Conn){
	//延迟处理关闭连接
	defer conn.Close()
	//通过连接获取reader
	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")
	//连接
	err = connect(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
}

四、课后个人总结：

go的面向对象根据结构体来实现，其中访问控制需要通过首字母是否大写来控制，这与Java的编码方式不同

Golang编程的代码风格与Java也有大的不同，并且golang比较硬性的规定了编码规范，比如if语句的括号不能换行等

五、引用参考：

Go语言标准库