Scrapy 源码剖析（四）Scrapy 如何完成抓取任务？

微信搜索关注「水滴与银弹」公众号，第一时间获取优质技术干货。7年资深后端研发，用简单的方式把技术讲清楚。

上一篇文章：Scrapy 源码剖析（三）Scrapy 有哪些核心组件？，我们已经分析了 Scrapy 核心组件的主要职责，以及它们在初始化时都完成了哪些工作。

这篇文章就让我们来看一下，也是 Scrapy 最核心的抓取流程是如何运行的，它是如何调度各个组件，完成整个抓取工作的。

运行入口

还是回到最初的入口，在Scrapy 源码剖析（二）Scrapy 是如何运行起来的？这篇文章中我们已经详细分析过了，在执行 Scrapy 命令时，主要经过以下几步：

• 调用 cmdline.py 的 execute 方法
• 找到对应的 命令实例 解析命令行
• 构建 CrawlerProcess 实例，调用 crawl 和 start 方法开始抓取

而 crawl 方法最终是调用了 Cralwer 实例的 crawl，这个方法最终把控制权交给了Engine，而 start 方法注册好协程池，就开始异步调度执行了。

我们来看 Cralwer 的 crawl 方法：

@defer.inlineCallbacks
def crawl(self, *args, **kwargs):
    assert not self.crawling, "Crawling already taking place"
    self.crawling = True
    try:
        # 创建爬虫实例
        self.spider = self._create_spider(*args, **kwargs)
        # 创建引擎
        self.engine = self._create_engine()
        # 调用spider的start_requests 获取种子URL
        start_requests = iter(self.spider.start_requests())
        # 调用engine的open_spider 交由引擎调度
        yield self.engine.open_spider(self.spider, start_requests)
        yield defer.maybeDeferred(self.engine.start)
    except Exception:
        if six.PY2:
            exc_info = sys.exc_info()
        self.crawling = False
        if self.engine is not None:
            yield self.engine.close()
        if six.PY2:
            six.reraise(*exc_info)
        raise

这里首先会创建出爬虫实例，然后创建引擎，之后调用了 spider 的 start_requests 方法，这个方法就是我们平时写的最多爬虫类的父类，它在 spiders/__init__.py 中定义：

def start_requests(self):
    # 根据定义好的start_urls属性 生成种子URL对象
    for url in self.start_urls:
        yield self.make_requests_from_url(url)

def make_requests_from_url(self, url):
    # 构建Request对象
    return Request(url, dont_filter=True)

构建请求

通过上面这段代码，我们能看到，平时我们必须要定义的 start_urls 属性，原来就是在这里用来构建 Request 的，来看 Request 的定义：

class Request(object_ref):

    def __init__(self, url, callback=None, method='GET', headers=None, body=None,
                 cookies=None, meta=None, encoding='utf-8', priority=0,
                 dont_filter=False, errback=None):
        # 编码
        self._encoding = encoding
        # 请求方法
        self.method = str(method).upper()
        # 设置url
        self._set_url(url)
        # 设置body
        self._set_body(body)
        assert isinstance(priority, int), "Request priority not an integer: %r" % priority
        # 优先级
        self.priority = priority
        assert callback or not errback, "Cannot use errback without a callback"
        # 回调函数
        self.callback = callback
        # 异常回调函数
        self.errback = errback
        # cookies
        self.cookies = cookies or {
   }
        # 构建Header
        self.headers = Headers(headers or {
   }, encoding=encoding)
        # 是否需要过滤
        self.dont_filter = dont_filter
		# 附加信息
        self._meta = dict(meta) if meta else None

Request 对象比较简单，就是封装了请求参数、请求方法、回调以及可附加的属性信息。

当然，你也可以在子类中重写 start_requests 和 make_requests_from_url 这 2 个方法，用来自定义逻辑构建种子请求。

引擎调度

再回到 crawl 方法，构建好种子请求对象后，调用了 engine 的 open_spider：

@defer.inlineCallbacks
def open_spider(self, spider, start_requests=(), close_if_idle=True):
    assert self.has_capacity(), "No free spider slot when opening %r" % \
        spider.name
    logger.info("Spider opened", extra={
   'spider': spider})
    # 注册_next_request调度方法 循环调度
    nextcall = CallLaterOnce(self._next_request, spider)
    # 初始化scheduler
    scheduler = self.scheduler_cls.from_crawler(self.crawler)
    # 调用爬虫中间件 处理种子请求
    start_requests = yield self.scraper.spidermw.process_start_requests(start_requests, spider)
    # 封装Slot对象
    slot = Slot(start_requests, close_if_idle, nextcall, scheduler)
    self.slot = slot
    self.spider = spider
    # 调用scheduler的open
    yield scheduler.open(spider)
    # 调用scrapyer的open
    yield self.scraper.open_spider(spider)
    # 调用stats的open
    self.crawler.stats.open_spider(spider)
    yield self.signals.send_catch_log_deferred(signals.spider_opened, spider=spider)
    # 发起调度
    slot.nextcall.schedule()
    slot.heartbeat.start(5)

在这里首先构建了一个 CallLaterOnce，之后把 _next_request 方法注册了进去，看此类的实现：

class CallLaterOnce(object):
    # 在twisted的reactor中循环调度一个方法
    def __init__(self, func, *a, **kw):
        self._func = func
        self._a = a
        self._kw = kw
        self._call = None

    def schedule(self, delay=0):
        # 上次发起调度 才可再次继续调度
        if self._call is None:
            # 注册self到callLater中
            self._call = reactor.callLater(delay, self)

    def cancel(self):
        if self._call:
            self._call.cancel()

    def __call__(self):
        # 上面注册的是self 所以会执行__call__
        self._call = None
        return self._func(*self._a, **self._kw)	

这里封装了循环执行的方法类，并且注册的方法会在 twisted 的 reactor 中异步执行，以后执行只需调用 schedule，就会注册 self 到 reactor 的 callLater 中，然后它会执行 __call__ 方法，最终执行的就是我们注册的方法。

而这里我们注册的方法就是引擎的 _next_request，也就是说，此方法会循环调度，直到程序退出。

之后调用了爬虫中间件的 process_start_requests 方法，你可以定义多个自己的爬虫中间件，每个类都重写此方法，爬虫在调度之前会分别调用你定义好的爬虫中间件，来处理初始化请求，你可以进行过滤、加工、筛选以及你想做的任何逻辑。

这样做的好处就是，把想做的逻辑拆分成多个中间件，每个中间件功能独立，而且维护起来更加清晰。

调度器

接下来就要开始调度任务了，这里首先调用了 Scheduler 的 open：

def open(self, spider):
    self.spider = spider
    # 实例化优先级队列
    self.mqs = self.pqclass(self._newmq)
    # 如果定义了dqdir则实例化基于磁盘的队列
    self.dqs = self._dq() if self.dqdir else None
    # 调用请求指纹过滤器的open方法
    return self.df.open()
    
def _dq(self):
    # 实例化磁盘队列
    activef = join(self.dqdir, 'active.json')
    if exists(activef):
        with open(activef) as f:
            prios = json.load(f)
    else:
        prios = ()
    q = self.pqclass(self._newdq, startprios=prios)
    if q:
        logger.info("Resuming crawl (%(queuesize)d requests scheduled)",
                    {
   'queuesize': len(q)}, extra={
   'spider': self.spider})
    return q

在 open 方法中，调度器会实例化出优先级队列，以及根据 dqdir是否配置，决定是否使用磁盘队列，最后调用了请求指纹过滤器的 open 方法，这个方法在父类 BaseDupeFilter 中定义：

class BaseDupeFilter(object):
    # 过滤器基类,子类可重写以下方法
    @classmethod
    def from_settings(cls, settings):
        return cls()

    def request_seen(self, request):
        # 请求过滤
        return False

    def open(self):
        # 可重写 完成过滤器的初始化工作
        pass

    def close(self, reason)