跳至内容
免费开始
返回博客

Elixir 网页抓取:附可运行代码的分步指南

Robert Sfichi最后更新于 6 min read
Elixir 网页抓取:附可运行代码的分步指南
简而言之:Elixir 通过 Req 进行 HTTP 抓取,使用 Floki 解析 CSS 选择器,并 Task.async_stream 用于并发处理。本指南将构建一个爬虫,用于抓取包含 1,000 本书籍的练习目录并导出为 CSV 和 JSON 格式,同时说明在何种情况下使用 Crawly 框架更为划算,并处理那些通过 JavaScript 渲染内容的页面。

Elixir 的网页抓取主要由三个部分组成:Req 用于获取页面,Floki 通过 CSS 选择器解析 HTML,以及 Task.async_stream 并能根据您设定的限制同时抓取多页。在本指南中,您将从头到尾构建一个爬虫。它将从公开的练习目录 books.toscrape.com 收集所有书籍,跟随分页逻辑,并行处理页面,礼貌地重试失败的请求,并将结果写入 CSV 和 JSON 文件。 随后,您将通过读取嵌入的 JSON、在无头 Chrome 中渲染页面,以及从相同的 Req 代码中调用爬取 API,来爬取一个由 JavaScript 渲染的页面(quotes.toscrape.com/js/)。

该代码针对下表中的包版本,包括 Floki 0.38 的变更——该变更悄然导致许多旧教程无法正常运行。

Elixir 适合用于网页抓取吗?

是的,Elixir 非常适合需要同时抓取大量页面的爬虫。BEAM 虚拟机可以运行数千个轻量级进程,因此你可以并行抓取页面,为每个页面设置超时,并且即使某个页面抓取失败,也不会导致整个程序崩溃。Python 拥有更多的爬虫库和更成熟的浏览器工具。

在以下情况下选择 Elixir:

  • 当爬虫需要抓取数百或数千个页面,且您希望在不使用线程或回调的情况下实现受限并发时。
  • 程序需长时间运行或按计划执行,且希望将失败情况隔离在单个页面范围内。
  • 您已使用 Elixir 或 Phoenix,并希望将爬虫集成到同一代码库中。

在以下情况下选择 Python:

  • 您正在进行原型开发、探索网站,或编写一次性脚本。我们的《Python 网络爬虫指南》涵盖了这一路径。
  • 你需要进行复杂的浏览器自动化操作,或者需要某个在 Elixir 中没有对应实现的库。

Web 爬虫需要哪些 Elixir 库?

Elixir 网页抓取需要一个 HTTP 客户端和一个 HTML 解析器。对于大多数项目,Req 和 Floki 已能满足这两方面的需求,而标准库则负责处理并发、URL 和 JSON。

Job

包

版本核查时间:2026年11月

适用场景

HTTP 客户端

req

0.7.5

默认选择:重试、重定向、JSON 解码以及 Finch 连接池。0.8.0 是一个候选版本。

HTTP 客户端(替代方案)

httpoison

3.0.0

成熟的客户端。3.0 版本已迁移至 hackney 4

HTTP 客户端(中间件风格)

tesla

1.22.0

当您需要可插拔适配器和中间件时

支持CSS选择器的HTML解析

floki

0.38.5

默认选项。在查询前进行解析

CSS 和 XPath 解析

meeseeks

0.18.0

当您需要 XPath 时

CSV 输出

nimble_csv

1.3.0

NimbleCSV.RFC4180 用于电子表格兼容文件

JSON

内置 JSON

Elixir 1.18+

在较旧版本的 Elixir 上使用 jason 1.4.5

并发

Task.async_stream

标准库

有限并行获取

爬虫框架

crawly

0.17.2(2024年7月发布)

爬虫、中间件和项目处理管道

浏览器自动化

playwright_ex、wallaby

0.15.0、0.31.0

渲染与交互(参见 JavaScript 部分)

在新代码中请避免使用 hound。其最新版本 1.1.1 发布于 2020 年。

如何搭建 Elixir 网络爬虫项目

设置分为四个步骤:安装 Elixir、验证安装、创建项目以及添加依赖项。

  1. 安装 Elixir。本指南中的代码使用了内置的 JSON 模块,因此你需要 Elixir 1.18 或更高版本。
  2. 检查版本:
elixir --version
  1. 创建一个新的 Mix 项目:
mix new elixir_scraper
cd elixir_scraper
  1. 打开 mix.exs,设置 Elixir 要求,并将 Req、Floki 和 NimbleCSV 添加到依赖项中:
def project do
  [
    app: :elixir_scraper,
    version: "0.1.0",
    elixir: "~> 1.18",
    start_permanent: Mix.env() == :prod,
    deps: deps()
  ]
end

defp deps do
  [
    {:req, "~> 0.7.5"},
    {:floki, "~> 0.38.5"},
    {:nimble_csv, "~> 1.3"}
  ]
end

然后获取这些依赖项:

mix deps.get

~> 0.7.5 接受错误修复版本但不接受 0.8 版本,因此次要版本的升级需谨慎进行。运行 mix hex.audit now and then。它会列出依赖树中任何位置已弃用的包以及存在已知安全公告的包。

如何使用 Req 发送你的第一个 HTTP 请求

Req 只需一次调用即可发送请求。在项目内使用 iex -S mix 并尝试以下操作:

iex> Req.get!("https://books.toscrape.com/").status
200

若要构建真正的爬虫,请使用 Req.new/1 并将其用于每次请求。将 lib/elixir_scraper.ex 替换为以下内容:

defmodule ElixirScraper do
  def client do
    Req.new(
      headers: [user_agent: "elixir-scraper-tutorial/1.0 (+mailto:you@example.com)"],
      receive_timeout: 30_000,
      max_retries: 3
    )
  end

  def fetch!(req, url) do
    case Req.get(req, url: url) do
      {:ok, %Req.Response{status: 200, body: body}} -> body
      {:ok, %Req.Response{status: status}} -> raise "GET #{url} returned HTTP #{status}"
      {:error, exception} -> raise exception
    end
  end
end

各项选项的作用如下:

  • User-Agent 用于标识你的爬虫并提供联系地址。在练习网站上,这是基本礼仪。而在真实网站上,你通常还需要设置更符合实际的请求头。
  • receive_timeout: 30_000 会在 30 秒后放弃等待响应,而不是无限期等待。
  • max_retries: 3 限制重试次数(参见“重试”部分)。
  • fetch!/2 根据状态码 200 进行模式匹配。任何其他状态码都会在错误消息中包含 URL,而超时等传输错误也会再次触发。如果不设置此选项,404 页面将流入你的解析器。

Req 的文档涵盖了请求头、重定向、Cookie 以及其他所有选项。

如何使用 Floki 解析 HTML

Floki 将 HTML 字符串转换为可通过 CSS 选择器进行查询的文档。您只需使用 Floki.parse_document!/1,随后调用 Floki.find/2 来获取匹配的元素, Floki.attribute/2 读取属性,并 Floki.text/1 来读取文本。将此代码保存为 scripts/first_look.exs:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://books.toscrape.com/")
doc = Floki.parse_document!(html)
cards = Floki.find(doc, "article.product_pod")
IO.puts("books on this page: #{length(cards)}")

first = hd(cards)
[title] = first |> Floki.find("h3 a") |> Floki.attribute("title")
price = first |> Floki.find("p.price_color") |> Floki.text()
IO.puts("first book: #{title} (#{price})")

使用以下方式运行 mix run scripts/first_look.exs:

books on this page: 20
first book: A Light in the Attic (£51.77)

页面上的每本书都位于一张 article.product_pod 卡片中,调用 Floki.find/2 卡片上的方法时,仅会在该卡片内部进行搜索。 Floki.attribute/2 始终返回一个列表,因为选择器可能匹配多个元素,因此 [title] = 匹配操作还会检查是否仅存在一个元素。链接文本会截断过长的标题,因此我们读取 title 属性。如果您需要复习 CSS 选择器语法,我们的 CSS 选择器速查表涵盖了爬虫最常使用的模式。

为什么 Floki 会返回一个空列表?

自 Floki 0.38 起,其函数不再接受原始 HTML 字符串。如果你将响应正文直接传递给 Floki.find/2,你会得到一个空列表,且不会出现任何错误或警告:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://books.toscrape.com/")
IO.inspect(Floki.find(html, "article.product_pod"), label: "raw string")

IO.inspect(html |> Floki.parse_document!() |> Floki.find("article.product_pod") |> length(),
  label: "parsed"
)
raw string: []
parsed: 20

这看起来完全像一个错误的选择器。请先进行解析,使用 Floki.parse_document!/1 用于解析完整页面,或 Floki.parse_fragment!/1 用于片段,并将其解析后的树结构传递给其他所有函数。许多旧教程和 AI 回答仍然直接传递字符串。Floki 的变更日志中列出了这一变更以及 0.38 版本中的其他破坏性更新。

如何将结构化数据提取到映射中

将每张卡片转换为一个映射。对于每本书,我们保留书名、以数字形式表示的价格、1 到 5 分的星级评分、库存状态以及一个绝对 URL。将这些函数添加到 ElixirScraper 模块中:

  @ratings %{"One" => 1, "Two" => 2, "Three" => 3, "Four" => 4, "Five" => 5}

  def parse_books(html, page_url) do
    doc = Floki.parse_document!(html)

    books =
      doc
      |> Floki.find("article.product_pod")
      |> Enum.map(&parse_book(&1, page_url))

    next =
      case Floki.attribute(doc, "li.next a", "href") do
        [href] -> absolute_url(page_url, href)
        [] -> nil
      end

    {books, next}
  end

  defp parse_book(card, page_url) do
    link = Floki.find(card, "h3 a")
    [title] = Floki.attribute(link, "title")
    [href] = Floki.attribute(link, "href")

    price =
      card
      |> Floki.find("p.price_color")
      |> Floki.text()
      |> String.replace("£", "")
      |> String.to_float()

    [class] = card |> Floki.find("p.star-rating") |> Floki.attribute("class")
    rating = class |> String.split() |> Enum.find_value(&Map.get(@ratings, &1))

    in_stock =
      card
      |> Floki.find("p.instock.availability")
      |> Floki.text()
      |> String.contains?("In stock")

    %{
      title: title,
      price: price,
      rating: rating,
      in_stock: in_stock,
      url: absolute_url(page_url, href)
    }
  end

  defp absolute_url(page_url, href), do: page_url |> URI.merge(href) |> URI.to_string()

代码的功能如下:

  • 价格被转换为浮点数。我们去除了 £ 符号,并调用 String.to_float/1.
  • 评分来自一个类名。该网站将评分标记为 class="star-rating Three",因此我们拆分类名字符串,并根据 @ratings map中进行查询。
  • 相对链接通过 URI.merge/2。页面上的 href 页面上的值是相对的,例如 catalogue/a-light-in-the-attic_1000/index.html。将它们与页面URL合并后,便会像浏览器那样解析,包括 ../ 更深层页面中的段。
  • 该函数还会返回下一页的 URL,或者 nil 在最后一页时,用于分页操作。

使用一个简短的脚本将前两本书以 JSON 格式输出:

url = "https://books.toscrape.com/"

{books, next} =
  ElixirScraper.client() |> ElixirScraper.fetch!(url) |> ElixirScraper.parse_books(url)

IO.puts(JSON.encode!(Enum.take(books, 2)))
IO.puts("next page: #{next}")
[{"title":"A Light in the Attic","url":"https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","in_stock":true,"price":51.77,"rating":3},{"title":"Tipping the Velvet","url":"https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html","in_stock":true,"price":53.74,"rating":1}]
next page: https://books.toscrape.com/catalogue/page-2.html

映射(Maps)不保留键的顺序,这就是为什么 url 会出现在 price 出现在JSON中。如果卡片缺少某个字段, [title] = 样式匹配会触发一个 MatchError,这会立即提示你标记发生了变化。

如何在 Elixir 中处理分页

要抓取每一页,请沿着“下一页”链接继续,直到该链接消失。一个递归函数会获取一页内容,解析其中的书籍,等待半秒,然后使用下一个 URL 调用自身。当 parse_books/2 返回 nil ,或者达到你作为安全网设置的页面上限时,该函数便会停止。将以下内容添加到模块中:

  @base_url "https://books.toscrape.com/"

  def crawl(req, start_url \\ @base_url, max_pages \\ 60) do
    do_crawl(req, start_url, max_pages, [])
  end

  defp do_crawl(_req, nil, _pages_left, acc), do: finish(acc)
  defp do_crawl(_req, _url, 0, acc), do: finish(acc)

  defp do_crawl(req, url, pages_left, acc) do
    {books, next} = req |> fetch!(url) |> parse_books(url)
    if next, do: Process.sleep(500)
    do_crawl(req, next, pages_left - 1, [books | acc])
  end

  defp finish(acc), do: acc |> Enum.reverse() |> List.flatten()

两个简短的 do_crawl/4 子句是停止条件,模式匹配会挑选出正确的那个。每页的书籍都会通过 [books | acc],这很高效。若使用 acc ++ books 会将每页的整个列表都复制一次。 finish/1 在最后将列表反转一次以恢复页面顺序,并将其扁平化为一个映射列表。

运行 ElixirScraper.crawl(ElixirScraper.client()) 该程序将遍历目录中的全部 50 页,并返回 1,000 本图书。半秒的暂停用于分散请求,而页面上限限制可防止因“下一页”链接导致的无限循环。

这仍然是数据抓取,而非网页爬取:你遵循一条已知的页面链,而不是发现网站上的每个链接。如果你不确定需要哪一种,请阅读我们关于数据抓取与网页爬取区别的说明文章。

如何使用 Task.async_stream 并行抓取多个页面

当你已经知道页面 URL 时,可以使用 Task.async_stream/3。它会在独立进程中对列表中的每个元素执行函数,最多 max_concurrency 个进程同时运行,并按原始顺序返回结果。由于目录的页面 URL 遵循固定模式,我们可以预先构建全部 50 个:

  def crawl_concurrent(req, pages \\ 1..50, max_concurrency \\ 4) do
    pages
    |> Enum.map(&"#{@base_url}catalogue/page-#{&1}.html")
    |> Task.async_stream(
      fn url -> req |> fetch!(url) |> parse_books(url) |> elem(0) end,
      max_concurrency: max_concurrency,
      timeout: 60_000,
      on_timeout: :kill_task
    )
    |> Enum.flat_map(fn
      {:ok, books} ->
        books

      {:exit, reason} ->
        IO.puts("page failed: #{inspect(reason)}")
        []
    end)
  end

调用 ElixirScraper.crawl_concurrent(ElixirScraper.client()) 将返回相同的 1,000 本书。之所以这样设计:

  • 每个页面都在自己的进程中运行。如果 fetch!/2 某一页发生异常,仅该进程会崩溃。其余页面仍会继续运行。
  • max_concurrency: 4 限制了负载。提高该值会加快获取速度,但会给服务器带来更大压力。在非自有网站上请从较低值开始。
  • on_timeout: :kill_task 保持批处理处于活动状态。默认情况下,如果某个任务的运行时间超过 timeout 的任务将退出调用进程并停止整个数据流。启用 :kill_task,运行缓慢的页面将作为 {:exit, :timeout} ,其余页面则继续加载。
  • Enum.flat_map/2 保留成功的页面并记录失败情况。

Req 客户端是一个普通的结构体,因此每个进程都可以使用相同的 req 值,而 Req 的连接池负责管理套接字。Task.async_stream/3 的文档中列出了其他选项,包括 ordered: false 当顺序不重要时。

如何礼貌地重试失败的请求

Req 会自动重试失败的请求,因此您无需编写重试循环。 默认情况下,它会在收到 408、429、500、502、503 和 504 响应时,以及发生超时和连接关闭等传输错误时,重试 GET 和 HEAD 请求。每次失败后,它会等待更长时间(带有轻微的随机抖动),并在 max_retries (默认 3 次)后停止。对于 429 和 503 响应,它会等待 Retry-After (若服务器发送了该字段)。对于 404 或其他 4xx 状态码,系统不会重试,因为再次请求不会改变响应结果。

你可以通过一个始终返回 503 的测试端点观察其工作原理:

req = ElixirScraper.client()
{:ok, res} = Req.get(req, url: "https://httpbin.org/status/503")
IO.puts("final status: #{res.status}")
{:ok, res} = Req.get(req, url: "https://books.toscrape.com/does-not-exist.html")
IO.puts("final status: #{res.status}")
[warning] retry: got response with status 503, will retry in 988ms, 3 attempts left
[warning] retry: got response with status 503, will retry in 1844ms, 2 attempts left
[warning] retry: got response with status 503, will retry in 3610ms, 1 attempt left
final status: 503
final status: 404

对于 503 状态码,系统会以逐渐增加的延迟重试三次;而 404 状态码则会立即重试。由于存在抖动,您实际遇到的延迟会有所不同。

有一项设置需要特别注意。如果你传入自定义的 retry_delay,Req 会将其用于每次重试并忽略 Retry-After 标头。除非您想覆盖服务器的要求,否则请保持该参数未设置。Req重试步骤的文档中描述了 retry, retry_delay以及 retry_log_level 选项。

如何将抓取的数据保存为 CSV 和 JSON

NimbleCSV 负责生成 CSV 文件,而 Elixir 的内置 JSON 模块可写入 JSON,因此这两种导出方式只需几行代码。将以下函数添加到模块中:

  def write_csv!(books, path) do
    header = ~w(title price rating in_stock url)

    rows =
      Enum.map(books, fn book ->
        Enum.map([book.title, book.price, book.rating, book.in_stock, book.url], &to_string/1)
      end)

    File.write!(path, NimbleCSV.RFC4180.dump_to_iodata([header | rows]))
  end

  def write_json!(books, path), do: File.write!(path, JSON.encode!(books))

然后在 scripts/scrape_books.exs:

books = ElixirScraper.crawl(ElixirScraper.client())
IO.puts("books: #{length(books)}")
ElixirScraper.write_csv!(books, "books.csv")
ElixirScraper.write_json!(books, "books.json")

使用以下命令运行: mix run scripts/scrape_books.exs。 books.csv 内容如下:

title,price,rating,in_stock,url
A Light in the Attic,51.77,3,true,https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
Tipping the Velvet,53.74,1,true,https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html

NimbleCSV.RFC4180 采用带引号的标准逗号分隔格式,因此包含逗号或引号的标题会保留在同一列中。行按固定的字段顺序构建,这一点很重要,因为映射(map)不会保留键的顺序。 to_string/1 会将数字和布尔值转换为文本。NimbleCSV 文档介绍了自定义分隔符,例如制表符。

在 Elixir 中进行网页抓取时,是否应该使用 Crawly?

当你需要一个框架时,请使用 Crawly:它包含爬虫、请求队列、用于 User-Agent 和域名过滤的中间件,以及用于验证、去重并将项目写入 CSV 或 JSON 文件的处理管道。对于小型任务、自定义逻辑,或者当你希望完全控制依赖树时,请继续使用 Req 和 Floki。

一个 Crawly 项目需要 {:crawly, "~> 0.17.2"} 以及 {:floki, "~> 0.38.5"} 在 mix.exs. 创建 config/config.exs 并使用以下配置:

import Config

config :crawly,
  concurrent_requests_per_domain: 4,
  closespider_itemcount: 1000,
  closespider_timeout: 1,
  middlewares: [
    Crawly.Middlewares.DomainFilter,
    Crawly.Middlewares.UniqueRequest,
    {Crawly.Middlewares.UserAgent,
     user_agents: ["elixir-scraper-tutorial/1.0 (+mailto:you@example.com)"]}
  ],
  pipelines: [
    {Crawly.Pipelines.Validate, fields: [:title, :price, :url]},
    {Crawly.Pipelines.DuplicatesFilter, item_id: :url},
    {Crawly.Pipelines.CSVEncoder, fields: [:title, :price, :url]},
    {Crawly.Pipelines.WriteToFile, extension: "csv", folder: "out", include_timestamp: false}
  ]

保存于 lib/books_crawler/books_spider.ex中保存的爬虫,会告诉 Crawly 从何处开始,以及如何将每个响应转换为项目和新请求:

defmodule BooksCrawler.BooksSpider do
  use Crawly.Spider

  @impl Crawly.Spider
  def base_url, do: "https://books.toscrape.com/"

  @impl Crawly.Spider
  def init, do: [start_urls: ["https://books.toscrape.com/"]]

  @impl Crawly.Spider
  def parse_item(response) do
    {:ok, doc} = Floki.parse_document(response.body)

    items =
      doc
      |> Floki.find("article.product_pod")
      |> Enum.map(fn card ->
        link = Floki.find(card, "h3 a")
        [title] = Floki.attribute(link, "title")
        [href] = Floki.attribute(link, "href")
        price = card |> Floki.find("p.price_color") |> Floki.text()

        %{
          title: title,
          price: price,
          url: Crawly.Utils.build_absolute_url(href, response.request_url)
        }
      end)

    requests =
      doc
      |> Floki.attribute("li.next a", "href")
      |> Crawly.Utils.build_absolute_urls(response.request_url)
      |> Crawly.Utils.requests_from_urls()

    %Crawly.ParsedItem{items: items, requests: requests}
  end
end

从 iex -S mix ,并使用 Crawly.Engine.start_spider(BooksCrawler.BooksSpider)。该爬虫会跟随“next”链接,管道会验证并去除每本书的重复项,当达到 1,000 个条目时运行停止,并在 out/.

在采用之前请了解其取舍:

  • 版本发布频率已放缓。Crawly 的最新版本是 0.17.2,发布于 2024 年 7 月。
  • 它锁定了较旧的 HTTP 客户端。Crawly 需要 httpoison ~> 2.2,因此将 {:httpoison, "~> 3.0"} 会因“版本解析失败”而报错。
  • 请审核代码库。这种版本锁定会使项目中保留旧版的 HTTP 堆栈。截至本文撰写之时, mix hex.audit flags 已针对 Crawly 的 HTTP 依赖项发布了安全公告,因此请在发布前运行该工具并阅读其报告内容。
  • 该 CSV 文件没有标题行。 CSVEncoder 仅写入数据行,且 WriteToFile 即使启用了 include_timestamp: false.
  • 编码器是管道。 CSVEncoder 或 JSONEncoder 必须位于 pipelines 之前 WriteToFile,而非位于 middlewares.

如果任务发展为按计划收集大量相关页面,你也可以将 URL 发现和限制交由受控且有界限的爬取处理。

如何在 Elixir 中抓取由 JavaScript 渲染的页面

Req 只能看到服务器发送的 HTML。如果页面在加载后通过 JavaScript 构建内容,那么该内容不会出现在响应中,你的 Floki 选择器将返回空结果。 在更换工具之前,请先确认问题是否出在这里,然后选择最轻量级的解决方案:首先尝试嵌入式数据,其次是无头浏览器,若渲染仅是问题的一部分,则采用受控 API。

如何检查页面是否需要 JavaScript

使用 Req 抓取页面并统计预期元素的数量。quotes.toscrape.com/js/ 在浏览器中显示 10 条报价。在模块中添加一个计数器:

  def count_quotes(html) do
    html |> Floki.parse_document!() |> Floki.find("div.quote") |> length()
  end

在原始 HTML 上运行它:

div.quote in raw HTML: 0

HTML 中匹配项为零,而屏幕上显示 10 个,说明这些引号是由 JavaScript 生成的。你可以手动确认:查看源代码会显示服务器发送的内容,而开发者工具的“元素”面板则显示脚本运行后的页面。

首先提取嵌入的 JSON

许多 JavaScript 页面会将数据封装在 HTML 内部,以行内 <script> 中,供页面代码读取。quotes.toscrape.com/js/ 通过 var data = [...]。使用正则表达式捕获该数组,并使用 JSON.decode!/1进行解码,整个过程无需浏览器参与:

  def embedded_quotes(html) do
    [_, json] = Regex.run(~r/var data = (\[.*?\]);\s*for \(var i/s, html)

    json
    |> JSON.decode!()
    |> Enum.map(fn q -> %{text: q["text"], author: q["author"]["name"], tags: q["tags"]} end)
  end

对同一响应调用这两个函数:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://quotes.toscrape.com/js/")
IO.puts("div.quote in raw HTML: #{ElixirScraper.count_quotes(html)}")
quotes = ElixirScraper.embedded_quotes(html)
IO.puts("quotes from the inline script: #{length(quotes)}")
IO.inspect(hd(quotes))
div.quote in raw HTML: 0
quotes from the inline script: 10
%{
  author: "Albert Einstein",
  text: "“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”",
  tags: ["change", "deep-thoughts", "thinking", "world"]
}

这就是来自单次 HTTP 请求的全部 10 条引用,已按结构整理。正则表达式锚定在数组后的代码上,因此会在正确的 ];处停止。此类正则表达式模式在脚本变更时会失效,因此请保持其特定性。

同样的思路也适用于页面打开后加载的数据。打开开发者工具的“网络”标签页,按“Fetch/XHR”过滤,然后刷新页面。如果页面调用了 JSON 接口,可直接使用 Req 进行请求。Req 会将 JSON 解码为映射对象,这比解析 HTML 更高效。

使用无头 Chrome 渲染页面

如果数据仅在渲染后才存在,请让真实浏览器运行脚本。Chrome 的无头模式可通过 --dump-dom,而 Elixir 可以通过 System.cmd/2:

  def render_with_chrome(url, chrome \\ "google-chrome") do
    {html, 0} = System.cmd(chrome, ["--headless=new", "--dump-dom", url])
    html
  end
html = ElixirScraper.render_with_chrome("https://quotes.toscrape.com/js/")
IO.puts("div.quote after rendering: #{ElixirScraper.count_quotes(html)}")
div.quote after rendering: 10

该 {html, 0} match 会确保当 Chrome 因错误退出时调用失败,且渲染后的 HTML 将经过与之前相同的 Floki 代码处理。运行爬虫的机器上必须安装 Chrome 或 Chromium。若二进制文件名称不同,请将 "chromium" 或完整路径作为第二个参数。每次调用都会启动一个完整的浏览器,因此请保持并发数较低。Chrome 无头模式的文档中还介绍了其他标志,例如 --screenshot 和 --window-size.

浏览器自动化替代方案

当需要点击、滚动或等待特定元素时, --dump-dom 仅靠 Chrome 是不够的。playwright_ex 是 Playwright Node.js 驱动程序的 Elixir 客户端,因此需要在应用程序旁安装 Node.js 和 Playwright。Wallaby 通过 ChromeDriver 或 Selenium 驱动浏览器,但它专为测试 Web 应用程序而设计,而非用于爬取。 Crawly 可以通过浏览器渲染服务发送其请求。这也解答了“Elixir 与 Selenium 孰优孰劣”的问题:Selenium 是一个浏览器驱动程序,而非一种编程语言,而 Elixir 是通过 Wallaby 等 WebDriver 库来调用它的。所有这些都意味着你需要自行运行和更新浏览器。 如果您需要渲染、等待和截图功能,可以通过将任务发送至托管浏览器运行时,在无需运行浏览器的情况下渲染页面。

自行实现的 Elixir 爬取何时会遇到瓶颈?

你刚刚构建的爬虫之所以能正常工作,是因为 books.toscrape.com 和 quotes.toscrape.com 是欢迎自动化请求的练习站点。而许多生产环境中的网站并不欢迎。 那段能返回 1,000 本完整书籍的代码,在面对 403 响应、验证码页面、按 IP 的速率限制、浏览器指纹检测或因国家/地区而异的内容时,可能会开始失败。BEAM 的并发性在此无济于事,因为这些限制取决于请求者是谁,而非你能发起多少次请求。

症状

可能原因

自行修复方法

何时停止

每次请求都返回 403 禁止访问

网站将您的客户端或IP地址标记为可疑

发送合理的请求头,降低请求频率

即使请求频率降低,封禁状态仍持续存在

429 请求过多

按IP或按会话限流

降低 max_concurrency,遵守 Retry-After

您需要的吞吐量超过了一个IP地址所能支持的范围

显示验证码页面而非内容

机器人检测

降低请求频率,查看网站的使用条款

正常流量中也会出现验证码

在浏览器中有效,但在无头Chrome中无效

指纹检查

审查无头模式启动选项

您正在维护浏览器补丁

根据地区显示不同的内容或价格

基于地理位置的响应

通过该国的IP地址进行路由

您需要支持多个国家

每次自行修复都会增加需要运行的基础设施:代理池、浏览器集群、重试队列和监控。我们关于如何避免被封锁的指南深入探讨了请求头、速率控制和代理。到一定程度时,将数据抓取任务交给服务处理,而将 Elixir 代码保留用于解析和存储,会更加合理。

如何从 Elixir 调用 Scraper API

Scraper API 会为您抓取页面、处理代理和重试,并能渲染 JavaScript,而您的 Elixir 代码仍保持相同的 Req 和 Floki 步骤。您只需发送一个包含 API 密钥和目标 URL 的 GET 请求,然后添加如下选项: render_js 或 country 仅当页面需要时才添加这些选项。

此函数通过 API 从美国位置渲染 JavaScript 报价页面,并从环境变量中读取密钥:

  def scraper_api(target_url, country \\ "us") do
    api_key = System.fetch_env!("WSA_API_KEY")

    Req.get("https://api.webscrapingapi.com/v2",
      params: [api_key: api_key, url: target_url, render_js: 1, country: country],
      receive_timeout: 120_000,
      retry: false
    )
  end

在解析之前调用它并检查状态:

case ElixirScraper.scraper_api("https://quotes.toscrape.com/js/") do
  {:ok, %Req.Response{status: 200, body: html}} ->
    IO.puts("quotes via Scraper API: #{ElixirScraper.count_quotes(html)}")

  {:ok, %Req.Response{status: status, body: body}} ->
    IO.puts("Scraper API returned #{status}: #{inspect(body)}")

  {:error, exception} ->
    IO.puts("request failed: #{Exception.message(exception)}")
end

将其保存为 scripts/scraper_api.exs,在终端中设置该键,然后运行:

export WSA_API_KEY="your_api_key"
mix run scripts/scraper_api.exs

为什么代码是这样的:

  • params: 会为您对目标 URL 进行编码。Req 会构建查询字符串,因此 ?, /,以及 & 等字符都不会导致请求失败。
  • System.fetch_env!/1 会快速失败。如果该变量未设置,它会在 System.EnvError 异常,且在任何请求发出之前。
  • 超时时间比以前更长。渲染页面所需的时间比普通数据获取更长,因此 120 秒为 API 加载和渲染页面留出了余地。
  • retry: false 避免重复调用。API 端已自行重试,因此客户端重试只会重复相同的工作。
  • 错误分支会显示请求体。Req 会将 JSON 错误请求体解码为映射,因此无效键会输出 Scraper API returned 401: %{"error" => "Invalid API key"}.

请将 API 密钥保存在服务器端。切勿将其包含在客户端代码中、提交到代码库,或打印在日志中。

常见的 Elixir 爬取错误及解决方法

大多数 Elixir 爬虫错误源于库的变更、依赖冲突,或是页面内容与预期不符。以下是各种症状及其解决方法。

错误或症状

原因

解决方法

Floki.find/2 返回 [] 在您确定存在匹配内容的页面上

Floki 0.38 需要经过解析的输入

调用 Floki.parse_document!/1 first

解析后选择器未返回任何内容

JavaScript 渲染的内容或选择器错误

检查原始 HTML,然后参考 JavaScript 部分

针对 crawly 和 httpoison 的“版本解析失败”

Crawly 0.17.2 要求 httpoison ~> 2.2

请勿将 HTTPoison 3 与 Crawly 并列,也不要在未使用 Crawly 的情况下使用 Req

mix hex.audit 列出了安全公告

旧的传递性依赖项

更新依赖项,并重新评估那些锁定旧版 HTTP 堆栈的包

重试被忽略 Retry-After

自定义 retry_delay 已设置

移除 retry_delay 或自行处理该标头

整个批处理因超时而退出

某个页面超时 Task.async_stream 超时,这将默认导致调用方退出

触发 timeout,设置 on_timeout: :kill_task、记录并继续

403 或 429 响应

阻塞或速率限制

减速、降低 max_concurrency,然后参阅“DIY 墙”部分

输出中的相对 URL

原始 href 值

使用以下方式解析它们 URI.merge/2

The JSON 模块未定义

Elixir 版本低于 1.18

请升级 Elixir,或使用 Jason

当错误未在表格中时,请打印状态码和响应正文的前几百字节。一旦看到服务器发送的内容,大多数抓取错误就会显而易见。

如何使用 Elixir 负责任地进行抓取

以网站所有者能够接受的方式进行抓取。阅读遵循《机器人排除协议》(RFC 9309)的 robots.txt 文件,并跳过其中禁止您的用户代理访问的路径。保持 max_concurrency 低频率、增加延迟,并让 Req 遵守 Retry-After 。使用包含联系地址的 User-Agent 标识您的客户端。遵守网站的服务条款,除非有明确的法律依据,否则避免收集个人数据。有关我们对此的处理方式的更多信息,请参阅我们的负责任的网络数据实践。

FAQ

Elixir 适合网络爬虫吗?

是的,特别是对于需要同时抓取大量页面的爬虫。BEAM 运行轻量级进程,因此 Task.async_stream 仅需几行代码即可实现受限并发、超时机制和故障隔离。Python 拥有更多的爬虫库和浏览器工具,因此在编写一次性脚本和进行复杂的浏览器自动化操作时通常速度更快。

哪款 Elixir 库最适合网络爬虫?

大多数项目会将用于 HTTP 请求的 Req 与通过 CSS 选择器解析 HTML 的 Floki 搭配使用。此外,还可添加 NimbleCSV 处理电子表格,使用内置的 JSON 模块生成 JSON 输出,并 Task.async_stream 用于并发处理。HTTPoison 是一个成熟的替代客户端,而 Crawly 则是一个完整的框架,适用于需要蜘蛛程序和项目处理管道的情况。

为什么 Floki.find 会返回一个空列表?

自 Floki 0.38 起,函数不再接受原始 HTML 字符串,因此将响应正文直接传递给 Floki.find 会静默返回空值。请先使用 Floki.parse_document!。如果仍然得到一个空列表,可能是选择器与标记不匹配,或者内容由 JavaScript 渲染,并不在服务器的 HTML 中。

如何使用 Elixir 抓取由 JavaScript 渲染的网站?

首先确认原始 HTML 中是否缺少该数据。然后在页面中的内联脚本或 JSON 请求中查找该数据,并使用 JSON.decode!进行解码。如果数据仅在渲染后才存在,请从 System.cmd,使用 playwright_ex 等浏览器库,或调用能够渲染 JavaScript 的爬取 API。

在 Elixir 中进行网页抓取时,应该使用 Crawly 还是 Req?

当您完全掌控整个流程时(例如处理少量网站、自定义逻辑以及自主管理并发),请使用 Req 和 Floki;当您需要一个包含爬虫、请求调度、中间件和项目处理管道的框架时,请使用 Crawly。Crawly 的最新版本仍依赖于 HTTPoison 2,因此在采用之前,请通过 mix hex.audit 。

可以在 Elixir 中使用 Selenium 吗?

可以,通过 WebDriver 库实现。Wallaby 通过 ChromeDriver 或 Selenium 驱动浏览器,不过它主要是为测试 Web 应用而非数据抓取而设计的。playwright_ex 是 Playwright Node.js 驱动程序的 Elixir 客户端。对于简单的页面,可以使用 --dump-dom 从 System.cmd 通常足以获取渲染后的 HTML。

如何在使用 Elixir 进行数据抓取时避免被封禁?

发送清晰的 User-Agent、限制并发数、在页面之间增加延迟,并让 Req 对 429 和 503 响应进行重试(这默认会遵守 Retry-After 。请遵守 robots.txt 规则及网站的使用条款。对于采用验证码、指纹识别或按 IP 限流的网站,仍可能被封禁,此时轮换 IP 或使用托管式爬取 API 便能派上用场。

下一步该怎么做

现在,您已经拥有了一个能够获取、解析、分页、并行处理页面、礼貌重试并导出干净数据的 Elixir 爬虫。只需再进行几个步骤,它就能投入生产环境:

  • 添加按主机限流机制,使每个进程共享一个请求配额,而不是仅依赖睡眠时间和 max_concurrency 等手段。
  • 仅在必要时进行渲染。将 Req 保留用于静态页面和嵌入式 JSON,仅将需要 JavaScript 的页面发送至无头 Chrome。
  • 在遇到阻塞时将数据获取任务移交出去。一旦你在代理和验证码处理上花费的时间超过了解析时间,就将数据获取步骤移交给托管 API,并保留其余的 Elixir 代码。

保留您的 Elixir 代码,跳过阻塞操作

将同一个 Req 客户端指向 Scraper API,即可从您选择的国家/地区获取已渲染的页面,无需自行运行浏览器或代理。起始配额为 5,000 次免费请求。JavaScript 渲染或地理定位不额外消耗配额,且失败的请求不计费。

查看 Scraper API 定价

关于作者

Robert Sfichi, 全栈开发工程师 @ WebScrapingAPI

Robert Sfichi

全栈开发工程师

罗伯特·斯菲奇是 WebScrapingAPI 的团队成员,致力于产品开发,并协助构建可靠的解决方案,以支持该平台及其用户。

开始构建

准备好扩展您的数据收集规模了吗?

加入2,000多家企业,使用WebScrapingAPI在无需任何基础设施开销的情况下,以企业级规模提取网络数据。