Lucene4.10使用教程(四)：lucene的Search

对于检索来说，Lucene4.10默认提供了很多检索模式，包括模糊查询、正则匹配、通配符匹配等有用的匹配模式，但是在实际使用时需要考虑Lucene匹配的效率和系统的需求然后选择相应的匹配模式。

Lucene也提供了分页的查询方式。可以在scoredocs中进行分页，适合数据量比较小的情况，数据量太大有可能导致内存溢出；使用SearchAfter分页，每页都从索引中查询数据，查询速度较上一种慢，但是不会有内存溢出的情况出现，这也是推荐的用法。

注意：在Lucene中是不存在date类型的，对于日期类型来说，如果需要进行索引查询，需要将日期转换为long类型进行存储和比较。

代码最有说服力，先上代码：

package com.johnny.lucene02.search;

import java.io.File;

import java.io.IOException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.io.ByteOrderMark;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.document.IntField;

import org.apache.lucene.document.LongField;

import org.apache.lucene.document.StringField;

import org.apache.lucene.document.TextField;

import org.apache.lucene.document.Field.Store;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.index.DirectoryReader;

import org.apache.lucene.index.IndexReader;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.index.Term;

import org.apache.lucene.queryparser.classic.QueryParser;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.FuzzyQuery;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.NumericRangeQuery;

import org.apache.lucene.search.PhraseQuery;

import org.apache.lucene.search.PrefixQuery;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.search.TermQuery;

import org.apache.lucene.search.TermRangeFilter;

import org.apache.lucene.search.TermRangeQuery;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.search.WildcardQuery;

import org.apache.lucene.search.BooleanClause.Occur;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;

import org.apache.lucene.store.LockObtainFailedException;

import org.apache.lucene.util.BytesRef;

import org.apache.lucene.util.Version;

/**

* 对于中文来说，Lucene提供的search基本上不能使用，使用中文分词器替换即可

* @author Johnny

*

*/

public class SearchUtil {

private Version Lucene_Version = Version.LUCENE_4_10_2;

private Directory directory;

private DirectoryReader reader = null;

private String[] ids = {"1","2","3","4","5","6"};

private String[] emails = {"aa@itat.org","bb@itat.org","cc@cc.org","dd@sina.org","ee@zttc.edu","ff@itat.org"};

private String[] contents = {

"welcome to visited the space,I like book java",

"hello boy, I like pingpeng ball",

"my name is cc I like game java",

"I like football",

"I like football and I like basketball too",

"I like movie and swim java"

};

private Date[] dates = null;

private int[] attachs = {2,3,1,4,5,5};

private String[] names = {"zhangsan","lisi","john","jetty","mike","jake"};

public SearchUtil() {

// directory = new RAMDirectory();

try {

directory = FSDirectory.open(new File("/Users/ChinaMWorld/Desktop/index/"));

setDates();

} catch (IOException e) {

e.printStackTrace();

}

}

private void setDates() {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

try {

dates = new Date[ids.length];

dates[0] = sdf.parse("2010-02-19");

dates[1] = sdf.parse("2012-01-11");

dates[2] = sdf.parse("2011-09-19");

dates[3] = sdf.parse("2010-12-22");

dates[4] = sdf.parse("2012-01-01");

dates[5] = sdf.parse("2011-05-19");

} catch (ParseException e) {

e.printStackTrace();

}

}

public void index() {

IndexWriter writer = null;

try {

writer = new IndexWriter(directory,new IndexWriterConfig(Lucene_Version, new StandardAnalyzer()));

//writer.deleteAll();

Document doc = null;

for(int i=0;i<ids.length;i++) {

doc = new Document();

doc.add(new StringField("id",ids[i],Store.YES));

doc.add(new StringField("email", emails[i],Store.YES));

doc.add(new TextField("content", contents[i], Store.NO));

doc.add(new StringField("name",names[i], Store.YES));

//存储数字

doc.add(new IntField("attach",attachs[i], Store.YES));

//存储日期

doc.add(new LongField("date", dates[i].getTime(), Store.YES));

String et = emails[i].substring(emails[i].lastIndexOf("@")+1);

System.out.println(et);

/**

* 在Lucene4.x中，只能给域加权，部门给文档加权，如果要提高文档的加权，需要给

* 文档的每个域进行加权

* **/

writer.addDocument(doc);

}

} catch (IOException e) {

e.printStackTrace();

} finally{

try{

if(writer!=null) writer.close();

}catch(Exception ex){

ex.printStackTrace();

}

}

}

public IndexSearcher getSearcher() {

try {

if(reader==null) {

reader = DirectoryReader.open(directory);

} else {

DirectoryReader tr = DirectoryReader.openIfChanged(reader) ;

if(tr!=null) {

reader.close();

reader = tr;

}

}

return new IndexSearcher(reader);

} catch (CorruptIndexException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return null;

}

/**

* 指定field进行查询，termquery不能进行数字和日期的查询

* 日期的查询需要转成数字进行查询，

* 数字查询使用NumbericRangeQuery

* @param field

* @param name

* @param num

*/

public void searchByTerm(String field,String name,int num) {

try {

IndexSearcher searcher = getSearcher();

Query query = new TermQuery(new Term(field,name));

TopDocs tds = searcher.search(query, num);

System.out.println("一共查询了:"+tds.totalHits);

for(ScoreDoc sd:tds.scoreDocs) {

Document doc = searcher.doc(sd.doc);

System.out.println(doc.get("id")+"---->"+

doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+

doc.get("attach")+","+doc.get("date"));

}

} catch (CorruptIndexException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public void searchByTermRange(String field,String start,String end,int num) {

try {

IndexSearcher searcher = getSearcher();

Query query = new TermRangeQuery(field,new BytesRef(start.getBytes()),new BytesRef(end.getBytes()) , true, true);

TopDocs tds = searcher.search(query, num);

System.out.println("一共查询了:"+tds.totalHits);

for(ScoreDoc sd:tds.scoreDocs) {

Document doc = searcher.doc(sd.doc);

System.out.println(doc.get("id")+"---->"+

doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+

doc.get("attach")+","+doc.get("date"));

}

} catch (CorruptIndexException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public void searchByQueryParse(Query query,int num) {

try {

IndexSearcher searcher = getSearcher();

TopDocs tds = searcher.search(query, num);

System.out.println("一共查询了:"+tds.totalHits);

for(ScoreDoc sd:tds.scoreDocs) {

Document doc = searcher.doc(sd.doc);

System.out.println(doc.get("id")+"---->"+

doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+

doc.get("attach")+","+doc.get("date")+"=="+sd.score);

}

} catch (CorruptIndexException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

/***如果想要获取为存储到索引中得值，可以根据ID去源文件中进行查找并返回**/

public void searchPage(String query,int pageIndex,int pageSize) {

try {

IndexSearcher searcher = getSearcher();

QueryParser parser = new QueryParser("content",new StandardAnalyzer());

Query q =null;

try {

q = parser.parse(query);

} catch (org.apache.lucene.queryparser.classic.ParseException e) {

e.printStackTrace();

}

TopDocs tds = searcher.search(q, 500);

ScoreDoc[] sds = tds.scoreDocs;

int start = (pageIndex-1)*pageSize;

int end = pageIndex*pageSize;

if(end>=sds.length) end = sds.length;

for(int i=start;i<end;i++) {

Document doc = searcher.doc(sds[i].doc);

String id = doc.get("id");

int arrInt = -1;

for(int j=0;j<ids.length;j++){

if(id.equals(ids[j])){

arrInt = j;

break;

}

}

System.out.println(sds[i].doc+":"+doc.get("name")+"-->"+contents[arrInt]);

}

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* 根据页码和分页大小获取上一次的最后一个ScoreDoc

*/

private ScoreDoc getLastScoreDoc(int pageIndex,int pageSize,Query query,IndexSearcher searcher) throws IOException {

if(pageIndex==1)return null;//如果是第一页就返回空

int num = pageSize*(pageIndex-1);//获取上一页的数量

TopDocs tds = searcher.search(query, num);

return tds.scoreDocs[num-1];

}

/***

* 在使用时，searchAfter查询的是指定页数后面的数据，效率更高，推荐使用

* @param query

* @param pageIndex

* @param pageSize

*/

public void searchPageByAfter(String query,int pageIndex,int pageSize) {

try {

IndexSearcher searcher = getSearcher();

QueryParser parser = new QueryParser("content",new StandardAnalyzer());

Query q = null;

try {

q = parser.parse(query);

} catch (org.apache.lucene.queryparser.classic.ParseException e) {

e.printStackTrace();

}

//先获取上一页的最后一个元素

ScoreDoc lastSd = getLastScoreDoc(pageIndex, pageSize, q, searcher);

//通过最后一个元素搜索下页的pageSize个元素

TopDocs tds = searcher.searchAfter(lastSd,q, pageSize);

for(ScoreDoc sd:tds.scoreDocs) {

Document doc = searcher.doc(sd.doc);

String id = doc.get("id");

int arrInt = -1;

for(int j=0;j<ids.length;j++){

if(id.equals(ids[j])){

arrInt = j;

break;

}

}

System.out.println(doc.get("name")+"-->"+contents[arrInt]);

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

测试代码如下：

package com.johnny.lucene02.search;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.queryparser.classic.QueryParser;

import org.apache.lucene.search.Query;

import org.apache.lucene.util.Version;

import org.junit.Before;

import org.junit.Test;

public class TestSearch {

private SearchUtil su = null;

@Before

public void init(){

su = new SearchUtil();

}

@Test

public void testInex(){

su.index();

}

@Test

public void testSearchByTerm(){

su.searchByTerm("content","i", 3);

}

@Test

public void testSearchByTermRange(){

//查询name以a开头和s结尾的

su.searchByTermRange("name","a","s",10);

//由于attachs是数字类型，使用TermRange无法查询

System.out.println("------------");

su.searchByTermRange("attach","2","10", 5);

}

@Test

public void testSearchByQueryParse() throws Exception{

//1、创建QueryParser对象,默认搜索域为content

QueryParser parser = new QueryParser( "content", new StandardAnalyzer());

//改变空格的默认操作符，以下可以改成AND

//parser.setDefaultOperator(Operator.AND);

//开启第一个字符的通配符匹配，默认关闭因为效率不高

parser.setAllowLeadingWildcard(true);

//搜索content中包含有like的

Query query = parser.parse("like");

//有basketball或者football的，空格默认就是OR

//query = parser.parse("basketball football");

//改变搜索域为name为mike

//query = parser.parse("content:like");

//同样可以使用*和?来进行通配符匹配

// query = parser.parse("name:j*");

//query = parser.parse("email:*@itat.org");

//匹配name中没有mike但是content中必须有pingpeng的，+和-要放置到域说明前面

query = parser.parse("-name:mike +like +pingpeng");

//匹配一个区间，注意:TO必须是大写

//query = parser.parse("id:[1 TO 6]");

//闭区间匹配只会匹配到2

//query = parser.parse("id:{1 TO 3}");

//完全匹配I Like Football的

//query = parser.parse("\"I like football\"");

//匹配I 和football之间有一个单词距离的

//query = parser.parse("\"I football\"~1");

//模糊查询

//query = parser.parse("name:make~");

//没有办法匹配数字范围（自己扩展Parser）

//query = parser.parse("attach:[2 TO 10]");

su.searchByQueryParse(query, 10);

}

@Test

public void testSearchPage() {

su.searchPage("java", 1,20);

}

@Test

public void testSearchPageByAfter() {

su.searchPageByAfter("java", 1,20);

}

}