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

时间:2022-11-19 11:42:42

转载请注明出处: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&num;编写了一个基于Lucene&period;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. 【前端优化之渲染优化】大屏android手机动画丢帧的背后

    前言 上周我与阿里的宇果有一次技术的交流,然后对天猫H5站点做了一些浅层次的分析,后面点时间基本天天都会有联系,中途聊了一些技术细节.聊了双方团队在干什么,最后聊到了前端优化.因为我本身参与了几次携程 ...

  2. js中location&period;href的用法

    Javascript中的location.href有很多种用法,主要如下: self.location.href="/url" 当前页面打开URL页面 ocation.href=& ...

  3. PyQt:自定义QLineEdit禁止选中复制粘贴

    说明 自定义的QLineEdit,当输入文本之后,禁止选中复制粘贴等操作 实现方法 MyQLineEdit类继承了QLineEdit类,并重写QLineEdit类中的mouseMoveEvent方法和 ...

  4. 【读书笔记】iOS-使用传感器

    和其他的高端智能机一样,iPhone携带了很多传感器:照相机,加速度计,GPS模块和数字指南针. 使用Core Motion框架,你的应用可以读取来自于加速度计,磁力计以及陀螺仪的运动数据. 近距离传 ...

  5. word2013怎样批量重设图片和大小?(转)

    https://www.zhihu.com/question/52908434/answer/132934213 点击视图,宏,查看宏,任意输入一个宏名,创建,清空框内内容,复制以下代码粘贴,保存. ...

  6. &lbrack;How to&rsqb; 使用HBase协处理器---Endpoint客户端代码的实现

    1.简介 不同于Observer协处理器,EndPoint由于需要同region进行rpc服务的通信,以及客户端出数据的归并,需要自行实现客户端代码. 基于[How to] 使用HBase协处理器-- ...

  7. SQL语句之数据库操作

    SQL语句系列 1.SQL语句之行操作 2.SQL语句之表操作 3.SQL语句之数据库操作 4.SQL语句之用户管理 占坑,带写……

  8. idea 下 启动maven项目,mybatis报错 Error parsing SQL Mapper Configuration&period; Cause&colon; java&period;io&period;IOException。。。。。

    我的具体报错日志是   Error parsing SQL Mapper Configuration. Cause: java.io.IOException  Could not find resou ...

  9. Windows API编程----枚举系统进程

    1.该函数可以检索系统中的每个进程的标识符(进程ID) BOOL WINAPI EnumProcesses( _Out_ DWORD *pProcessIds, _In_  DWORD cb, _Ou ...

  10. Idea&lowbar;学习&lowbar;10&lowbar;Idea远程debug

    一.前言 二.远程debug 1.在远程机器启动java调试模式. 需要在启动时添加如下jvm参数,来以java调试模式运行项目. java -Xdebug -Xrunjdwp:server=y,tr ...