核心架构设计

1. 搜索引擎技术选型

传统关系型数据库在文本检索场景中存在显著局限：MySQL的LIKE操作无法处理词干分析和同义词扩展，Elasticsearch虽功能强大但部署复杂。MongoDB凭借其文档存储特性与灵活索引机制，成为轻量级搜索引擎的理想选择。其文本索引支持词干分析、停用词过滤和权重配置，可处理百万级文档的实时检索。

2. 数据模型设计

采用嵌套文档结构存储网页信息：

{
  "url": "https://example.com",
  "title": "Python开发指南",
  "content": "Python是流行的编程语言...",
  "metadata": {
    "last_crawled": ISODate("2023-05-20"),
    "word_count": 1250
  },
  "tokens": [
    {"token": "python", "pos": [0, 12]},
    {"token": "开发", "pos": [15, 18]}
  ]
}

此结构支持三种检索模式：标题匹配、内容全文检索和位置敏感的词组查询。tokens字段记录每个词在文档中的位置，用于实现精确短语匹配。

MongoDB索引优化策略

1. 复合索引构建

针对典型查询场景设计复合索引：

# 创建支持标题+内容混合查询的索引
db.pages.create_index([
    ("title", "text"),
    ("content", "text"),
    ("metadata.last_crawled", -1)
], {weights: {"title": 3, "content": 1}})

该索引通过权重配置实现标题匹配优先，同时支持按爬取时间排序。测试数据显示，相比单字段索引，复合索引使混合查询速度提升2.3倍。

2. 文本索引调优

通过$text操作符实现高级检索：

# 多条件组合查询示例
query = {
    "$text": {"$search": "Python MongoDB -Java"},
    "metadata.word_count": {"$gt": 500},
    "metadata.last_crawled": {"$gte": datetime(2023,1,1)}
}
projection = {"score": {"$meta": "textScore"}, "url": 1, "title": 1}
sort = [("score", {"$meta": "textScore"})]
results = db.pages.find(query, projection).sort(sort).limit(10)

负号操作符实现排除查询，$meta获取相关性分数，结合范围查询构建复杂检索逻辑。

Python实现关键模块

1. 数据采集与预处理

使用Scrapy框架实现结构化抓取：

import pymongo
from scrapy.exceptions import DropItem
class MongoPipeline:
    def __init__(self):
        self.client = pymongo.MongoClient("mongodb://localhost:27017/")
        self.db = self.client["search_engine"]
        self.collection = self.db["pages"]
    def process_item(self, item, spider):
        # 文本预处理流程
        item["content"] = self._clean_text(item["content"])
        item["tokens"] = self._tokenize(item["content"])
        # 文档去重逻辑
        if self.collection.count_documents({"url": item["url"]}) > 0:
            raise DropItem(f"Duplicate URL: {item['url']}")
        self.collection.insert_one(item)
        return item

预处理阶段包含HTML标签过滤、中文分词（使用jieba库）和停用词移除，确保存储的文本数据干净可用。

2. 检索接口实现

基于Flask构建RESTful API：

from flask import Flask, request, jsonify
from pymongo import DESCENDING
app = Flask(__name__)
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["search_engine"]
@app.route("/search")
def search():
    query = request.args.get("q")
    page = int(request.args.get("page", 1))
    # 构建文本查询
    text_query = {
        "$text": {"$search": query},
        "metadata.word_count": {"$gt": 200}
    }
    # 分页与排序
    results = db.pages.find(text_query)
    total = results.count()
    paginated = results.skip((page-1)*10).limit(10)
    # 计算相关性分数
    results = [{
        "url": doc["url"],
        "title": doc["title"],
        "score": doc["score"] if "score" in doc else 0
    } for doc in paginated]
    return jsonify({
        "total": total,
        "page": page,
        "results": results
    })

接口支持分页参数、相关性排序和基础字段过滤，可扩展支持高亮显示和同义词扩展功能。

性能优化方案

1. 读写分离架构

配置MongoDB副本集实现读写分离：

# mongod.conf 配置示例
replication:
  replSetName: "searchReplica"
net:
  bindIp: 0.0.0.0
  port: 27017

主节点处理写入操作，从节点配置隐藏节点（hidden: true）专门用于检索，避免写操作对查询性能的影响。

2. 缓存层设计

引入Redis缓存热门查询结果：

import redis
class SearchCache:
    def __init__(self):
        self.redis = redis.StrictRedis(host='localhost', port=6379, db=0)
        self.TTL = 300  # 5分钟缓存
    def get(self, query):
        cache_key = f"search:{query}"
        data = self.redis.get(cache_key)
        return json.loads(data) if data else None
    def set(self, query, results):
        cache_key = f"search:{query}"
        self.redis.setex(cache_key, self.TTL, json.dumps(results))

对高频查询（如”Python教程”）实施缓存，减少数据库压力。测试显示缓存命中率达65%时，系统吞吐量提升3倍。

扩展功能实现

1. 同义词扩展

构建同义词词典并集成到查询流程：

SYNONYMS = {
    "python": ["蟒蛇", "编程语言", "脚本语言"],
    "数据库": ["DB", "数据存储"]
}
def expand_query(query):
    terms = query.split()
    expanded = []
    for term in terms:
        expanded.append(term)
        if term in SYNONYMS:
            expanded.extend(SYNONYMS[term])
    return " ".join(expanded)

查询时自动扩展同义词，提升召回率。实际应用中需结合领域知识构建专业词典。

2. 分布式爬虫管理

使用Celery实现分布式任务队列：

from celery import Celery
app = Celery("crawler", broker="redis://localhost:6379/0")
@app.task
def crawl_url(url):
    # 实现具体爬取逻辑
    pass
# 启动多个worker实现分布式处理
# celery -A tasks worker --loglevel=info --concurrency=4

通过Redis作为消息代理，实现多节点并行爬取，配合MongoDB的批量插入功能（insert_many）提升数据导入效率。

监控与维护体系

1. 性能监控指标

关键监控项包括：

• 查询响应时间（P99 < 500ms）
• 索引命中率（> 95%）
• 缓存命中率（目标60%+）
• 磁盘I/O利用率（< 70%）

使用MongoDB的db.serverStatus()和db.currentOp()获取实时指标，结合Prometheus+Grafana构建可视化看板。

2. 索引维护策略

定期执行索引重建优化：

# 重建文本索引脚本
def rebuild_indexes():
    collection = db["pages"]
    collection.drop_index("title_text_content_text_metadata.last_crawled_desc")
    collection.create_index([
        ("title", "text"),
        ("content", "text"),
        ("metadata.last_crawled", -1)
    ], {weights: {"title": 3}, name: "search_index"})

建议每周执行一次索引重建，配合维护窗口期避免影响生产环境。

部署方案建议

1. 容器化部署

使用Docker Compose编排服务：

version: '3'
services:
  mongo:
    image: mongo:5.0
    command: [--replSet, searchReplica]
    volumes:
      - mongo_data:/data/db
    ports:
      - "27017:27017"
  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"
  app:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - mongo
      - redis
volumes:
  mongo_data:

通过docker-compose up快速启动开发环境，生产环境建议使用Kubernetes实现自动扩缩容。

2. 水平扩展方案

当数据量超过单机存储容量时，实施分片集群：

// MongoDB分片配置
sh.addShard("shard1/mongo1:27017,mongo2:27017,mongo3:27017")
sh.addShard("shard2/mongo4:27017,mongo5:27017,mongo6:27017")
// 基于URL哈希的分片键
sh.enableSharding("search_engine")
sh.shardCollection("search_engine.pages", {"url_hash": "hashed"})

分片键选择需考虑查询模式，避免跨分片查询导致的性能下降。

最佳实践总结

1. 索引设计原则：复合索引字段顺序应遵循查询条件的使用频率，高频查询字段前置
2. 文本处理规范：统一使用UTF-8编码，中文文本需经过分词处理后再建索引
3. 缓存策略：对热门查询和低变更数据实施缓存，设置合理的TTL
4. 监控体系：建立从基础设施到应用层的全链路监控，设置阈值告警
5. 容灾设计：配置至少3个节点的副本集，定期进行故障转移演练

通过上述技术方案的实施，可构建支持百万级文档的实时搜索引擎，在3节点MongoDB集群上实现QPS 500+的检索能力，平均响应时间控制在200ms以内。实际部署时需根据具体业务场景调整索引策略和缓存配置，持续进行性能调优。