笔记-scrapy-深入学习-sheduler
1. scheduler.py
source code：scrapy/core/scheduler.py:
1.1. 初始化的开始
在分析engine的open_spider函数时，讲过scheduler对象是通过类的from_cralwer方法生成的，代码如下：
@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')
return cls(dupefilter, jobdir=job_dir(settings), logunser=logunser,
stats=crawler.stats, pqclass=pqclass, dqclass=dqclass, mqclass=mqclass)
在最后实际还是调用类的__init__()。
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
在这里指定了各种队列类型，但并没有构造队列，在下面会讲到。
实际上调度器默认只定义了2种队列类型，但并不是在这里构造的：
dqs:基于磁盘的任务队列：在配置文件可配置存储路径，每次执行后会把队列任务保存到磁盘上；
mqs:基于内存的任务队列：每次都在内存中执行，下次启动则消失；
1.2. 核心对象
前面共创建了4个对象，分别是dupefilter,pqclass,dqclass,mqclass.
1.dupefilter:
DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'
这个类的含义是"Request Fingerprint duplicates filter"，请求指纹重复过滤。
它对每个request请求生成指纹，对指纹重复的请求进行过滤。具体实现见文档：scrapy-去重
2.pqclass
SCHEDULER_PRIORITY_QUEUE = 'queuelib.PriorityQueue'
从名字上也可以看出这个一个优先级队列，使用的是queuelib.它的作用应该不说也明白就是对request请求按优先级进行排序。
如何指定优先级？
前面讲spider时，讲述过可以在spider中定义Rule规则来过滤我们需要跟进的链接形式，我们只要定义规则时指定一个process_request关键字参数即可，这个参数是一个函数，会传递给我们将要继续跟进的Request,我们直接对其设置priority属性即可。
优先级是一个整数，虽然queuelib使用小的数做为高优化级，但是由于scheduler再入队列时取了负值，所以实际上数值越大优先级越高，代码如下：
def _dqpush(self, request):
if self.dqs is None:
return
try:
reqd = request_to_dict(request, self.spider)
self.dqs.push(reqd, -request.priority)
3.dqclass
SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue'
从名字上看，这是一个支持序列化的后进先出的磁盘队列。主要用来帮助我们在停止爬虫后可以接着上一次继续开始爬虫。
序列化要指定一个目录，用于存储序列化文件。这个目录在命令行上通过'-s JOBDIR=XXX'来指定。scheduler会在这个目录下创建active.json文件，用来序列化队列的优先级。
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
_dq在engine open_spider时调用scheduler的open时调用，可以看到如果命令指定了JOBDIR参数，则从目录下寻找active.json，这个文件存储的上一次指定的优先级集合，然后用它和_newdq一起构造磁盘队列，这样就可以接着上次停止时的状态继续爬取了。
其中_newdq会使用JOBDIR和优先级作为参数初始化磁盘队列对象。
def _newdq(self, priority):
return self.dqclass(join(self.dqdir, 'p%s' % priority))
最后在scheduler关闭时会将优化级存入文件active.json文件，用于下次反序列化。
def close(self, reason):
if self.dqs:
prios = self.dqs.close()
with open(join(self.dqdir, 'active.json'), 'w') as f:
json.dump(prios, f)
return self.df.close(reason)
4.mqclass
SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'
从名字上看，是后进先出的内存队列。这个队列是为了构造优先级队列而存在的,在构造优先级队列时，需要传递一个队列工厂类，用它来构造每个不同的优先级队列，构造时会向这个队列工厂类传递优先级作为唯一的参数。
默认情况下实际上就是queuelib.LifoMemoryQueue.
1.3. 入列及出列
前面了解了内存队列和磁盘队列，下面看下scheduler怎样出列入列:
请求的获取和存入流程:
def next_request(self):
request = self.mqs.pop()
if request:
self.stats.inc_value('scheduler/dequeued/memory', spider=self.spider)
else:
request = self._dqpop()
if request:
self.stats.inc_value('scheduler/dequeued/disk', spider=self.spider)
if request:
self.stats.inc_value('scheduler/dequeued', spider=self.spider)
return request
取请求时优先使用内存队列，如果内存队列没有请求再使用磁盘队列。
在请求入队列时，优先存入磁盘队列，如果没有磁盘队列再存入内存队列。
def enqueue_request(self, request):
if not request.dont_filter and self.df.request_seen(request):
self.df.log(request, self.spider)
return False
dqok = self._dqpush(request)
if dqok:
self.stats.inc_value('scheduler/enqueued/disk', spider=self.spider)
else:
self._mqpush(request)
self.stats.inc_value('scheduler/enqueued/memory', spider=self.spider)
self.stats.inc_value('scheduler/enqueued', spider=self.spider)
return True
Scheduler在入列前调用过滤器进行过滤，如果request对象没有定义dont_filter选项，则用df来过滤，关于去重方法，见文档：scrapy-去重。.
调度器的核心基本就这些了。
另外还有一个LOG_UNSERIALIZABLE_REQUESTS参数，它是用来指定如果一个请求序列化失败，是否要记录日志。
1.4. 队列实现
前面定义了队列，但并没有实例化，
def open(self, spider):
self.spider = spider
self.mqs = self.pqclass(self._newmq)
self.dqs = self._dq() if self.dqdir else None
return self.df.open()
使用self.pqclass(self._newmq)，默认情况下等效于PriorityQueue(scrapy.squeues.LifoMemoryQueue)
class PriorityQueue(object):
"""A priority queue implemented using multiple internal queues (typically,
FIFO queues). The internal queue must implement the following methods:
"""
def __init__(self, qfactory, startprios=()):
self.queues = {}
self.qfactory = qfactory
for p in startprios:
self.queues[p] = self.qfactory(p)
self.curprio = min(startprios) if startprios else None
def push(self, obj, priority=0):
if priority not in self.queues:
self.queues[priority] = self.qfactory(priority)
q = self.queues[priority]
q.push(obj) # this may fail (eg. serialization error)
if self.curprio is None or priority < self.curprio:
self.curprio = priority
def pop(self):
if self.curprio is None:
return
q = self.queues[self.curprio]
m = q.pop()
if len(q) == 0:
del self.queues[self.curprio]
q.close()
prios = [p for p, q in self.queues.items() if len(q) > 0]
self.curprio = min(prios) if prios else None
return m
这里是优先级队列的初始化代码，queues是一个dict，dict元素是priority:qfactory形式。
结合起来的结果就是scrapy待爬队列初始化都是优先级队列，如果以后所有request的优先级相同（默认0），那么待爬队列就时一个FIFO/LIFO。如果使用不同的优先级，那么就是一个优先级队列了。
qfactory指定二级队列类型，它来自SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'，
修改它有两种结果：
- 所有请求优先级为0或相同，那么待爬队列就是一个LIFO或FIFO；
- 请求的优先级不同，那么待爬队列就是一个优先级队列，优等级队列的元素值也是队列（LIFO或FIFO）。
1.5. 爬取方式
从上一章节可以看出scrapy默认使用LIFO，那么它的爬取方式是深度优先，如果想使用广度优先，把SCHEDULER_MEMORY_QUEUE 改为FIFO就可以了。