go代码实践
1.猜数字
package main
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
func main() {
maxNum := 100
rand.Seed(time.Now().UnixMicro())
result := rand.Intn(maxNum)
for {
//1.输入数据
fmt.Println("请输入你猜测的数据：")
reader := bufio.NewReader(os.Stdin)
input, error := reader.ReadString('\n') //按行读取
//2.处理读取字符
if error != nil {
fmt.Println("An error occured while reading input. Please try again", error)
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
}
//3.结果判定
if guess > result {
fmt.Println("Your answer is too bigger, please try again!")
} else if guess < result {
fmt.Println("Your answer is too smaller, please try again!")
} else {
fmt.Println("congratulation！")
break
}
}
}
2.翻译词典
实现思路：
1.去彩云翻译网页，打开开发者模式，点击network，输入某词汇，点击翻译
2.请求抓包，从network中查看请求的response是不是自己想要的，如果是则右键请求，复制为cURL
3.利用工具生成go语言的req请求代码，curlconverter.com/
4.在获取结果中获取想要的json数据，反序列化为结构体类型
版本一
package main
import (
"fmt"
"io"
"log"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
//通过一个json字符串来描述输入数据
var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
//新建post请求
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
log.Fatal(err)
}
//设置请求头
req.Header.Set("authority", "api.interpreter.caiyunai.com")
req.Header.Set("accept", "application/json, text/plain, */*")
req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")
req.Header.Set("app-name", "xy")
req.Header.Set("content-type", "application/json;charset=UTF-8")
req.Header.Set("device-id", "d813b8f5c4e293ab5dbb6e7174410d17")
req.Header.Set("origin", "https://fanyi.caiyunapp.com")
req.Header.Set("os-type", "web")
req.Header.Set("os-version", "")
req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
req.Header.Set("sec-ch-ua", `\"Microsoft Edge\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"`)
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("sec-ch-ua-platform", `\"Windows\"`)
req.Header.Set("sec-fetch-dest", "empty")
req.Header.Set("sec-fetch-mode", "cors")
req.Header.Set("sec-fetch-site", "cross-site")
req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.42")
req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
//执行http请求
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
//关闭请求流
defer resp.Body.Close()
//获取请求结果json字符串
bodyText, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", bodyText)
}
缺点：通过手写的json格式字符串控制输入数据，获取的结果也只是json格式的字符串，不方便控制输入输出
改进方案：请求数据和结果数据都封装成strcut数据，发送请求数据时先将struct数据序列化为json字符串，获取结果时再将json字符串反序列化成struct数据
json字符转go结构体网站：oktools.net/
版本二
要实现用strcut控制输入输出，需修改部分：
①、添加两个结构体
// 请求数据结构体
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 {
} `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"`
}
②、发送请求时先创建结构体，再转序列化为json字符串作为输入
client := &http.Client{}
//新建struct，通过这个struct对象来描述输入数据
requestjson := DictRequest{TransType: "en2zh", Source: word}
//将请求数据为序列化为json字符串
buf, err := json.Marshal(requestjson)
if err != nil {
log.Fatal(err)
}
//将序列化结果转成输入流
var data = bytes.NewReader(buf)
//新建post请求
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
③、解析数据时，获取的是json字符串，把它反序列化为结构体数据
//获取请求结果json字符串
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 responsejson DictResponse
//将json数据反序列化为结构体
err = json.Unmarshal(bodyText, &responsejson)
if err != nil {
log.Fatal(err)
}
//获取结构体中某字段内容
for _, item := range responsejson.Dictionary.Explanations {
fmt.Println(item)
}
拓展：设置代理
需求：不想以自己的本机IP去发送请求，想使用代理服务器去给目标地址发请求，比如爬虫的时候使用代理IP
实现思路：使用http.Client类型创建一个HTTP客户端，然后通过http.Transport类型设置代理服务器，并将其传递给HTTP客户端即可。最后，使用client对象发送HTTP请求即可完成代理访问。
//设置代理IP
proxy := func(_ *http.Request) (*url.URL, error) {
return url.Parse("代理地址")
}
//设置传输对象
transport := &http.Transport{
Proxy: proxy,
}
//创建client
client := &http.Client{
Transport: transport,
}
resp, err := client.Get("http://www.example.com")
3.SOCKS5代理协议
socks5代理服务器充当请求方与目标服务器的中介，主要任务有：
- 和请求方建立连接，确认认证方式
- 接收请求方发来的请求，并与目标主机建立连接
- 转发请求给目标主机，并将回应的结果返回给请求方
实现代码：
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() {
//监听1080端口
server, err := net.Listen("tcp", "127.0.0.1:1080")
if err != nil {
panic(err)
}
//循环接收连接请求
for {
log.Printf("代理服务器已启动，等待请求中...")
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函数去实现认证阶段
err := auth(reader, conn)
if err != nil {
log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
return
}
log.Println("auth success")
//用connect去接收请求信息，包括请求的目的IP、目的端口号等
err = connect(reader, conn)
if err != nil {
log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
return
}
log.Println("connect 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
//读取第一个字节，协议版本号
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)
}
//读取第二个字节，可选认证方法数量methodSiz
methodSize, err := reader.ReadByte()
if err != nil {
return fmt.Errorf("read methodSize failed:%w", err)
}
method := make([]byte, methodSize)
//读取methodSiz个字节，各个认证方法对应代码
_, err = io.ReadFull(reader, method)
if err != nil {
return fmt.Errorf("read method failed:%w", err)
}
//打印协议版本和可选认证方式
log.Println("ver", ver, "method", method)
//回复请求方， 选择socks5Ver版本号，0x00认证方式
_, err = conn.Write([]byte{socks5Ver, 0x00})
if err != nil {
return fmt.Errorf("write failed:%w", err)
}
return nil
}
// 解析出目的address和port
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: //目标地址为IPV4，则后面4个字节为addr
_, 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: //目标地址为某域名，先读取第一个字节size，再读后size个字节为addr
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: //目标地址为IPV6，不处理
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])
//打印目的地址和目的端口号
log.Println("请求目的IP：", addr, " 目的端口号：", port)
//建立到目的IP与端口号的TCP连接，并生成往目标方向的输出流
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()
// +----+-----+-------+------+----------+----------+
// |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, conn)
cancel()
}()
//新建子线程二，将服务器结果返回给请求方
go func() {
_, _ = io.Copy(conn, dest)
cancel()
}()
<-ctx.Done()
return nil
}
defer关键字解释：用于注册延迟调用，defer语句会在当前（包含defer语句）的函数结束的时才会被调用，多用于释放各种资源。
测试
①、启动程序
②、在cmd中输入curl --socks5 127.0.0.1:1080 -v http://www.baidu.com
③、查看测试结果
代理服务器:接收到请求，成功打印出目的IP和目的端口号
请求方:请求状态码为200，请求方成功获取baidu相关的响应内容，具体查看如下的标签
