发布于 由admin

`Python`的`Web`爬虫：`Scrapy`的`分布式`爬虫和`中间件`的`实现`。

Scrapy 分布式爬虫与中间件深度解析

大家好，今天我们来深入探讨 Scrapy 框架下的分布式爬虫以及中间件的实现。Scrapy 作为一个强大的 Python 爬虫框架，其灵活性和可扩展性使其非常适合构建大型、复杂的爬虫系统。而分布式爬虫和中间件则是提升 Scrapy 爬虫效率和定制化能力的关键。

一、理解 Scrapy 的架构与核心组件

在深入分布式和中间件之前，我们先回顾一下 Scrapy 的基本架构。Scrapy 主要由以下几个核心组件组成：

  • Scrapy Engine (引擎): 负责控制数据流在所有组件之间流动，并触发事件。相当于爬虫的“大脑”。
  • Scheduler (调度器): 接收来自引擎的请求，并按照一定的优先级策略进行排序和去重，最终将请求发送给下载器。
  • Downloader (下载器): 负责下载网页内容，并将响应（Response）返回给引擎。
  • Spiders (爬虫): 定义如何爬取特定的网站。它负责发起初始请求，并解析响应，提取数据或生成新的请求。
  • Item Pipeline (项目管道): 负责处理 Spider 提取的数据。它可以对数据进行清洗、验证、存储等操作。
  • Downloader Middlewares (下载器中间件): 位于引擎和下载器之间，可以拦截请求和响应，并对其进行修改。例如，可以添加 User-Agent，设置代理，处理重定向等。
  • Spider Middlewares (爬虫中间件): 位于引擎和 Spider 之间，可以拦截请求和 Spider 输出的 Item，并对其进行修改。例如，可以修改请求的 URL，过滤 Item 等。

二、分布式爬虫的原理与实现

Scrapy 本身并非原生支持分布式，但我们可以借助 Redis 等消息队列来实现分布式爬虫。分布式爬虫的核心思想是将爬取任务分散到多个机器上执行，从而提高爬取效率。

  1. Redis 作为分布式调度器

    Redis 提供了一个高性能的键值存储系统，可以作为分布式爬虫的调度器和数据共享中心。我们可以将待爬取的 URL 存储在 Redis 的队列中，多个爬虫节点从队列中获取 URL 进行爬取。

    核心流程：

    • 主节点： 负责收集种子 URL，并将 URL 推送到 Redis 队列中。
    • 从节点： 从 Redis 队列中获取 URL，执行爬取操作，并将提取的数据存储到数据库或其他存储介质中。
    • 去重： 使用 Redis 的 Set 数据结构进行 URL 去重，防止重复爬取。

  2. scrapy-redis 组件

    scrapy-redis 是一个基于 Redis 的 Scrapy 组件，它简化了 Scrapy 分布式爬虫的实现。scrapy-redis 提供了以下功能：

    • Scheduler: 使用 Redis 队列作为调度器，实现了分布式任务队列。
    • Duplication Filter: 使用 Redis Set 作为去重过滤器，防止重复爬取。
    • Item Pipeline: 将 Item 存储到 Redis 中，方便其他应用使用。
    • Base Spiders: 提供了 RedisSpider 和 RedisCrawlSpider 两种基类，简化了分布式 Spider 的编写。

  3. 使用 scrapy-redis 构建分布式爬虫

    安装 scrapy-redis:

    pip install scrapy-redis

    配置 Scrapy 项目：

    在 settings.py 文件中进行如下配置：

    # 启用 scrapy-redis 调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"

# 确保所有的爬虫通过redis共享相同的去重过滤器。
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"

# 指定 redis 的连接信息
REDIS_HOST = 'localhost'
REDIS_PORT = 6379

# 如果需要密码
# REDIS_PASSWORD = 'your_redis_password'

# 爬虫空闲时等待请求的时间，单位秒。 这是性能优化的关键。
SCHEDULER_IDLE_BEFORE_CLOSE = 10

# 使用优先级队列
#SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'

# 使用 FIFO 队列
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.FifoQueue'

# 使用 LIFO 队列
#SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.LifoQueue'

# 启用 Item Pipeline，将 Item 存储到 Redis 中
ITEM_PIPELINES = {
    'your_project.pipelines.YourPipeline': 300, # 将your_project替换成你的项目名称
    'scrapy_redis.pipelines.RedisPipeline': 400,
}

# 指定 Item 存储的 key
REDIS_ITEMSKEY = '%(spider)s:items'

    编写 Spider：

    继承 RedisSpider 或 RedisCrawlSpider 类，并实现 parse 方法。

    # -*- coding: utf-8 -*-
import scrapy
from scrapy_redis.spiders import RedisSpider

class MySpider(RedisSpider):
    name = 'myspider'
    redis_key = 'myspider:start_urls'  # Redis 中存储起始 URL 的 key

    def parse(self, response):
        # 在这里编写解析逻辑
        # 例如：
        # title = response.xpath('//title/text()').get()
        # yield {'title': title}
        print(f"正在爬取：{response.url}") # 示例，打印爬取的 URL
        yield {'url': response.url, 'title': response.xpath('//title/text()').get()}

    Item Pipeline:

    # pipelines.py

class YourPipeline(object):
    def process_item(self, item, spider):
        # 在这里处理 Item，例如存储到数据库
        print(f"处理 Item: {item}") # 示例，打印 Item
        return item

    运行爬虫：

    scrapy runspider your_spider.py  # 将 your_spider.py 替换成你的 Spider 文件名

    向 Redis 中添加起始 URL：

    使用 Redis 客户端向 myspider:start_urls 队列中添加起始 URL。

    redis-cli lpush myspider:start_urls http://www.example.com
redis-cli lpush myspider:start_urls http://www.example.org

  4. 示例：爬取图书信息

    假设我们要爬取一个图书网站的图书信息，以下是一个使用 scrapy-redis 构建的分布式爬虫的示例。

    Spider (books_spider.py):

    # -*- coding: utf-8 -*-
import scrapy
from scrapy_redis.spiders import RedisSpider

class BooksSpider(RedisSpider):
    name = 'books'
    redis_key = 'books:start_urls'

    def parse(self, response):
        for book in response.css('article.product_pod'):
            title = book.css('h3 > a::text').get()
            price = book.css('div.product_price > p.price_color::text').get()
            yield {
                'title': title,
                'price': price,
            }

        next_page = response.css('li.next > a::attr(href)').get()
        if next_page is not None:
            yield scrapy.Request(response.urljoin(next_page))

    Item Pipeline (pipelines.py):

    # -*- coding: utf-8 -*-

class BooksPipeline(object):
    def process_item(self, item, spider):
        print(f"正在存储图书信息：{item}")
        # 在这里将 item 存储到数据库或其他存储介质中
        return item

    settings.py:

    （参考前面的配置，确保 SCHEDULER、DUPEFILTER_CLASS、REDIS_HOST、REDIS_PORT 和 ITEM_PIPELINES 等配置正确。）

    运行爬虫：

    scrapy runspider books_spider.py

    向 Redis 中添加起始 URL：

    redis-cli lpush books:start_urls http://books.toscrape.com/

三、Scrapy 中间件的实现与应用

Scrapy 中间件允许你在请求发送到下载器之前和响应返回给 Spider 之后，对请求和响应进行修改和处理。它们是 Scrapy 框架中非常强大的扩展机制。

  1. 中间件的类型

    Scrapy 中间件主要分为两种类型：

    • Downloader Middlewares (下载器中间件): 位于引擎和下载器之间，用于处理请求和响应。
    • Spider Middlewares (爬虫中间件): 位于引擎和 Spider 之间，用于处理请求和 Item。

  2. Downloader Middlewares 的实现

    Downloader Middlewares 主要用于以下场景：

    • 设置 User-Agent: 模拟不同的浏览器，防止被网站屏蔽。
    • 使用代理 IP: 隐藏真实 IP 地址，防止被网站封禁。
    • 处理重定向: 自动处理 HTTP 重定向。
    • 处理 Cookies: 管理 Cookies，模拟用户登录。
    • 处理异常: 处理下载过程中出现的异常。

    示例：设置 User-Agent 的 Downloader Middleware

    # middlewares.py

class RandomUserAgentMiddleware(object):
    def __init__(self):
        self.user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36',
            'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0',
            'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36'
        ]

    def process_request(self, request, spider):
        import random
        user_agent = random.choice(self.user_agents)
        request.headers['User-Agent'] = user_agent

    在 settings.py 中启用中间件：

    DOWNLOADER_MIDDLEWARES = {
    'your_project.middlewares.RandomUserAgentMiddleware': 543, # 将your_project替换成你的项目名称
}

    process_request(self, request, spider): 在请求发送到下载器之前被调用。它接收 request 和 spider 对象作为参数，并可以对 request 对象进行修改。

    示例：使用代理 IP 的 Downloader Middleware

    # middlewares.py

class ProxyMiddleware(object):
    def __init__(self):
        self.proxies = [
            'http://10.10.1.10:3128',
            'http://127.0.0.1:8888',
            # 更多代理 IP
        ]

    def process_request(self, request, spider):
        import random
        proxy = random.choice(self.proxies)
        request.meta['proxy'] = proxy

    在 settings.py 中启用中间件：

    DOWNLOADER_MIDDLEWARES = {
    'your_project.middlewares.ProxyMiddleware': 750,  # 将your_project替换成你的项目名称
}

    process_response(self, request, response, spider): 在下载器收到响应后，但在响应传递给 Spider 之前被调用。它可以用于处理重定向、Cookies 等。如果返回一个 Request 对象，Scrapy 将重新调度该请求。如果返回一个 Response 对象，该响应将被传递给 Spider 进行处理。

    process_exception(self, request, exception, spider): 当下载器抛出异常时被调用。它可以用于处理下载过程中出现的异常，例如连接超时、连接错误等。

  3. Spider Middlewares 的实现

    Spider Middlewares 主要用于以下场景：

    • 修改请求的 URL: 根据一定的规则修改请求的 URL。
    • 过滤 Item: 根据一定的条件过滤 Item。
    • 处理 Spider 产生的异常: 处理 Spider 在解析过程中产生的异常。

    示例：过滤 Item 的 Spider Middleware

    # middlewares.py

class FilterItemMiddleware(object):
    def process_spider_output(self, response, result, spider):
        for item in result:
            if item['price'] > 100:
                yield item

    在 settings.py 中启用中间件：

    SPIDER_MIDDLEWARES = {
    'your_project.middlewares.FilterItemMiddleware': 543, # 将your_project替换成你的项目名称
}

    process_spider_input(self, response, spider): 在 Spider 接收到响应之前被调用。它可以用于修改响应，例如修改响应的编码。

    process_spider_output(self, response, result, spider): 在 Spider 处理完响应并返回 Item 或 Request 对象后被调用。它可以用于过滤 Item 或修改 Request 对象。

    process_spider_exception(self, response, exception, spider): 当 Spider 抛出异常时被调用。它可以用于处理 Spider 在解析过程中产生的异常。

  4. 中间件的优先级

    Scrapy 中间件通过 settings.py 中的 DOWNLOADER_MIDDLEWARES 和 SPIDER_MIDDLEWARES 字典来启用，字典中的值表示中间件的优先级。优先级越低，中间件越先被调用。

    优先级范围为 0-1000，Scrapy 默认的中间件优先级范围为 0-700。建议自定义中间件的优先级高于 700，以避免与 Scrapy 默认的中间件冲突。

四、分布式爬虫与中间件的结合应用

分布式爬虫和中间件可以结合使用，以构建更加强大和灵活的爬虫系统。例如，可以在分布式爬虫中使用代理 IP 中间件，以防止被网站封禁。

  1. 示例：分布式爬虫中使用代理 IP

    在分布式爬虫的 settings.py 文件中，同时启用 scrapy-redis 组件和代理 IP 中间件。

    # 启用 scrapy-redis 调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"

# 确保所有的爬虫通过redis共享相同的去重过滤器。
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"

# 指定 redis 的连接信息
REDIS_HOST = 'localhost'
REDIS_PORT = 6379

# 启用代理 IP 中间件
DOWNLOADER_MIDDLEWARES = {
    'your_project.middlewares.ProxyMiddleware': 750,  # 将your_project替换成你的项目名称
}

    这样，所有的爬虫节点都会使用代理 IP 进行爬取，从而降低被网站封禁的风险。

五、一些建议

  • 合理选择队列类型： scrapy-redis 提供了多种队列类型，根据实际需求选择合适的队列类型。例如，如果需要保证爬取顺序，可以使用 FIFO 队列。
  • 优化 Redis 连接： 在高并发场景下，需要优化 Redis 连接，例如使用连接池。
  • 监控爬虫状态： 需要监控爬虫的运行状态，例如爬取速度、错误率等。可以使用 Scrapy 的 Stats Collector 或第三方监控工具。
  • 处理反爬策略： 需要根据网站的反爬策略，调整爬虫的策略，例如调整请求频率、添加随机延迟等。

数据与功能整合的有力工具

通过以上讲解，我们了解了 Scrapy 分布式爬虫的实现原理和中间件的应用。分布式爬虫可以提高爬取效率，而中间件可以增强爬虫的灵活性和定制化能力。将两者结合使用，可以构建更加强大和高效的爬虫系统，应对各种复杂的爬取场景。希望今天的讲解对大家有所帮助。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注