做爬虫这么多年，遇到过最崩溃的事情是什么？莫过于是辛辛苦苦爬了几个小时甚至几天的大量数据，因为程序意外中断、电脑突然关机，一夜回到解放前。
我至今还记得第一次写爬虫时的惨痛经历：凌晨爬起来看世界杯比分数据，写了个多线程爬虫准备通宵跑数据，结果第二天醒来发现程序不知道什么时候崩溃了，磁盘上只留下一些残缺的临时文件。几个月的准备工作，毁于一旦。
从那以后，我开始认真研究爬虫数据的持久化存储方案。这篇文章，我会从实战角度出发，带你从零掌握爬虫数据存储的各种方案，包括文件存储、SQLite、MongoDB等，帮你彻底解决"数据丢失"这个噩梦。
一、痛点分析：爬虫数据存储面临的挑战
1.1 数据的脆弱性
很多新手爬虫工程师都经历过这样的场景：
• 爬虫运行中突然崩溃，数据只保存了一半 • 多线程并发写入同一个文件，导致数据错乱 • 爬取的数据量太大，内存溢出 • 程序中断后不知道从哪继续，重复爬取
1.2 存储方案的选择困难
市面上的存储方案五花八门：
| 存储方案 | 适用场景 | 学习成本 | 数据量级 |
| ------- | ----------- | ---- | -------- |
| TXT/CSV | 简单日志、单字段数据 | 低 | 小于10万条 |
| JSON | API数据、结构化数据 | 低 | 小于100万条 |
| SQLite | 中小型项目、单机部署 | 中 | 小于1000万条 |
| MySQL | 企业级应用、分布式场景 | 高 | 亿级数据 |
| MongoDB | 文档型数据、敏捷开发 | 中 | 亿级数据 |
| Redis | 缓存、实时性数据 | 中 | GB级数据 |1.3 实际项目中的核心需求
经过多年实战，我总结出爬虫数据存储的三大核心需求：
-
断点续传能力：程序中断后能从上次位置继续
-
并发安全：多线程/多进程同时写入不会数据丢失
-
查询效率：能快速检索和统计已爬取的数据
二、环境准备：搭建开发环境
2.1 Python环境要求
# 推荐使用Python 3.8及以上版本
python --version
# Python 3.10.9
# 创建虚拟环境（推荐）
python -m venv crawler_env
source crawler_env/bin/activate # Linux/Mac
# crawler_env\Scripts\activate # Windows2.2 核心依赖安装
# 数据处理和分析
pip install pandas numpy
# 数据库驱动
pip install sqlalchemy pymysql pymongo redis
# 爬虫相关
pip install requests beautifulsoup4 lxml
# 数据序列化
pip install orjson
# 进度条显示
pip install tqdm
# 日志记录
pip install loguru2.3 推荐的目录结构
crawler_project/
├── config/
│ └── settings.py # 配置文件
├── storage/
│ ├── __init__.py
│ ├── base_storage.py # 存储基类
│ ├── file_storage.py # 文件存储
│ ├── sqlite_storage.py # SQLite存储
│ └── mongodb_storage.py # MongoDB存储
├── utils/
│ ├── logger.py # 日志工具
│ └── helpers.py # 辅助函数
├── data/ # 数据目录
│ ├── raw/ # 原始数据
│ └── processed/ # 处理后数据
├── main.py # 主程序
└── requirements.txt # 依赖清单三、分步实战：从文件到数据库的存储方案
3.1 第一步：文件存储 - JSON和CSV
文件存储是最简单直接的方案，适合数据量小、格式简单的场景。
JSON存储实现：
# storage/json_storage.py
import json
import os
from datetime import datetime
from pathlib import Path
from typing import List, Dict, Any, Optional
from threading import Lock
class JSONStorage:
"""JSON文件存储，支持追加模式和覆盖模式"""
def __init__(self, file_path: str, mode: str = "append"):
"""
初始化JSON存储
Args:
file_path: JSON文件路径
mode: 模式 - "append"追加 或 "overwrite"覆盖
"""
self.file_path = Path(file_path)
self.mode = mode
self.lock = Lock()
# 确保目录存在
self.file_path.parent.mkdir(parents=True, exist_ok=True)
# 初始化文件
if mode == "append" and self.file_path.exists():
self.data = self._load_existing_data()
else:
self.data = []
def _load_existing_data(self) -> List[Dict]:
"""加载已有数据"""
try:
with open(self.file_path, 'r', encoding='utf-8') as f:
content = f.read().strip()
if content:
return json.loads(content)
return []
except (json.JSONDecodeError, FileNotFoundError):
return []
def save(self, data: Any) -> bool:
"""
保存单条数据
Args:
data: 要保存的数据
Returns:
保存是否成功
"""
with self.lock:
try:
self.data.append(data)
self._write_to_file()
return True
except Exception as e:
print(f"保存数据失败: {e}")
return False
def save_batch(self, data_list: List[Any]) -> bool:
"""
批量保存数据
Args:
data_list: 数据列表
Returns:
保存是否成功
"""
with self.lock:
try:
self.data.extend(data_list)
self._write_to_file()
return True
except Exception as e:
print(f"批量保存失败: {e}")
return False
def _write_to_file(self):
"""写入文件"""
with open(self.file_path, 'w', encoding='utf-8') as f:
json.dump(self.data, f, ensure_ascii=False, indent=2)
def get_all(self) -> List[Dict]:
"""获取所有数据"""
return self.data
def count(self) -> int:
"""获取数据条数"""
return len(self.data)3.2 第二步：SQLite存储 - 轻量级数据库方案
当数据量增大，文件存储的查询效率就会成为瓶颈。SQLite是一个不错的选择，它零配置、单文件、完美支持SQL查询。
SQLite存储实现：
# storage/sqlite_storage.py
import sqlite3
import json
from pathlib import Path
from typing import List, Dict, Any, Optional, Tuple
from datetime import datetime
from contextlib import contextmanager
import threading
class SQLiteStorage:
"""SQLite数据库存储，支持断点续传和并发安全"""
def __init__(self, db_path: str, table_name: str = "scraped_data"):
"""
初始化SQLite存储
Args:
db_path: 数据库文件路径
table_name: 表名
"""
self.db_path = Path(db_path)
self.table_name = table_name
self.local = threading.local()
# 确保目录存在
self.db_path.parent.mkdir(parents=True, exist_ok=True)
# 初始化数据库和表
self._init_db()
def _get_connection(self) -> sqlite3.Connection:
"""获取线程安全的数据库连接"""
if not hasattr(self.local, 'connection'):
self.local.connection = sqlite3.connect(
str(self.db_path),
check_same_thread=False
)
self.local.connection.row_factory = sqlite3.Row
return self.local.connection
@contextmanager
def _get_cursor(self):
"""上下文管理器获取游标"""
conn = self._get_connection()
cursor = conn.cursor()
try:
yield cursor
conn.commit()
except Exception as e:
conn.rollback()
raise e
finally:
cursor.close()
def _init_db(self):
"""初始化数据库表"""
create_table_sql = f"""
CREATE TABLE IF NOT EXISTS {self.table_name} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
url TEXT UNIQUE,
title TEXT,
content TEXT,
author TEXT,
publish_date TEXT,
tags TEXT,
status TEXT DEFAULT 'pending',
created_at TEXT DEFAULT CURRENT_TIMESTAMP,
updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
metadata TEXT
)
"""
create_index_sql = f"""
CREATE INDEX IF NOT EXISTS idx_url ON {self.table_name}(url);
CREATE INDEX IF NOT EXISTS idx_status ON {self.table_name}(status);
CREATE INDEX IF NOT EXISTS idx_created_at ON {self.table_name}(created_at);
"""
with self._get_cursor() as cursor:
cursor.execute(create_table_sql)
cursor.executescript(create_index_sql)
def save(self, data: Dict[str, Any]) -> bool:
"""
保存单条数据
Args:
data: 要保存的数据
Returns:
保存是否成功
"""
try:
columns = ['url', 'title', 'content', 'author', 'publish_date', 'tags', 'metadata']
# 处理metadata（将其转为JSON字符串）
if 'metadata' in data and isinstance(data['metadata'], dict):
data['metadata'] = json.dumps(data['metadata'], ensure_ascii=False)
# 构建INSERT OR REPLACE语句
placeholders = ', '.join(['?' * len(columns)])
columns_str = ', '.join(columns)
sql = f"""
INSERT OR REPLACE INTO {self.table_name}
({columns_str}, updated_at)
VALUES ({placeholders}, datetime('now'))
"""
values = [data.get(col, '') for col in columns]
with self._get_cursor() as cursor:
cursor.execute(sql, values)
return True
except Exception as e:
print(f"保存数据失败: {e}")
return False
def save_batch(self, data_list: List[Dict[str, Any]]) -> bool:
"""
批量保存数据
Args:
data_list: 数据列表
Returns:
保存是否成功
"""
try:
columns = ['url', 'title', 'content', 'author', 'publish_date', 'tags', 'metadata']
placeholders = ', '.join(['?' * len(columns)])
columns_str = ', '.join(columns)
sql = f"""
INSERT OR REPLACE INTO {self.table_name}
({columns_str}, updated_at)
VALUES ({placeholders}, datetime('now'))
"""
batch_values = []
for data in data_list:
if 'metadata' in data and isinstance(data['metadata'], dict):
data['metadata'] = json.dumps(data['metadata'], ensure_ascii=False)
values = [data.get(col, '') for col in columns]
batch_values.append(values)
with self._get_cursor() as cursor:
cursor.executemany(sql, batch_values)
return True
except Exception as e:
print(f"批量保存失败: {e}")
return False
def exists(self, url: str) -> bool:
"""
检查URL是否已存在
Args:
url: 要检查的URL
Returns:
是否存在
"""
sql = f"SELECT 1 FROM {self.table_name} WHERE url = ?"
with self._get_cursor() as cursor:
cursor.execute(sql, (url,))
return cursor.fetchone() is not None
def get_pending_urls(self, limit: int = 100) -> List[str]:
"""
获取待处理的URL列表（用于断点续传）
Args:
limit: 获取数量
Returns:
URL列表
"""
sql = f"""
SELECT url FROM {self.table_name}
WHERE status = 'pending'
ORDER BY created_at
LIMIT ?
"""
with self._get_cursor() as cursor:
cursor.execute(sql, (limit,))
return [row['url'] for row in cursor.fetchall()]
def update_status(self, url: str, status: str) -> bool:
"""
更新URL状态
Args:
url: URL
status: 新状态
Returns:
是否更新成功
"""
sql = f"""
UPDATE {self.table_name}
SET status = ?, updated_at = datetime('now')
WHERE url = ?
"""
try:
with self._get_cursor() as cursor:
cursor.execute(sql, (status, url))
return True
except Exception as e:
print(f"更新状态失败: {e}")
return False
def count(self, status: Optional[str] = None) -> int:
"""
统计数据条数
Args:
status: 可选的状态过滤
Returns:
数据条数
"""
if status:
sql = f"SELECT COUNT(*) as cnt FROM {self.table_name} WHERE status = ?"
params = (status,)
else:
sql = f"SELECT COUNT(*) as cnt FROM {self.table_name}"
params = ()
with self._get_cursor() as cursor:
cursor.execute(sql, params)
return cursor.fetchone()['cnt']
def close(self):
"""关闭数据库连接"""
if hasattr(self.local, 'connection'):
self.local.connection.close()3.3 第三步：MongoDB存储 - 文档型数据库方案
对于复杂的嵌套数据结构和需要高并发读写的场景，MongoDB是更好的选择。
MongoDB存储实现：
# storage/mongodb_storage.py
from pymongo import MongoClient, ASCENDING, DESCENDING
from pymongo.errors import DuplicateKeyError, BulkWriteError
from typing import List, Dict, Any, Optional, Callable
from datetime import datetime
from pathlib import Path
import json
import threading
class MongoDBStorage:
"""MongoDB数据库存储，支持高并发和复杂数据结构"""
def __init__(
self,
host: str = "localhost",
port: int = 27017,
database: str = "crawler_db",
collection: str = "scraped_data",
username: str = "",
password: str = "",
max_pool_size: int = 50
):
"""
初始化MongoDB存储
Args:
host: MongoDB主机地址
port: MongoDB端口
database: 数据库名
collection: 集合名
username: 用户名（可选）
password: 密码（可选）
max_pool_size: 最大连接池大小
"""
self.host = host
self.port = port
self.database_name = database
self.collection_name = collection
self.lock = threading.Lock()
# 构建连接字符串
if username and password:
uri = f"mongodb://{username}:{password}@{host}:{port}/?maxPoolSize={max_pool_size}"
else:
uri = f"mongodb://{host}:{port}/?maxPoolSize={max_pool_size}"
self.client = MongoClient(uri)
self.db = self.client[database]
self.collection = self.db[collection]
# 创建索引
self._ensure_indexes()
def _ensure_indexes(self):
"""确保必要的索引存在"""
try:
# URL唯一索引 - 防止重复爬取
self.collection.create_index([("url", ASCENDING)], unique=True, background=True)
# 状态索引 - 快速查询待处理数据
self.collection.create_index([("status", ASCENDING)], background=True)
# 时间索引 - 按时间排序
self.collection.create_index([("created_at", DESCENDING)], background=True)
# 全文搜索索引（如果需要）
# self.collection.create_index([("title", "text"), ("content", "text")])
except Exception as e:
print(f"创建索引失败: {e}")
def save(self, data: Dict[str, Any]) -> bool:
"""
保存单条数据
Args:
data: 要保存的数据
Returns:
保存是否成功
"""
try:
# 添加时间戳
data['created_at'] = datetime.now()
data['updated_at'] = datetime.now()
if '_id' in data:
del data['_id']
result = self.collection.insert_one(data)
return result.inserted_id is not None
except DuplicateKeyError:
# URL已存在，执行更新
return self._update_by_url(data)
except Exception as e:
print(f"保存数据失败: {e}")
return False
def _update_by_url(self, data: Dict[str, Any]) -> bool:
"""根据URL更新数据"""
try:
url = data.get('url')
if not url:
return False
data['updated_at'] = datetime.now()
if '_id' in data:
del data['_id']
result = self.collection.update_one(
{'url': url},
{'$set': data}
)
return result.modified_count > 0 or result.matched_count > 0
except Exception as e:
print(f"更新数据失败: {e}")
return False
def save_batch(self, data_list: List[Dict[str, Any]]) -> Tuple[int, int]:
"""
批量保存数据
Args:
data_list: 数据列表
Returns:
(成功数量, 失败数量)
"""
if not data_list:
return (0, 0)
try:
# 预处理数据
processed_data = []
for data in data_list:
data_copy = data.copy()
data_copy['created_at'] = datetime.now()
data_copy['updated_at'] = datetime.now()
if '_id' in data_copy:
del data_copy['_id']
processed_data.append(data_copy)
# 使用unordered=True提高批量插入效率
result = self.collection.insert_many(processed_data, ordered=False)
return (len(result.inserted_ids), 0)
except BulkWriteError as e:
# 部分插入成功
success_count = e.details.get('nInserted', 0)
fail_count = len(data_list) - success_count
return (success_count, fail_count)
except Exception as e:
print(f"批量保存失败: {e}")
return (0, len(data_list))
def exists(self, url: str) -> bool:
"""
检查URL是否已存在
Args:
url: 要检查的URL
Returns:
是否存在
"""
return self.collection.count_documents({'url': url}, limit=1) > 0
def get_pending_urls(self, limit: int = 100) -> List[str]:
"""
获取待处理的URL列表
Args:
limit: 获取数量
Returns:
URL列表
"""
cursor = self.collection.find(
{'status': 'pending'},
{'url': 1}
).sort('created_at', ASCENDING).limit(limit)
return [doc['url'] for doc in cursor]
def update_status(self, url: str, status: str) -> bool:
"""
更新URL状态
Args:
url: URL
status: 新状态
Returns:
是否更新成功
"""
try:
result = self.collection.update_one(
{'url': url},
{
'$set': {
'status': status,
'updated_at': datetime.now()
}
}
)
return result.modified_count > 0 or result.matched_count > 0
except Exception as e:
print(f"更新状态失败: {e}")
return False
def update_batch_status(self, urls: List[str], status: str) -> int:
"""
批量更新状态
Args:
urls: URL列表
status: 新状态
Returns:
更新成功的数量
"""
try:
result = self.collection.update_many(
{'url': {'$in': urls}},
{
'$set': {
'status': status,
'updated_at': datetime.now()
}
}
)
return result.modified_count
except Exception as e:
print(f"批量更新状态失败: {e}")
return 0
def query(
self,
filter_dict: Optional[Dict] = None,
projection: Optional[List[str]] = None,
limit: int = 100,
skip: int = 0,
sort_field: str = "created_at",
sort_order: int = DESCENDING
) -> List[Dict]:
"""
查询数据
Args:
filter_dict: 查询条件
projection: 返回字段
limit: 返回数量限制
skip: 跳过数量
sort_field: 排序字段
sort_order: 排序方向
Returns:
数据列表
"""
filter_dict = filter_dict or {}
projection = projection or None
cursor = self.collection.find(filter_dict, projection) \
.sort(sort_field, sort_order) \
.skip(skip) \
.limit(limit)
results = []
for doc in cursor:
# 转换ObjectId为字符串
if '_id' in doc:
doc['_id'] = str(doc['_id'])
# 转换datetime为字符串
if 'created_at' in doc and isinstance(doc['created_at'], datetime):
doc['created_at'] = doc['created_at'].isoformat()
if 'updated_at' in doc and isinstance(doc['updated_at'], datetime):
doc['updated_at'] = doc['updated_at'].isoformat()
results.append(doc)
return results
def count(self, filter_dict: Optional[Dict] = None) -> int:
"""
统计数据条数
Args:
filter_dict: 可选的查询条件
Returns:
数据条数
"""
filter_dict = filter_dict or {}
return self.collection.count_documents(filter_dict)
def aggregate(self, pipeline: List[Dict]) -> List[Dict]:
"""
聚合查询
Args:
pipeline: 聚合管道
Returns:
聚合结果
"""
cursor = self.collection.aggregate(pipeline, allowDiskUse=True)
return list(cursor)
def close(self):
"""关闭数据库连接"""
if self.client:
self.client.close()四、避坑指南：实战经验总结
4.1 文件存储的坑
坑1：JSON文件损坏
# 错误做法：每次保存都重写整个文件
def save(self, data):
self.data.append(data)
with open('data.json', 'w') as f:
json.dump(self.data, f) # 大数据量时容易损坏
# 正确做法：使用追加模式和缓冲
def save(self, data):
with open('data.jsonl', 'a') as f:
f.write(json.dumps(data) + '
') # JSONL格式更安全坑2：CSV中文乱码
# 错误写法
writer = csv.writer(f)
writer.writerow(['中文', '测试'])
# 正确写法：指定编码
writer = csv.writer(f)
writer.writerow(['中文', '测试'].__class__('utf-8-sig'))
# 或者使用
with open('data.csv', 'w', newline='', encoding='utf-8-sig') as f:坑3：并发写入冲突
# 错误做法：多线程同时写入
def save(data):
with open('data.txt', 'a') as f:
f.write(data) # 会导致数据错乱
# 正确做法：使用锁保护
import threading
lock = threading.Lock()
def save(data):
with lock:
with open('data.txt', 'a') as f:
f.write(data)4.2 数据库存储的坑
坑4：SQLite并发写入阻塞
# 错误做法：每个线程创建独立连接
def worker():
conn = sqlite3.connect('test.db') # 每个线程都创建连接
# 多个连接同时写入会导致数据库锁定
# 正确做法：使用连接池或队列
from queue import Queue
write_queue = Queue()
def writer_worker():
conn = sqlite3.connect('test.db')
while True:
data = write_queue.get()
# 批量写入坑5：MongoDB连接泄漏
# 错误做法：不关闭连接
storage = MongoDBStorage()
# 使用后没有关闭
# 正确做法：使用上下文管理器或确保关闭
try:
storage = MongoDBStorage()
# 使用存储
finally:
storage.close()
# 或者使用 with 语句（如果实现了__enter__和__exit__）坑6：SQL注入风险
# 错误做法：字符串拼接SQL
def query(table_name):
sql = f"SELECT * FROM {table_name}" # 危险！
# 正确做法：参数化查询
def query(table_name):
sql = "SELECT * FROM %s" # 表名需要白名单验证
# 或者使用 SQLAlchemy 的 text()4.3 性能优化建议
坑7：频繁小批量写入
# 错误做法：每条数据都写入一次
for item in items:
storage.save(item) # 10000条数据就要写10000次
# 正确做法：批量写入
storage.save_batch(items) # 一次写入10000条坑8：没有创建索引
# MongoDB示例：创建索引
collection.create_index([("url", ASCENDING)], unique=True)
collection.create_index([("status", ASCENDING)])
collection.create_index([("created_at", DESCENDING)])坑9：内存占用过高
# 错误做法：一次性加载所有数据
all_data = storage.get_all() # 大数据量时内存爆炸
# 正确做法：分批处理
def process_in_batches(storage, batch_size=1000):
offset = 0
while True:
batch = storage.query(limit=batch_size, skip=offset)
if not batch:
break
process(batch)
offset += batch_size五、效果展示：存储方案对比
5.1 性能对比测试
以下是针对不同存储方案的性能测试结果（测试环境：10000条数据，每条约1KB）：
| 存储方案 | 写入速度 | 查询速度 | 内存占用 | 适用规模 |
| ------- | ------- | -------- | ---- | ------- |
| JSON文件 | 500条/秒 | 慢（全文件读取） | 中 | <10万条 |
| CSV文件 | 2000条/秒 | 中 | 低 | <100万条 |
| SQLite | 3000条/秒 | 快 | 低 | <1000万条 |
| MongoDB | 5000条/秒 | 快 | 高 | 亿级数据 |5.2 代码使用示例
# 1. JSON存储 - 最简单
storage = JSONStorage('data/articles.json')
storage.save({'title': 'Python爬虫教程', 'url': 'https://example.com/1'})
# 2. CSV存储 - 适合数据分析
storage = CSVStorage('data/articles.csv', fieldnames=['title', 'url', 'author'])
storage.save({'title': 'Python爬虫教程', 'url': 'https://example.com/1', 'author': '张三'})
# 3. SQLite存储 - 中小型项目首选
storage = SQLiteStorage('data/crawler.db', 'articles')
storage.save({
'url': 'https://example.com/1',
'title': 'Python爬虫教程',
'content': '内容...',
'author': '张三',
'metadata': {'source': 'website'}
})
# 4. MongoDB存储 - 复杂数据和高并发
storage = MongoDBStorage(
host='localhost',
database='crawler_db',
collection='articles'
)
storage.save({
'url': 'https://example.com/1',
'title': 'Python爬虫教程',
'content': '内容...',
'tags': ['Python', '爬虫'],
'metadata': {'views': 1000, 'likes': 50}
})六、总结与展望
6.1 方案选型建议
| 场景 | 推荐方案 |
| ----------- | ---------------- |
| 学习练习、简单脚本 | JSON/CSV文件 |
| 中小型爬虫项目 | SQLite |
| 企业级应用、分布式爬虫 | MySQL/PostgreSQL |
| 复杂嵌套数据、快速迭代 | MongoDB |
| 高频访问、实时数据 | Redis + MongoDB |6.2 进阶方向
-
分布式爬虫：使用Scrapy-Redis或Scrapy-Cluster
-
数据管道：使用Airflow或Luigi构建数据工作流
-
数据仓库：使用ClickHouse或ElasticSearch进行OLAP分析
-
监控告警：接入Prometheus+Grafana监控爬虫状态
6.3 核心要点回顾
• 数据存储是爬虫工程化的第一步 • 断点续传是生产环境爬虫的必备功能 • 根据数据规模和业务需求选择合适的存储方案 • 并发安全和错误处理是稳定性的关键 • 监控和告警帮助你及时发现问题
───
相关技术栈：Python 3.8+ | requests | BeautifulSoup | SQLAlchemy | pymongo | Redis | pandas
推荐阅读：
• Scrapy分布式爬虫实战 • MongoDB高级查询优化 • 数据管道工程实践
───
作者简介：多年Python开发工程师，专注于爬虫技术、数据采集和自动化领域。分享实用技术，输出实战经验。