Scrapy-Redis源码中的设计模式：观察者模式与策略模式

原创 于 2025-09-24 04:10:07 发布 · 738 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Scrapy-Redis源码中的设计模式：观察者模式与策略模式

【免费下载链接】scrapy-redis Redis-based components for Scrapy. 【免费下载链接】scrapy-redis 项目地址: https://gitcode.com/gh_mirrors/sc/scrapy-redis

Scrapy-Redis作为基于Redis的Scrapy分布式爬虫组件，其源码中巧妙运用了多种设计模式以实现高内聚低耦合的架构设计。本文将深入剖析源码中观察者模式（Observer Pattern）与策略模式（Strategy Pattern）的应用场景、实现方式及设计意图，帮助开发者理解框架设计精髓并提升分布式爬虫开发能力。

核心设计模式概览

Scrapy-Redis在实现分布式调度、URL去重和爬虫状态管理等核心功能时，主要采用了两种设计模式：观察者模式用于实现事件驱动的组件通信，策略模式用于支持算法和数据结构的灵活切换。这两种模式的组合使用，使得框架既具备良好的可扩展性，又能适应不同的分布式爬取场景需求。

设计模式在源码中的分布

设计模式核心实现文件主要应用场景
观察者模式src/scrapy_redis/spiders.py爬虫 idle 事件监听、请求调度触发
策略模式src/scrapy_redis/scheduler.py、src/scrapy_redis/queue.py队列实现切换、去重算法选择

观察者模式：事件驱动的爬虫调度

观察者模式（Observer Pattern）定义了对象间的一对多依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会自动收到通知并更新。在Scrapy-Redis中，该模式被用于实现爬虫空闲状态检测与请求调度的自动触发机制。

实现机制解析

在src/scrapy_redis/spiders.py中，RedisMixin类通过Scrapy的信号系统实现了观察者模式：

# 信号连接：当爬虫空闲时触发spider_idle方法
crawler.signals.connect(self.spider_idle, signal=signals.spider_idle)

这里RedisMixin作为观察者（Observer），订阅了Scrapy引擎的spider_idle信号。当爬虫进入空闲状态时，信号被触发，执行spider_idle方法：

def spider_idle(self):
    """
    Schedules a request if available, otherwise waits.
    or close spider when waiting seconds > MAX_IDLE_TIME_BEFORE_CLOSE.
    """
    if self.server is not None and self.count_size(self.redis_key) > 0:
        self.spider_idle_start_time = int(time.time())

    self.schedule_next_requests()  # 调度新请求

    idle_time = int(time.time()) - self.spider_idle_start_time
    if self.max_idle_time != 0 and idle_time >= self.max_idle_time:
        return
    raise DontCloseSpider  # 阻止爬虫关闭

事件处理流程

mermaid

当爬虫空闲时，RedisMixin通过spider_idle方法检查Redis中是否有待处理的请求。如果存在新请求，则调用schedule_next_requests()方法从Redis获取并调度请求，同时抛出DontCloseSpider异常阻止爬虫关闭；如果长时间没有新请求到达且超过max_idle_time阈值，则允许爬虫正常关闭。

关键实现细节

  1. 信号注册时机：在setup_redis()方法中完成信号连接，确保爬虫初始化时即具备事件监听能力：
def setup_redis(self, crawler=None):
    # ... 省略其他初始化代码 ...
    crawler.signals.connect(self.spider_idle, signal=signals.spider_idle)
  1. 状态保持机制：通过spider_idle_start_time记录空闲开始时间，结合max_idle_time实现爬虫自动关闭的超时控制：
idle_time = int(time.time()) - self.spider_idle_start_time
if self.max_idle_time != 0 and idle_time >= self.max_idle_time:
    return  # 允许关闭
raise DontCloseSpider  # 阻止关闭

策略模式：灵活可替换的核心算法

策略模式（Strategy Pattern）定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。此模式让算法的变化独立于使用算法的客户端。Scrapy-Redis在请求队列实现和URL去重机制中广泛应用了这一模式，允许用户根据需求选择不同的实现策略。

请求队列的策略模式实现

在src/scrapy_redis/scheduler.py中，调度器通过配置动态选择不同的队列实现：

def open(self, spider):
    self.spider = spider
    try:
        self.queue = load_object(self.queue_cls)(  # 动态加载队列类
            server=self.server,
            spider=spider,
            key=self.queue_key % {"spider": spider.name},
            serializer=self.serializer,
        )
    except TypeError as e:
        raise ValueError(
            f"Failed to instantiate queue class '{self.queue_cls}': {e}"
        )

queue_cls参数通过配置指定，默认值定义在src/scrapy_redis/defaults.py中：

# 默认队列类
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'

队列策略的多实现

src/scrapy_redis/queue.py中实现了多种队列策略，均遵循统一的接口规范：

# 基础队列接口
class Base(object):
    def __init__(self, server, spider, key, serializer=None):
        self.server = server
        self.spider = spider
        self.key = key % {'spider': spider.name}
        self.serializer = serializer or picklecompat

    def __len__(self):
        raise NotImplementedError

    def push(self, request):
        raise NotImplementedError

    def pop(self, timeout=0):
        raise NotImplementedError

    def clear(self):
        self.server.delete(self.key)

# 具体队列实现
class FifoQueue(Base):
    """FIFO queue using redis list"""
    def __len__(self):
        return self.server.llen(self.key)
    
    def push(self, request):
        self.server.lpush(self.key, self._encode_request(request))
    
    def pop(self, timeout=0):
        if timeout > 0:
            data = self.server.brpop(self.key, timeout)
            if isinstance(data, tuple):
                data = data[1]
        else:
            data = self.server.rpop(self.key)
        if data:
            return self._decode_request(data)

class PriorityQueue(Base):
    """Priority queue using redis sorted set"""
    def __len__(self):
        return self.server.zcard(self.key)
    
    def push(self, request):
        score = -request.priority
        data = self._encode_request(request)
        self.server.zadd(self.key, {data: score})
    
    def pop(self, timeout=0):
        # ... 实现逻辑 ...

队列策略的选择机制

调度器通过from_settings()方法读取配置，实现队列策略的动态选择：

@classmethod
def from_settings(cls, settings):
    kwargs = {
        # ... 其他参数 ...
        "queue_cls": settings.get("SCHEDULER_QUEUE_CLASS", defaults.SCHEDULER_QUEUE_CLASS),
        # ... 其他参数 ...
    }
    # ... 省略其他代码 ...
    return cls(server=server, **kwargs)

用户可通过修改Scrapy配置文件选择不同的队列实现：

# settings.py
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.FifoQueue'  # FIFO队列
# 或
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'  # 优先级队列
# 或
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.LifoQueue'  # LIFO队列

去重策略的灵活切换

除队列实现外，URL去重机制同样采用策略模式设计。src/scrapy_redis/scheduler.py中通过dupefilter_cls参数支持不同去重算法的切换：

def __init__(
    self,
    server,
    # ... 其他参数 ...
    dupefilter_cls=defaults.SCHEDULER_DUPEFILTER_CLASS,
    # ... 其他参数 ...
):
    # ... 初始化代码 ...
    if not self.df:
        self.df = load_object(self.dupefilter_cls).from_spider(spider)

默认的去重实现为基于Redis集合的src/scrapy_redis/dupefilter.py：

class RFPDupeFilter(BaseDupeFilter):
    """Redis-based request duplicates filter"""
    def __init__(self, server, key, debug=False):
        self.server = server
        self.key = key
        self.debug = debug
        self.logdupes = True

    @classmethod
    def from_settings(cls, settings):
        # ... 初始化逻辑 ...

    def request_seen(self, request):
        fp = self.request_fingerprint(request)
        added = self.server.sadd(self.key, fp)
        return not added

    def request_fingerprint(self, request):
        return request_fingerprint(request)

两种模式的协同工作机制

观察者模式与策略模式在Scrapy-Redis中并非孤立存在，而是协同工作形成有机整体。观察者模式实现事件驱动的自动调度，策略模式提供灵活的算法选择，二者结合使框架既能够响应动态变化，又可以适应不同场景需求。

协同工作流程

mermaid

配置驱动的策略选择

Scrapy-Redis通过配置文件将两种模式有机结合，用户可通过修改配置实现不同策略的组合：

# settings.py
# 队列策略配置
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'
# 去重策略配置
DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'
# 事件监听配置
MAX_IDLE_TIME_BEFORE_CLOSE = 300  # 5分钟空闲超时

这种设计使得框架具备极高的灵活性，既可以通过观察者模式实现自动化的事件响应，又能够通过策略模式根据实际需求定制核心算法。

设计模式带来的架构优势

Scrapy-Redis通过观察者模式和策略模式的巧妙运用，带来了多方面的架构优势，使其成为分布式爬虫领域的经典实现：

高可扩展性

策略模式的应用使得新增队列实现或去重算法变得极为简单，只需实现统一接口即可无缝集成到现有框架中，无需修改核心代码。例如，要添加一种新的优先级队列实现，只需继承Base类并实现__len__、push和pop方法。

松耦合设计

观察者模式将事件的产生者和消费者解耦，爬虫引擎无需知道具体的事件处理逻辑，只需触发相应事件即可。这种设计使得各组件可以独立演化，提高了代码的可维护性。

灵活的定制能力

通过配置驱动的策略选择机制，用户可以根据不同的爬取需求灵活调整队列类型、去重算法和空闲超时时间等参数，而无需修改框架源码。

分布式适应性

两种模式的组合使用，使得Scrapy-Redis能够很好地适应分布式环境下的动态变化。观察者模式确保爬虫能够及时响应新的爬取任务，策略模式则允许根据数据特性选择最适合的存储和处理策略。

总结与实践建议

Scrapy-Redis源码中的观察者模式和策略模式应用，为我们提供了优秀的分布式系统设计范例。通过事件驱动实现动态响应，通过策略选择实现灵活适配，这种设计思想不仅适用于爬虫系统，也可广泛应用于其他分布式和高并发场景。

实践建议

  1. 合理选择队列策略：根据爬取需求选择合适的队列类型。深度优先爬取可选用LifoQueue，广度优先爬取可选用FifoQueue，优先级爬取则选用PriorityQueue。

  2. 优化去重实现：对于大规模爬取，可考虑扩展RFPDupeFilter实现分片去重或过期清理机制，避免Redis键过大影响性能。

  3. 定制事件响应：通过扩展RedisMixin类，可以添加更多事件监听，如spider_opened或spider_closed，实现更精细的爬虫生命周期管理。

  4. 策略组合测试：不同的队列策略和去重策略组合可能产生不同的爬取效果，建议在实际项目中进行充分测试，选择最适合目标网站的策略组合。

通过深入理解和借鉴Scrapy-Redis中的设计模式应用，开发者不仅可以更好地使用框架，还能在自己的项目中设计出更加灵活、可扩展的系统架构。

官方文档：docs/index.rst 核心调度器源码：src/scrapy_redis/scheduler.py 队列策略实现：src/scrapy_redis/queue.py 事件监听实现：src/scrapy_redis/spiders.py

【免费下载链接】scrapy-redis Redis-based components for Scrapy. 【免费下载链接】scrapy-redis 项目地址: https://gitcode.com/gh_mirrors/sc/scrapy-redis

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值