爬虫工作量由小到大的思维转变---<第三十二章 Scrapy scheduler说明书)>
2023-12-28 14:03:53
前言:
因为scrapy-redis和scrapy之间最直接的区别在于调度器;那么,在讲解scrapy-redis之前,我发现自己没有对scrapy的调度器这一块进行过什么总结; 那么这篇 <关于调度器的说明文>?需要写在正式`自定义scrapy-redis`的前面!!
正文:
原版翻译scheduler:
? ? ? ? -包在scrapy/core/scheduler.py 里面,自己可以对着源码看;
from __future__ import annotations
import json
import logging
from abc import abstractmethod
from pathlib import Path
from typing import TYPE_CHECKING, Any, Optional, Type, TypeVar, cast
from twisted.internet.defer import Deferred
from scrapy.crawler import Crawler
from scrapy.dupefilters import BaseDupeFilter
from scrapy.http.request import Request
from scrapy.spiders import Spider
from scrapy.statscollectors import StatsCollector
from scrapy.utils.job import job_dir
from scrapy.utils.misc import create_instance, load_object
if TYPE_CHECKING:
from typing_extensions import Self
logger = logging.getLogger(__name__)
class BaseSchedulerMeta(type):
"""
元类,用于检查调度器类是否符合必要的接口
"""
def __instancecheck__(cls, instance: Any) -> bool:
return cls.__subclasscheck__(type(instance))
def __subclasscheck__(cls, subclass: type) -> bool:
return (
hasattr(subclass, "has_pending_requests")
and callable(subclass.has_pending_requests)
and hasattr(subclass, "enqueue_request")
and callable(subclass.enqueue_request)
and hasattr(subclass, "next_request")
and callable(subclass.next_request)
)
class BaseScheduler(metaclass=BaseSchedulerMeta):
"""
调度器组件负责存储从引擎接收到的请求,并在需要时将其发送回引擎。
请求的原始来源包括:
* Spider: ``start_requests`` 方法、为 ``start_urls`` 属性中的 URL 创建的请求、请求回调
* Spider 中间件: ``process_spider_output`` 和 ``process_spider_exception`` 方法
* Downloader 中间件: ``process_request``、``process_response`` 和 ``process_exception`` 方法
调度器返回存储的请求的顺序(通过 ``next_request`` 方法),在很大程度上决定了请求的下载顺序。
此类中定义的方法构成了 Scrapy 引擎与调度器交互的最小接口。
"""
@classmethod
def from_crawler(cls, crawler: Crawler) -> Self:
"""
工厂方法,接收当前 :class:`~scrapy.crawler.Crawler` 对象作为参数。
"""
return cls()
def open(self, spider: Spider) -> Optional[Deferred]:
"""
当引擎打开爬虫时调用该方法。它接收当前爬虫实例作为参数,
可用于执行初始化代码。
:param spider: 当前爬虫的对象
:type spider: :class:`~scrapy.spiders.Spider`
"""
pass
def close(self, reason: str) -> Optional[Deferred]:
"""
当引擎关闭爬虫时调用该方法。它接收爬取结束的原因作为参数,
可用于执行清理代码。
:param reason: 描述爬虫关闭原因的字符串
:type reason: :class:`str`
"""
pass
@abstractmethod
def has_pending_requests(self) -> bool:
"""
返回``True``如果调度器中有待处理的请求,否则返回``False``。
"""
raise NotImplementedError()
@abstractmethod
def enqueue_request(self, request: Request) -> bool:
"""
处理引擎接收到的请求。
如果请求成功存储,则返回``True``,否则返回``False``。
如果返回``False``,引擎将触发一个``request_dropped``信号,并且不会尝试以后再次调度该请求。
默认的 Scrapy 调度器在请求被去重过滤器拒绝时返回``False``。
"""
raise NotImplementedError()
@abstractmethod
def next_request(self) -> Optional[Request]:
"""
返回下一个要处理的 :class:`~scrapy.http.Request`,如果当前没有准备好的请求则返回``None``。
返回``None``意味着当前的 reactor 循环中不会向下载器发送调度器中的请求。
引擎会不断调用``next_request``直到``has_pending_requests``为``False``。
"""
raise NotImplementedError()
SchedulerTV = TypeVar("SchedulerTV", bound="Scheduler")
class Scheduler(BaseScheduler):
"""
默认的 Scrapy 调度器。此实现还通过 :setting:`DUPEFILTER_CLASS` 进行重复过滤。
该调度器将请求存储在多个优先级队列中(由 :setting:`SCHEDULER_PRIORITY_QUEUE` 设置定义)。
这些优先级队列由内存队列或磁盘队列(分别由 :setting:`SCHEDULER_MEMORY_QUEUE` 和 :setting:`SCHEDULER_DISK_QUEUE` 设置定义)支持。
请求的优先级几乎完全委托给优先级队列。此调度器执行的唯一优先级处理是,如果存在磁盘队列(即如果定义了 :setting:`JOBDIR` 设置),
则使用磁盘队列;如果序列化错误发生,则回退到使用内存队列。如果不存在磁盘队列,则直接使用内存队列。
:param dupefilter: 负责检查和过滤重复请求的对象。
默认情况下使用 :setting:`DUPEFILTER_CLASS` 设置的值。
:type dupefilter: :class:`scrapy.dupefilters.BaseDupeFilter` 实例或类似对象:
任何实现了 `BaseDupeFilter` 接口的类
:param jobdir: 用于持久化爬取状态的目录路径。
默认使用 :setting:`JOBDIR` 设置的值。
有关详细信息,请参阅 :ref:`topics-jobs`。
:type jobdir: :class:`str` 或 ``None``
:param dqclass: 用作持久请求队列的类。
默认使用 :setting:`SCHEDULER_DISK_QUEUE` 设置的值。
:type dqclass: 类
:param mqclass: 用作非持久请求队列的类。
默认使用 :setting:`SCHEDULER_MEMORY_QUEUE` 设置的值。
:type mqclass: 类
:param logunser: 一个布尔值,指示是否应记录无法序列化的请求。
默认使用 :setting:`SCHEDULER_DEBUG` 设置的值。
:type logunser: bool
:param stats: 用于记录请求调度过程统计数据的统计收集器对象。
默认使用 :setting:`STATS_CLASS` 设置的值。
:type stats: :class:`scrapy.statscollectors.StatsCollector` 实例或类似对象:
任何实现了 `StatsCollector` 接口的类
:param pqclass: 用作请求优先级队列的类。
默认使用 :setting:`SCHEDULER_PRIORITY_QUEUE` 设置的值。
:type pqclass: 类
:param crawler: 当前爬虫对应的爬虫对象。
:type crawler: :class:`scrapy.crawler.Crawler`
"""
def __init__(
self,
dupefilter: BaseDupeFilter,
jobdir: Optional[str] = None,
dqclass=None,
mqclass=None,
logunser: bool = False,
stats: Optional[StatsCollector] = None,
pqclass=None,
crawler: Optional[Crawler] = None,
):
self.df: BaseDupeFilter = dupefilter
self.dqdir: Optional[str] = self._dqdir(jobdir)
self.pqclass = pqclass
self.dqclass = dqclass
self.mqclass = mqclass
self.logunser: bool = logunser
self.stats: Optional[StatsCollector] = stats
self.crawler: Optional[Crawler] = crawler
@classmethod
def from_crawler(cls: Type[SchedulerTV], crawler: Crawler) -> SchedulerTV:
"""
工厂方法,使用来自爬虫设置的参数初始化调度器。
"""
dupefilter_cls = load_object(crawler.settings["DUPEFILTER_CLASS"])
return cls(
dupefilter=create_instance(dupefilter_cls, crawler.settings, crawler),
jobdir=job_dir(crawler.settings),
dqclass=load_object(crawler.settings["SCHEDULER_DISK_QUEUE"]),
mqclass=load_object(crawler.settings["SCHEDULER_MEMORY_QUEUE"]),
logunser=crawler.settings.getbool("SCHEDULER_DEBUG"),
stats=crawler.stats,
pqclass=load_object(crawler.settings["SCHEDULER_PRIORITY_QUEUE"]),
crawler=crawler,
)
def has_pending_requests(self) -> bool:
return len(self) > 0
def open(self, spider: Spider) -> Optional[Deferred]:
"""
1. 初始化内存队列
2. 初始化磁盘队列(如果 ``jobdir`` 属性是一个有效的目录)
3. 返回去重过滤器的 ``open`` 方法的结果
"""
self.spider = spider
self.mqs = self._mq()
self.dqs = self._dq() if self.dqdir else None
return self.df.open()
def close(self, reason: str) -> Optional[Deferred]:
"""
1. 如果存在磁盘队列,将挂起的请求保存到磁盘
2. 返回去重过滤器的 ``close`` 方法的结果
"""
if self.dqs is not None:
state = self.dqs.close()
assert isinstance(self.dqdir, str)
self._write_dqs_state(self.dqdir, state)
return self.df.close(reason)
def enqueue_request(self, request: Request) -> bool:
"""
除非请求被去重过滤器过滤掉,否则尝试将请求推送到磁盘队列,
如果没有磁盘队列则将请求推送到内存队列。
增加适当的统计数据,如:``scheduler/enqueued``,
``scheduler/enqueued/disk``, ``scheduler/enqueued/memory``。
如果请求成功存储,则返回``True``,否则返回``False``。
"""
if not request.dont_filter and self.df.request_seen(request):
self.df.log(request, self.spider)
return False
dqok = self._dqpush(request)
assert self.stats is not None
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
def next_request(self) -> Optional[Request]:
"""
从内存队列返回一个 :class:`~scrapy.http.Request` 对象,如果内存队列为空,则返回磁盘队列。
如果没有更多的入队请求,则返回``None``。
增加适当的统计数据,如:``scheduler/dequeued``,
``scheduler/dequeued/disk``, ``scheduler/dequeued/memory``。
"""
request: Optional[Request] = self.mqs.pop()
assert self.stats is not None
if request is not None:
self.stats.inc_value("scheduler/dequeued/memory", spider=self.spider)
else:
request = self._dqpop()
if request is not None:
self.stats.inc_value("scheduler/dequeued/disk", spider=self.spider)
if request is not None:
self.stats.inc_value("scheduler/dequeued", spider=self.spider)
return request
def __len__(self) -> int:
"""
返回已入队的请求总数
"""
return len(self.dqs) + len(self.mqs) if self.dqs is not None else len(self.mqs)
def _dqpush(self, request: Request) -> bool:
if self.dqs is None:
return False
try:
self.dqs.push(request)
except ValueError as e: # 非可序列化的请求
if self.logunser:
msg = (
"无法序列化请求: %(request)s - 原因: "
"%(reason)s - 不再记录更多无法序列化的请求(正在收集统计数据)"
)
logger.warning(
msg,
{"request": request, "reason": e},
exc_info=True,
extra={"spider": self.spider},
)
self.logunser = False
assert self.stats is not None
self.stats.inc_value("scheduler/unserializable", spider=self.spider)
return False
else:
return True
def _mqpush(self, request: Request) -> None:
self.mqs.push(request)
def _dqpop(self) -> Optional[Request]:
if self.dqs is not None:
return self.dqs.pop()
return None
def _mq(self):
"""创建一个新的内存存储的优先级队列实例"""
return create_instance(
self.pqclass,
settings=None,
crawler=self.crawler,
downstream_queue_cls=self.mqclass,
key="",
)
def _dq(self):
"""创建一个新的磁盘存储的优先级队列实例"""
assert self.dqdir
state = self._read_dqs_state(self.dqdir)
q = create_instance(
self.pqclass,
settings=None,
crawler=self.crawler,
downstream_queue_cls=self.dqclass,
key=self.dqdir,
startprios=state,
)
if q:
logger.info(
"恢复爬取(%(queuesize)d 个请求已安排)",
{"queuesize": len(q)},
extra={"spider": self.spider},
)
return q
def _dqdir(self, jobdir: Optional[str]) -> Optional[str]:
"""返回一个目录名称,用于保存磁盘队列的状态"""
if jobdir is not None:
dqdir = Path(jobdir, "requests.queue")
if not dqdir.exists():
dqdir.mkdir(parents=True)
return str(dqdir)
return None
def _read_dqs_state(self, dqdir: str) -> list:
path = Path(dqdir, "active.json")
if not path.exists():
return []
with path.open(encoding="utf-8") as f:
return cast(list, json.load(f))
def _write_dqs_state(self, dqdir: str, state: list) -> None:
with Path(dqdir, "active.json").open("w", encoding="utf-8") as f:
json.dump(state, f)
重点关注:
- has_pending_requests(self) -> bool: 判断调度器中是否有待处理的请求。这个方法用于告诉引擎是否还有未处理的请求,以确定是否继续进行请求调度和下载。
- enqueue_request(self, request: Request) -> bool: 处理引擎接收到的请求。这个方法将传入的请求存储到调度器中,并返回一个布尔值,指示请求是否成功存储。如果返回值为True,则请求已成功存储;如果返回值为False,则请求被去重过滤器拒绝或无法序列化等原因导致存储失败。
- next_request(self) -> Optional[Request]: 返回下一个要处理的请求。这个方法从调度器中获取下一个要处理的请求,并返回一个Request对象。如果调度器没有准备好的请求,将返回None。
-----除了这三个方法,还有一些其他方法和类变量也会影响调度器的行为,但它们的重要性可能不如上述三个方法。要实现一个完整的自定义调度器,还需要考虑其他方法,例如open和close方法用于初始化和清理,__len__方法用于获取当前队列中请求的数量等。
实现自定义调度器:
步骤:
案例假设已经创建好了Scrapy项目并定义了爬虫(Spider)和项目文件结构后.
1. 在项目目录下创建一个新的Python文件,例如`custom_scheduler.py`,用于编写自定义调度器的代码。
2. 在`custom_scheduler.py`文件中,导入必要的模块和类,并创建一个自定义的调度器类,并继承自`BaseScheduler`:
from scrapy.core.scheduler import BaseScheduler
from scrapy.http import Request
class CustomScheduler(BaseScheduler):
? ? def __init__(self, dupefilter):
? ? ? ? super().__init__(dupefilter)
? ? def has_pending_requests(self) -> bool:
? ? ? ? # 自定义判断逻辑
? ? ? ? pass
? ? def enqueue_request(self, request: Request) -> bool:
? ? ? ? # 自定义存储逻辑
? ? ? ? pass
? ? def next_request(self) -> Optional[Request]:
? ? ? ? # 自定义调度逻辑
? ? ? ? pass
3. 在自定义调度器的方法中,根据自己的需求实现相应的逻辑。例如,可以根据特定的调度算法重新定义`enqueue_request`和`next_request`方法。
5. 在项目的爬虫文件(Spider)中,导入自定义调度器类,并在`custom_settings`中指定使用自定义调度器:
from scrapy.spiders import Spider
from custom_scheduler import CustomScheduler
class MySpider(Spider):
? ? name = 'example'
? ? start_urls = ['http://example.com']
? ? custom_settings = {
? ? ? ? 'SCHEDULER': 'custom_scheduler.CustomScheduler',
? ? }
6. 运行Scrapy爬虫,Scrapy会使用你自定义调度器进行爬取的。
文章来源:https://blog.csdn.net/m0_56758840/article/details/135256736
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!