lucene-candy系列：LuceneHelper

cn.juque.lucenecandy.helper.LuceneHelper 对lucene的增删改查API进行了统一封装，目的在提供较为统一的API调度。

1. 查询
   该方法根据查询条件返回文档集合。需要注意的是，该方法的响应时间与返回的结果集成正比，所以使用该方法应合理评估涉及的结果集大小。

public List<Document> search(String index, BooleanQuery.Builder builder, Sort sort, Set<String> fieldToLoad) {
        Assert.notNull(index);
        Assert.notNull(builder);
        Assert.notNull(sort);
        try {
            long start = System.currentTimeMillis();
            IndexReader indexReader = this.indexReaderCache.get(index, false);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);
            int size = 10000;
            TopDocs topDocs;
            ScoreDoc lastDoc = null;
            List<Document> result = CollUtil.newArrayList();
            do {
                topDocs = indexSearcher.searchAfter(lastDoc, builder.build(), size, sort);
                if (topDocs.scoreDocs.length > 0) {
                    lastDoc = topDocs.scoreDocs[topDocs.scoreDocs.length - 1];
                    result.addAll(this.toDocument(indexSearcher, topDocs, fieldToLoad));
                }
            } while (topDocs.scoreDocs.length > 0);
            long cost = System.currentTimeMillis() - start;
            log.debug("search index:{} query:{}, size:{}, cost:{}ms", index, builder.build(), CollUtil.size(result), cost);
            return result;
        } catch (IndexNotFoundException e) {
            return new ArrayList<>(0);
        } catch (Exception e) {
            log.error("search index:{} 查询异常", index, e);
        }
        throw new AppException(MessageEnum.SYSTEM_ERROR);
    }

2. 分页查询
   lucene并没有提供类似mysql的分页查询API，所以，我做了一次页数合并，只考虑两种情况：第一页和非第一页。第一页很好理解，直接限定返回数量即可；非第一页则是把(n-1)页合并起来，查询出(n-1)的最后一个文档，从(n-1)开始限定返回数量。这个查询逻辑成立的前提是，排序条件必不可少！

public List<Document> searchByPage(String index, BooleanQuery.Builder builder, Sort sort, PageInfo pageInfo, Set<String> fieldToLoad) {
        long start = System.currentTimeMillis();
        List<Document> docList;
        try {
            IndexReader indexReader = this.indexReaderCache.get(index, false);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);
            // 查询出前一页最后一条记录，然后再查当前页
            if (pageInfo.getPage() <= 1) {
                TopDocs topDocs = indexSearcher.search(builder.build(), pageInfo.getLimit(), sort);
                pageInfo.setTotal(topDocs.totalHits.value);
                docList = this.toDocument(indexSearcher, topDocs, fieldToLoad);
            } else {
                int size = pageInfo.getLimit() * (pageInfo.getPage() - 1);
                TopDocs topDocs = indexSearcher.search(builder.build(), size, sort);
                ScoreDoc lastDoc = topDocs.scoreDocs[topDocs.scoreDocs.length - 1];
                topDocs = indexSearcher.searchAfter(lastDoc, builder.build(), pageInfo.getLimit(), sort);
                pageInfo.setTotal(topDocs.totalHits.value);
                docList = this.toDocument(indexSearcher, topDocs, fieldToLoad);
            }
            long end = System.currentTimeMillis() - start;
            if (end > 0) {
                log.debug("searchByPage index:{} query:{}, size:{}, cost time:{}ms", index, builder.build(), pageInfo.getTotal(), end);
            }
            return docList;
        } catch (IndexNotFoundException e) {
            return new ArrayList<>(0);
        } catch (Exception e) {
            log.error(" index:{} document searchByPage error", index, e);
        }
        throw new AppException(MessageEnum.SYSTEM_ERROR);
    }

3. 新增文档

public void addDocuments(String index, List<Document> docList) {
        if (CollUtil.isEmpty(docList)) {
            return;
        }
        IndexWriter indexWriter = this.indexWriterCache.get(index, false);
        try {
            indexWriter.addDocuments(docList);
        } catch (Exception e) {
            log.error(" index:{} add documents error", index, e);
            throw new AppException(MessageEnum.SYSTEM_ERROR);
        }
    }

4. 根据条件更新文档
   lucene的更新操作可以理解为“先删除，后新增”，区别于关系型数据库的更新，是整个文档的所有字段的全量更新。

public void updateByQuery(String index, Query query, Document document) {
        IndexWriter indexWriter = this.indexWriterCache.get(index, false);
        try {
            // 删除
            indexWriter.deleteDocuments(query);
            // 新增
            indexWriter.addDocument(document);
        } catch (Exception e) {
            log.error(" index:{} update document error", index, e);
            throw new AppException(MessageEnum.SYSTEM_ERROR);
        }
    }

5. 根据查询条件删除文档

public void deleteDocuments(String index, Query... query) {
        IndexWriter indexWriter = this.indexWriterCache.get(index, false);
        try {
            indexWriter.deleteDocuments(query);
        } catch (Exception e) {
            log.error(" index:{} delete document error", index, e);
            throw new AppException(MessageEnum.SYSTEM_ERROR);
        }
    }