Scrapy-redis之终结篇
scrapy-redis
为什么要用scrapy-redis？
Scrapy_redis在scrapy的基础上实现了更多，更强大的功能，具体体现在：reqeust去重，爬虫持久化，和轻松实现分布式,实现一个任务多台服务器执行，大大的提高了效率
安装
pip3 install scrapy-redis
scrapy-redis 执行流程
源码
scrapy-redis .connrction
connect 文件引入了redis 模块，这个是 redis-python库的接口，用于通过python访问redis数据库，可见，这个文件主要是实现连接redis数据库的功能（返回的是redis库的Redis对象或者StrictRedis对象，这俩都是可以直接用来进行数据操作的对象）。这些连接接口在其他文件中经常被用到。其中，我们可以看到，要想连接到redis数据库，和其他数据库差不多，需要一个ip地址、端口号、用户名密码（可选）和一个整形的数据库编号，同时我们还可以在scrapy工程的setting文件中配置套接字的超时时间、等待时间等。
其实这个模块的功能：
1. 从 settings 里面获取 redis 的链接配置
2. 获取 redis 的 链接 实例
import six
from scrapy.utils.misc import load_object
from . import defaults
#Shortcut maps 'setting name' -> 'parmater name'.
#redis://127.0.0.1:6379/0
SETTINGS_PARAMS_MAP = {
'REDIS_URL': 'url', #以url的方式链接数据库
'REDIS_HOST': 'host', #指定redis数据库的host
'REDIS_PORT': 'port', #指定redis数据库的port
'REDIS_ENCODING': 'encoding', #指定redis数据库的编码
}
def get_redis_from_settings(settings):
"""Returns a redis client instance from given Scrapy settings object.
This function uses ``get_client`` to instantiate the client and uses
``defaults.REDIS_PARAMS`` global as defaults values for the parameters. You
can override them using the ``REDIS_PARAMS`` setting.
Parameters
----------
settings : Settings ：scrapy设置文件
A scrapy settings object. See the supported settings below.
Returns
-------
server：redis客户端链接对象
Redis client instance.
Other Parameters
----------------
REDIS_URL : str, optional
Server connection URL.
REDIS_HOST : str, optional
Server host.
REDIS_PORT : str, optional
Server port.
REDIS_ENCODING : str, optional
Data encoding.
REDIS_PARAMS : dict, optional
Additional client parameters.
"""
params = defaults.REDIS_PARAMS.copy()
#从scrapy的设置文件中获取REDIS_PARAMS,覆盖defaults.REDIS_PARAMS的默认值
params.update(settings.getdict('REDIS_PARAMS'))
# XXX: Deprecate REDIS_* settings.
#
# SETTINGS_PARAMS_MAP = {
# 'REDIS_URL': 'url', # 以url的方式链接数据库
# 'REDIS_HOST': 'host', # 指定redis数据库的host
# 'REDIS_PORT': 'port', # 指定redis数据库的port
# 'REDIS_ENCODING': 'encoding', # 指定redis数据库的编码
# }
for source, dest in SETTINGS_PARAMS_MAP.items():
val = settings.get(source)
if val:
params[dest] = val
# Allow ``redis_cls`` to be a path to a class.
if isinstance(params.get('redis_cls'), six.string_types):
params['redis_cls'] = load_object(params['redis_cls'])
##调用get_redis方法返回redis数据库链接
return get_redis(**params)
#Backwards compatible alias.
from_settings = get_redis_from_settings
def get_redis(**kwargs):
# 方法返回redis数据库链接对象
"""Returns a redis client instance.
Parameters
----------
redis_cls : class, optional
Defaults to ``redis.StrictRedis``.
url : str, optional
If given, ``redis_cls.from_url`` is used to instantiate the class.
**kwargs
Extra parameters to be passed to the ``redis_cls`` class.
Returns
-------
server
Redis client instance.
"""
#redis_cls -> redis.StrictRedis
redis_cls = kwargs.pop('redis_cls', defaults.REDIS_CLS)
url = kwargs.pop('url', None)
if url:
#根据url方式创建redis数据库链接，并返回
return redis_cls.from_url(url, **kwargs)
else:
#根据host、port创建redis数据库链接，并返回
return redis_cls(**kwargs)
scrapy-redis .defaults
redis 的一些基础的默认的设置。其实就是一些默认配置：
import redis
# redis.StrictRedis()
# For standalone use.
DUPEFILTER_KEY = 'dupefilter:%(timestamp)s'
#redis数据库中保留item的key
PIPELINE_KEY = '%(spider)s:items'
#REDIS_CLS:redis客户端链接
REDIS_CLS = redis.StrictRedis
REDIS_ENCODING = 'utf-8'
# Sane connection defaults.
#链接redis数据库时设置的默认参数
REDIS_PARAMS = {
'socket_timeout': 30,
'socket_connect_timeout': 30,
'retry_on_timeout': True,
'encoding': REDIS_ENCODING,
}
#redis数据库中保存待爬取任务（request）的key
SCHEDULER_QUEUE_KEY = '%(spider)s:requests'
#默认指定了有优先级的任务队列存储方式（PriorityQueue）
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'
#redis数据库中保留去重指纹的key
SCHEDULER_DUPEFILTER_KEY = '%(spider)s:dupefilter'
#默认设置了scrapy_redis的去重组件
SCHEDULER_DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'
#默认起始任务的key
START_URLS_KEY = '%(name)s:start_urls'
START_URLS_AS_SET = False
scrapy-redis .dupefilter
这个主要是用来去重的。RFPDupeFilter继承自 Scrapy 的BaseDupeFilter，实现了 request 去重功能，基于 Scrapy 的 request_fingerprint 生成指纹，并在 Redis 上存储。当收到新的 request，首先生成指纹判断是否存在于已爬取的指纹库内（Redis set），若存在则返回 False，不存在返回 True.总得来说是这样的，这个文件首先获取到redis的server,然后从scrapy的request中获取request的指纹，将这个指纹进行存到redis的去重库中。达到去重的目的。
这个文件看起来比较复杂，重写了scrapy本身已经实现的 request 判重功能。因为本身 scrapy 单机跑的话，只需要读取内存中的request 队列 或者 持久化的 request 队列（scrapy默认的持久化似乎是json格式的文件，不是数据库）就能判断这次要发出的request url是否已经请求过或者正在调度（本地读就行了）。而 分布式跑的话，就需要各个主机上的scheduler都连接同一个数据库的同一个 request池 来判断这次的请求是否是重复的了。
在这个文件中，通过继承 BaseDupeFilter 重写他的方法，实现了基于redis的判重。根据源代码来看，scrapy-redis 使用了scrapy本身的一个 fingerprint 接口 request_fingerprint，这个接口很有趣，根据scrapy文档所说，他通过hash来判断两个url是否相同（相同的url会生成相同的hash结果），但是当两个url的地址相同，get型参数相同但是顺序不同时，也会生成相同的hash结果（这个真的比较神奇。。。）所以 scrapy-redis 依旧使用 url 的 fingerprint 来判断 request 请求是否已经出现过。这个类通过连接 redis，使用一个key来向redis的一个set中插入fingerprint（这个key对于同一种spider是相同的，redis 是一个key-value的数据库，如果key是相同的，访问到的值就是相同的，这里使用 spider名字+DupeFilter 的 key 就是为了在不同主机上的不同爬虫实例，只要属于同一种 spider，就会访问到同一个set，而这个 set 就是他们的url判重池 ），如果返回值为0，说明该set中该fingerprint 已经存在（因为集合是没有重复值的），则返回 False，如果返回值为 1，说明添加了一个fingerprint到set中，则说明这个 request 没有重复，于是返回True，还顺便把新fingerprint加入到数据库中了。
DupeFilter 判重会在 scheduler 类中用到，每一个 request 在进入调度之前都要进行判重，如果重复就不需要参加调度，直接舍弃就好了，不然就是白白浪费资源。
import logging
import time
from scrapy.dupefilters import BaseDupeFilter
from scrapy.utils.request import request_fingerprint
from . import defaults
from .connection import get_redis_from_settings
logger = logging.getLogger(__name__)
#TODO: Rename class to RedisDupeFilter.
class RFPDupeFilter(BaseDupeFilter):
"""Redis-based request duplicates filter.
This class can also be used with default Scrapy's scheduler.
"""
logger = logger
def __init__(self, server, key, debug=False):
"""Initialize the duplicates filter.
Parameters
----------
server : redis.StrictRedis
#redis客户端链接
The redis server instance.
key : str
#redis数据库中保留去重指纹的key
Redis key Where to store fingerprints.
debug : bool, optional
Whether to log filtered requests.
"""
self.server = server
self.key = key
self.debug = debug
self.logdupes = True
@classmethod
def from_settings(cls, settings):
"""Returns an instance from given settings.
This uses by default the key ``dupefilter:``. When using the
``scrapy_redis.scheduler.Scheduler`` class, this method is not used as
it needs to pass the spider name in the key.
Parameters
----------
settings : scrapy.settings.Settings
Returns
-------
RFPDupeFilter
A RFPDupeFilter instance.
"""
#
server = get_redis_from_settings(settings)
# XXX: This creates one-time key. needed to support to use this
# class as standalone dupefilter with scrapy's default scheduler
# if scrapy passes spider on open() method this wouldn't be needed
# TODO: Use SCRAPY_JOB env as default and fallback to timestamp.
key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}
debug = settings.getbool('DUPEFILTER_DEBUG')
return cls(server, key=key, debug=debug)
@classmethod
def from_crawler(cls, crawler):
"""Returns instance from crawler.
Parameters
----------
crawler : scrapy.crawler.Crawler
Returns
-------
RFPDupeFilter
Instance of RFPDupeFilter.
"""
return cls.from_settings(crawler.settings)
def request_seen(self, request):
"""Returns True if request was already seen.
Parameters
----------
request : scrapy.http.Request #请求对象
Returns
-------
bool ：True：表示已添加到任务队列, False:表示未添加到任务队列
"""
#根据request对象生成指纹
fp = self.request_fingerprint(request)
# This returns the number of values added, zero if already exists.
# 返回0：已存在集合中 返回1：指纹不存在集合中
added = self.server.sadd(self.key, fp)
return added == 0
def request_fingerprint(self, request):
"""Returns a fingerprint for a given request.
Parameters
----------
request : scrapy.http.Request
Returns
-------
str
"""
return request_fingerprint(request)
def close(self, reason=''):
"""Delete data on close. Called by Scrapy's scheduler.
Parameters
----------
reason : str, optional
"""
self.clear()
def clear(self):
"""Clears fingerprints data."""
self.server.delete(self.key)
def log(self, request, spider):
"""Logs given request.
Parameters
----------
request : scrapy.http.Request
spider : scrapy.spiders.Spider
"""
if self.debug:
msg = "Filtered duplicate request: %(request)s"
self.logger.debug(msg, {'request': request}, extra={'spider': spider})
elif self.logdupes:
msg = ("Filtered duplicate request %(request)s"
" - no more duplicates will be shown"
" (see DUPEFILTER_DEBUG to show all duplicates)")
self.logger.debug(msg, {'request': request}, extra={'spider': spider})
self.logdupes = False
scrapy-redis .picklecompat
这里实现了 loads 和 dumps 两个函数，其实就是实现了一个 serializer，因为 redis 数据库不能存储复杂对象（value部分只能是字符串，字符串列表，字符串集合和hash，key部分只能是字符串），所以我们存啥都要先串行化成文本才行。这里使用的就是python 的 pickle 模块，一个兼容 py2 和 py3 的串行化工具。这个 serializer 主要用于一会的 scheduler 存 reuqest 对象，至于为什么不实用 json 格式，我也不是很懂，item pipeline 的串行化默认用的就是 json。
"""A pickle wrapper module with protocol=-1 by default."""
try:
import cPickle as pickle # PY2
except ImportError:
import pickle
def loads(s):
return pickle.loads(s)
def dumps(obj):
return pickle.dumps(obj, protocol=-1)
scrapy-redis.pipelines
这是是用来实现分布式处理的作用。它将 Item 存储在 redis 中以实现分布式处理。由于在这里需要读取配置，所以就用到了from_crawler() 函数。pipeline 文件 实现了一个 item pipieline类，和 scrapy 的 item pipeline 是同一个对象，通过从 settings 中拿到我们配置的REDIS_ITEMS_KEY 作为 key，把 item 串行化之后存入 redis 数据库对应的 value 中（这个value可以看出出是个list，我们的每个item是这个list中的一个结点），这个pipeline把提取出的item存起来，主要是为了方便我们延后处理数据。
from scrapy.utils.misc import load_object
from scrapy.utils.serialize import ScrapyJSONEncoder
from twisted.internet.threads import deferToThread
from . import connection, defaults
default_serialize = ScrapyJSONEncoder().encode
class RedisPipeline(object):
#通过这个管道文件，将所有经过管道的item数据存储到redis数据库中
"""Pushes serialized item into a redis list/queue
Settings
--------
REDIS_ITEMS_KEY : str
Redis key where to store items.
REDIS_ITEMS_SERIALIZER : str
Object path to serializer function.
"""
def __init__(self, server,
key=defaults.PIPELINE_KEY,
serialize_func=default_serialize):
"""Initialize pipeline.
Parameters
----------
server : StrictRedis
Redis client instance.
key : str
Redis key where to store items.
serialize_func : callable
Items serializer function.
"""
# redis 数据库链接
self.server = server
# redis数据库保存item的key
self.key = key
# 获取序列化的参数
self.serialize = serialize_func
@classmethod
def from_settings(cls, settings):
params = {
'server': connection.from_settings(settings),
}
if settings.get('REDIS_ITEMS_KEY'):
params['key'] = settings['REDIS_ITEMS_KEY']
if settings.get('REDIS_ITEMS_SERIALIZER'):
params['serialize_func'] = load_object(
settings['REDIS_ITEMS_SERIALIZER']
)
return cls(**params)
@classmethod
def from_crawler(cls, crawler):
return cls.from_settings(crawler.settings)
def process_item(self, item, spider):
#使用线程执行数据插入任务
return deferToThread(self._process_item, item, spider)
def _process_item(self, item, spider):
# redis数据库保存item的key
key = self.item_key(item, spider)
# 序列化item数据
data = self.serialize(item)
# 将数据存入redis数据库
self.server.rpush(key, data)
return item
def item_key(self, item, spider):
"""Returns redis key based on given spider.
Override this function to use a different key depending on the item
and/or spider.
"""
return self.key % {'spider': spider.name}
scrapy-redis.queue
该文件实现了几个容器类，可以看这些容器和redis交互频繁，同时使用了我们上边 picklecompat 中定义的 serializer。这个文件实现的几个容器大体相同，只不过一个是队列，一个是栈，一个是优先级队列，这三个容器到时候会被scheduler对象实例化，来实现 request的调度。比如：我们使用 SpiderQueue 作为调度队列的类型，到时候 request 的调度方法就是先进先出，而实用SpiderStack 就是先进后出了。
我们可以仔细看看 SpiderQueue 的实现，他的 push 函数就和其他容器的一样，只不过 push进去的 request请求先被scrapy的接口 request_to_dict 变成了一个dict对象（因为request对象实在是比较复杂，有方法有属性不好串行化），之后使用picklecompat中的serializer串行化为字符串，然后使用一个特定的 key 存入redis中（该key在同一种spider中是相同的）。而调用pop时，其实就是从redis用那个特定的key去读其值（一个list），从list中读取最早进去的那个，于是就先进先出了。
这些容器类都会作为 scheduler 调度 request 的容器，scheduler 在每个主机上都会实例化一个，并且和 spider一一对应，所以分布式运行时会有一个 spide r的多个实例和一个 scheduler 的多个实例存在于不同的主机上，但是，因为 scheduler 都是用相同的容器，而这些容器都连接同一个 redis 服务器，又都使用 spider 名加 queue 来作为 key 读写数据，所以不同主机上的不同爬虫实例公用一个 request 调度池，实现了分布式爬虫之间的统一调度。
from scrapy.utils.reqser import request_to_dict, request_from_dict
from . import picklecompat
class Base(object):
"""Per-spider base queue class"""
def __init__(self, server, spider, key, serializer=None):
"""Initialize per-spider redis queue.
Parameters
----------
server : StrictRedis
Redis client instance.
spider : Spider
Scrapy spider instance.
key: str
Redis key where to put and get messages.
serializer : object
Serializer object with ``loads`` and ``dumps`` methods.
"""
if serializer is None:
# Backward compatibility.
# TODO: deprecate pickle.
serializer = picklecompat
if not hasattr(serializer, 'loads'):
raise TypeError("serializer does not implement 'loads' function: %r"
% serializer)
if not hasattr(serializer, 'dumps'):
raise TypeError("serializer '%s' does not implement 'dumps' function: %r"
% serializer)
self.server = server
self.spider = spider
#school:requests
self.key = key % {'spider': spider.name}
self.serializer = serializer
def _encode_request(self, request):
"""Encode a request object"""
obj = request_to_dict(request, self.spider)
return self.serializer.dumps(obj)
def _decode_request(self, encoded_request):
"""Decode an request previously encoded"""
obj = self.serializer.loads(encoded_request)
return request_from_dict(obj, self.spider)
def __len__(self):
"""Return the length of the queue"""
raise NotImplementedError
def push(self, request):
#存值
"""Push a request"""
raise NotImplementedError
def pop(self, timeout=0):
#取值
"""Pop a request"""
raise NotImplementedError
def clear(self):
#清空队列
"""Clear queue/stack"""
self.server.delete(self.key)
class FifoQueue(Base):
#SpiderQueue
"""Per-spider FIFO queue"""
def __len__(self):
"""Return the length of the queue"""
#获取待请求的任务数
return self.server.llen(self.key)
#从左往右 #从右往左取
#[3,2,1,0]
def push(self, request):
"""Push a request"""
#存的方式
self.server.lpush(self.key, self._encode_request(request))
def pop(self, timeout=0):
"""Pop a request"""
if timeout > 0:
#从右往左取值(timeout：阻塞时间)
data = self.server.brpop(self.key, timeout)
if isinstance(data, tuple):
data = data[1]
else:
data = self.server.rpop(self.key)
if data:
#将数据取出，转换为request对象
return self._decode_request(data)
class PriorityQueue(Base):
#有序集合（zset）
"""Per-spider priority queue abstraction using redis' sorted set"""
def __len__(self):
"""Return the length of the queue"""
return self.server.zcard(self.key)
def push(self, request):
"""Push a request"""
data = self._encode_request(request)
#设置权重（分数）
score = -request.priority
# We don't use zadd method as the order of arguments change depending on
# whether the class is Redis or StrictRedis, and the option of using
# kwargs only accepts strings, not bytes.
#往集合中添加请求任务
self.server.execute_command('ZADD', self.key, score, data)
def pop(self, timeout=0):
"""
Pop a request
timeout not support in this queue class
"""
# use atomic range/remove using multi/exec
pipe = self.server.pipeline()
pipe.multi()
pipe.zrange(self.key, 0, 0).zremrangebyrank(self.key, 0, 0)
results, count = pipe.execute()
if results:
# 将数据取出，转换为request对象
return self._decode_request(results[0])
class LifoQueue(Base):
## list 数据类型
"""Per-spider LIFO queue."""
#->村值 从左往右存 ## 取值 从左往右取
[3,2,1,0]
def __len__(self):
"""Return the length of the stack"""
return self.server.llen(self.key)
def push(self, request):
"""Push a request"""
# 村值 从左往右存
self.server.lpush(self.key, self._encode_request(request))
def pop(self, timeout=0):
"""Pop a request"""
if timeout > 0:
data = self.server.blpop(self.key, timeout)
if isinstance(data, tuple):
data = data[1]
else:
# 取值 从左往右取
data = self.server.lpop(self.key)
if data:
return self._decode_request(data)
# TODO: Deprecate the use of these names.
SpiderQueue = FifoQueue
SpiderStack = LifoQueue
SpiderPriorityQueue = PriorityQueue
scrapy-redis.scheduler
根据官方文档说明 在我们没有没有指定 SCHEDULER 参数时，默认使用：’scrapy.core.scheduler.Scheduler’ 作为SCHEDULER(调度器)
scrapy 改造了 python 本来的 collection.deque(双向队列)形成了自己的 Scrapy queue，但是 Scrapy 多个 spider 不能共享待爬取队列 Scrapy queue，即 Scrapy 本身不支持爬虫分布式。
scrapy-redis 的解决是把这个 Scrapy queue 换成redis数据库（也是指redis队列），从同一个 redis-server 存放要爬取的request，便能让多个 spider 去同一个数据库里读取。
Scrapy 中跟 “待爬队列” 直接相关的就是调度器 Scheduler，它负责对新的request 进行入列操作（加入Scrapy queue），取出下一个要爬取的 request（从Scrapy queue中取出）等操作。它把待爬队列按照优先级建立了一个字典结构，然后根据 request中 的优先级，来决定该入哪个队列，出列时则按优先级较小的优先出列。为了管理这个比较高级的队列字典，Scheduler 需要提供一系列的方法。但是原来的 Scheduler已经无法使用，所以使用 Scrapy-redis 的 scheduler组件。
scheduler.py 这个文件重写了 scheduler 类，用来代替 scrapy.core.scheduler 的原有调度器。其实对原有调度器的逻辑没有很大的改变，主要是使用了redis 作为数据存储的媒介，以达到各个爬虫之间的统一调度。 scheduler 负责调度各个 spider 的 request 请求，scheduler 初始化时，通过 settings 文件读取 queue 和 dupefilters 的类型（一般就用上边默认的），配置 queue 和 dupefilters 使用的 key（一般就是spider name加上queue或者dupefilters，这样对于同一种spider 的不同实例，就会使用相同的数据块了）。每当一个 request 要被调度时，enqueue_request 被调用，scheduler 使用dupefilters 来判断这个url是否重复，如果不重复，就添加到 queue 的容器中（先进先出，先进后出和优先级都可以，可以在settings中配置）。当调度完成时，next_request 被调用，scheduler 就通过 queue 容器的接口，取出一个 request，把他发送给相应的 spider，让spider 进行爬取工作。
import importlib
import six
from scrapy.utils.misc import load_object
from . import connection, defaults
# TODO: add SCRAPY_JOB support.
class Scheduler(object):
"""Redis-based scheduler
Settings
--------
SCHEDULER_PERSIST : bool (default: False)
Whether to persist or clear redis queue.
SCHEDULER_FLUSH_ON_START : bool (default: False)
Whether to flush redis queue on start.
SCHEDULER_IDLE_BEFORE_CLOSE : int (default: 0)
How many seconds to wait before closing if no message is received.
SCHEDULER_QUEUE_KEY : str
Scheduler redis key.
SCHEDULER_QUEUE_CLASS : str
Scheduler queue class.
SCHEDULER_DUPEFILTER_KEY : str
Scheduler dupefilter redis key.
SCHEDULER_DUPEFILTER_CLASS : str
Scheduler dupefilter class.
SCHEDULER_SERIALIZER : str
Scheduler serializer.
"""
def __init__(self, server,
persist=False,
flush_on_start=False,
queue_key=defaults.SCHEDULER_QUEUE_KEY,
queue_cls=defaults.SCHEDULER_QUEUE_CLASS,
dupefilter_key=defaults.SCHEDULER_DUPEFILTER_KEY,
dupefilter_cls=defaults.SCHEDULER_DUPEFILTER_CLASS,
idle_before_close=0,
serializer=None):
"""Initialize scheduler.
Parameters
----------
server : Redis
The redis server instance.
persist : bool
Whether to flush requests when closing. Default is False.
flush_on_start : bool
Whether to flush requests on start. Default is False.
queue_key : str
Requests queue key.
queue_cls : str
Importable path to the queue class.
dupefilter_key : str
Duplicates filter key.
dupefilter_cls : str
Importable path to the dupefilter class.
idle_before_close : int
Timeout before giving up.
"""
if idle_before_close < 0:
raise TypeError("idle_before_close cannot be negative")
self.server = server
self.persist = persist
self.flush_on_start = flush_on_start
self.queue_key = queue_key
self.queue_cls = queue_cls
self.dupefilter_cls = dupefilter_cls
self.dupefilter_key = dupefilter_key
self.idle_before_close = idle_before_close
self.serializer = serializer
self.stats = None
def __len__(self):
return len(self.queue)
@classmethod
def from_settings(cls, settings):
kwargs = {
'persist': settings.getbool('SCHEDULER_PERSIST'),
#flush_on_start：是否要重新执行
'flush_on_start': settings.getbool('SCHEDULER_FLUSH_ON_START'),
'idle_before_close': settings.getint('SCHEDULER_IDLE_BEFORE_CLOSE'),
}
# If these values are missing, it means we want to use the defaults.
optional = {
# TODO: Use custom prefixes for this settings to note that are
# specific to scrapy-redis.
'queue_key': 'SCHEDULER_QUEUE_KEY',
'queue_cls': 'SCHEDULER_QUEUE_CLASS',
'dupefilter_key': 'SCHEDULER_DUPEFILTER_KEY',
# We use the default setting name to keep compatibility.
'dupefilter_cls': 'DUPEFILTER_CLASS',
'serializer': 'SCHEDULER_SERIALIZER',
}
for name, setting_name in optional.items():
val = settings.get(setting_name)
if val:
kwargs[name] = val
# Support serializer as a path to a module.
if isinstance(kwargs.get('serializer'), six.string_types):
kwargs['serializer'] = importlib.import_module(kwargs['serializer'])
server = connection.from_settings(settings)
# Ensure the connection is working.
server.ping()
return cls(server=server, **kwargs)
@classmethod
def from_crawler(cls, crawler):
instance = cls.from_settings(crawler.settings)
# FIXME: for now, stats are only supported from this constructor
instance.stats = crawler.stats
return instance
def open(self, spider):
self.spider = spider
try:
#获取请求任务队列（类的对象）
self.queue = load_object(self.queue_cls)(
server=self.server,
spider=spider,
key=self.queue_key % {'spider': spider.name},
serializer=self.serializer,
)
except TypeError as e:
raise ValueError("Failed to instantiate queue class '%s': %s",
self.queue_cls, e)
try:
# 获取指纹集合 （类的对象）
self.df = load_object(self.dupefilter_cls)(
server=self.server,
key=self.dupefilter_key % {'spider': spider.name},
debug=spider.settings.getbool('DUPEFILTER_DEBUG'),
)
except TypeError as e:
raise ValueError("Failed to instantiate dupefilter class '%s': %s",
self.dupefilter_cls, e)
if self.flush_on_start:
self.flush()
# notice if there are requests already in the queue to resume the crawl
if len(self.queue):
spider.log("Resuming crawl (%d requests scheduled)" % len(self.queue))
def close(self, reason):
if not self.persist:
self.flush()
def flush(self):
# 清空指纹
self.df.clear()
# 清空任务队列
self.queue.clear()
def enqueue_request(self, request):
# return True 表示该request对象之前木有加入到任务队列，现在加入到任务队列
# return False 表示该request对象之前已经添加到任务队列
#dont_filter: False:过滤请求， True:
if not request.dont_filter and self.df.request_seen(request):
self.df.log(request, self.spider)
return False
if self.stats:
self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)
#往reids数据库中存贮request让请求任务
self.queue.push(request)
return True
def next_request(self):
#获取request对象，并返回
block_pop_timeout = self.idle_before_close
request = self.queue.pop(block_pop_timeout)
if request and self.stats:
self.stats.inc_value('scheduler/dequeued/redis', spider=self.spider)
return request
def has_pending_requests(self):
return len(self) > 0
这个文件下只有一个类 Scheduler，一如既往的通过类方法来实例化来实现 外部可以直接通过调用两个方法然后从爬虫中获取settings 和 crawler，但是有两个比较特殊的函数是 def open(self, spider) 和 def next_request(self)：
open(): 调度器启动时的自动的操作，这里主要实例化了任务队列 queue 和过滤器 dupefilter。
next_request(): 从任务队列取出 request。
scrapy-redis.spider
如果在 settings.py 里面：REDIS_START_URLS_AS_SET=False 的话，就是列表的形式，存入就是lpush或者是rpush等操作
如果是true的话，那么存入就是集合的形式，sadd等操作。REDIS_START_URLS_AS_SET=False # 默认是false，列表的格式取数据出来。# REDIS_START_URLS_KEY = ‘%(name)s:start_urls’ #不设置默认是这个，这个是存入redis里面的key，可以根据这来取 value，
-
例如:baidu:start_urls
-
redis 存入 开始 url:
-
列表：
import redis conn=redis.Redis(host='127.0.0.1',port=6379) conn.lpush('baidu:start_urls','http://www.baidu.com') -
集合：
import redis conn=redis.Redis(host='127.0.0.1',port=6379) conn.sadd('baidu:start_urls','http://www.baidu.com')##按照这个格式来存数据的print(conn.smembers(‘baidu:start_urls’))
spider 的改动也不是很大，主要是通过 connect 接口，给 spider绑定了 spider_idle 信号，spider 初始化时，通过 setup_redis 函数初始化好 redis 的连接，之后通过 next_requests 函数从 redis 中取出 strat url，使用的 key 是 settings 中REDIS_START_URLS_AS_SET 定义的（注意了这里的初始化 url 池 和 我们上边的 queue 的 url池 不是一个东西，queue的池是用于调度的，初始化url池是存放入口 url 的，他们都存在redis中，但是使用不同的key来区分，就当成是不同的表吧），spider使用少量的 start url，可以发展出很多新的 url，这些 url 会进入 scheduler 进行判重和调度。直到 spider 跑到调度池内没有 url 的时候，会触发 spider_idle 信号，从而触发 spider 的 next_requests 函数，再次从 redis 的 start url 池中读取一些url。
分析：在这个spider中通过connect signals.spider_idle信号实现对crawler状态的监视。当idle时，返回新的make_requests_from_url(url) 给引擎，进而交给调度器调度。
from scrapy import signals
from scrapy.exceptions import DontCloseSpider
from scrapy.spiders import Spider, CrawlSpider
from . import connection, defaults
from .utils import bytes_to_str
class RedisMixin(object):
"""Mixin class to implement reading urls from a redis queue."""
redis_key = None
redis_batch_size = None
redis_encoding = None
# Redis client placeholder.
server = None
def start_requests(self):
"""Returns a batch of start requests from redis."""
return self.next_requests()
def setup_redis(self, crawler=None):
"""Setup redis connection and idle signal.
This should be called after the spider has set its crawler object.
"""
if self.server is not None:
return
if crawler is None:
# We allow optional crawler argument to keep backwards
# compatibility.
# XXX: Raise a deprecation warning.
crawler = getattr(self, 'crawler', None)
if crawler is None:
raise ValueError("crawler is required")
settings = crawler.settings
if self.redis_key is None:
self.redis_key = settings.get(
'REDIS_START_URLS_KEY', defaults.START_URLS_KEY,
)
self.redis_key = self.redis_key % {'name': self.name}
if not self.redis_key.strip():
raise ValueError("redis_key must not be empty")
if self.redis_batch_size is None:
# TODO: Deprecate this setting (REDIS_START_URLS_BATCH_SIZE).
self.redis_batch_size = settings.getint(
'REDIS_START_URLS_BATCH_SIZE',
settings.getint('CONCURRENT_REQUESTS'),
)
try:
self.redis_batch_size = int(self.redis_batch_size)
except (TypeError, ValueError):
raise ValueError("redis_batch_size must be an integer")
if self.redis_encoding is None:
self.redis_encoding = settings.get('REDIS_ENCODING', defaults.REDIS_ENCODING)
self.logger.info("Reading start URLs from redis key '%(redis_key)s' "
"(batch size: %(redis_batch_size)s, encoding: %(redis_encoding)s",
self.__dict__)
self.server = connection.from_settings(crawler.settings)
# The idle signal is called when the spider has no requests left,
# that's when we will schedule new requests from redis queue
crawler.signals.connect(self.spider_idle, signal=signals.spider_idle)
def next_requests(self):
"""Returns a request to be scheduled or none."""
use_set = self.settings.getbool('REDIS_START_URLS_AS_SET', defaults.START_URLS_AS_SET)
#获取请求任务
fetch_one = self.server.spop if use_set else self.server.lpop
# XXX: Do we need to use a timeout here?
found = 0
# TODO: Use redis pipeline execution.
# redis数据库中请求的任务数redis_batch_size
while found < self.redis_batch_size:
#通过while循环取请求任务
data = fetch_one(self.redis_key)
if not data:
# Queue empty.
break
#根据redis数据库中取出的请求数据，构建request对象
req = self.make_request_from_data(data)
if req:
yield req
found += 1
else:
self.logger.debug("Request not made from data: %r", data)
if found:
self.logger.debug("Read %s requests from '%s'", found, self.redis_key)
def make_request_from_data(self, data):
"""Returns a Request instance from data coming from Redis.
By default, ``data`` is an encoded URL. You can override this method to
provide your own message decoding.
Parameters
----------
data : bytes
Message from redis.
"""
url = bytes_to_str(data, self.redis_encoding)
#通过调用make_requests_from_url方法，根据url地址，返回请求对像
return self.make_requests_from_url(url)
def schedule_next_requests(self):
"""Schedules a request if available"""
# TODO: While there is capacity, schedule a batch of redis requests.
for req in self.next_requests():
#这里将request请求对象交给engine引擎，去执行下载任务
self.crawler.engine.crawl(req, spider=self)
def spider_idle(self):
"""Schedules a request if available, otherwise waits."""
# XXX: Handle a sentinel to close the spider.
self.schedule_next_requests()
raise DontCloseSpider
class RedisSpider(RedisMixin, Spider):
"""Spider that reads urls from redis queue when idle.
Attributes
----------
redis_key : str (default: REDIS_START_URLS_KEY)
Redis key where to fetch start URLs from..
redis_batch_size : int (default: CONCURRENT_REQUESTS)
Number of messages to fetch from redis on each attempt.
redis_encoding : str (default: REDIS_ENCODING)
Encoding to use when decoding messages from redis queue.
Settings
--------
REDIS_START_URLS_KEY : str (default: ":start_urls")
Default Redis key where to fetch start URLs from..
REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)
Default number of messages to fetch from redis on each attempt.
REDIS_START_URLS_AS_SET : bool (default: False)
Use SET operations to retrieve messages from the redis queue. If False,
the messages are retrieve using the LPOP command.
REDIS_ENCODING : str (default: "utf-8")
Default encoding to use when decoding messages from redis queue.
"""
@classmethod
def from_crawler(self, crawler, *args, **kwargs):
obj = super(RedisSpider, self).from_crawler(crawler, *args, **kwargs)
obj.setup_redis(crawler)
return obj
class RedisCrawlSpider(RedisMixin, CrawlSpider):
"""Spider that reads urls from redis queue when idle.
Attributes
----------
redis_key : str (default: REDIS_START_URLS_KEY)
Redis key where to fetch start URLs from..
redis_batch_size : int (default: CONCURRENT_REQUESTS)
Number of messages to fetch from redis on each attempt.
redis_encoding : str (default: REDIS_ENCODING)
Encoding to use when decoding messages from redis queue.
Settings
--------
REDIS_START_URLS_KEY : str (default: ":start_urls")
Default Redis key where to fetch start URLs from..
REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)
Default number of messages to fetch from redis on each attempt.
REDIS_START_URLS_AS_SET : bool (default: True)
Use SET operations to retrieve messages from the redis queue.
REDIS_ENCODING : str (default: "utf-8")
Default encoding to use when decoding messages from redis queue.
"""
@classmethod
def from_crawler(self, crawler, *args, **kwargs):
obj = super(RedisCrawlSpider, self).from_crawler(crawler, *args, **kwargs)
obj.setup_redis(crawler)
return obj
这个 spider 文件有三个类，RedisMixin 是一个基类，剩余两个是多继承。
RedisMixin 类：
- 1 setup_redis主要是获取redis的server和获取爬虫的idle signal，当爬虫没有请求时，调用空闲信号，那时我们将从redis队列安排新请求。
- 2 spider_idle主要是 idle 信号处理，这里调用 schedule_next_requests 完成从 Redis 调度
- 3 make_request_from_data 主要是从redis队列获取ur
- 4 next_requests这个主要是redis获取url，我从这里看到可以设置url队列在redis的存储的数据格式函数schedule_next_requests从next_requests获取 url 包装为 HttpRequest.
RedisSpider(RedisMixin, Spiser) 类: 多继承，用 RedisMixin 调度功能覆盖 Spider 原生
RedisSpider(RedisMixin, CrawlSpiser) 类: 多继承，用 RedisMixin 调度功能覆盖 CrawlSpider 原生
当编写分布式爬虫时，不在使用scrapy原有的Spider类，重写的RedisSpider继承了Spider和RedisMixin这两个类，RedisMixin是用来从 redis 读取url的类。
当我们生成一个 Spider 继承 RedisSpider 时，调用 setup_redis 函数，这个函数会去连接 redis 数据库，然后会设置 signals (信号)：
一个是当 spider 空闲时候的 signal，会调用 spider_idle 函数，这个函数调用 schedule_next_request函数，保证 spider 是一直活着的状态，并且抛出 DontCloseSpider 异常。
一个是当抓到一个 item 时的 signal，会调用 item_scraped 函数，这个函数会调用 schedule_next_request函数，获取下一个 request。
scrapy-redis.utils
import six
#将bytes二进制数据转为字符串
def bytes_to_str(s, encoding='utf-8'):
"""Returns a str if a bytes object is given."""
if six.PY3 and isinstance(s, bytes):
return s.decode(encoding)
return s
注册自定义pipeline及Scrapy-Redis分布式爬虫相关设置
#-----------Scrapy-Redis分布式爬虫相关设置如下-------------
# 使用Scrapy-Redis的去重组件,不再使用scrapy的去重组件
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用Scrapy-Redis的调度器,不再使用scrapy的调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 使用Scrapy-Redis的从请求集合中取出请求的方式,三种方式择其一即可:
SCHEDULER_CLASS = "scrapy_redis.queue.SpiderPriorityQueue"
# 分别按(1)请求的优先级/(2)队列FIFO/(3)栈FILO 取出请求
#SCHEDULER_CLASS = "scrapy_redis.queue.SpiderQueue"
#SCHEDULER_CLASS = "scrapy_redis.queue.SpiderStack"
SCHEDULER_PERSIST = True # 允许暂停,redis请求记录不会丢失(重启爬虫不会重头爬取已爬过的页面)
REDIS_HOST = "200.200.200.200" # 这两项是Redis连接设置,如果注释或不写会默认将数据存放到本机的Redis中
REDIS_PORT = 6379 # 注意:master端的Redis需要允许远程连接--配置中注释掉bind 127.0.0.1
#----------注册RedisPipeline/自定义pipeline------------------
# # 注意:自定义pipeline的优先级需高于Redispipeline,因为RedisPipeline不会返回item,
# 所以如果RedisPipeline优先级高于自定义pipeline,那么自定义pipeline无法获取到item
ITEM_PIPELINES = {
"example.pipelines.ExampPipeline":300, # 自定义pipeline视情况选择性注册(可选)
"scrapy_redis.pipelines.RedisPipeline":400 # 将RedisPipeline注册到pipeline组件中(这样才能将数据存入Redis)
}
- 执行爬虫— scrapy crawl yy
注意: 在原始scrapy项目的基础上,在settings.py文件中添加上述几行设置,就可以将scrapy爬取的数据存放到本机redis中
注意: 上述要想成功保存到本机Redis,有两个前提:本机必须(pip install scrapy-redis) 和本机redis必须启动(redis-server /etc/redis.conf)
修改爬虫文件
import scrapy
from scrapy linkextractor import LinkExtractor
from scrapy.Spiders import CrawlSpider,Rule
from youyuan.items import YouyuanItem
import re
from scrapy_redis.Spiders import RedisCrawlSpider # 变化1:从scrapy_redis.Spiders中引入RedisCrawlSpider
class YySpider(RedisCrawlSpider): # 变化2:爬虫类所继承的父类变为RedisCrawlSpider类
name = "yy"
redis_key = "yyspider:start_urls" # 变化3:多了一个对所有爬虫发号施令的redis_key,少了allowed_domain和start_urls
def __init__(self,*args,**kwargs): # 变化4:重写__init__方法:动态获取限制域
domain = kwargs.pop('domain','')
self.allowed_domain = filter(None,domain,split(','))
super(YySpider,self).__init__(*args,**kwargs) # 注意super()里面的参数因爬虫类名不同而不同
page_links = LinkExtractor(allow=(r'youyuan.com/find/beijing/mm18-25/advance-0-0-0-0-0-0-0/p\d+/'))
person_links = LinkExtractor(allow =(r'youyuan.com/\d+-profile/'))
.......
....... # 后面的代码都相同