20K Java+AI 岗位高频考点 — 向量检索是RAG和AI应用的核心基础设施,面试高频考察Embedding原理、HNSW/IVF算法、Milvus/pgvector实战。覆盖向量模型、检索算法、Spring AI集成、性能优化。
Embedding = 将文本/图片等转化为固定长度的浮点向量
使得语义相近的内容在向量空间中距离相近
示例:
"Java编程" → [0.23, -0.15, 0.89, ..., 0.12] (1536维)
"Java开发" → [0.22, -0.14, 0.88, ..., 0.11] (相近)
"红烧肉食谱" → [0.01, 0.95, -0.33, ..., 0.67] (不同)
维度:通常是256/384/768/1536维
距离度量:余弦相似度(cosine)、L2距离(euclidean)、内积(dot product)
| 模型 | 提供方 | 维度 | 特点 |
|---|---|---|---|
| text-embedding-3-small | OpenAI | 1536 | 通用,API调用 |
| text-embedding-3-large | OpenAI | 3072 | 高精度 |
| bge-large-zh-v1.5 | BAAI | 1024 | 中文最强(开源) |
| bge-m3 | BAAI | 1024 | 多语言+多粒度 |
| gte-large-zh | Alibaba | 1024 | 中文优秀 |
| Cohere embed-v3 | Cohere | 1024 | 搜索优化 |
| E5-mistral-7b | Microsoft | 4096 | 高精度大模型 |
// 余弦相似度(最常用,范围[-1,1])
public static float cosineSimilarity(float[] a, float[] b) {
float dot = 0, normA = 0, normB = 0;
for (int i = 0; i < a.length; i++) {
dot += a[i] * b[i];
normA += a[i] * a[i];
normB += b[i] * b[i];
}
return (float) (dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-8));
}
// L2距离(越小越相似)
public static float l2Distance(float[] a, float[] b) {
float sum = 0;
for (int i = 0; i < a.length; i++) {
sum += (a[i] - b[i]) * (a[i] - b[i]);
}
return (float) Math.sqrt(sum);
}
@Configuration
public class EmbeddingConfig {
@Bean
public EmbeddingModel embeddingModel(RestClient.Builder restClient) {
return new OpenAiEmbeddingModel(restClient,
OpenAiApi.builder().apiKey(System.getenv("OPENAI_API_KEY")).build(),
MetadataMode.EMBED,
OpenAiEmbeddingOptions.builder()
.model("text-embedding-3-small")
.dimensions(1536)
.build());
}
}
// 使用
@Autowired EmbeddingModel embeddingModel;
public float[] embed(String text) {
return embeddingModel.embed(text);
}
// 批量
public List<float[]> embedBatch(List<String> texts) {
return embeddingModel.embed(texts, EmbeddingOptions.EMPTY);
}
暴力搜索(KNN):
- 与所有向量计算距离,取Top-K
- 精度100%,但O(N)复杂度
- 百万级以上不可接受
近似最近邻(ANN):
- 牺牲少量精度换取100-1000倍加速
- 召回率通常>95%
- 适合大规模向量检索
ANN算法分类:
- 基于图:HNSW、NSW
- 基于量化:PQ、OPQ、SQ
- 基于树:KD-Tree、Annoy
- 基于哈希:LSH
- 基于聚类:IVF、IVF-PQ
HNSW = Hierarchical Navigable Small World
核心思想:多层图结构,上层稀疏下层密集
查找时从上层开始,逐层向下逼近目标
构建:
1. 随机决定节点出现在哪些层
2. 每层维护一个Navigable Small World图
3. 新节点连接到最近的M个邻居
查询:
1. 从最高层入口开始
2. 在当前层贪心搜索最近邻
3. 到达局部最优后进入下一层
4. 最底层找到精确最近邻
参数:
M = 16-64:每层最大连接数(越大越准但越慢)
ef_construction = 100-200:构建时搜索宽度
ef_search = 50-200:查询时搜索宽度
性能:百万级向量,查询 < 1ms
IVF(Inverted File Index):
1. 对所有向量做K-Means聚类(如1024个聚类中心)
2. 每个向量归属最近的聚类中心
3. 查询时只搜索最近的nprobe个聚类
PQ(Product Quantization):
1. 将向量切分为M个子空间(如128维切8个16维)
2. 每个子空间独立做K-Means(256个中心)
3. 每个子向量用1字节编码(中心ID)
4. 128维float(512B) → 8字节,压缩64倍
IVF+PQ联合:
1. IVF筛选候选聚类(减少搜索范围)
2. PQ快速计算距离(压缩存储+快速比较)
3. 精排时用原始向量重算
适合:亿级向量,内存敏感场景
Facebook开源的向量检索库(Python/C++)
常用索引:
IndexFlatL2 → 暴力搜索(精确)
IndexIVFFlat → IVF + 原始向量
IndexIVFPQ → IVF + PQ量化
IndexHNSWFlat → HNSW图索引
IndexScalarQuantizer → 标量量化
Java集成:
- JNI直接调用
- 或通过Milvus(内置Faiss)
GPU加速:
faiss.index_gpu_to_cpu / index_cpu_to_gpu
适合:亿级向量,需要GPU加速
组件:
- Proxy:客户端入口,解析请求
- Coordinator:元数据管理+调度
- Worker Node:数据读写+索引构建
- Storage:MinIO/S3(对象) + etcd(元数据) + Kafka/Wal(日志)
特性:
- 云原生,存算分离
- 支持HNSW/IVF_PQ/SCANN等多种索引
- CRUD + 标量过滤 + 向量检索
- 水平扩展
- 多租户
数据模型:
Collection(表) → Field(列) → Index(索引)
字段类型:FloatVector, BinaryVector, Int64, VarChar, JSON, Array
// Spring AI Milvus集成
@Configuration
public class MilvusConfig {
@Bean
public VectorStore vectorStore(EmbeddingModel embeddingModel) {
MilvusVectorStoreOptions options = MilvusVectorStoreOptions.builder()
.collectionName("documents")
.databaseName("default")
.indexType(IndexType.IVF_FLAT)
.metricType(MetricType.COSINE)
.build();
return MilvusVectorStore.builder()
.embeddingModel(embeddingModel)
.milvusClient(milvusClient())
.options(options)
.build();
}
@Bean
public MilvusServiceClient milvusClient() {
return ConnectParam.newBuilder()
.withHost("localhost")
.withPort(19530)
.build();
}
}
// 使用
@Autowired VectorStore vectorStore;
// 添加文档
vectorStore.add(List.of(
new Document("Java是面向对象语言", Map.of("source", "wiki", "category", "programming")),
new Document("Spring是Java框架", Map.of("source", "docs", "category", "framework"))
));
// 搜索
List<Document> results = vectorStore.similaritySearch(
SearchRequest.builder()
.query("什么是Java")
.topK(5)
.filterExpression("category == 'programming'")
.build());
| 索引 | 构建速度 | 查询速度 | 内存 | 适用 |
|---|---|---|---|---|
| FLAT | 快 | 慢 | 高 | 小数据集/精确搜索 |
| IVF_FLAT | 中 | 中 | 中 | 百万级通用 |
| IVF_PQ | 慢 | 快 | 低 | 内存敏感/亿级 |
| HNSW | 慢 | 最快 | 高 | 低延迟要求 |
| SCANN | 慢 | 快 | 中 | Google优化方案 |
// 向量检索 + 标量过滤
SearchRequest request = SearchRequest.builder()
.query("如何学习Java")
.topK(10)
.filterExpression("category == 'tutorial' AND year >= 2024")
.similarityThreshold(0.7)
.build();
// Milvus支持丰富的过滤表达式:
// field == value, field > value, field IN [v1, v2]
// field LIKE '%keyword%', JSON字段过滤
// array_contains(field, value)
CREATE EXTENSION vector;
CREATE TABLE documents (
id bigserial PRIMARY KEY,
content text NOT NULL,
embedding vector(1536),
metadata jsonb
);
-- HNSW索引
CREATE INDEX idx_doc_embedding ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- 查询
SELECT id, content, 1 - (embedding <=> $query_vector) AS similarity
FROM documents
WHERE metadata->>'category' = 'java'
ORDER BY embedding <=> $query_vector
LIMIT 5;
| 维度 | pgvector | Milvus |
|---|---|---|
| 类型 | PG扩展 | 独立向量库 |
| 最大规模 | 百万级 | 十亿级 |
| SQL查询 | 完整SQL | 有限过滤 |
| 运维 | PG运维即可 | 独立运维 |
| 事务 | ACID | 有限 |
| 适用 | 中小规模+SQL | 大规模+高并发 |
建议:<百万级+已有PG → pgvector;百万级以上+高并发 → Milvus
分块大小影响检索质量:
- 太小(100字):语义不完整
- 太大(2000字):噪声太多
- 推荐:300-800字,重叠50-100字
分块方式:
1. 固定大小:简单但可能截断句子
2. 按段落:保留语义完整性
3. 按标题(Markdown Header):保留文档结构
4. 语义分块:基于Embedding相似度切分
Spring AI TextSplitter:
TokenTextSplitter splitter = new TokenTextSplitter(800, 100, 5, 10000, true);
List<Document> chunks = splitter.split(document);
问题:小块检索精度高但上下文不完整
方案:小块检索,返回大块上下文
实现:
1. 大块(2000字)作为父文档,存入vector_store
2. 小块(500字)作为子文档,存入vector_store_child
3. 子文档的metadata中记录parentId
检索:
1. 用query搜索子文档
2. 通过parentId找到父文档
3. 返回父文档的完整上下文给LLM
// 向量检索 + 关键词检索 + RRF融合
@Service
public class HybridSearchService {
@Autowired VectorStore vectorStore;
@Autowired ElasticsearchService esService;
public List<Document> hybridSearch(String query, int topK) {
// 1. 向量检索
List<Document> vectorResults = vectorStore.similaritySearch(
SearchRequest.builder().query(query).topK(topK * 3).build());
// 2. 关键词检索
List<Document> keywordResults = esService.search(query, topK * 3);
// 3. RRF融合
Map<String, Double> scores = new HashMap<>();
int k = 60;
for (int i = 0; i < vectorResults.size(); i++) {
scores.merge(vectorResults.get(i).getId(), 1.0 / (k + i + 1), Double::sum);
}
for (int i = 0; i < keywordResults.size(); i++) {
scores.merge(keywordResults.get(i).getId(), 1.0 / (k + i + 1), Double::sum);
}
return scores.entrySet().stream()
.sorted(Map.Entry.<String, Double>comparingByValue().reversed())
.limit(topK)
.map(e -> findById(e.getKey()))
.collect(Collectors.toList());
}
}
HNSW调优:
- m = 16:默认,平衡性能和内存
- m = 32:更高召回率,内存翻倍
- m = 64:最高召回率,内存4倍
- ef_construction = 200:构建质量(越高越好,构建越慢)
- ef_search = 100:查询质量(越高越准,查询越慢)
经验:
- m=16, ef_search=100 → 召回率>95%,延迟<5ms
- m=32, ef_search=200 → 召回率>99%,延迟<10ms
- 生产推荐:m=32, ef_construction=200, ef_search=100
IVF调优:
- nlist = sqrt(N):聚类数(N为向量数)
- nprobe = 10-50:搜索聚类数
1. 量化压缩:
- PQ:压缩4-8倍,精度损失<5%
- SQ:压缩2倍,精度损失<2%
2. 分区:
- 按时间分区(只搜索近期数据)
- 按业务分区(只搜索相关数据)
3. 缓存:
- 热点查询结果缓存
- Embedding结果缓存
4. 批处理:
- 批量插入(1000条/批)
- 批量查询
5. 预计算:
- 查询Embedding预计算缓存
- 热门查询预计算结果
文本+图片联合检索:
CLIP模型:将文本和图片映射到同一向量空间
- "一只猫" 和 猫的图片 → 相似的向量
Java实现:
// 图片Embedding
float[] imageEmbedding = clipModel.embedImage(imageFile);
// 文本Embedding
float[] textEmbedding = clipModel.embedText("一只猫");
// 跨模态检索
List<Document> results = vectorStore.similaritySearch(
SearchRequest.builder()
.queryEmbedding(imageEmbedding) // 用图片搜文本
.topK(5).build());
决策树:
数据量?
├── <100万 → pgvector(简单,已有PG基础设施)
├── 100万-1000万 → Milvus/Qdrant/Weaviate
└── >1000万 → Milvus集群/Pinecone Serverless
需要SQL过滤?
├── 是 → pgvector / Weaviate
└── 否 → Milvus / Qdrant
团队运维能力?
├── 弱 → Pinecone(全托管)
└── 强 → Milvus(自建)
检索层优化:
1. 更好的Embedding模型(BGE > OpenAI > 默认)
2. 混合检索(向量+BM25 RRF融合)
3. Rerank重排序(BGE-Reranker/Cohere)
4. 查询改写(Multi-Query/HyDE)
5. 分块策略调优(300-800字+重叠)
索引层优化:
1. HNSW参数调优(m=32, ef_search=100)
2. 元数据过滤(缩小搜索范围)
3. 父子文档(小块检索+大块上下文)
中文场景:
1. bge-large-zh-v1.5 → 中文最强开源
2. bge-m3 → 多语言+长文本
3. gte-large-zh → 阿里达摩院
英文/多语言:
1. text-embedding-3-large → OpenAI最强
2. Cohere embed-v3 → 搜索场景优化
3. E5-mistral-7b → 最高精度
选型维度:
- 语言(中文/英文/多语言)
- 精度(准确率 vs 速度)
- 成本(API vs 自部署)
- 维度(存储成本)
Embedding三步:文本→向量→相似度计算(余弦/L2/内积)
>
ANN两算法:HNSW(图结构,快) / IVF+PQ(聚类+量化,省内存)
>
向量库三选:小规模pgvector / 中大规模Milvus / 托管Pinecone
>
RAG检索四优化:换更好Embedding + 混合检索 + Rerank + 分块调优