#为什么选择 Scrapy？：同步 vs 异步、Twisted 引擎、2026 爬虫生态最佳实践

# 同步爬虫：requests + BeautifulSoup
import requests
from bs4 import BeautifulSoup
import time

def sync_crawler(urls):
    results = []
    start = time.time()
    
    # 🔴 核心问题：串行执行 + 网络I/O阻塞CPU
    for idx, url in enumerate(urls):
        print(f"正在爬取第{idx+1}个URL...")
        response = requests.get(url)  # 这一步网络等待期间，CPU完全空闲！
        soup = BeautifulSoup(response.text, "html.parser")
        results.append({
            "url": url,
            "title": soup.find("title").text or ""
        })
    
    end = time.time()
    print(f"✅ 同步完成，耗时：{end - start:.2f}秒")
    return results

# 测试：5个带1秒延迟的URL
test_urls = ["https://httpbin.org/delay/1"] * 5
sync_crawler(test_urls)
# 输出预测：总耗时≈5.1秒（串行叠加延迟）

# 异步爬虫模拟：asyncio + aiohttp
import asyncio
import aiohttp
from bs4 import BeautifulSoup

class AsyncMockSpider:
    def __init__(self, max_concurrent=16):
        self.max_concurrent = max_concurrent
        self.sem = asyncio.Semaphore(max_concurrent)  # 🔑 限制并发数防封IP
    
    async def fetch(self, session, url):
        async with self.sem:  # 同时只有max_concurrent个请求在等待网络
            async with session.get(url) as resp:
                html = await resp.text()
                soup = BeautifulSoup(html, "html.parser")
                return {
                    "url": url,
                    "title": soup.find("title").text or ""
                }
    
    async def crawl(self, urls):
        start = asyncio.get_event_loop().time()
        # 🔑 核心：并发创建+执行所有任务，网络等待期间切换任务
        async with aiohttp.ClientSession() as session:
            tasks = [self.fetch(session, url) for url in urls]
            results = await asyncio.gather(*tasks)
        
        end = asyncio.get_event_loop().time()
        print(f"✅ 异步完成，耗时：{end - start:.2f}秒")
        return results

# 同样测试：5个带1秒延迟的URL
# asyncio.run(AsyncMockSpider().crawl(test_urls))
# 输出预测：总耗时≈1.1秒（所有请求几乎同时完成）

# Scrapy真实示例
import scrapy
from scrapy.crawler import CrawlerProcess

class ExampleSpider(scrapy.Spider):
    name = "example_spider"
    start_urls = ["https://httpbin.org/delay/1"] * 100  # 100个URL直接炸锅模拟？
    
    custom_settings = {
        "CONCURRENT_REQUESTS": 16,  # 并发数
        "DOWNLOAD_DELAY": 0.1,       # 下载延迟
        "LOG_LEVEL": "INFO"           # 日志级别（INFO比DEBUG省资源）
    }
    
    def parse(self, response):
        yield {
            "url": response.url,
            "status": response.status
        }

# 运行
# if __name__ == "__main__":
#     process = CrawlerProcess()
#     process.crawl(ExampleSpider)
#     process.start()

"""
Twisted = 事件驱动的异步网络框架（2002年诞生，比asyncio早12年！）
核心部件：
  1. Reactor（反应器）：整个异步系统的“心脏”——无限循环监听I/O事件
  2. Deferred（延迟对象）：异步操作的“承诺”——成功/失败回调链
  3. Protocol/Facory/Transport：底层网络协议、工厂、传输层封装

为什么Scrapy选它？
  ✅ 生态成熟：20年积累，覆盖HTTP、FTP、DNS等全协议
  ✅ 性能稳定：久经生产环境考验
  ✅ 跨平台兼容：Windows/Linux/Mac全通用
  ✅ 内置工具链：DNS缓存、代理池支持、自动重连等现成功能
"""

# 自己动手写一个“迷你Reactor”
import select
import socket
from collections import deque

class MiniReactor:
    def __init__(self):
        self.readers = {}  # 待监听的读事件（fd -> 回调）
        self.writers = {}  # 待监听的写事件（fd -> 回调）
        self.deferreds = deque()  # 待处理的延迟回调
        self.running = True
    
    def add_reader(self, fd, callback):
        self.readers[fd] = callback
    
    def add_writer(self, fd, callback):
        self.writers[fd] = callback
    
    def run(self):
        while self.running:
            # 🔑 核心：select系统调用同时监听读/写事件，不阻塞CPU
            r_list, w_list, _ = select.select(
                list(self.readers.keys()),
                list(self.writers.keys()),
                [],
                0.1  # 0.1秒超时
            )
            # 处理就绪的读事件
            for fd in r_list:
                self.readers.get(fd)(fd)
            # 处理就绪的写事件
            for fd in w_list:
                self.writers.get(fd)(fd)
    
    def stop(self):
        self.running = False

"""
2026企业级爬虫技术栈分层：
┌─────────────────────────────────────────┐
│  应用层（监控/可视化/API）                │
│  Prometheus + Grafana / FastAPI / Flask  │
├─────────────────────────────────────────┤
│  核心爬虫层                               │
│  Scrapy 2.11+ / Scrapy-Redis 0.7+ /      │
│  Scrapy-Playwright（现代JS渲染首选）       │
├─────────────────────────────────────────┤
│  数据处理层                               │
│  Pandas 2.0+ / PyArrow 12.0+ / SQLAlchemy│
├─────────────────────────────────────────┤
│  基础设施层（Docker/K8s容器化）            │
│  Redis 7.2+（去重/队列） / PostgreSQL 16+  │
│  / MongoDB 7.0+ / MinIO（存储图片/视频）   │
└─────────────────────────────────────────┘
"""

# settings.py 高性能配置模板
CONCURRENT_REQUESTS = 32                    # 全局并发数
CONCURRENT_REQUESTS_PER_DOMAIN = 8          # 单域名并发数（防封核心）
DOWNLOAD_DELAY = 0.5                        # 下载延迟（秒）
RANDOMIZE_DOWNLOAD_DELAY = 0.5              # 随机延迟范围（0.5×DOWNLOAD_DELAY ~ 1.5×）
AUTOTHROTTLE_ENABLED = True                 # 自动限速（根据目标网站响应调整）
AUTOTHROTTLE_TARGET_CONCURRENCY = 4.0       # 自动限速的目标并发数
DNSCACHE_ENABLED = True                     # DNS缓存（减少DNS查询开销）
LOG_LEVEL = "INFO"                          # 日志级别（DEBUG太占内存）

# Scrapy中间件架构示意图
"""
请求处理链（从Engine到目标网站）：
Spider → Spider Middleware → Scheduler → Downloader Middleware → 目标网站

响应处理链（从目标网站到Item Pipeline）：
目标网站 → Downloader Middleware → Engine → Spider Middleware → Spider → Item Pipeline
"""