当前位置：主页 > 查看内容

Scrapy源码剖析：Scrapy有哪些核心组件？

发布时间：2021-05-27 00:00| 有 位朋友查看

简介：在上一篇文章：Scrapy源码剖析：Scrapy是如何运行起来的？我们主要剖析了 Scrapy 是如何运行起来的核心逻辑，也就是在真正执行抓取任务之前，Scrapy 都做了哪些工作。 这篇文章，我们就来进一步剖析一下，Scrapy 有哪些核心组件？以及它们主要负责了哪些工作……

在上一篇文章：Scrapy源码剖析：Scrapy是如何运行起来的？我们主要剖析了 Scrapy 是如何运行起来的核心逻辑，也就是在真正执行抓取任务之前，Scrapy 都做了哪些工作。

这篇文章，我们就来进一步剖析一下，Scrapy 有哪些核心组件？以及它们主要负责了哪些工作？这些组件为了完成这些功能，内部又是如何实现的。

爬虫类

我们接着上一篇结束的地方开始讲起。上次讲到 Scrapy 运行起来后，执行到最后到了 Crawler 的 crawl 方法，我们来看这个方法：

  1. @defer.inlineCallbacks  
  2. def crawl(self, *args, **kwargs):  
  3.     assert not self.crawling, "Crawling already taking place"  
  4.     self.crawling = True  
  5.     try: 
  6.         # 从spiderloader中找到爬虫类 并实例化爬虫实例  
  7.         selfself.spider = self._create_spider(*args, **kwargs)  
  8.         # 创建引擎  
  9.         selfself.engine = self._create_engine()  
  10.         # 调用爬虫类的start_requests方法 拿到种子URL列表  
  11.         start_requests = iter(self.spider.start_requests())  
  12.         # 执行引擎的open_spider 并传入爬虫实例和初始请求  
  13.         yield self.engine.open_spider(self.spider, start_requests)  
  14.         yield defer.maybeDeferred(self.engine.start)  
  15.     except Exception:  
  16.         if six.PY2:  
  17.             exc_info = sys.exc_info()  
  18.         self.crawling = False  
  19.         if self.engine is not None:  
  20.             yield self.engine.close()  
  21.         if six.PY2:  
  22.             six.reraise(*exc_info)  
  23.         raise 

执行到这里，我们看到首先创建了爬虫实例，然后创建了引擎，最后把爬虫交给引擎来处理了。

在上一篇文章我们也讲到，在 Crawler 实例化时，会创建 SpiderLoader，它会根据我们定义的配置文件 settings.py 找到存放爬虫的位置，我们写的爬虫代码都在这里。

然后 SpiderLoader 会扫描这些代码文件，并找到父类是 scrapy.Spider 爬虫类，然后根据爬虫类中的 name 属性（在编写爬虫时，这个属性是必填的），生成一个 {spider_name: spider_cls} 的字典，最后根据 scrapy crawl <spider_name> 命令中的 spider_name 找到我们写的爬虫类，然后实例化它，在这里就是调用了_create_spider方法：

  1. def _create_spider(self, *args, **kwargs):  
  2.     # 调用类方法from_crawler实例化  
  3.     return self.spidercls.from_crawler(self, *args, **kwargs) 

实例化爬虫比较有意思，它不是通过普通的构造方法进行初始化，而是调用了类方法 from_crawler 进行的初始化，找到 scrapy.Spider 类：

  1. @classmethod  
  2. def from_crawler(cls, crawler, *args, **kwargs):  
  3.     spider = cls(*args, **kwargs)  
  4.     spider._set_crawler(crawler)  
  5.     return spider      
  6. def _set_crawler(self, crawler):  
  7.     self.crawler = crawler  
  8.     # 把settings对象赋给spider实例  
  9.     self.settings = crawler.settings  
  10.     crawler.signals.connect(self.close, signals.spider_closed) 

在这里我们可以看到，这个类方法其实也是调用了构造方法，进行实例化，同时也拿到了 settings 配置，来看构造方法干了些什么？

  1. class Spider(object_ref):  
  2.     name = None 
  3.     custom_settings = None  
  4.     def __init__(self, name=None, **kwargs):  
  5.         # name必填  
  6.         if name is not None:  
  7.             self.name = name  
  8.         elif not getattr(self, 'name', None):  
  9.             raise ValueError("%s must have a name" % type(self).__name__)  
  10.         self.__dict__.update(kwargs) 
  11.         # 如果没有设置start_urls 默认是[]  
  12.         if not hasattr(self, 'start_urls'):  
  13.             self.start_urls = [] 

看到这里是不是很熟悉？这里就是我们平时编写爬虫类时，最常用的几个属性：name、start_urls、custom_settings：

  •  name：在运行爬虫时通过它找到我们编写的爬虫类；
  •  start_urls：抓取入口，也可以叫做种子URL；
  •  custom_settings：爬虫自定义配置，会覆盖配置文件中的配置项；

引擎

分析完爬虫类的初始化后，还是回到 Crawler 的 crawl 方法，紧接着就是创建引擎对象，也就是 _create_engine 方法，看看初始化时都发生了什么？

  1. class ExecutionEngine(object):  
  2.     """引擎"""  
  3.     def __init__(self, crawler, spider_closed_callback):  
  4.         self.crawler = crawler  
  5.         # 这里也把settings配置保存到引擎中  
  6.         self.settings = crawler.settings  
  7.         # 信号  
  8.         self.signals = crawler.signals  
  9.         # 日志格式  
  10.         self.logformatter = crawler.logformatter  
  11.         self.slot = None  
  12.         self.spider = None  
  13.         self.running = False  
  14.         self.paused = False  
  15.         # 从settings中找到Scheduler调度器，找到Scheduler类  
  16.         self.scheduler_cls = load_object(self.settings['SCHEDULER']) 
  17.         # 同样，找到Downloader下载器类  
  18.         downloader_cls = load_object(self.settings['DOWNLOADER'])  
  19.         # 实例化Downloader  
  20.         self.downloader = downloader_cls(crawler)  
  21.         # 实例化Scraper 它是引擎连接爬虫类的桥梁  
  22.         self.scraper = Scraper(crawler)  
  23.         self._spider_closed_callback = spider_closed_callback 

在这里我们能看到，主要是对其他几个核心组件进行定义和初始化，主要包括包括：Scheduler、Downloader、Scrapyer，其中 Scheduler 只进行了类定义，没有实例化。

也就是说，引擎是整个 Scrapy 的核心大脑，它负责管理和调度这些组件，让这些组件更好地协调工作。

下面我们依次来看这几个核心组件都是如何初始化的？

调度器

调度器初始化发生在引擎的 open_spider 方法中，我们提前来看一下调度器的初始化。

  1. class Scheduler(object):  
  2.  """调度器"""  
  3.     def __init__(self, dupefilter, jobdir=None, dqclass=None, mqclass=None,  
  4.                  logunser=False, stats=None, pqclass=None):  
  5.         # 指纹过滤器  
  6.         self.df = dupefilter  
  7.         # 任务队列文件夹  
  8.         selfself.dqdir = self._dqdir(jobdir)  
  9.         # 优先级任务队列类  
  10.         self.pqclass = pqclass  
  11.         # 磁盘任务队列类  
  12.         self.dqclass = dqclass  
  13.         # 内存任务队列类  
  14.         self.mqclass = mqclass  
  15.         # 日志是否序列化  
  16.         self.logunser = logunser  
  17.         self.stats = stats       
  18.      @classmethod  
  19.     def from_crawler(cls, crawler):  
  20.         settings = crawler.settings  
  21.         # 从配置文件中获取指纹过滤器类  
  22.         dupefilter_cls = load_object(settings['DUPEFILTER_CLASS'])  
  23.         # 实例化指纹过滤器  
  24.         dupefilter = dupefilter_cls.from_settings(settings)  
  25.         # 从配置文件中依次获取优先级任务队列类、磁盘队列类、内存队列类  
  26.         pqclass = load_object(settings['SCHEDULER_PRIORITY_QUEUE'])  
  27.         dqclass = load_object(settings['SCHEDULER_DISK_QUEUE'])  
  28.         mqclass = load_object(settings['SCHEDULER_MEMORY_QUEUE'])  
  29.         # 请求日志序列化开关  
  30.         logunser = settings.getbool('LOG_UNSERIALIZABLE_REQUESTS', settings.getbool('SCHEDULER_DEBUG'))  
  31.         return cls(dupefilter, jobdir=job_dir(settings), logunserlogunser=logunser,  
  32.                    stats=crawler.stats, pqclasspqclass=pqclass, dqclassdqclass=dqclass, mqclassmqclass=mqclass) 

可以看到，调度器的初始化主要做了 2 件事：

  •  实例化请求指纹过滤器：主要用来过滤重复请求；
  •  定义不同类型的任务队列：优先级任务队列、基于磁盘的任务队列、基于内存的任务队列；

请求指纹过滤器又是什么？

在配置文件中，我们可以看到定义的默认指纹过滤器是 RFPDupeFilter：

  1. class RFPDupeFilter(BaseDupeFilter):  
  2.     """请求指纹过滤器"""  
  3.     def __init__(self, path=None, debug=False):  
  4.         self.file = None  
  5.         # 指纹集合 使用的是Set 基于内存  
  6.         self.fingerprints = set()  
  7.         self.logdupes = True  
  8.         self.debug = debug  
  9.         self.logger = logging.getLogger(__name__)  
  10.         # 请求指纹可存入磁盘  
  11.         if path:  
  12.             self.file = open(os.path.join(path, 'requests.seen'), 'a+') 
  13.              self.file.seek(0)  
  14.             self.fingerprints.update(x.rstrip() for x in self.file) 
  15.     @classmethod  
  16.     def from_settings(cls, settings):  
  17.         debug = settings.getbool('DUPEFILTER_DEBUG')  
  18.         return cls(job_dir(settings), debug) 

请求指纹过滤器初始化时，定义了指纹集合，这个集合使用内存实现的 Set，而且可以控制这些指纹是否存入磁盘以供下次重复使用。

也就是说，指纹过滤器的主要职责是：过滤重复请求，可自定义过滤规则。

在下篇文章中我们会介绍到，每个请求是根据什么规则生成指纹的，然后是又如何实现重复请求过滤逻辑的，这里我们先知道它的功能即可。

下面来看调度器定义的任务队列都有什么作用？

调度器默认定义了 2 种队列类型：

  •  基于磁盘的任务队列：在配置文件可配置存储路径，每次执行后会把队列任务保存到磁盘上；
  •  基于内存的任务队列：每次都在内存中执行，下次启动则消失；

配置文件默认定义如下：

  1. # 基于磁盘的任务队列(后进先出)  
  2. SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue'  
  3. # 基于内存的任务队列(后进先出)  
  4. SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'  
  5. # 优先级队列  
  6. SCHEDULER_PRIORITY_QUEUE = 'queuelib.PriorityQueue' 

如果我们在配置文件中定义了 JOBDIR 配置项，那么每次执行爬虫时，都会把任务队列保存在磁盘中，下次启动爬虫时可以重新加载继续执行我们的任务。

如果没有定义这个配置项，那么默认使用的是内存队列。

细心的你可能会发现，默认定义的这些队列结构都是后进先出的，什么意思呢？

也就是在运行我们的爬虫代码时，如果生成一个抓取任务，放入到任务队列中，那么下次抓取就会从任务队列中先获取到这个任务，优先执行。

这么实现意味什么呢？其实意味着：Scrapy 默认的采集规则是深度优先！

如何改变这种机制，变为广度优先采集呢？这时候我们就要看一下 scrapy.squeues 模块了，在这里定义了很多种队列：

  1. # 先进先出磁盘队列(pickle序列化)  
  2. PickleFifoDiskQueue = _serializable_queue(queue.FifoDiskQueue, \  
  3.     _pickle_serialize, pickle.loads)  
  4. # 后进先出磁盘队列(pickle序列化)  
  5. PickleLifoDiskQueue = _serializable_queue(queue.LifoDiskQueue, \  
  6.     _pickle_serialize, pickle.loads)  
  7. # 先进先出磁盘队列(marshal序列化)  
  8. MarshalFifoDiskQueue = _serializable_queue(queue.FifoDiskQueue, \  
  9.     marshal.dumps, marshal.loads)  
  10. # 后进先出磁盘队列(marshal序列化)  
  11. MarshalLifoDiskQueue = _serializable_queue(queue.LifoDiskQueue, \  
  12.     marshal.dumps, marshal.loads)  
  13. # 先进先出内存队列  
  14. FifoMemoryQueue = queue.FifoMemoryQueue  
  15. # 后进先出内存队列  
  16. LifoMemoryQueue = queue.LifoMemoryQueue 

如果我们想把抓取任务改为广度优先，我们只需要在配置文件中把队列类修改为先进先出队列类就可以了！从这里我们也可以看出，Scrapy 各个组件之间的耦合性非常低，每个模块都是可自定义的。

如果你想探究这些队列是如何实现的，可以参考 Scrapy 作者写的 scrapy/queuelib 项目，在 Github 上就可以找到，在这里有这些队列的具体实现。

下载器

回到引擎的初始化的地方，接下来我们来看，下载器是如何初始化的。

在默认的配置文件 default_settings.py 中，下载器配置如下：

  1. DOWNLOADER = 'scrapy.core.downloader.Downloader' 

我们来看 Downloader 类的初始化：

  1. class Downloader(object):  
  2.     """下载器"""  
  3.     def __init__(self, crawler):  
  4.         # 同样的 拿到settings对象  
  5.         self.settings = crawler.settings  
  6.         self.signals = crawler.signals  
  7.         self.slots = {}  
  8.         self.active = set()  
  9.         # 初始化DownloadHandlers  
  10.         self.handlers = DownloadHandlers(crawler)  
  11.         # 从配置中获取设置的并发数  
  12.         selfself.total_concurrency = self.settings.getint('CONCURRENT_REQUESTS')  
  13.         # 同一域名并发数  
  14.         selfself.domain_concurrency = self.settings.getint('CONCURRENT_REQUESTS_PER_DOMAIN')  
  15.         # 同一IP并发数  
  16.         selfself.ip_concurrency = self.settings.getint('CONCURRENT_REQUESTS_PER_IP')  
  17.         # 随机延迟下载时间  
  18.         selfself.randomize_delay = self.settings.getbool('RANDOMIZE_DOWNLOAD_DELAY')  
  19.         # 初始化下载器中间件  
  20.         self.middleware = DownloaderMiddlewareManager.from_crawler(crawler)  
  21.         self._slot_gc_loop = task.LoopingCall(self._slot_gc) 
  22.         self._slot_gc_loop.start(60) 

在这个过程中，主要是初始化了下载处理器、下载器中间件管理器以及从配置文件中拿到抓取请求控制的相关参数。

那么下载处理器是做什么的？下载器中间件又负责哪些工作？

先来看 DownloadHandlers：

  1. class DownloadHandlers(object):  
  2.     """下载器处理器"""  
  3.     def __init__(self, crawler):  
  4.         self._crawler = crawler  
  5.         self._schemes = {} # 存储scheme对应的类路径 后面用于实例化  
  6.         self._handlers = {} # 存储scheme对应的下载器  
  7.         self._notconfigured = {}  
  8.         # 从配置中找到DOWNLOAD_HANDLERS_BASE 构造下载处理器  
  9.         # 注意：这里是调用getwithbase方法  取的是配置中的XXXX_BASE配置  
  10.         handlers = without_none_values( 
  11.              crawler.settings.getwithbase('DOWNLOAD_HANDLERS'))  
  12.         # 存储scheme对应的类路径 后面用于实例化  
  13.         for scheme, clspath in six.iteritems(handlers):  
  14.             self._schemes[scheme] = clspath  
  15.         crawler.signals.connect(self._close, signals.engine_stopped) 

下载处理器在默认的配置文件中是这样配置的：

  1. # 用户可自定义的下载处理器  
  2. DOWNLOAD_HANDLERS = {}  
  3. # 默认的下载处理器  
  4. DOWNLOAD_HANDLERS_BASE = {  
  5.     'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler',  
  6.     'http': 'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',  
  7.     'https': 'scrapy.core.downloader.handlers.http.HTTPDownloadHandler',  
  8.     's3': 'scrapy.core.downloader.handlers.s3.S3DownloadHandler',  
  9.     'ftp': 'scrapy.core.downloader.handlers.ftp.FTPDownloadHandler',  
  10. } 

看到这里你应该能明白了，下载处理器会根据下载资源的类型，选择对应的下载器去下载资源。其中我们最常用的就是 http 和 https 对应的处理器。

但是请注意，在这里，这些下载器是没有被实例化的，只有在真正发起网络请求时，才会进行初始化，而且只会初始化一次，后面文章会讲到。

下面我们来看下载器中间件 DownloaderMiddlewareManager 初始化过程，同样地，这里又调用了类方法 from_crawler 进行初始化，而且 DownloaderMiddlewareManager 继承了MiddlewareManager 类，来看它在初始化做了哪些工作：

  1. class MiddlewareManager(object):  
  2.     """所有中间件的父类，提供中间件公共的方法"""  
  3.     component_name = 'foo middleware'  
  4.     @classmethod  
  5.     def from_crawler(cls, crawler):  
  6.         # 调用from_settings  
  7.         return cls.from_settings(crawler.settings, crawler)  
  8.      @classmethod  
  9.     def from_settings(cls, settings, crawler=None):  
  10.         # 调用子类_get_mwlist_from_settings得到所有中间件类的模块  
  11.         mwlist = cls._get_mwlist_from_settings(settings) 
  12.          middlewares = []  
  13.         enabled = []  
  14.         # 依次实例化  
  15.         for clspath in mwlist:  
  16.             try:  
  17.                 # 加载这些中间件模块  
  18.                 mwcls = load_object(clspath)  
  19.                 # 如果此中间件类定义了from_crawler 则调用此方法实例化  
  20.                 if crawler and hasattr(mwcls, 'from_crawler'):  
  21.                     mw = mwcls.from_crawler(crawler)  
  22.                 # 如果此中间件类定义了from_settings 则调用此方法实例化  
  23.                 elif hasattr(mwcls, 'from_settings'): 
  24.                      mw = mwcls.from_settings(settings)  
  25.                 # 上面2个方法都没有，则直接调用构造实例化  
  26.                 else:  
  27.                     mw = mwcls()  
  28.                 middlewares.append(mw)  
  29.                 enabled.append(clspath)  
  30.             except NotConfigured as e:  
  31.                 if e.args:  
  32.                     clsname = clspath.split('.')[-1]  
  33.                     logger.warning("Disabled %(clsname)s: %(eargs)s",  
  34.                                    {'clsname': clsname, 'eargs': e.args[0]},  
  35.                                    extra={'crawler': crawler})   
  36.         logger.info("Enabled %(componentname)ss:\n%(enabledlist)s",  
  37.                     {'componentname': cls.component_name,  
  38.                      'enabledlist': pprint.pformat(enabled)},  
  39.                     extra={'crawler': crawler})  
  40.         # 调用构造方法  
  41.         return cls(*middlewares) 
  42.     @classmethod  
  43.     def _get_mwlist_from_settings(cls, settings):  
  44.         # 具体有哪些中间件类，子类定义  
  45.         raise NotImplementedError 
  46.      def __init__(self, *middlewares):  
  47.         self.middlewares = middlewares  
  48.         # 定义中间件方法  
  49.         self.methods = defaultdict(list)  
  50.         for mw in middlewares:  
  51.             self._add_middleware(mw)      
  52.   def _add_middleware(self, mw):  
  53.         # 默认定义的 子类可覆盖  
  54.         # 如果中间件类有定义open_spider 则加入到methods  
  55.         if hasattr(mw, 'open_spider'):  
  56.             self.methods['open_spider'].append(mw.open_spider)  
  57.         # 如果中间件类有定义close_spider 则加入到methods  
  58.         # methods就是一串中间件的方法链 后期会依次调用  
  59.         if hasattr(mw, 'close_spider'):  
  60.             self.methods['close_spider'].insert(0, mw.close_spider) 

DownloaderMiddlewareManager 实例化过程：

  1. class DownloaderMiddlewareManager(MiddlewareManager):  
  2.  """下载中间件管理器"""  
  3.     component_name = 'downloader middleware'  
  4.     @classmethod  
  5.     def _get_mwlist_from_settings(cls, settings):  
  6.         # 从配置文件DOWNLOADER_MIDDLEWARES_BASE和DOWNLOADER_MIDDLEWARES获得所有下载器中间件  
  7.         return build_component_list(  
  8.             settings.getwithbase('DOWNLOADER_MIDDLEWARES'))  
  9.     def _add_middleware(self, mw):  
  10.         # 定义下载器中间件请求、响应、异常一串方法  
  11.         if hasattr(mw, 'process_request'):  
  12.             self.methods['process_request'].append(mw.process_request)  
  13.         if hasattr(mw, 'process_response'):  
  14.             self.methods['process_response'].insert(0, mw.process_response)  
  15.         if hasattr(mw, 'process_exception'):  
  16.             self.methods['process_exception'].insert(0, mw.process_exception) 

下载器中间件管理器继承了 MiddlewareManager 类，然后重写了 _add_middleware 方法，为下载行为定义默认的下载前、下载后、异常时对应的处理方法。

这里我们可以想一下，中间件这么做的好处是什么？

从这里能大概看出，从某个组件流向另一个组件时，会经过一系列中间件，每个中间件都定义了自己的处理流程，相当于一个个管道，输入时可以针对数据进行处理，然后送达到另一个组件，另一个组件处理完逻辑后，又经过这一系列中间件，这些中间件可再针对这个响应结果进行处理，最终输出。

Scraper

下载器实例化完了之后，回到引擎的初始化方法中，然后就是实例化 Scraper，在Scrapy源码分析（一）架构概览这篇文章中我提到过，这个类没有在架构图中出现，但这个类其实是处于Engine、Spiders、Pipeline 之间，是连通这三个组件的桥梁。

我们来看一下它的初始化过程：

  1. class Scraper(object):  
  2.     def __init__(self, crawler):  
  3.         self.slot = None  
  4.         # 实例化爬虫中间件管理器  
  5.         self.spidermw = SpiderMiddlewareManager.from_crawler(crawler)  
  6.         # 从配置文件中加载Pipeline处理器类  
  7.         itemproc_cls = load_object(crawler.settings['ITEM_PROCESSOR'])  
  8.         # 实例化Pipeline处理器  
  9.         self.itemproc = itemproc_cls.from_crawler(crawler)  
  10.         # 从配置文件中获取同时处理输出的任务个数  
  11.         self.concurrent_items = crawler.settings.getint('CONCURRENT_ITEMS')  
  12.         self.crawler = crawler  
  13.         self.signals = crawler.signals  
  14.         self.logformatter = crawler.logformatter 

Scraper 创建了 SpiderMiddlewareManager，它的初始化过程：

  1. class SpiderMiddlewareManager(MiddlewareManager):  
  2.  """爬虫中间件管理器"""  
  3.     component_name = 'spider middleware'  
  4.     @classmethod  
  5.     def _get_mwlist_from_settings(cls, settings):  
  6.         # 从配置文件中SPIDER_MIDDLEWARES_BASE和SPIDER_MIDDLEWARES获取默认的爬虫中间件类  
  7.         return build_component_list(settings.getwithbase('SPIDER_MIDDLEWARES')) 
  8.     def _add_middleware(self, mw):  
  9.         super(SpiderMiddlewareManager, self)._add_middleware(mw)  
  10.         # 定义爬虫中间件处理方法  
  11.         if hasattr(mw, 'process_spider_input'):  
  12.             self.methods['process_spider_input'].append(mw.process_spider_input)  
  13.         if hasattr(mw, 'process_spider_output'):  
  14.             self.methods['process_spider_output'].insert(0, mw.process_spider_output)  
  15.         if hasattr(mw, 'process_spider_exception'):  
  16.             self.methods['process_spider_exception'].insert(0, mw.process_spider_exception)  
  17.         if hasattr(mw, 'process_start_requests'):  
  18.             self.methods['process_start_requests'].insert(0, mw.process_start_requests) 

爬虫中间件管理器初始化与之前的下载器中间件管理器类似，先是从配置文件中加载了默认的爬虫中间件类，然后依次注册爬虫中间件的一系列流程方法。配置文件中定义的默认的爬虫中间件类如下：

  1. SPIDER_MIDDLEWARES_BASE = {  
  2.  # 默认的爬虫中间件类  
  3.     'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50,  
  4.     'scrapy.spidermiddlewares.offsite.OffsiteMiddleware': 500,  
  5.     'scrapy.spidermiddlewares.referer.RefererMiddleware': 700,  
  6.     'scrapy.spidermiddlewares.urllength.UrlLengthMiddleware': 800,  
  7.     'scrapy.spidermiddlewares.depth.DepthMiddleware': 900,  
  8. } 

这里解释一下，这些默认的爬虫中间件的职责：

  •  HttpErrorMiddleware：针对非 200 响应错误进行逻辑处理；
  •  OffsiteMiddleware：如果Spider中定义了 allowed_domains，会自动过滤除此之外的域名请求；
  •  RefererMiddleware：追加 Referer 头信息；
  •  UrlLengthMiddleware：过滤 URL 长度超过限制的请求；
  •  DepthMiddleware：过滤超过指定深度的抓取请求；

当然，在这里你也可以定义自己的爬虫中间件，来处理自己所需的逻辑。

爬虫中间件管理器初始化完之后，然后就是 Pipeline 组件的初始化，默认的 Pipeline 组件是 ItemPipelineManager：

  1. class ItemPipelineManager(MiddlewareManager):  
  2.     component_name = 'item pipeline'  
  3.     @classmethod  
  4.     def _get_mwlist_from_settings(cls, settings):  
  5.         # 从配置文件加载ITEM_PIPELINES_BASE和ITEM_PIPELINES类  
  6.         return build_component_list(settings.getwithbase('ITEM_PIPELINES'))  
  7.     def _add_middleware(self, pipe):  
  8.         super(ItemPipelineManager, self)._add_middleware(pipe)  
  9.         # 定义默认的pipeline处理逻辑  
  10.         if hasattr(pipe, 'process_item'):  
  11.             self.methods['process_item'].append(pipe.process_item) 
  12.     def process_item(self, item, spider):  
  13.         # 依次调用所有子类的process_item方法  
  14.         return self._process_chain('process_item', item, spider) 

我们可以看到 ItemPipelineManager 也是中间件管理器的一个子类，由于它的行为非常类似于中间件，但由于功能较为独立，所以属于核心组件之一。

从 Scraper 的初始化过程我们可以看出，它管理着 Spiders 和 Pipeline 相关的数据交互。

总结

好了，这篇文章我们主要剖析了 Scrapy 涉及到的核心的组件，主要包括：引擎、下载器、调度器、爬虫类、输出处理器，以及它们各自都是如何初始化的，在初始化过程中，它们又包含了哪些子模块来辅助完成这些模块的功能。

这些组件各司其职，相互协调，共同完成爬虫的抓取任务，而且从代码中我们也能发现，每个组件类都是定义在配置文件中的，也就是说我们可以实现自己的逻辑，然后替代这些组件，这样的设计模式也非常值得我们学习。

【责任编辑：庞桂玉 TEL：（010）68476606】
本文转载自网络，原文链接：https://mp.weixin.qq.com/s/FGsqNS1TWAj-ls4DeEfRyg
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！
上一篇：都说HashMap是线程不安全的，到底体现在哪儿？ 下一篇：没有了

推荐图文

  • 周排行
  • 月排行
  • 总排行

随机推荐