1 package com.fjsh.SearchJobsFirst;
2
3 import java.text.SimpleDateFormat;
4 import java.util.Calendar;
5 import java.util.Date;
6 import java.util.GregorianCalendar;
7 import java.util.HashMap;
8 import java.util.Iterator;
9 import java.util.LinkedHashMap;
10 import java.util.List;
11 import java.util.Map;
12 import java.util.Map.Entry;
13
14 import javax.swing.RepaintManager;
15 import javax.swing.text.html.parser.Entity;
16
17 import org.apache.solr.client.solrj.SolrQuery;
18 import org.apache.solr.client.solrj.SolrServer;
19 import org.apache.solr.client.solrj.SolrServerException;
20 import org.apache.solr.client.solrj.impl.HttpSolrServer;
21 import org.apache.solr.client.solrj.response.FacetField;
22 import org.apache.solr.client.solrj.response.FacetField.Count;
23 import org.apache.solr.client.solrj.response.Group;
24 import org.apache.solr.client.solrj.response.GroupCommand;
25 import org.apache.solr.client.solrj.response.GroupResponse;
26 import org.apache.solr.client.solrj.response.QueryResponse;
27 import org.apache.solr.common.SolrDocument;
28 import org.apache.solr.common.SolrDocumentList;
29 import org.apache.solr.common.params.GroupParams;
30 import org.apache.solr.common.params.ModifiableSolrParams;
31 /**
32 * @Project JobsOtherWebSearch
33 * @Package com.fjsh.SearchJobsFirst
34 * @ClassName: SearchJobs
35 * @Author fjsh
36 * @Description: 对solr中的各个功能进行测试
37 * @Date 2014-3-5 下午3:38:09
38 */
39
40 public class SearchJobs {
41 private static String url = "jdbc:sqlserver://192.168.2.106:1433;DatabaseName=JobsOtherweb51jobDB"
;
42 private static String user = "sa"
;
43 private static String password = "sa"
;
44 private String Corenum;
45 public static int JobsId = 219443;
// start jobsid
46 public SolrServer solrServer =
null;
// new
47 // HttpSolrServer("http://192.168.2.100:8080/solr/JobsOtherWeb1");
48
49 // 1、 创建solrserver对象：
50 public SolrServer createSolrServer() {
51 HttpSolrServer solr =
null;
52 try {
53 solr =
new HttpSolrServer(
54 "http://192.168.2.106:8080/solr/JobsOtherWeb0"
);
55 solr.setConnectionTimeout(100
);
56 solr.setDefaultMaxConnectionsPerHost(100
);
57 solr.setMaxTotalConnections(100
);
58 }
catch (Exception e) {
59 System.out.println("请检查tomcat服务器或端口是否开启!"
);
60 e.printStackTrace();
61 }
62 return solr;
63 }
64
65 // 简单的查询，取出二十个
66 public void querytop20() {
67 solrServer =
createSolrServer();
68 System.out.println("简单查询取出前二十个"
);
69 String dtStart =
new SimpleDateFormat("yyyyMMddHHmmssSSS"
)
70 .format(
new Date());
71 System.out.println("开始时间：" + dtStart + "\n"
);
72 try {
73 SolrQuery query =
new SolrQuery();
// 查询
74 query.setQuery("jobsName:计算机"
);
75 query.setRows(20
);
76 SolrDocumentList docs =
solrServer.query(query).getResults();
77 for (SolrDocument sd : docs) {
78 System.out.println(sd.getFieldValue("jobsName"
));
79 System.out.println(sd.getFieldValue("publishDate"
));
80 }
81 solrServer.shutdown();
82 String dtEnd =
new SimpleDateFormat("yyyyMMddHHmmssSSS"
)
83 .format(
new Date());
84 System.out.println(query);
85 }
catch (SolrServerException e) {
86 // TODO Auto-generated catch block
87 e.printStackTrace();
88 }
89 }
90
91 // 删除索引
92 // 据查询结果删除：
93 public void DeleteByQuery() {
94 solrServer =
createSolrServer();
95 try {
96 // 删除所有的索引
97 solrServer.deleteByQuery("jobsName:高级技术支持"
);
98 solrServer.commit();
99 }
catch (Exception e) {
100 e.printStackTrace();
101 }
102 }
103
104 // 根据索引号删除索引：
105 public void DeleteByQueryJobsId() {
106 solrServer =
createSolrServer();
107 try {
108 solrServer.deleteById("515792"
);
109 solrServer.commit();
110 }
catch (Exception e) {
111 e.printStackTrace();
112 }
113 }
114
115 // 查询
116 // SolrJ提供的查询功能比较强大，可以进行结果中查询、范围查询、排序等。
117 // 补充一下范围查询的格式：[star t TO end]，start与end是相应数据格式的值的字符串形式，“TO” 一定要保持大写！
118 /*
119 * field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
120 * 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序 如果为false 降序 hightlight 是否需要高亮显示
121 */
122 public QueryResponse Search(String[] field, String[] key,
int start,
123 int count, String[] sortfield, Boolean[] flag, Boolean hightlight) {
124 solrServer =
createSolrServer();
125 // 检测输入是否合法
126 if (
null == field ||
null == key || field.length !=
key.length) {
127 return null;
128 }
129 if (
null == sortfield ||
null ==
flag
130 || sortfield.length !=
flag.length) {
131 return null;
132 }
133
134 SolrQuery query =
null;
135 try {
136 // 初始化查询对象
137 query =
new SolrQuery(field[0] + ":" + key[0
]);
138 for (
int i = 0; i < field.length; i++
) {
139 query.addFilterQuery(field[i] + ":" +
key[i]);
140 }
141 // 设置起始位置与返回结果数
142 query.setStart(start);
143 query.setRows(count);
144 // 设置排序
145 for (
int i = 0; i < sortfield.length; i++
) {
146 if (flag[i]) {
147 query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
148 }
else {
149 query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
150 }
151 }
152 // 设置高亮
153 if (
null !=
hightlight) {
154 query.setHighlight(
true);
// 开启高亮组件
155 query.addHighlightField("jobsName");
// 高亮字段
156 query.setHighlightSimplePre("<font color=\"red\">");
// 标记
157 query.setHighlightSimplePost("</font>"
);
158 query.setHighlightSnippets(1);
// 结果分片数，默认为1
159 query.setHighlightFragsize(1000);
// 每个分片的最大长度，默认为100
160
161 }
162 }
catch (Exception e) {
163 e.printStackTrace();
164 }
165
166 QueryResponse rsp =
null;
167 try {
168 rsp =
solrServer.query(query);
169 }
catch (Exception e) {
170 e.printStackTrace();
171 return null;
172 }
173 // 返回查询结果
174 return rsp;
175 }
176
177 // Facet的一个应用：自动补全
178 // prefix为前缀，min为最大返回结果数
179 // field需要查询并返回不全的字段，prefix需要查询并返回的字段不全值
180
181 public String[] autoComplete(String field, String prefix,
int min) {
182 /*------------第一处标记------------------------*/
183 solrServer =
createSolrServer();
184 String words[] =
null;
185 StringBuffer sb =
new StringBuffer(""
);
186 SolrQuery query =
new SolrQuery(field + ":" +
prefix);
187 QueryResponse rsp =
new QueryResponse();
188 // Facet为solr中的层次分类查询
189 /*------------第二处标记：程序从第一处标记执行到这里需要300ms所以将上面的代码进行实例化最好------------------------*/
190 try {
191 query.setFacet(
true);
192 // query.setQuery("*:*");
193 query =
new SolrQuery(field + ":" +
prefix);
194 query.setFacetPrefix(prefix);
195 query.addFacetField(field);
196 rsp =
solrServer.query(query);
197 /*------------第三处标记：程序从第二处标记执行到这里需要200ms但此处很难再进行优化，由于查询的复杂性------------------------*/
198 }
catch (Exception e) {
199 // TODO: handle exception
200 e.printStackTrace();
201 return null;
202 }
203 if (
null !=
rsp) {
204 FacetField ff =
rsp.getFacetField(field);
205 List<Count> countList =
ff.getValues();
206 if (
null ==
countList) {
207 return null;
208 }
209 for (
int i = 0; i < countList.size(); i++
) {
210 String tmp[] = countList.get(i).toString().split(" "
);
211 // 排除单个字
212 if (tmp[0].length() < 2
) {
213 continue;
214 }
215 sb.append(tmp[0] + " "
);
216 min--
;
217 if (min == 0
) {
218 break;
219 }
220 }
221 words = sb.toString().split(" "
);
222 }
else {
223 return null;
224 }
225 return words;
226 }
227 /**
228 * @Author fjsh
229 * @Title SearchGroup
230 * @Description 按group进行查找
231 * @param QUERY_CONTENT 查询内容
232 * @param QUERY_ROWS 查找的数量,默认是10
233 * @param GROUP true or false 是否按group查询
234 * @param GROUP_FIELD 查询field
235 * @param GROUP_LIMIT The number of results (documents) to return for each group. Defaults to 1
236 * @Return void
237 * @Throws
238 * @Date 2014-5-7
239 * 输出结果的时候，由于定义的数据索引没有做很好是调整，显示的结果并不理想，不过此方法可以作为参考
240 */
241 public void SearchGroup(String QUERY_CONTENT,
int QUERY_ROWS, Boolean GROUP, String GROUP_FIELD,String GROUP_LIMIT) {
242 SolrServer server =
createSolrServer();
243 SolrQuery param =
new SolrQuery();
244 param.setQuery("jobsName:"+
QUERY_CONTENT);
245 param.setRows(QUERY_ROWS);
246 param.setParam(GroupParams.GROUP, GROUP);
247 param.setParam(GroupParams.GROUP_FIELD, GROUP_FIELD);
248 param.setParam(GroupParams.GROUP_LIMIT, GROUP_LIMIT);
249 QueryResponse response =
null;
250 try {
251 response =
server.query(param);
252 }
catch (SolrServerException e) {
253 // logger.error(e.getMessage(), e);
254 }
255 Map<String, Integer> info =
new HashMap<String, Integer>
();
256 GroupResponse groupResponse =
response.getGroupResponse();
257 if(groupResponse !=
null) {
258 List<GroupCommand> groupList =
groupResponse.getValues();
259 for(GroupCommand groupCommand : groupList) {
260 List<Group> groups =
groupCommand.getValues();
261 for(Group group : groups) {
262 info.put(group.getGroupValue(), (
int)group.getResult().getNumFound());
263 System.out.println(group.getGroupValue()+"---"+
group.getResult().getNumFound());
264 }
265 }
266 }
267 }
268
269 /*
270 * 介绍了一下facet之后，来说说怎么实现facet。facet的实现其实很简单，主要在搜索参数上带上就OK。
271 *
272 * facet=on/true #代表开启facet facet.field=cate #代表要统计的面（分组），比如上面的分类，品牌，可以多次出现
273 * facet.limit =20 #每个分组最多返回条数 facet.mincount = 1 #这个表示分组下某一条目的最小数据量
274 * facet.missing = on/true #统计null的值 facet.method = #默认为fc, fc表示Field Cache
275 * 比如
276 * ：http://localhost/product/select/?q=铁观音&facet=on&facet.field=category&facet
277 * .field=brand&facet.mincount=1在搜索结果中返回xml的facet结果
278 *
279 *
280 * view sourceprint? 01 <lst name="facet_counts"> 02 <lst
281 * name="facet_queries"/> 03 <lst name="facet_fields"> 04 <lst
282 * name="category"> 05 <int name="2742">64</int> 06 <int name="793">48</int>
283 * 07 <int name="2741">12</int> 08 <int name="801">6</int> 09 <int
284 * name="1087">1</int> 10 </lst> 11 <lst name="brand"> 12 <int
285 * name="229">74</int> 13 <int name="227">16</int> 14 <int
286 * name="270">13</int> 15 <int name="317">10</int> 16 <int name="0">4</int>
287 * 17 <int name="165">4</int> 18 <int name="203">3</int> 19 <int
288 * name="147">2</int> 20 <int name="166">2</int> 21 <int name="217">1</int>
289 * 22 <int name="342">1</int> 23 <int name="343">1</int> 24 </lst> 25 </lst>
290 * <lst name="category"> 分组名 <int name="2742">64</int>
291 * 分组内条目，name表示条目，64是统计结果数。
292 *
293 *
294 *
295 *
296 * Date Facet 日期类型的字段在文档中很常见 , 如商品上市时间 , 货物出仓时间 , 书籍上架时间等等 . 某些情况下需要针对这些字段进行
297 * Facet. 不过时间字段的取值有无限性 , 用户往往关心的不是某个时间点而是某个时间段内的查询统计结果 . Solr
298 * 为日期字段提供了更为方便的查询统计方式 . 当然 , 字段的类型必须是 DateField( 或其子类型 ). 需要注意的是 , 使用 Date
299 * Facet 时 , 字段名 , 起始时间 , 结束时间 , 时间间隔这 4 个参数都必须提供 . 与 Field Facet 类似 ,Date
300 * Facet 也可以对多个字段进行 Facet. 并且针对每个字段都可以单独设置参数 . 2.1 facet.date 该参数表示需要进行 Date
301 * Facet 的字段名 , 与 facet.field 一样 , 该参数可以被设置多次 , 表示对多个字段进行 Date Facet. 2.2
302 * facet.date.start 起始时间 , 时间的一般格式为 ” 1995-12-31T23:59:59Z”, 另外可以使用
303 * ”NOW”,”YEAR”,”MONTH” 等等 , 具体格式可以参考 org.apache.solr.schema. DateField 的
304 * java doc. 2.3 facet.date.end 结束时间 . 2.4 facet.date.gap 时间间隔 . 如果 start 为
305 * 2009-1-1,end 为 2010-1-1.gap 设置为 ”+1MONTH” 表示间隔 1 个月 , 那么将会把这段时间划分为 12
306 * 个间隔段 . 注意 ”+” 因为是特殊字符所以应该用 ”+” 代替 . 2.5 facet.date.hardend 取值可以为
307 * true|false, 默认为 false. 它表示 gap 迭代到 end 处采用何种处理 . 举例说明 start 为
308 * 2009-1-1,end 为 2009-12-25,gap 为 ”+1MONTH”,hardend 为 false 的话最后一个时间段为
309 * 2009-12-1 至 2010-1-1;hardend 为 true 的话最后一个时间段为 2009-12-1 至 2009-12-25.
310 * 2.6 facet.date.other 取值范围为 before|after|between|none|all, 默认为 none.
311 * before 会对 start 之前的值做统计 . after 会对 end 之后的值做统计 . between 会对 start 至 end
312 * 之间所有值做统计 . 如果 hardend 为 true 的话 , 那么该值就是各个时间段统计值的和 . none 表示该项禁用 . all 表示
313 * before,after,all 都会统计 . 举例 : &facet=on &facet.date=date
314 * &facet.date.start=2009-1-1T0:0:0Z &facet.date.end=2010-1-1T0:0:0Z
315 * &facet.date.gap=+1MONTH &facet.date.other=all
316 */
317 public void FacetFieldQuery()
throws Exception {
318 solrServer =
createSolrServer();
319 SolrQuery query =
new SolrQuery();
// 建立一个新的查询
320 query.setQuery("jobsName:计算机维护"
);
321 query.setFacet(
true);
// 设置facet=on
322 // 分类信息分为：薪水，发布时间，教育背景，工作经验，公司类型，工作类型
323 query.addFacetField(
new String[] { "salary", "publishDate"
,
324 "educateBackground", "jobExperience", "companytype", "jobsType" });
// 设置需要facet的字段
325 query.setFacetLimit(10);
// 限制facet返回的数量
326 query.setFacetMissing(
false);
// 不统计null的值
327 query.setFacetMinCount(1);
// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
328
329 // query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
330 QueryResponse response =
solrServer.query(query);
331 System.out.println("查询时间：" +
response.getQTime());
332 List<FacetField> facets = response.getFacetFields();
// 返回的facet列表
333 for (FacetField facet : facets) {
334 System.out.println(facet.getName());
335 System.out.println("----------------"
);
336 List<Count> counts =
facet.getValues();
337 for (Count count : counts) {
338 System.out.println(count.getName() + ":" +
count.getCount());
339 }
340 System.out.println();
341 }
342
343 }
344
345 // 时间片使用方法
346 public void FacetFieldQueryDate()
throws Exception {
347 solrServer =
createSolrServer();
348 SolrQuery query =
new SolrQuery();
// 建立一个新的查询
349 query.setQuery("jobsName:计算"
);
350 query.setFacet(
true);
// 设置facet=on
351 query.setFacetLimit(10);
// 限制facet返回的数量
352 query.setFacetMissing(
false);
// 不统计null的值
353 query.setFacetMinCount(1);
// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
354 query.addFacetField(
new String[] { "salary", "educateBackground"
,
355 "jobExperience", "companytype", "jobsType" });
// 设置需要facet的字段
356 // query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
357 // query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
358 SimpleDateFormat time0 =
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"
);
359 SimpleDateFormat time1 =
new SimpleDateFormat("yyyy-MM-dd"
);
360 SimpleDateFormat time2 =
new SimpleDateFormat("HH:mm:ss"
);
361 // return
362 // date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();
363
364 Calendar c =
Calendar.getInstance();
365 c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"
));
366 Date date =
c.getTime();
367 String dateNow = time1.format(date) + "T" + time2.format(date) + "Z"
;
368 c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"
));
369 c.add(Calendar.DATE, -1
);
370 date =
c.getTime();
371 // 当天
372 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
373 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
374 c.add(Calendar.DATE, -2
);
375 date =
c.getTime();
376 // 前三天
377 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
378 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
379 c.add(Calendar.DATE, -4
);
380 date =
c.getTime();
381 // 前一周
382 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
383 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
384 c.add(Calendar.DATE, -7
);
385 date =
c.getTime();
386 // 前两周
387 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
388 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
389 c.add(Calendar.DATE, -16
);
390 date =
c.getTime();
391 // 前一个月
392 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
393 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
394 c.add(Calendar.DATE, -30
);
395 date =
c.getTime();
396 // 前两个月
397 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
398 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
399
400 QueryResponse response =
solrServer.query(query);
401 System.out.println("查询时间：" +
response.getQTime());
402 List<FacetField> facets = response.getFacetFields();
// 返回的facet列表
403 for (FacetField facet : facets) {
404 System.out.println(facet.getName());
405 System.out.println("----------------"
);
406 List<Count> counts =
facet.getValues();
407 for (Count count : counts) {
408 System.out.println(count.getName() + ":" +
count.getCount());
409 }
410 System.out.println();
411 }
412 // 根据时间段来获取数据
413 Map<String, Integer> maps =
response.getFacetQuery();
414 for (Entry<String, Integer>
entry : maps.entrySet()) {
415 System.out.println(entry.getKey() + ":" +
entry.getValue());
416 }
417
418 }
419
420 // 最终使用的查询方式
421 // SolrJ提供的查询功能比较强大，可以进行结果中查询、范围查询、排序等。
422 // 补充一下范围查询的格式：[star t TO end]，start与end是相应数据格式的值的字符串形式，“TO” 一定要保持大写！
423 /*
424 * field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
425 * 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序 如果为false 降序 hightlight 是否需要高亮显示
426 */
427 public QueryResponse searchResult(String[] field, String[] key,
int start,
428 int count, String[] sortfield, Boolean[] flag, Boolean hightlight)
429 throws Exception {
430 solrServer =
createSolrServer();
431 // 检测输入是否合法
432 if (
null == field ||
null == key || field.length !=
key.length) {
433 return null;
434 }
435
436
437 SolrQuery query =
null;
438 try {
439 // 初始化查询对象
440 query =
new SolrQuery(field[0] + ":" + key[0
]);
441 for (
int i = 0; i < field.length; i++
) {
442 query.addFilterQuery(field[i] + ":" +
key[i]);
443 }
444 // 设置起始位置与返回结果数
445 query.setStart(start);
446 query.setRows(count);
447 // 设置排序
448 if (!(
null == sortfield ||
null ==
flag
449 || sortfield.length !=
flag.length)) {
450 for (
int i = 0; i < sortfield.length; i++
) {
451 if (flag[i]) {
452 query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
453 }
else {
454 query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
455 }
456 }
457 }
458
459 // 设置高亮
460 if (
null !=
hightlight) {
461 query.setHighlight(
true);
// 开启高亮组件
462 query.addHighlightField("jobsName");
// 高亮字段
463 query.setHighlightSimplePre("<font color=\"red\">");
// 标记
464 query.setHighlightSimplePost("</font>"
);
465 query.setHighlightSnippets(1);
// 结果分片数，默认为1
466 query.setHighlightFragsize(1000);
// 每个分片的最大长度，默认为100
467
468 }
469 }
catch (Exception e) {
470 e.printStackTrace();
471 }
472 query.setFacet(
true);
// 设置facet=on
473 query.setFacetLimit(10);
// 限制facet返回的数量
474 query.setFacetMissing(
false);
// 不统计null的值
475 query.setFacetMinCount(1);
// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
476 query.addFacetField(
new String[] { "salary", "educateBackground"
,
477 "jobExperience", "companytype", "jobsType" });
// 设置需要facet的字段
478 // query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
479 // query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
480 SimpleDateFormat time0 =
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"
);
481 SimpleDateFormat time1 =
new SimpleDateFormat("yyyy-MM-dd"
);
482 SimpleDateFormat time2 =
new SimpleDateFormat("HH:mm:ss"
);
483 // return
484 // date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();
485
486 Calendar c =
Calendar.getInstance();
487 c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"
));
488 Date date =
c.getTime();
489 String dateNow = time1.format(date) + "T" + time2.format(date) + "Z"
;
490 c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"
));
491 c.add(Calendar.DATE, -1
);
492 date =
c.getTime();
493 // 当天
494 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
495 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
496 c.add(Calendar.DATE, -2
);
497 date =
c.getTime();
498 // 前三天
499 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
500 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
501 c.add(Calendar.DATE, -4
);
502 date =
c.getTime();
503 // 前一周
504 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
505 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
506 c.add(Calendar.DATE, -7
);
507 date =
c.getTime();
508 // 前两周
509 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
510 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
511 c.add(Calendar.DATE, -16
);
512 date =
c.getTime();
513 // 前一个月
514 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
515 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
516 c.add(Calendar.DATE, -30
);
517 date =
c.getTime();
518 // 前两个月
519 query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
520 + time2.format(date) + "Z" + " TO " + dateNow + "]"
);
521
522 QueryResponse rsp =
null;
523 try {
524 rsp =
solrServer.query(query);
525 System.out.println("此次查询时间qtime :" +
rsp.getQTime());
526 List<FacetField> facets = rsp.getFacetFields();
// 返回的facet列表
527 for (FacetField facet : facets) {
528 System.out.println(facet.getName());
529 System.out.println("----------------"
);
530 List<Count> counts =
facet.getValues();
531 for (Count countitem : counts) {
532 System.out.println(countitem.getName() + ":"
533 +
countitem.getCount());
534 }
535 System.out.println();
536 }
537 // 根据时间段来获取数据
538 Map<String, Integer> maps =
rsp.getFacetQuery();
539 for (Entry<String, Integer>
entry : maps.entrySet()) {
540 System.out.println(entry.getKey() + ":" +
entry.getValue());
541 }
542 // 获取返回的结果
543 SolrDocumentList docs =
rsp.getResults();
544 for (SolrDocument doc : docs) {
545 System.out.println("-----"
);
546 System.out.println(doc.getFieldValue("jobsName"
));
547 System.out.println(doc.getFieldValue("publishDate"
));
548
549 }
550 }
catch (Exception e) {
551 e.printStackTrace();
552 return null;
553 }
554 // 返回查询结果
555 return rsp;
556 }
557 }
转载于:https://www.cnblogs.com/Lxiaojiang/p/6513047.html
