动态网页爬虫双引擎架构实战：Selenium与Playwright结合应用-代码聚汇网

动态网页爬虫双引擎架构实战：Selenium与Playwright结合应用

哗啦啦的小流弊

1. 动态页面爬虫的挑战与破局思路

作为一名长期从事数据采集的开发者，我深知动态页面爬取的技术痛点。以某点评网为代表的现代Web应用，普遍采用前后端分离架构，这给传统爬虫带来了三大技术障碍：

首先是数据异步加载问题。现代网站90%以上的核心数据（如商户信息、用户评价）都通过AJAX接口动态获取。以某点评网为例，当我们用浏览器查看网页源码时，只能看到基础的HTML骨架，真正的数据内容是通过后续的XHR请求逐步填充的。

其次是客户端渲染依赖。许多关键信息（如综合评分、人均消费）并非由服务端直接返回，而是前端JavaScript根据原始数据计算后动态渲染的。我曾做过测试，直接请求某点评网的页面接口，返回的JSON数据中并不包含最终展示的星级评分，这个数值是前端根据多个维度评分加权计算得出的。

最后是日益复杂的反爬机制。现代网站会从多个维度检测爬虫行为：

请求特征检测：包括User-Agent、Header完整性、Cookie连续性等
行为模式分析：如请求频率、点击轨迹、页面停留时间
环境指纹收集：包括WebGL渲染、字体列表、Canvas指纹等

2. 双引擎架构设计原理

2.1 技术选型对比

在动态页面爬取领域，主流的解决方案可分为三类：

技术方案	代表工具	优点	缺点
无头浏览器	Selenium	生态成熟、支持多语言	性能较低、资源占用高
现代浏览器协议	Playwright	执行速度快、支持多浏览器	新工具、社区资源较少
直接接口分析	requests+逆向	效率最高、资源消耗最小	逆向难度大、维护成本高

经过多次实践验证，我最终选择了Selenium+Playwright的双引擎方案，主要基于以下考量：

功能互补性：Selenium的成熟稳定与Playwright的高效创新形成互补
风险分散：单一工具被反爬时，可快速切换到另一引擎继续工作
场景适配：不同页面结构可能对不同引擎的适应性存在差异

2.2 核心架构设计

双引擎爬虫的系统架构如下图所示（文字描述）：

code复制[爬虫调度中心]
    │
    ├── [Selenium引擎]──>浏览器驱动──>Chrome实例
    │       ├── 页面渲染
    │       ├── 行为模拟
    │       └── 数据提取
    │
    └── [Playwright引擎]──>Playwright API──>Chromium实例
            ├── 自动等待
            ├── 网络拦截
            └── 数据捕获

这个架构的关键优势在于：

通过统一的调度中心管理两个引擎
可根据目标网站的反爬策略动态切换引擎
数据提取层抽象为统一接口，后续处理无需关心来源

3. 环境配置与核心实现

3.1 基础环境搭建

Python环境建议使用3.8+版本，依赖管理推荐使用poetry：

bash复制# 安装poetry（如未安装）
pip install poetry

# 初始化项目
poetry init

# 添加依赖
poetry add selenium playwright beautifulsoup4 pandas
poetry add playwright-install

特别提醒：Playwright需要安装浏览器二进制文件，执行以下命令：

bash复制poetry run playwright install
poetry run playwright install-chromium

3.2 Selenium引擎实现

3.2.1 浏览器配置

为避免被识别为爬虫，需要对浏览器实例进行深度定制：

python复制from selenium import webdriver
from selenium.webdriver.chrome.options import Options

def create_stealth_driver():
    options = Options()
    
    # 基础反检测配置
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_experimental_option("excludeSwitches", ["enable-automation"])
    options.add_experimental_option("useAutomationExtension", False)
    
    # 模拟真实用户配置
    options.add_argument("--start-maximized")
    options.add_argument("--lang=zh-CN")
    
    # 禁用图片加载提升性能
    prefs = {"profile.managed_default_content_settings.images": 2}
    options.add_experimental_option("prefs", prefs)
    
    driver = webdriver.Chrome(options=options)
    
    # 覆盖navigator.webdriver属性
    driver.execute_script(
        "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
    )
    
    return driver

3.2.2 页面交互逻辑

某点评网的页面交互有以下几个关键点需要处理：

地理位置弹窗：首次访问会出现定位请求

python复制def handle_location_popup(driver):
    try:
        reject_btn = WebDriverWait(driver, 5).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".geoip-reject"))
        )
        reject_btn.click()
    except:
        pass

登录悬浮窗：滚动时可能触发登录提示

python复制def dismiss_login_popup(driver):
    try:
        close_btn = WebDriverWait(driver, 3).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".close-login"))
        )
        close_btn.click()
    except:
        pass

智能验证：频繁操作可能触发验证

python复制def handle_captcha(driver):
    try:
        if "verify" in driver.current_url:
            # 这里需要接入打码平台或手动处理
            print("遇到验证码，需要人工干预")
            input("按回车继续...")
    except:
        pass

3.3 Playwright引擎实现

3.3.1 基础配置

Playwright的配置更为简洁：

python复制from playwright.sync_api import sync_playwright

def create_playwright_context():
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,
            args=["--disable-blink-features=AutomationControlled"]
        )
        context = browser.new_context(
            locale="zh-CN",
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64)..."
        )
        page = context.new_page()
        return page

3.3.2 网络请求拦截

Playwright的强大之处在于可以监听网络请求：

python复制def setup_request_interception(page):
    def intercept_request(route, request):
        # 阻止不必要的资源加载
        if request.resource_type in ["image", "stylesheet", "font"]:
            route.abort()
        else:
            route.continue_()
    
    page.route("**/*", intercept_request)

3.3.3 数据抓取策略

针对某点评网的列表页，可以采用以下策略：

python复制def scrape_listings(page, url):
    page.goto(url)
    
    # 等待关键元素加载
    page.wait_for_selector(".shop-list li", state="attached")
    
    # 模拟滚动加载
    for _ in range(5):
        page.evaluate("window.scrollBy(0, window.innerHeight)")
        page.wait_for_timeout(2000)  # 模拟人类浏览间隔
    
    # 提取数据
    shops = page.query_selector_all(".shop-list li")
    data = []
    for shop in shops:
        name = shop.query_selector(".shop-name").inner_text()
        score = shop.query_selector(".star-score").get_attribute("title")
        data.append({"name": name, "score": score})
    
    return data

4. 反爬对抗与优化策略

4.1 指纹伪装技术

现代反爬系统会检测大量浏览器指纹特征，我们需要针对性处理：

WebGL渲染器伪装：

python复制canvas_script = """
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
"""
real_renderer = driver.execute_script(canvas_script)

字体指纹混淆：

python复制font_script = """
const div = document.createElement('div');
div.style.fontFamily = 'Arial';
document.body.appendChild(div);
return window.getComputedStyle(div).fontFamily;
"""
driver.execute_script(font_script)

4.2 行为模式模拟

真实用户的行为具有随机性和不确定性，我们需要模拟这些特征：

随机滚动模式：

python复制def random_scroll(driver):
    height = driver.execute_script("return document.body.scrollHeight")
    for _ in range(random.randint(3, 7)):
        scroll_to = random.randint(0, height)
        driver.execute_script(f"window.scrollTo(0, {scroll_to})")
        time.sleep(random.uniform(0.5, 2.0))

鼠标移动轨迹：

python复制def human_like_movement(driver, element):
    action = ActionChains(driver)
    
    # 生成贝塞尔曲线路径
    start_x, start_y = 0, 0
    end_x, end_y = element.location['x'], element.location['y']
    
    # 中间控制点
    control1_x = start_x + (end_x - start_x) / 3
    control1_y = start_y + (end_y - start_y) / 3 + random.randint(-50, 50)
    
    # 实现略...实际应使用贝塞尔曲线算法生成路径点
    
    action.move_to_element(element).perform()

4.3 代理与速率控制

智能代理轮换：

python复制class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current = 0
    
    def get_next(self):
        proxy = self.proxies[self.current]
        self.current = (self.current + 1) % len(self.proxies)
        return {
            "http": f"http://{proxy}",
            "https": f"http://{proxy}"
        }

自适应请求间隔：

python复制class RequestThrottler:
    def __init__(self, base_delay=1.0):
        self.base_delay = base_delay
        self.last_request = 0
    
    def wait(self):
        elapsed = time.time() - self.last_request
        if elapsed < self.base_delay:
            # 随机抖动增加自然性
            delay = self.base_delay - elapsed + random.uniform(0, 0.5)
            time.sleep(delay)
        self.last_request = time.time()

5. 数据处理与存储方案

5.1 数据清洗策略

采集到的原始数据通常需要清洗：

python复制def clean_shop_data(raw_data):
    # 评分标准化
    def normalize_score(score_str):
        try:
            return float(score_str.replace("星", "").strip())
        except:
            return None
    
    # 人均消费提取
    def extract_price(price_str):
        match = re.search(r"人均:(\d+)", price_str)
        return int(match.group(1)) if match else None
    
    cleaned = []
    for item in raw_data:
        cleaned.append({
            "name": item["name"].strip(),
            "score": normalize_score(item.get("score", "")),
            "price": extract_price(item.get("price_info", ""))
        })
    return cleaned

5.2 存储方案选型

根据数据量级不同，可选择不同存储方案：

数据规模	推荐方案	优点	适用场景
<10万条	SQLite	零配置、单文件	小型项目、快速原型
10-100万条	PostgreSQL	功能完善、性能好	中型项目、需要复杂查询
>100万条	MongoDB分片	水平扩展、适合非结构化数据	大型分布式采集系统

以PostgreSQL为例的存储实现：

python复制import psycopg2
from psycopg2.extras import execute_batch

class PostgresStorage:
    def __init__(self, conn_str):
        self.conn = psycopg2.connect(conn_str)
    
    def save_batch(self, data):
        sql = """
        INSERT INTO shop_data (name, score, price, location)
        VALUES (%s, %s, %s, %s)
        ON CONFLICT (name, location) DO UPDATE SET
            score = EXCLUDED.score,
            price = EXCLUDED.price
        """
        
        with self.conn.cursor() as cur:
            execute_batch(cur, sql, data)
            self.conn.commit()

6. 实战经验与避坑指南

6.1 常见问题排查

元素定位失败：
- 现象：无法找到预期的页面元素
- 可能原因：
  - 页面尚未完全加载 → 增加等待时间
  - iframe嵌套 → 需要先切换到对应frame
  - 元素被动态替换 → 使用更稳定的选择器
验证码频发：
- 预防措施：
  - 控制操作频率
  - 使用高质量代理IP
  - 维护有效的Cookie池
- 解决方案：
  - 接入打码平台API
  - 人工干预流程设计
数据不完整：
- 检查点：
  - 确认滚动加载是否触发
  - 检查网络请求是否被拦截
  - 验证选择器是否匹配最新页面结构

6.2 性能优化技巧

并发控制：

python复制from concurrent.futures import ThreadPoolExecutor

def concurrent_crawl(urls, workers=4):
    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = []
        for url in urls:
            futures.append(executor.submit(scrape_page, url))
        
        results = []
        for future in as_completed(futures):
            results.extend(future.result())
        return results

缓存利用：

python复制from diskcache import Cache

cache = Cache("scrape_cache")

@cache.memoize(expire=3600)
def scrape_page(url):
    # 实际抓取逻辑
    return data

智能重试机制：

python复制from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
def scrape_with_retry(url):
    try:
        return scrape_page(url)
    except Exception as e:
        log_error(f"Failed to scrape {url}: {str(e)}")
        raise

在实际项目中，这套双引擎方案成功帮助我稳定采集了某点评网全国20个主要城市的餐饮数据，日均处理量超过50万条。关键是要根据目标网站的特点不断调整策略，保持技术方案的适应性。