下载器中间件(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
| 状态码 | 含义 |
|---|---|
| 301 | 被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个 URI 之一 |
| 302 | 请求的资源现在临时从不同的 URI 响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求 |
| 303 | 对应当前请求的响应可以在另一个 URI 上被找到，而且客户端应当采用 GET 的方式访问那个资源 |
| 307 | 请求的资源现在临时从不同的URI 响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求 |
| 400 | 1、语义有误，当前请求无法被服务器理解。除非进行修改，否则客户端不应该重复提交这个请求。 2、请求参数有误。 |
| 401 | 当前请求需要用户验证。该响应必须包含一个适用于被请求资源的 WWW-Authenticate 信息头用以询问用户信息 |
| 403 | 服务器已经理解请求，但是拒绝执行它。与401响应不同的是，身份验证并不能提供任何帮助，而且这个请求也不应该被重复提交。如果这不是一个 HEAD 请求，而且服务器希望能够讲清楚为何请求不能被执行，那么就应该在实体内描述拒绝的原因。当然服务器也可以返回一个404响应，假如它不希望让客户端获得任何信息 |
| 404 | 请求失败，请求所希望得到的资源未被在服务器上发现。 |
| 500 | 服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在服务器的程序码出错时出现。 |
| 502 | 作为网关或者代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。 |
| 503 | 由于临时的服务器维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复. 如果能够预计延迟时间，那么响应中可以包含一个 Retry-After 头用以标明这个延迟时间。如果没有给出这个 Retry-After 信息，那么客户端应当以处理500响应的方式处理它。 注意：503状态码的存在并不意味着服务器在过载的时候必须使用它。某些服务器只不过是希望拒绝客户端的连接 |
| 504 | 作为网关或者代理工作的服务器尝试执行请求时，未能及时从上游服务器（URI标识出的服务器，例如HTTP、FTP、LDAP）或者辅助服务器（例如DNS）收到响应。 注意：某些代理服务器在DNS查询超时时会返回400或者500错误 |
| 522 | |
| 524 | |
| 408 | 请求超时。客户端没有在服务器预备等待的时间内完成一个请求的发送。客户端可以随时再次提交这一请求而无需进行任何更改。 |
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