简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

如何在Java项目中高效实现搜索功能核心技术与方法解析

威震华夏关云长

3万

主题

349

科技点

3万

积分

大区版主

木柜子打湿

积分
31898

三倍冰淇淋无人之境【一阶】财Doro小樱（小丑装）立华奏以外的星空【二阶】⑨的冰沙
发表于 2025-9-8 23:20:15 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

在当今信息爆炸的时代，搜索功能已经成为几乎所有应用程序的核心组成部分。无论是电子商务网站、企业内部系统还是社交媒体平台，高效、准确的搜索功能都是提升用户体验的关键因素。本文将深入探讨在Java项目中实现高效搜索功能的核心技术与方法，从基础实现到高级优化，帮助开发者构建满足各种需求的搜索解决方案。

搜索功能的重要性与应用场景

搜索功能在各类应用中扮演着至关重要的角色：

1. 电子商务平台：帮助用户快速找到所需商品，提高转化率
2. 内容管理系统：便于内容检索和管理
3. 企业内部系统：加速信息查找，提高工作效率
4. 社交媒体：实现用户、话题和内容的快速定位
5. 文档管理系统：支持海量文档的快速检索

一个高效的搜索系统不仅能提供快速响应，还应具备相关性排序、模糊匹配、高亮显示等高级功能，以满足用户多样化的搜索需求。

Java中实现搜索的核心技术

基本数据结构搜索

对于小型应用或简单需求，可以使用Java内置的数据结构实现基本搜索功能。
  2. // 使用List进行线性搜索
  3. public List<Product> searchByName(List<Product> products, String keyword) {
  4.     List<Product> result = new ArrayList<>();
  5.     for (Product product : products) {
  6.         if (product.getName().toLowerCase().contains(keyword.toLowerCase())) {
  7.             result.add(product);
  8.         }
  9.     }
  10.     return result;
  11. }
  13. // 使用Set进行快速查找
  14. public Set<Product> searchInSet(Set<Product> productSet, String keyword) {
  15.     Set<Product> result = new HashSet<>();
  16.     for (Product product : productSet) {
  17.         if (product.getName().toLowerCase().contains(keyword.toLowerCase())) {
  18.             result.add(product);
  19.         }
  20.     }
  21.     return result;
  22. }
复制代码
  2. // 使用Map实现基于ID的快速查找
  3. public Map<String, Product> productMap = new HashMap<>();
  5. public Product searchById(String id) {
  6.     return productMap.get(id);
  7. }
  9. // 使用Map进行多条件搜索
  10. public List<Product> searchByMultipleCriteria(Map<String, String> criteria) {
  11.     List<Product> result = new ArrayList<>();
  12.     for (Product product : productMap.values()) {
  13.         boolean match = true;
  14.         for (Map.Entry<String, String> entry : criteria.entrySet()) {
  15.             String key = entry.getKey();
  16.             String value = entry.getValue().toLowerCase();
  17.             
  18.             if ("name".equals(key) && !product.getName().toLowerCase().contains(value)) {
  19.                 match = false;
  20.                 break;
  21.             } else if ("category".equals(key) && !product.getCategory().toLowerCase().equals(value)) {
  22.                 match = false;
  23.                 break;
  24.             }
  25.             // 可以添加更多条件
  26.         }
  27.         if (match) {
  28.             result.add(product);
  29.         }
  30.     }
  31.     return result;
  32. }
复制代码

数据库搜索

对于大多数企业应用，数据存储在关系数据库中，利用SQL查询是实现搜索的常见方式。
  2. // 使用JDBC实现基本搜索
  3. public List<Product> searchInDatabase(String keyword) {
  4.     List<Product> result = new ArrayList<>();
  5.     String sql = "SELECT * FROM products WHERE name LIKE ? OR description LIKE ?";
  6.    
  7.     try (Connection conn = dataSource.getConnection();
  8.          PreparedStatement stmt = conn.prepareStatement(sql)) {
  9.         
  10.         String searchPattern = "%" + keyword + "%";
  11.         stmt.setString(1, searchPattern);
  12.         stmt.setString(2, searchPattern);
  13.         
  14.         ResultSet rs = stmt.executeQuery();
  15.         while (rs.next()) {
  16.             Product product = new Product();
  17.             product.setId(rs.getString("id"));
  18.             product.setName(rs.getString("name"));
  19.             product.setDescription(rs.getString("description"));
  20.             // 设置其他属性
  21.             result.add(product);
  22.         }
  23.     } catch (SQLException e) {
  24.         e.printStackTrace();
  25.     }
  26.     return result;
  27. }
复制代码
  2. // 使用JPA Repository方法
  3. public interface ProductRepository extends JpaRepository<Product, String> {
  4.    
  5.     // 基本名称搜索
  6.     List<Product> findByNameContainingIgnoreCase(String keyword);
  7.    
  8.     // 多条件搜索
  9.     List<Product> findByNameContainingIgnoreCaseAndCategory(String name, String category);
  10.    
  11.     // 自定义查询
  12.     @Query("SELECT p FROM Product p WHERE LOWER(p.name) LIKE LOWER(CONCAT('%', ?1, '%')) OR LOWER(p.description) LIKE LOWER(CONCAT('%', ?1, '%'))")
  13.     List<Product> searchByKeyword(String keyword);
  14. }
  16. // 服务层使用
  17. @Service
  18. public class ProductService {
  19.    
  20.     @Autowired
  21.     private ProductRepository productRepository;
  22.    
  23.     public List<Product> searchProducts(String keyword) {
  24.         return productRepository.searchByKeyword(keyword);
  25.     }
  26.    
  27.     public List<Product> advancedSearch(String name, String category, Double minPrice, Double maxPrice) {
  28.         Specification<Product> spec = Specification.where(null);
  29.         
  30.         if (name != null && !name.isEmpty()) {
  31.             spec = spec.and((root, query, cb) ->
  32.                 cb.like(cb.lower(root.get("name")), "%" + name.toLowerCase() + "%"));
  33.         }
  34.         
  35.         if (category != null && !category.isEmpty()) {
  36.             spec = spec.and((root, query, cb) ->
  37.                 cb.equal(root.get("category"), category));
  38.         }
  39.         
  40.         if (minPrice != null) {
  41.             spec = spec.and((root, query, cb) ->
  42.                 cb.ge(root.get("price"), minPrice));
  43.         }
  44.         
  45.         if (maxPrice != null) {
  46.             spec = spec.and((root, query, cb) ->
  47.                 cb.le(root.get("price"), maxPrice));
  48.         }
  49.         
  50.         return productRepository.findAll(spec);
  51.     }
  52. }
复制代码

全文搜索引擎集成

对于大规模数据和高性能搜索需求，集成专门的全文搜索引擎是最佳选择。

搜索性能优化技术

索引技术

索引是提高搜索性能的关键技术，它通过预先构建数据结构来加速查询过程。
  2. // 在实体类中定义索引
  3. @Entity
  4. @Table(name = "products",
  5.        indexes = {
  6.            @Index(name = "idx_product_name", columnList = "name"),
  7.            @Index(name = "idx_product_category", columnList = "category"),
  8.            @Index(name = "idx_product_price", columnList = "price")
  9.        })
  10. public class Product {
  11.     @Id
  12.     private String id;
  13.    
  14.     @Column(name = "name", nullable = false)
  15.     private String name;
  16.    
  17.     @Column(name = "category")
  18.     private String category;
  19.    
  20.     @Column(name = "price")
  21.     private Double price;
  22.    
  23.     // 其他字段、getter和setter
  24. }
复制代码
  2. // 创建复合索引以支持多字段查询
  3. @Entity
  4. @Table(name = "products",
  5.        indexes = {
  6.            @Index(name = "idx_product_name_category", columnList = "name, category"),
  7.            @Index(name = "idx_product_category_price", columnList = "category, price")
  8.        })
  9. public class Product {
  10.     // 实体定义
  11. }
复制代码

缓存策略

缓存可以显著减少数据库访问次数，提高搜索响应速度。
  2. @Service
  3. public class ProductService {
  4.    
  5.     @Autowired
  6.     private ProductRepository productRepository;
  7.    
  8.     @Cacheable(value = "productSearch", key = "#keyword")
  9.     public List<Product> searchProducts(String keyword) {
  10.         return productRepository.searchByKeyword(keyword);
  11.     }
  12.    
  13.     @CacheEvict(value = "productSearch", allEntries = true)
  14.     public void clearSearchCache() {
  15.         // 清除所有搜索缓存
  16.     }
  17.    
  18.     @CacheEvict(value = "productSearch", key = "#product.id")
  19.     public void updateProduct(Product product) {
  20.         productRepository.save(product);
  21.     }
  22. }
复制代码
  2. @Service
  3. public class ProductSearchService {
  4.    
  5.     @Autowired
  6.     private ProductRepository productRepository;
  7.    
  8.     @Autowired
  9.     private RedisTemplate<String, Object> redisTemplate;
  10.    
  11.     private static final String SEARCH_CACHE_PREFIX = "search:";
  12.    
  13.     public List<Product> searchWithCache(String keyword) {
  14.         String cacheKey = SEARCH_CACHE_PREFIX + keyword;
  15.         
  16.         // 尝试从缓存获取
  17.         List<Product> cachedResult = (List<Product>) redisTemplate.opsForValue().get(cacheKey);
  18.         if (cachedResult != null) {
  19.             return cachedResult;
  20.         }
  21.         
  22.         // 缓存未命中，查询数据库
  23.         List<Product> result = productRepository.searchByKeyword(keyword);
  24.         
  25.         // 将结果存入缓存，设置过期时间
  26.         redisTemplate.opsForValue().set(cacheKey, result, 1, TimeUnit.HOURS);
  27.         
  28.         return result;
  29.     }
  30.    
  31.     public void invalidateSearchCache(String keyword) {
  32.         String cacheKey = SEARCH_CACHE_PREFIX + keyword;
  33.         redisTemplate.delete(cacheKey);
  34.     }
  35. }
复制代码

查询优化

优化查询语句和执行计划可以显著提高搜索性能。
  2. // 使用EXPLAIN分析查询性能
  3. public void analyzeQueryPerformance(String keyword) {
  4.     String sql = "EXPLAIN SELECT * FROM products WHERE name LIKE ?";
  5.    
  6.     try (Connection conn = dataSource.getConnection();
  7.          PreparedStatement stmt = conn.prepareStatement(sql)) {
  8.         
  9.         stmt.setString(1, "%" + keyword + "%");
  10.         ResultSet rs = stmt.executeQuery();
  11.         
  12.         while (rs.next()) {
  13.             // 分析查询执行计划
  14.             System.out.println(rs.getString(1));
  15.         }
  16.     } catch (SQLException e) {
  17.         e.printStackTrace();
  18.     }
  19. }
  21. // 优化后的查询，避免使用前导通配符
  22. public List<Product> optimizedSearch(String keyword) {
  23.     // 避免使用前导通配符(%)，这会导致索引失效
  24.     if (keyword.startsWith("%")) {
  25.         keyword = keyword.substring(1);
  26.     }
  27.    
  28.     return productRepository.searchByKeyword(keyword);
  29. }
复制代码
  2. // 使用JPA实现高效分页
  3. public Page<Product> searchWithPagination(String keyword, int page, int size) {
  4.     PageRequest pageRequest = PageRequest.of(page, size, Sort.by("name").ascending());
  5.     return productRepository.findByNameContainingIgnoreCase(keyword, pageRequest);
  6. }
  8. // 使用游标分页(Cursor-based Pagination)替代传统分页
  9. public List<Product> searchWithCursor(String keyword, String lastId, int limit) {
  10.     if (lastId == null || lastId.isEmpty()) {
  11.         // 第一页查询
  12.         return productRepository.findFirst10ByNameContainingIgnoreCaseOrderByIdAsc(keyword);
  13.     } else {
  14.         // 后续页面查询，使用ID作为游标
  15.         return productRepository.findFirst10ByIdAfterAndNameContainingIgnoreCaseOrderByIdAsc(lastId, keyword);
  16.     }
  17. }
复制代码

常用搜索框架和库的介绍与使用

Lucene

Apache Lucene是一个高性能、全功能的文本搜索引擎库，它提供了强大的索引和搜索功能。
  2. public class LuceneSearchService {
  3.    
  4.     private final Directory indexDirectory;
  5.     private final Analyzer analyzer;
  6.    
  7.     public LuceneSearchService(String indexDirPath) throws IOException {
  8.         this.indexDirectory = FSDirectory.open(Paths.get(indexDirPath));
  9.         this.analyzer = new StandardAnalyzer();
  10.     }
  11.    
  12.     // 创建索引
  13.     public void indexProducts(List<Product> products) throws IOException {
  14.         IndexWriterConfig config = new IndexWriterConfig(analyzer);
  15.         IndexWriter writer = new IndexWriter(indexDirectory, config);
  16.         
  17.         // 清除现有索引
  18.         writer.deleteAll();
  19.         
  20.         for (Product product : products) {
  21.             Document doc = new Document();
  22.             doc.add(new StringField("id", product.getId(), Field.Store.YES));
  23.             doc.add(new TextField("name", product.getName(), Field.Store.YES));
  24.             doc.add(new TextField("description", product.getDescription(), Field.Store.YES));
  25.             doc.add(new StringField("category", product.getCategory(), Field.Store.YES));
  26.             doc.add(new DoublePoint("price", product.getPrice()));
  27.             
  28.             writer.addDocument(doc);
  29.         }
  30.         
  31.         writer.close();
  32.     }
  33.    
  34.     // 搜索产品
  35.     public List<Product> searchProducts(String queryStr, int maxResults) throws IOException, ParseException {
  36.         QueryParser parser = new QueryParser("name", analyzer);
  37.         Query query = parser.parse(queryStr);
  38.         
  39.         IndexReader reader = DirectoryReader.open(indexDirectory);
  40.         IndexSearcher searcher = new IndexSearcher(reader);
  41.         
  42.         TopDocs topDocs = searcher.search(query, maxResults);
  43.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  44.         
  45.         List<Product> results = new ArrayList<>();
  46.         for (ScoreDoc scoreDoc : scoreDocs) {
  47.             Document doc = searcher.doc(scoreDoc.doc);
  48.             
  49.             Product product = new Product();
  50.             product.setId(doc.get("id"));
  51.             product.setName(doc.get("name"));
  52.             product.setDescription(doc.get("description"));
  53.             product.setCategory(doc.get("category"));
  54.             product.setPrice(Double.parseDouble(doc.get("price")));
  55.             
  56.             results.add(product);
  57.         }
  58.         
  59.         reader.close();
  60.         return results;
  61.     }
  62.    
  63.     // 高级搜索 - 多字段搜索
  64.     public List<Product> advancedSearch(String queryStr, int maxResults) throws IOException, ParseException {
  65.         // 创建多字段查询
  66.         String[] fields = {"name", "description", "category"};
  67.         BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
  68.         
  69.         QueryParser parser = new QueryParser("", analyzer);
  70.         Query query = parser.parse(queryStr);
  71.         
  72.         for (String field : fields) {
  73.             booleanQuery.add(new BooleanClause(new TermQuery(new Term(field, queryStr)), BooleanClause.Occur.SHOULD));
  74.         }
  75.         
  76.         IndexReader reader = DirectoryReader.open(indexDirectory);
  77.         IndexSearcher searcher = new IndexSearcher(reader);
  78.         
  79.         TopDocs topDocs = searcher.search(booleanQuery.build(), maxResults);
  80.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  81.         
  82.         List<Product> results = new ArrayList<>();
  83.         for (ScoreDoc scoreDoc : scoreDocs) {
  84.             Document doc = searcher.doc(scoreDoc.doc);
  85.             
  86.             Product product = new Product();
  87.             product.setId(doc.get("id"));
  88.             product.setName(doc.get("name"));
  89.             product.setDescription(doc.get("description"));
  90.             product.setCategory(doc.get("category"));
  91.             product.setPrice(Double.parseDouble(doc.get("price")));
  92.             
  93.             results.add(product);
  94.         }
  95.         
  96.         reader.close();
  97.         return results;
  98.     }
  99. }
复制代码

Elasticsearch

Elasticsearch是一个基于Lucene的分布式、RESTful搜索和分析引擎，适用于大规模数据搜索。
  2. @Service
  3. public class ElasticsearchService {
  4.    
  5.     private final RestHighLevelClient client;
  6.    
  7.     public ElasticsearchService() {
  8.         client = new RestHighLevelClient(
  9.             RestClient.builder(
  10.                 new HttpHost("localhost", 9200, "http")));
  11.     }
  12.    
  13.     // 创建索引
  14.     public void createIndex(String indexName) throws IOException {
  15.         CreateIndexRequest request = new CreateIndexRequest(indexName);
  16.         client.indices().create(request, RequestOptions.DEFAULT);
  17.     }
  18.    
  19.     // 索引产品数据
  20.     public void indexProduct(String indexName, Product product) throws IOException {
  21.         IndexRequest request = new IndexRequest(indexName);
  22.         request.id(product.getId());
  23.         
  24.         // 将产品对象转换为JSON字符串
  25.         ObjectMapper mapper = new ObjectMapper();
  26.         String json = mapper.writeValueAsString(product);
  27.         request.source(json, XContentType.JSON);
  28.         
  29.         client.index(request, RequestOptions.DEFAULT);
  30.     }
  31.    
  32.     // 批量索引产品
  33.     public void bulkIndexProducts(String indexName, List<Product> products) throws IOException {
  34.         BulkRequest request = new BulkRequest();
  35.         ObjectMapper mapper = new ObjectMapper();
  36.         
  37.         for (Product product : products) {
  38.             IndexRequest indexRequest = new IndexRequest(indexName)
  39.                 .id(product.getId())
  40.                 .source(mapper.writeValueAsString(product), XContentType.JSON);
  41.             request.add(indexRequest);
  42.         }
  43.         
  44.         client.bulk(request, RequestOptions.DEFAULT);
  45.     }
  46.    
  47.     // 基本搜索
  48.     public List<Product> searchProducts(String indexName, String fieldName, String value, int size) throws IOException {
  49.         SearchRequest request = new SearchRequest(indexName);
  50.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  51.         
  52.         // 匹配查询
  53.         sourceBuilder.query(QueryBuilders.matchQuery(fieldName, value));
  54.         sourceBuilder.size(size);
  55.         
  56.         request.source(sourceBuilder);
  57.         
  58.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  59.         SearchHit[] hits = response.getHits().getHits();
  60.         
  61.         List<Product> results = new ArrayList<>();
  62.         ObjectMapper mapper = new ObjectMapper();
  63.         
  64.         for (SearchHit hit : hits) {
  65.             Product product = mapper.readValue(hit.getSourceAsString(), Product.class);
  66.             results.add(product);
  67.         }
  68.         
  69.         return results;
  70.     }
  71.    
  72.     // 多条件搜索
  73.     public List<Product> multiFieldSearch(String indexName, String keyword, String category, Double minPrice, Double maxPrice, int size) throws IOException {
  74.         SearchRequest request = new SearchRequest(indexName);
  75.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  76.         
  77.         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  78.         
  79.         // 关键词搜索
  80.         if (keyword != null && !keyword.isEmpty()) {
  81.             boolQuery.should(QueryBuilders.matchQuery("name", keyword));
  82.             boolQuery.should(QueryBuilders.matchQuery("description", keyword));
  83.         }
  84.         
  85.         // 分类过滤
  86.         if (category != null && !category.isEmpty()) {
  87.             boolQuery.filter(QueryBuilders.termQuery("category", category));
  88.         }
  89.         
  90.         // 价格范围过滤
  91.         if (minPrice != null || maxPrice != null) {
  92.             RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
  93.             if (minPrice != null) {
  94.                 rangeQuery.gte(minPrice);
  95.             }
  96.             if (maxPrice != null) {
  97.                 rangeQuery.lte(maxPrice);
  98.             }
  99.             boolQuery.filter(rangeQuery);
  100.         }
  101.         
  102.         sourceBuilder.query(boolQuery);
  103.         sourceBuilder.size(size);
  104.         
  105.         request.source(sourceBuilder);
  106.         
  107.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  108.         SearchHit[] hits = response.getHits().getHits();
  109.         
  110.         List<Product> results = new ArrayList<>();
  111.         ObjectMapper mapper = new ObjectMapper();
  112.         
  113.         for (SearchHit hit : hits) {
  114.             Product product = mapper.readValue(hit.getSourceAsString(), Product.class);
  115.             results.add(product);
  116.         }
  117.         
  118.         return results;
  119.     }
  120.    
  121.     // 聚合搜索
  122.     public Map<String, Object> searchWithAggregations(String indexName, String keyword) throws IOException {
  123.         SearchRequest request = new SearchRequest(indexName);
  124.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  125.         
  126.         // 基本查询
  127.         if (keyword != null && !keyword.isEmpty()) {
  128.             sourceBuilder.query(QueryBuilders.multiMatchQuery(keyword, "name", "description"));
  129.         }
  130.         
  131.         // 添加分类聚合
  132.         TermsAggregationBuilder categoryAggregation = AggregationBuilders.terms("categories")
  133.             .field("category")
  134.             .size(10);
  135.         
  136.         // 添加价格范围聚合
  137.         RangeAggregationBuilder priceRangeAggregation = AggregationBuilders.range("price_ranges")
  138.             .field("price")
  139.             .addRange(0, 50)
  140.             .addRange(50, 100)
  141.             .addRange(100, 200)
  142.             .addRange(200, Double.MAX_VALUE);
  143.         
  144.         sourceBuilder.aggregation(categoryAggregation);
  145.         sourceBuilder.aggregation(priceRangeAggregation);
  146.         
  147.         request.source(sourceBuilder);
  148.         
  149.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  150.         
  151.         // 处理聚合结果
  152.         Map<String, Object> result = new HashMap<>();
  153.         
  154.         // 获取分类聚合结果
  155.         Terms categoriesAgg = response.getAggregations().get("categories");
  156.         List<Map<String, Object>> categories = new ArrayList<>();
  157.         for (Terms.Bucket bucket : categoriesAgg.getBuckets()) {
  158.             Map<String, Object> categoryInfo = new HashMap<>();
  159.             categoryInfo.put("name", bucket.getKeyAsString());
  160.             categoryInfo.put("count", bucket.getDocCount());
  161.             categories.add(categoryInfo);
  162.         }
  163.         result.put("categories", categories);
  164.         
  165.         // 获取价格范围聚合结果
  166.         Range priceRangesAgg = response.getAggregations().get("price_ranges");
  167.         List<Map<String, Object>> priceRanges = new ArrayList<>();
  168.         for (Range.Bucket bucket : priceRangesAgg.getBuckets()) {
  169.             Map<String, Object> rangeInfo = new HashMap<>();
  170.             rangeInfo.put("from", bucket.getFrom());
  171.             rangeInfo.put("to", bucket.getTo());
  172.             rangeInfo.put("count", bucket.getDocCount());
  173.             priceRanges.add(rangeInfo);
  174.         }
  175.         result.put("priceRanges", priceRanges);
  176.         
  177.         return result;
  178.     }
  179.    
  180.     // 关闭客户端
  181.     public void close() throws IOException {
  182.         client.close();
  183.     }
  184. }
复制代码

Hibernate Search

Hibernate Search将Elasticsearch或Lucene与Hibernate ORM集成，提供透明的全文搜索功能。
  2. // 实体类配置
  3. @Entity
  4. @Table(name = "products")
  5. @Indexed(index = "products") // 声明此实体需要被索引
  6. public class Product {
  7.    
  8.     @Id
  9.     @GeneratedValue(generator = "UUID")
  10.     @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
  11.     @Column(name = "id", updatable = false, nullable = false)
  12.     @DocumentId // 声明为文档ID
  13.     private String id;
  14.    
  15.     @Column(name = "name", nullable = false)
  16.     @Field(name = "name", analyzer = @Analyzer(definition = "standard")) // 声明为可搜索字段
  17.     private String name;
  18.    
  19.     @Column(name = "description")
  20.     @Field(name = "description", analyzer = @Analyzer(definition = "standard"))
  21.     private String description;
  22.    
  23.     @Column(name = "category")
  24.     @Field(name = "category", analyzer = @Analyzer(definition = "keyword"))
  25.     private String category;
  26.    
  27.     @Column(name = "price")
  28.     @Field(name = "price")
  29.     @NumericField // 数值字段，支持范围查询
  30.     private Double price;
  31.    
  32.     // 其他字段、getter和setter
  33. }
复制代码
  2. @Service
  3. public class HibernateSearchService {
  4.    
  5.     @PersistenceContext
  6.     private EntityManager entityManager;
  7.    
  8.     // 初始化索引
  9.     public void initializeIndex() {
  10.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  11.         try {
  12.             fullTextEntityManager.createIndexer().startAndWait();
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17.    
  18.     // 基本搜索
  19.     public List<Product> search(String keyword) {
  20.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  21.         
  22.         QueryBuilder qb = fullTextEntityManager.getSearchFactory()
  23.             .buildQueryBuilder()
  24.             .forEntity(Product.class)
  25.             .get();
  26.         
  27.         // 在name和description字段中搜索关键词
  28.         org.apache.lucene.search.Query luceneQuery = qb
  29.             .keyword()
  30.             .onFields("name", "description")
  31.             .matching(keyword)
  32.             .createQuery();
  33.         
  34.         // 包装Hibernate查询
  35.         FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(luceneQuery, Product.class);
  36.         
  37.         // 执行搜索
  38.         return jpaQuery.getResultList();
  39.     }
  40.    
  41.     // 高级搜索 - 多条件组合
  42.     public List<Product> advancedSearch(String keyword, String category, Double minPrice, Double maxPrice) {
  43.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  44.         
  45.         QueryBuilder qb = fullTextEntityManager.getSearchFactory()
  46.             .buildQueryBuilder()
  47.             .forEntity(Product.class)
  48.             .get();
  49.         
  50.         BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
  51.         
  52.         // 添加关键词搜索条件
  53.         if (keyword != null && !keyword.isEmpty()) {
  54.             org.apache.lucene.search.Query keywordQuery = qb
  55.                 .keyword()
  56.                 .onFields("name", "description")
  57.                 .matching(keyword)
  58.                 .createQuery();
  59.             booleanQuery.add(keywordQuery, BooleanClause.Occur.SHOULD);
  60.         }
  61.         
  62.         // 添加分类过滤条件
  63.         if (category != null && !category.isEmpty()) {
  64.             org.apache.lucene.search.Query categoryQuery = qb
  65.                 .keyword()
  66.                 .onField("category")
  67.                 .matching(category)
  68.                 .createQuery();
  69.             booleanQuery.add(categoryQuery, BooleanClause.Occur.MUST);
  70.         }
  71.         
  72.         // 添加价格范围过滤条件
  73.         if (minPrice != null || maxPrice != null) {
  74.             RangeQuery<Double> priceRangeQuery = qb
  75.                 .range()
  76.                 .onField("price")
  77.                 .from(minPrice != null ? minPrice : 0.0)
  78.                 .to(maxPrice != null ? maxPrice : Double.MAX_VALUE)
  79.                 .createQuery();
  80.             booleanQuery.add(priceRangeQuery, BooleanClause.Occur.MUST);
  81.         }
  82.         
  83.         // 如果没有添加任何条件，使用MatchAllDocsQuery
  84.         if (booleanQuery.build().clauses().isEmpty()) {
  85.             return fullTextEntityManager.createFullTextQuery(new MatchAllDocsQuery(), Product.class).getResultList();
  86.         }
  87.         
  88.         // 包装Hibernate查询
  89.         FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(booleanQuery.build(), Product.class);
  90.         
  91.         // 执行搜索
  92.         return jpaQuery.getResultList();
  93.     }
  94.    
  95.     // 分页搜索
  96.     public List<Product> searchWithPagination(String keyword, int page, int size) {
  97.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  98.         
  99.         QueryBuilder qb = fullTextEntityManager.getSearchFactory()
  100.             .buildQueryBuilder()
  101.             .forEntity(Product.class)
  102.             .get();
  103.         
  104.         org.apache.lucene.search.Query luceneQuery = qb
  105.             .keyword()
  106.             .onFields("name", "description")
  107.             .matching(keyword)
  108.             .createQuery();
  109.         
  110.         FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(luceneQuery, Product.class);
  111.         
  112.         // 设置分页
  113.         jpaQuery.setFirstResult(page * size);
  114.         jpaQuery.setMaxResults(size);
  115.         
  116.         // 执行搜索
  117.         return jpaQuery.getResultList();
  118.     }
  119.    
  120.     // 排序搜索
  121.     public List<Product> searchWithSorting(String keyword, String sortField, boolean ascending) {
  122.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  123.         
  124.         QueryBuilder qb = fullTextEntityManager.getSearchFactory()
  125.             .buildQueryBuilder()
  126.             .forEntity(Product.class)
  127.             .get();
  128.         
  129.         org.apache.lucene.search.Query luceneQuery = qb
  130.             .keyword()
  131.             .onFields("name", "description")
  132.             .matching(keyword)
  133.             .createQuery();
  134.         
  135.         FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(luceneQuery, Product.class);
  136.         
  137.         // 设置排序
  138.         Sort sort = new Sort(new SortField(sortField, SortField.Type.STRING, !ascending));
  139.         jpaQuery.setSort(sort);
  140.         
  141.         // 执行搜索
  142.         return jpaQuery.getResultList();
  143.     }
  144.    
  145.     // 模糊搜索
  146.     public List<Product> fuzzySearch(String keyword, float similarity) {
  147.         FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
  148.         
  149.         QueryBuilder qb = fullTextEntityManager.getSearchFactory()
  150.             .buildQueryBuilder()
  151.             .forEntity(Product.class)
  152.             .get();
  153.         
  154.         org.apache.lucene.search.Query luceneQuery = qb
  155.             .keyword()
  156.             .fuzzy()
  157.             .withEditDistanceUpTo(2) // 最大编辑距离
  158.             .withPrefixLength(1) // 前缀长度
  159.             .onFields("name", "description")
  160.             .matching(keyword)
  161.             .createQuery();
  162.         
  163.         FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(luceneQuery, Product.class);
  164.         
  165.         // 执行搜索
  166.         return jpaQuery.getResultList();
  167.     }
  168. }
复制代码

实际案例和代码示例

电子商务网站产品搜索实现

下面是一个完整的电子商务网站产品搜索实现示例，结合了多种技术。
  2. public interface ProductSearchService {
  3.    
  4.     /**
  5.      * 基本关键词搜索
  6.      * @param keyword 搜索关键词
  7.      * @param page 页码
  8.      * @param size 每页大小
  9.      * @return 分页搜索结果
  10.      */
  11.     SearchResult<Product> searchByKeyword(String keyword, int page, int size);
  12.    
  13.     /**
  14.      * 高级搜索
  15.      * @param criteria 搜索条件
  16.      * @param page 页码
  17.      * @param size 每页大小
  18.      * @return 分页搜索结果
  19.      */
  20.     SearchResult<Product> advancedSearch(SearchCriteria criteria, int page, int size);
  21.    
  22.     /**
  23.      * 获取搜索建议
  24.      * @param prefix 用户输入的前缀
  25.      * @param size 返回建议数量
  26.      * @return 搜索建议列表
  27.      */
  28.     List<String> getSuggestions(String prefix, int size);
  29.    
  30.     /**
  31.      * 获取搜索聚合结果
  32.      * @param criteria 搜索条件
  33.      * @return 聚合结果
  34.      */
  35.     SearchAggregations getAggregations(SearchCriteria criteria);
  36. }
复制代码
  2. public class SearchCriteria {
  3.     private String keyword;
  4.     private String category;
  5.     private Double minPrice;
  6.     private Double maxPrice;
  7.     private List<String> brands;
  8.     private List<String> attributes;
  9.     private SortOption sortOption;
  10.    
  11.     // Getters and Setters
  12.    
  13.     public enum SortOption {
  14.         RELEVANCE("relevance"),
  15.         PRICE_ASC("price_asc"),
  16.         PRICE_DESC("price_desc"),
  17.         NAME_ASC("name_asc"),
  18.         NAME_DESC("name_desc"),
  19.         NEWEST("newest"),
  20.         RATING("rating");
  21.         
  22.         private final String value;
  23.         
  24.         SortOption(String value) {
  25.             this.value = value;
  26.         }
  27.         
  28.         public String getValue() {
  29.             return value;
  30.         }
  31.     }
  32. }
复制代码
  2. public class SearchResult<T> {
  3.     private List<T> content;
  4.     private int totalPages;
  5.     private long totalElements;
  6.     private int pageNumber;
  7.     private int pageSize;
  8.    
  9.     // Getters and Setters
  10. }
  12. public class SearchAggregations {
  13.     private List<CategoryCount> categories;
  14.     private List<PriceRangeCount> priceRanges;
  15.     private List<BrandCount> brands;
  16.     private List<AttributeCount> attributes;
  17.    
  18.     // Getters and Setters
  19.    
  20.     public static class CategoryCount {
  21.         private String name;
  22.         private long count;
  23.         
  24.         // Getters and Setters
  25.     }
  26.    
  27.     public static class PriceRangeCount {
  28.         private double from;
  29.         private double to;
  30.         private long count;
  31.         
  32.         // Getters and Setters
  33.     }
  34.    
  35.     public static class BrandCount {
  36.         private String name;
  37.         private long count;
  38.         
  39.         // Getters and Setters
  40.     }
  41.    
  42.     public static class AttributeCount {
  43.         private String name;
  44.         private String value;
  45.         private long count;
  46.         
  47.         // Getters and Setters
  48.     }
  49. }
复制代码
  2. @Service
  3. public class ElasticsearchProductSearchService implements ProductSearchService {
  4.    
  5.     private final RestHighLevelClient client;
  6.     private final ProductRepository productRepository;
  7.    
  8.     public ElasticsearchProductSearchService(ProductRepository productRepository) {
  9.         this.productRepository = productRepository;
  10.         this.client = new RestHighLevelClient(
  11.             RestClient.builder(
  12.                 new HttpHost("localhost", 9200, "http")));
  13.     }
  14.    
  15.     @Override
  16.     public SearchResult<Product> searchByKeyword(String keyword, int page, int size) {
  17.         SearchCriteria criteria = new SearchCriteria();
  18.         criteria.setKeyword(keyword);
  19.         return advancedSearch(criteria, page, size);
  20.     }
  21.    
  22.     @Override
  23.     public SearchResult<Product> advancedSearch(SearchCriteria criteria, int page, int size) {
  24.         try {
  25.             SearchRequest request = new SearchRequest("products");
  26.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  27.             
  28.             // 构建查询
  29.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  30.             
  31.             // 关键词搜索
  32.             if (criteria.getKeyword() != null && !criteria.getKeyword().isEmpty()) {
  33.                 boolQuery.should(QueryBuilders.matchQuery("name", criteria.getKeyword()).boost(2.0f));
  34.                 boolQuery.should(QueryBuilders.matchQuery("description", criteria.getKeyword()));
  35.                 boolQuery.should(QueryBuilders.matchQuery("brand", criteria.getKeyword()));
  36.             }
  37.             
  38.             // 分类过滤
  39.             if (criteria.getCategory() != null && !criteria.getCategory().isEmpty()) {
  40.                 boolQuery.filter(QueryBuilders.termQuery("category", criteria.getCategory()));
  41.             }
  42.             
  43.             // 价格范围过滤
  44.             if (criteria.getMinPrice() != null || criteria.getMaxPrice() != null) {
  45.                 RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
  46.                 if (criteria.getMinPrice() != null) {
  47.                     rangeQuery.gte(criteria.getMinPrice());
  48.                 }
  49.                 if (criteria.getMaxPrice() != null) {
  50.                     rangeQuery.lte(criteria.getMaxPrice());
  51.                 }
  52.                 boolQuery.filter(rangeQuery);
  53.             }
  54.             
  55.             // 品牌过滤
  56.             if (criteria.getBrands() != null && !criteria.getBrands().isEmpty()) {
  57.                 boolQuery.filter(QueryBuilders.termsQuery("brand", criteria.getBrands()));
  58.             }
  59.             
  60.             sourceBuilder.query(boolQuery);
  61.             
  62.             // 设置分页
  63.             sourceBuilder.from(page * size);
  64.             sourceBuilder.size(size);
  65.             
  66.             // 设置排序
  67.             if (criteria.getSortOption() != null) {
  68.                 switch (criteria.getSortOption()) {
  69.                     case PRICE_ASC:
  70.                         sourceBuilder.sort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
  71.                         break;
  72.                     case PRICE_DESC:
  73.                         sourceBuilder.sort(SortBuilders.fieldSort("price").order(SortOrder.DESC));
  74.                         break;
  75.                     case NAME_ASC:
  76.                         sourceBuilder.sort(SortBuilders.fieldSort("name.keyword").order(SortOrder.ASC));
  77.                         break;
  78.                     case NAME_DESC:
  79.                         sourceBuilder.sort(SortBuilders.fieldSort("name.keyword").order(SortOrder.DESC));
  80.                         break;
  81.                     case NEWEST:
  82.                         sourceBuilder.sort(SortBuilders.fieldSort("createdAt").order(SortOrder.DESC));
  83.                         break;
  84.                     case RATING:
  85.                         sourceBuilder.sort(SortBuilders.fieldSort("rating").order(SortOrder.DESC));
  86.                         break;
  87.                     case RELEVANCE:
  88.                     default:
  89.                         // 默认按相关性排序
  90.                         break;
  91.                 }
  92.             }
  93.             
  94.             request.source(sourceBuilder);
  95.             
  96.             // 执行搜索
  97.             SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  98.             
  99.             // 处理结果
  100.             List<Product> products = new ArrayList<>();
  101.             ObjectMapper mapper = new ObjectMapper();
  102.             
  103.             for (SearchHit hit : response.getHits().getHits()) {
  104.                 Product product = mapper.readValue(hit.getSourceAsString(), Product.class);
  105.                 products.add(product);
  106.             }
  107.             
  108.             // 构建返回结果
  109.             SearchResult<Product> result = new SearchResult<>();
  110.             result.setContent(products);
  111.             result.setPageNumber(page);
  112.             result.setPageSize(size);
  113.             result.setTotalElements(response.getHits().getTotalHits().value);
  114.             result.setTotalPages((int) Math.ceil((double) response.getHits().getTotalHits().value / size));
  115.             
  116.             return result;
  117.         } catch (IOException e) {
  118.             throw new RuntimeException("搜索失败", e);
  119.         }
  120.     }
  121.    
  122.     @Override
  123.     public List<String> getSuggestions(String prefix, int size) {
  124.         try {
  125.             SearchRequest request = new SearchRequest("products");
  126.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  127.             
  128.             // 使用Completion Suggester实现搜索建议
  129.             SuggestionBuilder termSuggestionBuilder = SuggestBuilders.completionSuggestion("name_suggest")
  130.                 .prefix(prefix)
  131.                 .size(size);
  132.             
  133.             SuggestBuilder suggestBuilder = new SuggestBuilder();
  134.             suggestBuilder.addSuggestion("name_suggest", termSuggestionBuilder);
  135.             
  136.             sourceBuilder.suggest(suggestBuilder);
  137.             request.source(sourceBuilder);
  138.             
  139.             SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  140.             Suggest suggest = response.getSuggest();
  141.             CompletionSuggestion completionSuggestion = suggest.getSuggestion("name_suggest");
  142.             
  143.             List<String> suggestions = new ArrayList<>();
  144.             for (CompletionSuggestion.Entry entry : completionSuggestion.getEntries()) {
  145.                 for (CompletionSuggestion.Entry.Option option : entry.getOptions()) {
  146.                     suggestions.add(option.getText().string());
  147.                 }
  148.             }
  149.             
  150.             return suggestions;
  151.         } catch (IOException e) {
  152.             throw new RuntimeException("获取搜索建议失败", e);
  153.         }
  154.     }
  155.    
  156.     @Override
  157.     public SearchAggregations getAggregations(SearchCriteria criteria) {
  158.         try {
  159.             SearchRequest request = new SearchRequest("products");
  160.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  161.             
  162.             // 构建查询
  163.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  164.             
  165.             // 关键词搜索
  166.             if (criteria.getKeyword() != null && !criteria.getKeyword().isEmpty()) {
  167.                 boolQuery.should(QueryBuilders.matchQuery("name", criteria.getKeyword()));
  168.                 boolQuery.should(QueryBuilders.matchQuery("description", criteria.getKeyword()));
  169.             }
  170.             
  171.             // 分类过滤
  172.             if (criteria.getCategory() != null && !criteria.getCategory().isEmpty()) {
  173.                 boolQuery.filter(QueryBuilders.termQuery("category", criteria.getCategory()));
  174.             }
  175.             
  176.             // 价格范围过滤
  177.             if (criteria.getMinPrice() != null || criteria.getMaxPrice() != null) {
  178.                 RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
  179.                 if (criteria.getMinPrice() != null) {
  180.                     rangeQuery.gte(criteria.getMinPrice());
  181.                 }
  182.                 if (criteria.getMaxPrice() != null) {
  183.                     rangeQuery.lte(criteria.getMaxPrice());
  184.                 }
  185.                 boolQuery.filter(rangeQuery);
  186.             }
  187.             
  188.             sourceBuilder.query(boolQuery);
  189.             sourceBuilder.size(0); // 不返回文档，只返回聚合结果
  190.             
  191.             // 添加分类聚合
  192.             TermsAggregationBuilder categoryAggregation = AggregationBuilders.terms("categories")
  193.                 .field("category")
  194.                 .size(10);
  195.             
  196.             // 添加价格范围聚合
  197.             RangeAggregationBuilder priceRangeAggregation = AggregationBuilders.range("price_ranges")
  198.                 .field("price")
  199.                 .addRange(0, 50)
  200.                 .addRange(50, 100)
  201.                 .addRange(100, 200)
  202.                 .addRange(200, 500)
  203.                 .addRange(500, Double.MAX_VALUE);
  204.             
  205.             // 添加品牌聚合
  206.             TermsAggregationBuilder brandAggregation = AggregationBuilders.terms("brands")
  207.                 .field("brand")
  208.                 .size(10);
  209.             
  210.             sourceBuilder.aggregation(categoryAggregation);
  211.             sourceBuilder.aggregation(priceRangeAggregation);
  212.             sourceBuilder.aggregation(brandAggregation);
  213.             
  214.             request.source(sourceBuilder);
  215.             
  216.             // 执行搜索
  217.             SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  218.             
  219.             // 处理聚合结果
  220.             SearchAggregations result = new SearchAggregations();
  221.             
  222.             // 处理分类聚合
  223.             Terms categoriesAgg = response.getAggregations().get("categories");
  224.             List<SearchAggregations.CategoryCount> categories = new ArrayList<>();
  225.             for (Terms.Bucket bucket : categoriesAgg.getBuckets()) {
  226.                 SearchAggregations.CategoryCount categoryCount = new SearchAggregations.CategoryCount();
  227.                 categoryCount.setName(bucket.getKeyAsString());
  228.                 categoryCount.setCount(bucket.getDocCount());
  229.                 categories.add(categoryCount);
  230.             }
  231.             result.setCategories(categories);
  232.             
  233.             // 处理价格范围聚合
  234.             Range priceRangesAgg = response.getAggregations().get("price_ranges");
  235.             List<SearchAggregations.PriceRangeCount> priceRanges = new ArrayList<>();
  236.             for (Range.Bucket bucket : priceRangesAgg.getBuckets()) {
  237.                 SearchAggregations.PriceRangeCount priceRangeCount = new SearchAggregations.PriceRangeCount();
  238.                 priceRangeCount.setFrom(bucket.getFrom() != null ? bucket.getFrom().doubleValue() : 0);
  239.                 priceRangeCount.setTo(bucket.getTo() != null ? bucket.getTo().doubleValue() : Double.MAX_VALUE);
  240.                 priceRangeCount.setCount(bucket.getDocCount());
  241.                 priceRanges.add(priceRangeCount);
  242.             }
  243.             result.setPriceRanges(priceRanges);
  244.             
  245.             // 处理品牌聚合
  246.             Terms brandsAgg = response.getAggregations().get("brands");
  247.             List<SearchAggregations.BrandCount> brands = new ArrayList<>();
  248.             for (Terms.Bucket bucket : brandsAgg.getBuckets()) {
  249.                 SearchAggregations.BrandCount brandCount = new SearchAggregations.BrandCount();
  250.                 brandCount.setName(bucket.getKeyAsString());
  251.                 brandCount.setCount(bucket.getDocCount());
  252.                 brands.add(brandCount);
  253.             }
  254.             result.setBrands(brands);
  255.             
  256.             return result;
  257.         } catch (IOException e) {
  258.             throw new RuntimeException("获取聚合结果失败", e);
  259.         }
  260.     }
  261.    
  262.     @PreDestroy
  263.     public void close() {
  264.         try {
  265.             client.close();
  266.         } catch (IOException e) {
  267.             e.printStackTrace();
  268.         }
  269.     }
  270. }
复制代码
  2. @RestController
  3. @RequestMapping("/api/search")
  4. public class SearchController {
  5.    
  6.     private final ProductSearchService searchService;
  7.    
  8.     public SearchController(ProductSearchService searchService) {
  9.         this.searchService = searchService;
  10.     }
  11.    
  12.     @GetMapping("/products")
  13.     public ResponseEntity<SearchResult<Product>> searchProducts(
  14.             @RequestParam(required = false) String keyword,
  15.             @RequestParam(required = false) String category,
  16.             @RequestParam(required = false) Double minPrice,
  17.             @RequestParam(required = false) Double maxPrice,
  18.             @RequestParam(required = false) List<String> brands,
  19.             @RequestParam(required = false) SearchCriteria.SortOption sort,
  20.             @RequestParam(defaultValue = "0") int page,
  21.             @RequestParam(defaultValue = "10") int size) {
  22.         
  23.         SearchCriteria criteria = new SearchCriteria();
  24.         criteria.setKeyword(keyword);
  25.         criteria.setCategory(category);
  26.         criteria.setMinPrice(minPrice);
  27.         criteria.setMaxPrice(maxPrice);
  28.         criteria.setBrands(brands);
  29.         criteria.setSortOption(sort);
  30.         
  31.         SearchResult<Product> result = searchService.advancedSearch(criteria, page, size);
  32.         return ResponseEntity.ok(result);
  33.     }
  34.    
  35.     @GetMapping("/suggestions")
  36.     public ResponseEntity<List<String>> getSuggestions(
  37.             @RequestParam String prefix,
  38.             @RequestParam(defaultValue = "5") int size) {
  39.         
  40.         List<String> suggestions = searchService.getSuggestions(prefix, size);
  41.         return ResponseEntity.ok(suggestions);
  42.     }
  43.    
  44.     @GetMapping("/aggregations")
  45.     public ResponseEntity<SearchAggregations> getAggregations(
  46.             @RequestParam(required = false) String keyword,
  47.             @RequestParam(required = false) String category,
  48.             @RequestParam(required = false) Double minPrice,
  49.             @RequestParam(required = false) Double maxPrice,
  50.             @RequestParam(required = false) List<String> brands) {
  51.         
  52.         SearchCriteria criteria = new SearchCriteria();
  53.         criteria.setKeyword(keyword);
  54.         criteria.setCategory(category);
  55.         criteria.setMinPrice(minPrice);
  56.         criteria.setMaxPrice(maxPrice);
  57.         criteria.setBrands(brands);
  58.         
  59.         SearchAggregations aggregations = searchService.getAggregations(criteria);
  60.         return ResponseEntity.ok(aggregations);
  61.     }
  62. }
复制代码

最佳实践和注意事项

索引设计最佳实践

1. 选择合适的字段类型：根据数据特性选择合适的字段类型，如文本、数值、日期等
2. 合理设置分析器：根据语言和搜索需求选择合适的分析器
3. 避免过度索引：只对需要搜索的字段建立索引，减少资源消耗
4. 使用复合索引：对经常一起查询的字段创建复合索引
5. 定期维护索引：定期优化和重建索引，保持搜索性能
  2. // Elasticsearch索引映射示例
  3. PUT /products
  4. {
  5.   "mappings": {
  6.     "properties": {
  7.       "id": {
  8.         "type": "keyword"
  9.       },
  10.       "name": {
  11.         "type": "text",
  12.         "analyzer": "standard",
  13.         "fields": {
  14.           "keyword": {
  15.             "type": "keyword",
  16.             "ignore_above": 256
  17.           }
  18.         }
  19.       },
  20.       "description": {
  21.         "type": "text",
  22.         "analyzer": "standard"
  23.       },
  24.       "category": {
  25.         "type": "keyword"
  26.       },
  27.       "price": {
  28.         "type": "double"
  29.       },
  30.       "brand": {
  31.         "type": "keyword"
  32.       },
  33.       "attributes": {
  34.         "type": "nested",
  35.         "properties": {
  36.           "name": {
  37.             "type": "keyword"
  38.           },
  39.           "value": {
  40.             "type": "keyword"
  41.           }
  42.         }
  43.       },
  44.       "createdAt": {
  45.         "type": "date"
  46.       },
  47.       "rating": {
  48.         "type": "double"
  49.       },
  50.       "name_suggest": {
  51.         "type": "completion"
  52.       }
  53.     }
  54.   }
  55. }
复制代码

查询优化最佳实践

1. 避免使用通配符开头的查询：如*keyword，这会导致全表扫描
2. 使用过滤器而非查询：对于不需要计算相关性的条件，使用过滤器提高性能
3. 限制返回字段：只返回需要的字段，减少数据传输量
4. 合理使用分页：避免深度分页，使用游标分页替代
5. 缓存常用查询结果：对高频查询结果进行缓存
  2. // 优化查询示例
  3. public List<Product> optimizedSearch(String keyword, String category, int page, int size) {
  4.     BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  5.    
  6.     // 使用must而非should确保相关性
  7.     if (keyword != null && !keyword.isEmpty()) {
  8.         boolQuery.must(QueryBuilders.matchQuery("name", keyword));
  9.     }
  10.    
  11.     // 使用filter而非must提高性能
  12.     if (category != null && !category.isEmpty()) {
  13.         boolQuery.filter(QueryBuilders.termQuery("category", category));
  14.     }
  15.    
  16.     SearchSourceBuilder sourceBuilder = new SearchSourceBuilder()
  17.         .query(boolQuery)
  18.         .from(page * size)
  19.         .size(size)
  20.         .fetchSource(new String[]{"id", "name", "price", "image"}, null); // 只返回需要的字段
  21.    
  22.     // 执行查询...
  23. }
复制代码

性能监控与调优

1. 监控搜索响应时间：设置性能监控，及时发现性能问题
2. 分析慢查询：定期分析慢查询，优化索引和查询
3. 合理分配资源：根据负载情况调整搜索服务资源
4. 使用性能分析工具：如Elasticsearch的Profile API
  2. // 使用Profile API分析查询性能
  3. public void analyzeQueryPerformance(String keyword) {
  4.     SearchRequest request = new SearchRequest("products");
  5.     SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  6.    
  7.     sourceBuilder.query(QueryBuilders.matchQuery("name", keyword));
  8.     sourceBuilder.profile(true); // 启用性能分析
  9.    
  10.     request.source(sourceBuilder);
  11.    
  12.     try {
  13.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  14.         
  15.         // 获取分析结果
  16.         ProfileShardResult profileShardResult = response.getProfileResults().get(0);
  17.         List<QueryProfileShardResult> queryProfileShardResults = profileShardResult.getSearchResults();
  18.         
  19.         // 分析查询性能
  20.         for (QueryProfileShardResult queryProfileResult : queryProfileShardResults) {
  21.             // 输出查询时间
  22.             System.out.println("Query time: " + queryProfileResult.getQueryTime() + "ms");
  23.             
  24.             // 分析查询详情
  25.             ProfileResult profileResult = queryProfileResult.getQuery();
  26.             printProfileResult(profileResult, 0);
  27.         }
  28.     } catch (IOException e) {
  29.         e.printStackTrace();
  30.     }
  31. }
  33. private void printProfileResult(ProfileResult profileResult, int indent) {
  34.     String indentStr = "  ".repeat(indent);
  35.     System.out.println(indentStr + "Type: " + profileResult.getQueryType());
  36.     System.out.println(indentStr + "Time: " + profileResult.getTime() + "ms");
  37.     System.out.println(indentStr + "Description: " + profileResult.getDescription());
  38.    
  39.     for (ProfileResult child : profileResult.getChildren()) {
  40.         printProfileResult(child, indent + 1);
  41.     }
  42. }
复制代码

搜索结果排序与相关性优化

1. 使用相关性评分：利用搜索引擎内置的相关性评分机制
2. 自定义评分：根据业务需求自定义评分规则
3. 使用boost调整权重：对不同字段设置不同权重
4. 结合业务规则排序：如新品优先、热销优先等
  2. // 自定义评分查询示例
  3. public List<Product> searchWithCustomScoring(String keyword, String category) {
  4.     BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  5.    
  6.     // 基本查询
  7.     if (keyword != null && !keyword.isEmpty()) {
  8.         boolQuery.should(QueryBuilders.matchQuery("name", keyword).boost(2.0f));
  9.         boolQuery.should(QueryBuilders.matchQuery("description", keyword).boost(1.0f));
  10.     }
  11.    
  12.     if (category != null && !category.isEmpty()) {
  13.         boolQuery.filter(QueryBuilders.termQuery("category", category));
  14.     }
  15.    
  16.     // 使用Function Score Query自定义评分
  17.     FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(
  18.         boolQuery,
  19.         new FunctionScoreQueryBuilder.FilterFunctionBuilder[] {
  20.             // 新品评分提升
  21.             new FunctionScoreQueryBuilder.FilterFunctionBuilder(
  22.                 QueryBuilders.matchAllQuery(),
  23.                 ScoreFunctionBuilders.exponentialDecayFunction("createdAt", "now", "30d", "7d")
  24.             ),
  25.             // 高评分产品提升
  26.             new FunctionScoreQueryBuilder.FilterFunctionBuilder(
  27.                 QueryBuilders.matchAllQuery(),
  28.                 ScoreFunctionBuilders.fieldValueFactorFunction("rating")
  29.                     .modifier(FieldValueFactorFunctionModifier.LN1P)
  30.                     .missing(0)
  31.             ),
  32.             // 库存充足产品提升
  33.             new FunctionScoreQueryBuilder.FilterFunctionBuilder(
  34.                 QueryBuilders.rangeQuery("stock").gt(10),
  35.                 ScoreFunctionBuilders.weightFactorFunction(1.5f)
  36.             )
  37.         }
  38.     ).boostMode(CombineFunction.MULTIPLY).scoreMode(FunctionScoreQuery.ScoreMode.SUM);
  39.    
  40.     SearchSourceBuilder sourceBuilder = new SearchSourceBuilder()
  41.         .query(functionScoreQuery);
  42.    
  43.     // 执行查询...
  44. }
复制代码

结论

在Java项目中实现高效搜索功能需要综合考虑多种因素，包括数据规模、性能需求、功能复杂度等。本文详细介绍了从基础数据结构搜索到高级全文搜索引擎的各种技术方法，并通过实际案例展示了如何构建完整的搜索解决方案。

对于小型应用，可以使用Java内置数据结构或数据库查询实现基本搜索功能；对于中型应用，可以集成Lucene或Hibernate Search提供更强大的搜索能力；对于大型分布式应用，Elasticsearch则是最佳选择，它提供了高性能、可扩展的搜索解决方案。

无论选择哪种技术，都需要关注索引设计、查询优化、性能监控和结果相关性等关键方面，以构建满足用户需求的高效搜索系统。通过合理应用本文介绍的技术和方法，开发者可以在Java项目中实现快速、准确、用户友好的搜索功能，提升应用的整体用户体验。
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.