lucene7.5學習筆記（二）搜索及分頁的實現

實現了對數據的索引建立後就需要實現通過索引對數據的檢索功能了，同時大部分的檢索往往要求實現數據分頁顯示，因此同時需要實現數據的分頁功能。

實現查詢首先要創建一個IndexSearcher對象，創建代碼如下。

String indexDirectoryPath = "D：/code/";
Directory indexDirectory = FSDirectory.open(Paths.get(indexDirectoryPath));
IndexReader reader = DirectoryReader.open(directory);
IndexSearcher indexSearcher = new IndexSearcher(reader) ;

上面的代碼中需要注意indexDirectoryPath中的地址需要和之前創建IndexWriter時使用的地址相同。通過創建的IndexSearcher我們就可以實現各種數據檢索功能了，例如最簡單的關鍵字檢索功能，代碼如下。

TermQuery query = new TermQuery(new Term("Title", "通知公告"));
BooleanQuery booleanQuery = new BooleanQuery.Builder().add(query, Occur.MUST).build();
TopDocs hits = indexSearcher.search(booleanQuery, 30);
for(ScoreDoc scoreDoc : hits.scoreDocs) {
    Document doc = searcher.getDocument(scoreDoc);
	System.out.println("File: " + doc.get("Title"));
}

上述代碼中Title是之前創建的索引中包含的字段，在這裏指定查詢title中包含的“通知公告”相關內容的數據。同時最後將title中的數據打印出來，這裏有個一個需要注意的，如果需要將title字段的內容能夠在查詢結果中獲取需要在建立索引時將名稱爲title的field設置爲Field.Store.YES，否則雖然可以對title進行查詢，但是無法從查詢的結果中獲取到title的內容。

上面的例子中雖然實現了簡單的關鍵字檢索，但是lucene中的檢索方式非常的多，而且操作方式比較繁瑣，爲了配合後面的分頁檢索我設計了一個LuceneQuery類，用於統一管理lucene的檢索條件，最終在查詢時可以通過這個類自動獲取query對象來實現檢索。LuceneQuery類代碼如下：

package cn.izdigital.zwei.businesscomponent.lucene;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
import org.apache.lucene.document.IntPoint;
import org.apache.lucene.document.LongPoint;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.WildcardQuery;

import cn.izdigital.zwei.businesscomponent.mybatis.IntegerBaseEnum;

public class LuceneQuery {

	private BooleanQuery.Builder bqBuilder;
	private Sort sort;
	private List<SortField> sortFields;
	
	public LuceneQuery() {
		bqBuilder = new BooleanQuery.Builder();
		sort = null;
		sortFields = new LinkedList<>();
	}
	
	public BooleanQuery getQuery() {
		return bqBuilder.build();
	}
	
	public Sort getSort() {
		if(sortFields.size() > 0) {
			sort = new Sort(sortFields.stream().toArray(SortField[]::new));
		}
		else {
			sort = new Sort();
		}
		return sort;
	}
	
	/**
	 * 添加排序
	 * @param fieldName
	 * @param fieldType
	 * @param reverse true是降序  false爲升序
	 */
	public void addSortField(String fieldName, SortField.Type fieldType, boolean reverse ) {
		sortFields.add(new SortField(fieldName, fieldType, reverse));
	}
	
	/**
	 * 添加全文檢索
	 */
	public void addFullTextQuery(String searchQuery, String...fieldNames) {
		Analyzer analyzer = new SmartChineseAnalyzer();
		MultiFieldQueryParser parser = new MultiFieldQueryParser(fieldNames, analyzer);
		try {
			Query query = parser.parse(searchQuery);
			bqBuilder.add(query, BooleanClause.Occur.MUST);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * term查詢
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addTermQuery(String fieldName, String value, BooleanClause.Occur occur) {
		Query query = new TermQuery(new Term(fieldName, value));
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 添加前綴檢索
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addPrefixQuery(String fieldName, String value, BooleanClause.Occur occur) {
		PrefixQuery query = new PrefixQuery(new Term(fieldName, value));
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 通配符查詢
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addWildcardQuery(String fieldName, String value, BooleanClause.Occur occur) {
		Query query = new WildcardQuery(new Term(fieldName, value));
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 數值查詢
	 * @param value
	 * @param fieldName
	 * @param occur
	 */
	public void addIntEqualQuery(String fieldName, int value, BooleanClause.Occur occur) {
		Query query = IntPoint.newExactQuery(fieldName, value);
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 數值範圍查詢
	 * @param fieldName
	 * @param min
	 * @param max
	 * @param occur
	 */
	public void addIntRangeQuery(String fieldName, int min, int max, BooleanClause.Occur occur) {
		Query query = IntPoint.newRangeQuery(fieldName, min, max);
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 數值查詢
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addLongEqualQuery(String fieldName, long value, BooleanClause.Occur occur) {
		Query query = LongPoint.newExactQuery(fieldName, value);
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 數值範圍查詢
	 * @param fieldName
	 * @param min
	 * @param max
	 * @param occur
	 */
	public void addLongRangeQuery(String fieldName, long min, long max, BooleanClause.Occur occur) {
		Query query = LongPoint.newRangeQuery(fieldName, min, max);
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 時間範圍查詢
	 * @param fieldName
	 * @param startTime
	 * @param endTime
	 * @param occur
	 */
	public void addDateRangeQuery(String fieldName, Date startTime, Date endTime, BooleanClause.Occur occur) {
		Query query = LongPoint.newRangeQuery(fieldName, startTime.getTime(), endTime.getTime());
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 複雜檢索添加
	 * @param fieldName
	 * @param searchQuery
	 * @param occur
	 */
	public void addStringArrayQuery(String fieldName, String[] searchQuery, BooleanClause.Occur occur) {
		if(searchQuery != null && searchQuery.length > 0) {
			for (String value : searchQuery) {
				TermQuery query = new TermQuery(new Term(fieldName + "Detail", value));
				bqBuilder.add(query, occur);
			}
		}
	}
	
	/**
	 * Enum檢索添加
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addIntegerBaseEnumQuery(String fieldName, IntegerBaseEnum value, BooleanClause.Occur occur) {
		Query query = IntPoint.newExactQuery(fieldName, value.getValue());
		bqBuilder.add(query, occur);
	}
	
	/**
	 * 添加boolean檢索
	 * @param fieldName
	 * @param value
	 * @param occur
	 */
	public void addBooleanQuery(String fieldName, boolean value, BooleanClause.Occur occur) {
		int result = (value ? 1 : 0);
		Query query = IntPoint.newExactQuery(fieldName, result);
		bqBuilder.add(query, occur);
	}
	
}

通過LuceneQuery類添加檢索條件非常簡單，還是以關鍵字檢索爲例，代碼如下。

luceneQuery.addFullTextQuery("通知公告", "Title");

下面實現具體的數據查詢，我在實現時所有的查詢用的field都是Field.Store.NO的，同時將對象數據序列化後保存在lucene中一個統一的field中。這麼設計出於代碼實現簡單的考慮，反序列化和序列化使用的是fastjson，maven依賴添加如下。

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.7</version>
</dependency>

查詢方法實現代碼如下。

public <T> List<T> search(LuceneQuery query, Class<T> c){
	int maxHitCount = 10000;
        try {
		TopDocs hits = searcher.search(query.getQuery(), maxHitCount, query.getSort());
		List<T> list = new LinkedList<>();
		for (ScoreDoc scoreDoc : hits.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			T t = JSON.parseObject(doc.get("SerializeData"), c);
			list.add(t);
		}
		return list;
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} 
	return null;
}

上述方法中提取的名爲SerializeData的field就是我存儲序列化數據的field。

實現了簡單的查詢後我們還需要實現分頁的功能，分頁我採用的是開源的PageInfo插件，maven依賴添加如下。

<dependency>
    <groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.1.4</version>
</dependency>

實現分頁檢索的方法如下。

public <T> PageInfo<T> search(LuceneQuery query, Class<T> c, int pageIndex, int pageSize) {
	int maxHitCount = 10000;
        try {
		TopDocs hits = searcher.search(query.getQuery(), maxHitCount, query.getSort());
		ScoreDoc[] scoreDocs = hits.scoreDocs;
		//查詢結果總數
		int totalCount = scoreDocs.length;
		int pages = (int) Math.ceil((double)totalCount / (double)pageSize);
		//查詢起始記錄位置
	    int begin = pageSize * (pageIndex - 1) ;
	    //查詢終止記錄位置
	    int end = Math.min(begin + pageSize, scoreDocs.length);
		List<T> list = new LinkedList<>();
		for (int i = begin; i < end; i++) {
			Document doc = searcher.doc(scoreDocs[i].doc);
			T t = JSON.parseObject(doc.get("SerializeData"), c);
			list.add(t);
		}
		PageInfo<T> result = new PageInfo<>(list);
		result.setPageNum(pageIndex);
		result.setPageSize(pageSize);
		result.setSize(end - begin);
		result.setTotal(totalCount);
		result.setPages(pages);
		return result;
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} 
	return null;
}

至此lucene的分頁檢索功能就實現了。