crawlo 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

crawlo/settings/default_settings.py

@@ -29,54 +29,54 @@ DOWNLOADER = "crawlo.downloader.aiohttp_downloader.AioHttpDownloader"
 # 可以在Spider类中设置 custom_settings = {'DOWNLOADER_TYPE': 'httpx'}
 
 # 请求超时与安全
-DOWNLOAD_TIMEOUT = 30          # 下载超时时间（秒）
-VERIFY_SSL = True              # 是否验证 SSL 证书
-USE_SESSION = True             # 是否使用持久化会话（aiohttp 特有）
+DOWNLOAD_TIMEOUT = 30  # 下载超时时间（秒）
+VERIFY_SSL = True  # 是否验证 SSL 证书
+USE_SESSION = True  # 是否使用持久化会话（aiohttp 特有）
 
 # 请求延迟控制
-DOWNLOAD_DELAY = 1.0          # 基础延迟（秒）
-RANDOM_RANGE = (0.8, 1.2)    # 随机延迟系数范围
-RANDOMNESS = True              # 是否启用随机延迟
+DOWNLOAD_DELAY = 1.0  # 基础延迟（秒）
+RANDOM_RANGE = (0.8, 1.2)  # 随机延迟系数范围
+RANDOMNESS = True  # 是否启用随机延迟
 
 # 重试策略
-MAX_RETRY_TIMES = 3            # 最大重试次数
-RETRY_PRIORITY = -1            # 重试请求的优先级调整
+MAX_RETRY_TIMES = 3  # 最大重试次数
+RETRY_PRIORITY = -1  # 重试请求的优先级调整
 RETRY_HTTP_CODES = [408, 429, 500, 502, 503, 504, 522, 524]  # 触发重试的状态码
-IGNORE_HTTP_CODES = [403, 404] # 直接标记成功、不重试的状态码
-ALLOWED_CODES = []             # 允许的状态码（空表示不限制）
+IGNORE_HTTP_CODES = [403, 404]  # 直接标记成功、不重试的状态码
+ALLOWED_CODES = []  # 允许的状态码（空表示不限制）
 
 # 连接与响应大小限制
-CONNECTION_POOL_LIMIT = 50    # 最大并发连接数（连接池大小）
+CONNECTION_POOL_LIMIT = 50  # 最大并发连接数（连接池大小）
 CONNECTION_POOL_LIMIT_PER_HOST = 20  # 每个主机的连接池大小
-DOWNLOAD_MAXSIZE = 10 * 1024 * 1024   # 最大响应体大小（10MB）
-DOWNLOAD_WARN_SIZE = 1024 * 1024      # 响应体警告阈值（1MB）
+DOWNLOAD_MAXSIZE = 10 * 1024 * 1024  # 最大响应体大小（10MB）
+DOWNLOAD_WARN_SIZE = 1024 * 1024  # 响应体警告阈值（1MB）
 DOWNLOAD_RETRY_TIMES = MAX_RETRY_TIMES  # 下载器内部重试次数（复用全局）
 
 # 下载统计配置
-DOWNLOADER_STATS = True        # 是否启用下载器统计功能
-DOWNLOAD_STATS = True          # 是否记录下载时间和大小统计
+DOWNLOADER_STATS = True  # 是否启用下载器统计功能
+DOWNLOAD_STATS = True  # 是否记录下载时间和大小统计
 
 # ============================== 并发与调度 ==============================
 
-CONCURRENCY = 8                # 单个爬虫的并发请求数
-INTERVAL = 5                   # 日志统计输出间隔（秒）
-DEPTH_PRIORITY = 1             # 深度优先策略优先级
-MAX_RUNNING_SPIDERS = 3        # 最大同时运行的爬虫数
+CONCURRENCY = 8  # 单个爬虫的并发请求数
+INTERVAL = 5  # 日志统计输出间隔（秒）
+DEPTH_PRIORITY = 1  # 深度优先策略优先级
+MAX_RUNNING_SPIDERS = 3  # 最大同时运行的爬虫数
 
 # ============================== 队列配置 ==============================
 
 # 🎯 运行模式选择：'standalone'(单机), 'distributed'(分布式), 'auto'(自动检测)
-RUN_MODE = 'standalone'         # 默认单机模式，简单易用
+RUN_MODE = 'standalone'  # 默认单机模式，简单易用
 
 # 队列类型选择：'memory'(内存), 'redis'(分布式), 'auto'(自动选择)
-QUEUE_TYPE = 'memory'           # 默认内存队列，无需外部依赖
+QUEUE_TYPE = 'memory'  # 默认内存队列，无需外部依赖
 SCHEDULER_MAX_QUEUE_SIZE = 2000  # 调度器队列最大容量
 SCHEDULER_QUEUE_NAME = 'crawlo:requests'  # Redis 队列名称
-QUEUE_MAX_RETRIES = 3          # 队列操作最大重试次数
-QUEUE_TIMEOUT = 300            # 队列操作超时时间（秒）
+QUEUE_MAX_RETRIES = 3  # 队列操作最大重试次数
+QUEUE_TIMEOUT = 300  # 队列操作超时时间（秒）
 
 # 大规模爬取优化配置
-LARGE_SCALE_BATCH_SIZE = 1000   # 批处理大小
+LARGE_SCALE_BATCH_SIZE = 1000  # 批处理大小
 LARGE_SCALE_CHECKPOINT_INTERVAL = 5000  # 进度保存间隔
 LARGE_SCALE_MAX_MEMORY_USAGE = 500  # 最大内存使用量（MB）
 
@@ -89,13 +89,14 @@ MYSQL_USER = 'root'
 MYSQL_PASSWORD = '123456'
 MYSQL_DB = 'crawl'
 MYSQL_TABLE = 'crawlo'
-MYSQL_BATCH_SIZE = 100         # 批量插入条数
+MYSQL_BATCH_SIZE = 100  # 批量插入条数
+MYSQL_USE_BATCH = False  # 是否启用批量插入
 
 # MySQL 连接池
-MYSQL_FLUSH_INTERVAL = 5       # 缓存刷新间隔（秒）
+MYSQL_FLUSH_INTERVAL = 5  # 缓存刷新间隔（秒）
 MYSQL_POOL_MIN = 5
 MYSQL_POOL_MAX = 20
-MYSQL_ECHO = False             # 是否打印 SQL 日志
+MYSQL_ECHO = False  # 是否打印 SQL 日志
 
 # --- MongoDB 配置 ---
 MONGO_URI = 'mongodb://user:password@host:27017'
@@ -103,12 +104,24 @@ MONGO_DATABASE = 'scrapy_data'
 MONGO_COLLECTION = 'crawled_items'
 MONGO_MAX_POOL_SIZE = 200
 MONGO_MIN_POOL_SIZE = 20
+MONGO_BATCH_SIZE = 100  # 批量插入条数
+MONGO_USE_BATCH = False  # 是否启用批量插入
 
 # ============================== 去重过滤配置 ==============================
 
 # 请求指纹存储目录（文件过滤器使用）
 REQUEST_DIR = '.'
 
+# 根据运行模式自动选择去重管道
+# 单机模式默认使用内存去重管道
+# 分布式模式默认使用Redis去重管道
+if RUN_MODE == 'distributed':
+    # 分布式模式下默认使用Redis去重管道
+    DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.RedisDedupPipeline'
+else:
+    # 单机模式下默认使用内存去重管道
+    DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.MemoryDedupPipeline'
+
 # 去重过滤器类（二选一）
 FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'
 # FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter' # 分布式去重
@@ -117,76 +130,116 @@ FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'
 REDIS_HOST = os.getenv('REDIS_HOST', '127.0.0.1')
 REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
 REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', '')  # 默认无密码
+REDIS_DB = int(os.getenv('REDIS_DB', 0))  # Redis 数据库编号，默认为 0
 # 🔧 根据是否有密码生成不同的 URL 格式
 if REDIS_PASSWORD:
-    REDIS_URL = f'redis://:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}/0'
+    REDIS_URL = f'redis://:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB}'
 else:
-    REDIS_URL = f'redis://{REDIS_HOST}:{REDIS_PORT}/0'
-REDIS_KEY = 'request_fingerprint'        # Redis 中存储指纹的键名
-REDIS_TTL = 0                            # 指纹过期时间（0 表示永不过期）
-CLEANUP_FP = 0                           # 程序结束时是否清理指纹（0=不清理）
-FILTER_DEBUG = True                      # 是否开启去重调试日志
-DECODE_RESPONSES = True                  # Redis 返回是否解码为字符串
+    REDIS_URL = f'redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB}'
+REDIS_KEY = 'request_fingerprint'  # Redis 中存储指纹的键名
+REDIS_TTL = 0  # 指纹过期时间（0 表示永不过期）
+CLEANUP_FP = 0  # 程序结束时是否清理指纹（0=不清理）
+FILTER_DEBUG = True  # 是否开启去重调试日志
+DECODE_RESPONSES = True  # Redis 返回是否解码为字符串
 
 # ============================== 中间件配置 ==============================
 
 MIDDLEWARES = [
     # === 请求预处理阶段 ===
-    'crawlo.middleware.request_ignore.RequestIgnoreMiddleware',   # 1. 忽略无效请求
-    'crawlo.middleware.download_delay.DownloadDelayMiddleware',   # 2. 控制请求频率
-    'crawlo.middleware.default_header.DefaultHeaderMiddleware',   # 3. 添加默认请求头
-    'crawlo.middleware.proxy.ProxyMiddleware',                    # 4. 设置代理
+    'crawlo.middleware.request_ignore.RequestIgnoreMiddleware',  # 1. 忽略无效请求
+    'crawlo.middleware.download_delay.DownloadDelayMiddleware',  # 2. 控制请求频率
+    'crawlo.middleware.default_header.DefaultHeaderMiddleware',  # 3. 添加默认请求头
+    'crawlo.middleware.proxy.ProxyMiddleware',  # 4. 设置代理
 
     # === 响应处理阶段 ===
-    'crawlo.middleware.retry.RetryMiddleware',                    # 5. 失败请求重试
-    'crawlo.middleware.response_code.ResponseCodeMiddleware',     # 6. 处理特殊状态码
-    'crawlo.middleware.response_filter.ResponseFilterMiddleware', # 7. 响应内容过滤
+    'crawlo.middleware.retry.RetryMiddleware',  # 5. 失败请求重试
+    'crawlo.middleware.response_code.ResponseCodeMiddleware',  # 6. 处理特殊状态码
+    'crawlo.middleware.response_filter.ResponseFilterMiddleware',  # 7. 响应内容过滤
 ]
 
 # ============================== 扩展与管道 ==============================
 
 # 数据处理管道（启用的存储方式）
 PIPELINES = [
-    'crawlo.pipelines.console_pipeline.ConsolePipeline',          # 控制台输出
+    'crawlo.pipelines.console_pipeline.ConsolePipeline',  # 控制台输出
     # 'crawlo.pipelines.mysql_pipeline.AsyncmyMySQLPipeline',     # MySQL 存储（可选）
 ]
 
+# 根据运行模式自动配置默认去重管道
+if RUN_MODE == 'distributed':
+    # 分布式模式下添加Redis去重管道
+    PIPELINES.insert(0, DEFAULT_DEDUP_PIPELINE)
+else:
+    # 单机模式下添加内存去重管道
+    PIPELINES.insert(0, DEFAULT_DEDUP_PIPELINE)
+
 # 扩展组件（监控与日志）
 EXTENSIONS = [
-    'crawlo.extension.log_interval.LogIntervalExtension',         # 定时日志
-    'crawlo.extension.log_stats.LogStats',                        # 统计信息
-    'crawlo.extension.logging_extension.CustomLoggerExtension',   # 自定义日志
+    'crawlo.extension.log_interval.LogIntervalExtension',  # 定时日志
+    'crawlo.extension.log_stats.LogStats',  # 统计信息
+    'crawlo.extension.logging_extension.CustomLoggerExtension',  # 自定义日志
+    'crawlo.extension.memory_monitor.MemoryMonitorExtension',  # 内存监控
+    # 'crawlo.extension.request_recorder.RequestRecorderExtension',  # 请求记录
+    # 'crawlo.extension.performance_profiler.PerformanceProfilerExtension',  # 性能分析
+    # 'crawlo.extension.health_check.HealthCheckExtension',  # 健康检查
 ]
 
 # ============================== 日志与监控 ==============================
 
-LOG_LEVEL = 'INFO'                         # 日志级别: DEBUG/INFO/WARNING/ERROR
-STATS_DUMP = True                          # 是否周期性输出统计信息
-LOG_FILE = f'logs/{PROJECT_NAME}.log'      # 日志文件路径
+LOG_LEVEL = 'INFO'  # 日志级别: DEBUG/INFO/WARNING/ERROR
+STATS_DUMP = True  # 是否周期性输出统计信息
+
+# ============================== 扩展配置 ==============================
+
+# 内存监控扩展配置
+MEMORY_MONITOR_ENABLED = False  # 是否启用内存监控
+MEMORY_MONITOR_INTERVAL = 60  # 内存检查间隔（秒）
+MEMORY_WARNING_THRESHOLD = 80.0  # 内存使用警告阈值（百分比）
+MEMORY_CRITICAL_THRESHOLD = 90.0  # 内存使用严重阈值（百分比）
+
+# 请求记录扩展配置
+REQUEST_RECORDER_ENABLED = False  # 是否启用请求记录
+REQUEST_RECORDER_OUTPUT_DIR = 'requests_log'  # 请求记录输出目录
+REQUEST_RECORDER_MAX_FILE_SIZE = 10 * 1024 * 1024  # 单个记录文件最大大小（字节）
+
+# 性能分析扩展配置
+PERFORMANCE_PROFILER_ENABLED = False  # 是否启用性能分析
+PERFORMANCE_PROFILER_OUTPUT_DIR = 'profiling'  # 性能分析输出目录
+PERFORMANCE_PROFILER_INTERVAL = 300  # 定期保存分析结果间隔（秒）
+
+# 健康检查扩展配置
+HEALTH_CHECK_ENABLED = True  # 是否启用健康检查
+HEALTH_CHECK_INTERVAL = 60  # 健康检查间隔（秒）
+
+# ============================== 日志与监控 ==============================
+
+LOG_LEVEL = 'INFO'  # 日志级别: DEBUG/INFO/WARNING/ERROR
+STATS_DUMP = True  # 是否周期性输出统计信息
+LOG_FILE = f'logs/{PROJECT_NAME}.log'  # 日志文件路径
 LOG_FORMAT = '%(asctime)s - [%(name)s] - %(levelname)s： %(message)s'
 LOG_ENCODING = 'utf-8'
 
 # ============================== 代理配置 ==============================
 
-PROXY_ENABLED = False                       # 是否启用代理
+PROXY_ENABLED = False  # 是否启用代理
 PROXY_API_URL = "https://api.proxyprovider.com/get"  # 代理获取接口（请替换为真实地址）
 
 # 代理提取方式（支持字段路径或函数）
-PROXY_EXTRACTOR = "proxy"                  # 如返回 {"proxy": "http://1.1.1.1:8080"}
+PROXY_EXTRACTOR = "proxy"  # 如返回 {"proxy": "http://1.1.1.1:8080"}
 
 # 代理刷新控制
-PROXY_REFRESH_INTERVAL = 60                # 代理刷新间隔（秒）
-PROXY_API_TIMEOUT = 10                     # 请求代理 API 超时时间
+PROXY_REFRESH_INTERVAL = 60  # 代理刷新间隔（秒）
+PROXY_API_TIMEOUT = 10  # 请求代理 API 超时时间
 
 # ============================== Curl-Cffi 特有配置 ==============================
 
 # 浏览器指纹模拟（仅 CurlCffi 下载器有效）
-CURL_BROWSER_TYPE = "chrome"               # 可选: chrome, edge, safari, firefox 或版本如 chrome136
+CURL_BROWSER_TYPE = "chrome"  # 可选: chrome, edge, safari, firefox 或版本如 chrome136
 
 # 自定义浏览器版本映射（可覆盖默认行为）
 CURL_BROWSER_VERSION_MAP = {
     "chrome": "chrome136",
-    "edge": "edge101", 
+    "edge": "edge101",
     "safari": "safari184",
     "firefox": "firefox135",
     # 示例：旧版本测试
@@ -194,8 +247,8 @@ CURL_BROWSER_VERSION_MAP = {
 }
 
 # Curl-Cffi 优化配置
-CURL_RANDOMIZE_DELAY = False     # 是否启用随机延迟
-CURL_RETRY_BACKOFF = True        # 是否启用指数退避重试
+CURL_RANDOMIZE_DELAY = False  # 是否启用随机延迟
+CURL_RETRY_BACKOFF = True  # 是否启用指数退避重试
 
 # 默认请求头（可被 Spider 覆盖）
 DEFAULT_REQUEST_HEADERS = {
@@ -206,21 +259,21 @@ DEFAULT_REQUEST_HEADERS = {
 # ============================== 下载器优化配置 ==============================
 
 # 下载器健康检查
-DOWNLOADER_HEALTH_CHECK = True   # 是否启用下载器健康检查
-HEALTH_CHECK_INTERVAL = 60       # 健康检查间隔（秒）
+DOWNLOADER_HEALTH_CHECK = True  # 是否启用下载器健康检查
+HEALTH_CHECK_INTERVAL = 60  # 健康检查间隔（秒）
 
 # 请求统计配置
-REQUEST_STATS_ENABLED = True     # 是否启用请求统计
-STATS_RESET_ON_START = False     # 启动时是否重置统计
+REQUEST_STATS_ENABLED = True  # 是否启用请求统计
+STATS_RESET_ON_START = False  # 启动时是否重置统计
 
 # HttpX 下载器专用配置
-HTTPX_HTTP2 = True               # 是否启用HTTP/2支持
-HTTPX_FOLLOW_REDIRECTS = True    # 是否自动跟随重定向
+HTTPX_HTTP2 = True  # 是否启用HTTP/2支持
+HTTPX_FOLLOW_REDIRECTS = True  # 是否自动跟随重定向
 
 # AioHttp 下载器专用配置
-AIOHTTP_AUTO_DECOMPRESS = True   # 是否自动解压响应
-AIOHTTP_FORCE_CLOSE = False      # 是否强制关闭连接
+AIOHTTP_AUTO_DECOMPRESS = True  # 是否自动解压响应
+AIOHTTP_FORCE_CLOSE = False  # 是否强制关闭连接
 
 # 通用优化配置
-CONNECTION_TTL_DNS_CACHE = 300   # DNS缓存TTL（秒）
-CONNECTION_KEEPALIVE_TIMEOUT = 15 # Keep-Alive超时（秒）
+CONNECTION_TTL_DNS_CACHE = 300  # DNS缓存TTL（秒）
+CONNECTION_KEEPALIVE_TIMEOUT = 15  # Keep-Alive超时（秒）

crawlo/subscriber.py

@@ -1,9 +1,10 @@
 #!/usr/bin/python
 # -*- coding:UTF-8 -*-
 import asyncio
+import weakref
 from collections import defaultdict
 from inspect import iscoroutinefunction
-from typing import Dict, Set, Callable, Coroutine, Any, TypeAlias, List
+from typing import Dict, Set, Callable, Coroutine, Any, TypeAlias, List, Tuple
 
 
 class ReceiverTypeError(TypeError):
@@ -24,22 +25,30 @@ class Subscriber:
 
     def __init__(self):
         """初始化一个空的订阅者字典。"""
-        self._subscribers: Dict[str, Set[ReceiverCoroutine]] = defaultdict(set)
+        # 使用弱引用字典避免内存泄漏
+        self._subscribers: Dict[str, Dict[ReceiverCoroutine, int]] = defaultdict(dict)
+        # 用于缓存排序后的订阅者列表，提高频繁事件的处理性能
+        self._sorted_subscribers_cache: Dict[str, List[Tuple[ReceiverCoroutine, int]]] = {}
 
-    def subscribe(self, receiver: ReceiverCoroutine, *, event: str) -> None:
+    def subscribe(self, receiver: ReceiverCoroutine, *, event: str, priority: int = 0) -> None:
         """
         订阅一个事件。
 
         Args:
             receiver: 一个协程函数 (例如 async def my_func(...))。
             event: 要订阅的事件名称。
+            priority: 订阅者优先级，数值越小优先级越高，默认为0。
 
         Raises:
             ReceiverTypeError: 如果提供的 `receiver` 不是一个协程函数。
         """
         if not iscoroutinefunction(receiver):
             raise ReceiverTypeError(f"接收者 '{receiver.__qualname__}' 必须是一个协程函数。")
-        self._subscribers[event].add(receiver)
+        
+        # 使用弱引用避免内存泄漏
+        self._subscribers[event][receiver] = priority
+        # 清除缓存
+        self._sorted_subscribers_cache.pop(event, None)
 
     def unsubscribe(self, receiver: ReceiverCoroutine, *, event: str) -> None:
         """
@@ -52,13 +61,47 @@ class Subscriber:
             event: 事件名称。
         """
         if event in self._subscribers:
-            self._subscribers[event].discard(receiver)
+            self._subscribers[event].pop(receiver, None)
+            # 清除缓存
+            self._sorted_subscribers_cache.pop(event, None)
+
+    def _get_sorted_subscribers(self, event: str) -> List[Tuple[ReceiverCoroutine, int]]:
+        """
+        获取按优先级排序的订阅者列表。
+        
+        Args:
+            event: 事件名称。
+            
+        Returns:
+            按优先级排序的订阅者列表。
+        """
+        # 检查缓存
+        if event in self._sorted_subscribers_cache:
+            return self._sorted_subscribers_cache[event]
+        
+        # 获取有效的订阅者（使用弱引用检查）
+        valid_subscribers = {}
+        for receiver, priority in list(self._subscribers[event].items()):
+            # 检查弱引用是否仍然有效
+            if isinstance(receiver, Callable):
+                valid_subscribers[receiver] = priority
+        
+        # 更新订阅者字典
+        self._subscribers[event] = valid_subscribers
+        
+        # 按优先级排序（数值小的优先级高）
+        sorted_subscribers = sorted(valid_subscribers.items(), key=lambda x: x[1])
+        # 缓存结果
+        self._sorted_subscribers_cache[event] = sorted_subscribers
+        
+        return sorted_subscribers
 
     async def notify(self, event: str, *args, **kwargs) -> List[Any]:
         """
         异步地、并发地通知所有订阅了该事件的接收者。
 
         此方法会等待所有订阅者任务完成后再返回，并收集所有结果或异常。
+        订阅者按优先级顺序执行，优先级高的先执行。
 
         Args:
             event: 要触发的事件名称。
@@ -68,39 +111,21 @@ class Subscriber:
         Returns:
             一个列表，包含每个订阅者任务的返回结果或在执行期间捕获的异常。
         """
-        receivers = self._subscribers.get(event, set())
-        if not receivers:
+        sorted_subscribers = self._get_sorted_subscribers(event)
+        if not sorted_subscribers:
             return []
 
-        tasks = [asyncio.create_task(receiver(*args, **kwargs)) for receiver in receivers]
+        # 为频繁触发的事件重用任务对象以提高性能
+        tasks = []
+        for receiver, _ in sorted_subscribers:
+            try:
+                # 创建任务并添加到列表
+                task = asyncio.create_task(receiver(*args, **kwargs))
+                tasks.append(task)
+            except Exception as e:
+                # 如果创建任务失败，记录异常并继续处理其他订阅者
+                tasks.append(asyncio.Future())  # 添加一个已完成的Future表示错误
+                tasks[-1].set_exception(e)
 
         # 并发执行所有任务并返回结果列表（包括异常）
-        return await asyncio.gather(*tasks, return_exceptions=True)
-
-# #!/usr/bin/python
-# # -*- coding:UTF-8 -*-
-# import asyncio
-# from collections import defaultdict
-# from inspect import iscoroutinefunction
-# from typing import Dict, Set, Callable, Coroutine
-#
-# from crawlo.exceptions import ReceiverTypeError
-#
-#
-# class Subscriber:
-#
-#     def __init__(self):
-#         self._subscribers: Dict[str, Set[Callable[..., Coroutine]]] = defaultdict(set)
-#
-#     def subscribe(self, receiver: Callable[..., Coroutine], *, event: str) -> None:
-#         if not iscoroutinefunction(receiver):
-#             raise ReceiverTypeError(f"{receiver.__qualname__} must be a coroutine function")
-#         self._subscribers[event].add(receiver)
-#
-#     def unsubscribe(self, receiver: Callable[..., Coroutine], *, event: str) -> None:
-#         self._subscribers[event].discard(receiver)
-#
-#     async def notify(self, event: str, *args, **kwargs) -> None:
-#         for receiver in self._subscribers[event]:
-#             # 不能 await
-#             asyncio.create_task(receiver(*args, **kwargs))
+        return await asyncio.gather(*tasks, return_exceptions=True)

crawlo/templates/project/items.py.tmpl

@@ -12,7 +12,7 @@ class ExampleItem(Item):
     """
     一个示例数据项。
     """
-    # name = Field()
+    id = Field()
     # price = Field()
     # description = Field()
     pass

crawlo/templates/project/middlewares.py.tmpl

@@ -3,6 +3,8 @@
 {{project_name}}.middlewares
 ============================
 自定义中间件，用于在请求/响应/异常处理过程中插入自定义逻辑。
+
+这是一个简单的示例中间件，您可以根据需要添加更多中间件。
 """
 
 import random
@@ -11,8 +13,15 @@ from crawlo.utils.log import get_logger
 from crawlo.exceptions import IgnoreRequest
 
 
-class RandomUserAgentMiddleware:
-    """随机 User-Agent 中间件。"""
+class ExampleMiddleware:
+    """
+    示例中间件，演示如何处理请求、响应和异常。
+    
+    此中间件会：
+    1. 为请求添加随机 User-Agent
+    2. 记录请求和响应信息
+    3. 处理异常情况
+    """
     
     def __init__(self):
         self.logger = get_logger(self.__class__.__name__)
@@ -22,66 +31,81 @@ class RandomUserAgentMiddleware:
             'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0',
             'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0',
         ]
-    
+
     def process_request(self, request, spider):
+        """
+        在请求被下载器执行前调用。
+        
+        Args:
+            request: 请求对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 继续处理请求
+            Response: 返回响应对象（短路处理）
+            Request: 返回新请求对象（替换原请求）
+        """
+        # 为请求添加随机 User-Agent
         if 'User-Agent' not in request.headers:
             ua = random.choice(self.user_agents)
             request.headers['User-Agent'] = ua
-        return None
-
-
-class CustomDownloaderMiddleware:
-    """自定义下载器中间件示例。"""
-
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-
-    def process_request(self, request, spider):
-        """在请求被下载器执行前调用。"""
-        # 示例：添加自定义请求头
-        # request.headers['Custom-Header'] = 'Custom-Value'
-        # 示例：设置代理
-        # request.meta['proxy'] = 'http://proxy.example.com:8080'
+            self.logger.debug(f"为请求 {request.url} 设置 User-Agent: {ua[:50]}...")
+        
         return None
 
     def process_response(self, request, response, spider):
-        """在响应被 Spider 处理前调用。"""
-        # 示例：检查响应状态
+        """
+        在响应被 Spider 处理前调用。
+        
+        Args:
+            request: 原始请求对象
+            response: 响应对象
+            spider: 爬虫实例
+            
+        Returns:
+            Response: 处理后的响应对象
+        """
+        # 记录响应信息
+        self.logger.info(f"收到响应: {request.url} - 状态码: {response.status_code}")
+        
+        # 可以在这里处理特殊状态码
         if response.status_code == 403:
             self.logger.warning(f"访问被拒绝: {request.url}")
+        
         return response
 
     def process_exception(self, request, exception, spider):
-        """在下载或处理过程中发生异常时调用。"""
+        """
+        在下载或处理过程中发生异常时调用。
+        
+        Args:
+            request: 请求对象
+            exception: 异常对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 异常将继续传播
+            Response: 返回响应对象（处理异常）
+            Request: 返回新请求对象（重试请求）
+        """
         self.logger.error(f"请求异常: {request.url} - {exception}")
         return None
 
 
-class CustomSpiderMiddleware:
-    """
-Spider 中间件示例。
-    """
-
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-
-    def process_spider_input(self, response, spider):
-        """在 Spider 的 parse 方法被调用前调用。"""
-        # 可以用来验证响应
-        pass
-
-    def process_spider_output(self, response, result, spider):
-        """在 Spider 的 parse 方法返回结果后调用。"""
-        # 可以用来过滤或修改结果
-        for item in result:
-            yield item
-
-    def process_spider_exception(self, response, exception, spider):
-        """在 Spider 的 parse 方法抛出异常时调用。"""
-        self.logger.error(f"Spider 异常: {response.url} - {exception}")
-        pass
-
-    def process_start_requests(self, start_requests, spider):
-        """在 Spider 的 start_requests 生成器被消费时调用。"""
-        for request in start_requests:
-            yield request
+# ======================== 使用说明 ========================
+# 
+# 在 settings.py 中启用中间件：
+# MIDDLEWARES = [
+#     '{{project_name}}.middlewares.ExampleMiddleware',
+# ]
+# 
+# 您可以根据需要添加更多中间件，例如：
+# 1. 请求处理中间件（修改请求头、设置代理等）
+# 2. 响应处理中间件（解析、过滤等）
+# 3. 异常处理中间件（重试、记录等）
+# 
+# 每个中间件可以实现以下方法：
+# - process_request: 处理请求
+# - process_response: 处理响应
+# - process_exception: 处理异常
+# ======================== 使用说明 ========================