基于lucene的案例開發：查詢語句創建PackQuery

2019-11-15 00:51:48

字體：大中小

來源：轉載

供稿：網友

轉載請注明出處：http://blog.csdn.net/xiaojimanman/article/details/44656141

http://www.llwjy.com/blogdetail/162e5e70516d7ddfb6df8f77e6b13a2b.html

個人博客站已經上線了，網址 www.llwjy.com ~歡迎各位吐槽

-----------------------------------------------------------------------------------------------------------

在之前的《基于lucene的案例開發：Query查詢》這篇博客中對實際開發過程中比較常見的Query做了簡單的介紹，這里就介紹下具體的代碼實現。查看最新代碼點擊這里或訪問http://www.llwjy.com/source/com.lulei.lucene.query.PackQuery.html

view plaincopy to clipboardPRint?

/**
*@Description:創建查詢Query
*/
packagecom.lulei.lucene.query;
importjava.io.IOException;
importjava.io.StringReader;
importjava.util.ArrayList;
importorg.apache.lucene.analysis.Analyzer;
importorg.apache.lucene.analysis.TokenStream;
importorg.apache.lucene.analysis.tokenattributes.CharTermAttribute;
importorg.apache.lucene.index.Term;
importorg.apache.lucene.queryparser.classic.MultiFieldQueryParser;
importorg.apache.lucene.queryparser.classic.ParseException;
importorg.apache.lucene.queryparser.classic.QueryParser;
importorg.apache.lucene.search.BooleanClause.Occur;
importorg.apache.lucene.search.BooleanQuery;
importorg.apache.lucene.search.NumericRangeQuery;
importorg.apache.lucene.search.PhraseQuery;
importorg.apache.lucene.search.PrefixQuery;
importorg.apache.lucene.search.Query;
importorg.apache.lucene.search.TermQuery;
importorg.apache.lucene.search.TermRangeQuery;
importorg.apache.lucene.search.WildcardQuery;
importorg.apache.lucene.util.Version;
importcom.lulei.lucene.index.manager.IndexManager;
publicclassPackQuery{
//分詞器
privateAnalyzeranalyzer;
//使用索引中的分詞器
publicPackQuery(StringindexName){
analyzer=IndexManager.getIndexManager(indexName).getAnalyzer();
}
//使用自定義分詞器
publicPackQuery(Analyzeranalyzer){
this.analyzer=analyzer;
}
/**
*@paramkey
*@paramfields
*@returnQuery
*@throwsParseException
*@Author:lulei
*@Description:查詢字符串匹配多個查詢域
*/
publicQuerygetMultiFieldQuery(Stringkey,String[]fields)throwsParseException{
MultiFieldQueryParserparse=newMultiFieldQueryParser(Version.LUCENE_43,fields,analyzer);
Queryquery=null;
query=parse.parse(key);
returnquery;
}
/**
*@paramkey
*@paramfield
*@returnQuery
*@throwsParseException
*@Author:lulei
*@Description:查詢字符串匹配單個查詢域
*/
publicQuerygetOneFieldQuery(Stringkey,Stringfield)throwsParseException{
if(key==null||key.length()<1){
returnnull;
}
QueryParserparse=newQueryParser(Version.LUCENE_43,field,analyzer);
Queryquery=null;
query=parse.parse(key);
returnquery;
}
/**
*@paramkey
*@paramfields
*@paramoccur
*@returnQuery
*@throwsIOException
*@Author:lulei
*@Description:查詢字符串、多個查詢域以及查詢域在查詢語句中的關系
*/
publicQuerygetBooleanQuery(Stringkey,String[]fields,Occur[]occur)throwsIOException{
if(fields.length!=occur.length){
System.out.println("fields.lengthisn'tequalsoccur.length,pleasecheckparams!");
returnnull;
}
BooleanQueryquery=newBooleanQuery();
TokenStreamtokenStream=analyzer.tokenStream("",newStringReader(key));
ArrayList<String>analyzerKeys=newArrayList<String>();
while(tokenStream.incrementToken()){
CharTermAttributeterm=tokenStream.getAttribute(CharTermAttribute.class);
analyzerKeys.add(term.toString());
}
for(inti=0;i<fields.length;i++){
BooleanQueryqueryField=newBooleanQuery();
for(StringanalyzerKey:analyzerKeys){
TermQuerytermQuery=newTermQuery(newTerm(fields[i],analyzerKey));
queryField.add(termQuery,Occur.SHOULD);
}
query.add(queryField,occur[i]);
}
returnquery;
}
/**
*@paramquerys
*@paramoccur
*@returnQuery
*@Author:lulei
*@Description:組合多個查詢，之間的關系由occur確定
*/
publicQuerygetBooleanQuery(ArrayList<Query>querys,ArrayList<Occur>occurs){
if(querys.size()!=occurs.size()){
System.out.println("querys.size()isn'tequalsoccurs.size(),pleasecheckparams!");
returnnull;
}
BooleanQueryquery=newBooleanQuery();
for(inti=0;i<querys.size();i++){
query.add(querys.get(i),occurs.get(i));
}
returnquery;
}
/**
*@paramfieldName
*@paramvalue
*@return
*@Author:lulei
*@Description:StringField屬性的搜索
*/
publicQuerygetStringFieldQuery(Stringvalue,StringfieldName){
Queryquery=null;
query=newTermQuery(newTerm(fieldName,value));
returnquery;
}
/**
*@paramfields
*@paramvalues
*@return
*@Author:lulei
*@Description:多個StringField屬性的搜索
*/
publicQuerygetStringFieldQuery(String[]values,String[]fields,Occuroccur){
if(fields==null||values==null||fields.length!=values.length){
returnnull;
}
ArrayList<Query>querys=newArrayList<Query>();
ArrayList<Occur>occurs=newArrayList<Occur>();
for(inti=0;i<fields.length;i++){
querys.add(getStringFieldQuery(values[i],fields[i]));
occurs.add(occur);
}
returngetBooleanQuery(querys,occurs);
}
/**
*@paramkey
*@paramfield
*@paramlucene43
*@return
*@throwsParseException
*@Author:lulei
*@Description:查詢字符串和單個查詢域QueryParser是否使用4.3
*/
publicQuerygetOneFieldQuery(Stringkey,Stringfield,booleanlucene43)throwsParseException{
if(key==null||key.length()<1){
returnnull;
}
if(lucene43){
returngetOneFieldQuery(key,field);
}
@SuppressWarnings("deprecation")
QueryParserparse=newQueryParser(Version.LUCENE_30,field,analyzer);
Queryquery=null;
query=parse.parse(key);
returnquery;
}
/**
*@paramkey
*@paramfield
*@Author:lulei
*@Description:key開頭的查詢字符串，和單個域匹配
*/
publicQuerygetStartQuery(Stringkey,Stringfield){
if(key==null||key.length()<1){
returnnull;
}
Queryquery=newPrefixQuery(newTerm(field,key));
returnquery;
}
/**
*@paramkey
*@paramfields
*@paramoccur
*@Author:lulei
*@Description:key開頭的查詢字符串，和多個域匹配，每個域之間的關系由occur確定
*/
publicQuerygetStartQuery(Stringkey,String[]fields,Occuroccur){
if(key==null||key.length()<1){
returnnull;
}
ArrayList<Query>querys=newArrayList<Query>();
ArrayList<Occur>occurs=newArrayList<Occur>();
for(Stringfield:fields){
querys.add(getStartQuery(key,field));
occurs.add(occur);
}
returngetBooleanQuery(querys,occurs);
}
/**
*@paramkey
*@paramfields
*@Author:lulei
*@Description:key開頭的查詢字符串，和多個域匹配，每個域之間的關系Occur.SHOULD
*/
publicQuerygetStartQuery(Stringkey,String[]fields){
returngetStartQuery(key,fields,Occur.SHOULD);
}
/**
*@paramkey
*@paramfield
*@paramslop
*@return
*@Author:lulei
*@Description:自定每個詞元之間的最大距離
*/
publicQuerygetPhraseQuery(Stringkey,Stringfield,intslop){
if(key==null||key.length()<1){
returnnull;
}
StringReaderreader=newStringReader(key);
PhraseQueryquery=newPhraseQuery();
query.setSlop(slop);
try{
TokenStreamtokenStream=this.analyzer.tokenStream(field,reader);
tokenStream.reset();
CharTermAttributeterm=tokenStream.getAttribute(CharTermAttribute.class);
while(tokenStream.incrementToken()){
query.add(newTerm(field,term.toString()));
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
returnnull;
}
returnquery;
}
/**
*@paramkey
*@paramfields
*@paramslop
*@paramoccur
*@return
*@Author:lulei
*@Description:自定每個詞元之間的最大距離，查詢多個域，每個域之間的關系由occur確定
*/
publicQuerygetPhraseQuery(Stringkey,String[]fields,intslop,Occuroccur){
if(key==null||key.length()<1){
returnnull;
}
ArrayList<Query>querys=newArrayList<Query>();
ArrayList<Occur>occurs=newArrayList<Occur>();
for(Stringfield:fields){
querys.add(getPhraseQuery(key,field,slop));
occurs.add(occur);
}
returngetBooleanQuery(querys,occurs);
}
/**
*@paramkey
*@paramfields
*@paramslop
*@return
*@Author:lulei
*@Description:自定每個詞元之間的最大距離，查詢多個域，每個域之間的關系是Occur.SHOULD
*/
publicQuerygetPhraseQuery(Stringkey,String[]fields,intslop){
returngetPhraseQuery(key,fields,slop,Occur.SHOULD);
}
/**
*@paramkey
*@paramfield
*@return
*@Author:lulei
*@Description:通配符檢索eg:getWildcardQuery("a*thor","field")
*/
publicQuerygetWildcardQuery(Stringkey,Stringfield){
if(key==null||key.length()<1){
returnnull;
}
returnnewWildcardQuery(newTerm(field,key));
}
/**
*@paramkey
*@paramfields
*@paramoccur
*@return
*@Author:lulei
*@Description:通配符檢索，域之間的關系為occur
*/
publicQuerygetWildcardQuery(Stringkey,String[]fields,Occuroccur){
if(key==null||key.length()<1){
returnnull;
}
ArrayList<Query>querys=newArrayList<Query>();
ArrayList<Occur>occurs=newArrayList<Occur>();
for(Stringfield:fields){
querys.add(getWildcardQuery(key,field));
occurs.add(occur);
}
returngetBooleanQuery(querys,occurs);
}
/**
*@paramkey
*@paramfields
*@return
*@Author:lulei
*@Description:通配符檢索，域之間的關系為Occur.SHOULD
*/
publicQuerygetWildcardQuery(Stringkey,String[]fields){
returngetWildcardQuery(key,fields,Occur.SHOULD);
}
/**
*@paramkeyStart
*@paramkeyEnd
*@paramfield
*@paramincludeStart
*@paramincludeEnd
*@return
*@Author:lulei
*@Description:范圍搜索
*/
publicQuerygetRangeQuery(StringkeyStart,StringkeyEnd,Stringfield,booleanincludeStart,booleanincludeEnd){
returnTermRangeQuery.newStringRange(field,keyStart,keyEnd,includeStart,includeEnd);
}
/**
*@parammin
*@parammax
*@paramfield
*@paramincludeMin
*@paramincludeMax
*@return
*@Author:lulei
*@Description:范圍搜索
*/
publicQuerygetRangeQuery(intmin,intmax,Stringfield,booleanincludeMin,booleanincludeMax){
returnNumericRangeQuery.newIntRange(field,min,max,includeMin,includeMax);
}
/**
*@parammin
*@parammax
*@paramfield
*@paramincludeMin
*@paramincludeMax
*@return
*@Author:lulei
*@Description:范圍搜索
*/
publicQuerygetRangeQuery(floatmin,floatmax,Stringfield,booleanincludeMin,booleanincludeMax){
returnNumericRangeQuery.newFloatRange(field,min,max,includeMin,includeMax);
}
/**
*@parammin
*@parammax
*@paramfield
*@paramincludeMin
*@paramincludeMax
*@return
*@Author:lulei
*@Description:范圍搜索
*/
publicQuerygetRangeQuery(doublemin,doublemax,Stringfield,booleanincludeMin,booleanincludeMax){
returnNumericRangeQuery.newDoubleRange(field,min,max,includeMin,includeMax);
}
publicstaticvoidmain(String[]args)throwsIOException{
}
}