Go语言实战案例【proxy代理|在线词典】 | 豆包MarsCode AI刷题在线词典本次案例：做一个在线词典，通过

在线词典

本次案例：做一个在线词典，通过==彩云小译==的API进行测试，在这个例子中，会介绍一些常用的网站，希望能够帮到你。

下面，让我们开始吧。

首先，让我们打开彩云小译, 右击->检查->网络, 然后输入一个单词，比如说 $good$ ，这时候，会出现一系列请求，我们选中dict，如下：

可以看到，发送这个请求需要的请求头还是很多的，我们可以不用自己设置，打开网站WebSite ，将curl命令转换成对应语言的代码：

依次执行下面操作：右击dict->复制->以 $cURL(bash)格式复制全部内容$

然后粘贴到上面的网站，得到结果：

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
)

func main() {
	client := &http.Client{}
	req, err := http.NewRequest("GET", "https://cdn-web.caiyunapp.com/lingoCloud/newVersion/img/close.png", nil)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("accept", "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8")
	req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
	req.Header.Set("cookie", "_gcl_au=1.1.1584873094.1730945762; _ga=GA1.2.916411859.1730945762; _gid=GA1.2.1052851366.1731034826; _ga_R9YPR75N68=GS1.1.1731034825.3.1.1731034909.60.0.0; _ga_65TZCJSDBD=GS1.1.1731034826.3.0.1731034909.0.0.0")
	req.Header.Set("priority", "u=1, i")
	req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("sec-ch-ua", `"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"`)
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("sec-ch-ua-platform", `"Windows"`)
	req.Header.Set("sec-fetch-dest", "image")
	req.Header.Set("sec-fetch-mode", "no-cors")
	req.Header.Set("sec-fetch-site", "same-site")
	req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)
}

上面代码需要稍微做一些修改：

func main() {
	client := &http.Client{}
	var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`) // 字符串转成流，发送效率更高
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("accept", "application/json, text/plain, */*")
	req.Header.Set("accept-language", "zh")
	req.Header.Set("app-name", "xiaoyi")
	req.Header.Set("authorization", "Bearer")
	req.Header.Set("content-type", "application/json;charset=UTF-8")
	req.Header.Set("device-id", "a50dfaf465e91d2a09592c3d8816e817")
	req.Header.Set("origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("os-type", "web")
	req.Header.Set("os-version", "")
	req.Header.Set("priority", "u=1, i")
	req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("sec-ch-ua", `"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"`)
	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/130.0.0.0 Safari/537.36")
	req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
	resp, err := client.Do(req) // 真正发起请求
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)
}

运行之后会得到响应数据。到这里并没有结束，可以把项目做的更好一些，上面例子中，查询的单词顾定成了good，我们可以将请求封装到一个结构体中，然后用json序列化一下，由于相应数据也是json格式，对响应数据需要反序列化，但是响应的属性很多，我们不需要自己写，这里再推荐一个网站，通过json数据构造响应体结构：oktools.iokde.com/json ，然后输出对应的发音以及翻译，这部分可以在请求的dict中看到：

最终代码如下：

package trans

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
)

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

func Query(word string) {
	client := &http.Client{}
	//var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`) // 字符串转成流，发送效率更高
	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("accept", "application/json, text/plain, */*")
	req.Header.Set("accept-language", "zh")
	req.Header.Set("app-name", "xiaoyi")
	req.Header.Set("authorization", "Bearer")
	req.Header.Set("content-type", "application/json;charset=UTF-8")
	req.Header.Set("device-id", "a50dfaf465e91d2a09592c3d8816e817")
	req.Header.Set("origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("os-type", "web")
	req.Header.Set("os-version", "")
	req.Header.Set("priority", "u=1, i")
	req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("sec-ch-ua", `"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"`)
	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/130.0.0.0 Safari/537.36")
	req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
	resp, err := client.Do(req) // 真正发起请求
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := io.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.Printf("%#v\n", dictResponse)
    	// 输出发音以及中文。
	fmt.Println(dictResponse.Dictionary.Entry, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
	for _, item := range dictResponse.Dictionary.Explanations {
		fmt.Println(item)
	}
}

main 函数：

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ./Enviroment/go\\workspace/go\\main.go")
	}
	trans.Query(os.Args[1])
}

打开终端，在当前项目下执行：go run main.go good 就能达到文章开始时候的效果啦。

proxy代理

效果图：

![](D:\UserData\sichenyong\bytetech\Go小项目.assets\bandicam 2024-11-08 11-26-43-204.gif)

正常情况下，应该是客户端直接向目标主机发送http请求，三次握手之后进行数据传输，但目标主机限制当前客户端的访问呢？应该如何访问目标主机？

正确答案是：通过代理服务器，通俗的解释一下，正常情况下我们应该进通过学校大门进出，如果不让出学校，我们就会找校门出去，代理服务器就好像给你开了一个小门，可以通过这个小门访问目标主机的资源。原理图如下：

注意：除非特别说明，下面数子表示的是字节

协商阶段，请求头格式如下：

VER	NMETHODS	METHODS
1	1	1~255

VER：协议版本， socks5为0x05
NMETHODS：方法数目，表示后面的方法编号列表（METHODS字段）中有多少种客户端支持的认证方法
METHODS：方法编号列表，存储客户端支持的认证方法的编号。

协商过后代理服务器从给定的方法编号列表中选择一个方法并返回==选择报文==

VER	METHOD
1	1

METHOD字段用来返回选择的方法编号

支持的认证方式有：

0x00: 不需要认证
0x01: GSSAPI认证
0x02: 用户名和密码方式认证
0x03: IANA认证
0x80-0xfe: 保留的认证方式
0xff: 不支持任何认证方式，当客户端收到此信息必须关闭连接。

请求阶段

协商完成之后，客户端就可以向代理服务器发送代理请求，客户端会向代理服务器发送下面格式的请求：

VER	CMD	RSV	ATYP	DST.ADDR	DST.PORT
1	1	X'00'	1	Variable	2

VER：版本号，socks5协议的值是0x05。
CMD：指令编号，0x01表示connect指令，用于TCP代理。
RSV：保留字段，值从上面支持的认证方式选，默认0x00
ATYP：目标地址类型
- 0x01：IPv4地址，DST.ADDR占四个字节。
- 0x03：域名，DST.ADDR是一个长度可变的域名，其中第一个字节标识域名长度。
- ...
DST.ADDR：目标地址
DST.PORT：目标端口

响应报文

SOCKs服务端会根据请求类型和源、目的地址，执行对应的操作，并且返回对应的一个或多个报文信息，格式如下

VER	REP	RSV	ATYP	BND.ADDR	BND.PORT
1	1	X'00'	1	Variable	2

VER：socks5版本，这里是0x05。
REP：relay field, 内容取值如下
- 0x00 成功
- 0x01常规 SOCKS 服务故障
- 0x02 规则不允许的连接
- 0x03 网络不可达
- 0x04 主机无法访问
- 0x05 拒绝连接
- 0x06 连接超时
- 0x07 不支持的命令
- 0x08 不支持的地址类型
RSV：保留字段，必须是0
ATYP：地址类型，同上
BND.ADDR：服务绑定的地址，即请求成功后客户端需要连接的代理服务器的地址或域名，客户端之后的通信均通过该地址对应的服务器。
BND.PORT：服务绑定的端口号。

当代理服务器返回成功的消息后，后续客户端通过绑定的地址和端口号与代理服务器通信，由代理服务器转发客户端的请求到目标服务器，并将目标服务器的响应转发个客户端。

代码如下：

首先定义常量：

const (
	socks5Ver = 0x05  // 协议号
	cmdBind   = 0x01 // connect连接
	atypIPV4  = 0x01 
	atypeHOST = 0x03
	atypeIPV6 = 0x04
)

主函数：

func ProxyV1() {
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
	fmt.Println("服务启动......")
	for {
		client, err := server.Accept()
		if err != nil {
			log.Printf("accept err:%v", err)
			continue
		}
		go process(client)
	}
}

process 函数

func process(client net.Conn) {
	defer client.Close()
	reader := bufio.NewReader(client)
	err := auth(reader, client) // 认证
	if err != nil {
		log.Printf("client %v auth err:%v", client.RemoteAddr(), err)
		return
	}
	log.Printf("auth success!")
	err = connect(reader, client) // 连接请求
	if err != nil {
		log.Printf("client %v  auth failed:%v", client.RemoteAddr(), err)
		return
	}
}

auth函数：

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 method size failed: %w", err)
	}
	method := make([]byte, methodSize)
	_, err = io.ReadFull(reader, method)
	if err != nil {
		return fmt.Errorf("read method failed: %w", err)
	}
	log.Println("ver", ver, "method", method)

	/**
	+-------+----------------+
	|VER	| METHODS		 |
	+-------+----------------+
	|	1   |     1 		 |
	+-------+----------------+
	*/
	// 告诉浏览器我们需要哪种鉴权方式
	_, err = conn.Write([]byte{socks5Ver, 0x00}) // 不需要认证
	if err != nil {
		return fmt.Errorf("write socks5 ver failed: %w", err)
	}
	return nil
}

connect函数

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, atype := 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 atype {
	case atypIPV4:
		// 读四个字节
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read ipv4 addr 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 host size failed: %w", err)
		}
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		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])
	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)
	}

	// 与目标客户端建立连接
	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	if err != nil {
		return fmt.Errorf("dail dst failed: %w", err)
	}
	defer dest.Close()
	log.Println("dial", addr, port)

	// 实现双向数据转发
	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
}