solr操作代码大全

向右看齐 2022-08-03 00:55 135阅读 0赞

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;

**\[java\]**  [view plain][] [copy][view plain]

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

[view plain]: http://blog.csdn.net/a925907195/article/details/42491157#