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

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