30分钟教你上手用Java快速搭建你的第一个向量数据库

<dependencies>
    <dependency>
        <groupId>io.milvus</groupId>
        <artifactId>milvus-sdk-java</artifactId>
        <version>2.4.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.14.0</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>2.0.9</version>
    </dependency>
</dependencies>

import io.milvus.client.MilvusClient;
import io.milvus.param.ConnectParam;
import io.milvus.param.MilvusClientParam;
import io.milvus.param.R;
import io.milvus.param.collection.CreateCollectionParam;
import io.milvus.param.collection.FieldType;
import io.milvus.param.dml.InsertParam;
import io.milvus.param.dml.SearchParam;
import io.milvus.response.InsertResponse;
import io.milvus.response.SearchResponse;
import org.apache.commons.lang3.RandomUtils;

import java.util.ArrayList;
import java.util.List;

public class VectorDbDemo {
    // Milvus Lite 数据库连接地址（本地文件路径，自定义）
    private static final String MILVUS_URL = "localhost:19530";
    // 集合名称（类似表名，自定义）
    private static final String COLLECTION_NAME = "java_vector_demo";
    // 向量维度（需与生成的向量维度一致，这里选128维）
    private static final int VECTOR_DIM = 128;

    public static void main(String[] args) {
        // 1. 构建连接参数
        ConnectParam connectParam = ConnectParam.newBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();

        // 2. 创建 Milvus 客户端
        MilvusClient client = new MilvusClient(connectParam);

        // 测试连接是否成功
        R<Boolean> healthCheck = client.checkHealth();
        if (healthCheck.getData()) {
            System.out.println("✅ 数据库连接成功！");
        } else {
            System.out.println("❌ 数据库连接失败：" + healthCheck.getMessage());
            return;
        }

        // 后续操作（创建集合、插数、查询）将在这里补充
    }
}

// 3. 创建集合（先判断是否存在，存在则删除）
if (client.hasCollection(COLLECTION_NAME).getData()) {
    client.dropCollection(COLLECTION_NAME);
    System.out.println("⚠️  集合已存在，已删除");
}

// 定义字段：主键字段（自增ID）
FieldType idField = FieldType.newBuilder()
        .withName("id")
        .withDataType(FieldType.DataType.Int64)
        .withPrimaryKey(true)
        .withAutoID(true) // 自增
        .build();

// 定义字段：向量字段（核心）
FieldType vectorField = FieldType.newBuilder()
        .withName("content_vector")
        .withDataType(FieldType.DataType.FloatVector)
        .withDimension(VECTOR_DIM) // 向量维度与生成的一致
        .build();

// 定义字段：普通属性字段（存储文本原文，方便查询后展示）
FieldType textField = FieldType.newBuilder()
        .withName("text_content")
        .withDataType(FieldType.DataType.VarChar)
        .withMaxLength(512) // 文本最大长度
        .build();

// 构建创建集合的参数
CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
        .withCollectionName(COLLECTION_NAME)
        .addFieldType(idField)
        .addFieldType(vectorField)
        .addFieldType(textField)
        .withConsistencyLevel(CreateCollectionParam.ConsistencyLevelEnum.STRONG) // 一致性级别
        .build();

// 执行创建集合
R<Boolean> createResult = client.createCollection(createParam);
if (createResult.getData()) {
    System.out.println("✅ 集合创建成功！");
} else {
    System.out.println("❌ 集合创建失败：" + createResult.getMessage());
    client.close();
    return;
}

// 4. 生成测试数据（5条文本，模拟用户问答场景）
List<String> textList = new ArrayList<>();
textList.add("Java 中如何创建线程？有几种方式？");
textList.add("Java 线程的生命周期包括哪些状态？");
textList.add("Spring Boot 如何配置数据库连接池？");
textList.add("Spring Cloud 与 Spring Boot 的区别是什么？");
textList.add("Java 8 的 Lambda 表达式有什么用法？");

// 生成向量：将每条文本转化为128维向量（模拟，实际用模型生成）
List<List<Float>> vectorList = new ArrayList<>();
for (int i = 0; i < textList.size(); i++) {
    List<Float> vector = new ArrayList<>();
    for (int j = 0; j < VECTOR_DIM; j++) {
        // 用随机数模拟向量（真实场景替换为模型输出）
        vector.add(RandomUtils.nextFloat(0.0f, 1.0f));
    }
    vectorList.add(vector);
}

// 构建插入参数
InsertParam insertParam = InsertParam.newBuilder()
        .withCollectionName(COLLECTION_NAME)
        .addField("text_content", textList) // 插入文本字段
        .addField("content_vector", vectorList) // 插入向量字段
        .build();

// 执行插入
R<InsertResponse> insertResult = client.insert(insertParam);
if (insertResult.getData() != null) {
    System.out.println("✅ 数据插入成功！插入条数：" + textList.size());
    System.out.println("插入数据ID：" + insertResult.getData().getInsertIds());
} else {
    System.out.println("❌ 数据插入失败：" + insertResult.getMessage());
    client.close();
    return;
}

// 5. 创建向量索引（提升查询效率）
// 索引参数（IVF_FLAT 是基础索引类型，适合小数据量）
String indexParam = String.format("{\"index_type\": \"IVF_FLAT\", \"params\": {\"nlist\": 1024}, \"metric_type\": \"L2\"}");
R<Boolean> createIndexResult = client.createIndex(
        COLLECTION_NAME,
        "content_vector", // 向量字段名
        indexParam
);
if (createIndexResult.getData()) {
    System.out.println("✅ 向量索引创建成功！");
} else {
    System.out.println("❌ 索引创建失败：" + createIndexResult.getMessage());
    client.close();
    return;
}

// 6. 加载集合到内存（查询前必须执行）
R<Boolean> loadResult = client.loadCollection(COLLECTION_NAME);
if (loadResult.getData()) {
    System.out.println("✅ 集合加载到内存成功！");
} else {
    System.out.println("❌ 集合加载失败：" + loadResult.getMessage());
    client.close();
    return;
}

// 7. 执行相似度查询（模拟用户查询："Java 线程相关问题"）
String queryText = "Java 线程相关问题";
// 生成查询向量（同样用随机数模拟，真实场景与数据向量用同一模型生成）
List<Float> queryVector = new ArrayList<>();
for (int j = 0; j < VECTOR_DIM; j++) {
    queryVector.add(RandomUtils.nextFloat(0.0f, 1.0f));
}

// 构建查询参数
SearchParam searchParam = SearchParam.newBuilder()
        .withCollectionName(COLLECTION_NAME)
        .withMetricType(SearchParam.MetricType.L2) // 距离计算方式（L2为欧氏距离）
        .withTopK(2) // 返回最相似的2条数据
        .withVectorFieldName("content_vector")
        .addVector(queryVector)
        .withParams("{\"nprobe\": 10}") // 索引查询参数
        .addOutputField("text_content") // 要返回的字段
        .build();

// 执行查询
R<SearchResponse> searchResult = client.search(searchParam);
if (searchResult.getData() != null) {
    System.out.println("\n🔍 查询结果（与\"" + queryText + "\"最相似的2条数据）：");
    // 解析查询结果
    SearchResponse.Data data = searchResult.getData().get(0);
    for (int i = 0; i < data.getScoreCount(); i++) {
        float score = data.getScores().get(i); // 相似度分数（L2距离越小越相似）
        String text = data.getFields().get("text_content").get(i).toString(); // 文本内容
        System.out.println((i+1) + ". 相似度：" + String.format("%.4f", score) + "，内容：" + text);
    }
} else {
    System.out.println("❌ 查询失败：" + searchResult.getMessage());
}

// 关闭客户端
client.close();