下载器中间件(Downloader middlewares)

https://cloud.tencent.com/info/557b853f48ed88bf74ee82f006149bff.html
在下载器处理request之前触发
下载器中间件是在引擎及下载器之间的特定钩子(specific hook)，处理Downloader传递给引擎的response。 其提供了一个简便的机制，通过插入自定义代码来扩展Scrapy功能。

三大方法：

• process_request(request,spider)

  当每个request通过下载中间件时，该方法被调用，要求返回None， Response, Request对象， raise IgnoreRequest：

  • None: Scrapy将继续处理该request，执行其他的中间件的相应方法，直到合适的下载器处理函数(download handler)被调用,该request被执行(其response被下载)。 即不做任何操作，不影响后面中间件执行， 不影响下载流程
  • Response对象： Scrapy将不会调用任何其他的process_request()或process_exception() 方法，或相应地下载函数；其将返回该response。 已安装的中间件的 process_response() 方法则会在每个response返回时被调用。即执行该中间件process_response()方法来接盘
  • Request对象：Scrapy则停止调用 process_request方法并重新调度返回的request。当新返回的request被执行后， 相应地中间件链将会根据下载的response被调用。 Request重新返回调度器队列
  • raise一个IgnoreRequest异常：则安装的下载中间件的 process_exception() 方法会被调用。如果没有任何一个方法处理该异常， 则request的errback(Request.errback)方法会被调用。如果没有代码处理抛出的异常， 则该异常被忽略且不记录。 process_exception方法来接盘

• process_response(request, response, spider)
  process_response 不能返回 None
  当每个response通过下载中间件时，该方法被调用。process_response的返回值也是有三种：response对象，request对象，或者raise一个IgnoreRequest异常：

  • response对象： (可以与传入的response相同，也可以是全新的对象)， 该response会被在链中的其他中间件的 process_response() 方法处理。 后续的中间件接收response， 跳过process_request了
  • Request 对象： 则中间件链停止， 返回的request会被重新调度下载。处理类似于 process_request() 返回request所做的那样。回炉调度器
  • IgnoreRequest 异常，则调用request的errback(Request.errback)。 如果没有代码处理抛出的异常，则该异常被忽略且不记录(不同于其他异常那样) process_exception方法来接盘

• process_exception(request, exception, spider)
  当下载处理器(download handler)或 process_request() (下载中间件)抛出异常(包括 IgnoreRequest 异常)时，Scrapy调用 process_exception()。也是返回三者中的一个: 返回 None 、 一个 Response 对象、或者一个 Request 对象。

  • None： Scrapy将会继续处理该异常，接着调用已安装的其他中间件的 process_exception() 方法，直到所有中间件都被调用完毕，则调用默认的异常处理。即把这个异常传递给后续的中间件的process_exception

  • Response 对象： 则已安装的中间件链的 process_response() 方法被调用。Scrapy将不会调用任何其他中间件的 process_exception() 方法。 后续中间件的process_response()接力

  • Request 对象： 则返回的request将会被重新调用下载。这将停止中间件process_excepption() 方法执行，就如返回一个response的那样。 这个是非常有用的，就相当于如果我们失败了可以在这里进行一次失败的重试，例如当我们访问一个网站出现因为频繁爬取被封ip就可以在这里设置增加代理继续访问。 回炉调度器

了解完这个， 我们来看下几个默认的下载中间件的源码：

在scrapy.settings.default_settings中查看：

DOWNLOADER_MIDDLEWARES = {}

DOWNLOADER_MIDDLEWARES_BASE = {
    # Engine side
    'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100,
    'scrapy.downloadermiddlewares.httpauth.HttpAuthMiddleware': 300,
    'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware': 350,
    'scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
    'scrapy.downloadermiddlewares.ajaxcrawl.AjaxCrawlMiddleware': 560,
    'scrapy.downloadermiddlewares.redirect.MetaRefreshMiddleware': 580,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 590,
    'scrapy.downloadermiddlewares.redirect.RedirectMiddleware': 600,
    'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
    'scrapy.downloadermiddlewares.stats.DownloaderStats': 850,
    'scrapy.downloadermiddlewares.httpcache.HttpCacheMiddleware': 900,
    # Downloader side
}

1, RetryMiddleware

重试下载
RetryMiddleware 可以通过下列设定进行配置 (更多内容请参考设置文档):

RETRY_ENABLED = True
RETRY_TIMES = 2   # initial response + 2 retries = 3 requests
RETRY_HTTP_CODES = [500, 502, 503, 504, 522, 524, 408]

def __init__(self, settings):
      if not settings.getbool('RETRY_ENABLED'):
          raise NotConfigured
      self.max_retry_times = settings.getint('RETRY_TIMES')
      self.retry_http_codes = set(int(x) for x in settings.getlist('RETRY_HTTP_CODES'))
      self.priority_adjust = settings.getint('RETRY_PRIORITY_ADJUST')

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

中间件启动的时候配置， 初始化配置

def process_response(self, request, response, spider):
        if request.meta.get('dont_retry', False):
            return response
        if response.status in self.retry_http_codes:
            reason = response_status_message(response.status)
            return self._retry(request, reason, spider) or response
        return response

没有process_exception方法(只处理前面传来的response和exception情况)
process_response中 dont_retry是request.meta中包含的键， 该request将会被本中间件忽略(如果个别url不想retry，可以在Request请求中带meta = {'dont_retry': False})。 返回结果分为这么几种情况：

• Response对象： meta不包含 dont_retry键值 或者包含 设置为True
• Request对象： 执行_retry， retry_times <= retry_times时， 返回调度器队列末尾重试
• Response对象： 执行_retry，retry_times > retry_times时， 尝试已满， 尽管response的状态码是self.retry_http_codes， 还是将其返回(所以说，我们自己的spider parse函数中需要去判断respose.status, scrapy不管正确与否都会给你返回一个response)
• response对象： 正常返回的response， 无需重试

** 前面传来的response的状态码status异常， 重试， 否则原样传递**

def _retry(self, request, reason, spider):
        retries = request.meta.get('retry_times', 0) + 1

        retry_times = self.max_retry_times

        if 'max_retry_times' in request.meta:
            retry_times = request.meta['max_retry_times']

        stats = spider.crawler.stats
        if retries <= retry_times:
            logger.debug("Retrying %(request)s (failed %(retries)d times): %(reason)s",
                         {'request': request, 'retries': retries, 'reason': reason},
                         extra={'spider': spider})
            retryreq = request.copy()
            retryreq.meta['retry_times'] = retries
            retryreq.dont_filter = True
            retryreq.priority = request.priority + self.priority_adjust

            if isinstance(reason, Exception):
                reason = global_object_name(reason.__class__)

            stats.inc_value('retry/count')
            stats.inc_value('retry/reason_count/%s' % reason)
            return retryreq
        else:
            stats.inc_value('retry/max_reached')
            logger.debug("Gave up retrying %(request)s (failed %(retries)d times): %(reason)s",
                         {'request': request, 'retries': retries, 'reason': reason},
                         extra={'spider': spider})

Request(url, meta={'max_retry_times': 5}, callback = self.parse)
覆盖setting中的配置 RETRY_TIMES。

copy一份request, 并修改它的meta字典， 增加retry_times用来标记这个第几次尝试。 返回request。 前面说到， process_response()方法返回request对象， 会停止后续的中间件， 添加到调度器回炉重新调度。 即重试。 重试次数满了以后， 返回None

def process_exception(self, request, exception, spider):
        if isinstance(exception, self.EXCEPTIONS_TO_RETRY) \
                and not request.meta.get('dont_retry', False):
            return self._retry(request, exception, spider)

异常process_exception处理， 两种情况：

• 如果承接的参数exception异常类型是self.EXCEPTIONS_TO_RETRY 并且检查有request.meta的dont_retry键值是True, 那么 调用 self._retry:

  • Request： 尝试未满， 回炉
  • None: 尝试已满， 同下一条None的后续处理

• 异常不是self.EXCEPTIONS_TO_RETRY 返回None, 调用剩下的中间件的process_exception方法

2, RedirectMiddleware

该中间件根据response的状态处理重定向的request。

通过该中间件的(被重定向的)request的url可以通过 Request.meta 的 redirect_urls 键找到。

默认Setting:

REDIRECT_ENABLED = True
REDIRECT_MAX_TIMES = 20  # uses Firefox default setting
REDIRECT_PRIORITY_ADJUST = +2

class RedirectMiddleware(BaseRedirectMiddleware):
    """
    Handle redirection of requests based on response status
    and meta-refresh html tag.
    """
    def process_response(self, request, response, spider):
        if (request.meta.get('dont_redirect', False) or
                response.status in getattr(spider, 'handle_httpstatus_list', []) or
                response.status in request.meta.get('handle_httpstatus_list', []) or
                request.meta.get('handle_httpstatus_all', False)):
            return response

        allowed_status = (301, 302, 303, 307, 308)
        if 'Location' not in response.headers or response.status not in allowed_status:
            return response

        location = safe_url_string(response.headers['location'])

        redirected_url = urljoin(request.url, location)

        if response.status in (301, 307, 308) or request.method == 'HEAD':
            redirected = request.replace(url=redirected_url)
            return self._redirect(redirected, request, spider, response.status)

        redirected = self._redirect_request_using_get(request, redirected_url)
        return self._redirect(redirected, request, spider, response.status)

继承了BaseRedirectMiddleware， 只实现了process_response()， 因为只有拿到Response才能判断 是否重定向了.

同样的 Rquest对象中meta的dont_redirect键控制

allowed_status = (301, 302, 303, 307, 308)
        if 'Location' not in response.headers or response.status not in allowed_status:
            return response

非跳转链接， 返回正常的response

location = safe_url_string(response.headers['location'])

        redirected_url = urljoin(request.url, location)

redirected_url跳转后的链接， request.url是本来要访问的页面
找一个重定向的页面 看下response.headers['location']

补充：

• HEAD 类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
• GET 请求指定的页面信息，并返回实体主体。
• POST 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。

父类BaseRedirectMiddleware的_redirect是返回两种情况：

• 修改后重定向的Request(meta标记第几次跳转了) 回调度器再访问
• IgnoreRequest 异常， process_exception来处理， 但是没有实现process_exception方法， 所以忽略该异常

没看懂为啥根据request的headers和status分为这俩种情况

• response.status in (301, 307, 308) or request.method == 'HEAD'
• response.status in (302, 303) and or request.method != 'HEAD'

有大神了解http这块的， 还望赐教~

补充一个涉及到状态码的表

http://tool.oschina.net/commons?type=5

3, DefaultHeadersMiddleware

该中间件设置 DEFAULT_REQUEST_HEADERS 指定的默认request header。

class DefaultHeadersMiddleware(object):

    def __init__(self, headers):
        self._headers = headers

    @classmethod
    def from_crawler(cls, crawler):
        headers = without_none_values(crawler.settings['DEFAULT_REQUEST_HEADERS'])
        return cls(headers.items())

    def process_request(self, request, spider):
        for k, v in self._headers:
            request.headers.setdefault(k, v)

这个比较简单， 使用setting中 DEFAULT_REQUEST_HEADERS 来作为request.headers， 在Request构造函数中也可以指定headers, 所以没什么用

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, flags=None)

4, CookiesMiddleware

该中间件使得爬取需要cookie(例如使用session)的网站成为了可能。 其追踪了web server发送的cookie，并在之后的request中发送回去， 就如浏览器所做的那样。

• 涉及到setting中的COOKIES_ENABLED 和 COOKIES_DEBUG 配置
  • COOKIES_ENABLED: 默认: True, 是否启用cookies middleware。如果关闭，cookies将不会发送给web server。
  • COOKIES_DEBUG: 默认: False, 如果启用，Scrapy将记录所有在request(Cookie 请求头)发送的cookies及response接收到的cookies(Set-Cookie 接收头)。
• meta的cookiejar键值. 单spider多cookie session

    for i, url in enumerate(urls):
       yield scrapy.Request("http://www.example.com",                              meta={'cookiejar': i},
                              callback=self.parse_page)
   def parse_page(self, response):
       # do some processing
       return scrapy.Request("http://www.example.com/otherpage",
               meta={'cookiejar': response.meta['cookiejar']},
               callback=self.parse_other_page)

来看下源码：

def process_request(self, request, spider):
        if request.meta.get('dont_merge_cookies', False):
            return

        cookiejarkey = request.meta.get("cookiejar")
        jar = self.jars[cookiejarkey]
        cookies = self._get_request_cookies(jar, request)
        for cookie in cookies:
            jar.set_cookie_if_ok(cookie, request)

        # set Cookie header
        request.headers.pop('Cookie', None)
        jar.add_cookie_header(request)
        self._debug_cookie(request, spider)

    def process_response(self, request, response, spider):
        if request.meta.get('dont_merge_cookies', False):
            return response

        # extract cookies from Set-Cookie and drop invalid/expired cookies
        cookiejarkey = request.meta.get("cookiejar")
        jar = self.jars[cookiejarkey]
        jar.extract_cookies(response, request)
        self._debug_set_cookie(response, spider)

        return response

4, RobotsTxtMiddleware

robots 条款, ROBOTSTXT_OBEY

class RobotsTxtMiddleware(object):
    DOWNLOAD_PRIORITY = 1000

    def __init__(self, crawler):
        if not crawler.settings.getbool('ROBOTSTXT_OBEY'):
            raise NotConfigured

        self.crawler = crawler
        self._useragent = crawler.settings.get('USER_AGENT')
        self._parsers = {}

    @classmethod
    def from_crawler(cls, crawler):
        return cls(crawler)

    def process_request(self, request, spider):
        if request.meta.get('dont_obey_robotstxt'):
            return
        d = maybeDeferred(self.robot_parser, request, spider)
        d.addCallback(self.process_request_2, request, spider)
        return d

    def process_request_2(self, rp, request, spider):
        if rp is not None and not rp.can_fetch(
                 to_native_str(self._useragent), request.url):
            logger.debug("Forbidden by robots.txt: %(request)s",
                         {'request': request}, extra={'spider': spider})
            raise IgnoreRequest()

    def robot_parser(self, request, spider):
        url = urlparse_cached(request)
        netloc = url.netloc

        if netloc not in self._parsers:
            self._parsers[netloc] = Deferred()
            robotsurl = "%s://%s/robots.txt" % (url.scheme, url.netloc)
            robotsreq = Request(
                robotsurl,
                priority=self.DOWNLOAD_PRIORITY,
                meta={'dont_obey_robotstxt': True}
            )
            dfd = self.crawler.engine.download(robotsreq, spider)
            dfd.addCallback(self._parse_robots, netloc)
            dfd.addErrback(self._logerror, robotsreq, spider)
            dfd.addErrback(self._robots_error, netloc)

        if isinstance(self._parsers[netloc], Deferred):
            d = Deferred()
            def cb(result):
                d.callback(result)
                return result
            self._parsers[netloc].addCallback(cb)
            return d
        else:
            return self._parsers[netloc]

    def _logerror(self, failure, request, spider):
        if failure.type is not IgnoreRequest:
            logger.error("Error downloading %(request)s: %(f_exception)s",
                         {'request': request, 'f_exception': failure.value},
                         exc_info=failure_to_exc_info(failure),
                         extra={'spider': spider})
        return failure

    def _parse_robots(self, response, netloc):
        rp = robotparser.RobotFileParser(response.url)
        body = ''
        if hasattr(response, 'text'):
            body = response.text
        else: # last effort try
            try:
                body = response.body.decode('utf-8')
            except UnicodeDecodeError:
                # If we found garbage, disregard it:,
                # but keep the lookup cached (in self._parsers)
                # Running rp.parse() will set rp state from
                # 'disallow all' to 'allow any'.
                pass
        # stdlib's robotparser expects native 'str' ;
        # with unicode input, non-ASCII encoded bytes decoding fails in Python2
        rp.parse(to_native_str(body).splitlines())

        rp_dfd = self._parsers[netloc]
        self._parsers[netloc] = rp
        rp_dfd.callback(rp)

    def _robots_error(self, failure, netloc):
        rp_dfd = self._parsers[netloc]
        self._parsers[netloc] = None
        rp_dfd.callback(None)

需要先下载，得到response解析后才能拿到robots.txt 条款
在robot_parser()方法中，

robotsurl = "%s://%s/robots.txt" % (url.scheme, url.netloc)
            robotsreq = Request(
                robotsurl,
                priority=self.DOWNLOAD_PRIORITY,
                meta={'dont_obey_robotstxt': True}
            )
dfd = self.crawler.engine.download(robotsreq, spider)

self.crawler.engine.download 下载器
解析robots 包from six.moves.urllib import robotparser 提供了方法， python包真是多，

5， RedisMiddleware

关于Redis存储已爬取的urlhash，需要实现RedisMiddleware。

class RedisMiddleware(object):
    """
    redis 存储已爬取的urlHash, 已存在则不下载
    """
    enabled_setting = 'REDIS_ENABLED'

    def __init__(self, settings):
        if not settings.getbool(self.enabled_setting):
            raise NotConfigured
        self.redis_opera = RedisOpera()
        # redis 连接池
        self.redis_conf = settings.getdict('REDIS_CONF')
        if self.redis_conf == {} or 'keys' not in self.redis_conf.keys():
            raise NotConfigured
        # 初始化redis-keys
        self.redis_opera.init_url_set(self._get(self.redis_conf, 'db', 0),
                                      self.redis_conf['keys'],
                                      self._get(self.redis_conf, 'db_name'),
                                      self._get(self.redis_conf, 'initialUrlListSql')
                                      )

    @staticmethod
    def _get(dct, name, default=None):
        return dct[name] if dct[name] is not None else default

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

    def process_request(self, request, spider):
        hash_id = get_md5(request.url)
        flag = self.redis_opera.is_exists(hash_id, self.redis_conf['db'], self.redis_conf['keys'])
        if not flag:
            return None
        else:
            raise IgnoreRequest()

    def process_exception(self, request, exception, spider):
        pass