猜谜游戏、彩云词典爬虫、SOCKS5代理的 Go(Golang) 小实践,附带全代码解释

简介: 猜谜游戏在编程语言实践都已经和 HelloWord 程序成为必不可少的新手实践环节,毕竟,它能够让我们基本熟悉 for 循环、变量定义、打印、if else 语句等等的使用,当我们基本熟悉该语言基础之后,就要学会其优势方面的程序实践,比如 Golang 所具备的爬虫及其并发优势。我们将采用彩云词典的英文单词翻译成中文的在线词典爬虫程序,及其改进版本,在并发上,我们将采用 SOCKS5 代理服务器的方式体验 Golang 语言的高并发易用性

👏 Hi! 我是 Yumuing,一个技术的敲钟人

👨‍💻 每天分享技术文章,永远做技术的朝拜者

📚 欢迎关注我的博客:Yumuing's blog

猜谜游戏在编程语言实践都已经和 HelloWord 程序成为必不可少的新手实践环节,毕竟,它能够让我们基本熟悉 for 循环、变量定义、打印、if else 语句等等的使用,当我们基本熟悉该语言基础之后,就要学会其优势方面的程序实践,比如 Golang 所具备的爬虫及其并发优势。我们将采用彩云词典的英文单词翻译成中文的在线词典爬虫程序,及其改进版本,在并发上,我们将采用 SOCKS5 代理服务器的方式体验 Golang 语言的高并发易用性。

欢迎关注我的字节后端青训营代码仓库,更新每日课后作业及其改进代码,除此之外,还会每周发布对应笔记,欢迎一起 star 或者 contribute 代码仓库

猜谜游戏

思路:

  1. 生成随机数
  2. 读取输入文本
  3. 删除不必要的换行符
  4. 转化文本为数字
  5. 循环判断是否猜数正确
  6. 正确退出循环
  7. 不正确则从第二步重新开始

官方版

package main

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

// 官方版本
func main() {
   
   
    maxNum := 100
    // 定义随机种子为当前时间,如果没有设定随机种子,生成数一致
    rand.Seed(time.Now().UnixNano())
    // 设置随机数最高值n,最小值默认从零开始,即生成一个值在区间 [0, n) 的 Int 数
    secretNumber := rand.Intn(maxNum)
    fmt.Println("Please input your guess")
    // 读取文本
    reader := bufio.NewReader(os.Stdin)
    // 输入判断,猜数正确退出循环
    for {
   
   
        input, err := reader.ReadString('\n')
        // nil 即为 golang 的空值
        if err != nil {
   
   
            fmt.Println("An error occured while reading input. Please try again", err)
            // continue 返回循环开始处
            continue
        }
        // windows 需要修改换行符
        input = strings.Trim(input, "\r\n")
        // 利用 string 方法转化为数字
        guess, err := strconv.Atoi(input)
        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 结束循环
            break
        }
    }
}

简易版:


package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
   
   
    maxNum := 100
    rand.Seed(time.Now().UnixNano()) //  设置随机数种子
    secretNumber := rand.Intn(maxNum)
    fmt.Println("Please input your guess")
    for {
   
   
        // 采用 fmt.Scanf 则无需额外处理文本 
        var guess int _, err := fmt.Scanf("%d\n", &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
        }
    }
}

在线词典

https://fanyi.caiyunapp.com/ 进行抓包,即网站加载结束后,在输入英文前打开浏览器自带的开发者工具,进行网络录制(network),输入英文,出现如下网络活动:

  • translator(重复两次)
  • dict(重复两次)

通过筛选,选择 dict 获取以下响应数据:

image-20230513154152368

image-20230513152406249

我们可以看出,发送数据中,source 为需要翻译的词,trans_type 为翻译类型,此处为英语翻译成汉语。响应数据中,entry 参数为需要翻译的词 test ,explanations 为翻译结果。为了方便爬取,采用代码生成的方法进行获取 go 参数。

复制为 cURL(bash),注意 edge 浏览器选择复制成 bash 格式,而不是 cmd 格式,否则,代码生成会发生错误。

curl 'https://api.interpreter.caiyunai.com/v1/dict' \
  -H 'authority: api.interpreter.caiyunai.com' \
  -H 'accept: application/json, text/plain, */*' \
  -H 'accept-language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6' \
  -H 'app-name: xy' \
  -H 'content-type: application/json;charset=UTF-8' \
  -H 'device-id: f1de93819e3bb9f68a199a51c6ee2efb' \
  -H 'origin: https://fanyi.caiyunapp.com' \
  -H 'os-type: web' \
  -H 'os-version;' \
  -H 'referer: https://fanyi.caiyunapp.com/' \
  -H 'sec-ch-ua: "Microsoft Edge";v="113", "Chromium";v="113", "Not-A.Brand";v="24"' \
  -H 'sec-ch-ua-mobile: ?1' \
  -H 'sec-ch-ua-platform: "Android"' \
  -H 'sec-fetch-dest: empty' \
  -H 'sec-fetch-mode: cors' \
  -H 'sec-fetch-site: cross-site' \
  -H 'user-agent: Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Mobile Safari/537.36 Edg/113.0.1774.35' \
  -H 'x-authorization: token:qgemv4jr1y38jyq6vhvi' \
  --data-raw '{"trans_type":"en2zh","source":"test"}' \
  --compressed

利用 Convert curl to Go (curlconverter.com) 生成代码如下:

package main

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

func main() {
   
   
    client := &http.Client{
   
   }
    var data = strings.NewReader(`{"trans_type":"en2zh","source":"test"}`)
    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", "f1de93819e3bb9f68a199a51c6ee2efb")
    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", "?1")
    req.Header.Set("sec-ch-ua-platform", `"Android"`)
    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 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Mobile Safari/537.36 Edg/113.0.1774.35")
    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)
}

运行结束后,获取到的响应数据(未格式化展示)如下

{
   
   "rc":0,"wiki":{
   
   },"dictionary":{
   
   "prons":{
   
   "en-us":"[t\u03b5st]","en":"[test]"},"explanations":["n.,vt.\u8bd5\u9a8c,\u6d4b\u8bd5,\u68c0\u9a8c"],"synonym":["examine","question","quiz","grill","query"],"antonym":[],"wqx_example":[["take a test","\u53c2\u52a0\u6d4b\u8bd5"],["receive a test","\u63a5\u53d7\u8003\u9a8c"],["put something to the test","\u68c0\u9a8c\u67d0\u4e8b"],["We will have an English test on Monday morning . ","\u661f\u671f\u4e00\u65e9\u4e0a\u6211\u4eec\u5c06\u6709\u4e00\u6b21\u82f1\u8bed\u6d4b\u9a8c\u3002"]],"entry":"test","type":"word","related":[],"source":"wenquxing"}}

利用该响应数据,我们就能够构造一个响应数据结构体,可利用 JSON转Golang Struct - 在线工具 - OKTools 进行代码生成。生成代码如下:

// 响应数据文本,少数参数有用
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      []interface{
   
   } `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 DictRequest struct {
   
   
    // 翻译类型
    TransType string `json:"trans_type"`
    // 翻译文本
    Source string `json:"source"`
    // 用户id
    UserID string `json:"user_id"`
}

把前面生成的请求代码封装改造(把请求参数和响应 json 数据序列化)成 query 方法,如下:

func query(word string) {
   
   
    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("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", "f1de93819e3bb9f68a199a51c6ee2efb")
    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", "?1")
    req.Header.Set("sec-ch-ua-platform", `"Android"`)
    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 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Mobile Safari/537.36 Edg/113.0.1774.35")
    req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
    // 发起请求
    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)
    }
}

调用请求方法:main 函数

func main() {
   
   
    // 运行代码:go run dict.go hello
    // hello 即为要翻译的文本
    if len(os.Args) != 2 {
   
   
        fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)
        os.Exit(1)
    }
    word := os.Args[1]
    query(word)
}

运行结果如下:

test UK: [test] US: [tεst]
n.,vt.试验,测试,检验

以上为官方版本,我自行改造了一部分内容,添加了以下功能:

  • 改变命令行运行方式,运行后输入翻译文本,而不是携带在运行命令中
  • 判断输入格式是否为英文字段,如果不是,报异常

在序列化之前(request := DictRequest{TransType: "en2zh", Source: word} 之前)添加的判断代码如下:

// 判断是否为英文
    dictionary := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    for _, v := range word {
   
   
        if !strings.Contains(dictionary, string(v)) {
   
   
            log.Fatal("Translation error, please enter English!")
        }
    }

当然,我们可以

main 函数改造如下

func main() {
   
   
    fmt.Printf("请输入您想翻译的单词:")
    var word string
    _, err := fmt.Scanf("%v", &word)
    if err != nil {
   
   
        fmt.Println(err)
        return
    }
    query(word)
    return
}

SOCKS5 代理

建立简单 tcp 服务器,以方便验证代理服务器结果,实现效果:往 tcp 服务器发送什么数据,就会返回打印什么数据,可用 netcat 进行验证,先安装 netcat ,步骤如下:

  1. 下载官网压缩包:netcat 1.11 for Win32/Win64 (eternallybored.org)
  2. 关闭自带杀毒软件,以防误删文件
  3. 解压并将解压后文件复制到 C:\Windows\System32 中即可(管理员权限)
  4. 打开 cmd 命令行即可使用 netcat 命令,即 nc 命令

tcp 服务器代码如下:

func main() {
   
   
    // 运行命令:go run tcp.go
    // windows 安装 netcat 之后,解压缩到 C:\Windows\System32 便可以使用 nc 命令
    // 测试命令:nc 127.0.0.1 1080
    // 监听发送给该端口的请求
    server, err := net.Listen("tcp", "127.0.0.1:1080")
    if err != nil {
   
   
        panic(err)
    }
    for {
   
   
        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)
    // 把发送的数据打印出来
    for {
   
   
        b, err := reader.ReadByte()
        if err != nil {
   
   
            break
        }
        _, err = conn.Write([]byte{
   
   b})
        if err != nil {
   
   
            break
        }
    }
}

接下来就是建立代理服务器的步骤了

image-20230513171714728

从上图,我们可以知道 SOCKS5 的实现步骤分为以下三步:

  1. 认证阶段
  2. 请求阶段
  3. relay (回复)阶段

认证阶段包括以下三个字段

VER NMETHODS METHODS
1 1 1 to 255
  1. VER: 协议版本,socks5为0x05

  2. NMETHODS: 支持认证的方法数量

  3. METHODS: 对应NMETHODS,NMETHODS的值为多少,METHODS就有多少个字节。RFC预定义了一些值的含义,内容如下:

    • 0x00:不需要认证

    • 0x02 :用户密码认证

认证阶段逻辑步骤如下:

  1. 浏览器会给代理服务器发送一个请求参数包,以便通过认证,然后服务端得选择一种认证方式,告诉客户端:VER 0x05,METHOD 可为如下

    • 如果是无需认证的话,methods 为 0x01,无需携带其他参数
    • 如果是用户密码认证的话,methods 为 0x02,需要验证用户密码
  2. 代理服务器读取请求参数,并利用 io.ReadFull 读满一个缓冲区。

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
   
   
    // 读取字段信息
    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)
    }
    // 设置为无需认证
    _, err = conn.Write([]byte{
   
   socks5Ver, 0x00})
    // 代理服务器还需要返回一个 response,返回包包括两个字段,
    // 一个是 version 一个是 method,
    if err != nil {
   
   
        return fmt.Errorf("write failed:%w", err)
    }
    return nil
}

请求阶段:在完成认证以后,客户端需要告知服务端它的目标地址,需要包括以下请求参数包

VER CMD RSV ATYP DST.ADDR DST.PORT
1 1 X'00' 1 Variable 2
  1. VER:0x05,socks5的值为0x05
  2. CMD:连接方式,0x01=CONNECT, 0x02=BIND, 0x03=UDP ASSOCIATE

  3. RSV:保留字段,现在没什么用

  4. ATYP:地址类型,0x01=IPv4,0x03=域名,0x04=IPv6

  5. DST.ADDR

    • 目标地址

    • 目标地址类型,DST.ADDR的数据对应这个字段的类型。

      0x01表示IPv4地址,DST.ADDR为4个字节

      0x03表示域名,DST.ADDR是一个可变长度的域名

  6. DST.PORT:目标端口,2字节,网络字节序(network octec order)

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
   
   
    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]
    // 读取 socks5Ver
    if ver != socks5Ver {
   
   
        return fmt.Errorf("not supported ver:%v", ver)
    }
    // 读取 cmd
    if cmd != cmdBind {
   
   
        return fmt.Errorf("not supported cmd:%v", cmd)
    }
    addr := ""
    // 处理 atyp
    switch atyp {
   
   
    case atypeIPV4:
        _, 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)
    }
    // BigEndian:“network octec order” 网络字节序
    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)
    _, 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, reader)
        cancel()
    }()
    go func() {
   
   
        _, _ = io.Copy(conn, dest)
        cancel()
    }()

    <-ctx.Done()
    return nil

最后照例简单总结下:

  • Go语言非常适合实现网络服务,代码短小精悍,性能强大
  • Socks 5 是一个简单的二进制网络代理协议
  • 网络字节序实际上就是 BigEndian,大端存储

欢迎关注我的字节后端青训营代码仓库,更新每日课后作业及其改进代码,除此之外,还会每周发布对应笔记,欢迎一起 star 或者 contribute 代码仓库

求点赞

目录
相关文章
|
1月前
|
Go 调度 开发者
Go语言中的并发编程:深入理解与实践###
探索Go语言在并发编程中的独特优势,揭秘其高效实现的底层机制。本文通过实例和分析,引导读者从基础到进阶,掌握Goroutines、Channels等核心概念,提升并发处理能力。 ###
|
13天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出,成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践,包括Go语言的特性如何适应微服务架构的需求,以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析,展示Go语言在微服务开发中的优势,并讨论在实际应用中可能遇到的挑战和解决方案。
|
20天前
|
存储 Cloud Native Shell
go库介绍:Golang中的Viper库
Viper 是 Golang 中的一个强大配置管理库,支持环境变量、命令行参数、远程配置等多种配置来源。本文详细介绍了 Viper 的核心特点、应用场景及使用方法,并通过示例展示了其强大功能。无论是简单的 CLI 工具还是复杂的分布式系统,Viper 都能提供优雅的配置管理方案。
|
20天前
|
Unix Linux Go
go进阶编程:Golang中的文件与文件夹操作指南
本文详细介绍了Golang中文件与文件夹的基本操作,包括读取、写入、创建、删除和遍历等。通过示例代码展示了如何使用`os`和`io/ioutil`包进行文件操作,并强调了错误处理、权限控制和路径问题的重要性。适合初学者和有经验的开发者参考。
|
20天前
|
数据采集 存储 XML
Python实现网络爬虫自动化:从基础到实践
本文将介绍如何使用Python编写网络爬虫,从最基础的请求与解析,到自动化爬取并处理复杂数据。我们将通过实例展示如何抓取网页内容、解析数据、处理图片文件等常用爬虫任务。
114 1
|
1月前
|
Cloud Native Go API
Go语言在微服务架构中的创新应用与实践
本文深入探讨了Go语言在构建高效、可扩展的微服务架构中的应用。Go语言以其轻量级协程(goroutine)和强大的并发处理能力,成为微服务开发的首选语言之一。通过实际案例分析,本文展示了如何利用Go语言的特性优化微服务的设计与实现,提高系统的响应速度和稳定性。文章还讨论了Go语言在微服务生态中的角色,以及面临的挑战和未来发展趋势。
|
1月前
|
Go 开发者
Go语言中的并发编程:从基础到实践
在当今的软件开发中,并发编程已经成为了一项不可或缺的技能。Go语言以其简洁的语法和强大的并发支持,成为了开发者们的首选。本文将带你深入了解Go语言中的并发编程,从基础概念到实际应用,帮助你掌握这一重要的编程技能。
|
1月前
|
SQL 关系型数据库 MySQL
Go语言项目高效对接SQL数据库:实践技巧与方法
在Go语言项目中,与SQL数据库进行对接是一项基础且重要的任务
66 11
|
20天前
|
NoSQL 测试技术 Go
自动化测试在 Go 开源库中的应用与实践
本文介绍了 Go 语言的自动化测试及其在 `go mongox` 库中的实践。Go 语言通过 `testing` 库和 `go test` 命令提供了简洁高效的测试框架,支持单元测试、集成测试和基准测试。`go mongox` 库通过单元测试和集成测试确保与 MongoDB 交互的正确性和稳定性,使用 Docker Compose 快速搭建测试环境。文章还探讨了表驱动测试、覆盖率检查和 Mock 工具的使用,强调了自动化测试在开源库中的重要性。
|
22天前
|
Go
Go语言中的并发编程:深入探索与实践###
探索Go语言的并发编程,就像解锁了一把高效处理复杂任务的钥匙。本文旨在通过简明扼要的方式,阐述Goroutines和Channels如何协同工作,以实现高效的并发处理。不同于传统的技术文档,这里我们将用一个生动的故事来串联起这些概念,让你在轻松阅读中领悟到并发编程的精髓。 ###
下一篇
无影云桌面