Nomic-Embed-Text-V2-MoE Java开发指南集成SpringBoot构建企业级语义搜索服务如果你是一名Java后端开发者正在为你的应用寻找一个强大的语义理解能力那么你来对地方了。今天我们就来聊聊如何把Nomic-Embed-Text-V2-MoE这个前沿的文本嵌入模型优雅地集成到你的SpringBoot项目中打造一个稳定、高效的企业级语义搜索服务。你可能听说过很多关于向量搜索、大模型嵌入的讨论但落实到Java工程层面总会遇到一些实际问题API怎么调用才稳定向量计算用哪个库高并发下如何保证性能服务化部署又该怎么设计别担心这篇文章就是为你准备的实战手册。我们不谈空洞的理论直接从代码和工程实践出发带你一步步构建一个可落地的解决方案。1. 项目准备与环境搭建在开始敲代码之前我们需要先把环境和依赖准备好。这个过程就像盖房子前打地基虽然基础但至关重要。1.1 核心依赖引入首先创建一个标准的SpringBoot项目。这里我们使用Maven作为构建工具当然你也可以用Gradle原理是相通的。打开你的pom.xml文件添加以下核心依赖dependencies !-- SpringBoot Web Starter (用于提供RESTful API) -- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-web/artifactId /dependency !-- 用于HTTP客户端调用星图平台API -- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-webflux/artifactId /dependency !-- 向量计算库 - 我们选择Apache Commons Math -- dependency groupIdorg.apache.commons/groupId artifactIdcommons-math3/artifactId version3.6.1/version /dependency !-- 用于JSON序列化/反序列化 -- dependency groupIdcom.fasterxml.jackson.core/groupId artifactIdjackson-databind/artifactId /dependency !-- 配置管理 -- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-configuration-processor/artifactId optionaltrue/optional /dependency !-- 测试相关 -- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-test/artifactId scopetest/scope /dependency /dependencies这里我选择了WebFlux的客户端而不是传统的RestTemplate主要是因为WebFlux的响应式特性在高并发调用外部API时表现更好资源利用率更高。向量计算库方面Apache Commons Math足够轻量且功能全面适合大多数语义相似度计算场景。1.2 配置文件设置接下来我们需要在application.yml或application.properties中配置一些关键信息。这些配置最好放在配置中心或者环境变量中这里为了演示方便我们直接写在配置文件里# application.yml nomic: embed: # 星图平台API的基础地址 api-base-url: https://your-mirror-platform-api-endpoint # 你的API密钥务必妥善保管不要提交到代码仓库 api-key: ${NOMIC_API_KEY:your-api-key-here} # 模型名称 model: nomic-embed-text-v2-moe # 请求超时时间毫秒 timeout: 30000 # 最大重试次数 max-retries: 3 spring: application: name: semantic-search-service # 服务端口 server: port: 8080注意那个${NOMIC_API_KEY:your-api-key-here}的写法这是Spring的占位符语法。在实际生产环境中你应该通过环境变量NOMIC_API_KEY来注入真实的API密钥这样更安全。2. 核心组件设计与实现地基打好了现在开始盖房子的主体结构。我们需要设计几个核心组件API客户端、向量计算服务、以及业务逻辑层。2.1 API客户端封装调用外部API最怕的就是不稳定所以一个好的客户端需要具备重试、超时、异常处理等能力。我们先定义一个配置类来加载刚才的配置Configuration ConfigurationProperties(prefix nomic.embed) Data public class NomicEmbedConfig { private String apiBaseUrl; private String apiKey; private String model; private int timeout; private int maxRetries; }然后我们创建API客户端。这里我采用建造者模式来构建请求让代码更清晰Component Slf4j public class NomicEmbedClient { private final WebClient webClient; private final NomicEmbedConfig config; public NomicEmbedClient(NomicEmbedConfig config) { this.config config; this.webClient WebClient.builder() .baseUrl(config.getApiBaseUrl()) .defaultHeader(Authorization, Bearer config.getApiKey()) .defaultHeader(Content-Type, application/json) .build(); } /** * 获取文本的向量嵌入 * param text 输入文本 * return 768维的向量Nomic-Embed-Text-V2-MoE的输出维度 */ public CompletableFuturedouble[] embedText(String text) { if (text null || text.trim().isEmpty()) { return CompletableFuture.completedFuture(new double[768]); } EmbedRequest request new EmbedRequest(config.getModel(), text); return webClient.post() .uri(/v1/embeddings) .bodyValue(request) .retrieve() .bodyToMono(EmbedResponse.class) .retry(config.getMaxRetries()) .timeout(Duration.ofMillis(config.getTimeout())) .doOnError(e - log.error(调用嵌入API失败: {}, e.getMessage())) .map(response - { if (response.getData() ! null !response.getData().isEmpty()) { return response.getData().get(0).getEmbedding(); } throw new RuntimeException(API响应数据为空); }) .toFuture(); } /** * 批量获取文本向量嵌入 * param texts 文本列表 * return 向量列表 */ public CompletableFutureListdouble[] embedTexts(ListString texts) { if (texts null || texts.isEmpty()) { return CompletableFuture.completedFuture(Collections.emptyList()); } BatchEmbedRequest request new BatchEmbedRequest(config.getModel(), texts); return webClient.post() .uri(/v1/embeddings/batch) .bodyValue(request) .retrieve() .bodyToMono(BatchEmbedResponse.class) .retry(config.getMaxRetries()) .timeout(Duration.ofMillis(config.getTimeout())) .doOnError(e - log.error(调用批量嵌入API失败: {}, e.getMessage())) .map(response - response.getData().stream() .map(EmbeddingData::getEmbedding) .collect(Collectors.toList())) .toFuture(); } // 请求和响应的DTO类 Data AllArgsConstructor NoArgsConstructor public static class EmbedRequest { private String model; private String input; } Data AllArgsConstructor NoArgsConstructor public static class BatchEmbedRequest { private String model; private ListString input; } Data public static class EmbedResponse { private ListEmbeddingData data; } Data public static class BatchEmbedResponse { private ListEmbeddingData data; } Data public static class EmbeddingData { private double[] embedding; } }这个客户端有几个关键设计点使用WebFlux的WebClient支持响应式编程适合高并发场景内置重试机制通过retry()方法自动重试提高稳定性超时控制避免长时间等待阻塞线程异常处理通过doOnError记录日志但不中断流返回CompletableFuture方便异步编程和结果组合2.2 向量计算服务拿到向量之后我们需要计算相似度。这里我们实现一个向量服务封装常见的向量操作Service public class VectorService { /** * 计算余弦相似度 * param vectorA 向量A * param vectorB 向量B * return 相似度得分范围[-1, 1]越接近1越相似 */ public double cosineSimilarity(double[] vectorA, double[] vectorB) { if (vectorA.length ! vectorB.length) { throw new IllegalArgumentException(向量维度必须相同); } double dotProduct 0.0; double normA 0.0; double normB 0.0; for (int i 0; i vectorA.length; i) { dotProduct vectorA[i] * vectorB[i]; normA vectorA[i] * vectorA[i]; normB vectorB[i] * vectorB[i]; } if (normA 0 || normB 0) { return 0.0; } return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB)); } /** * 计算欧几里得距离 * param vectorA 向量A * param vectorB 向量B * return 距离值越小越相似 */ public double euclideanDistance(double[] vectorA, double[] vectorB) { if (vectorA.length ! vectorB.length) { throw new IllegalArgumentException(向量维度必须相同); } double sum 0.0; for (int i 0; i vectorA.length; i) { double diff vectorA[i] - vectorB[i]; sum diff * diff; } return Math.sqrt(sum); } /** * 向量归一化L2范数 * param vector 输入向量 * return 归一化后的向量 */ public double[] normalize(double[] vector) { double norm 0.0; for (double v : vector) { norm v * v; } norm Math.sqrt(norm); if (norm 0) { return vector.clone(); } double[] normalized new double[vector.length]; for (int i 0; i vector.length; i) { normalized[i] vector[i] / norm; } return normalized; } /** * 批量计算相似度并排序 * param queryVector 查询向量 * param candidateVectors 候选向量列表 * param topK 返回前K个最相似的结果 * return 排序后的相似度结果 */ public ListSimilarityResult findTopKSimilar(double[] queryVector, Listdouble[] candidateVectors, ListString candidateTexts, int topK) { if (candidateVectors.size() ! candidateTexts.size()) { throw new IllegalArgumentException(向量和文本数量必须相同); } ListSimilarityResult results new ArrayList(); for (int i 0; i candidateVectors.size(); i) { double similarity cosineSimilarity(queryVector, candidateVectors.get(i)); results.add(new SimilarityResult(candidateTexts.get(i), similarity, i)); } // 按相似度降序排序 results.sort((a, b) - Double.compare(b.getScore(), a.getScore())); // 返回前K个结果 return results.stream().limit(topK).collect(Collectors.toList()); } Data AllArgsConstructor public static class SimilarityResult { private String text; private double score; private int index; } }这里我实现了两种相似度计算方式余弦相似度和欧几里得距离。在语义搜索中通常使用余弦相似度因为它只关注向量的方向而不关注大小更适合文本嵌入向量的比较。3. 业务逻辑与API设计有了基础组件现在我们来构建业务逻辑层和对外提供的API接口。3.1 语义搜索服务首先创建一个服务类封装完整的语义搜索流程Service Slf4j public class SemanticSearchService { private final NomicEmbedClient embedClient; private final VectorService vectorService; // 这里简单用内存存储实际生产环境应该用向量数据库 private final MapString, double[] vectorCache new ConcurrentHashMap(); private final ListString cachedTexts new CopyOnWriteArrayList(); public SemanticSearchService(NomicEmbedClient embedClient, VectorService vectorService) { this.embedClient embedClient; this.vectorService vectorService; } /** * 添加文档到搜索索引 * param text 文档文本 * return 文档ID */ public CompletableFutureString indexDocument(String text) { return embedClient.embedText(text) .thenApply(vector - { String docId doc_ System.currentTimeMillis() _ cachedTexts.size(); vectorCache.put(docId, vector); cachedTexts.add(text); log.info(已索引文档: {}, 向量维度: {}, docId, vector.length); return docId; }) .exceptionally(e - { log.error(索引文档失败: {}, e.getMessage()); throw new RuntimeException(索引失败, e); }); } /** * 批量索引文档 * param texts 文档列表 * return 文档ID列表 */ public CompletableFutureListString indexDocuments(ListString texts) { return embedClient.embedTexts(texts) .thenApply(vectors - { ListString docIds new ArrayList(); for (int i 0; i vectors.size(); i) { String docId doc_ System.currentTimeMillis() _ (cachedTexts.size() i); vectorCache.put(docId, vectors.get(i)); cachedTexts.add(texts.get(i)); docIds.add(docId); } log.info(批量索引完成共{}个文档, texts.size()); return docIds; }) .exceptionally(e - { log.error(批量索引失败: {}, e.getMessage()); throw new RuntimeException(批量索引失败, e); }); } /** * 语义搜索 * param query 查询文本 * param topK 返回结果数量 * return 相似度最高的文档 */ public CompletableFutureListVectorService.SimilarityResult search(String query, int topK) { if (vectorCache.isEmpty()) { return CompletableFuture.completedFuture(Collections.emptyList()); } return embedClient.embedText(query) .thenApply(queryVector - { // 收集所有缓存的向量 Listdouble[] vectors new ArrayList(vectorCache.values()); ListString texts new ArrayList(cachedTexts); // 计算相似度并返回前K个结果 return vectorService.findTopKSimilar(queryVector, vectors, texts, topK); }) .exceptionally(e - { log.error(搜索失败: {}, e.getMessage()); return Collections.emptyList(); }); } /** * 获取索引中的文档数量 */ public int getIndexSize() { return cachedTexts.size(); } /** * 清空索引 */ public void clearIndex() { vectorCache.clear(); cachedTexts.clear(); log.info(索引已清空); } }这个服务类有几个关键特性异步处理所有耗时操作都返回CompletableFuture避免阻塞线程内存缓存简单使用ConcurrentHashMap存储向量实际生产环境应该用专业的向量数据库错误处理使用exceptionally处理异常保证服务稳定性批量操作支持批量索引提高效率3.2 RESTful API接口现在我们对外提供HTTP API接口RestController RequestMapping(/api/search) Slf4j public class SearchController { private final SemanticSearchService searchService; public SearchController(SemanticSearchService searchService) { this.searchService searchService; } /** * 索引单个文档 */ PostMapping(/index) public CompletableFutureResponseEntityMapString, Object indexDocument(RequestBody MapString, String request) { String text request.get(text); if (text null || text.trim().isEmpty()) { return CompletableFuture.completedFuture( ResponseEntity.badRequest().body(Map.of(error, 文本内容不能为空)) ); } return searchService.indexDocument(text) .thenApply(docId - ResponseEntity.ok(Map.of( success, true, docId, docId, message, 文档索引成功 ))) .exceptionally(e - ResponseEntity.status(500).body(Map.of( success, false, error, 索引失败: e.getMessage() ))); } /** * 批量索引文档 */ PostMapping(/index/batch) public CompletableFutureResponseEntityMapString, Object indexDocuments(RequestBody MapString, ListString request) { ListString texts request.get(texts); if (texts null || texts.isEmpty()) { return CompletableFuture.completedFuture( ResponseEntity.badRequest().body(Map.of(error, 文本列表不能为空)) ); } return searchService.indexDocuments(texts) .thenApply(docIds - ResponseEntity.ok(Map.of( success, true, docIds, docIds, count, docIds.size(), message, 批量索引成功 ))) .exceptionally(e - ResponseEntity.status(500).body(Map.of( success, false, error, 批量索引失败: e.getMessage() ))); } /** * 语义搜索 */ GetMapping(/query) public CompletableFutureResponseEntityMapString, Object search( RequestParam String q, RequestParam(defaultValue 10) int topK) { if (q null || q.trim().isEmpty()) { return CompletableFuture.completedFuture( ResponseEntity.badRequest().body(Map.of(error, 查询内容不能为空)) ); } return searchService.search(q, topK) .thenApply(results - { ListMapString, Object formattedResults results.stream() .map(r - Map.of( text, r.getText(), score, String.format(%.4f, r.getScore()), rank, results.indexOf(r) 1 )) .collect(Collectors.toList()); return ResponseEntity.ok(Map.of( success, true, query, q, topK, topK, totalResults, results.size(), results, formattedResults, indexSize, searchService.getIndexSize() )); }) .exceptionally(e - ResponseEntity.status(500).body(Map.of( success, false, error, 搜索失败: e.getMessage() ))); } /** * 获取索引状态 */ GetMapping(/status) public ResponseEntityMapString, Object getStatus() { return ResponseEntity.ok(Map.of( indexSize, searchService.getIndexSize(), status, running, timestamp, System.currentTimeMillis() )); } /** * 清空索引谨慎使用 */ DeleteMapping(/clear) public ResponseEntityMapString, Object clearIndex() { searchService.clearIndex(); return ResponseEntity.ok(Map.of( success, true, message, 索引已清空 )); } }这个控制器提供了完整的CRUD操作POST /api/search/index- 索引单个文档POST /api/search/index/batch- 批量索引文档GET /api/search/query- 执行语义搜索GET /api/search/status- 获取服务状态DELETE /api/search/clear- 清空索引生产环境需要加权限控制4. 高并发与生产环境优化上面的代码已经可以工作了但在生产环境中我们还需要考虑更多。下面聊聊高并发场景下的优化方案。4.1 连接池与线程池配置首先我们需要优化WebClient的配置避免连接数不足导致的性能瓶颈Configuration public class WebClientConfig { Bean public WebClient.Builder webClientBuilder(NomicEmbedConfig config) { // 创建连接池 ConnectionProvider connectionProvider ConnectionProvider.builder(nomic-pool) .maxConnections(100) // 最大连接数 .pendingAcquireTimeout(Duration.ofSeconds(30)) // 等待连接超时 .maxIdleTime(Duration.ofMinutes(5)) // 连接最大空闲时间 .build(); // 配置响应式HTTP客户端 HttpClient httpClient HttpClient.create(connectionProvider) .responseTimeout(Duration.ofMillis(config.getTimeout())) .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000); // 连接超时 return WebClient.builder() .clientConnector(new ReactorClientHttpConnector(httpClient)) .defaultHeader(Authorization, Bearer config.getApiKey()) .defaultHeader(Content-Type, application/json); } }4.2 异步处理与背压控制在高并发场景下我们需要控制请求的速率避免拖垮下游服务Service Slf4j public class RateLimitedEmbedService { private final NomicEmbedClient embedClient; private final Scheduler scheduler; private final Semaphore semaphore; public RateLimitedEmbedService(NomicEmbedConfig config, NomicEmbedClient embedClient) { this.embedClient embedClient; // 使用信号量控制并发数 this.semaphore new Semaphore(config.getMaxConcurrentRequests()); // 创建调度器用于延迟重试 this.scheduler Schedulers.newBoundedElastic( 10, // 线程数 100, // 任务队列容量 embed-rate-limiter ); } /** * 带速率限制的文本嵌入 */ public CompletableFuturedouble[] embedWithRateLimit(String text) { return CompletableFuture.supplyAsync(() - { try { // 获取许可如果无法获取则等待 if (!semaphore.tryAcquire(3, TimeUnit.SECONDS)) { throw new RuntimeException(请求超时请稍后重试); } try { return embedClient.embedText(text).join(); } finally { semaphore.release(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException(请求被中断, e); } }, scheduler); } /** * 带指数退避的重试机制 */ public CompletableFuturedouble[] embedWithRetry(String text, int maxRetries) { return Mono.fromCallable(() - embedClient.embedText(text)) .retryWhen(Retry.backoff(maxRetries, Duration.ofSeconds(1)) .maxBackoff(Duration.ofSeconds(10)) .doBeforeRetry(retrySignal - log.warn(重试嵌入请求重试次数: {}, retrySignal.totalRetries()))) .timeout(Duration.ofSeconds(30)) .toFuture(); } }4.3 向量数据库集成以Milvus为例内存缓存只适合小规模数据生产环境需要向量数据库。这里以Milvus为例Service Slf4j public class MilvusVectorService { private final MilvusServiceClient milvusClient; private final String collectionName document_vectors; public MilvusVectorService(Value(${milvus.host}) String host, Value(${milvus.port}) int port) { this.milvusClient new MilvusServiceClient( ConnectParam.newBuilder() .withHost(host) .withPort(port) .build() ); initCollection(); } private void initCollection() { // 检查集合是否存在 RBoolean resp milvusClient.hasCollection( HasCollectionParam.newBuilder() .withCollectionName(collectionName) .build() ); if (!resp.getData()) { // 创建集合 FieldType fieldType1 FieldType.newBuilder() .withName(id) .withDataType(DataType.Int64) .withPrimaryKey(true) .withAutoID(true) .build(); FieldType fieldType2 FieldType.newBuilder() .withName(vector) .withDataType(DataType.FloatVector) .withDimension(768) // Nomic-Embed-Text-V2-MoE的维度 .build(); FieldType fieldType3 FieldType.newBuilder() .withName(text) .withDataType(DataType.VarChar) .withMaxLength(65535) .build(); CreateCollectionParam createParam CreateCollectionParam.newBuilder() .withCollectionName(collectionName) .withDescription(文档向量存储) .withShardsNum(2) .addFieldType(fieldType1) .addFieldType(fieldType2) .addFieldType(fieldType3) .build(); milvusClient.createCollection(createParam); log.info(创建Milvus集合: {}, collectionName); } } /** * 插入向量到Milvus */ public ListLong insertVectors(Listdouble[] vectors, ListString texts) { ListListFloat floatVectors vectors.stream() .map(vector - Arrays.stream(vector) .mapToObj(v - (float) v) .collect(Collectors.toList())) .collect(Collectors.toList()); ListInsertParam.Field fields new ArrayList(); fields.add(new InsertParam.Field(vector, floatVectors)); fields.add(new InsertParam.Field(text, texts)); InsertParam insertParam InsertParam.newBuilder() .withCollectionName(collectionName) .withFields(fields) .build(); RMutationResult result milvusClient.insert(insertParam); milvusClient.flush(FlushParam.newBuilder() .addCollectionName(collectionName) .build()); return result.getData().getIDs().getIntId().getData(); } /** * 在Milvus中搜索相似向量 */ public ListSearchResult searchSimilar(double[] queryVector, int topK) { ListFloat floatVector Arrays.stream(queryVector) .mapToObj(v - (float) v) .collect(Collectors.toList()); ListListFloat searchVectors Collections.singletonList(floatVector); SearchParam searchParam SearchParam.newBuilder() .withCollectionName(collectionName) .withMetricType(MetricType.IP) // 内积相当于余弦相似度向量已归一化 .withTopK(topK) .withVectors(searchVectors) .withVectorFieldName(vector) .addOutField(text) .build(); RSearchResults resp milvusClient.search(searchParam); return resp.getData().getResults().stream() .flatMap(list - list.stream()) .map(hit - new SearchResult( hit.getField(text).toString(), hit.getScore())) .collect(Collectors.toList()); } Data AllArgsConstructor public static class SearchResult { private String text; private float score; } }4.4 缓存策略优化对于频繁查询的向量我们可以加入本地缓存Service Slf4j public class CachedEmbeddingService { private final NomicEmbedClient embedClient; private final CacheString, double[] embeddingCache; public CachedEmbeddingService(NomicEmbedConfig config) { this.embedClient embedClient; // 使用Caffeine作为本地缓存 this.embeddingCache Caffeine.newBuilder() .maximumSize(10000) // 最大缓存数量 .expireAfterWrite(1, TimeUnit.HOURS) // 写入后1小时过期 .recordStats() // 记录统计信息 .build(); } /** * 获取缓存的嵌入向量 */ public CompletableFuturedouble[] getCachedEmbedding(String text) { // 生成缓存键使用MD5避免过长的文本作为key String cacheKey generateCacheKey(text); // 尝试从缓存获取 double[] cached embeddingCache.getIfPresent(cacheKey); if (cached ! null) { log.debug(缓存命中: {}, cacheKey); return CompletableFuture.completedFuture(cached); } // 缓存未命中调用API return embedClient.embedText(text) .thenApply(vector - { embeddingCache.put(cacheKey, vector); log.debug(缓存未命中已缓存新向量: {}, cacheKey); return vector; }); } private String generateCacheKey(String text) { try { MessageDigest md MessageDigest.getInstance(MD5); byte[] digest md.digest(text.getBytes(StandardCharsets.UTF_8)); return DatatypeConverter.printHexBinary(digest).toLowerCase(); } catch (NoSuchAlgorithmException e) { // 回退到简单哈希 return String.valueOf(text.hashCode()); } } /** * 获取缓存统计信息 */ public MapString, Object getCacheStats() { CacheStats stats embeddingCache.stats(); return Map.of( hitRate, stats.hitRate(), missRate, stats.missRate(), loadCount, stats.loadCount(), evictionCount, stats.evictionCount() ); } }5. 测试与部署5.1 单元测试写一些基本的单元测试来验证核心功能SpringBootTest Slf4j class SemanticSearchServiceTest { Autowired private SemanticSearchService searchService; Test void testIndexAndSearch() { // 索引一些文档 ListString documents Arrays.asList( Java是一种广泛使用的编程语言, Spring Boot简化了Java应用开发, 机器学习是人工智能的重要分支, 深度学习需要大量的计算资源 ); // 批量索引 ListString docIds searchService.indexDocuments(documents).join(); assertFalse(docIds.isEmpty()); assertEquals(4, searchService.getIndexSize()); // 执行搜索 ListVectorService.SimilarityResult results searchService.search(Java开发, 2).join(); // 验证结果 assertFalse(results.isEmpty()); assertEquals(2, results.size()); // 最相关的结果应该是关于Java的 VectorService.SimilarityResult topResult results.get(0); assertTrue(topResult.getText().contains(Java)); log.info(测试通过搜索结果: {}, results); } Test void testEmptySearch() { ListVectorService.SimilarityResult results searchService.search(不存在的查询, 5).join(); assertTrue(results.isEmpty()); } AfterEach void cleanup() { searchService.clearIndex(); } }5.2 集成测试SpringBootTest(webEnvironment SpringBootTest.WebEnvironment.RANDOM_PORT) AutoConfigureMockMvc class SearchControllerIntegrationTest { Autowired private MockMvc mockMvc; Test void testSearchApi() throws Exception { // 索引文档 MapString, String indexRequest Map.of(text, 这是一个测试文档); mockMvc.perform(post(/api/search/index) .contentType(MediaType.APPLICATION_JSON) .content(new ObjectMapper().writeValueAsString(indexRequest))) .andExpect(status().isOk()) .andExpect(jsonPath($.success).value(true)) .andExpect(jsonPath($.docId).exists()); // 执行搜索 mockMvc.perform(get(/api/search/query) .param(q, 测试) .param(topK, 5)) .andExpect(status().isOk()) .andExpect(jsonPath($.success).value(true)) .andExpect(jsonPath($.results).isArray()) .andExpect(jsonPath($.results[0].text).value(这是一个测试文档)); } }5.3 Docker部署配置最后我们创建一个Dockerfile来容器化部署# Dockerfile FROM openjdk:11-jre-slim # 设置工作目录 WORKDIR /app # 复制构建好的JAR文件 COPY target/semantic-search-service-*.jar app.jar # 设置JVM参数 ENV JAVA_OPTS-Xmx2g -Xms1g -XX:UseG1GC -XX:MaxGCPauseMillis200 # 暴露端口 EXPOSE 8080 # 健康检查 HEALTHCHECK --interval30s --timeout3s --start-period5s --retries3 \ CMD curl -f http://localhost:8080/api/search/status || exit 1 # 启动应用 ENTRYPOINT [sh, -c, java $JAVA_OPTS -jar app.jar]以及docker-compose.yml方便一键部署# docker-compose.yml version: 3.8 services: semantic-search: build: . ports: - 8080:8080 environment: - NOMIC_API_KEY${NOMIC_API_KEY} - MILVUS_HOSTmilvus - MILVUS_PORT19530 - JAVA_OPTS-Xmx2g -Xms1g -XX:UseG1GC depends_on: - milvus networks: - semantic-network restart: unless-stopped milvus: image: milvusdb/milvus:v2.3.3 ports: - 19530:19530 volumes: - milvus-data:/var/lib/milvus environment: - ETCD_ENDPOINTSetcd:2379 depends_on: - etcd networks: - semantic-network etcd: image: quay.io/coreos/etcd:v3.5.5 environment: - ETCD_AUTO_COMPACTION_MODErevision - ETCD_AUTO_COMPACTION_RETENTION1000 - ETCD_QUOTA_BACKEND_BYTES4294967296 - ETCD_SNAPSHOT_COUNT50000 volumes: - etcd-data:/etcd networks: - semantic-network networks: semantic-network: driver: bridge volumes: milvus-data: etcd-data:6. 总结与建议走完这一整套流程你应该已经掌握了在SpringBoot项目中集成Nomic-Embed-Text-V2-MoE模型的核心要点。从最基础的API调用封装到向量计算服务再到完整的高并发语义搜索服务我们一步步构建了一个相对完整的企业级解决方案。实际用下来这套方案在中小规模的场景下表现不错响应速度和准确度都能满足要求。不过有几个地方需要特别注意首先是API调用频率虽然我们加了重试和限流但如果量特别大还是要考虑更复杂的熔断和降级策略。其次是向量存储文章里用了内存缓存做演示生产环境一定要换成专业的向量数据库比如Milvus、Qdrant或者Pinecone不然数据量一大内存就扛不住了。性能优化方面除了代码里提到的连接池和缓存还可以考虑批量处理请求把多个文本打包一起发送给API能显著减少网络开销。监控也很重要建议把API调用耗时、缓存命中率、搜索响应时间这些指标都监控起来方便及时发现问题。如果你打算在生产环境使用建议先从一个小规模的应用场景开始比如站内搜索或者文档分类跑通了再逐步扩大范围。过程中遇到问题很正常多看看日志调整调整参数慢慢就能找到最适合自己业务的配置。最后技术选型上Java生态里做向量计算的选择其实不少除了Apache Commons Math也可以看看ND4J或者Deeplearning4j它们对GPU加速支持更好。不过对于大多数应用我们这套方案已经足够用了关键是稳定、易维护。获取更多AI镜像想探索更多AI镜像和应用场景访问 CSDN星图镜像广场提供丰富的预置镜像覆盖大模型推理、图像生成、视频生成、模型微调等多个领域支持一键部署。