本文档详细介绍了如何使用 Java 客户端连接 Elasticsearch 进行索引创建、数据增删改查、搜索、聚合等操作。包括验证连接、检查索引状态、创建索引、添加数据、查询数据、删除数据、更新数据、搜索及高亮显示、分类统计等。还展示了如何处理高级查询和分类统计，并提供了相关异常处理。
package test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpHost;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
//import org.apache.lucene.search.TotalHits;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchPhraseQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.hibernate.criterion.Order;
import org.junit.Test;
import com.pde.ams.p9.adapter.EsConfig;
import com.pde.ams.p9.domain.AmsFtsQueryBean;
import com.pde.ams.p9.task.AmsFtsDocBean;
import com.pde.ams.p9.util.BeanMapUtils;
import com.pde.app.common.params.PdpSystemParams;
import com.pde.pdp.fts.domain.FtsDocBase;
import com.pde.pdp.fts.domain.FtsFacetBean;
import com.pde.pdp.fts.domain.FtsQueryBean;
import com.pde.pdp.fts.domain.FtsValueBean;
import net.sf.ehcache.search.Query;
public class ElasticsearchTest {
//链接elasticsearch
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("127.0.0.1", 9200, "http")));
/**验证链接是否成功*/
@Test
public void test0() throws IOException{
/**
* 通过id判断数据是否存在
*/
GetRequest getRequest = new GetRequest(
"book",
"1");
boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
if (exists) {
System.out.println("链接成功");
}else{
System.out.println("链接失败");
}
client.close();
}
/**
* 判断索引是否存在
* @param hostUrl
* @param coreCode
* @return
*/
public int getCoreStatus(String hostUrl, String coreCode) {
//elasticsearch 客户端 连接
RestHighLevelClient hightClient = new EsConfig().hightClient();
GetIndexRequest request = new GetIndexRequest(coreCode);
boolean exists;
try {
request.local(false);
request.humanReadable(true);
request.includeDefaults(false);
exists = hightClient.indices().exists(request, RequestOptions.DEFAULT);
hightClient.close();
if (exists ==true) {
return 0;
} else {
return -3;
}
} catch (IOException e) {
e.printStackTrace();
}
return 0;
}
/*创建索引新增数据
* json方式*/
@Test
public void test1() throws IOException{
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("127.0.0.1", 9200, "http")));
IndexRequest request = new IndexRequest("posts");
request.id("1");
String jsonString = "{" +
"\"user\":\"kimchy\"," +
"\"postDate\":\"2013-01-30\"," +
"\"message\":\"trying out Elasticsearch\"" +
"}";
request.source(jsonString, XContentType.JSON);
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
String id = indexResponse.getId();
System.out.println("创建的id是："+indexResponse.getId());
client.close();
}
/*创建索引新增数据
* map方式*/
@Test
public void test2() throws IOException{
Map<String, Object> jsonMap = new HashMap<>();
jsonMap.put("user", "kimchy");
jsonMap.put("postDate", new Date());
jsonMap.put("message", "trying out Elasticsearch");
IndexRequest request = new IndexRequest("posts")
.id("2").source(jsonMap);
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
System.out.println("创建的id是："+indexResponse.getId());
client.close();
}
/*创建索引新增数据
* builder方式*/
@Test
public void test3() throws IOException{
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{
builder.field("user", "kimchy");
builder.timeField("postDate", new Date());
builder.field("message", "trying out Elasticsearch");
}
builder.endObject();
IndexRequest request = new IndexRequest("posts")
.id("3").source(builder);
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
System.out.println("创建的id是："+indexResponse.getId());
client.close();
}
/*创建索引新增数据
* objcet方式*/
@Test
public void test4() throws IOException{
IndexRequest request = new IndexRequest("posts")
.id("4")
.source("user", "kimchy",
"postDate", new Date(),
"message", "trying out Elasticsearch");
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
System.out.println("创建的id是："+indexResponse.getId());
client.close();
}
/* GetApi*/
@Test
public void test5() throws IOException{
GetRequest getRequest = new GetRequest(
"book",
"1");
GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
Map<String, Object> source = getResponse.getSource();
System.out.println("获取到的内容是："+source);
client.close();
}
/**
* 删除符合查询 条件的
* @param hostUrl
* @param coreName
* @param expression
* @return
*/
public int delByExpression(String hostUrl,String coreName ,String expression){
//elasticsearch 客户端 连接
RestHighLevelClient hightClient = new EsConfig().hightClient();
//参数为索引名，可以不指定，可以一个，可以多个
DeleteByQueryRequest request = new DeleteByQueryRequest(coreName);
// 更新时版本冲突
request.setConflicts("proceed");
expression= expression.substring(expression.indexOf(":")+1);
// 设置查询条件，第一个参数是字段名
request.setQuery(new TermQueryBuilder("tableId",expression));
// 更新最大文档数
//request.setMaxDocs(10);
// 批次大小
//request.setBatchSize(1000);
// 并行
//request.setSlices(2);
// 使用滚动参数来控制“搜索上下文”存活的时间
//request.setScroll(TimeValue.timeValueMinutes(10));
// 超时
//request.setTimeout(TimeValue.timeValueMinutes(2));
// 刷新索引
request.setRefresh(true);
try {
//调用客户端执行删除操作
BulkByScrollResponse deleteByQuery = hightClient.deleteByQuery(request, RequestOptions.DEFAULT);
}catch(ElasticsearchException e){
e.printStackTrace();
return -4;
} catch (IOException e) {
e.printStackTrace();
return -2;
}finally {
try {
hightClient.close();
} catch (IOException e) {
e.printStackTrace();
return -2;
}
}
return 0;
}
/* DeleteApi*/
@Test
public void test6() throws IOException{
DeleteRequest request = new DeleteRequest(
"gb");
DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
String id = deleteResponse.getId();
System.out.println("删除的id是："+id);
client.close();
}
@Test
public void test6_1() throws IOException{
DeleteIndexRequest request = new DeleteIndexRequest("gb");
try {
AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
System.out.println("删除的索引是："+delete);
client.close();
}catch(ElasticsearchException e){
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
}
/* DeleteApi*/
@Test
public void test7() throws IOException{
UpdateRequest request = new UpdateRequest(
"posts",
"1");
String jsonString = "{" +
"\"updated\":\"2017-01-01\"," +
"\"reason\":\"daily update\"" +
"}";
request.doc(jsonString, XContentType.JSON);
UpdateResponse updateResponse = client.update(
request, RequestOptions.DEFAULT);
String id = updateResponse.getId();
System.out.println("更新的id是："+id);
client.close();
}
/* SearchApi*/
@Test
public void test8() throws IOException{
SearchRequest searchRequest = new SearchRequest();
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.termQuery("user","kimchy"));
searchRequest.indices("posts");
searchRequest.searchType(SearchType.QUERY_THEN_FETCH);
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//System.out.println("更新的id是："+searchResponse.getHits().getTotalHits());
client.close();
}
/*query api 查询详情*/
@Test
public void test9() throws IOException{
SearchRequest searchRequest = new SearchRequest();
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//模糊查询 查询分数字段包含95的
searchSourceBuilder//.query(QueryBuilders.matchAllQuery())//查询所有的字段
//.query(QueryBuilders.matchQuery("name", "十一五"))//查询某个字段匹配
.query(QueryBuilders.multiMatchQuery("《现代推销理论与技巧（第2版）》", "name","info"))//多字段匹配
//.query(QueryBuilders.queryStringQuery("name:张*"))//按字符传匹配
//.from(2)//分页从第几条开始
//.size(3)//每页展示几条
.sort("_id",SortOrder.ASC)//排序
//.postFilter(QueryBuilders.rangeQuery("_id").from(10).to(11))
;
//设置搜索库
searchRequest.indices();
//设置搜索type
searchRequest.searchType(SearchType.DFS_QUERY_THEN_FETCH);
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
SearchHits hits = searchResponse.getHits();
//System.out.println(hits.getTotalHits());
SearchHit[] hits2 = hits.getHits();
for(SearchHit searchHit :hits2){
System.out.println(searchHit.getSourceAsString());
}
client.close();
}
/**
* 分类统计
* @throws IOException
*/
@Test
public void test10() throws IOException{
SearchRequest searchRequest = new SearchRequest();
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_Score").field("Score");
searchSourceBuilder.query(QueryBuilders.matchAllQuery())
.aggregation(aggregation);
searchRequest.indices("chengji");
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
Terms terms = searchResponse.getAggregations().get("by_Score");
List<? extends Bucket> buckets = terms.getBuckets();
for (Bucket bucket : buckets) {
Object key = bucket.getKey();
long docCount = bucket.getDocCount();
System.out.println(key+"---"+docCount);
}
}
@Test
public void test11() {
SearchRequest searchRequest = new SearchRequest();
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//设置搜索条条件
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
//创建一个高亮展示bulider
HighlightBuilder highlightBuilder = new HighlightBuilder();
//高亮的字段
highlightBuilder.field("displayFields");
//是否多个字段都高亮
highlightBuilder.requireFieldMatch(false);
//设置前缀后缀
highlightBuilder.preTags("<span style='color:red'>");
highlightBuilder.postTags("</span>");
boolQueryBuilder.must(
new BoolQueryBuilder()
.should(new MatchPhraseQueryBuilder("content","省政府"))
.should(new MatchPhraseQueryBuilder("displayFields","省政府"))
);
searchSourceBuilder.query(boolQueryBuilder)
//排序(要确保查询内容中存在需要排序的字段，否则会报错)
//.sort(bean.getSortField(),SortOrder.DESC)
.from(0)//分页从第几条
.size(10)//每页展示多少条
.highlighter(highlightBuilder);//高亮展示
//设置查询索引可以是单个或多个,多个需要放在数组中
searchRequest.indices("2_1");
//设置搜索源
searchRequest.source(searchSourceBuilder);
//调用客户端进行搜索
SearchResponse searchResponse;
try {
searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
SearchHits hits = searchResponse.getHits();
for (SearchHit hit : searchResponse.getHits().getHits()) {
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
//解析高亮字段
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
HighlightField field= highlightFields.get("displayFields");
if(field!= null){
Text[] fragments = field.fragments();
String n_field = "";
for (Text fragment : fragments) {
n_field += fragment;
}
//高亮内容覆盖原内容
sourceAsMap.put("displayFields",n_field);
}
try {
/*System.out.println(hit.getSourceAsMap());
System.out.println("————————————————————————————————");*/
} catch (Exception e) {
e.printStackTrace();
}
}
TimeValue took = searchResponse.getTook();
} catch (IOException e1) {
e1.printStackTrace();
}
/*System.out.println(took);
System.out.println("————————————————————————————————");
System.out.println(took.getMillis());
System.out.println("————————————————————————————————");*/
TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_year").field("year").order(BucketOrder.key(false));
searchSourceBuilder.aggregation(aggregation);
SearchRequest source = searchRequest.source(searchSourceBuilder);
try {
SearchResponse searchResponse2 = client.search(source, RequestOptions.DEFAULT);
Terms terms = searchResponse2.getAggregations().get("by_year");
List<? extends Bucket> buckets = terms.getBuckets();
for (Bucket bucket : buckets) {
Object key = bucket.getKey();
long docCount = bucket.getDocCount();
System.out.println("key是："+key+"value是："+docCount);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 创建 索引
* @param coreName
*/
public void CreateIndex(String coreName ){
//elasticsearch 客户端 连接
RestHighLevelClient hightClient = new EsConfig().hightClient();
CreateIndexRequest createIndexRequest = new CreateIndexRequest("coreName");
try {
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{
builder.startObject("properties");
{
builder.startObject("id");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("srcType");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("number");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("entryId");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("fileId");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("entryCode");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("fileName");{builder.field("type", "text").field("index", "false");}builder.endObject();
builder.startObject("title");{builder.field("type", "text").field("index", "false");}builder.endObject();
builder.startObject("tableType");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("fondsId");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("tableId");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("archivesClass");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("year");{builder.field("type", "keyword").field("index", "true");}builder.endObject();
builder.startObject("dept");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("displayFields");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("fields");{builder.field("type", "text").field("index", "true");}builder.endObject();
builder.startObject("content");{builder.field("type", "text").field("index", "true");}builder.endObject();
}
builder.endObject();
}
builder.endObject();
createIndexRequest.mapping(builder);
CreateIndexResponse response = hightClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 检索查询
*/
@Override
public FtsQueryBean search(FtsQueryBean bean) {
List<String> cores = filterCore(this.getWsServiceUrl(),bean.getCores());
if(cores.size() > 0){
bean.setCores(cores);
try {
//建立 elasticsearch链接
RestHighLevelClient hightClient = new EsConfig().hightClient();
//创建一个查询请求
SearchRequest searchRequest = new SearchRequest();
//创建一个搜索条件builder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//设置搜索条条件
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
/**
* 1、先判断是否是高级检索 处理执行高级检索条件
* 2、不是高级检索判断判断是否全词匹配
*/
List<FtsValueBean> fqList = bean.getFqList();
if (fqList!=null&&fqList.size()>0) {
List<QueryBuilder> must = boolQueryBuilder.must();
BoolQueryBuilder boolQueryBuilder2 = new BoolQueryBuilder();
for (FtsValueBean vb:fqList) {
boolQueryBuilder2.must(new MatchQueryBuilder("displayFields",vb.getName()+":"+vb.getValue()));
must.add(boolQueryBuilder2);
}
} else {
if (bean.getParticipleType() ==1) {
boolQueryBuilder.must(
new BoolQueryBuilder()
.should(new MatchPhraseQueryBuilder("content",bean.getContent()))
.should(new MatchPhraseQueryBuilder("displayFields",bean.getContent()))
);
} else {
boolQueryBuilder.must(
new BoolQueryBuilder()
.should(new MatchQueryBuilder("content",bean.getContent()))
.should(new MatchQueryBuilder("displayFields",bean.getContent()))
);
}
}
//封装表ID
if (bean instanceof AmsFtsQueryBean){
//在判断权限用户
if (((AmsFtsQueryBean)bean).getTablePowerIds()!=null){
List<QueryBuilder> must = boolQueryBuilder.must();
BoolQueryBuilder boolQueryBuilder2 = new BoolQueryBuilder();
for (String tableId: ((AmsFtsQueryBean) bean).getTablePowerIds()){
boolQueryBuilder2.should(new MatchPhraseQueryBuilder("tableId",tableId));
}
must.add(boolQueryBuilder2);
}
//增加处理要检索的全宗列表（D6用）
if (((AmsFtsQueryBean)bean).getFondsIds()!=null&&((AmsFtsQueryBean)bean).getFondsIds().size()>0){
List<QueryBuilder> must = boolQueryBuilder.must();
BoolQueryBuilder boolQueryBuilder2 = new BoolQueryBuilder();
for (String fondsId: ((AmsFtsQueryBean) bean).getFondsIds()){
boolQueryBuilder2.should(new MatchPhraseQueryBuilder("fondsId",fondsId));
}
must.add(boolQueryBuilder2);
}
//add archiveClass condition
if(((AmsFtsQueryBean) bean).getArchiveClass() != null){
if(((AmsFtsQueryBean) bean).getArchiveClass().size()!=0){
StringBuilder strb = new StringBuilder();
List<QueryBuilder> must = boolQueryBuilder.must();
BoolQueryBuilder boolQueryBuilder2 = new BoolQueryBuilder();
for(String s:((AmsFtsQueryBean) bean).getArchiveClass()){
strb.append("tableType:"+s+" OR ");
boolQueryBuilder2.should(new MatchPhraseQueryBuilder("tableType",s));
}
must.add(boolQueryBuilder2);
}
}
}
//设置搜索范围，1=条目 2=全文 0=条目+全文
if(bean.getType()==1){
boolQueryBuilder.must(QueryBuilders.matchPhraseQuery("srcType",1));
}else if (bean.getType()==2) {
boolQueryBuilder.must(QueryBuilders.matchPhraseQuery("srcType",2));
}
//如果必须包含字段不为空 加入过滤条件
if (bean.getIncludeWords() !=null && bean.getIncludeWords() !="") {
String[] split = bean.getIncludeWords().split("\\s+");
List<QueryBuilder> must = boolQueryBuilder.must();
for (String string : split) {
must.add(new BoolQueryBuilder().
should(new MatchPhraseQueryBuilder("content",string)).
should(new MatchPhraseQueryBuilder("displayFields",string)));
}
}
//如果排除字段不为空，加入过滤条件
if (bean.getRejectWords()!=null && bean.getRejectWords() !="") {
String[] split = bean.getRejectWords().split("\\s+");
List<QueryBuilder> mustNot = boolQueryBuilder.mustNot();
for (String string : split) {
mustNot.add(new BoolQueryBuilder().
should(new MatchPhraseQueryBuilder("content",string)).
should(new MatchPhraseQueryBuilder("displayFields",string)));
}
}
String fq = bean.getFq();
if(fq != null && fq.trim().length()>0){
List<QueryBuilder> must = boolQueryBuilder.must();
String fqName = fq.substring(0,fq.indexOf(":"));
String fqValue = fq.substring(fq.indexOf(":") + 1);
for (String s: SOLR_REJECT_KEY_WORD) {
fqValue = fqValue.replace(s, "\\" + s);
}
must.add(new BoolQueryBuilder().
should(new MatchPhraseQueryBuilder(fqName,fqValue))
);
}
//创建一个高亮展示bulider
HighlightBuilder highlightBuilder = new HighlightBuilder();
//高亮的字段
highlightBuilder.field("displayFields");
//是否多个字段都高亮
highlightBuilder.requireFieldMatch(false);
//设置前缀后缀
highlightBuilder.preTags("<span style='color:red'>");
highlightBuilder.postTags("</span>");
searchSourceBuilder.query(boolQueryBuilder)
.from(bean.getStart())//分页从第几条
.size(bean.getRows())//每页展示多少条
.highlighter(highlightBuilder);//高亮展示
//.sort(bean.getSortField(),SortOrder.DESC)//排序(要确保查询内容中存在需要排序的字段，否则会报错)
//将需要查询的索引转存到数组中
String[] coreArry = new String[cores.size()];
for (int i = 0; i < cores.size(); i++) {
coreArry[i] = cores.get(i);
}
searchRequest.indices(coreArry);
//设置搜索源
searchRequest.source(searchSourceBuilder);
//调用客户端进行搜索
SearchResponse searchResponse = hightClient.search(searchRequest, RequestOptions.DEFAULT);
SearchHits hits = searchResponse.getHits();
List<AmsFtsDocBean> beans = new ArrayList<>();
/*
* 1、解析获取到高亮字段
* 2、将高亮字段替换原来文档中的字段
* 3、将文档内容转换成bean对象放入list对象中返回
*/
for (SearchHit hit : searchResponse.getHits().getHits()) {
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
//解析高亮字段
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
HighlightField field= highlightFields.get("displayFields");
if(field!= null){
Text[] fragments = field.fragments();
String n_field = "";
for (Text fragment : fragments) {
n_field += fragment;
}
//高亮内容覆盖原内容
sourceAsMap.put("displayFields",n_field);
}
try {
beans.add(BeanMapUtils.mapToBean(hit.getSourceAsMap(),AmsFtsDocBean.class));
} catch (Exception e) {
e.printStackTrace();
}
}
bean.setTotal(hits.getTotalHits().value);
TimeValue took = searchResponse.getTook();
bean.setTimes(took.getMillis());
List<FtsDocBase> bases = new ArrayList<FtsDocBase>();
for(AmsFtsDocBean b:beans){
if (b.getContent()==null){
b.setContent("");
}
bases.add(b);
}
bean.setBeans(bases);
/**
* 分类统计，在查询的基础上，按照 split数组中的字段进行统计查询
*/
String[] split = pdpSystemParams.getValue(PdpSystemParams.PAGE_SHOW).split(";");
List<FtsFacetBean> fbs = new ArrayList<FtsFacetBean>();
for (String string : split) {
TermsAggregationBuilder aggregation = AggregationBuilders.terms(string)
.field(string+".keyword")
.order(BucketOrder.key(false))
.size(10);
searchSourceBuilder.aggregation(aggregation);
SearchRequest source = searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse2 = hightClient.search(source, RequestOptions.DEFAULT);
Terms terms = searchResponse2.getAggregations().get(string);
List<? extends Bucket> buckets = terms.getBuckets();
FtsFacetBean fb = new FtsFacetBean();
fb.setName(string);
List<FtsValueBean> vbs = new ArrayList<FtsValueBean>();
for (Bucket bucket : buckets) {
FtsValueBean vb = new FtsValueBean();
vb.setName(bucket.getKey().toString());
vb.setValue(""+bucket.getDocCount());
vbs.add(vb);
}
fb.setValues(vbs);
fbs.add(fb);
}
bean.setFacetBeans(fbs);
}catch(ElasticsearchException e){
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return bean;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
