scrapy-splash 0.9.0

安装

使用 pip 安装 scrapy-splash

$ pip install scrapy-splash

Scrapy-Splash 使用 Splash HTTP API，因此您还需要一个 Splash 实例。通常，安装和运行 Splash，以下内容就足够了

$ docker run -p 8050:8050 scrapinghub/splash

有关更多信息，请参阅 Splash 的 安装文档。

配置

1. 将 Splash 服务器地址添加到 Scrapy 项目的 settings.py 中，如下所示

   SPLASH_URL = 'http://192.168.59.103:8050'

2. 通过在 settings.py 文件中将 Splash 中间件添加到 DOWNLOADER_MIDDLEWARES 中并更改 HttpCompressionMiddleware 的优先级来启用 Splash 中间件

   DOWNLOADER_MIDDLEWARES = {
       'scrapy_splash.SplashCookiesMiddleware': 723,
       'scrapy_splash.SplashMiddleware': 725,
       'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
   }

   默认 Scrapy 设置中，723 的顺序是在 HttpProxyMiddleware (750) 之前。

   需要更改 HttpCompressionMiddleware 的优先级以允许高级响应处理；有关详细信息，请参阅 https://github.com/scrapy/scrapy/issues/1895。

3. 通过在 settings.py 中添加它来启用 SplashDeduplicateArgsMiddleware

   SPIDER_MIDDLEWARES = {
       'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
   }

   此中间件是支持 cache_args 功能所必需的；它通过在磁盘请求队列中多次存储重复的 Splash 参数来节省磁盘空间。如果使用 Splash 2.1+，则此中间件还可以通过多次不向 Splash 服务器发送这些重复参数来节省网络流量。

4. 设置自定义 DUPEFILTER_CLASS

   DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'

5. 如果您使用 Scrapy HTTP 缓存，则需要自定义缓存存储后端。scrapy-splash 提供了 scrapy.contrib.httpcache.FilesystemCacheStorage 的子类

   HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'

   如果您使用其他缓存存储，则需要对其进行子类化，并用 scrapy_splash.splash_request_fingerprint 替换所有 scrapy.util.request.request_fingerprint 调用。

还有一些其他选项可供选择。如果您想更改默认设置，请将它们放入 settings.py 中

• SPLASH_COOKIES_DEBUG 默认为 False。将其设置为 True 以启用 SplashCookiesMiddleware 中的调试 cookies。此选项类似于内置的 scarpy cookies 中间件的 COOKIES_DEBUG：它记录所有请求发送和接收的 cookies。

• SPLASH_LOG_400 默认为 True - 它指示记录来自 Splash 的所有 400 错误。这些错误很重要，因为它们显示了执行 Splash 脚本时发生的错误。将其设置为 False 以禁用此日志记录。

• SPLASH_SLOT_POLICY 默认为 scrapy_splash.SlotPolicy.PER_DOMAIN（作为对象，而不是字符串）。它指定了 Splash 请求的并发性和礼貌性如何保持，并为 SplashRequest 的 slot_policy 参数指定默认值，如下所述。

使用

yield SplashRequest(url, self.parse_result,
    args={
        # optional; parameters passed to Splash HTTP API
        'wait': 0.5,

        # 'url' is prefilled from request url
        # 'http_method' is set to 'POST' for POST requests
        # 'body' is set to request body for POST requests
    },
    endpoint='render.json', # optional; default is render.html
    splash_url='<url>',     # optional; overrides SPLASH_URL
    slot_policy=scrapy_splash.SlotPolicy.PER_DOMAIN,  # optional
)

yield scrapy.Request(url, self.parse_result, meta={
    'splash': {
        'args': {
            # set rendering arguments here
            'html': 1,
            'png': 1,

            # 'url' is prefilled from request url
            # 'http_method' is set to 'POST' for POST requests
            # 'body' is set to request body for POST requests
        },

        # optional parameters
        'endpoint': 'render.json',  # optional; default is render.json
        'splash_url': '<url>',      # optional; overrides SPLASH_URL
        'slot_policy': scrapy_splash.SlotPolicy.PER_DOMAIN,
        'splash_headers': {},       # optional; a dict with headers sent to Splash
        'dont_process_response': True, # optional, default is False
        'dont_send_headers': True,  # optional, default is False
        'magic_response': False,    # optional, default is True
    }
})

>>> SplashFormRequest('http://example.com', formdata={'foo': 'bar'})
<POST http://example.com>

会话处理

Splash 本身是无状态的 - 每个请求都是从干净状态开始的。为了支持会话，需要以下内容

1. 客户端（Scrapy）必须将当前 cookie 发送到 Splash;

2. Splash 脚本应使用这些 cookie 进行请求，并从 HTTP 响应头或 JavaScript 代码中更新它们；

3. 更新的 cookie 应发送回客户端；

4. 客户端应将当前 cookie 与更新的 cookie 合并。

为了 (2) 和 (3)，Splash 为 Splash Lua 脚本提供了 splash:get_cookies() 和 splash:init_cookies() 方法。

scrapy-splash 为 (1) 和 (4) 提供了辅助工具：要在 'cookies' 字段中发送当前 cookie 并从 'cookies' 响应字段中合并 cookie，将 request.meta['splash']['session_id'] 设置为会话标识符。如果您只想使用单个会话，则对所有请求使用相同的 session_id；任何值如 '1' 或 'foo' 都可以。

为了使 scrapy-splash 会话处理正常工作，您必须使用 /execute 端点和接受 'cookies' 参数并返回 'cookies' 字段的结果的 Lua 脚本。

function main(splash)
    splash:init_cookies(splash.args.cookies)

    -- ... your script

    return {
        cookies = splash:get_cookies(),
        -- ... other results, e.g. html
    }
end

SplashRequest 会自动为 /execute 端点设置 session_id，即如果使用 SplashRequest、/execute 端点和兼容的 Lua 渲染脚本，则默认启用 cookie 处理。

如果您想从相同的 cookie 集合开始，但后来“分叉”会话，则在 session_id 之外设置 request.meta['splash']['new_session_id']。请求 cookie 将从 session_id cookiejar 中获取，但响应 cookie 将合并回 new_session_id cookiejar。

可以与 SplashRequest 一起使用标准的 Scrapy cookies 参数来向当前 Splash cookiejar 添加 cookie。

示例

获取 HTML 内容

import scrapy
from scrapy_splash import SplashRequest

class MySpider(scrapy.Spider):
    start_urls = ["http://example.com", "http://example.com/foo"]

    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(url, self.parse, args={'wait': 0.5})

    def parse(self, response):
        # response.body is a result of render.html call; it
        # contains HTML processed by a browser.
        # ...

获取 HTML 内容和屏幕截图

import json
import base64
import scrapy
from scrapy_splash import SplashRequest

class MySpider(scrapy.Spider):

    # ...
        splash_args = {
            'html': 1,
            'png': 1,
            'width': 600,
            'render_all': 1,
        }
        yield SplashRequest(url, self.parse_result, endpoint='render.json',
                            args=splash_args)

    # ...
    def parse_result(self, response):
        # magic responses are turned ON by default,
        # so the result under 'html' key is available as response.body
        html = response.body

        # you can also query the html result as usual
        title = response.css('title').extract_first()

        # full decoded JSON data is available as response.data:
        png_bytes = base64.b64decode(response.data['png'])

        # ...

运行简单的 Splash Lua 脚本

import json
import base64
from scrapy_splash import SplashRequest


class MySpider(scrapy.Spider):

    # ...
        script = """
        function main(splash)
            assert(splash:go(splash.args.url))
            return splash:evaljs("document.title")
        end
        """
        yield SplashRequest(url, self.parse_result, endpoint='execute',
                            args={'lua_source': script})

    # ...
    def parse_result(self, response):
        doc_title = response.text
        # ...

更复杂的 Splash Lua 脚本 示例 - 通过 CSS 选择器获取 HTML 元素的屏幕截图（需要 Splash 2.1+）。注意如何将参数传递给脚本

import json
import base64
from scrapy_splash import SplashRequest

script = """
-- Arguments:
-- * url - URL to render;
-- * css - CSS selector to render;
-- * pad - screenshot padding size.

-- this function adds padding around region
function pad(r, pad)
  return {r[1]-pad, r[2]-pad, r[3]+pad, r[4]+pad}
end

-- main script
function main(splash)

  -- this function returns element bounding box
  local get_bbox = splash:jsfunc([[
    function(css) {
      var el = document.querySelector(css);
      var r = el.getBoundingClientRect();
      return [r.left, r.top, r.right, r.bottom];
    }
  ]])

  assert(splash:go(splash.args.url))
  assert(splash:wait(0.5))

  -- don't crop image by a viewport
  splash:set_viewport_full()

  local region = pad(get_bbox(splash.args.css), splash.args.pad)
  return splash:png{region=region}
end
"""

class MySpider(scrapy.Spider):


    # ...
        yield SplashRequest(url, self.parse_element_screenshot,
            endpoint='execute',
            args={
                'lua_source': script,
                'pad': 32,
                'css': 'a.title'
            }
         )

    # ...
    def parse_element_screenshot(self, response):
        image_data = response.body  # binary image data in PNG format
        # ...

使用Lua脚本获取带有cookies、headers、body和正确设置方法的HTML响应；lua_source参数值在Splash服务器上缓存，不会随每个请求发送（需要Splash 2.1+）

import scrapy
from scrapy_splash import SplashRequest

script = """
function main(splash)
  splash:init_cookies(splash.args.cookies)
  assert(splash:go{
    splash.args.url,
    headers=splash.args.headers,
    http_method=splash.args.http_method,
    body=splash.args.body,
    })
  assert(splash:wait(0.5))

  local entries = splash:history()
  local last_response = entries[#entries].response
  return {
    url = splash:url(),
    headers = last_response.headers,
    http_status = last_response.status,
    cookies = splash:get_cookies(),
    html = splash:html(),
  }
end
"""

class MySpider(scrapy.Spider):


    # ...
        yield SplashRequest(url, self.parse_result,
            endpoint='execute',
            cache_args=['lua_source'],
            args={'lua_source': script},
            headers={'X-My-Header': 'value'},
        )

    def parse_result(self, response):
        # here response.body contains result HTML;
        # response.headers are filled with headers from last
        # web page loaded to Splash;
        # cookies from all responses and from JavaScript are collected
        # and put into Set-Cookie response header, so that Scrapy
        # can remember them.

HTTP基本认证

如果您需要使用HTTP基本认证访问Splash，请使用SPLASH_USER和SPLASH_PASS可选设置

SPLASH_USER = 'user'
SPLASH_PASS = 'userpass'

另一种选项是meta['splash']['splash_headers']：它允许设置发送到Splash服务器的自定义headers；如果您想按请求更改凭据，请将Authorization header添加到splash_headers

import scrapy
from w3lib.http import basic_auth_header

class MySpider(scrapy.Spider):
    # ...
    def start_requests(self):
        auth = basic_auth_header('user', 'userpass')
        yield SplashRequest(url, self.parse,
                            splash_headers={'Authorization': auth})

警告：不要使用HttpAuthMiddleware（即http_user / http_pass 爬虫属性）进行Splash认证：如果您偶尔从您的爬虫发送非Splash请求，可能会将Splash凭据暴露给远程网站，因为HttpAuthMiddleware无条件地为所有请求设置凭据。

为什么不直接使用Splash HTTP API呢？

scrapy-splash的明显替代方案是直接向Splash HTTP API 发送请求。查看下面的示例，并确保阅读其后的观察结果

import json

import scrapy
from scrapy.http.headers import Headers

RENDER_HTML_URL = "http://127.0.0.1:8050/render.html"

class MySpider(scrapy.Spider):
    start_urls = ["http://example.com", "http://example.com/foo"]

    def start_requests(self):
        for url in self.start_urls:
            body = json.dumps({"url": url, "wait": 0.5}, sort_keys=True)
            headers = Headers({'Content-Type': 'application/json'})
            yield scrapy.Request(RENDER_HTML_URL, self.parse, method="POST",
                                 body=body, headers=headers)

    def parse(self, response):
        # response.body is a result of render.html call; it
        # contains HTML processed by a browser.
        # ...

它工作得很好，并且足够简单，但有一些问题您应该注意

1. 有一些样板代码。

2. 从Scrapy的角度来看，我们正在向RENDER_HTML_URL发送请求，而不是目标URL。它影响并发和礼貌设置：CONCURRENT_REQUESTS_PER_DOMAIN、DOWNLOAD_DELAY等可能会以意想不到的方式表现，因为延迟和并发设置不再是按域设置的。

3. 从Scrapy的角度来看，response.url是Splash服务器的URL。scrapy-splash将其修复为请求页面的URL。“真实”URL仍然可以通过response.real_url获得。scrapy-splash还允许在Scrapy端透明地处理response.status和response.headers。

4. 一些选项相互依赖 - 例如，如果您使用timeout Splash选项，那么您可能还想设置download_timeout scrapy.Request元数据键。

5. 很容易出错 - 例如，如果您在准备JSON body时不使用sort_keys=True参数，那么即使所有键和值都相同，二进制POST body内容也可能不同，这意味着dupefilter和cache将无法正常工作。

6. 默认的Scrapy重复过滤器没有考虑Splash的具体情况。例如，如果URL在JSON POST请求体中发送，Scrapy将计算请求指纹而不规范化此URL。

7. Splash错误请求（HTTP 400）错误难以调试，因为默认情况下Scrapy不会显示响应内容。SplashMiddleware默认情况下会记录HTTP 400 Splash响应的内容（可以通过设置SPLASH_LOG_400 = False选项关闭）。

8. 处理cookie很繁琐，并且在与Splash一起工作时不能使用Scrapy内置的Cookie中间件来处理cookie。

9. 不会随每个请求改变的大Splash参数（例如lua_source）在保存到Scrapy磁盘请求队列时可能会占用大量空间。scrapy-splash提供了一种仅保存一次此类静态参数的方法。

10. Splash 2.1+提供了一种通过在服务器上缓存大型静态参数来节省网络流量的方式，但这需要客户端支持：客户端应发送适当的save_args和load_args值，并处理HTTP 498响应。

scrapy-splash 工具允许处理此类边缘情况并减少样板代码。

获取帮助

• 对于页面渲染问题，请阅读“Splash FAQ”页面

• 有关 Scrapy 相关的错误，请查看“报告 Scrapy 错误”页面

获取任何其他帮助的最佳方法是在 Stack Overflow 上提问

贡献

源代码和错误跟踪器在 github 上：https://github.com/scrapy-plugins/scrapy-splash

要运行测试，安装“tox”Python 包，然后从源代码签出处运行 tox 命令。

要运行集成测试，启动 Splash 并在运行 tox 命令之前设置 SPLASH_URL 环境变量为 Splash 地址。

docker run -d --rm -p8050:8050 scrapinghub/splash:3.0
SPLASH_URL=http://127.0.0.1:8050 tox -e py36

更改

SPIDER_MIDDLEWARES = {
    'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}