Java 结合向量数据库实现智能商品推荐系统

原创于 2025-12-05 10:17:55 发布 · 638 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#java #数据库 #开发语言

数据库同时被 3 个专栏收录

57 篇文章

订阅专栏

人工智能AI

49 篇文章

订阅专栏

Java 进阶

23 篇文章

订阅专栏

AI赋能编程语言挑战赛 7w人浏览 94人参与

在电商领域，个性化推荐已成为提升用户体验和转化率的核心驱动力。传统基于协同过滤或规则的推荐系统，在处理大规模数据和捕捉商品深层语义关系时往往力不从心。而向量数据库的出现，为解决这一问题提供了新的思路。本文将详细介绍如何使用 Java 结合向量数据库，实现一个高效、精准的相似商品推荐系统。

一、核心技术栈

1. 向量数据库选型

我们选择 Milvus 作为向量数据库，原因如下：

支持大规模向量数据的高效存储和检索
提供丰富的距离计算算法（欧氏距离、余弦相似度等）
支持 Java SDK，便于集成到现有 Java 应用中
具备高可用性和可扩展性

2. 文本向量化模型

使用 Hugging Face 的 Sentence-BERT 模型将商品描述转换为向量：

能够捕捉文本的深层语义信息
生成的向量具有良好的语义相似性
支持通过 Java 调用

3. 其他技术

Spring Boot：构建微服务架构
MySQL：存储商品的结构化数据
Redis：缓存热点数据，提高响应速度

二、系统架构设计

1. 整体架构

+----------------+     +----------------+     +----------------+
|  商品信息系统   | --> |  向量生成服务   | --> |  Milvus向量库  |
+----------------+     +----------------+     +----------------+
         |                        |                        |
         |                        |                        |
         v                        v                        v
+----------------+     +----------------+     +----------------+
|  MySQL数据库   |     |   Redis缓存    | <-- |  推荐服务API   |
+----------------+     +----------------+     +----------------+
                                                      ^
                                                      |
                                                      v
                                               +----------------+
                                               |  前端应用      |
                                               +----------------+

2. 核心流程

数据准备：从商品信息系统获取商品数据，包括商品 ID、名称、描述、分类等
向量生成：使用 Sentence-BERT 模型将商品描述转换为向量
向量存储：将生成的向量及对应的商品 ID 存储到 Milvus 向量库
相似搜索：当用户请求相似商品时，根据目标商品的向量在 Milvus 中进行相似度搜索
结果处理：结合 MySQL 中的商品结构化数据，对搜索结果进行排序和过滤
缓存优化：将热门商品的推荐结果缓存到 Redis 中，提高响应速度

三、代码实现

1. 环境配置

首先，我们需要添加必要的依赖到 Maven 项目中：

<!-- Milvus Java SDK -->
<dependency>
    <groupId>io.milvus</groupId>
    <artifactId>milvus-sdk-java</artifactId>
    <version>2.2.15</version>
</dependency>

<!-- Hugging Face Transformers -->
<dependency>
    <groupId>ai.djl.huggingface</groupId>
    <artifactId>tokenizers</artifactId>
    <version>0.22.1</version>
</dependency>
<dependency>
    <groupId>ai.djl.huggingface</groupId>
    <artifactId>pytorch-model-zoo</artifactId>
    <version>0.22.1</version>
</dependency>

<!-- Spring Boot -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.1.5</version>
</dependency>

<!-- Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>3.1.5</version>
</dependency>

2. 向量生成服务

import ai.djl.huggingface.tokenizers.HuggingFaceTokenizer;
import ai.djl.modality.nlp.DefaultVocabulary;
import ai.djl.modality.nlp.bert.BertTokenizer;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDManager;
import ai.djl.repository.zoo.Criteria;
import ai.djl.repository.zoo.ModelZoo;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.translate.TranslateException;
import ai.djl.translate.Translator;
import ai.djl.translate.TranslatorContext;

import java.io.IOException;
import java.util.List;

public class VectorGenerator {
    private final ZooModel<String, float[]> model;
    private final HuggingFaceTokenizer tokenizer;

    public VectorGenerator() throws IOException, TranslateException {
        // 加载 Sentence-BERT 模型
        Criteria<String, float[]> criteria = Criteria.builder()
                .setTypes(String.class, float[].class)
                .optModelUrls("djl://ai.djl.huggingface.pytorch/sentence-transformers/all-MiniLM-L6-v2")
                .optTranslator(new SentenceTranslator())
                .build();
        
        model = ModelZoo.loadModel(criteria);
        
        // 初始化分词器
        tokenizer = HuggingFaceTokenizer.newInstance("sentence-transformers/all-MiniLM-L6-v2");
    }

    public float[] generateVector(String text) throws TranslateException {
        try (NDManager manager = NDManager.newBaseManager()) {
            return model.newPredictor().predict(text);
        }
    }

    private static class SentenceTranslator implements Translator<String, float[]> {
        @Override
        public float[] processOutput(TranslatorContext ctx, NDArray ndArray) {
            // 对输出向量进行归一化处理
            NDArray normalized = ndArray.div(ndArray.norm());
            return normalized.toFloatArray();
        }

        @Override
        public NDArray processInput(TranslatorContext ctx, String input) {
            // 此处省略分词和编码逻辑，实际实现中需要根据模型要求进行处理
            return null;
        }
    }
}

3. Milvus 向量库操作

import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.*;
import io.milvus.param.*;
import io.milvus.param.collection.*;
import io.milvus.param.dml.InsertParam;
import io.milvus.param.dml.SearchParam;
import io.milvus.response.SearchResultsWrapper;

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

public class MilvusVectorStore {
    private final MilvusClient client;
    private final String collectionName = "product_vectors";
    private final int dimension = 384; // Sentence-BERT 模型输出向量维度

    public MilvusVectorStore() {
        // 连接到 Milvus 服务器
        ConnectParam connectParam = ConnectParam.newBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();
        client = new MilvusServiceClient(connectParam);
        
        // 检查并创建集合
        createCollectionIfNotExists();
    }

    private void createCollectionIfNotExists() {
        HasCollectionParam hasParam = HasCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .build();
        R<BoolResponse> hasResponse = client.hasCollection(hasParam);
        
        if (!hasResponse.getData().getValue()) {
            // 定义集合结构
            FieldType idField = FieldType.newBuilder()
                    .withName("product_id")
                    .withDataType(DataType.Int64)
                    .withPrimaryKey(true)
                    .withAutoID(false)
                    .build();
            
            FieldType vectorField = FieldType.newBuilder()
                    .withName("vector")
                    .withDataType(DataType.FloatVector)
                    .withDimension(dimension)
                    .build();
            
            CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
                    .withCollectionName(collectionName)
                    .withFieldTypes(idField, vectorField)
                    .build();
            
            client.createCollection(createParam);
            
            // 创建索引
            IndexType indexType = IndexType.IVF_FLAT;
            String indexParam = "{\"nlist\": 1024}";
            
            CreateIndexParam indexParam = CreateIndexParam.newBuilder()
                    .withCollectionName(collectionName)
                    .withFieldName("vector")
                    .withIndexType(indexType)
                    .withMetricType(MetricType.COSINE)
                    .withExtraParam(indexParam)
                    .build();
            
            client.createIndex(indexParam);
        }
    }

    public void insertVector(long productId, float[] vector) {
        List<Long> productIds = new ArrayList<>();
        productIds.add(productId);
        
        List<List<Float>> vectors = new ArrayList<>();
        List<Float> floatList = new ArrayList<>();
        for (float v : vector) {
            floatList.add(v);
        }
        vectors.add(floatList);
        
        InsertParam insertParam = InsertParam.newBuilder()
                .withCollectionName(collectionName)
                .withFields("product_id", "vector")
                .withValues(productIds, vectors)
                .build();
        
        client.insert(insertParam);
    }

    public List<Long> searchSimilarVectors(float[] queryVector, int topK) {
        List<List<Float>> queryVectors = new ArrayList<>();
        List<Float> floatList = new ArrayList<>();
        for (float v : queryVector) {
            floatList.add(v);
        }
        queryVectors.add(floatList);
        
        SearchParam searchParam = SearchParam.newBuilder()
                .withCollectionName(collectionName)
                .withMetricType(MetricType.COSINE)
                .withOutFields("product_id")
                .withTopK(topK)
                .withVectors(queryVectors)
                .withVectorFieldName("vector")
                .withParams("{\"nprobe\": 10}")
                .build();
        
        R<SearchResults> searchResponse = client.search(searchParam);
        SearchResultsWrapper wrapper = new SearchResultsWrapper(searchResponse.getData().getResults());
        
        List<Long> similarProductIds = new ArrayList<>();
        for (int i = 0; i < wrapper.getRowCount(0); i++) {
            Long productId = wrapper.getFieldAsLong(0, i, "product_id");
            similarProductIds.add(productId);
        }
        
        return similarProductIds;
    }
}

4. 商品推荐服务

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductRecommendationService {
    @Autowired
    private VectorGenerator vectorGenerator;
    
    @Autowired
    private MilvusVectorStore vectorStore;
    
    @Autowired
    private ProductRepository productRepository;

    /**
     * 生成并存储商品向量
     */
    public void generateAndStoreProductVector(Product product) {
        try {
            float[] vector = vectorGenerator.generateVector(product.getDescription());
            vectorStore.insertVector(product.getId(), vector);
        } catch (Exception e) {
            // 处理异常
        }
    }

    /**
     * 获取相似商品推荐
     */
    @Cacheable(value = "similarProducts", key = "#productId")
    public List<Product> getSimilarProducts(Long productId, int topK) {
        try {
            // 获取目标商品
            Product targetProduct = productRepository.findById(productId)
                    .orElseThrow(() -> new RuntimeException("Product not found"));
            
            // 生成目标商品的向量
            float[] queryVector = vectorGenerator.generateVector(targetProduct.getDescription());
            
            // 在 Milvus 中搜索相似向量
            List<Long> similarProductIds = vectorStore.searchSimilarVectors(queryVector, topK + 1);
            
            // 移除自身
            similarProductIds.remove(productId);
            
            // 获取商品详情
            return productRepository.findAllById(similarProductIds);
        } catch (Exception e) {
            // 处理异常
            return List.of();
        }
    }
}

5. REST API 接口

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/api/recommendations")
public class RecommendationController {
    @Autowired
    private ProductRecommendationService recommendationService;

    @GetMapping("/similar/{productId}")
    public List<Product> getSimilarProducts(
            @PathVariable Long productId,
            @RequestParam(defaultValue = "10") int topK) {
        return recommendationService.getSimilarProducts(productId, topK);
    }
}

四、系统优化策略

1. 批量处理

在向量生成和插入阶段，采用批量处理方式，减少网络开销和数据库操作次数：

public void batchInsertVectors(List<Product> products) {
    // 批量生成向量
    List<Long> productIds = new ArrayList<>();
    List<List<Float>> vectors = new ArrayList<>();
    
    for (Product product : products) {
        try {
            float[] vector = vectorGenerator.generateVector(product.getDescription());
            productIds.add(product.getId());
            
            List<Float> floatList = new ArrayList<>();
            for (float v : vector) {
                floatList.add(v);
            }
            vectors.add(floatList);
        } catch (Exception e) {
            // 处理异常
        }
    }
    
    // 批量插入到 Milvus
    InsertParam insertParam = InsertParam.newBuilder()
            .withCollectionName(collectionName)
            .withFields("product_id", "vector")
            .withValues(productIds, vectors)
            .build();
    
    client.insert(insertParam);
}

2. 异步更新

商品信息发生变化时，异步更新向量库，避免影响主业务流程：

@Async
public void asyncUpdateProductVector(Product product) {
    generateAndStoreProductVector(product);
}

3. 混合推荐策略

结合向量相似度和其他因素（如销量、评分、价格等）进行综合排序：

public List<Product> getHybridRecommendations(Long productId, int topK) {
    // 获取相似商品
    List<Product> similarProducts = getSimilarProducts(productId, topK * 2);
    
    // 结合其他因素进行排序
    return similarProducts.stream()
            .sorted(Comparator.comparing(Product::getScore)
                    .thenComparing(Product::getSalesVolume).reversed())
            .limit(topK)
            .collect(Collectors.toList());
}