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

基于lucene的案例开发:查询语句创建PackQuery的更多相关文章

  1. 基于lucene的案例开发:纵横小说分布式採集

    转载请注明出处:http://blog.csdn.net/xiaojimanman/article/details/46812645 http://www.llwjy.com/blogdetail/9 ...

  2. C#编写了一个基于Lucene.Net的搜索引擎查询通用工具类:SearchEngineUtil

    最近由于工作原因,一直忙于公司的各种项目(大部份都是基于spring cloud的微服务项目),故有一段时间没有与大家分享总结最近的技术研究成果的,其实最近我一直在不断的深入研究学习Spring.Sp ...

  3. SqlServer ----- 根据查询语句创建视图

    我们都知道视图的本质就是查询语句,那么就可以根据查询语句创建视图, 前提 知道视图的组成,已经写好的sql 语句,多表或单表的查询语句,将查询语句变成视图. 所以视图可以由单表,多表或视图加表构成. ...

  4. create table 使用select查询语句创建表的方法分享

    转自:http://www.maomao365.com/?p=6642 摘要:下文讲述使用select查询语句建立新的数据表的方法分享 ---1 mysql create table `新数据表名` ...

  5. WebGIS中兴趣点简单查询、基于Lucene分词查询的设计和实现

    文章版权由作者李晓晖和博客园共有,若转载请于明显处标明出处:http://www.cnblogs.com/naaoveGIS/. 1.前言 兴趣点查询是指:输入框中输入地名.人名等查询信息后,地图上可 ...

  6. Orcle 查询语句

    首先,以超级管理员的身份登录oracle       sqlplus sys/bjsxt as sysdba   --然后,解除对scott用户的锁       alter user scott ac ...

  7. mysql-数据库查询语句汇总

    目录 数据库查询语句 ***** 添加数据补充: 所有的select 关键字 where 条件 distinct 去除重复记录 指定字段 取别名 group by having order limit ...

  8. Apache Solr采用Java开发、基于Lucene的全文搜索服务器

    http://docs.spring.io/spring-data/solr/ 首先介绍一下solr: Apache Solr (读音: SOLer) 是一个开源.高性能.采用Java开发.基于Luc ...

  9. 一种安全云存储方案设计(下)——基于Lucene的云端搜索与密文基础上的模糊查询

    一种安全的云存储方案设计(未完整理中) 一篇老文了,现在看看错漏颇多,提到的一些技术已经跟不上了.仅对部分内容重新做了一些修正,增加了一些机器学习的内容,然并卵. 这几年来,云产品层出不穷,但其安全性 ...

随机推荐

  1. destoon系统商城加淘宝客按钮方法

    destoon系统很多喜欢运营B2B的站长都在用,其中的商城模块常常被用来做淘宝客,其中的难点是如何把购买按钮做成淘宝客地址,这个问题的修改在论坛上被叫价50元,下面小编把这个实用的方法分享下,希望对 ...

  2. [转载]css3属性box-sizing:border-box的作用

    http://jastate.com/css3-properties-box-sizingborder-box.html 定义和用法 按照w3c school的说法,box-sizing:border ...

  3. Spring MVC使用@ResponseBody返回JSON数据406以及乱码问题解决方案

    刚到一家公司,做原始的工作---接口,程序就我一人,没环境,没架构,更没旧项目可以利用,一切从0开始,经理以为我是老鸟,来就布置任务,要一周拿出结果.其实有现成架构的话写个接口还不是分分钟钟的事,关键 ...

  4. Powershell创建数组

    在Powershell中创建数组可以使用逗号. PS C:Powershell> $nums=2,0,1,2 PS C:Powershell> $nums 2 0 1 2 对于连续的数字数 ...

  5. 11G在线重建索引

    SQL> select count(*) from test_idx; COUNT(*) ---------- 19087751 SQL> select segment_name,segm ...

  6. 【转】Android 定时器实现的几种方式和removeCallbacks失效问题详解--不错

    原文网址:http://blog.csdn.net/xiaanming/article/details/9011193 实现定时器有很多种方式,在这里我简单的介绍几种方式 (1)使用Handler + ...

  7. wikioi3052 多米诺

    题目描述 Description 一个矩形可以划分成M*N个小正方形,其中有一些小正方形不能使用.一个多米诺骨牌占用两个相邻的小正方形.试问整个区域内最多可以不重叠地放多少个多米诺骨牌且不占用任何一个 ...

  8. Linux CentOS 7 YouCompleteMe相关配置。

    CentOS 6.5上面弄了2天,以失败告终!!!当作练手了.在网上看到一篇CentOS7.0上安装YouCompleteMe插件的文章,就重新在虚拟机上安装了一个CentOS7,按那个文章执行了一下 ...

  9. hdu2082:简单母函数

    题目大意: a,b,c,d...z这些字母的价值是1,2,3......26 给定 这26个字母分别的数量,求总价值不超过50的单词的数量 分析: 标准做法是构造母函数 把某个单词看作是,关于x的多项 ...

  10. FileUtil.java

    package com.founder.util.file; import java.io.BufferedReader; import java.io.File; import java.io.Fi ...