寫(xiě)文章

首頁(yè) 手記 Scrapy下載器中間件入門(mén)詳解

Scrapy下載器中間件入門(mén)詳解

標(biāo)簽：

爬蟲(chóng) 中間件

概述

Scrapy是一个功能强大的Python爬虫框架，提供了下载器中间件来处理请求和响应。这些中间件允许开发者在请求发出前或响应返回后执行自定义操作，增强爬虫的灵活性和可扩展性。通过配置和编写中间件，开发者可以实现如请求头修改、代理设置、错误处理等多种功能。

Scrapy框架概述

Scrapy 是一个用于爬取网站数据，提取结构性数据并保存的 Python 库。它是一款高度可扩展的爬虫框架，其功能强大、使用灵活、易于扩展，广泛应用于数据采集和网络爬虫领域。Scrapy 提供了一系列抽象和组件，允许开发者专注于数据处理的各个阶段，如请求发起、响应解析、数据提取和存储。Scrapy 的架构具有高度的模块化，使得开发者可以轻松地添加自定义组件以满足特定需求。

Scrapy 的核心组件包括调度器、下载器、下载器中间件、解析器、数据管道和蜘蛛中间件。调度器负责管理待抓取的 URL 列表，下载器负责发起网络请求并获取响应，下载器中间件可以对请求或响应进行预处理或后处理，解析器负责解析响应数据以获取所需信息，数据管道负责将提取的数据保存到指定的存储系统，蜘蛛中间件则提供了与蜘蛛（Spider）交互的扩展接口。

Scrapy 的主要优点包括：

异步 IO：Scrapy 使用异步 IO 机制进行网络通信，使得爬虫在等待网络响应时不会阻塞，从而提高了整体性能。
强大的蜘蛛：Scrapy 蜘蛛允许开发者定义 URL 模板和回调函数，以实现高效的数据提取。
强大的下载器中间件：Scrapy 提供了下载器中间件，允许开发者在请求发出或响应返回时对其进行处理。
高度可扩展：Scrapy 的架构允许开发者轻松添加自定义组件，以实现特定功能或优化性能。
内置支持多种数据存储：Scrapy 内置了多种数据存储的支持，开发者可以轻松地将爬取的数据保存到数据库或文件中。

Scrapy 不仅适用于简单的数据抓取任务，也适用于复杂的网络爬虫项目。开发者可以利用 Scrapy 灵活的架构和丰富的 API，快速构建高效、可扩展的网络爬虫。

Scrapy下载器中间件的作用及应用场景

Scrapy 下载器中间件的主要目的是提供一个扩展点，用于在发送请求之前或接收到响应之后执行自定义操作。这种机制允许开发者对请求和响应进行预处理或后处理，从而实现更灵活的数据抓取和处理流程。下载器中间件通常用于以下场景：

请求头的修改：在发送请求之前，下载器中间件可以修改请求的头信息，例如添加或修改 User-Agent、Cookie 等信息，以实现伪装或身份验证功能。
代理设置：下载器中间件可以动态设置或修改请求的代理信息，例如使用 IP 代理池来代理请求，以避免网络请求被目标站点屏蔽。
错误处理和数据清洗：下载器中间件可以在接收到响应后进行错误检查或数据清洗，以确保后续处理的数据质量。例如，中间件可以检查响应状态码，过滤无效响应，或对响应内容进行预处理。
注入日志信息：下载器中间件可以用于记录请求和响应信息，以便调试和分析爬虫的运行状况。
请求和响应的过滤：下载器中间件可以对请求和响应进行过滤或修改，例如，过滤掉不需要处理的请求或响应，或者对响应内容进行特定的处理。

这些功能使得下载器中间件成为 Scrapy 框架中不可或缺的一部分，它增强了爬虫的灵活性和可扩展性，使得开发者能够更方便地处理各种复杂的网络数据抓取任务。

Scrapy下载器中间件的工作流程

Scrapy 下载器中间件的工作流程包括请求发出前的预处理和响应返回后的后处理两个阶段。这些阶段通过一系列的中间件函数来实现，这些函数按照特定的顺序执行，提供了高度的灵活性和可扩展性。

请求发出前的预处理阶段

process_request 方法：在请求发出前，Scrapy 会依次调用所有已注册的中间件的 process_request 方法。这些方法可以修改请求、调整请求头、设置代理，甚至可以决定是否继续发送请求或短路处理（例如，返回 None 表示直接发送请求，或返回 Response 对象表示拦截请求并返回响应）。
- 返回值：如果 process_request 方法返回 None，则表示请求继续被发送。如果返回一个 Response 对象，则表示请求被拦截，并且返回的响应将被直接传递给下游处理逻辑。如果返回一个 Request 对象，则会重新发起新的请求，代替原来的请求。如果抛出 IgnoreRequest 异常，则表示该请求将被忽略。
- 示例代码：
```
class MyCustomDownloaderMiddleware:
 def process_request(self, request, spider):
     # 修改请求头
     request.headers['User-Agent'] = 'My Custom User-Agent'
     # 或者
     request.meta['proxy'] = 'http://proxy.example.com:8080'

     # 如果返回 None，继续发送请求
     return None
     # 如果返回 Response 对象，拦截请求并返回响应
     return Response(url=request.url, status=200, body=b'Hello, World!')

     # 如果返回 Request 对象，重新发起请求
     return Request(url='http://example.com', method='GET')
```

响应返回后的后处理阶段

process_response 方法：当响应返回后，Scrapy 会依次调用所有已注册的中间件的 process_response 方法。这些方法可以修改响应数据，执行错误检查，甚至实现响应级别的日志记录。

返回值：如果 process_response 方法返回一个 Response 对象，表示响应将被传递给下一个中间件继续处理，或传递给蜘蛛的回调函数进行解析。如果抛出 IgnoreRequest 异常，则表示该请求将被忽略。

示例代码：

class MyCustomDownloaderMiddleware:
 def process_response(self, request, response, spider):
     # 修改响应内容
     response.body = b'Hello, modified content!'

     # 返回修改后的响应，继续传递给下一个中间件或蜘蛛的回调函数
     return response
     # 如果需要重新发送请求，可以返回新的 Request 对象
     return Request(url=response.url)

     # 如果需要忽略请求，可以抛出 IgnoreRequest 异常
     raise IgnoreRequest()

process_exception 方法：如果请求过程遇到异常，Scrapy 会调用中间件的 process_exception 方法来处理这些异常。这个方法可以捕获异常并进行相应的处理，例如重新发送请求或返回一个错误响应。
- 返回值：如果 process_exception 方法返回一个 Response 对象或 Request 对象，表示异常被处理，相应的响应或请求将被传递给下一个中间件或蜘蛛的回调函数。如果返回 None，则表示不进行任何处理，异常将被传递给下一个中间件。如果抛出 IgnoreRequest 异常，则表示该请求将被忽略。
- 示例代码：
```
class MyCustomDownloaderMiddleware:
 def process_exception(self, request, exception, spider):
     # 捕获异常
     print(f'Exception for {request.url}: {exception}')

     # 重新发送请求
     return Request(url=request.url)

     # 返回错误响应
     return Response(url=request.url, status=500, body=b'Internal Server Error')

     # 如果不进行处理，返回 None
     return None

     # 如果需要忽略请求，抛出 IgnoreRequest 异常
     raise IgnoreRequest()
```

中间件执行顺序

每个中间件都有一个特定的顺序，该顺序决定了它们如何相互交互。在 Scrapy 的配置文件（通常是 settings.py）中，可以通过设置 DOWNLOADER_MIDDLEWARES 字典来指定中间件的顺序。例如：

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
    'myproject.middlewares.AnotherMiddleware': 540,
}

这里的数字是优先级值，数值越小的中间件优先级越高，先执行。例如，上面的例子中，MyCustomDownloaderMiddleware 的优先级低于 AnotherMiddleware，因此 AnotherMiddleware 的 process_request 方法会在 MyCustomDownloaderMiddleware 的 process_request 方法之前执行。

中间件类的完整定义

以下是一个完整的中间件类定义，包括 from_crawler 方法：

class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 修改请求头
        request.headers['User-Agent'] = 'My Custom User-Agent'
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        return response

    def process_exception(self, request, exception, spider):
        # 捕获异常并重新发送请求
        print(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

总结来说，Scrapy 下载器中间件提供了丰富的机制来处理请求和响应，使得开发者可以灵活地实现各种数据抓取和处理任务。通过配置中间件的顺序，可以控制中间件的执行顺序和优先级。

Scrapy下载器中间件的安装与配置

环境搭建与依赖安装

要使用 Scrapy 下载器中间件，首先需要在本地环境中安装 Scrapy 和其相关依赖。以下是安装步骤：

安装 Python 环境：确保已经安装了 Python 3.x 版本。可以通过 Python 官方网站下载并安装最新的 Python 版本。安装完成后，可以在命令行中输入 python --version 或 python3 --version 来验证 Python 版本。
安装 Scrapy：使用 pip 工具安装 Scrapy。打开命令行或终端，输入以下命令：
```
pip install scrapy
```
此命令会安装 Scrapy 及其所有依赖项，包括 Twisted（一个事件驱动的网络框架）、lxml（用于 XML 和 HTML 解析）、parsel（用于解析 HTML 和 XML）等。
创建 Scrapy 项目：安装完成后，可以使用 scrapy startproject 命令来创建一个新的 Scrapy 项目。例如：
```
scrapy startproject myproject
```
这个命令会创建一个名为 myproject 的文件夹，并在其中生成一系列文件和目录结构。这些文件和目录包括 settings.py、items.py、spiders 目录等，它们是 Scrapy 项目的标准组成部分。
安装 Scrapy 依赖扩展：某些情况下，可能需要额外的扩展或第三方库来增强 Scrapy 的功能，例如 scrapy-redis（用于分布式爬虫）或 scrapy-proxies（用于代理池）。这些库可以通过 pip 安装：
```
pip install scrapy-redis
pip install scrapy-proxies
```
配置环境变量：根据需要，可能还需要配置环境变量来指定某些依赖或配置。例如，可以配置 SCRAPY_SETTINGS_MODULE 来指定 Scrapy 设置文件的位置。

以下是一个完整的安装和配置脚本示例：

# 安装 Python
# Python 3.x 安装省略

# 安装 Scrapy
pip install scrapy

# 创建 Scrapy 项目
scrapy startproject myproject

# 安装 Scrapy 扩展
pip install scrapy-redis
pip install scrapy-proxies

# 配置环境变量（根据需要修改）
export SCRAPY_SETTINGS_MODULE=myproject.settings

通过上述步骤，就可以成功搭建一个 Scrapy 爬虫开发环境，并安装了所有必要的依赖。

Scrapy项目初始化与中间件配置方法

在 Scrapy 项目初始化完成后，需要配置下载器中间件以实现具体的功能。以下是配置步骤和方法的详细说明：

项目文件结构

Scrapy 项目通常包含以下文件和目录：

myproject/: 项目的根目录。
- myproject/settings.py: 项目的配置文件。
- myproject/items.py: 定义用于存储爬取数据的容器类。
- myproject/spiders/: 存放爬虫文件的目录。
- myproject/pipelines.py: 定义数据处理管道的文件。
- myproject/middlewares.py: 定义下载器中间件的文件。
- myproject/: 其他项目相关文件和目录。

配置中间件

下载器中间件的配置主要在 settings.py 文件中进行。要启用和配置中间件，需要编辑 settings.py 文件，并在其中设置 DOWNLOADER_MIDDLEWARES 字典。例如：

定义中间件类：在 myproject/middlewares.py 文件中定义一个下载器中间件类。例如：

# myproject/middlewares.py
from scrapy import signals
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 修改请求头
        request.headers['User-Agent'] = 'My Custom User-Agent'
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Hello, modified content!'
        return response

    def process_exception(self, request, exception, spider):
        # 捕获异常并重新发送请求
        print(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

配置中间件：在 settings.py 文件中设置 DOWNLOADER_MIDDLEWARES 字典，指定要使用的中间件及其优先级。例如：
```
# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 800,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 900,
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 1000,
    'myproject.middlewares.AnotherMiddleware': 540,
}
```
这里，DOWNLOADER_MIDDLEWARES 字典中的键是中间件类的完整路径，值是中间件的优先级。优先级数值越小，优先级越高。例如，MyCustomDownloaderMiddleware 的优先级为 500，而 HttpCompressionMiddleware 的优先级为 800。按照优先级顺序，MyCustomDownloaderMiddleware 会在 HttpCompressionMiddleware 之前执行。

启用中间件

要启用下载器中间件，必须在 settings.py 文件中正确配置 DOWNLOADER_MIDDLEWARES 字典。确保中间件类的路径是正确的，并且优先级值是合理的。一旦配置完毕，运行 Scrapy 项目时，Scrapy 会自动调用这些中间件中的方法来处理请求和响应。

配置示例

以下是一个完整的配置示例，展示了如何在 settings.py 文件中配置多个中间件及其优先级：

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 800,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 900,
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 1000,
    'myproject.middlewares.AnotherMiddleware': 540,
    'scrapy_proxies.RandomProxy': 700,
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
}

在这个示例中，除了自定义的 MyCustomDownloaderMiddleware 和 AnotherMiddleware，还配置了 Scrapy 内置的中间件，如 HttpCompressionMiddleware 和 UserAgentMiddleware。此外，还添加了一个来自第三方库 scrapy-proxies 的 RandomProxy 中间件，用于实现动态代理。

通过以上步骤，可以成功地配置和启用 Scrapy 下载器中间件。这些配置使 Scrapy 能够根据需要灵活处理请求和响应，从而实现更强大的网络爬虫功能。

编写简单的Scrapy下载器中间件

中间件类定义

编写 Scrapy 下载器中间件的第一步是定义中间件类。中间件类通常定义在项目的 myproject/middlewares.py 文件中。以下是定义一个简单的中间件类的基本步骤：

继承合适的类：通常，中间件类不直接继承任何特定的父类，而是实现一些特定的方法。这些方法将被 Scrapy 调用来处理请求和响应。
实现必要方法：中间件类通常需要实现以下三个方法：
- process_request：在请求发出之前调用，可以修改请求或决定是否继续发送请求。
- process_response：在接收到响应之后调用，可以修改响应或决定如何处理响应。
- process_exception：在请求过程中发生异常时调用，可以捕获异常并进行相应处理。
注册中间件类：确保中间件类被正确注册到 settings.py 文件中的 DOWNLOADER_MIDDLEWARES 字典中，以便 Scrapy 能够调用这些方法。

以下是一个简单的中间件类示例：

# myproject/middlewares.py
class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 添加一个自定义请求头
        request.headers['Custom-Header'] = 'My Custom Value'
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        # 继续处理响应
        return response

    def process_exception(self, request, exception, spider):
        # 捕获异常并返回一个新的请求
        print(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

中间件方法详解

process_request 方法：

输入参数：
- request：待处理的请求对象。
- spider：发起请求的 Spider 对象。
返回值：
- None：表示继续发送请求。
- Response 对象：表示拦截请求并直接返回响应。
- Request 对象：表示重新发送一个请求。
- IgnoreRequest 异常：表示忽略请求。

示例：

def process_request(self, request, spider):
 # 修改请求头
 request.headers['User-Agent'] = 'My Custom User-Agent'
 # 继续处理请求
 return None
 # 如果需要返回一个响应
 return Response(url=request.url, status=200, body=b'Custom Response')
 # 如果需要重新发送请求
 return Request(url='http://example.com')

process_response 方法：
- 输入参数：
  - request：发起该响应的请求对象。
  - response：接收到的响应对象。
  - spider：发起请求的 Spider 对象。
- 返回值：
  - Response 对象：表示修改响应并继续处理。
  - IgnoreRequest 异常：表示忽略请求。
- 示例：
```
def process_response(self, request, response, spider):
 # 修改响应内容
 response.body = b'Modified response content'
 # 继续处理响应
 return response
```
process_exception 方法：
- 输入参数：
  - request：发生异常的请求对象。
  - exception：捕获到的异常对象。
  - spider：发起请求的 Spider 对象。
- 返回值：
  - Response 对象：表示返回一个响应。
  - IgnoreRequest 异常：表示忽略请求。
  - None：表示不进行处理。
- 示例：
```
def process_exception(self, request, exception, spider):
 # 捕获异常并重新发送请求
 print(f'Exception for {request.url}: {exception}')
 return Request(url=request.url)
```

注册中间件类

为了使中间件类生效，需要在 settings.py 文件中将该类注册到 DOWNLOADER_MIDDLEWARES 字典中。例如：

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 800,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 900,
}

演示代码

以下是完整的中间件类定义和注册示例：

# myproject/middlewares.py
from scrapy import signals
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 添加一个自定义请求头
        request.headers['Custom-Header'] = 'My Custom Value'
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        # 继续处理响应
        return response

    def process_exception(self, request, exception, spider):
        # 捕获异常并返回一个新的请求
        print(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 800,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 900,
}

通过上述步骤，可以成功定义并注册一个简单的 Scrapy 下载器中间件类。这些类可以在 request 发出和 response 返回时执行自定义逻辑，从而增强 Scrapy 爬虫的功能。

中间件实例

以下是一个具体的中间件实例，展示了如何在请求发出前修改请求头，并在接收到响应后修改响应内容：

# myproject/middlewares.py
class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 添加一个自定义请求头
        request.headers['Custom-Header'] = 'My Custom Value'
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        # 继续处理响应
        return response

在 settings.py 文件中注册中间件：

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
}

通过定义和注册上述中间件类，可以在请求发出前添加自定义请求头，并在接收到响应后修改响应内容。这使得 Scrapy 爬虫能够灵活处理请求和响应，从而实现更复杂的数据抓取和处理任务。

编写中间件的基本方法

在定义中间件类时，需要实现三个基本方法：process_request、process_response 和 process_exception。这些方法的实现决定了中间件如何处理请求和响应，以及如何处理异常情况。

`process_request` 方法

process_request 方法是在请求发出之前被调用的，主要用于修改请求或决定是否发送请求。以下是该方法的详细说明：

参数：
- request：待处理的请求对象。
- spider：发起请求的 Spider 对象。
返回值：
- None：表示继续发送请求。
- Response 对象：表示拦截请求并直接返回响应。
- Request 对象：表示重新发送一个请求。
- IgnoreRequest 异常：表示忽略请求。

示例代码：

def process_request(self, request, spider):
 # 修改请求头
 request.headers['User-Agent'] = 'My Custom User-Agent'
 # 继续处理请求
 return None

 # 如果需要返回一个响应
 return Response(url=request.url, status=200, body=b'Custom Response')

 # 如果需要重新发送请求
 return Request(url='http://example.com')

`process_response` 方法

process_response 方法是在接收到响应之后被调用的，主要用于修改响应或决定如何处理响应。以下是该方法的详细说明：

参数：
- request：发起该响应的请求对象。
- response：接收到的响应对象。
- spider：发起请求的 Spider 对象。
返回值：
- Response 对象：表示修改响应并继续处理。
- IgnoreRequest 异常：表示忽略请求。

示例代码：

def process_response(self, request, response, spider):
 # 修改响应内容
 response.body = b'Modified response content'
 # 继续处理响应
 return response

`process_exception` 方法

process_exception 方法是在请求过程中发生异常时被调用的，主要用于捕获异常并进行相应的处理。以下是该方法的详细说明：

参数：
- request：发生异常的请求对象。
- exception：捕获到的异常对象。
- spider：发起请求的 Spider 对象。
返回值：
- Response 对象：表示返回一个响应。
- IgnoreRequest 异常：表示忽略请求。
- None：表示不进行处理。

示例代码：

def process_exception(self, request, exception, spider):
 # 捕获异常并重新发送请求
 print(f'Exception for {request.url}: {exception}')
 return Request(url=request.url)

中间件实例

以下是一个具体的中间件实例，展示了如何在请求发出前修改请求头，并在接收到响应后修改响应内容：

# myproject/middlewares.py
from scrapy import signals
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class MyCustomDownloaderMiddleware:
    def __init__(self):
        self.logger = logging.getLogger(__name__)

    def process_request(self, request, spider):
        # 添加一个自定义请求头
        request.headers['Custom-Header'] = 'My Custom Value'
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        # 继续处理响应
        return response

    def process_exception(self, request, exception, spider):
        # 捕获异常并返回一个新的请求
        print(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

在 settings.py 文件中注册中间件：

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
}

通过定义和注册上述中间件类，可以在请求发出前添加自定义请求头，并在接收到响应后修改响应内容。这使得 Scrapy 爬虫能够灵活处理请求和响应，从而实现更复杂的数据抓取和处理任务。

Scrapy下载器中间件的高级技巧

Scrapy 下载器中间件提供了许多高级功能，使得开发者能够更灵活地处理请求和响应。以下是一些常见的高级技巧：

中间件顺序设置

设置中间件顺序：可以通过 DOWNLOADER_MIDDLEWARES 字典中的优先级值来控制中间件的执行顺序。优先级数值越小，优先级越高，先执行。例如：
```
DOWNLOADER_MIDDLEWARES = {
  'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
  'myproject.middlewares.AnotherMiddleware': 540,
}
```
在上述配置中，MyCustomDownloaderMiddleware 的优先级低于 AnotherMiddleware，因此 AnotherMiddleware 的 process_request 方法会在 MyCustomDownloaderMiddleware 的 process_request 方法之前执行。

中间件与Pipeline的配合使用

中间件与Pipeline的协同：在某些场景下，中间件可以配合 Pipeline 使用。例如，在中间件中修改请求或响应后，Pipeline 可以进一步处理数据。例如：

# myproject/middlewares.py
class MyCustomDownloaderMiddleware:
  def process_request(self, request, spider):
      # 修改请求头
      request.headers['Custom-Header'] = 'My Custom Value'
      return None

  def process_response(self, request, response, spider):
      # 修改响应内容
      response.body = b'Hello, modified content!'
      return response

# myproject/pipelines.py
class MyCustomPipeline:
  def process_item(self, item, spider):
      # 处理数据
      return item

自定义扩展Scrapy功能

自定义扩展：除了内置的中间件和 Pipeline，开发者还可以自定义中间件和 Pipeline 来扩展 Scrapy 的功能。例如，可以创建一个中间件来实现 IP 代理池的动态轮换：

# myproject/middlewares.py
import random
from scrapy.http import Request
from scrapy.exceptions import IgnoreRequest

class DynamicProxyMiddleware:
  def __init__(self):
      self.proxies = ['http://proxy1.example.com:8080', 'http://proxy2.example.com:8080']

  def process_request(self, request, spider):
      # 动态选择代理
      request.meta['proxy'] = random.choice(self.proxies)
      return None

  def process_response(self, request, response, spider):
      # 检查代理状态
      if 'proxy_error' in response.text:
          print(f'Proxy {request.meta["proxy"]} is not working')
          raise IgnoreRequest()
      return response

请求和响应的自定义处理

自定义请求和响应处理：中间件可以用于请求和响应的自定义处理，例如在请求发出前修改请求头、在响应返回后修改响应内容。例如：

# myproject/middlewares.py
class CustomRequestMiddleware:
  def process_request(self, request, spider):
      # 修改请求头
      request.headers['User-Agent'] = 'My Custom User-Agent'
      return None

  def process_response(self, request, response, spider):
      # 修改响应内容
      response.body = b'Modified response content'
      return response

通过上述高级技巧，可以进一步提高 Scrapy 爬虫的灵活性和可扩展性，使得开发者能够更好地处理复杂的网络数据抓取任务。

Scrapy下载器中间件的常见应用场景

Scrapy 下载器中间件在实际应用中扮演着重要的角色，通过中间件的灵活配置可以实现多种功能，例如请求头修改、代理池管理、请求和响应的自定义处理等。以下是几个常见的应用场景及其具体实现方法。

请求头、代理设置

请求头修改

请求头的修改可以用于伪装、身份验证、定制请求行为等多种场景。以下是一个示例，展示了如何在请求发出前修改 User-Agent 和 Cookie 请求头：

# myproject/middlewares.py
class MyCustomDownloaderMiddleware:
    def process_request(self, request, spider):
        # 修改请求头
        request.headers['User-Agent'] = 'My Custom User-Agent'
        request.headers['Cookie'] = 'my_cookie_value'
        # 继续处理请求
        return None

使用代理池

代理设置可以帮助爬虫规避 IP 封禁，提高抓取效率。以下是一个示例，展示了如何在请求发出前动态设置代理信息：

# myproject/middlewares.py
import random
from scrapy.http import Request

class ProxyMiddleware:
    def __init__(self):
        self.proxies = ['http://proxy1.example.com:8080', 'http://proxy2.example.com:8080']

    def process_request(self, request, spider):
        # 动态设置代理信息
        request.meta['proxy'] = random.choice(self.proxies)
        # 继续处理请求
        return None

IP代理池的管理

IP 代理池的管理可以通过中间件来实现动态代理轮换和代理状态监控。以下是一个示例，展示了如何动态选择代理 IP 并记录代理状态：

# myproject/middlewares.py
import random
from scrapy.exceptions import IgnoreRequest

class DynamicProxyMiddleware:
    def __init__(self):
        self.proxies = ['http://proxy1.example.com:8080', 'http://proxy2.example.com:8080']

    def process_request(self, request, spider):
        # 动态选择代理
        request.meta['proxy'] = random.choice(self.proxies)
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 检查代理状态
        if 'proxy_error' in response.text:
            print(f'Proxy {request.meta["proxy"]} is not working')
            raise IgnoreRequest()
        # 继续处理响应
        return response

请求和响应的自定义处理

响应状态码检查

在接收到响应后，可以通过检查响应的状态码来决定如何处理响应。例如，可以过滤掉非 200 状态码的响应：

# myproject/middlewares.py
class StatusCodeMiddleware:
    def process_response(self, request, response, spider):
        # 检查响应状态码
        if response.status != 200:
            print(f'Ignoring response {response.url} due to status code {response.status}')
            raise IgnoreRequest()
        # 继续处理响应
        return response

数据预处理和清洗

可以在响应返回后对数据进行预处理或清洗，以便后续处理。例如，可以去掉响应中的某些部分：

# myproject/middlewares.py
class DataCleaningMiddleware:
    def process_response(self, request, response, spider):
        # 清洗响应数据
        response.body = response.body.replace(b'old_text', b'new_text')
        # 继续处理响应
        return response

响应内容修改

可以在响应返回后修改响应内容，例如，替换某些文本内容：

# myproject/middlewares.py
class ContentModificationMiddleware:
    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = response.body.replace(b'old_text', b'new_text')
        # 继续处理响应
        return response

响应编码修改

有些网页使用了非标准的编码，可以通过中间件来修改响应的编码：

# myproject/middlewares.py
class EncodingMiddleware:
    def process_response(self, request, response, spider):
        # 修改响应编码
        response.encoding = 'utf-8'
        # 继续处理响应
        return response

通过上述示例，可以看出 Scrapy 下载器中间件在请求头、代理设置、代理池管理、请求和响应自定义处理等方面的应用场景。这些功能使得 Scrapy 爬虫能够应对各种网络抓取需求，提高抓取质量和效率。

中间件实例

以下是一个具体的中间件实例，展示了如何在请求发出前修改请求头，并在接收到响应后修改响应内容：

# myproject/middlewares.py
class MyCustomDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        # 使用 from_crawler 构造函数来获取 crawler 对象
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 添加一个自定义请求头
        request.headers['Custom-Header'] = 'My Custom Value'
        # 继续处理请求
        return None

    def process_response(self, request, response, spider):
        # 修改响应内容
        response.body = b'Modified response content'
        # 继续处理响应
        return response

在 settings.py 文件中注册中间件：

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.MyCustomDownloaderMiddleware': 500,
}

通过定义和注册上述中间件类，可以在请求发出前添加自定义请求头，并在接收到响应后修改响应内容。这使得 Scrapy 爬虫能够灵活处理请求和响应，从而实现更复杂的数据抓取和处理任务。

Scrapy下载器中间件的调试与错误处理

Scrapy 下载器中间件的调试与错误处理是保证爬虫稳定运行的重要环节。通过对中间件进行调试，可以更好地理解其工作流程和行为。同时，正确的错误处理机制可以提高爬虫的健壮性，避免因异常导致爬虫中断。

使用日志记录中间件行为

日志记录是调试中间件行为的有效工具。Scrapy 提供了丰富的日志记录功能，可以通过配置日志级别和输出来记录中间件的行为。以下是一些常用的日志记录方法：

配置日志级别

在 settings.py 文件中设置日志级别，可以控制记录的日志详细程度。例如，设置为 DEBUG 级别可以记录详细的日志信息：

# myproject/settings.py
LOG_LEVEL = 'DEBUG'

自定义日志记录

在中间件类中，可以通过调用 logging 模块来记录日志信息。例如：

import logging
from scrapy import signals
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class MyCustomDownloaderMiddleware:
    def __init__(self):
        self.logger = logging.getLogger(__name__)

    def process_request(self, request, spider):
        self.logger.debug(f'Request URL: {request.url}')
        request.headers['Custom-Header'] = 'My Custom Value'
        return None

    def process_response(self, request, response, spider):
        self.logger.debug(f'Response status: {response.status}')
        response.body = b'Modified response content'
        return response

    def process_exception(self, request, exception, spider):
        self.logger.error(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

日志示例

以下是一个完整的中间件类示例，展示了如何在请求和响应处理过程中记录日志信息：

# myproject/middlewares.py
import logging
from scrapy import signals
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class MyCustomDownloaderMiddleware:
    def __init__(self):
        self.logger = logging.getLogger(__name__)

    def process_request(self, request, spider):
        self.logger.debug(f'Request URL: {request.url}')
        request.headers['Custom-Header'] = 'My Custom Value'
        return None

    def process_response(self, request, response, spider):
        self.logger.debug(f'Response status: {response.status}')
        response.body = b'Modified response content'
        return response

    def process_exception(self, request, exception, spider):
        self.logger.error(f'Exception for {request.url}: {exception}')
        return Request(url=request.url)

通过上述日志记录方法，可以清晰地看到中间件在请求和响应处理中的行为，帮助进行调试和故障排查。

常见错误排查与解决方法

在使用 Scrapy 下载器中间件时，可能会遇到各种常见错误。以下是一些典型的错误及其解决方法：

`process_request` 方法返回错误类型

错误说明：process_request 方法如果返回了一个非预期的类型（如返回了 IgnoreRequest 对象而不是 None 或 Request 对象），会导致 Scrapy 报错。
解决方法：确保 process_request 方法的返回值正确，可能的返回值包括 None、Request 对象或 Response 对象。

`process_response` 方法返回错误类型

错误说明：process_response 方法如果返回了一个非预期的类型（如返回了 IgnoreRequest 对象而不是 None 或 Response 对象），会导致 Scrapy 报错。
解决方法：确保 process_response 方法的返回值正确，可能的返回值包括 None 或 Response 对象。

`process_exception` 方法返回错误类型

错误说明：process_exception 方法如果返回了一个非预期的类型（如返回了 IgnoreRequest 对象而不是 None 或 Request 对象），会导致 Scrapy 报错。
解决方法：确保 process_exception 方法的返回值正确，可能的返回值包括 None、Request 对象或 Response 对象。

日志错误

错误说明：如果在日志中看到与中间件相关的错误信息，可能是因为日志配置不正确或日志级别设置不当。
解决方法：检查 settings.py 文件中的日志配置，确保日志级别设置正确，并且日志输出路径和格式正确。

其他常见错误

错误说明：其他常见的错误包括中间件顺序设置错误、中间件类未正确注册、依赖库版本不兼容等。
解决方法：检查 DOWNLOADER_MIDDLEWARES 字典中的顺序是否正确，确保中间件类路径正确，依赖库版本与 Scrapy 兼容。

中间件的单元测试方法

为了确保中间件的正确性和健壮性，可以编写单元测试来验证中间件的行为。以下是一个单元测试示例，使用 unittest 模块来测试中间件的 process_request 方法：

# myproject/tests/test_middlewares.py
import unittest
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class TestMyCustomDownloaderMiddleware(unittest.TestCase):
    def setUp(self):
        from myproject.middlewares import MyCustomDownloaderMiddleware
        self.middleware = MyCustomDownloaderMiddleware()

    def test_process_request(self):
        request = Request(url='http://example.com')
        result = self.middleware.process_request(request, None)
        self.assertIsNone(result)
        self.assertIn(b'Custom-Header', request.headers)

    def test_process_response(self):
        response = Response(url='http://example.com', status=200, body=b'Original content')
        result = self.middleware.process_response(request, response, None)
        self.assertEqual(result.body, b'Modified response content')

    def test_process_exception(self):
        request = Request(url='http://example.com')
        result = self.middleware.process_exception(request, Exception('Some exception'), None)
        self.assertIsInstance(result, Request)

测试示例

以下是一个完整的单元测试示例，展示了如何测试中间件的行为：

# myproject/tests/test_middlewares.py
import unittest
from scrapy.http import Request, Response
from scrapy.exceptions import IgnoreRequest

class TestMyCustomDownloaderMiddleware(unittest.TestCase):
    def setUp(self):
        from myproject.middlewares import MyCustomDownloaderMiddleware
        self.middleware = MyCustomDownloaderMiddleware()

    def test_process_request(self):
        request = Request(url='http://example.com')
        result = self.middleware.process_request(request, None)
        self.assertIsNone(result)
        self.assertIn(b'Custom-Header', request.headers)

    def test_process_response(self):
        response = Response(url='http://example.com', status=200, body=b'Original content')
        result = self.middleware.process_response(request, response, None)
        self.assertEqual(result.body, b'Modified response content')

    def test_process_exception(self):
        request = Request(url='http://example.com')
        result = self.middleware.process_exception(request, Exception('Some exception'), None)
        self.assertIsInstance(result, Request)

通过编写单元测试，可以确保中间件在不同条件下能够正确处理请求和响应，并且不会抛出异常。这些测试可以作为持续集成的一部分，确保代码的稳定性和可维护性。

點(diǎn)擊查看更多內(nèi)容

為 TA 點(diǎn)贊

若覺(jué)得本文不錯(cuò)，就分享一下吧！

評(píng)論

評(píng)論

共同學(xué)習(xí)，寫(xiě)下你的評(píng)論

評(píng)論加載中...

展開(kāi)查看更多評(píng)論

作者其他優(yōu)質(zhì)文章

正在加載中

蠱毒傳說(shuō)

手記
篇

粉絲

18

獲贊與收藏

84

關(guān)注作者，訂閱最新文章

閱讀免費(fèi)教程

Python 原生爬蟲(chóng)教程

19個(gè)小節(jié) 55156 1188

Scrapy 入門(mén)教程

27個(gè)小節(jié) 11097 266

后端通用面試教程

41個(gè)小節(jié) 32194 359

推薦

評(píng)論

收藏

共同學(xué)習(xí)，寫(xiě)下你的評(píng)論



感謝您的支持，我會(huì)繼續(xù)努力的～

掃碼打賞，你說(shuō)多少就多少

贊賞金額會(huì)直接到老師賬戶

支付方式

打開(kāi)微信掃一掃，即可進(jìn)行掃碼打賞哦

今天注冊(cè)有機(jī)會(huì)得

100積分直接送

付費(fèi)專欄免費(fèi)學(xué)

大額優(yōu)惠券免費(fèi)領(lǐng)

立即參與放棄機(jī)會(huì)

點(diǎn)擊
抽獎(jiǎng)

慕課手記新用戶專享福利

恭喜你，你的運(yùn)氣太好了，居然抽中了 100個(gè)積分！

恭喜你，抽中了價(jià)值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標(biāo)、機(jī)械鍵盤(pán)、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優(yōu)惠券
在等著你去兌換了噢

作者：

免費(fèi)贈(zèng)送

兌換碼：1111222211 復(fù)制

優(yōu)惠券可用于購(gòu)買實(shí)戰(zhàn)課、體系課
無(wú)門(mén)檻使用

先去看看，有什么好東西馬上兌換


第七色在线视频,2021少妇久久久久久久久久,亚洲欧洲精品成人久久av18,亚洲国产精品特色大片观看完整版,孙宇晨将参加特朗普的晚宴

熱搜

最近搜索清空

Scrapy下載器中間件入門(mén)詳解

请求发出前的预处理阶段

响应返回后的后处理阶段

中间件执行顺序

中间件类的完整定义

项目文件结构

配置中间件

启用中间件

配置示例

中间件方法详解

注册中间件类

演示代码

中间件实例

process_request 方法

process_response 方法

process_exception 方法

中间件实例

中间件顺序设置

中间件与Pipeline的配合使用

自定义扩展Scrapy功能

请求和响应的自定义处理

请求头、代理设置

请求头修改

使用代理池

IP代理池的管理

请求和响应的自定义处理

响应状态码检查

数据预处理和清洗

响应内容修改

响应编码修改

中间件实例

配置日志级别

自定义日志记录

日志示例

process_request 方法返回错误类型

process_response 方法返回错误类型

process_exception 方法返回错误类型

日志错误

其他常见错误

测试示例

閱讀免費(fèi)教程

`process_request` 方法

`process_response` 方法

`process_exception` 方法

`process_request` 方法返回错误类型

`process_response` 方法返回错误类型

`process_exception` 方法返回错误类型