scrapy源码分析（十）------------Scraper

上一节分析了Scheduler的源码，这一节分析ExecutionEngine的另外一个关键对象Scraper.

Scraper的主要作用是对网络蜘蛛中间件进行管理，通过中间件完成请求，响应，数据分析等工作。

先从构造函数分析起：

scrapy/core/scraper.py:

class Scraper(object):

    def __init__(self, crawler):
        self.slot = None
        self.spidermw = SpiderMiddlewareManager.from_crawler(crawler)
        itemproc_cls = load_object(crawler.settings['ITEM_PROCESSOR'])
        self.itemproc = itemproc_cls.from_crawler(crawler)
        self.concurrent_items = crawler.settings.getint('CONCURRENT_ITEMS')
        self.crawler = crawler
        self.signals = crawler.signals
        self.logformatter = crawler.logformatter

主要有3个对象，先依次分析一下：

1.spidermw:

self.spidermw = SpiderMiddlewareManager.from_crawler(crawler)

老规矩，调用SpiderMiddlewareManger的from_crawler方法生成网络蜘蛛中间件管理器。

这个from_cralwer方法是基类MiddlewareManger的方法:

scrapy/middleware.py:

@classmethod
def from_crawler(cls, crawler):
    return cls.from_settings(crawler.settings, crawler)

通过crawler的配置生成对象：

@classmethod
def from_settings(cls, settings, crawler=None):
    mwlist = cls._get_mwlist_from_settings(settings) /*调用_get_mwlist_from_settings方法从配置文件中生成中间件列表，这个方法需要子类实现*/
    middlewares = []
    enabled = []
    for clspath in mwlist:
        try:
            mwcls = load_object(clspath)
            if crawler and hasattr(mwcls, 'from_crawler'):/*依次加载中间件模块并构造对象，构造顺序是先尝试调用from_cralwer,再尝试调用from_settings,最后都没有再调用__init__*/
                mw = mwcls.from_crawler(crawler)
            elif hasattr(mwcls, 'from_settings'):
                mw = mwcls.from_settings(settings)
            else:
                mw = mwcls()
            middlewares.append(mw)
            enabled.append(clspath)
        except NotConfigured as e:
            if e.args:
                clsname = clspath.split('.')[-1]
                logger.warning("Disabled %(clsname)s: %(eargs)s",
                               {'clsname': clsname, 'eargs': e.args[0]},
                               extra={'crawler': crawler})

    logger.info("Enabled %(componentname)ss:\n%(enabledlist)s",
                {'componentname': cls.component_name,
                 'enabledlist': pprint.pformat(enabled)},
                extra={'crawler': crawler})
    return cls(*middlewares) /*用中间件对象列表构造管理器*/

scrapy实现了许多中间件管理器，不同的中间件管理器需要实现自己的_get_mwlist_from_settings方法来从配置中获取中间件列表，我们看下spider中间件管理器的实现：

@classmethod
def _get_mwlist_from_settings(cls, settings):
    return build_component_list(settings.getwithbase('SPIDER_MIDDLEWARES'))

调用公共的build_component_list方法从配置中获取SPIDER_MIDDLEWARES_BASE中间件列表，我们看下默认的中间件：

SPIDER_MIDDLEWARES_BASE = {
    # Engine side
    'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50,
    'scrapy.spidermiddlewares.offsite.OffsiteMiddleware': 500,
    'scrapy.spidermiddlewares.referer.RefererMiddleware': 700,
    'scrapy.spidermiddlewares.urllength.UrlLengthMiddleware': 800,
    'scrapy.spidermiddlewares.depth.DepthMiddleware': 900,
    # Spider side
}

中间件除了类路径，还有一个优先级，这个决定了后面调用的先后顺序，数字越小调用越靠前。

获取了中间件列表之后，就是依次加载中间件模块，并构造中间件对象。构造中间件对象时会尝试使用不同的方法，优先依次是from_crawler,from_settings,__init__。

再看下MiddlewareManager的构造方法:

def __init__(self, *middlewares):
    self.middlewares = middlewares
    self.methods = defaultdict(list)
    for mw in middlewares:
        self._add_middleware(mw)

遍历所有的中间件，并调用_add_middleware方法:

def _add_middleware(self, mw):
    if hasattr(mw, 'open_spider'):
        self.methods['open_spider'].append(mw.open_spider)
    if hasattr(mw, 'close_spider'):
        self.methods['close_spider'].insert(0, mw.close_spider)

可以看到，就是向methods字典里依次添加中间件的'open_spider'和'close_spider'方法。

def _add_middleware(self, mw):
    super(SpiderMiddlewareManager, self)._add_middleware(mw)
    if hasattr(mw, 'process_spider_input'):
        self.methods['process_spider_input'].append(mw.process_spider_input)
    if hasattr(mw, 'process_spider_output'):
        self.methods['process_spider_output'].insert(0, mw.process_spider_output)
    if hasattr(mw, 'process_spider_exception'):
        self.methods['process_spider_exception'].insert(0, mw.process_spider_exception)
    if hasattr(mw, 'process_start_requests'):
        self.methods['process_start_requests'].insert(0, mw.process_start_requests)

网络蜘蛛中间件管理器通过自定义'_add_middleware'方法还添加了'process_spider_input','process_spider_output','process_spider_exception','process_start_request'方法，这些方面后面的分析中都会乃至。

这样就分析完了网络蜘蛛中间件管理器对象的构造代码，可以看到它维护了所有配置的中间件对象，并通过方法字典维护了中间件的各种钩子方法，后面的代码分析中将会看到如何使用这些中间件对象和它们的方法。

2.itemproc

itemproc_cls = load_object(crawler.settings['ITEM_PROCESSOR'])
self.itemproc = itemproc_cls.from_crawler(crawler)

itemproc从配置文件中获取‘ITEM_PROCESSOR’，默认为：

ITEM_PROCESSOR = 'scrapy.pipelines.ItemPipelineManager'

也是调用其from_crawler方法生成对象:

scrapy/pipelines/__init__.py:

class ItemPipelineManager(MiddlewareManager):

    component_name = 'item pipeline'

可以看到其也是一个中间件管理器，因此也需要定义‘_get_mwlist_from_settings'来初始化中间件列表：

@classmethod
def _get_mwlist_from_settings(cls, settings):
    return build_component_list(settings.getwithbase('ITEM_PIPELINES'))

看一下它默认管理哪些中间件:

ITEM_PIPELINES = {}
ITEM_PIPELINES_BASE = {}

默认为空，也就是没有。所以如果需要对爬取到的数据进行处理，需要我们自己定义，下面是我自己定义的一个中间件:

ITEM_PIPELINES = {
   'tutorials.pipelines.MongoPipeline': 300,
}

这个中间件主要是使用mongodb进行数据存储。

再看一下，ItemPipelineManger的其它方法：

def _add_middleware(self, pipe):
    super(ItemPipelineManager, self)._add_middleware(pipe)
    if hasattr(pipe, 'process_item'):
        self.methods['process_item'].append(pipe.process_item)

def process_item(self, item, spider):
    return self._process_chain('process_item', item, spider)

可以看到重定义了_add_middleware方法，也就是除了向管理器中添加中间件的'open_spider'和'close_spider'方法，还添加了'process_item'方法，自定义的ITEM_PIPELINE实现这个方法用于处理从网页中爬取到的item.

3.concurrent_items

self.concurrent_items = crawler.settings.getint('CONCURRENT_ITEMS')

这个默认的配置为100:

CONCURRENT_ITEMS = 100

这个并发度用于控制同时处理的爬取到的item的数据数目，通过twisted.internet的task.Cooperator实现并发控制：

def handle_spider_output(self, result, request, response, spider):
    if not result:
        return defer_succeed(None)
    it = iter_errback(result, self.handle_spider_error, request, response, spider)
    dfd = parallel(it, self.concurrent_items,
        self._process_spidermw_output, request, response, spider)
    return dfd

可以看到scraper在处理spider的parse结果后会调用handle_spider_output来处理输出，通过parallel来控制同时处理的条目。

了解了Scraper使用的3个对象的主要功能，我们来看一下scraper串联它们3个来工作的流程：

ExecutionEngine在open_spider里会调用scraper的open_spider方法来初始化scraper:

yield self.scraper.open_spider(spider)

我们看下Scraper的open_spider:

@defer.inlineCallbacks
def open_spider(self, spider):
    """Open the given spider for scraping and allocate resources for it"""
    self.slot = Slot()
    yield self.itemproc.open_spider(spider)

声明了一个Slot,如果item管理器中的中间件定义了open_spider方法则调用它。

前面讲engine的时候讲过，引擎里会通过不断执行’_next_request'方法来处理新的请求，其中又会在不需要backout时调用'_next_request_from_scheduler'来处理新请求，这个方法从名字上也可以看出，是从上一节讲述的scheduler中取请求处理。

def _next_request_from_scheduler(self, spider):
    slot = self.slot
    request = slot.scheduler.next_request()
    if not request:
        return
    d = self._download(request, spider)
    d.addBoth(self._handle_downloader_output, request, spider)
    d.addErrback(lambda f: logger.info('Error while handling downloader output',
                                       exc_info=failure_to_exc_info(f),
                                       extra={'spider': spider}))
    d.addBoth(lambda _: slot.remove_request(request))
    d.addErrback(lambda f: logger.info('Error while removing request from slot',
                                       exc_info=failure_to_exc_info(f),
                                       extra={'spider': spider}))
    d.addBoth(lambda _: slot.nextcall.schedule())
    d.addErrback(lambda f: logger.info('Error while scheduling new request',
                                       exc_info=failure_to_exc_info(f),
                                       extra={'spider': spider}))
    return d

可以看到，从scheduler中获取一个请求后，调用_download方法进行下载，然后给这个Deferred安装了一个callback方法_handle_downloader_output来处理下载完成后的操作。最后会移除请求并再一次调用nextcall的schedule来处理新请求，这是我们前面提到的主动调用的一种情况，被动调用即5s心跳前面章节有讲解。

Scraper主要在下载完成后起作用，我们来分析_handle_downloader_output方法:

def _handle_downloader_output(self, response, request, spider):
    assert isinstance(response, (Request, Response, Failure)), response
    # downloader middleware can return requests (for example, redirects)
    if isinstance(response, Request):
        self.crawl(response, spider)
        return
    # response is a Response or Failure
    d = self.scraper.enqueue_scrape(response, request, spider)
    d.addErrback(lambda f: logger.error('Error while enqueuing downloader output',
                                        exc_info=failure_to_exc_info(f),
                                        extra={'spider': spider}))
    return d

可以看到，如果返回的response是Request则继续调用crawl方法入schdeuler队列，否则则调用scraper的enqueue_scrape方法。

def enqueue_scrape(self, response, request, spider):
    slot = self.slot
    dfd = slot.add_response_request(response, request)/*放入队列中*/
    def finish_scraping(_):
        slot.finish_response(response, request)
        self._check_if_closing(spider, slot)
        self._scrape_next(spider, slot)
        return _
    dfd.addBoth(finish_scraping)
    dfd.addErrback(
        lambda f: logger.error('Scraper bug processing %(request)s',
                               {'request': request},
                               exc_info=failure_to_exc_info(f),
                               extra={'spider': spider}))
    self._scrape_next(spider, slot)
    return dfd

这个方法先把要分析的response放入自己的队列中，然后为这个response返回的deferred添加一个finish_scraping方法，用来处理scraping完成后的操作，然后调用_scrape_next处理队列中的response.

def _scrape_next(self, spider, slot):
    while slot.queue:
        response, request, deferred = slot.next_response_request_deferred()
        self._scrape(response, request, spider).chainDeferred(deferred) /*链接到原来的deferred*/

可以看到这个方法不断从队列中获取response来调用_scrape方法，并在_scrape后调用原来安装的finish_scraping方法。

def _scrape(self, response, request, spider):
    """Handle the downloaded response or failure trough the spider
    callback/errback"""
    assert isinstance(response, (Response, Failure))

    dfd = self._scrape2(response, request, spider) # returns spiders processed output
    dfd.addErrback(self.handle_spider_error, request, response, spider)
    dfd.addCallback(self.handle_spider_output, request, response, spider)
    return dfd

_scrape方法调用_scrape2后，会给deferred安装handle_spider_output方法，说明在_scrape2处理完成后会调用handle_spider_output方法，这个方法也就是前面提到的处理具体item的方法。

这个_scrape2方法判断如果request_result不是错误就调用前面讲的中间件管理器的scrape_response方法

def _scrape2(self, request_result, request, spider):
    """Handle the different cases of request's result been a Response or a
    Failure"""
    if not isinstance(request_result, Failure):
        return self.spidermw.scrape_response(
            self.call_spider, request_result, request, spider)
    else:
        # FIXME: don't ignore errors in spider middleware
        dfd = self.call_spider(request_result, request, spider)
        return dfd.addErrback(
            self._log_download_errors, request_result, request, spider)

我们接着看网络蜘蛛中间件管理器的scrape_response方法:

def scrape_response(self, scrape_func, response, request, spider):
    fname = lambda f:'%s.%s' % (
            six.get_method_self(f).__class__.__name__,
            six.get_method_function(f).__name__)

    def process_spider_input(response):
        for method in self.methods['process_spider_input']:
            try:
                result = method(response=response, spider=spider)
                assert result is None, \
                        'Middleware %s must returns None or ' \
                        'raise an exception, got %s ' \
                        % (fname(method), type(result))
            except:
                return scrape_func(Failure(), request, spider)
        return scrape_func(response, request, spider)

    def process_spider_exception(_failure):
        exception = _failure.value
        for method in self.methods['process_spider_exception']:
            result = method(response=response, exception=exception, spider=spider)
            assert result is None or _isiterable(result), \
                'Middleware %s must returns None, or an iterable object, got %s ' % \
                (fname(method), type(result))
            if result is not None:
                return result
        return _failure

    def process_spider_output(result):
        for method in self.methods['process_spider_output']:
            result = method(response=response, result=result, spider=spider)
            assert _isiterable(result), \
                'Middleware %s must returns an iterable object, got %s ' % \
                (fname(method), type(result))
        return result

    dfd = mustbe_deferred(process_spider_input, response)
    dfd.addErrback(process_spider_exception)
    dfd.addCallback(process_spider_output)
    return dfd

这个方法首先依次调用中间件的'process_spider_input'方法，然后调用传递进来的scrap_func，也就是call_spider方法，如果某个中间件的'process_spider_input'方法抛出了异常，则以Failure调用call_spider方法。

如果所有中间件都处理成功，且call_spider也返回成功，则调用'process_spider_output'方法，这个方法依次调用中间件的'process_spider_output'方法。

下面重点分析下call_spider方法：

def call_spider(self, result, request, spider):
    result.request = request
    dfd = defer_result(result)
    dfd.addCallbacks(request.callback or spider.parse, request.errback)
    return dfd.addCallback(iterate_spider_output)
可以看到，会对返回的response调用request.callback或者spider.parse方法，也就是说如果Request定义了callback则
优先调用callback分析，如果没有则调用spider的parse方法分析。

这样整个流程就清楚了，对于一个下载的网页，会先调用各个spider中间件的'process_spider_input'方法处理，如果全部
处理成功则调用request.callback或者spider.parse方法进行分析，然后将分析的结果调用各个spider中间件的‘process_spider_output'
处理，都处理成功了再交给ItemPipeLine进行处理，ItemPipeLine调用定义的'process_item'处理爬取到的数据结果。