基于lucene的案例开发：查询语句创建PackQuery

2022-01-01 12:51:07

转载请注明出处：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

  1. /**
  2. *@Description:  创建查询Query
  3. */
  4. package com.lulei.lucene.query;
  5. import java.io.IOException;
  6. import java.io.StringReader;
  7. import java.util.ArrayList;
  8. import org.apache.lucene.analysis.Analyzer;
  9. import org.apache.lucene.analysis.TokenStream;
  10. import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  11. import org.apache.lucene.index.Term;
  12. import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
  13. import org.apache.lucene.queryparser.classic.ParseException;
  14. import org.apache.lucene.queryparser.classic.QueryParser;
  15. import org.apache.lucene.search.BooleanClause.Occur;
  16. import org.apache.lucene.search.BooleanQuery;
  17. import org.apache.lucene.search.NumericRangeQuery;
  18. import org.apache.lucene.search.PhraseQuery;
  19. import org.apache.lucene.search.PrefixQuery;
  20. import org.apache.lucene.search.Query;
  21. import org.apache.lucene.search.TermQuery;
  22. import org.apache.lucene.search.TermRangeQuery;
  23. import org.apache.lucene.search.WildcardQuery;
  24. import org.apache.lucene.util.Version;
  25. import com.lulei.lucene.index.manager.IndexManager;
  26. public class PackQuery {
  27. //分词器
  28. private Analyzer analyzer;
  29. //使用索引中的分词器
  30. public PackQuery(String indexName) {
  31. analyzer = IndexManager.getIndexManager(indexName).getAnalyzer();
  32. }
  33. //使用自定义分词器
  34. public PackQuery(Analyzer analyzer) {
  35. this.analyzer = analyzer;
  36. }
  37. /**
  38. * @param key
  39. * @param fields
  40. * @return Query
  41. * @throws ParseException
  42. * @Author: lulei
  43. * @Description: 查询字符串匹配多个查询域
  44. */
  45. public Query getMultiFieldQuery(String key, String[] fields) throws ParseException{
  46. MultiFieldQueryParser parse = new MultiFieldQueryParser(Version.LUCENE_43, fields, analyzer);
  47. Query query = null;
  48. query = parse.parse(key);
  49. return query;
  50. }
  51. /**
  52. * @param key
  53. * @param field
  54. * @return Query
  55. * @throws ParseException
  56. * @Author: lulei
  57. * @Description: 查询字符串匹配单个查询域
  58. */
  59. public Query getOneFieldQuery(String key, String field) throws ParseException{
  60. if (key == null || key.length() < 1){
  61. return null;
  62. }
  63. QueryParser parse = new QueryParser(Version.LUCENE_43, field, analyzer);
  64. Query query = null;
  65. query = parse.parse(key);
  66. return query;
  67. }
  68. /**
  69. * @param key
  70. * @param fields
  71. * @param occur
  72. * @return Query
  73. * @throws IOException
  74. * @Author: lulei
  75. * @Description: 查询字符串、多个查询域以及查询域在查询语句中的关系
  76. */
  77. public Query getBooleanQuery(String key, String[] fields, Occur[] occur) throws IOException{
  78. if (fields.length != occur.length){
  79. System.out.println("fields.length isn't equals occur.length, please check params!");
  80. return null;
  81. }
  82. BooleanQuery query = new BooleanQuery();
  83. TokenStream tokenStream = analyzer.tokenStream("", new StringReader(key));
  84. ArrayList<String> analyzerKeys = new ArrayList<String>();
  85. while(tokenStream.incrementToken()){
  86. CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class);
  87. analyzerKeys.add(term.toString());
  88. }
  89. for(int i = 0; i < fields.length; i++){
  90. BooleanQuery queryField = new BooleanQuery();
  91. for(String analyzerKey : analyzerKeys){
  92. TermQuery termQuery = new TermQuery(new Term(fields[i], analyzerKey));
  93. queryField.add(termQuery, Occur.SHOULD);
  94. }
  95. query.add(queryField, occur[i]);
  96. }
  97. return query;
  98. }
  99. /**
  100. * @param querys
  101. * @param occur
  102. * @return Query
  103. * @Author: lulei
  104. * @Description: 组合多个查询，之间的关系由occur确定
  105. */
  106. public Query getBooleanQuery(ArrayList<Query> querys, ArrayList<Occur> occurs){
  107. if (querys.size() != occurs.size()){
  108. System.out.println("querys.size() isn't equals occurs.size(), please check params!");
  109. return null;
  110. }
  111. BooleanQuery query = new BooleanQuery();
  112. for (int i = 0; i < querys.size(); i++){
  113. query.add(querys.get(i), occurs.get(i));
  114. }
  115. return query;
  116. }
  117. /**
  118. * @param fieldName
  119. * @param value
  120. * @return
  121. * @Author: lulei
  122. * @Description: StringField属性的搜索
  123. */
  124. public Query getStringFieldQuery(String value, String fieldName){
  125. Query query = null;
  126. query = new TermQuery(new Term(fieldName, value));
  127. return query;
  128. }
  129. /**
  130. * @param fields
  131. * @param values
  132. * @return
  133. * @Author: lulei
  134. * @Description: 多个StringField属性的搜索
  135. */
  136. public Query getStringFieldQuery(String[] values, String[] fields, Occur occur){
  137. if (fields == null || values == null || fields.length != values.length){
  138. return null;
  139. }
  140. ArrayList<Query> querys = new ArrayList<Query>();
  141. ArrayList<Occur> occurs = new ArrayList<Occur>();
  142. for (int i = 0; i < fields.length; i++){
  143. querys.add(getStringFieldQuery(values[i], fields[i]));
  144. occurs.add(occur);
  145. }
  146. return getBooleanQuery(querys, occurs);
  147. }
  148. /**
  149. * @param key
  150. * @param field
  151. * @param lucene43
  152. * @return
  153. * @throws ParseException
  154. * @Author: lulei
  155. * @Description: 查询字符串和单个查询域 QueryParser是否使用4.3
  156. */
  157. public Query getOneFieldQuery(String key, String field, boolean lucene43) throws ParseException{
  158. if (key == null || key.length() < 1){
  159. return null;
  160. }
  161. if (lucene43){
  162. return getOneFieldQuery(key, field);
  163. }
  164. @SuppressWarnings("deprecation")
  165. QueryParser parse = new QueryParser(Version.LUCENE_30, field, analyzer);
  166. Query query = null;
  167. query = parse.parse(key);
  168. return query;
  169. }
  170. /**
  171. * @param key
  172. * @param field
  173. * @Author: lulei
  174. * @Description: key开头的查询字符串，和单个域匹配
  175. */
  176. public Query getStartQuery(String key, String field) {
  177. if (key == null || key.length() < 1){
  178. return null;
  179. }
  180. Query query = new PrefixQuery(new Term(field, key));
  181. return  query;
  182. }
  183. /**
  184. * @param key
  185. * @param fields
  186. * @param occur
  187. * @Author: lulei
  188. * @Description: key开头的查询字符串，和多个域匹配，每个域之间的关系由occur确定
  189. */
  190. public Query getStartQuery(String key, String []fields, Occur occur){
  191. if (key == null || key.length() < 1){
  192. return null;
  193. }
  194. ArrayList<Query> querys = new ArrayList<Query>();
  195. ArrayList<Occur> occurs = new ArrayList<Occur>();
  196. for (String field : fields) {
  197. querys.add(getStartQuery(key, field));
  198. occurs.add(occur);
  199. }
  200. return getBooleanQuery(querys, occurs);
  201. }
  202. /**
  203. * @param key
  204. * @param fields
  205. * @Author: lulei
  206. * @Description: key开头的查询字符串，和多个域匹配，每个域之间的关系Occur.SHOULD
  207. */
  208. public Query getStartQuery(String key, String []fields) {
  209. return getStartQuery(key, fields, Occur.SHOULD);
  210. }
  211. /**
  212. * @param key
  213. * @param field
  214. * @param slop
  215. * @return
  216. * @Author:lulei
  217. * @Description: 自定每个词元之间的最大距离
  218. */
  219. public Query getPhraseQuery(String key, String field, int slop) {
  220. if (key == null || key.length() < 1){
  221. return null;
  222. }
  223. StringReader reader = new StringReader(key);
  224. PhraseQuery query = new PhraseQuery();
  225. query.setSlop(slop);
  226. try {
  227. TokenStream  tokenStream  = this.analyzer.tokenStream(field, reader);
  228. tokenStream.reset();
  229. CharTermAttribute  term = tokenStream.getAttribute(CharTermAttribute.class);
  230. while(tokenStream.incrementToken()){
  231. query.add(new Term(field, term.toString()));
  232. }
  233. reader.close();
  234. } catch (IOException e) {
  235. e.printStackTrace();
  236. return null;
  237. }
  238. return query;
  239. }
  240. /**
  241. * @param key
  242. * @param fields
  243. * @param slop
  244. * @param occur
  245. * @return
  246. * @Author:lulei
  247. * @Description: 自定每个词元之间的最大距离，查询多个域，每个域之间的关系由occur确定
  248. */
  249. public Query getPhraseQuery(String key, String[] fields, int slop, Occur occur) {
  250. if (key == null || key.length() < 1){
  251. return null;
  252. }
  253. ArrayList<Query> querys = new ArrayList<Query>();
  254. ArrayList<Occur> occurs = new ArrayList<Occur>();
  255. for (String field : fields) {
  256. querys.add(getPhraseQuery(key, field, slop));
  257. occurs.add(occur);
  258. }
  259. return getBooleanQuery(querys, occurs);
  260. }
  261. /**
  262. * @param key
  263. * @param fields
  264. * @param slop
  265. * @return
  266. * @Author:lulei
  267. * @Description:  自定每个词元之间的最大距离，查询多个域，每个域之间的关系是Occur.SHOULD
  268. */
  269. public Query getPhraseQuery(String key, String[] fields, int slop) {
  270. return getPhraseQuery(key, fields, slop, Occur.SHOULD);
  271. }
  272. /**
  273. * @param key
  274. * @param field
  275. * @return
  276. * @Author:lulei
  277. * @Description: 通配符检索 eg:getWildcardQuery("a*thor", "field")
  278. */
  279. public Query getWildcardQuery(String key, String field) {
  280. if (key == null || key.length() < 1){
  281. return null;
  282. }
  283. return new WildcardQuery(new Term(field, key));
  284. }
  285. /**
  286. * @param key
  287. * @param fields
  288. * @param occur
  289. * @return
  290. * @Author:lulei
  291. * @Description: 通配符检索，域之间的关系为occur
  292. */
  293. public Query getWildcardQuery(String key, String[] fields, Occur occur) {
  294. if (key == null || key.length() < 1){
  295. return null;
  296. }
  297. ArrayList<Query> querys = new ArrayList<Query>();
  298. ArrayList<Occur> occurs = new ArrayList<Occur>();
  299. for (String field : fields) {
  300. querys.add(getWildcardQuery(key, field));
  301. occurs.add(occur);
  302. }
  303. return getBooleanQuery(querys, occurs);
  304. }
  305. /**
  306. * @param key
  307. * @param fields
  308. * @return
  309. * @Author:lulei
  310. * @Description: 通配符检索，域之间的关系为Occur.SHOULD
  311. */
  312. public Query getWildcardQuery(String key, String[] fields) {
  313. return getWildcardQuery(key, fields, Occur.SHOULD);
  314. }
  315. /**
  316. * @param keyStart
  317. * @param keyEnd
  318. * @param field
  319. * @param includeStart
  320. * @param includeEnd
  321. * @return
  322. * @Author:lulei
  323. * @Description: 范围搜索
  324. */
  325. public Query getRangeQuery (String keyStart, String keyEnd, String field, boolean includeStart, boolean includeEnd) {
  326. return TermRangeQuery.newStringRange(field, keyStart, keyEnd, includeStart, includeEnd);
  327. }
  328. /**
  329. * @param min
  330. * @param max
  331. * @param field
  332. * @param includeMin
  333. * @param includeMax
  334. * @return
  335. * @Author:lulei
  336. * @Description: 范围搜索
  337. */
  338. public Query getRangeQuery (int min, int max, String field, boolean includeMin, boolean includeMax) {
  339. return NumericRangeQuery.newIntRange(field, min, max, includeMin, includeMax);
  340. }
  341. /**
  342. * @param min
  343. * @param max
  344. * @param field
  345. * @param includeMin
  346. * @param includeMax
  347. * @return
  348. * @Author:lulei
  349. * @Description: 范围搜索
  350. */
  351. public Query getRangeQuery (float min, float max, String field, boolean includeMin, boolean includeMax) {
  352. return NumericRangeQuery.newFloatRange(field, min, max, includeMin, includeMax);
  353. }
  354. /**
  355. * @param min
  356. * @param max
  357. * @param field
  358. * @param includeMin
  359. * @param includeMax
  360. * @return
  361. * @Author:lulei
  362. * @Description: 范围搜索
  363. */
  364. public Query getRangeQuery (double min, double max, String field, boolean includeMin, boolean includeMax) {
  365. return NumericRangeQuery.newDoubleRange(field, min, max, includeMin, includeMax);
  366. }
  367. public static void main(String[] args) throws IOException {
  368. }
  369. }

PackQuery类的构造方法，可以手动指定分词器也可以使用索引的分词器。个人建议，在项目中使用索引中的分词器，这样就不会因为分词器的不同造成不知名的错误。

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

ps:最近发现其他网站可能会对博客转载，上面并没有源链接，如想查看更多关于 基于lucene的案例开发 请点击这里。或访问网址http://blog.csdn.net/xiaojimanman/article/category/2841877

上一篇：【USACO 3.2.4】饲料调配


下一篇：第二十五章 ansible基础