SpringBoot集成Milvus|（实现向量的存储和查询）

今天药忘吃喽~ 2023-10-09 18:12 44阅读 0赞

## SpringBoot集成Milvus|（实现向量的存储和查询） ##

--------------------

### 文章目录  SpringBoot集成Milvus|（实现向量的存储和查询）  @\[TOC\]  前言  一、Milvus介绍  二、Milvus数据库安装  1.Milvus安装环境准备（centos7）  2.Milvus客户端安装  3.attu新建Milvus集合  三、Milvus集成  1.依赖引入  2.客户端初始化  3.代码创建集合示例  总结 ###

章节  
第一章链接: [SpringBoot集成Milvus|（实现向量的存储和查询）][SpringBoot_Milvus]

## 前言 ##

随着互联网不断发展，电子邮件、论文、物联网传感数据、社交媒体照片、蛋白质分子结构等非结构化数据已经变得越来越普遍。如果想要使用计算机来处理这些数据，需要使用 embedding 技术将这些数据转化为向量。随后，Milvus 会存储这些向量，并为其建立索引。Milvus 能够根据两个向量之间的距离来分析他们的相关性。如果两个向量十分相似，这说明向量所代表的源数据也十分相似

## 一、Milvus介绍 ##

Milvus 是一款云原生向量数据库，它具备高可用、高性能、易拓展的特点，用于海量向量数据的实时召回。  
Milvus 基于 FAISS、Annoy、HNSW 等向量搜索库构建，核心是解决稠密向量相似度检索的问题。在向量检索库的基础上，Milvus 支持数据分区分片、数据持久化、增量数据摄取、标量向量混合查询、time travel 等功能，同时大幅优化了向量检索的性能，可满足任何向量检索场景的应用需求。通常，建议用户使用 Kubernetes 部署 Milvus，以获得最佳可用性和弹性。

## 二、Milvus数据库安装 ##

### 1.Milvus安装环境准备（centos7） ###

> 1、服务器需要部署docker以及docker-compose  
> 2、新建一个工作目录  
> 3、获取Milvus的安装启动YAML文件  
> 4、获取文件wget https://github.com/milvus-io/milvus/releases/download/v2.1.4/milvus-standalone-docker-compose.yml -O docker-compose.yml  
> 5、启动docker镜像 sudo docker-compose up -d  
> 6、启动后容器情况  
> ![在这里插入图片描述][80185f0f7c584f2d99b34a393dfb3c83.png]  
> 7、停止Milvus容器  
> sudo docker-compose down

### 2.Milvus客户端安装 ###

> 1、在docker仓库中找到Milvus对应版本的客户端镜像  
> 2、拉取镜像;docker pull zilliz/attu:v2.1.0  
> 3、运行attu  
> docker run -itd --restart=always -p 13000:3000 -e HOST\_URL=http://\{ip\}:13000 -e MILVUS\_URL=\{ip\}:19530 zilliz/attu:v2.1.0  
> ip为部署ip  
> 4、浏览器登陆访问：http://\{ip\}::13000

### 3.attu新建Milvus集合 ###

> 新建集合名称为content3，字段id是主键，content存的是内容对应的文本id，content\_intro存的是内容向量  
> ![请添加图片描述][02b128ff198e4698b2f7d3fd7beefb64.png]  
> 新建pattion  
> content3\_partion为新建的分区![请添加图片描述][1f66ef820eaa420e8b7a245a952748a9.png]

## 三、Milvus集成 ##

### 1.依赖引入 ###

> java操作Milvus的组件工具

<dependency>
           <groupId>io.milvus</groupId>
           <artifactId>milvus-sdk-java</artifactId>
           <version>2.2.4</version>
           <exclusions>
               <exclusion>
                   <groupId>org.apache.logging.log4j</groupId>
                   <artifactId>log4j-slf4j-impl</artifactId>
               </exclusion>
           </exclusions>
       </dependency>

### 2.客户端初始化 ###

> 初始化客户端使用实例，放入容器

@Configuration
    public class MilvusConfig {
        
    
        @Value("${milvus.host}")
        private String host;
        @Value("${milvus.port}")
        private Integer port;
    
        @Bean
        public MilvusServiceClient milvusServiceClient() {
        
            return new MilvusServiceClient(
                    ConnectParam.newBuilder()
                            .withHost(host)
                            .withPort(port)
                            .build());
        }
    }

### 3.代码创建集合示例 ###

> 代码初始化集合结构

public class PushMaterielsConst {
        
        /**
         * 集合名称(库名)
         */
        public static final String COLLECTION_NAME = "content3";
    
        public static final String PARTITION_NAME = "content3_partion";
    
        /**
         * 分片数量
         */
        public static final Integer SHARDS_NUM = 1;
        /**
         * 分区数量
         */
        public static final Integer PARTITION_NUM = 1;
    
        /**
         * 分区前缀
         */
        public static final String PARTITION_PREFIX = "shards_";
        /**
         * 向量值长度
         */
        public static final Integer FEATURE_DIM = 256;
    
        public static final Boolean TRUE = true;
    
        /**
         * 字段
         */
        public static class Field {
        
            /**
             * 主键idID
             */
            public static final String ID = "id";
            /**
             * 文本id
             */
            public static final String CONTENT = "content";
            /**
             * 向量值
             */
            public static final String CONTENT_INTRO = "content_intro";
        }
    
    
    }

> 创建结合代码

public void creatCollection() {
        
            FieldType fieldType1 = FieldType.newBuilder()
                    .withName(PushMaterielsConst.Field.ID)
                    .withDataType(DataType.Int64)
                    .withPrimaryKey(true)
                    .withAutoID(false)
                    .build();
            FieldType fieldType2 = FieldType.newBuilder()
                    .withName(PushMaterielsConst.Field.CONTENT)
                    .withDataType(DataType.VarChar)
                    .withMaxLength(255)
                    .build();
            FieldType fieldType3 = FieldType.newBuilder()
                    .withName(PushMaterielsConst.Field.CONTENT_INTRO)
                    .withDataType(DataType.FloatVector)
                    .withDimension(2)
                    .build();
            CreateCollectionParam createCollectionReq = CreateCollectionParam.newBuilder()
                    .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                    .withDescription("user content search")
                    .withShardsNum(2)
                    .addFieldType(fieldType1)
                    .addFieldType(fieldType2)
                    .addFieldType(fieldType3)
                    .build();
            MilvusServiceClient milvusClient = getClient();
            R<RpcStatus> response = milvusClient.createCollection(createCollectionReq);
            log.info(PushMaterielsConst.COLLECTION_NAME + "是否成功创建集合——>>" + response.getStatus());
        }

> 插入数据代码

/**
         * 插入数据
         *
         * @param milvusParamVoList
         * @return
         */
        public void insertPrepare(List<MilvusParamBo> milvusParamVoList) {
        
            List<String> content_array = new ArrayList<>();
            List<List<Float>> vector_array = new ArrayList<>();
            for (MilvusParamBo vo : milvusParamVoList) {
        
                content_array.add(vo.getContentId());
                vector_array.add(vo.getVector());
            }
    
            List<InsertParam.Field> fields = new ArrayList<>();
            fields.add(new InsertParam.Field(PushMaterielsConst.Field.CONTENT, content_array));
            fields.add(new InsertParam.Field(PushMaterielsConst.Field.CONTENT_INTRO, vector_array));
    
            InsertParam insertParam = InsertParam.newBuilder()
                    .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                    .withPartitionName(PushMaterielsConst.PARTITION_NAME)
                    .withFields(fields)
                    .build();
            R<MutationResult> insert = milvusClient.insert(insertParam);
            Integer status = insert.getStatus();
            System.out.println("数据插入状态：" + status);
        }

> 查询数据代码

public List<String> searchTallestSimilarity(List<Float> arcsoftToFloat) {
        
            log.info("----Milvus数据加载到内存------");
            loadCollection();
            List<List<Float>> list = new ArrayList<>();
            list.add(arcsoftToFloat);
            SearchParam searchParam = SearchParam.newBuilder()
                    //集合名称
                    .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                    .withPartitionNames(Arrays.asList(PushMaterielsConst.PARTITION_NAME))
                    //计算方式
                    // 欧氏距离 (L2)
                    // 内积 (IP)
                    .withMetricType(MetricType.L2)
                    .withOutFields(Arrays.asList(PushMaterielsConst.Field.CONTENT))
                    //返回多少条结果
                    .withTopK(5)
                    //搜索的向量值
                    .withVectors(list)
                    //搜索的Field
                    .withVectorFieldName(PushMaterielsConst.Field.CONTENT_INTRO)
                    .withParams(SEARCH_PARAM)
                    .build();
    
            log.info("----Milvus向量搜索------");
            R<SearchResults> search = milvusClient.search(searchParam);
            log.info("----搜索数据处理------");
            if (search.getData() == null) return null;
            List<String> returnList = Lists.newArrayList();
            SearchResultsWrapper wrapper = new SearchResultsWrapper(search.getData().getResults());
            for (int i = 0; i < list.size(); i++) {
        
                List<?> fieldData = wrapper.getFieldData(PushMaterielsConst.Field.CONTENT, i);
                for (int j = 0; j < fieldData.size(); j++) {
        
                    returnList.add((String) fieldData.get(j));
                }
            }
            return returnList;
        }
        public void loadCollection() {
        
            log.info("----Milvus加载到内存------");
            R<RpcStatus> response = milvusClient.loadPartitions(
                    LoadPartitionsParam
                            .newBuilder()
                            //集合名称
                            .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                            //需要加载的分区名称
                            .withPartitionNames(Lists.newArrayList(PushMaterielsConst.PARTITION_NAME))
                            .build());
            log.info("Milvus数据加载到内存状态：{}", response.getStatus());
        }

> 按照多条件匹配查询数据

public List<MilvesSearchDate> searchTallestSimilarityWithExpr(List<Float> arcsoftToFloat, ContentParamVo paramVo,
                                                                      String collectionName, String partionName) {
        
            Integer top = paramVo.getTop();
            if (top == null || top < 1) {
        
                top = 5;
            }
            loadCollection(collectionName, partionName);
    
            // 查询参数封装
            //1、向量查询参数
            List<List<Float>> list = new ArrayList<>();
            list.add(arcsoftToFloat);
            SearchParam.Builder builder = SearchParam.newBuilder()
                    //集合名称
                    .withCollectionName(collectionName)
                    .withPartitionNames(Arrays.asList(partionName))
                    //计算方式
                    // 欧氏距离 (L2)
                    // 内积 (IP)
                    .withMetricType(MetricType.L2)
                    .withOutFields(Arrays.asList(MilvusFileId.PARTID))
                    //返回多少条结果
                    .withTopK(top)
                    //搜索的向量值
                    .withVectors(list)
                    //搜索的Field
                    .withVectorFieldName(MilvusFileId.EMBEDDING)
                    .withParams(SEARCH_PARAM);
    //                .withExpr();
            //2、类别查询参数
            List<String> categorys = paramVo.getCategoryId();
            if (categorys != null && categorys.size() > 0) {
        
                String categoryExpr = StringUtils.join(MilvusFileId.CATEGORY, " in [", listToString(categorys), "]");
                log.info("过滤条件：{}", categoryExpr);
                builder.withExpr(categoryExpr);
            }
            //3、文章id查询参数
            List<String> docs = paramVo.getDocId();
            if (docs != null && docs.size() > 0) {
        
                String docExpr = StringUtils.join(MilvusFileId.DOCID, " in [", listToString(docs), "]");
                log.info("过滤条件：{}", docExpr);
                builder.withExpr(docExpr);
            }
            log.info("----Milvus向量搜索------");
            R<SearchResults> search = milvusClient.search(builder.build());
            log.info("----搜索数据处理------");
            if (search.getData() == null) {
        
                log.error("搜索数据返回为空");
                return null;
            }
            List<MilvesSearchDate> returnList = Lists.newArrayList();
            SearchResultsWrapper wrapper = new SearchResultsWrapper(search.getData().getResults());
            try {
        
                for (int i = 0; i < list.size(); i++) {
        
                    List<SearchResultsWrapper.IDScore> scores = wrapper.getIDScore(i);
                    List<?> fieldData = wrapper.getFieldData(MilvusFileId.PARTID, i);
                    for (int j = 0; j < fieldData.size(); j++) {
        
                        returnList.add(MilvesSearchDate.builder()
                                .partId((String) fieldData.get(j))
                                .score(scores.get(j).getScore())
                                .build());
                    }
                }
            } catch (Exception e) {
        
                log.error("解析向量匹配数据异常：{}", e.getMessage());
            }
            return returnList;
        }

## 总结 ##

上述为springboot集成Milvus数据库的实现，查询的时候存在问题，如果查询的写了前五条数据，实际只查询到3条的话，剩下的两天就会乱给（给的数据和查询文本不相干）

[SpringBoot_Milvus]: https://blog.csdn.net/Oaklkm/article/details/125890437?spm=1001.2014.3001.5502
[80185f0f7c584f2d99b34a393dfb3c83.png]: https://img-blog.csdnimg.cn/80185f0f7c584f2d99b34a393dfb3c83.png
[02b128ff198e4698b2f7d3fd7beefb64.png]: https://img-blog.csdnimg.cn/02b128ff198e4698b2f7d3fd7beefb64.png
[1f66ef820eaa420e8b7a245a952748a9.png]: https://img-blog.csdnimg.cn/1f66ef820eaa420e8b7a245a952748a9.png