爬虫类
接着上次代码讲,上次的运行入口执行到最后是执行了Crawler
的crawl
方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@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()
start_requests = iter(self.spider.start_requests())
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
|
在这里,就交由scrapy的引擎来处理了。
依次来看,爬虫类是如何实例化的?上文已讲解过,在Crawler
实例化时,会创建SpiderLoader
,它会根据用户的配置文件settings.py
找到存放爬虫的位置,我们写的爬虫都会放在这里。
然后SpiderLoader
会扫描这里的所有文件,并找到父类是scrapy.Spider
爬虫类,然后根据爬虫类中的name
属性(在编写爬虫时,这个属性是必填的),最后生成一个{spider_name: spider_cls}
的字典,然后根据scrapy crawl <spider_name>
命令,根据spider_name
找到对应的爬虫类,然后实例化它,在这里就是调用了_create_spider
方法:
1
2
3
|
def _create_spider(self, *args, **kwargs):
return self.spidercls.from_crawler(self, *args, **kwargs)
|
实例化爬虫比较有意思,它不是通过普通的构造方法进行初始化,而是调用了类方法from_crawler
进行的初始化,找到scrapy.Spider
类:
1
2
3
4
5
6
7
8
9
10
11
|
@classmethod
def from_crawler(cls, crawler, *args, **kwargs):
spider = cls(*args, **kwargs)
spider._set_crawler(crawler)
return spider
def _set_crawler(self, crawler):
self.crawler = crawler
self.settings = crawler.settings
crawler.signals.connect(self.close, signals.spider_closed)
|
在这里可以看到,这个类方法其实也是调用了构造方法,进行实例化,同时也拿到了settings
配置,来看构造方法干了些什么?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Spider(object_ref):
name =
None
custom_settings =
None
def __init__(self, name=None, **kwargs):
if name
is
not
None:
self.name = name
elif
not getattr(self,
'name',
None):
raise ValueError(
"%s must have a name" % type(self).__name__)
self.__dict__.update(kwargs)
if
not hasattr(self,
'start_urls'):
self.start_urls = []
|
看到这里是不是很熟悉?这里就是我们平时编写爬虫类时,最常用的几个属性:name
、start_urls
、custom_settings
。
name
:在运行爬虫时通过它找到对应的爬虫脚本而使用;start_urls
:定义种子URL;custom_settings
:从字面意思可以看出,爬虫自定义配置,会覆盖配置文件的配置项;
引擎
分析完爬虫类的初始化后,还是回到Crawler
的crawl
方法,紧接着就是创建引擎对象,也就是_create_engine
方法,这里直接进行了引擎初始化操作,看看都发生了什么?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class ExecutionEngine(object):
"""引擎"""
def __init__(self, crawler, spider_closed_callback):
self.crawler = crawler
self.settings = crawler.settings
self.signals = crawler.signals
self.logformatter = crawler.logformatter
self.slot =
None
self.spider =
None
self.running =
False
self.paused =
False
self.scheduler_cls = load_object(self.settings[
'SCHEDULER'])
downloader_cls = load_object(self.settings[
'DOWNLOADER'])
self.downloader = downloader_cls(crawler)
self.scraper = Scraper(crawler)
self._spider_closed_callback = spider_closed_callback
|
在这里能看到,进行了核心组件的定义和初始化,包括:Scheduler
、Downloader
、Scrapyer
,其中Scheduler
只进行了类定义,没有实例化。
调度器
调度器初始化发生在引擎的open_spider
方法中,我们提前来看一下调度器的初始化完成了哪些工作?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
class Scheduler(object):
"""调度器"""
def __init__(self, dupefilter, jobdir=None, dqclass=None, mqclass=None,
logunser=False, stats=None, pqclass=None):
self.df = dupefilter
self.dqdir = self._dqdir(jobdir)
self.pqclass = pqclass
self.dqclass = dqclass
self.mqclass = mqclass
self.logunser = logunser
self.stats = stats
@classmethod
def from_crawler(cls, crawler):
settings = crawler.settings
dupefilter_cls = load_object(settings[
'DUPEFILTER_CLASS'])
dupefilter = dupefilter_cls.from_settings(settings)
pqclass = load_object(settings[
'SCHEDULER_PRIORITY_QUEUE'])
dqclass = load_object(settings[
'SCHEDULER_DISK_QUEUE'])
mqclass = load_object(settings[
'SCHEDULER_MEMORY_QUEUE'])
logunser = settings.getbool(
'LOG_UNSERIALIZABLE_REQUESTS', settings.getbool(
'SCHEDULER_DEBUG'))
return cls(dupefilter, jobdir=job_dir(settings), logunser=logunser,
stats=crawler.stats, pqclass=pqclass, dqclass=dqclass, mqclass=mqclass)
|
调度器的初始化主要做了2件事:
- 实例化请求指纹过滤器:用来过滤重复请求,可自己重写替换之;
- 定义各种不同类型的任务队列:优先级任务队列、基于磁盘的任务队列、基于内存的任务队列;
请求指纹过滤器
先来看请求指纹过滤器是什么?
在配置文件中定义的默认指纹过滤器是RFPDupeFilter
:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class RFPDupeFilter(BaseDupeFilter):
"""请求指纹过滤器"""
def __init__(self, path=None, debug=False):
self.file =
None
self.fingerprints = set()
self.logdupes =
True
self.debug = debug
self.logger = logging.getLogger(__name__)
if path:
self.file = open(os.path.join(path,
'requests.seen'),
'a+')
self.file.seek(
0)
self.fingerprints.update(x.rstrip()
for x
in self.file)
@classmethod
def from_settings(cls, settings):
debug = settings.getbool(
'DUPEFILTER_DEBUG')
return cls(job_dir(settings), debug)
|
请求指纹过滤器初始化时,定义了指纹集合,这个集合使用内存实现的set
,而且可以控制这些指纹是否存入磁盘供下次重复使用。
指纹过滤器的主要职责是:过滤重复请求,可自定义过滤规则。
在下篇文章中会介绍到,每个请求是根据什么规则生成指纹,进而实现重复请求过滤逻辑的。
任务队列
调度器默认定义的2种队列类型:
- 基于磁盘的任务队列:在配置文件可配置存储路径,每次执行后会把队列任务保存到磁盘上;
- 基于内存的任务队列:每次都在内存中执行,下次启动则消失;
配置文件默认定义如下:
1
2
3
4
5
6
|
SCHEDULER_DISK_QUEUE =
'scrapy.squeues.PickleLifoDiskQueue'
SCHEDULER_MEMORY_QUEUE =
'scrapy.squeues.LifoMemoryQueue'
SCHEDULER_PRIORITY_QUEUE =
'queuelib.PriorityQueue'
|
如果用户在配置文件中定义了JOBDIR
,那么则每次把任务队列保存在磁盘中,下次启动时自动加载。
如果没有定义,那么则使用的是内存队列。
细心的你会发现,默认定义的这些队列结构都是后进先出的,什么意思呢?
也就是说:Scrapy默认的采集规则是深度优先采集!
如何改变这种机制,变为广度优先采集呢?那么你可以看一下scrapy.squeues
模块,其中定义了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
PickleFifoDiskQueue = _serializable_queue(queue.FifoDiskQueue, \
_pickle_serialize, pickle.loads)
PickleLifoDiskQueue = _serializable_queue(queue.LifoDiskQueue, \
_pickle_serialize, pickle.loads)
MarshalFifoDiskQueue = _serializable_queue(queue.FifoDiskQueue, \
marshal.dumps, marshal.loads)
MarshalLifoDiskQueue = _serializable_queue(queue.LifoDiskQueue, \
marshal.dumps, marshal.loads)
FifoMemoryQueue = queue.FifoMemoryQueue
LifoMemoryQueue = queue.LifoMemoryQueue
|
你只需要在配置文件中把队列类修改为先进先出队列类就可以了!有没有发现,模块化、组件替代再次发挥威力!
如果你想追究这些队列是如何实现的,可以参考scrapy作者写的scrapy/queuelib模块。
下载器
回头引擎的初始化,来看下载器是如何初始化的。
在默认的配置文件default_settings.py
中,下载器配置如下:
1
|
DOWNLOADER =
'scrapy.core.downloader.Downloader'
|
Downloader
实例化:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class Downloader(object):
"""下载器"""
def __init__(self, crawler):
self.settings = crawler.settings
self.signals = crawler.signals
self.slots = {}
self.active = set()
self.handlers = DownloadHandlers(crawler)
self.total_concurrency = self.settings.getint(
'CONCURRENT_REQUESTS')
self.domain_concurrency = self.settings.getint(
'CONCURRENT_REQUESTS_PER_DOMAIN')
self.ip_concurrency = self.settings.getint(
'CONCURRENT_REQUESTS_PER_IP')
self.randomize_delay = self.settings.getbool(
'RANDOMIZE_DOWNLOAD_DELAY')
self.middleware = DownloaderMiddlewareManager.from_crawler(crawler)
self._slot_gc_loop = task.LoopingCall(self._slot_gc)
self._slot_gc_loop.start(
60)
|
这个过程主要是初始化了下载处理器、下载器中间件管理器以及从配置文件中拿到抓取请求控制相关参数。
下载器DownloadHandlers
是做什么的?
下载器中间件DownloaderMiddlewareManager
初始化发生了什么?
下载处理器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class DownloadHandlers(object):
"""下载器处理器"""
def __init__(self, crawler):
self._crawler = crawler
self._schemes = {}
self._handlers = {}
self._notconfigured = {}
handlers = without_none_values(
crawler.settings.getwithbase(
'DOWNLOAD_HANDLERS'))
for scheme, clspath
in six.iteritems(handlers):
self._schemes[scheme] = clspath
crawler.signals.connect(self._close, signals.engine_stopped)
|
下载处理器在默认的配置文件中是这样配置的:
1
2
3
4
5
6
7
8
9
10
|
DOWNLOAD_HANDLERS = {}
DOWNLOAD_HANDLERS_BASE = {
'file':
'scrapy.core.downloader.handlers.file.FileDownloadHandler',
'http':
'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',
'https':
'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',
's3':
'scrapy.core.downloader.handlers.s3.S3DownloadHandler',
'ftp':
'scrapy.core.downloader.handlers.ftp.FTPDownloadHandler',
}
|
看到这里你应该能明白了,说白了就是需下载的资源是什么类型,就选用哪一种下载处理器进行网络下载,其中最常用的就是http
和https
对应的处理器。
从这里你也能看出,scrapy的架构是非常低耦合的,任何涉及到的组件及模块都是可重写和配置的。scrapy提供了基础的服务组件,你也可以自己实现其中的某些组件,修改配置即可达到替换的目的。
到这里,大概就能明白,下载处理器的工作就是:管理着各种资源对应的下载器,在真正发起网络请求时,选取对应的下载器进行资源下载。
但是请注意,在这个初始化过程中,这些下载器是没有被实例化的,也就是说,在真正发起网络请求时,才会进行初始化,而且只会初始化一次,后面会讲到。
下载器中间件管理器
下面来看下载器中间件DownloaderMiddlewareManager
初始化,同样的这里又调用了类方法from_crawler
进行初始化,DownloaderMiddlewareManager
继承了MiddlewareManager
类,来看它在初始化做了哪些工作:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
class MiddlewareManager(object):
"""所有中间件的父类,提供中间件公共的方法"""
component_name =
'foo middleware'
@classmethod
def from_crawler(cls, crawler):
return cls.from_settings(crawler.settings, crawler)
@classmethod
def from_settings(cls, settings, crawler=None):
mwlist = cls._get_mwlist_from_settings(settings)
middlewares = []
enabled = []
for clspath
in mwlist:
try:
mwcls = load_object(clspath)
if crawler
and hasattr(mwcls,
'from_crawler'):
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)
@classmethod
def _get_mwlist_from_settings(cls, settings):
raise NotImplementedError
def __init__(self, *middlewares):
self.middlewares = middlewares
self.methods = defaultdict(list)
for mw
in middlewares:
self._add_middleware(mw)
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)
|
DownloaderMiddlewareManager
实例化:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class DownloaderMiddlewareManager(MiddlewareManager):
"""下载中间件管理器"""
component_name =
'downloader middleware'
@classmethod
def _get_mwlist_from_settings(cls, settings):
return build_component_list(
settings.getwithbase(
'DOWNLOADER_MIDDLEWARES'))
def _add_middleware(self, mw):
if hasattr(mw,
'process_request'):
self.methods[
'process_request'].append(mw.process_request)
if hasattr(mw,
'process_response'):
self.methods[
'process_response'].insert(
0, mw.process_response)
if hasattr(mw,
'process_exception'):
self.methods[
'process_exception'].insert(
0, mw.process_exception)
|
下载器中间件管理器继承了MiddlewareManager
类,然后重写了_add_middleware
方法,为下载行为定义默认的下载前、下载后、异常时对应的处理方法。
中间件的职责是什么?从这里能大概看出,从某个组件流向另一个组件时,会经过一系列中间件,每个中间件都定义了自己的处理流程,相当于一个个管道,输入时可以针对数据进行处理,然后送达到另一个组件,另一个组件处理完逻辑后,又经过这一系列中间件,这些中间件可再针对这个响应结果进行处理,最终输出。
Scraper
下载器实例化完了之后,回到引擎的初始化方法中,然后是实例化Scraper
,在Scrapy源码分析(一)架构概览中已经大概说到,这个类没有在架构图中出现,但这个类其实是处于Engine
、Spiders
、Pipeline
之间,是连通这3个组件的桥梁。
来看它的初始化:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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
|
爬虫中间件管理器
SpiderMiddlewareManager
初始化:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class SpiderMiddlewareManager(MiddlewareManager):
"""爬虫中间件管理器"""
component_name =
'spider middleware'
@classmethod
def _get_mwlist_from_settings(cls, settings):
return build_component_list(settings.getwithbase(
'SPIDER_MIDDLEWARES'))
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)
|
爬虫中间件管理器初始化与之前的下载器中间件管理器类似,先是从配置文件中加载了默认的爬虫中间件类,然后依次注册爬虫中间件的一系列流程方法。
配置文件中定义的默认的爬虫中间件类如下:
1
2
3
4
5
6
7
8
|
SPIDER_MIDDLEWARES_BASE = {
'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,
}
|
这些默认的爬虫中间件职责分别如下:
- HttpErrorMiddleware:会针对响应不是200错误进行逻辑处理;
- OffsiteMiddleware:如果Spider中定义了
allowed_domains
,会自动过滤初次之外的域名请求; - RefererMiddleware:追加
Referer
头信息; - UrlLengthMiddleware:控制过滤URL长度超过配置的请求;
- DepthMiddleware:过滤超过配置深入的抓取请求;
当然,你也可以定义自己的爬虫中间件,来处理自己需要的逻辑。
Pipeline管理器
爬虫中间件管理器初始化完之后,然后就是Pipeline
组件的初始化,默认的Pipeline
组件是ItemPipelineManager
:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class ItemPipelineManager(MiddlewareManager):
component_name =
'item pipeline'
@classmethod
def _get_mwlist_from_settings(cls, settings):
return build_component_list(settings.getwithbase(
'ITEM_PIPELINES'))
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)
|
可以看到ItemPipelineManager
也是一个中间件管理器的子类,由于它的行为非常类似于中间件,但由于功能较为独立,所以属于核心组件之一。
从Scraper
的初始化能够看到,它管理着Spiders
和Pipeline
相关的交互逻辑。
总结
到这里,所有组件:引擎、下载器、调度器、爬虫类、输出处理器都依次初始化完成,每个核心组件下其实都包含一些小的组件在里面,帮助处理某一环节的各种流程。