Golang实现简单爬虫程序 net/http与goquery结合-Golang-PHP中文网

Go语言爬虫常用错误处理策略包括：网络错误重试并配合指数退避，根据HTTP状态码区分客户端与服务器错误以决定重试逻辑，解析失败时校验HTML格式与编码，数据提取时判断空值；通过context控制超时，用fmt.Errorf包装错误保留上下文，确保爬虫健壮性。

golang实现简单爬虫程序 net/http与goquery结合

在Go语言里，想写个小爬虫，

net/http

登录后复制

库用来搞定网络请求，

goquery

登录后复制

则负责HTML解析，这俩搭起来，效率高，代码也清晰。它能让你快速从网页上抓取所需信息，而且Go的并发特性让这个过程非常高效。

解决方案

一个简单的Go爬虫，利用

net/http

登录后复制

发送HTTP请求获取网页内容，然后用

goquery

登录后复制

（一个基于jQuery语法的HTML解析库）来解析和提取数据。下面是一个基本示例，它会抓取一个指定URL，并尝试提取页面上所有的链接和页面标题。

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/url" // 用于处理相对路径
    "strings"
    "time"

    "github.com/PuerkitoBio/goquery"
)

// SimpleCrawlerConfig 定义爬虫配置
type SimpleCrawlerConfig struct {
    TargetURL string
    Timeout   time.Duration
}

// CrawlResult 定义爬取结果
type CrawlResult struct {
    Title string
    Links []string
}

// crawlPage 抓取并解析单个页面
func crawlPage(config SimpleCrawlerConfig) (*CrawlResult, error) {
    fmt.Printf("正在尝试抓取: %s\n", config.TargetURL)

    client := &http.Client{
        Timeout: config.Timeout, // 设置请求超时
    }

    req, err := http.NewRequest("GET", config.TargetURL, nil)
    if err != nil {
        return nil, fmt.Errorf("创建请求失败: %w", err)
    }
    // 可以设置User-Agent等请求头，模拟浏览器
    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")

    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("HTTP请求失败: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("HTTP状态码异常: %d %s", resp.StatusCode, resp.Status)
    }

    doc, err := goquery.NewDocumentFromReader(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("解析HTML失败: %w", err)
    }

    result := &CrawlResult{}
    result.Title = doc.Find("title").Text()

    baseURL, err := url.Parse(config.TargetURL)
    if err != nil {
        log.Printf("解析基础URL失败: %v", err)
        baseURL = nil // 继续执行，但相对路径可能不准确
    }

    doc.Find("a").Each(func(i int, s *goquery.Selection) {
        href, exists := s.Attr("href")
        if exists && href != "" {
            // 处理相对路径和绝对路径
            resolvedURL := href
            if baseURL != nil {
                parsedHref, parseErr := url.Parse(href)
                if parseErr == nil {
                    resolvedURL = baseURL.ResolveReference(parsedHref).String()
                }
            }
            // 简单过滤掉一些非HTTP(S)链接
            if strings.HasPrefix(resolvedURL, "http://") || strings.HasPrefix(resolvedURL, "https://") {
                result.Links = append(result.Links, resolvedURL)
            }
        }
    })

    return result, nil
}

func main() {
    config := SimpleCrawlerConfig{
        TargetURL: "http://example.com", // 替换成你想抓取的实际URL
        Timeout:   10 * time.Second,
    }

    crawlResult, err := crawlPage(config)
    if err != nil {
        log.Fatalf("爬取失败: %v", err)
    }

    fmt.Printf("\n页面标题: %s\n", crawlResult.Title)
    fmt.Println("\n提取到的链接:")
    for _, link := range crawlResult.Links {
        fmt.Println(link)
    }
}

登录后复制

在Go语言爬虫中，有哪些常见的错误处理策略？

说实话，写爬虫，最让人头疼的不是怎么抓取，而是怎么处理那些千奇百怪的错误。网络环境复杂，目标网站也可能随时变动，所以错误处理是构建健壮爬虫的关键。

我们通常会遇到几种错误：

立即学习“go语言免费学习笔记（深入）”；

网络错误： 比如目标服务器没响应、连接超时、DNS解析失败。
```
net/http
```
登录后复制
库在遇到这些问题时会直接返回
```
error
```
登录后复制
。我的做法是，先判断这个
```
error
```
登录后复制
是不是
```
nil
```
登录后复制
，不是的话，就得考虑是重试还是直接放弃。重试的话，可以加个指数退避（Exponential Backoff），就是每次失败后等待的时间逐渐加长，给服务器一点喘息空间，也避免自己被封IP。
HTTP状态码异常： 比如
```
404 Not Found
```
登录后复制
、
```
500 Internal Server Error
```
登录后复制
、
```
403 Forbidden
```
登录后复制
。这些错误表明请求成功发送，但服务器拒绝或无法处理。对于
```
404
```
登录后复制
，可能是页面不存在；对于
```
403
```
登录后复制
，可能需要模拟更完整的浏览器行为（比如设置
```
User-Agent
```
登录后复制
，或者处理
```
Cookie
```
登录后复制
）。我通常会根据状态码做不同的判断，有些状态码（比如
```
4xx
```
登录后复制
客户端错误）可能不需要重试，而
```
5xx
```
登录后复制
服务器错误则可以尝试重试。
HTML解析错误： 网页内容可能不完整、格式错误，或者编码有问题。
```
goquery.NewDocumentFromReader
```
登录后复制
在读取
```
resp.Body
```
登录后复制
时如果遇到IO问题，或者内容根本不是HTML，也可能返回错误。这种情况下，可能需要检查源网页的编码，或者只是简单地跳过这个页面。
数据提取错误： 即使HTML解析成功，你想要的元素可能不存在。
```
goquery
```
登录后复制
的
```
Find
```
登录后复制
方法如果没找到元素，返回的
```
Selection
```
登录后复制
会是空的，这时候调用
```
.Text()
```
登录后复制
或
```
.Attr()
```
登录后复制
通常不会报错，但会返回空字符串或
```
false
```
登录后复制
。所以，在提取数据后，需要对结果进行校验，比如判断字符串是否为空，或者数字是否有效。

在Go里面，错误处理的哲学就是显式地返回

error

登录后复制

。我喜欢用

fmt.Errorf

登录后复制

和

%w

登录后复制

来包装错误，这样能保留原始错误的上下文，方便调试。同时，对于一些可预期的错误，比如某些特定的HTTP状态码，我会自定义错误类型，让调用方能更清晰地判断错误原因。引入

context.Context

登录后复制

来管理请求的生命周期，可以实现请求的超时控制和取消，这在并发爬虫中尤其重要。

如何利用Go协程（Goroutine）和通道（Channel）提升爬虫效率？

Go语言的并发模型，说实话，是它在爬虫领域大放异彩的主要原因。

goroutine

登录后复制

和

channel

登录后复制

简直是为I/O密集型任务量身定制的。

你想啊，一个普通的爬虫，顺序地一个接一个地抓取网页，当它在等待一个网页响应时，CPU其实是闲置的。但如果用

goroutine

登录后复制

，你可以同时发起几十个甚至几百个请求。当一个请求在等待网络响应时，另一个

goroutine

登录后复制

可能已经在处理解析数据了，这样就把CPU和网络I/O的利用率都提上来了。

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

查看详情

基本思路是：

并发抓取： 每当有一个新的URL需要抓取时，就启动一个
```
goroutine
```
登录后复制
去处理它。
通道通信：
```
channel
```
登录后复制
在这里扮演着数据管道的角色。你可以用一个
```
channel
```
登录后复制
来发送待抓取的URL，用另一个
```
channel
```
登录后复制
来接收抓取到的结果。
工作池（Worker Pool）： 为了避免一下子启动太多
```
goroutine
```
登录后复制
导致资源耗尽或被目标网站封禁，通常会实现一个工作池。比如，你设置10个
```
goroutine
```
登录后复制
作为“工人”，它们从一个
```
URL
```
登录后复制
队列的
```
channel
```
登录后复制
里获取任务，完成任务后把结果发到另一个
```
channel
```
登录后复制
，然后继续等待新任务。这样就能控制并发度。

一个简单的并发抓取骨架大概是这样：

package main

import (
    "fmt"
    "log"
    "sync"
    "time"
)

// 假设 crawlPage 函数如上文定义

func main() {
    urlsToCrawl := []string{
        "http://example.com",
        "http://www.google.com", // 替换为其他可访问的URL
        "http://www.baidu.com",  // 替换为其他可访问的URL
        // 更多URL...
    }

    var wg sync.WaitGroup
    resultsChan := make(chan *CrawlResult, len(urlsToCrawl)) // 缓冲通道，防止阻塞

    for _, u := range urlsToCrawl {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            config := SimpleCrawlerConfig{
                TargetURL: url,
                Timeout:   5 * time.Second,
            }
            result, err := crawlPage(config)
            if err != nil {
                log.Printf("爬取 %s 失败: %v", url, err)
                return
            }
            resultsChan <- result // 将结果发送到通道
        }(u)
    }

    // 等待所有goroutine完成
    wg.Wait()
    close(resultsChan) // 关闭通道，表示所有结果都已发送

    // 从通道接收并处理结果
    fmt.Println("\n--- 所有并发爬取结果 ---")
    for result := range resultsChan {
        fmt.Printf("URL: %s\n", result.Title) // 这里需要知道是哪个URL的标题，CrawlResult需要增加URL字段
        fmt.Printf("标题: %s\n", result.Title)
        fmt.Printf("链接数量: %d\n", len(result.Links))
        fmt.Println("---")
    }
}

// 注意：CrawlResult 结构体需要添加一个 OriginalURL 字段
// type CrawlResult struct {
//     OriginalURL string
//     Title       string
//     Links       []string
// }
// 并在 crawlPage 中设置 OriginalURL = config.TargetURL

登录后复制

通过这种方式，你可以把抓取、解析、存储等不同阶段的任务拆分到不同的

goroutine

登录后复制

中，用

channel

登录后复制

连接起来，形成一个高效的流水线。这比单线程的效率提升可不是一点半点。

除了链接，goquery还能如何灵活地提取特定页面元素？

goquery

登录后复制

之所以好用，就是因为它把jQuery那一套CSS选择器语法搬到了Go里面。这意味着，只要你能在浏览器开发者工具里用CSS选择器定位到的元素，

goquery

登录后复制

基本都能帮你抓到。

我经常用它来抓取文章标题、图片URL，甚至是一些表格数据，只要有CSS选择器能定位到，基本就没问题。

这里是一些常用的提取方式：

提取文本内容： 如果你想抓取某个
```
div
```
登录后复制
里的文章标题，或者
```
p
```
登录后复制
标签里的段落文本，直接用
```
.Text()
```
登录后复制
方法就行。
```
// 假设要提取 class 为 "article-title" 的 h1 标签文本
title := doc.Find("h1.article-title").Text()
fmt.Printf("文章标题: %s\n", title)
```
登录后复制
提取属性值： 比如图片的
```
src
```
登录后复制
属性、链接的
```
href
```
登录后复制
属性、按钮的
```
data-id
```
登录后复制
属性等。用
```
.Attr("属性名")
```
登录后复制
方法。它会返回两个值：属性值和是否存在。
```
// 提取页面中第一张图片的 src 属性
imgSrc, exists := doc.Find("img").First().Attr("src")
if exists {
    fmt.Printf("第一张图片URL: %s\n", imgSrc)
}
```
登录后复制

遍历元素： 如果有很多个相同的元素需要提取，比如一个列表页里所有的文章卡片，可以用

.Each()

登录后复制

方法来遍历。

// 提取所有 class 为 "product-item" 的 div 里的商品名称和价格
doc.Find("div.product-item").Each(func(i int, s *goquery.Selection) {
    productName := s.Find("h2.product-name").Text()
    productPrice := s.Find("span.price").Text()
    fmt.Printf("商品 %d: %s - %s\n", i+1, productName, productPrice)
})

登录后复制

组合选择器：
```
goquery
```
登录后复制
支持各种复杂的CSS选择器，比如子元素选择器（
```
>
```
登录后复制
）、后代选择器（空格）、属性选择器（
```
[attr=value]
```
登录后复制
）、伪类选择器（
```
:nth-child
```
登录后复制
）等等。这让定位特定元素变得非常灵活。
```
// 提取 ID 为 "main-content" 下的第一个段落文本
firstParagraph := doc.Find("#main-content p:first-of-type").Text()
fmt.Printf("主内容区第一段: %s\n", firstParagraph)
```
登录后复制