URL管理模块

爬虫核心枢纽：URL 管理模块与去重算法精讲

小象实战讲义 · Python数据分析实战

在大型网络爬虫系统中，网页之间往往存在相互指向的双向链接或环路。如果没有高效的调度与去重机制，爬虫就会陷入死循环或在重复页面中浪费海量带宽与算力。**URL 管理模块（URL Manager）**正是解决这一核心痛点的调度中枢。本节我们将深入剖析 URL 管理器的功能边界、内存与数据库持久化实现，以及大规模去重策略。

💡 核心导读

• URL 管理模块的核心职责：杜绝死循环循环指向、避免重复爬取、智能调度爬取队列。
• 三大核心 API：
  • add_new_url(s)：新链接校验与去重入队；
  • has_new_url()：检查待爬队列是否有存量；
  • get_new_url()：取出待抓取目标并归档至已抓取集合。
• 实现选型：
  • 内存级：基于 set 与 collections.deque（实现 BFS/DFS）；
  • 持久化：基于 SQLite 关系数据库（支持断点续爬）。

1. URL 管理器的核心逻辑与数据流转

URL 管理器维护两大核心数据结构：待爬取队列（Unvisited URLs） 与 已爬取集合（Visited URLs）。

                    [ 网页解析器发现的新链接 ]
                               │
                               ▼
                   ┌────────────────────────┐
                   │ 是否已存在于已爬/待爬? │
                   └───────────┬────────────┘
                               │ 否 (新 URL)
                               ▼
┌─────────────────────────────────────────────────────────────┐
│ 待爬取队列 (Queue) : [ URL_1, URL_2, URL_3, ... ]           │
└──────────────────────────────┬──────────────────────────────┘
                               │ get_new_url()
                               ▼
┌─────────────────────────────────────────────────────────────┐
│ 已爬取集合 (Set 去重) : { URL_A, URL_B, ... }               │
└─────────────────────────────────────────────────────────────┘

2. Python 代码实战：内存与持久化 URL 管理器

# 示例 1：内存级高效 URL 管理器实现

from collections import deque

class MemoryUrlManager:
    """基于双端队列与哈希集合的内存 URL 管理器"""
    def __init__(self):
        self.new_urls_queue = deque()
        self.new_urls_set = set()
        self.old_urls_set = set()
        
    def add_new_url(self, url):
        if not url or url in self.old_urls_set or url in self.new_urls_set:
            return False
        self.new_urls_queue.append(url)
        self.new_urls_set.add(url)
        return True
        
    def add_new_urls(self, urls):
        count = sum(1 for u in urls if self.add_new_url(u))
        return count
        
    def has_new_url(self):
        return len(self.new_urls_queue) > 0
        
    def get_new_url(self):
        if not self.has_new_url():
            return None
        url = self.new_urls_queue.popleft()
        self.new_urls_set.remove(url)
        self.old_urls_set.add(url)
        return url

# 测试运行
manager = MemoryUrlManager()
manager.add_new_url("http://example.com/p1")
manager.add_new_urls(["http://example.com/p2", "http://example.com/p1"])

print("是否有待爬链接:", manager.has_new_url())
while manager.has_new_url():
    print("取出待爬:", manager.get_new_url())

接下来实现支持断点续爬的 SQLite 持久化管理器：

# 示例 2：基于 SQLite 的持久化 URL 管理器 (支持断点续爬)

import sqlite3

class SqliteUrlManager:
    """基于 SQLite 的持久化 URL 管理器"""
    def __init__(self, db_path=":memory:"):
        self.conn = sqlite3.connect(db_path)
        self.cursor = self.conn.cursor()
        self.cursor.execute("""
        CREATE TABLE IF NOT EXISTS url_pool (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            url TEXT UNIQUE NOT NULL,
            status INTEGER DEFAULT 0  -- 0: 待抓取, 1: 已完成
        );
        """)
        self.conn.commit()
        
    def add_new_url(self, url):
        try:
            self.cursor.execute("INSERT OR IGNORE INTO url_pool (url, status) VALUES (?, 0);", (url,))
            self.conn.commit()
            return self.cursor.rowcount > 0
        except Exception:
            return False
            
    def get_new_url(self):
        self.cursor.execute("SELECT id, url FROM url_pool WHERE status = 0 LIMIT 1;")
        row = self.cursor.fetchone()
        if not row:
            return None
        row_id, url = row
        self.cursor.execute("UPDATE url_pool SET status = 1 WHERE id = ?;", (row_id,))
        self.conn.commit()
        return url
        
    def has_new_url(self):
        self.cursor.execute("SELECT COUNT(*) FROM url_pool WHERE status = 0;")
        return self.cursor.fetchone()[0] > 0

db_mgr = SqliteUrlManager(":memory:")
db_mgr.add_new_url("http://weather.com/beijing")
db_mgr.add_new_url("http://weather.com/shanghai")
db_mgr.add_new_url("http://weather.com/beijing")

print("持久化待爬取检查:", db_mgr.has_new_url())
while db_mgr.has_new_url():
    print("DB 取出:", db_mgr.get_new_url())

📝 动手练一练

1. 场景分析题：如果爬虫在运行过程中意外断电，内存型 URL 管理器会发生什么？持久化管理器又是如何支持断点续爬的？

   👉 点击查看参考答案

   参考答案： ① 内存型管理器中的所有待爬与已爬数据全部丢失，重启后必须从头重新爬取； ② SQLite 等持久化管理器已将 URL 与状态持久化到磁盘文件中。重启后只需查询 WHERE status = 0 的记录，即可无缝继续未完成的任务。

2. 编程练习：编写一个重试控制器函数，当 URL 请求失败时记录失败次数，并在失败达到 3 次时归档标记。

   👉 点击查看参考答案

   参考答案：

   def handle_retry(url, retry_dict, max_retries=3):
       retry_dict[url] = retry_dict.get(url, 0) + 1
       if retry_dict[url] < max_retries:
           return "RETRY"
       return "DROP"
   
   retries = {}
   print("第1次失败:", handle_retry("http://a.com", retries))
   print("第2次失败:", handle_retry("http://a.com", retries))
   print("第3次失败:", handle_retry("http://a.com", retries))

本章小结

在本节中，我们全面攻克了 URL 管理模块的核心技术：

• 深刻理解了 URL 管理器在去重与防循环中的中枢价值；
• 掌握了基于 Python 原生集合与双端队列的轻量内存实现；
• 掌握了基于 SQLite 的持久化断点续爬方案。

📋 行动清单

• 理解内存去重与持久化去重的选型权衡。
• 做好准备，进入下一小节学习《网页下载模块（Requests 实战）》！

—— 小象教研组