Golang爬虫实战：net/http与goquery结合使用

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

在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语言爬虫中，有哪些常见的错误处理策略？

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

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

• 网络错误： 比如目标服务器没响应、连接超时、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的利用率都提上来了。

基本思路是：

1. 并发抓取： 每当有一个新的URL需要抓取时，就启动一个goroutine去处理它。
2. 通道通信： channel在这里扮演着数据管道的角色。你可以用一个channel来发送待抓取的URL，用另一个channel来接收抓取到的结果。
3. 工作池（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)

掌握了这些基本的goquery用法，再结合对目标网页HTML结构的分析，基本上就能搞定大部分的数据提取需求了。很多时候，我会在浏览器里先用开发者工具尝试各种CSS选择器，确定能准确无误地定位到目标元素后，再把选择器写到Go代码里。