轉載請注明出處：[http://blog.csdn.net/xiaojimanman/article/details/44656141](http://blog.csdn.net/xiaojimanman/article/details/44656141) [http://www.llwjy.com/blogdetail/162e5e70516d7ddfb6df8f77e6b13a2b.html](http://www.llwjy.com/blogdetail/162e5e70516d7ddfb6df8f77e6b13a2b.html) 個人博客站已經上線了，網址 [www.llwjy.com ](http://www.llwjy.com)~歡迎各位吐槽 ----------------------------------------------------------------------------------------------------------- 在之前的《[基于lucene的案例開發：Query查詢](http://www.llwjy.com/blogdetail/e058b44d064c09a0b4a7cbce4e1a9453.html)》這篇博客中對實際開發過程中比較常見的Query做了簡單的介紹，這里就介紹下具體的代碼實現。查看最新代碼[點擊這里](http://www.llwjy.com/source/com.lulei.lucene.query.PackQuery.html)或訪問?http://www.llwjy.com/source/com.lulei.lucene.query.PackQuery.html? ~~~ /** *@Description: 創建查詢Query */ package com.lulei.lucene.query; import java.io.IOException; import java.io.StringReader; import java.util.ArrayList; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.index.Term; import org.apache.lucene.queryparser.classic.MultiFieldQueryParser; import org.apache.lucene.queryparser.classic.ParseException; import org.apache.lucene.queryparser.classic.QueryParser; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.BooleanQuery; 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.TermQuery; import org.apache.lucene.search.TermRangeQuery; import org.apache.lucene.search.WildcardQuery; import org.apache.lucene.util.Version; import com.lulei.lucene.index.manager.IndexManager; public class PackQuery { //分詞器 private Analyzer analyzer; //使用索引中的分詞器 public PackQuery(String indexName) { analyzer = IndexManager.getIndexManager(indexName).getAnalyzer(); } //使用自定義分詞器 public PackQuery(Analyzer analyzer) { this.analyzer = analyzer; } /** * @param key * @param fields * @return Query * @throws ParseException * @Author: lulei * @Description: 查詢字符串匹配多個查詢域 */ public Query getMultiFieldQuery(String key, String[] fields) throws ParseException{ MultiFieldQueryParser parse = new MultiFieldQueryParser(Version.LUCENE_43, fields, analyzer); Query query = null; query = parse.parse(key); return query; } /** * @param key * @param field * @return Query * @throws ParseException * @Author: lulei * @Description: 查詢字符串匹配單個查詢域 */ public Query getOneFieldQuery(String key, String field) throws ParseException{ if (key == null || key.length() < 1){ return null; } QueryParser parse = new QueryParser(Version.LUCENE_43, field, analyzer); Query query = null; query = parse.parse(key); return query; } /** * @param key * @param fields * @param occur * @return Query * @throws IOException * @Author: lulei * @Description: 查詢字符串、多個查詢域以及查詢域在查詢語句中的關系 */ public Query getBooleanQuery(String key, String[] fields, Occur[] occur) throws IOException{ if (fields.length != occur.length){ System.out.println("fields.length isn't equals occur.length, please check params!"); return null; } BooleanQuery query = new BooleanQuery(); TokenStream tokenStream = analyzer.tokenStream("", new StringReader(key)); ArrayList<String> analyzerKeys = new ArrayList<String>(); while(tokenStream.incrementToken()){ CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class); analyzerKeys.add(term.toString()); } for(int i = 0; i < fields.length; i++){ BooleanQuery queryField = new BooleanQuery(); for(String analyzerKey : analyzerKeys){ TermQuery termQuery = new TermQuery(new Term(fields[i], analyzerKey)); queryField.add(termQuery, Occur.SHOULD); } query.add(queryField, occur[i]); } return query; } /** * @param querys * @param occur * @return Query * @Author: lulei * @Description: 組合多個查詢，之間的關系由occur確定 */ public Query getBooleanQuery(ArrayList<Query> querys, ArrayList<Occur> occurs){ if (querys.size() != occurs.size()){ System.out.println("querys.size() isn't equals occurs.size(), please check params!"); return null; } BooleanQuery query = new BooleanQuery(); for (int i = 0; i < querys.size(); i++){ query.add(querys.get(i), occurs.get(i)); } return query; } /** * @param fieldName * @param value * @return * @Author: lulei * @Description: StringField屬性的搜索 */ public Query getStringFieldQuery(String value, String fieldName){ Query query = null; query = new TermQuery(new Term(fieldName, value)); return query; } /** * @param fields * @param values * @return * @Author: lulei * @Description: 多個StringField屬性的搜索 */ public Query getStringFieldQuery(String[] values, String[] fields, Occur occur){ if (fields == null || values == null || fields.length != values.length){ return null; } ArrayList<Query> querys = new ArrayList<Query>(); ArrayList<Occur> occurs = new ArrayList<Occur>(); for (int i = 0; i < fields.length; i++){ querys.add(getStringFieldQuery(values[i], fields[i])); occurs.add(occur); } return getBooleanQuery(querys, occurs); } /** * @param key * @param field * @param lucene43 * @return * @throws ParseException * @Author: lulei * @Description: 查詢字符串和單個查詢域 QueryParser是否使用4.3 */ public Query getOneFieldQuery(String key, String field, boolean lucene43) throws ParseException{ if (key == null || key.length() < 1){ return null; } if (lucene43){ return getOneFieldQuery(key, field); } @SuppressWarnings("deprecation") QueryParser parse = new QueryParser(Version.LUCENE_30, field, analyzer); Query query = null; query = parse.parse(key); return query; } /** * @param key * @param field * @Author: lulei * @Description: key開頭的查詢字符串，和單個域匹配 */ public Query getStartQuery(String key, String field) { if (key == null || key.length() < 1){ return null; } Query query = new PrefixQuery(new Term(field, key)); return query; } /** * @param key * @param fields * @param occur * @Author: lulei * @Description: key開頭的查詢字符串，和多個域匹配，每個域之間的關系由occur確定 */ public Query getStartQuery(String key, String []fields, Occur occur){ if (key == null || key.length() < 1){ return null; } ArrayList<Query> querys = new ArrayList<Query>(); ArrayList<Occur> occurs = new ArrayList<Occur>(); for (String field : fields) { querys.add(getStartQuery(key, field)); occurs.add(occur); } return getBooleanQuery(querys, occurs); } /** * @param key * @param fields * @Author: lulei * @Description: key開頭的查詢字符串，和多個域匹配，每個域之間的關系Occur.SHOULD */ public Query getStartQuery(String key, String []fields) { return getStartQuery(key, fields, Occur.SHOULD); } /** * @param key * @param field * @param slop * @return * @Author:lulei * @Description: 自定每個詞元之間的最大距離 */ public Query getPhraseQuery(String key, String field, int slop) { if (key == null || key.length() < 1){ return null; } StringReader reader = new StringReader(key); PhraseQuery query = new PhraseQuery(); query.setSlop(slop); try { TokenStream tokenStream = this.analyzer.tokenStream(field, reader); tokenStream.reset(); CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class); while(tokenStream.incrementToken()){ query.add(new Term(field, term.toString())); } reader.close(); } catch (IOException e) { e.printStackTrace(); return null; } return query; } /** * @param key * @param fields * @param slop * @param occur * @return * @Author:lulei * @Description: 自定每個詞元之間的最大距離，查詢多個域，每個域之間的關系由occur確定 */ public Query getPhraseQuery(String key, String[] fields, int slop, Occur occur) { if (key == null || key.length() < 1){ return null; } ArrayList<Query> querys = new ArrayList<Query>(); ArrayList<Occur> occurs = new ArrayList<Occur>(); for (String field : fields) { querys.add(getPhraseQuery(key, field, slop)); occurs.add(occur); } return getBooleanQuery(querys, occurs); } /** * @param key * @param fields * @param slop * @return * @Author:lulei * @Description: 自定每個詞元之間的最大距離，查詢多個域，每個域之間的關系是Occur.SHOULD */ public Query getPhraseQuery(String key, String[] fields, int slop) { return getPhraseQuery(key, fields, slop, Occur.SHOULD); } /** * @param key * @param field * @return * @Author:lulei * @Description: 通配符檢索 eg:getWildcardQuery("a*thor", "field") */ public Query getWildcardQuery(String key, String field) { if (key == null || key.length() < 1){ return null; } return new WildcardQuery(new Term(field, key)); } /** * @param key * @param fields * @param occur * @return * @Author:lulei * @Description: 通配符檢索，域之間的關系為occur */ public Query getWildcardQuery(String key, String[] fields, Occur occur) { if (key == null || key.length() < 1){ return null; } ArrayList<Query> querys = new ArrayList<Query>(); ArrayList<Occur> occurs = new ArrayList<Occur>(); for (String field : fields) { querys.add(getWildcardQuery(key, field)); occurs.add(occur); } return getBooleanQuery(querys, occurs); } /** * @param key * @param fields * @return * @Author:lulei * @Description: 通配符檢索，域之間的關系為Occur.SHOULD */ public Query getWildcardQuery(String key, String[] fields) { return getWildcardQuery(key, fields, Occur.SHOULD); } /** * @param keyStart * @param keyEnd * @param field * @param includeStart * @param includeEnd * @return * @Author:lulei * @Description: 范圍搜索 */ public Query getRangeQuery (String keyStart, String keyEnd, String field, boolean includeStart, boolean includeEnd) { return TermRangeQuery.newStringRange(field, keyStart, keyEnd, includeStart, includeEnd); } /** * @param min * @param max * @param field * @param includeMin * @param includeMax * @return * @Author:lulei * @Description: 范圍搜索 */ public Query getRangeQuery (int min, int max, String field, boolean includeMin, boolean includeMax) { return NumericRangeQuery.newIntRange(field, min, max, includeMin, includeMax); } /** * @param min * @param max * @param field * @param includeMin * @param includeMax * @return * @Author:lulei * @Description: 范圍搜索 */ public Query getRangeQuery (float min, float max, String field, boolean includeMin, boolean includeMax) { return NumericRangeQuery.newFloatRange(field, min, max, includeMin, includeMax); } /** * @param min * @param max * @param field * @param includeMin * @param includeMax * @return * @Author:lulei * @Description: 范圍搜索 */ public Query getRangeQuery (double min, double max, String field, boolean includeMin, boolean includeMax) { return NumericRangeQuery.newDoubleRange(field, min, max, includeMin, includeMax); } public static void main(String[] args) throws IOException { } } ~~~ PackQuery類的構造方法，可以手動指定分詞器也可以使用索引的分詞器。個人建議，在項目中使用索引中的分詞器，這樣就不會因為分詞器的不同造成不知名的錯誤。 ---------------------------------------------------------------------------------------------------- ps:最近發現其他網站可能會對博客轉載，上面并沒有源鏈接，如想查看更多關于 [基于lucene的案例開發](http://www.llwjy.com/blogtype/lucene.html) 請[點擊這里](http://blog.csdn.net/xiaojimanman/article/category/2841877)。或訪問網址http://blog.csdn.net/xiaojimanman/article/category/2841877