solr在使用solrj操作中的各个操作大全

转自: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;
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;

/**
 * @Project JobsOtherWebSearch
 * @Package com.fjsh.SearchJobsFirst
 * @ClassName: SearchJobs 
 * @Author fjsh
 * @Description: 对solr中的各个功能进行测试
 * @Date 2014-3-5 下午3:38:09 
 */

public class SearchJobs {
	private static String url = "jdbc:sqlserver://192.168.2.106:1433;DatabaseName=JobsOtherweb51jobDB";
	private static String user = "sa";
	private static String password = "sa";
	private String Corenum;
	public static int JobsId = 219443;// start jobsid
	public SolrServer solrServer = null;// new
										// HttpSolrServer("http://192.168.2.100:8080/solr/JobsOtherWeb1");

	// 1、 创建solrserver对象:
	public SolrServer createSolrServer() {
		HttpSolrServer solr = null;
		try {
			solr = new HttpSolrServer(
					"http://192.168.2.106:8080/solr/JobsOtherWeb0");
			solr.setConnectionTimeout(100);
			solr.setDefaultMaxConnectionsPerHost(100);
			solr.setMaxTotalConnections(100);
		} catch (Exception e) {
			System.out.println("请检查tomcat服务器或端口是否开启!");
			e.printStackTrace();
		}
		return solr;
	}

	// 简单的查询,取出二十个
	public void querytop20() {
		solrServer = createSolrServer();
		System.out.println("简单查询取出前二十个");
		String dtStart = new SimpleDateFormat("yyyyMMddHHmmssSSS")
				.format(new Date());
		System.out.println("开始时间:" + dtStart + "\n");
		try {
			SolrQuery query = new SolrQuery();// 查询
			query.setQuery("jobsName:计算机");
			query.setRows(20);
			SolrDocumentList docs = solrServer.query(query).getResults();
			for (SolrDocument sd : docs) {
				System.out.println(sd.getFieldValue("jobsName"));
				System.out.println(sd.getFieldValue("publishDate"));
			}
			solrServer.shutdown();
			String dtEnd = new SimpleDateFormat("yyyyMMddHHmmssSSS")
					.format(new Date());
			System.out.println(query);
		} catch (SolrServerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// 删除索引
	// 据查询结果删除:
	public void DeleteByQuery() {
		solrServer = createSolrServer();
		try {
			// 删除所有的索引
			solrServer.deleteByQuery("jobsName:高级技术支持");
			solrServer.commit();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 根据索引号删除索引:
	public void DeleteByQueryJobsId() {
		solrServer = createSolrServer();
		try {
			solrServer.deleteById("515792");
			solrServer.commit();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 查询
	// SolrJ提供的查询功能比较强大,可以进行结果中查询、范围查询、排序等。
	// 补充一下范围查询的格式:[star t TO end],start与end是相应数据格式的值的字符串形式,“TO” 一定要保持大写!
	/*
	 * field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
	 * 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序 如果为false 降序 hightlight 是否需要高亮显示
	 */
	public QueryResponse Search(String[] field, String[] key, int start,
			int count, String[] sortfield, Boolean[] flag, Boolean hightlight) {
		solrServer = createSolrServer();
		// 检测输入是否合法
		if (null == field || null == key || field.length != key.length) {
			return null;
		}
		if (null == sortfield || null == flag
				|| sortfield.length != flag.length) {
			return null;
		}

		SolrQuery query = null;
		try {
			// 初始化查询对象
			query = new SolrQuery(field[0] + ":" + key[0]);
			for (int i = 0; i < field.length; i++) {
				query.addFilterQuery(field[i] + ":" + key[i]);
			}
			// 设置起始位置与返回结果数
			query.setStart(start);
			query.setRows(count);
			// 设置排序
			for (int i = 0; i < sortfield.length; i++) {
				if (flag[i]) {
					query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
				} else {
					query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
				}
			}
			// 设置高亮
			if (null != hightlight) {
				query.setHighlight(true); // 开启高亮组件
				query.addHighlightField("jobsName");// 高亮字段
				query.setHighlightSimplePre("<font color=\"red\">");// 标记
				query.setHighlightSimplePost("</font>");
				query.setHighlightSnippets(1);// 结果分片数,默认为1
				query.setHighlightFragsize(1000);// 每个分片的最大长度,默认为100

			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		QueryResponse rsp = null;
		try {
			rsp = solrServer.query(query);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		// 返回查询结果
		return rsp;
	}

	// Facet的一个应用:自动补全
	// prefix为前缀,min为最大返回结果数
	// field需要查询并返回不全的字段,prefix需要查询并返回的字段不全值

	public String[] autoComplete(String field, String prefix, int min) {
		/*------------第一处标记------------------------*/
		solrServer = createSolrServer();
		String words[] = null;
		StringBuffer sb = new StringBuffer("");
		SolrQuery query = new SolrQuery(field + ":" + prefix);
		QueryResponse rsp = new QueryResponse();
		// Facet为solr中的层次分类查询
		/*------------第二处标记:程序从第一处标记执行到这里需要300ms所以将上面的代码进行实例化最好------------------------*/
		try {
			query.setFacet(true);
			// query.setQuery("*:*");
			query = new SolrQuery(field + ":" + prefix);
			query.setFacetPrefix(prefix);
			query.addFacetField(field);
			rsp = solrServer.query(query);
			/*------------第三处标记:程序从第二处标记执行到这里需要200ms但此处很难再进行优化,由于查询的复杂性------------------------*/
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return null;
		}
		if (null != rsp) {
			FacetField ff = rsp.getFacetField(field);
			List<Count> countList = ff.getValues();
			if (null == countList) {
				return null;
			}
			for (int i = 0; i < countList.size(); i++) {
				String tmp[] = countList.get(i).toString().split(" ");
				// 排除单个字
				if (tmp[0].length() < 2) {
					continue;
				}
				sb.append(tmp[0] + " ");
				min--;
				if (min == 0) {
					break;
				}
			}
			words = sb.toString().split(" ");
		} else {
			return null;
		}
		return words;
	}
	/**
	 * @Author fjsh
	 * @Title SearchGroup
	 * @Description 按group进行查找
	 * @param QUERY_CONTENT 查询内容
	 * @param QUERY_ROWS 查找的数量,默认是10
	 * @param GROUP true or false 是否按group查询
	 * @param GROUP_FIELD 查询field
	 * @param GROUP_LIMIT The number of results (documents) to return for each group. Defaults to 1
	 * @Return void
	 * @Throws 
	 * @Date 2014-5-7
	 * 输出结果的时候,由于定义的数据索引没有做很好是调整,显示的结果并不理想,不过此方法可以作为参考
	 */
	public void SearchGroup(String QUERY_CONTENT,int QUERY_ROWS, Boolean GROUP, String GROUP_FIELD,String GROUP_LIMIT) {
		 SolrServer server = createSolrServer();  
		 SolrQuery param = new SolrQuery();  
		 param.setQuery("jobsName:"+QUERY_CONTENT);  
		 param.setRows(QUERY_ROWS);  
		 param.setParam(GroupParams.GROUP, GROUP);  
		 param.setParam(GroupParams.GROUP_FIELD, GROUP_FIELD);  		
		 param.setParam(GroupParams.GROUP_LIMIT, GROUP_LIMIT);  
		 QueryResponse response = null;  
		 try {  
		     response = server.query(param);  
		 } catch (SolrServerException e) {  
		    // logger.error(e.getMessage(), e);  
		 }  
		 Map<String, Integer> info = new HashMap<String, Integer>();  
		 GroupResponse groupResponse = response.getGroupResponse();  
		 if(groupResponse != null) {  
		     List<GroupCommand> groupList = groupResponse.getValues();  
		     for(GroupCommand groupCommand : groupList) {  
		         List<Group> groups = groupCommand.getValues();  
		         for(Group group : groups) {  
		             info.put(group.getGroupValue(), (int)group.getResult().getNumFound()); 
		             System.out.println(group.getGroupValue()+"---"+group.getResult().getNumFound());
		         }  
		     }  
		 }  
	}

	/*
	 * 介绍了一下facet之后,来说说怎么实现facet。facet的实现其实很简单,主要在搜索参数上带上就OK。
	 * 
	 * facet=on/true #代表开启facet facet.field=cate #代表要统计的面(分组),比如上面的分类,品牌,可以多次出现
	 * facet.limit =20 #每个分组最多返回条数 facet.mincount = 1 #这个表示分组下某一条目的最小数据量
	 * facet.missing = on/true #统计null的值 facet.method = #默认为fc, fc表示Field Cache
	 * 比如
	 * :http://localhost/product/select/?q=铁观音&facet=on&facet.field=category&facet
	 * .field=brand&facet.mincount=1在搜索结果中返回xml的facet结果
	 * 
	 * 
	 * view sourceprint? 01 <lst name="facet_counts"> 02 <lst
	 * name="facet_queries"/> 03 <lst name="facet_fields"> 04 <lst
	 * name="category"> 05 <int name="2742">64</int> 06 <int name="793">48</int>
	 * 07 <int name="2741">12</int> 08 <int name="801">6</int> 09 <int
	 * name="1087">1</int> 10 </lst> 11 <lst name="brand"> 12 <int
	 * name="229">74</int> 13 <int name="227">16</int> 14 <int
	 * name="270">13</int> 15 <int name="317">10</int> 16 <int name="0">4</int>
	 * 17 <int name="165">4</int> 18 <int name="203">3</int> 19 <int
	 * name="147">2</int> 20 <int name="166">2</int> 21 <int name="217">1</int>
	 * 22 <int name="342">1</int> 23 <int name="343">1</int> 24 </lst> 25 </lst>
	 * <lst name="category"> 分组名 <int name="2742">64</int>
	 * 分组内条目,name表示条目,64是统计结果数。
	 * 
	 * 
	 * 
	 * 
	 * Date Facet 日期类型的字段在文档中很常见 , 如商品上市时间 , 货物出仓时间 , 书籍上架时间等等 . 某些情况下需要针对这些字段进行
	 * Facet. 不过时间字段的取值有无限性 , 用户往往关心的不是某个时间点而是某个时间段内的查询统计结果 . Solr
	 * 为日期字段提供了更为方便的查询统计方式 . 当然 , 字段的类型必须是 DateField( 或其子类型 ). 需要注意的是 , 使用 Date
	 * Facet 时 , 字段名 , 起始时间 , 结束时间 , 时间间隔这 4 个参数都必须提供 . 与 Field Facet 类似 ,Date
	 * Facet 也可以对多个字段进行 Facet. 并且针对每个字段都可以单独设置参数 . 2.1 facet.date 该参数表示需要进行 Date
	 * Facet 的字段名 , 与 facet.field 一样 , 该参数可以被设置多次 , 表示对多个字段进行 Date Facet. 2.2
	 * facet.date.start 起始时间 , 时间的一般格式为 ” 1995-12-31T23:59:59Z”, 另外可以使用
	 * ”NOW”,”YEAR”,”MONTH” 等等 , 具体格式可以参考 org.apache.solr.schema. DateField 的
	 * java doc. 2.3 facet.date.end 结束时间 . 2.4 facet.date.gap 时间间隔 . 如果 start 为
	 * 2009-1-1,end 为 2010-1-1.gap 设置为 ”+1MONTH” 表示间隔 1 个月 , 那么将会把这段时间划分为 12
	 * 个间隔段 . 注意 ”+” 因为是特殊字符所以应该用 ”%2B” 代替 . 2.5 facet.date.hardend 取值可以为
	 * true|false, 默认为 false. 它表示 gap 迭代到 end 处采用何种处理 . 举例说明 start 为
	 * 2009-1-1,end 为 2009-12-25,gap 为 ”+1MONTH”,hardend 为 false 的话最后一个时间段为
	 * 2009-12-1 至 2010-1-1;hardend 为 true 的话最后一个时间段为 2009-12-1 至 2009-12-25.
	 * 2.6 facet.date.other 取值范围为 before|after|between|none|all, 默认为 none.
	 * before 会对 start 之前的值做统计 . after 会对 end 之后的值做统计 . between 会对 start 至 end
	 * 之间所有值做统计 . 如果 hardend 为 true 的话 , 那么该值就是各个时间段统计值的和 . none 表示该项禁用 . all 表示
	 * before,after,all 都会统计 . 举例 : &facet=on &facet.date=date
	 * &facet.date.start=2009-1-1T0:0:0Z &facet.date.end=2010-1-1T0:0:0Z
	 * &facet.date.gap=%2B1MONTH &facet.date.other=all
	 */
	public void FacetFieldQuery() throws Exception {
		solrServer = createSolrServer();
		SolrQuery query = new SolrQuery();// 建立一个新的查询
		query.setQuery("jobsName:计算机维护");
		query.setFacet(true);// 设置facet=on
		// 分类信息分为:薪水,发布时间,教育背景,工作经验,公司类型,工作类型
		query.addFacetField(new String[] { "salary", "publishDate",
				"educateBackground", "jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
		query.setFacetLimit(10);// 限制facet返回的数量
		query.setFacetMissing(false);// 不统计null的值
		query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值,比如设置为1,则统计数量最小为1,不然不显示

		// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
		QueryResponse response = solrServer.query(query);
		System.out.println("查询时间:" + response.getQTime());
		List<FacetField> facets = response.getFacetFields();// 返回的facet列表
		for (FacetField facet : facets) {
			System.out.println(facet.getName());
			System.out.println("----------------");
			List<Count> counts = facet.getValues();
			for (Count count : counts) {
				System.out.println(count.getName() + ":" + count.getCount());
			}
			System.out.println();
		}

	}

	// 时间片使用方法
	public void FacetFieldQueryDate() throws Exception {
		solrServer = createSolrServer();
		SolrQuery query = new SolrQuery();// 建立一个新的查询
		query.setQuery("jobsName:计算");
		query.setFacet(true);// 设置facet=on
		query.setFacetLimit(10);// 限制facet返回的数量
		query.setFacetMissing(false);// 不统计null的值
		query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值,比如设置为1,则统计数量最小为1,不然不显示
		query.addFacetField(new String[] { "salary", "educateBackground",
				"jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
		// query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
		// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
		SimpleDateFormat time0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		SimpleDateFormat time1 = new SimpleDateFormat("yyyy-MM-dd");
		SimpleDateFormat time2 = new SimpleDateFormat("HH:mm:ss");
		// return
		// date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();

		Calendar c = Calendar.getInstance();
		c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
		Date date = c.getTime();
		String dateNow = time1.format(date) + "T" + time2.format(date) + "Z";
		c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
		c.add(Calendar.DATE, -1);
		date = c.getTime();
		// 当天
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -2);
		date = c.getTime();
		// 前三天
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -4);
		date = c.getTime();
		// 前一周
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -7);
		date = c.getTime();
		// 前两周
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -16);
		date = c.getTime();
		// 前一个月
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -30);
		date = c.getTime();
		// 前两个月
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");

		QueryResponse response = solrServer.query(query);
		System.out.println("查询时间:" + response.getQTime());
		List<FacetField> facets = response.getFacetFields();// 返回的facet列表
		for (FacetField facet : facets) {
			System.out.println(facet.getName());
			System.out.println("----------------");
			List<Count> counts = facet.getValues();
			for (Count count : counts) {
				System.out.println(count.getName() + ":" + count.getCount());
			}
			System.out.println();
		}
		// 根据时间段来获取数据
		Map<String, Integer> maps = response.getFacetQuery();
		for (Entry<String, Integer> entry : maps.entrySet()) {
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}

	}

	// 最终使用的查询方式
	// SolrJ提供的查询功能比较强大,可以进行结果中查询、范围查询、排序等。
	// 补充一下范围查询的格式:[star t TO end],start与end是相应数据格式的值的字符串形式,“TO” 一定要保持大写!
	/*
	 * field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
	 * 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序 如果为false 降序 hightlight 是否需要高亮显示
	 */
	public QueryResponse searchResult(String[] field, String[] key, int start,
			int count, String[] sortfield, Boolean[] flag, Boolean hightlight)
			throws Exception {
		solrServer = createSolrServer();
		// 检测输入是否合法
		if (null == field || null == key || field.length != key.length) {
			return null;
		}
		

		SolrQuery query = null;
		try {
			// 初始化查询对象
			query = new SolrQuery(field[0] + ":" + key[0]);
			for (int i = 0; i < field.length; i++) {
				query.addFilterQuery(field[i] + ":" + key[i]);
			}
			// 设置起始位置与返回结果数
			query.setStart(start);
			query.setRows(count);
			// 设置排序
			if (!(null == sortfield || null == flag
					|| sortfield.length != flag.length)) {
				for (int i = 0; i < sortfield.length; i++) {
					if (flag[i]) {
						query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
					} else {
						query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
					}
				}
			}
			
			// 设置高亮
			if (null != hightlight) {
				query.setHighlight(true); // 开启高亮组件
				query.addHighlightField("jobsName");// 高亮字段
				query.setHighlightSimplePre("<font color=\"red\">");// 标记
				query.setHighlightSimplePost("</font>");
				query.setHighlightSnippets(1);// 结果分片数,默认为1
				query.setHighlightFragsize(1000);// 每个分片的最大长度,默认为100

			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		query.setFacet(true);// 设置facet=on
		query.setFacetLimit(10);// 限制facet返回的数量
		query.setFacetMissing(false);// 不统计null的值
		query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值,比如设置为1,则统计数量最小为1,不然不显示
		query.addFacetField(new String[] { "salary", "educateBackground",
				"jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
		// query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
		// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
		SimpleDateFormat time0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		SimpleDateFormat time1 = new SimpleDateFormat("yyyy-MM-dd");
		SimpleDateFormat time2 = new SimpleDateFormat("HH:mm:ss");
		// return
		// date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();

		Calendar c = Calendar.getInstance();
		c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
		Date date = c.getTime();
		String dateNow = time1.format(date) + "T" + time2.format(date) + "Z";
		c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
		c.add(Calendar.DATE, -1);
		date = c.getTime();
		// 当天
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -2);
		date = c.getTime();
		// 前三天
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -4);
		date = c.getTime();
		// 前一周
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -7);
		date = c.getTime();
		// 前两周
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -16);
		date = c.getTime();
		// 前一个月
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");
		c.add(Calendar.DATE, -30);
		date = c.getTime();
		// 前两个月
		query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
				+ time2.format(date) + "Z" + " TO " + dateNow + "]");

		QueryResponse rsp = null;
		try {
			rsp = solrServer.query(query);
			System.out.println("此次查询时间qtime :" + rsp.getQTime());
			List<FacetField> facets = rsp.getFacetFields();// 返回的facet列表
			for (FacetField facet : facets) {
				System.out.println(facet.getName());
				System.out.println("----------------");
				List<Count> counts = facet.getValues();
				for (Count countitem : counts) {
					System.out.println(countitem.getName() + ":"
							+ countitem.getCount());
				}
				System.out.println();
			}
			// 根据时间段来获取数据
			Map<String, Integer> maps = rsp.getFacetQuery();
			for (Entry<String, Integer> entry : maps.entrySet()) {
				System.out.println(entry.getKey() + ":" + entry.getValue());
			}
			// 获取返回的结果
			SolrDocumentList docs = rsp.getResults();			
			for (SolrDocument doc : docs) {
				System.out.println("-----");
				System.out.println(doc.getFieldValue("jobsName"));
				System.out.println(doc.getFieldValue("publishDate"));

			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		// 返回查询结果
		return rsp;
	}
}

阅读更多
个人分类: 云计算 人工智能
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭