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的分页检索功能就实现了。