GoColly：打造高效、智能的网页爬取利器，掌握数据世界的钥匙

最新推荐文章于 2024-03-25 10:32:02 发布

代码炼金术

最新推荐文章于 2024-03-25 10:32:02 发布

阅读量2.5k

点赞数 27

分类专栏： GoLang-并发之王文章标签： go爬虫 python爬虫 colly scripy 多线程爬虫爬虫 golang

本文链接：https://blog.csdn.net/raymend_lee/article/details/135716666

版权

GoLang-并发之王专栏收录该内容

8 篇文章 0 订阅

订阅专栏

GoColly：打造高效、智能的网页爬取利器，掌握数据世界的钥匙

Colly 是一个用于 Web 爬虫和数据抓取的 Go 语言库。它提供了一个简单而灵活的方式来编写和执行网页抓取任务。以下是 Colly 的一些主要特点和功能：

灵活性：Colly 提供了丰富的 API，使您能够灵活地定义和控制爬取过程。您可以定义要访问的起始 URL、要提取的数据、要执行的操作等。
并发支持：Colly 充分利用了 Go 语言的并发特性，可以并行处理多个请求，从而提高爬取效率。
选择器（Selector）：Colly 内置了类似于 CSS 选择器的功能，使您能够方便地定位和提取网页中的元素。您可以根据标签、类名、ID 等属性来选择要抓取的数据。
请求处理：Colly 提供了丰富的请求处理功能，包括设置请求头、处理 Cookie、处理重定向、处理表单提交等。
数据提取：Colly 支持使用正则表达式和 XPath 来提取网页中的数据。您可以根据自己的需求选择合适的方法。
中间件（Middleware）：Colly 允许您使用中间件来自定义请求处理过程。您可以添加自己的中间件来处理请求前后的逻辑，例如修改请求参数、记录日志等。
扩展性：Colly 架构设计良好，易于扩展。您可以根据自己的需求编写自定义的扩展。

总体而言，Colly 是一个功能强大、易于使用的 Web 爬虫库，适用于各种数据抓取和网页分析的场景。无论是简单的数据采集任务还是复杂的网站抓取任务，Colly 都可以帮助您快速实现。

Colly 相对于 Scrapy 具有以下几个优势：

并发性能：由于 Colly 使用 Go 语言编写，可以充分利用 Go 语言的并发特性。Go 语言在处理并发请求方面表现出色，因此 Colly 在处理大规模并发请求时可能比 Scrapy 更高效。
执行效率：Go 语言以其高效的性能而闻名，编译后的 Colly 代码可以直接作为可执行文件运行，而不需要依赖 Python 解释器。这意味着 Colly 在执行上可能比 Scrapy 更快速和节省资源。
部署简便：Colly 的可执行文件可以直接在目标环境中部署，而不需要额外配置 Python 环境。这使得 Colly 在部署和移植方面更为简便。
Go 语言生态系统：虽然 Colly 的社区相对较小，但是 Go 语言本身具有强大的生态系统，提供了许多高质量的库和工具。这可以使您在使用 Colly 过程中获得更多的支持和扩展选项。

需要注意的是，Scrapy 作为一个成熟的 Python 爬虫框架，具有广泛的用户基础、丰富的文档和社区支持。它提供了许多高级功能，如内置的处理器和中间件，以及丰富的插件生态系统。

Colly的安装和使用：

安装 Colly：在 Go 语言环境中，您可以使用以下命令安装 Colly：
```
go get -u github.com/gocolly/colly/v2
```
```

创建一个新的 Go 文件并导入 Colly 包：

package main

import (
    "fmt"
    "github.com/gocolly/colly/v2"
)

func main() {
    // 在这里编写您的爬虫代码
}
```

创建一个 Colly Collector 对象并设置相关配置：

func main() {
    c := colly.NewCollector()

    // 设置 User-Agent
    c.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"

    // 可选：设置代理
    // c.SetProxy("http://your-proxy-url")

    // 在这里编写您的爬虫代码
}
```

定义回调函数来处理请求的响应和提取数据：

func main() {
    c := colly.NewCollector()

    c.OnHTML("h1", func(e *colly.HTMLElement) {
        fmt.Println(e.Text)
    })

    c.OnRequest(func(r *colly.Request) {
        fmt.Println("Visiting", r.URL.String())
    })

    // 在这里编写您的爬虫代码
}
```

在上面的例子中，`OnHTML` 设置了一个回调函数，用于提取 `<h1>` 标签中的文本内容。`OnRequest` 设置了另一个回调函数，用于在发起请求时打印访问的 URL。

添加起始 URL 并启动爬虫：

func main() {
    c := colly.NewCollector()

    c.OnHTML("h1", func(e *colly.HTMLElement) {
        fmt.Println(e.Text)
    })

    c.OnRequest(func(r *colly.Request) {
        fmt.Println("Visiting", r.URL.String())
    })

    // 添加起始 URL
    c.Visit("http://example.com")

    // 在这里编写您的爬虫代码
}
```

在上面的例子中，我们使用 `c.Visit` 方法添加了一个起始 URL，爬虫会从该 URL 开始进行抓取。

运行代码并观察结果：

go run main.go
```

运行代码后，Colly 将会发起请求并调用相应的回调函数来处理响应和提取数据。

这只是 Colly 的基本用法示例，您可以根据自己的需求使用更多的 Colly API，例如设置请求头、处理 Cookie、处理表单提交等。通过 Colly 的灵活性和丰富的功能，您可以编写出强大的网络爬虫和数据抓取程序。

当使用 Colly 进行网页爬取时，以下是一些可以帮助您更深入了解和使用 Colly 的关键概念和功能：

选择器（Selector）：Colly 提供了类似于 CSS 选择器的功能，可以根据标签名、类名、ID、属性等来选择要抓取的数据。您可以使用 OnHTML 方法设置相应的选择器，并在回调函数中处理选中的元素。
```
c.OnHTML("div.article", func(e *colly.HTMLElement) {
    // 处理选中的 div.article 元素
})
```
```

提取数据：Colly 支持通过正则表达式和 XPath 来提取网页中的数据。您可以使用 OnHTML 方法结合正则表达式或 xpath 参数来选择和提取数据。

c.OnHTML("div.article", func(e *colly.HTMLElement) {
    // 使用正则表达式提取数据
    matchedData := e.DOM.Text()

    // 使用 XPath 提取数据
    xpathData := e.DOM.Find("//div[@class='content']").Text()
})
```

请求处理：Colly 提供了多种请求处理功能，包括设置请求头、处理 Cookie、处理重定向、处理表单提交等。您可以使用 BeforeRequest 方法添加回调函数，在发起请求之前对请求进行处理。

c.OnRequest(func(r *colly.Request) {
    // 设置请求头
    r.Headers.Set("Referer", "http://example.com")

    // 处理 Cookie
    r.Headers.Set("Cookie", "sessionid=123456789")

    // 处理重定向
    r.AllowURLRevisit = true

    // 处理表单提交
    r.Method = "POST"
    r.Body = []byte("username=test&password=123456")
})
```

中间件（Middleware）：Colly 允许您使用中间件来自定义请求处理过程。中间件可以在请求前后执行自定义的逻辑，例如修改请求参数、记录日志、验证身份等。您可以使用 c.Use 方法添加自定义的中间件。

c.Use(func(next colly.Handler) colly.Handler {
    return colly.HandlerFunc(func(r *colly.Response) {
        // 在请求前执行逻辑
        fmt.Println("Before request")

        // 继续处理请求
        next.HandleResponse(r)

        // 在请求后执行逻辑
        fmt.Println("After request")
    })
})
```

错误处理：Colly 具有错误处理机制，您可以使用 OnError 方法设置错误处理函数。在爬取过程中，如果发生错误，例如请求失败或提取数据时出错，Colly 将调用相应的错误处理函数。
```
c.OnError(func(r *colly.Response, err error) {
    // 处理错误
})
```
```
并发设置：Colly 允许您根据需要设置并发请求的数量。通过 c.Limit 方法，您可以限制同时运行的并发请求的数量。
```
c.Limit(&colly.LimitRule{
    DomainGlob:  "*",
    Parallelism: 2,
})
```
```

这些是 Colly 的一些重要概念和功能，可以帮助您更好地使用 Colly 进行网页爬取和数据抓取。您可以根据具体的需求和场景，灵活运用这些功能来构建强大的爬虫程序。要了解更多关于 Colly 的详细信息和示例，请查阅 Colly 的官方文档。

当使用 Colly 进行网页爬取时，可以帮助您更深入了解和使用 Colly：

路由（Router）：Colly 提供了路由功能，可以根据不同的 URL 模式将请求分配给不同的处理函数。您可以使用 c.OnURL 方法设置路由规则，并在回调函数中处理相应的请求。
```
c.OnURL("/posts/[0-9]+", func(r *colly.Response) {
    // 处理匹配的 URL 请求
})
```
```

子收集器（Subcollector）：Colly 支持创建子收集器，可以在回调函数中创建新的 Colly 收集器，并使用子收集器进行嵌套的网页爬取。这对于需要在特定页面上进行深度抓取或递归爬取的情况非常有用。

c.OnHTML("a.link", func(e *colly.HTMLElement) {
    subCollector := c.Clone()
    subCollector.OnHTML("div.content", func(e *colly.HTMLElement) {
        // 处理子收集器中的数据
    })
    subCollector.Visit(e.Attr("href"))
})
```

定时任务（Scheduler）：Colly 提供了调度器功能，可以使用 c.Limit 方法结合时间间隔来设置爬虫的请求速率。这可以帮助您控制请求的频率，避免对目标服务器造成过大的负载。
```
c.Limit(&colly.LimitRule{
    DomainGlob:  "*",
    Parallelism: 2,
    Delay:       2 * time.Second,
})
```
```

存储数据：Colly 允许您将抓取的数据保存到不同的存储介质，例如文件、数据库或消息队列。您可以在回调函数中将数据保存到所需的存储介质中。

c.OnHTML("div.post", func(e *colly.HTMLElement) {
    // 提取数据并保存到数据库
    title := e.ChildText("h2.title")
    content := e.ChildText("div.content")
    // 将数据保存到数据库
})
```

多线程支持：Colly 支持多线程操作，可以在爬虫程序中使用多个并发的 Colly 收集器。这可以提高爬取效率，同时处理多个请求。

collector1 := colly.NewCollector()
collector2 := colly.NewCollector()

// 在 collector1 中处理请求
collector1.Visit("http://example.com")

// 在 collector2 中处理请求
collector2.Visit("http://example2.com")
```

处理动态网页：Colly 默认是基于静态页面的爬虫框架，但您也可以结合其他工具（如 Selenium）来处理动态网页。通过在回调函数中执行 JavaScript 代码，您可以模拟用户行为和与 JavaScript 交互，从而爬取动态生成的内容。

c.OnHTML("div.comments", func(e *colly.HTMLElement) {
    // 执行 JavaScript 代码
    e.DOM.CallFunction(`function() {
        // 在页面上滚动以加载更多评论
        window.scrollTo(0, document.body.scrollHeight);
    }`)
})
```

登录和会话管理：如果需要爬取需要登录的网站或需要处理会话的网站，您可以使用 Colly 的 Cookie 和表单处理功能来管理会话状态。通过在回调函数中模拟登录过程，您可以获取登录后的页面内容。

c.OnHTML("form#login-form", func(e *colly.HTMLElement) {
    // 填写登录表单
    e.Request.PostForm = url.Values{
        "username": {"your-username"},
        "password": {"your-password"},
    }
    // 提交表单
    e.Request.Method = "POST"
    e.Request.URL = e.Request.AbsoluteURL(e.Attr("action"))
    c.OnResponse(func(r *colly.Response) {
        // 处理登录后的响应
    })
    c.Visit(e.Request.URL.String())
})
```

User-Agent 和代理设置：某些网站可能会根据 User-Agent 头信息或 IP 地址来限制爬虫访问。您可以使用 Colly 的请求处理功能来设置自定义的 User-Agent 头信息和代理服务器，以模拟不同的浏览器和 IP 地址。

c.OnRequest(func(r *colly.Request) {
    // 设置自定义 User-Agent
    r.Headers.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36")

    // 设置代理服务器
    r.ProxyURL = "http://your-proxy-server.com:8080"
})
```

使用代理池：如果您需要在爬取过程中使用多个代理，可以考虑使用代理池。代理池是一组可用的代理服务器，您可以轮流使用它们来进行请求，以增加请求的多样性和匿名性。

proxyPool := []string{"http://proxy1:8080", "http://proxy2:8080", "http://proxy3:8080"}

c.OnRequest(func(r *colly.Request) {
    // 随机选择代理
    proxy := proxyPool[rand.Intn(len(proxyPool))]
    r.ProxyURL = proxy
})
```

处理重试和错误：在爬取过程中，可能会遇到连接超时、请求失败或其他错误。您可以使用 Colly 的错误处理功能来处理这些错误，并实现重试机制，以增加爬取的稳定性。

c.OnError(func(r *colly.Response, err error) {
    // 处理错误
    // 可以选择重试请求
    if shouldRetry(err) {
        c.Retry(r, err)
        return
    }
})
```

这些技巧和功能可以帮助您更好地使用 Colly 进行网页爬取和数据抓取。请注意，在进行网页爬取时，请确保遵守网站的规则和法律，并尊重网站的使用条款和隐私政策。

Colly 支持多协程操作，这意味着您可以在并发的情况下运行多个 Colly 收集器，从而提高爬取效率。以下是在 Colly 中实现多协程的一般方法：

创建多个 Colly 收集器：使用 colly.NewCollector 函数创建多个 Colly 收集器实例。每个收集器实例都可以独立运行并处理自己的请求。
```
collector1 := colly.NewCollector()
collector2 := colly.NewCollector()
```
```

分配任务：将要爬取的任务分配给不同的收集器。可以根据不同的 URL、域名或其他条件将任务分配给不同的收集器。

// 为第一个收集器分配任务
collector1.Visit("https://example.com/page1")

// 为第二个收集器分配任务
collector2.Visit("https://example.com/page2")
```

启动收集器：对于每个收集器实例，使用 Visit 方法启动爬取任务。每个收集器将独立地运行并发出自己的请求。

// 启动第一个收集器
go collector1.Visit("https://example.com/page1")

// 启动第二个收集器
go collector2.Visit("https://example.com/page2")
```

控制并发度：使用 collector.Limit 方法来设置每个收集器的并发度。可以限制每个收集器同时执行的请求数量，以避免对目标服务器造成过大的负载。

// 设置第一个收集器的并发度为2
collector1.Limit(&colly.LimitRule{Parallelism: 2})

// 设置第二个收集器的并发度为4
collector2.Limit(&colly.LimitRule{Parallelism: 4})
```

请注意，使用多协程爬取时，需要注意线程安全性和数据共享的问题。确保在不同的协程中操作共享数据时进行正确的同步和保护。

通过在不同的协程中并发运行多个 Colly 收集器，您可以提高爬取的效率，并更快地获取所需的数据。

确定每个收集器的合适并发度以避免对目标服务器造成过大的负载是一个需要进行实验和调整的过程。以下是一些指导原则，可以帮助您确定合适的并发度：

目标服务器的负载能力：不同的服务器和网站对并发请求的负载能力有所不同。一些服务器可能能够处理大量的并发请求，而其他服务器可能在面对过多并发请求时性能下降。了解目标服务器的负载能力是很重要的。
初始设置较低的并发度：在开始时，可以选择较低的并发度，例如 1 或 2。这样可以在不过载服务器的情况下进行初始测试，并逐渐增加并发度以找到最佳值。
监测请求响应时间：通过监测请求的响应时间，可以评估服务器的负载情况。如果请求响应时间开始显著增加，说明服务器可能已经达到或接近其负载极限。根据响应时间的变化，可以调整并发度。
逐步增加并发度：从初始的较低并发度开始，逐步增加并发度，并观察服务器的响应时间。如果响应时间保持在可接受范围内，可以继续增加并发度。如果响应时间开始增长，表示服务器正在负载过重，应该降低并发度。
并发度和请求间隔的平衡：除了并发度，还要考虑请求之间的间隔时间。如果请求间隔太短，即使并发度较低，服务器仍可能承受过大的负载。在调整并发度时，还要考虑增加请求之间的间隔时间，以减轻服务器的负担。
监控服务器日志和错误响应：定期检查目标服务器的日志和错误响应，以检测是否有过多的请求被拒绝或发生其他错误。这些信息可以帮助您调整并发度和请求间隔，以避免对服务器造成过大的负载。

通过项目测试并逐步调整，并结合对目标服务器的了解，您可以找到适合每个收集器的合适并发度，以平衡爬取效率和对服务器的负载。请始终遵守网站的使用条款和爬虫规则，确保合法和道德地进行网页爬取。

代码炼金术

关注

27
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
0
评论
GoColly：打造高效、智能的网页爬取利器，掌握数据世界的钥匙

这只是 Colly 的基本用法示例，您可以根据自己的需求使用更多的 Colly API，例如设置请求头、处理 Cookie、处理表单提交等。通过 Colly 的灵活性和丰富的功能，您可以编写出强大的网络爬虫和数据抓取程序。通过项目测试并逐步调整，并结合对目标服务器的了解，您可以找到适合每个收集器的合适并发度，以平衡爬取效率和对服务器的负载。需要注意的是，Scrapy 作为一个成熟的 Python 爬虫框架，具有广泛的用户基础、丰富的文档和社区支持。根据响应时间的变化，可以调整并发度。
复制链接

扫一扫