一、说明：

　　一、Elasticsearch提供了两个JAVA REST Client版本：

　　1、java low level rest client:

　　低级别的rest客户端，通过http与集群交互，用户需自己编组请求JSON串，及解析响应JSON串。兼容所有Elasticsearch版本。

　　特点：maven引入

　　使用介绍: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-low.html

　　2、java high rest client:

　　高级别的REST客户端，基于低级别的REST客户端，增加了编组请求JSON串、解析响应JSON串等相关API，使用的版本需要保存和ES服务一致的版本，否则会有版本问题。

　　从6.0.0开始加入的，目的是以java面向对象的方式进行请求、响应处理。

　　每个API支持 同步、异步 两种方式，同步方法之间返回一个结果对象。异步的方法以async为后缀，通过listener参数来通知结果。高级java resy客户端依赖Elasticsearch core pproject

　　兼容性说明：

　　依赖jdk1.8和Elasticsearch core project

二、Java Low Level Rest Client的使用

1、JAVA High Level Rest Client maven集成

org.elasticsearch.client elasticsearch-rest-high-level-client 6.3.1

版本：

Elasticsearch 6.3.1

pom文件：

org.elasticsearch.client elasticsearch-rest-high-level-client 6.3.1
org.apache.logging.log4j log4j-api 2.7
org.apache.logging.log4j log4j-core 2.7

    <dependency>  
        <groupId>net.sf.json-lib</groupId>  
        <artifactId>json-lib</artifactId>  
        <version>0.9</version>  
    </dependency>  
</dependencies>

给定集群的多个节点地址，将客户端负载均衡地向这个节点地址集发请求：

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

/**
* @Author: xiaolaotou
* @Date: 2019/4/28
*/
public class ClientUtil {
public static RestHighLevelClient getClient(){
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("192.168.200.100",9200,"http"),
new HttpHost("192.168.200.101",9200,"http"),
new HttpHost("192.168.200.102",9200,"http"))
);
return client;
}
}

2、创建索引

/**
* 创建索引
* @throws Exception
*/
public static void createindex()throws Exception{
RestHighLevelClient client = ClientUtil.getClient();
//1、创建索引，设置索引名
CreateIndexRequest request = new CreateIndexRequest("mess");
//2、设置索引的settings
request.settings(Settings.builder()
.put("index.number_of_shards",3)//分片数
.put("index.number_of_replicas",1)//副本数
.put("analysis.analyzer.default.tokenizer","ik_smart"))//默认分词器
;
//3、设置索引的mappings
request.mapping("_doc",
" {\n" +
" \"_doc\": {\n" +
" \"properties\": {\n" +
" \"message\": {\n" +
" \"type\": \"text\"\n" +
" }\n" +
" }\n" +
" }\n" +
" }",
XContentType.JSON);
//4、设置索引的别名
request.alias(new Alias("mmm"));
//5、发送方式
// //5、1采用同步方式发送请求
CreateIndexResponse response = client.indices().create(request);
// 处理响应
boolean acknowledged = response.isAcknowledged();
boolean shardsAcknowledged = response.isShardsAcknowledged();
System.out.println("acknowledged = " + acknowledged);
System.out.println("shardsAcknowledged = " + shardsAcknowledged);
client.close();
//5、2采用异步方法发送请求
// ActionListener listener = new ActionListener() {
// @Override
// public void onResponse(CreateIndexResponse createIndexResponse) {
// //处理响应
// boolean acknowledged = createIndexResponse.isAcknowledged();
// boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
// System.out.println("shardsAcknowledged = " + shardsAcknowledged);
// System.out.println("acknowledged = " + acknowledged);
// }
// @Override
// public void onFailure(Exception e) {
// System.out.println("创建索引异常 = " + e.getMessage());
// }
// };
// client.indices().createAsync(request,listener);
// client.close();
}

3、index document

public static void indexDocument() throws IOException {
RestHighLevelClient client = ClientUtil.getClient();
//1、创建索引请求
IndexRequest request = new IndexRequest("mess", "_doc");
//2、准备文档数据
//方式一：直接给JSON串
String jsonString = "{" +
"\"user\":\"kimchy\"," +
"\"postDate\":\"2013-01-31\"," +
"\"message\":\"trying out Elasticsearch\"" +
"}";
request.source(jsonString, XContentType.JSON);

    //方式二：以map对象来表示文档  

// HashMap jsonMap = new HashMap<>();
// jsonMap.put("user", "kimchy");
// jsonMap.put("postDate", new Date());
// jsonMap.put("message", "trying out Elasticsearch");
// request.source(jsonMap);

    //方式三：用XContentBuilder来构建文档  

// XContentBuilder builder = XContentFactory.jsonBuilder();
// builder.startObject();
// {
// builder.field("user", "kimchy");
// builder.field("postDate", new Date());
// builder.field("message", "trying out Elasticsearch");
// }
// builder.endObject();
// request.source(builder);

// //方式四：直接用key-value对给出
// request.source("user", "kimchy",
// "postDate", new Date(),
// "message", "trying out Elasticsearch");

    //3、其他的一些可选设置  
        /\*  
        request.routing("routing");  //设置routing值  
        request.timeout(TimeValue.timeValueSeconds(1));  //设置主分片等待时长  
        request.setRefreshPolicy("wait\_for");  //设置重刷新策略  
        request.version(2);  //设置版本号  
        request.opType(DocWriteRequest.OpType.CREATE);  //操作类别  
        \*/  
    //4、发送请求-->同步方式  
    IndexResponse indexResponse = null;  
    try {  
        // 同步方式  
        indexResponse = client.index(request);  
    } catch(ElasticsearchException e) {  
        // 捕获，并处理异常  
        //判断是否版本冲突、create但文档已存在冲突  
        if (e.status() == RestStatus.CONFLICT) {  
            logger.error("冲突了，请在此写冲突处理逻辑！\\n" + e.getDetailedMessage());  
        }

        logger.error("索引异常", e);  
    }  
    //处理响应  
    if(indexResponse != null) {  
        String index = indexResponse.getIndex();  
        String type = indexResponse.getType();  
        String id = indexResponse.getId();  
        long version = indexResponse.getVersion();  
        if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {  
            System.out.println("新增文档成功，处理逻辑代码写到这里。");  
        } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {  
            System.out.println("修改文档成功，处理逻辑代码写到这里。");  
        }  
        // 分片处理信息  
        ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();  
        if (shardInfo.getTotal() != shardInfo.getSuccessful()) {

        }  
        // 如果有分片副本失败，可以获得失败原因信息  
        if (shardInfo.getFailed() > 0) {  
            for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {  
                String reason = failure.reason();  
                System.out.println("副本失败原因：" + reason);  
            }  
        }  
    }  
    client.close();

    //异步方式  

// ActionListener listener = new ActionListener(){
// @Override
// public void onResponse(IndexResponse indexResponse) {
// //5、处理响应
// if (indexResponse != null) {
// String index = indexResponse.getIndex();
// String type = indexResponse.getType();
// String id = indexResponse.getId();
// long version = indexResponse.getVersion();
// if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
// System.out.println("新增文档成功，处理逻辑代码写到这里。");
// } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
// System.out.println("修改文档成功，处理逻辑代码写到这里。");
// }
// }
// }
// @Override
// public void onFailure(Exception e) {
// System.out.println("创建索引异常：" + e.getMessage());
// }
// };
// client.indexAsync(request,listener);
// client.close();
}

4、get document（获取文档数据）

/**
* 获取文档数据
* @throws IOException
*/
public static void getDocument() throws IOException {
RestHighLevelClient client = ClientUtil.getClient();
//1、创建获取文档请求
GetRequest request = new GetRequest("mess","_doc","bcUli2oBM0IXAkB-Yvpr");
//2、可选的设置
// request.routing("routing");
// request.version(2);
// request.fetchSourceContext(new FetchSourceContext(false));//是否获取_source字段

    //选择返回的字段  
    String\[\] includes=new String\[\]{"message","postDate"};  
    String\[\] excludes = Strings.EMPTY\_ARRAY;  
    FetchSourceContext fetchSourceContext =  
            new FetchSourceContext(true, includes, excludes);  
    request.fetchSourceContext(fetchSourceContext);  
    // 取stored字段  
        /\*request.storedFields("message");  
        GetResponse getResponse = client.get(request);  
        String message = getResponse.getField("message").getValue();\*/  
    //发送请求  
    GetResponse getResponse = null;  
    try {  
        // 同步请求  
        getResponse = client.get(request);  
        System.out.println("getResponse = " + getResponse);  
    } catch (ElasticsearchException e) {  
        if (e.status() == RestStatus.NOT\_FOUND) {  
            logger.error("没有找到该id的文档" );  
        }  
        if (e.status() == RestStatus.CONFLICT) {  
            logger.error("获取时版本冲突了，请在此写冲突处理逻辑！" );  
        }  
        logger.error("获取文档异常", e);  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  
    //处理响应  
    if(getResponse != null) {  
        String index = getResponse.getIndex();  
        String type = getResponse.getType();  
        String id = getResponse.getId();  
        if (getResponse.isExists()) { // 文档存在  
            long version = getResponse.getVersion();  
            String sourceAsString = getResponse.getSourceAsString(); //结果取成 String  
            Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();  // 结果取成Map  
            byte\[\] sourceAsBytes = getResponse.getSourceAsBytes();    //结果取成字节数组

            logger.info("index:" + index + "  type:" + type + "  id:" + id);  
            logger.info(sourceAsString);

        } else {  
            logger.error("没有找到该id的文档" );  
        }  
    }  
client.close();

5、bulk批量索引

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;

/**
* @Author: xiaolaotou
* @Date: 2019/5/6
*/
public class BulkIndex {
public static void main(String[] args) throws IOException {
RestHighLevelClient client = ClientUtil.getClient();
//1、创建批量操作请求
BulkRequest request = new BulkRequest();
request.add(new IndexRequest("mess","_doc","1")
.source(XContentType.JSON,"field","foo"));
request.add(new IndexRequest("mess","_doc","2")
.source(XContentType.JSON,"field","bar"));
request.add(new IndexRequest("mess","_doc","3")
.source(XContentType.JSON,"field","baz"));
// 2、可选的设置
/*
request.timeout("2m");
request.setRefreshPolicy("wait_for");
request.waitForActiveShards(2);
*/
//发送请求--》同步方式
BulkResponse bulkResponse = client.bulk(request);
//处理响应
if(bulkResponse != null) {
for (BulkItemResponse bulkItemResponse : bulkResponse) {
DocWriteResponse itemResponse = bulkItemResponse.getResponse();

            if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX  
                    || bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE) {  
                IndexResponse indexResponse = (IndexResponse) itemResponse;  
                //TODO 新增成功的处理

            } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {  
                UpdateResponse updateResponse = (UpdateResponse) itemResponse;  
                //TODO 修改成功的处理

            } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {  
                DeleteResponse deleteResponse = (DeleteResponse) itemResponse;  
                //TODO 删除成功的处理  
            }  
        }  
    }  
    client.close();  
}  

}

6、Search查询数据

package com.study.es_hrset_client;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.ShardSearchFailure;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.suggest.Suggest;
import org.elasticsearch.search.suggest.term.TermSuggestion;

/**
*
* @author xiaolaotou
* @date 2019/5/6
*
*/
public class SearchDemo {

private static Logger logger = LogManager.getRootLogger();  

public static void main(String\[\] args) {  
    try (RestHighLevelClient client = InitDemo.getClient();) {

        // 1、创建search请求  
        //SearchRequest searchRequest = new SearchRequest();  
        SearchRequest searchRequest = new SearchRequest("bank");  
        searchRequest.types("\_doc");

        // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。  
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 

        //构造QueryBuilder  
        /\*QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")  
                .fuzziness(Fuzziness.AUTO)  
                .prefixLength(3)  
                .maxExpansions(10);  
        sourceBuilder.query(matchQueryBuilder);\*/

        sourceBuilder.query(QueryBuilders.termQuery("age", 24));  
        sourceBuilder.from(0);  
        sourceBuilder.size(10);  
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS)); 

        //是否返回\_source字段  
        //sourceBuilder.fetchSource(false);

        //设置返回哪些字段  
        /\*String\[\] includeFields = new String\[\] {"title", "user", "innerObject.\*"};  
        String\[\] excludeFields = new String\[\] {"\_type"};  
        sourceBuilder.fetchSource(includeFields, excludeFields);\*/

        //指定排序  
        //sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));  
        //sourceBuilder.sort(new FieldSortBuilder("\_uid").order(SortOrder.ASC));

        // 设置返回 profile  
        //sourceBuilder.profile(true);

        //将请求体加入到请求中  
        searchRequest.source(sourceBuilder);

        // 可选的设置  
        //searchRequest.routing("routing");

        // 高亮设置  
        /\*  
        HighlightBuilder highlightBuilder = new HighlightBuilder();  
        HighlightBuilder.Field highlightTitle =  
                new HighlightBuilder.Field("title");  
        highlightTitle.highlighterType("unified");  
        highlightBuilder.field(highlightTitle);  
        HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");  
        highlightBuilder.field(highlightUser);  
        sourceBuilder.highlighter(highlightBuilder);\*/

        //加入聚合  
        /\*TermsAggregationBuilder aggregation = AggregationBuilders.terms("by\_company")  
                .field("company.keyword");  
        aggregation.subAggregation(AggregationBuilders.avg("average\_age")  
                .field("age"));  
        sourceBuilder.aggregation(aggregation);\*/

        //做查询建议  
        /\*SuggestionBuilder termSuggestionBuilder =  
                SuggestBuilders.termSuggestion("user").text("kmichy");  
            SuggestBuilder suggestBuilder = new SuggestBuilder();  
            suggestBuilder.addSuggestion("suggest\_user", termSuggestionBuilder);  
        sourceBuilder.suggest(suggestBuilder);\*/

        //3、发送请求  
        SearchResponse searchResponse = client.search(searchRequest);

        //4、处理响应  
        //搜索结果状态信息  
        RestStatus status = searchResponse.status();  
        TimeValue took = searchResponse.getTook();  
        Boolean terminatedEarly = searchResponse.isTerminatedEarly();  
        boolean timedOut = searchResponse.isTimedOut();

        //分片搜索情况  
        int totalShards = searchResponse.getTotalShards();  
        int successfulShards = searchResponse.getSuccessfulShards();  
        int failedShards = searchResponse.getFailedShards();  
        for (ShardSearchFailure failure : searchResponse.getShardFailures()) {  
            // failures should be handled here  
        }

        //处理搜索命中文档结果  
        SearchHits hits = searchResponse.getHits();

        long totalHits = hits.getTotalHits();  
        float maxScore = hits.getMaxScore();

        SearchHit\[\] searchHits = hits.getHits();  
        for (SearchHit hit : searchHits) {  
            // do something with the SearchHit

            String index = hit.getIndex();  
            String type = hit.getType();  
            String id = hit.getId();  
            float score = hit.getScore();

            //取\_source字段值  
            String sourceAsString = hit.getSourceAsString(); //取成json串  
            Map<String, Object> sourceAsMap = hit.getSourceAsMap(); // 取成map对象  
            //从map中取字段值  
            /\*  
            String documentTitle = (String) sourceAsMap.get("title");  
            List<Object> users = (List<Object>) sourceAsMap.get("user");  
            Map<String, Object> innerObject = (Map<String, Object>) sourceAsMap.get("innerObject");  
            \*/  
            logger.info("index:" + index + "  type:" + type + "  id:" + id);  
            logger.info(sourceAsString);

            //取高亮结果  
            /\*Map<String, HighlightField> highlightFields = hit.getHighlightFields();  
            HighlightField highlight = highlightFields.get("title");  
            Text\[\] fragments = highlight.fragments();  
            String fragmentString = fragments\[0\].string();\*/  
        }

        // 获取聚合结果  
        /\*  
        Aggregations aggregations = searchResponse.getAggregations();  
        Terms byCompanyAggregation = aggregations.get("by\_company");  
        Bucket elasticBucket = byCompanyAggregation.getBucketByKey("Elastic");  
        Avg averageAge = elasticBucket.getAggregations().get("average\_age");  
        double avg = averageAge.getValue();  
        \*/

        // 获取建议结果  
        /\*Suggest suggest = searchResponse.getSuggest();  
        TermSuggestion termSuggestion = suggest.getSuggestion("suggest\_user");  
        for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {  
            for (TermSuggestion.Entry.Option option : entry) {  
                String suggestText = option.getText().string();  
            }  
        }  
        \*/

        //异步方式发送获查询请求  
        /\*  
        ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {  
            @Override  
            public void onResponse(SearchResponse getResponse) {  
                //结果获取  
            }

            @Override  
            public void onFailure(Exception e) {  
                //失败处理  
            }  
        };  
        client.searchAsync(searchRequest, listener);  
        \*/

    } catch (IOException e) {  
        logger.error(e);  
    }  
}  

}

7、highlight 高亮

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import java.io.IOException;
import java.util.Map;

/**
* @Author: xiaolaotou

* @Date: 2019/5/6
*/
public class highlight {
public static void main(String[] args) throws IOException {
RestHighLevelClient client = ClientUtil.getClient();
//1、创建请求
SearchRequest searchRequest = new SearchRequest("mess");
//2、用SearchSourceBuilder来构造查询请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//构造QueryBuilder
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy");
sourceBuilder.query(matchQueryBuilder);
//高亮设置
HighlightBuilder highlightBuilder = new HighlightBuilder();
//不同字段可有不同设置，如不同标签
HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("user");
highlightTitle.preTags("").postTags("");
highlightBuilder.field(highlightTitle);
sourceBuilder.highlighter(highlightBuilder);
searchRequest.source(sourceBuilder);
//3、发送请求
SearchResponse searchResponse = client.search(searchRequest);
//4、处理响应
if (RestStatus.OK.equals(searchResponse.status())) {
//处理搜索命中文档结果
SearchHits hits = searchResponse.getHits();
SearchHit[] searchHits = hits.getHits();
for (SearchHit hit : searchHits) {
//取_source字段值
Map sourceAsMap = hit.getSourceAsMap(); // 取成map对象
//从map中取字段值
/*String title = (String) sourceAsMap.get("title");
String content = (String) sourceAsMap.get("content"); */
System.out.println("sourceAsMap = " + sourceAsMap);
//取高亮结果
Map highlightFields = hit.getHighlightFields();
HighlightField highlight = highlightFields.get("user");
if (highlight != null) {
Text[] fragments = highlight.fragments(); //多值的字段会有多个值
if (fragments != null) {
String fragmentString = fragments[0].string();
System.out.println("user highlight = " + fragmentString);
//可用高亮字符串替换上面sourceAsMap中的对应字段返回到上一级调用
//sourceAsMap.put("title", fragmentString);
}
}
}
}
client.close();
}
}

8、查询建议

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.suggest.Suggest;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.elasticsearch.search.suggest.SuggestBuilders;
import org.elasticsearch.search.suggest.SuggestionBuilder;
import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
import org.elasticsearch.search.suggest.term.TermSuggestion;
import org.elasticsearch.search.suggest.term.TermSuggestionBuilder;
import java.io.IOException;

/**
* @Author: xiaolaotou
* @Date: 2019/5/6
*/
public class SearchSuggestion {
public static void termSuggest() throws IOException {
RestHighLevelClient client = ClientUtil.getClient();
//1、创建search请求
SearchRequest searchRequest = new SearchRequest("mess");
// 2、用SearchSourceBuilder来构造查询请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//做查询建议
//词项建议
TermSuggestionBuilder termSuggestionBuilder = SuggestBuilders.termSuggestion("user").text("kimchy");
SuggestBuilder suggestBuilder = new SuggestBuilder();
suggestBuilder.addSuggestion("user",termSuggestionBuilder);
sourceBuilder.suggest(suggestBuilder);

    //发送请求  
    SearchResponse searchResponse = client.search(searchRequest);  
    //处理响应  
            //搜索结果状态信息  
    if(RestStatus.OK.equals(searchResponse.status())) {  
        // 获取建议结果  
        Suggest suggest = searchResponse.getSuggest();  
        TermSuggestion termSuggestion = suggest.getSuggestion("suggest\_user");  
        for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {  
            System.out.println("entry = " + entry.getText().string());  
            for (TermSuggestion.Entry.Option option : entry) {  
                String suggestText = option.getText().string();  
                System.out.println("suggest option = " + suggestText);  
            }  
        }  
    }  
    }

/\*\*  
 \* 自动补全，根据用户的输入联想到可能的词或者短语  
 \*/  
public static void completionSuggester() throws IOException {  
    RestHighLevelClient client = ClientUtil.getClient();  
    //1、创建请求  
    SearchRequest searchRequest = new SearchRequest("mess");  
    //2、用SearchSourceBuilder来构造查询请求体  
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();  
    SuggestionBuilder termSuggestionBuilder =  
            SuggestBuilders.completionSuggestion("suggest").prefix("lucene s")  
                    .skipDuplicates(true);  
    SuggestBuilder suggestBuilder = new SuggestBuilder();  
    suggestBuilder.addSuggestion("song-suggest", termSuggestionBuilder);  
    sourceBuilder.suggest(suggestBuilder);

    searchRequest.source(sourceBuilder);

    //3、发送请求  
    SearchResponse searchResponse = client.search(searchRequest);  
    //4、处理响应  
    //搜索结果状态信息  
    if(RestStatus.OK.equals(searchResponse.status())) {  
        // 获取建议结果  
        Suggest suggest = searchResponse.getSuggest();  
        CompletionSuggestion termSuggestion = suggest.getSuggestion("song-suggest");  
        for (CompletionSuggestion.Entry entry : termSuggestion.getEntries()) {  
            System.out.println("text: " + entry.getText().string());  
            for (CompletionSuggestion.Entry.Option option : entry) {  
                String suggestText = option.getText().string();  
                System.out.println("suggest option  = " + suggestText);  
            }  
        }  
    }

}  
public static void main(String\[\] args) throws IOException {  
    termSuggest();  

// completionSuggester();
}
}

9、aggregation 聚合分析

import java.io.IOException;
import java.util.concurrent.ExecutionException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
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.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.builder.SearchSourceBuilder;

public class AggregationDemo {

private static Logger logger = LogManager.getRootLogger();

public static void main(String\[\] args) {  
    try (RestHighLevelClient client = ClientUtil.getClient();) {

        // 1、创建search请求  
        //SearchRequest searchRequest = new SearchRequest();  
        SearchRequest searchRequest = new SearchRequest("bank");

        // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。  
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.size(0);

        //加入聚合  
        //字段值项分组聚合  
        TermsAggregationBuilder aggregation = AggregationBuilders.terms("by\_age")  
                .field("age").order(BucketOrder.aggregation("average\_balance", true));  
        //计算每组的平均balance指标  
        aggregation.subAggregation(AggregationBuilders.avg("average\_balance")  
                .field("balance"));  
        sourceBuilder.aggregation(aggregation);

        searchRequest.source(sourceBuilder);

        //3、发送请求  
        SearchResponse searchResponse = client.search(searchRequest);

        //4、处理响应  
        //搜索结果状态信息  
        if(RestStatus.OK.equals(searchResponse.status())) {  
            // 获取聚合结果  
            Aggregations aggregations = searchResponse.getAggregations();  
            Terms byAgeAggregation = aggregations.get("by\_age");  
            logger.info("aggregation by\_age 结果");  
            logger.info("docCountError: " + byAgeAggregation.getDocCountError());  
            logger.info("sumOfOtherDocCounts: " + byAgeAggregation.getSumOfOtherDocCounts());  
            logger.info("------------------------------------");  
            for(Bucket buck : byAgeAggregation.getBuckets()) {  
                logger.info("key: " + buck.getKeyAsNumber());  
                logger.info("docCount: " + buck.getDocCount());  
                //logger.info("docCountError: " + buck.getDocCountError());  
                //取子聚合  
                Avg averageBalance = buck.getAggregations().get("average\_balance");

                logger.info("average\_balance: " + averageBalance.getValue());  
                logger.info("------------------------------------");  
            }  
            //直接用key 来去分组  
            /\*Bucket elasticBucket = byCompanyAggregation.getBucketByKey("24");  
            Avg averageAge = elasticBucket.getAggregations().get("average\_age");  
            double avg = averageAge.getValue();\*/

        }

    } catch (Exception  e) {  
        logger.error(e);  
    }  
}  

}