首页手记 Scrapy爬虫中间件教程：新手快速入门指南

Scrapy爬虫中间件教程：新手快速入门指南

标签：

爬虫中间件

概述

本文详细介绍了Scrapy中间件的概念、作用和分类，包括请求中间件、响应中间件和爬虫中间件的具体实现和配置方法。通过实例展示了如何编写和应用这些中间件，帮助开发者增强Scrapy爬虫的功能。

Scrapy爬虫简介

Scrapy简介

Scrapy是一款广泛使用的Python框架，专为Web抓取和数据提取而设计。它不仅提供了强大的功能来处理复杂的网站结构，还具备高度可扩展、可维护的特点。Scrapy以其灵活性和速度著称，能够帮助开发者快速地从网站中提取有价值的信息。通过Scrapy，开发者可以轻松地实现各种各样的Web数据采集任务，从简单的信息抓取到复杂的爬虫设计。

Scrapy爬虫的基本结构

Scrapy项目的结构通常包含以下几个主要部分：

项目目录：Scrapy项目的根目录，包含了项目的配置文件和所有必要的组件。
spider：爬虫模块，主要负责定义爬取的规则和逻辑。每个爬虫类继承自scrapy.Spider，并定义了name、start_urls和parse等方法。
items：定义了数据模型，类似于ORM中的模型定义，用于存储爬取的数据。
pipelines：处理和存储提取的数据，通常用于清洗、验证和持久化数据。
settings：定义项目级别的配置，如下载延迟、并发请求数量等。
中间件：提供了钩子点，可以用于处理请求、响应以及爬虫生成的信号。
commands：定义自定义命令，可以用来简化任务的执行。

安装Scrapy环境

安装Scrapy环境可以通过pip来完成。以下是安装步骤：

确保已经安装了Python环境。Scrapy支持Python 3.6及以上版本。可以通过以下代码检查Python环境是否已安装：
```
python --version
```
打开命令行工具，输入以下命令安装Scrapy：
```
pip install scrapy
```
创建一个Scrapy项目：
```
scrapy startproject myproject
```
进入项目目录：
```
cd myproject
```
创建一个新的爬虫。例如，创建一个名为my_spider的爬虫，并启动它：
```
scrapy genspider my_spider example.com
scrapy crawl my_spider
```

通过以上步骤，可以成功安装Scrapy环境并创建一个基本的项目结构。

Scrapy中间件基础

中间件的概念

在Scrapy中，中间件（Middleware）是位于请求处理流程中的钩子点，可以在请求发送之前和响应返回之后进行处理。中间件可以拦截请求和响应，用于实现各种功能，如请求重试、数据转换、日志记录等。这些中间件不仅可以增强Scrapy的功能，还可以灵活地修改爬虫的行为。

Scrapy中间件的作用

Scrapy中间件的主要作用包括：

拦截请求：在请求发送之前进行处理和修改。
拦截响应：在响应返回后进行处理和修改。
处理异常：在请求或响应处理过程中捕获异常。
数据转换：对获取的数据进行预处理或转换。
日志记录：记录请求或响应的详细信息。

这些功能使开发者能够在不修改爬虫逻辑的情况下，灵活地增强爬虫的功能。

中间件的分类

Scrapy中间件可以分为以下几类：

请求中间件（Request Middleware）：处理request对象，可以修改请求的参数、设置请求头等。
响应中间件（Response Middleware）：处理response对象，可以修改响应的内容或处理异常。
爬虫中间件（Spider Middleware）：处理与爬虫相关的信号，例如在爬虫开始或结束时进行操作，或者在数据处理过程中进行干预。

每种中间件类型都提供了相应的API，用于处理特定类型的对象。通过这些中间件，开发者可以增强Scrapy的处理能力，实现复杂的数据抓取任务。

了解Scrapy爬虫中间件

请求中间件(Request Middleware)

请求中间件主要用于在发送请求之前对其进行处理。这可以包括修改请求的参数、设置请求头、添加或修改cookies等。以下是一个简单的请求中间件示例：

定义中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，覆盖process_request方法，用于处理请求。

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        # 在这里对请求进行处理
        print(f"Processing request for: {request.url}")
        return request

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyRequestMiddleware': 543,
}

响应中间件(Response Middleware)

响应中间件用于处理HTTP响应。这可以包括修改响应的内容、添加或修改cookies等。以下是一个简单的响应中间件示例：

定义中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，覆盖process_response方法，用于处理响应。

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyResponseMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_response(self, request, response, spider):
        # 在这里对响应进行处理
        print(f"Processing response from: {request.url}")
        return response

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyResponseMiddleware': 543,
}

爬虫中间件(Spider Middleware)

爬虫中间件用于处理与爬虫相关的信号。这可以包括在爬虫开始或结束时执行特定的操作，或者在数据处理过程中进行干预。以下是一个简单的爬虫中间件示例：

定义中间件类，继承自scrapy.spidermiddlewares.SpiderMiddleware。
在中间件类中，覆盖process_spider_output方法，用于处理爬虫输出的数据。

from scrapy import signals
from scrapy.spidermiddlewares.spider import SpiderMiddleware

class MySpiderMiddleware(SpiderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        spider_mw = cls()
        crawler.signals.connect(spider_mw.spider_opened, signals.spider_opened)
        crawler.signals.connect(spider_mw.spider_closed, signals.spider_closed)
        return spider_mw

    def spider_opened(self, spider):
        print(f"Spider '{spider.name}' has been opened.")

    def spider_closed(self, spider):
        print(f"Spider '{spider.name}' has been closed.")

    def process_spider_output(self, response, result, spider):
        # 在这里处理爬虫输出的数据
        for item in result:
            yield item

在settings.py中启用该中间件：

SPIDER_MIDDLEWARES = {
    'myproject.middlewares.MySpiderMiddleware': 543,
}

编写Scrapy爬虫中间件实例

捕捉异常请求

在一个实际的Web爬虫中，可能会遇到请求失败或响应异常的情况。通过编写一个请求中间件，可以在请求发送前捕捉这些异常，从而避免不必要的错误。以下是一个简单的请求中间件示例，用于捕捉异常请求：

定义中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，覆盖process_request方法，用于处理请求。

from scrapy import signals
from scrapy.exceptions import IgnoreRequest
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        # 捕捉异常请求
        if request.url.endswith('/invalid'):
            raise IgnoreRequest(f"Invalid request: {request.url}")
        print(f"Processing request for: {request.url}")
        return request

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyRequestMiddleware': 543,
}

自定义下载延迟

在爬虫运行过程中，可以通过设置下载延迟来控制请求的发送速率，避免对目标网站造成过大压力。通过编写一个请求中间件，可以在每次请求发送前自定义下载延迟。以下是一个简单的请求中间件示例，用于自定义下载延迟：

定义中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，覆盖process_request方法，用于设置下载延迟。

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        # 自定义下载延迟
        request.meta['download_delay'] = 2  # 设置延迟为2秒
        print(f"Processing request for: {request.url}")
        return request

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyRequestMiddleware': 543,
}

处理下载的HTTP响应

在收到HTTP响应后，可以通过编写一个响应中间件来处理响应的内容，例如修改响应的内容或添加日志信息。以下是一个简单的响应中间件示例，用于处理HTTP响应：

定义中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，覆盖process_response方法，用于处理响应。

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyResponseMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_response(self, request, response, spider):
        # 处理HTTP响应
        if response.status == 403:
            print(f"Server responded with a 403 Forbidden error: {request.url}")
        print(f"Processing response from: {request.url}")
        return response

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyResponseMiddleware': 543,
}

Scrapy中间件配置详解

中间件的启用与禁用

在Scrapy项目中，可以通过修改settings.py文件来启用或禁用中间件。中间件的启用和禁用通过字典DOWNLOADER_MIDDLEWARES或SPIDER_MIDDLEWARES来配置。以下是一个启用和禁用中间件的示例：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyRequestMiddleware': 543,  # 启用请求中间件
    'myproject.middlewares.MyResponseMiddleware': 543,  # 启用响应中间件
}
SPIDER_MIDDLEWARES = {
    'myproject.middlewares.MySpiderMiddleware': 543,  # 启用爬虫中间件
}

要禁用中间件，可以将中间件从字典中删除：

DOWNLOADER_MIDDLEWARES = {
}
SPIDER_MIDDLEWARES = {
}

中间件的顺序配置

中间件的顺序配置可以通过在字典中设置优先级来控制。优先级是一个整数，数值越小，优先级越高。在settings.py中，可以通过设置中间件的优先级来控制中间件的执行顺序。以下是一个中间件顺序配置的示例：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyRequestMiddleware': 543,  # 优先级为543
    'myproject.middlewares.MyResponseMiddleware': 544,  # 优先级为544
}
SPIDER_MIDDLEWARES = {
    'myproject.middlewares.MySpiderMiddleware': 543,  # 优先级为543
}

注意，中间件的优先级值并不是固定的，可以根据需要进行调整。例如，如果希望MyResponseMiddleware在MyRequestMiddleware之前执行，可以将其优先级设置为较小的值：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyResponseMiddleware': 542,  # 优先级为542
    'myproject.middlewares.MyRequestMiddleware': 543,  # 优先级为543
}

通过调整优先级，可以灵活地控制中间件的执行顺序，以满足不同的需求。

自定义中间件的实现

自定义中间件的实现需要创建一个新的中间件类，并覆盖相应的处理方法。以下是一个自定义请求中间件的实现示例：

创建一个新的中间件类，继承自scrapy.core.downloader.middleware.DownloaderMiddleware。
在中间件类中，实现from_crawler静态方法，用于初始化中间件。
覆盖process_request方法，用于处理请求。

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyCustomRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        cls.crawler = crawler
        return cls()

    def process_request(self, request, spider):
        # 在这里实现自定义的请求处理逻辑
        print(f"Custom processing request for: {request.url}")
        return request

在settings.py中启用该中间件：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomRequestMiddleware': 543,
}

通过以上步骤，可以实现一个自定义的请求中间件，用于处理特定的请求逻辑。

实战演练：构建一个包含中间件的Scrapy爬虫

整合所学知识

在这一部分，我们将整合所学的Scrapy中间件知识，构建一个完整的包含中间件的Scrapy爬虫。这个爬虫将从一个网站抓取数据，并通过中间件对请求和响应进行处理。以下是实现步骤：

创建Scrapy项目：

scrapy startproject my_scrapy_project
cd my_scrapy_project

定义爬虫：

在my_scrapy_project/spiders目录下创建一个新的爬虫文件example_spider.py，并定义一个爬虫类。

import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 解析响应内容
        title = response.xpath('//title/text()').get()
        print(f"Title: {title}")
        for href in response.css('a::attr(href)'):
            yield response.follow(href, self.parse)

实现中间件：

在my_scrapy_project/middlewares目录下创建一个新的中间件文件example_middleware.py，并定义请求中间件、响应中间件和爬虫中间件。

请求中间件：

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        print(f"Processing request for: {request.url}")
        return request

响应中间件：

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyResponseMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_response(self, request, response, spider):
        print(f"Processing response from: {request.url}")
        return response

爬虫中间件：

from scrapy import signals
from scrapy.spidermiddlewares.spider import SpiderMiddleware

class MySpiderMiddleware(SpiderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        spider_mw = cls()
        crawler.signals.connect(spider_mw.spider_opened, signals.spider_opened)
        crawler.signals.connect(spider_mw.spider_closed, signals.spider_closed)
        return spider_mw

    def spider_opened(self, spider):
        print(f"Spider '{spider.name}' has been opened.")

    def spider_closed(self, spider):
        print(f"Spider '{spider.name}' has been closed.")

配置中间件：

在my_scrapy_project/settings.py中启用这些中间件。

DOWNLOADER_MIDDLEWARES = {
    'my_scrapy_project.middlewares.MyRequestMiddleware': 543,
    'my_scrapy_project.middlewares.MyResponseMiddleware': 543,
}
SPIDER_MIDDLEWARES = {
    'my_scrapy_project.middlewares.MySpiderMiddleware': 543,
}

运行爬虫：

运行爬虫并观察中间件的输出。
```
scrapy crawl example
```

案例代码解析

在上一步中，我们构建了一个包含中间件的Scrapy爬虫。以下是对案例代码的详细解析：

爬虫定义：

import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 解析响应内容
        title = response.xpath('//title/text()').get()
        print(f"Title: {title}")
        for href in response.css('a::attr(href)'):
            yield response.follow(href, self.parse)

这个爬虫定义了一个名为example的爬虫，它会从http://example.com开始抓取数据。parse方法用于解析响应内容，提取标题并打印出来。同时，它会继续抓取页面中的链接。

请求中间件：

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        print(f"Processing request for: {request.url}")
        return request

这个请求中间件会在每次请求发送之前打印请求的URL，然后返回请求对象。

响应中间件：

from scrapy import signals
from scrapy.core.downloader.middleware import DownloaderMiddleware

class MyResponseMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_response(self, request, response, spider):
        print(f"Processing response from: {request.url}")
        return response

这个响应中间件会在每次接收到响应后打印响应对应的URL，然后返回响应对象。

爬虫中间件：

from scrapy import signals
from scrapy.spidermiddlewares.spider import SpiderMiddleware

class MySpiderMiddleware(SpiderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        spider_mw = cls()
        crawler.signals.connect(spider_mw.spider_opened, signals.spider_opened)
        crawler.signals.connect(spider_mw.spider_closed, signals.spider_closed)
        return spider_mw

    def spider_opened(self, spider):
        print(f"Spider '{spider.name}' has been opened.")

    def spider_closed(self, spider):
        print(f"Spider '{spider.name}' has been closed.")

这个爬虫中间件会在爬虫开始时打印爬虫已打开的消息，爬虫结束时打印爬虫已关闭的消息。

配置中间件：

DOWNLOADER_MIDDLEWARES = {
    'my_scrapy_project.middlewares.MyRequestMiddleware': 543,
    'my_scrapy_project.middlewares.MyResponseMiddleware': 543,
}
SPIDER_MIDDLEWARES = {
    'my_scrapy_project.middlewares.MySpiderMiddleware': 543,
}

在settings.py中配置了请求中间件和响应中间件，优先级都设置为543。同时配置了爬虫中间件，优先级设置为543。

通过以上步骤，我们构建了一个包含中间件的Scrapy爬虫，并通过中间件对请求和响应进行了处理。这个示例展示了如何在Scrapy中使用中间件来增强爬虫的功能。

实战技巧分享

在实际应用中，Scrapy中间件可以用于处理各种复杂的情况。以下是一些实用的技巧分享：

增强日志记录：
通过在中间件中添加日志记录，可以更好地跟踪爬虫的执行过程。例如，在请求中间件中记录每个请求的详细信息：

import logging

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        logging.info(f"Requesting URL: {request.url}")
        return request

通过这种方式，可以更容易地定位和解决问题。

处理重定向：
在某些情况下，网站可能会重定向到其他页面。可以通过响应中间件捕获这些重定向并进行处理：

class MyResponseMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_response(self, request, response, spider):
        if response.status == 302:  # 重定向状态码
            logging.info(f"Redirected to: {response.headers['location']}")
        return response

自定义错误处理：
在请求中间件中，可以对特定的HTTP错误代码进行处理，例如404或500错误：

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        if request.url.endswith('/invalid'):
            raise IgnoreRequest(f"Invalid request: {request.url}")
        print(f"Processing request for: {request.url}")
        return request

动态调整下载延迟：
通过请求中间件动态调整下载延迟，可以更好地控制爬虫的抓取速度：

class MyRequestMiddleware(DownloaderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        return cls()

    def process_request(self, request, spider):
        request.meta['download_delay'] = 2  # 设置延迟为2秒
        print(f"Processing request for: {request.url}")
        return request

增强爬虫中间件：
通过爬虫中间件，可以对爬虫的行为进行更灵活的控制。例如，在爬虫开始时设置一些全局变量：

class MySpiderMiddleware(SpiderMiddleware):
    @classmethod
    def from_crawler(cls, crawler):
        spider_mw = cls()
        crawler.signals.connect(spider_mw.spider_opened, signals.spider_opened)
        crawler.signals.connect(spider_mw.spider_closed, signals.spider_closed)
        return spider_mw

    def spider_opened(self, spider):
        spider.global_var = 'initial_value'  # 设置全局变量
        print(f"Spider '{spider.name}' has been opened.")

    def spider_closed(self, spider):
        print(f"Spider '{spider.name}' has been closed.")

通过这些技巧，可以在实际应用中更好地利用Scrapy中间件，实现更强大的功能和更灵活的控制。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

守着星空守着你

手记
篇

粉丝

39

获赞与收藏

267

关注作者，订阅最新文章

阅读免费教程

Python 原生爬虫教程

19个小节 51409 1115

Scrapy 入门教程

27个小节 10493 251

后端通用面试教程

41个小节 30583 343

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Scrapy爬虫中间件教程：新手快速入门指南

阅读免费教程