solr在使用solrj操作中的各个操作大全(在solrcores中测试)(转自:http://blog.csdn.net/a925907195/article/details/42491157)-阿里云开发者社区

开发者社区> 涂作权> 正文

solr在使用solrj操作中的各个操作大全(在solrcores中测试)(转自:http://blog.csdn.net/a925907195/article/details/42491157)

简介: package com.fjsh.SearchJobsFirst; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.HashMap; im
+关注继续查看
package com.fjsh.SearchJobsFirst;  
  
import java.text.SimpleDateFormat;  
import java.util.Calendar;  
import java.util.Date;  
import java.util.GregorianCalendar;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.LinkedHashMap;  
import java.util.List;  
import java.util.Map;  
import java.util.Map.Entry;  
  
import javax.swing.RepaintManager;  
import javax.swing.text.html.parser.Entity;  
  
import org.apache.solr.client.solrj.SolrQuery;  
import org.apache.solr.client.solrj.SolrServer;  
import org.apache.solr.client.solrj.SolrServerException;  
import org.apache.solr.client.solrj.impl.HttpSolrServer;  
import org.apache.solr.client.solrj.response.FacetField;  
import org.apache.solr.client.solrj.response.FacetField.Count;  
import org.apache.solr.client.solrj.response.Group;  
import org.apache.solr.client.solrj.response.GroupCommand;  
import org.apache.solr.client.solrj.response.GroupResponse;  
import org.apache.solr.client.solrj.response.QueryResponse;  
import org.apache.solr.common.SolrDocument;  
import org.apache.solr.common.SolrDocumentList;  
import org.apache.solr.common.params.GroupParams;  
import org.apache.solr.common.params.ModifiableSolrParams;

  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. }

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
perl学习6-return操作符
#!/usr/bin/perl -wmy @names=qw/ fred barney betty dino wilma pebbles bamm-bamm /;my $result=&which_element_is("dino",@names);sub which_element_is {  my($what,@array)=@_;  foreach (0.
469 0
Ubuntu中使用SSHSecure Shell测试Windows与Linux系统间操作及传输问题解决大全
安装SSH服务器 Linux终端下输入sudo apt-get install openssh-server 桥接模式IP设置 inux 与Windows 都是设置为自动获取 IP 地址,然后调到第一次测试一栏开始。
1102 0
SharePoint API测试系列——对Recorded Item做OM操作(委托的妙用)
转载请注明出自天外归云的博客园:http://www.cnblogs.com/LanTianYou/ 对Recorded Item动态调用OM Methods进行测试,界面如下: 输入Site的URL,File在SharePoint中的相对URL,并选择OM操作类型,点击Test进行测试。
721 0
阿里云大数据计算服务MaxCompute命令行工具——odpscmd的操作使用
在MaxCompute生态中,命令行工具究竟处于什么样的位置?它又发挥着什么样的作用?能够帮助开发者如何更好使用MaxCompute?在本文中,阿里巴巴计算平台产品专家曲宁将通过一个完整简单的小例子为大家介绍MaxCompute命令行工具odpscmd的使用以及其所具有的各种能力。
4704 0
使用mybatis对数据库执行更新操作时,parameterType为某个具体的bean,而bean中传入的参数为null时,抛出异常
使用mybatis对数据库执行更新操作时,parameterType为某个具体的bean,而bean中传入的参数为null时,抛出异常 问题描述 在使用mybatis对数据库执行更新操作时,parameterType为某个具体的bean,而bean中传入的参数为null时,抛出异常如下:org.
1662 0
+关注
涂作权
java,架构,编程语言相关专家
1234
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载