一、简介

1.先看ES的架构图

二、ES支持的客户端连接方式

1.REST API

　　http请求，例如，浏览器请求get方法；利用Postman等工具发起REST请求；java 发起httpClient请求等。

2.Transport 连接

　　socket连接，用官方提供的TransPort客户端，底层是netty。

注意：ES的发展规划中在7.0版本开始将废弃 TransportClient，8.0版本中将完全移除 TransportClient，取而代之的是High Level REST Client。

3. ES提供了多种编程语言客户端

　　

官网可以了解详情：

https://www.elastic.co/guide/en/elasticsearch/client/index.html

三、Java REST Client介绍

1. ES提供了两个JAVA REST client 版本

Java Low Level REST Client: 低级别的REST客户端，通过http与集群交互，用户需自己编组请求JSON串，及解析响应JSON串。兼容所有ES版本。
Java High Level REST Client: 高级别的REST客户端，基于低级别的REST客户端，增加了编组请求JSON串、解析响应JSON串等相关api。使用的版本需要保持和ES服务端的版本一致，否则会有版本问题。

官方推荐使用高级版，低级版需要自己准确记住api。

2. Java Low Level REST Client 说明

特点，maven 引入、使用介绍： https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-low.html

API doc ：https://artifacts.elastic.co/javadoc/org/elasticsearch/client/elasticsearch-rest-client/6.2.4/index.html.

3. Java High Level REST Client 说明

从6.0.0开始加入的，目的是以java面向对象的方式来进行请求、响应处理。
每个API 支持 同步/异步 两种方式，同步方法直接返回一个结果对象。异步的方法以async为后缀，通过listener参数来通知结果。
高级java REST 客户端依赖Elasticsearch core project

兼容性说明：

依赖 java1.8 和 Elasticsearch core project
请使用与服务端ES版本一致的客户端版本

4. Java High Level REST Client  maven 集成

  1. <dependency>
  2.     <groupId>org.elasticsearch.client</groupId>
  3.     <artifactId>elasticsearch-rest-high-level-client</artifactId>
  4.     <version>6.2.4</version>
  5. </dependency>

5.将log4j2.xml编译到classes路径下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration status="OFF">
  3.     <appenders>
  4.         <Console name="Console" target="SYSTEM_OUT">
  5.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
  6.         </Console>
  7.     </appenders>
  8.     <loggers>
  9.         <root level="info">
  10.             <appender-ref ref="Console"/>
  11.         </root>
  12.     </loggers>
  13. </configuration>

6. Java High Level REST Client  初始化

  1. RestHighLevelClient client = new RestHighLevelClient(
  2.         RestClient.builder(
  3.                 new HttpHost("localhost", 9200, "http"),
  4.                 new HttpHost("localhost", 9201, "http")));

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

Client 不再使用了，记得关闭它：

  1. client.close();

API及用法示例，请参考：

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.3/java-rest-high-create-index.html

四、Java High Level REST Client  使用示例

准备（需要配置log4j2的maven配置和log的配置文件，否则运行demo控制台会报错）：

编写示例之前首先在maven工程里面引入和ES服务端版本一样的Java客户端

  1. <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>6.3.1</version>
    </dependency>
    <!--日志-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.11.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.11.1</version>
    </dependency>

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

  1. package com.es.demo;
  2.  
  3. import org.apache.http.HttpHost;
  4. import org.elasticsearch.client.RestClient;
  5. import org.elasticsearch.client.RestHighLevelClient;
  6.  
  7. public class InitClient {
  8.  
  9.     public static RestHighLevelClient getClient(){
  10.         RestHighLevelClient client = new RestHighLevelClient(
  11.                 RestClient.builder(
  12.                         new HttpHost("localhost", , "http")));
  13.         return client;
  14.     }
  15.  
  16. }

1.创建索引

  1. package com.es.demo;
  2.  
  3. import org.elasticsearch.action.ActionListener;
  4. import org.elasticsearch.action.admin.indices.alias.Alias;
  5. import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
  6. import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
  7. import org.elasticsearch.action.index.IndexResponse;
  8. import org.elasticsearch.client.RestHighLevelClient;
  9. import org.elasticsearch.common.settings.Settings;
  10. import org.elasticsearch.common.xcontent.XContentType;
  11.  
  12. public class CreateIndexDemo {
  13.  
  14.     public static void main(String ags[]){
  15.         try(RestHighLevelClient client = InitClient.getClient()){
  16.  
  17.             // 1.创建索引名
  18.             CreateIndexRequest request = new CreateIndexRequest("book8");
  19.  
  20.             // 2.索引setting配置
  21.             request.settings(Settings.builder().put("index.number_of_shards",)
  22.                     .put("index.number_of_replicas", ) // 副本数
  23.                     .put("analysis.analyzer.default.tokenizer","standard")
  24.             );
  25.  
  26.             // 3.设置索引的mapping
  27.             request.mapping("_doc",
  28.                     "  {\n" +
  29.                             "    \"_doc\": {\n" +
  30.                             "      \"properties\": {\n" +
  31.                             "        \"message\": {\n" +
  32.                             "          \"type\": \"text\"\n" +
  33.                             "        }\n" +
  34.                             "      }\n" +
  35.                             "    }\n" +
  36.                             "  }",
  37.                     XContentType.JSON);
  38.  
  39.             // 设置索引别名
  40.             request.alias(new Alias("lab1"));
  41.  
  42.             // 5.发送请求
  43.             // 5.1同步方式
  44.             CreateIndexResponse response = client.indices().create(request);
  45.  
  46.             // 处理响应
  47.             boolean acknowledged = response.isAcknowledged();
  48.             boolean shardsAcknowledged = response.isShardsAcknowledged();
  49.  
  50.             System.out.println("请求结果---------------");
  51.             System.out.println("acknowledged:"+acknowledged);
  52.             System.out.println("shardsAcknowledged:"+shardsAcknowledged);
  53.  
  54.             // 5.2 异步方式发送请求
  55.            /* ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
  56.  
  57.                 @Override
  58.                 public void onResponse(CreateIndexResponse createIndexResponse) {
  59.                     boolean acknowledged = createIndexResponse.isAcknowledged();
  60.                     boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
  61.                     System.out.println("请求结果---------------");
  62.                     System.out.println("acknowledged:"+acknowledged);
  63.                     System.out.println("shardsAcknowledged:"+shardsAcknowledged);
  64.                 }
  65.  
  66.                 @Override
  67.                 public void onFailure(Exception e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             };
  71.  
  72.             client.indices().createAsync(request, listener);*/
  73.  
  74.         }catch (Exception e){
  75.             e.printStackTrace();
  76.         }
  77.     }
  78. }

结果：

  1. 请求结果---------------
  2. acknowledged:true
  3. shardsAcknowledged:true

构建json官方一共给出四中方式：

  1. package com.es.demo;
  2.  
  3. import org.elasticsearch.action.ActionListener;
  4. import org.elasticsearch.action.admin.indices.alias.Alias;
  5. import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
  6. import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
  7. import org.elasticsearch.action.index.IndexResponse;
  8. import org.elasticsearch.client.RestHighLevelClient;
  9. import org.elasticsearch.common.settings.Settings;
  10. import org.elasticsearch.common.xcontent.XContentBuilder;
  11. import org.elasticsearch.common.xcontent.XContentFactory;
  12. import org.elasticsearch.common.xcontent.XContentType;
  13.  
  14. import java.util.HashMap;
  15. import java.util.Map;
  16.  
  17. public class CreateIndexDemo {
  18.  
  19.     public static void main(String ags[]){
  20.         try(RestHighLevelClient client = InitClient.getClient()){
  21.  
  22.             // 1.创建索引名
  23.             CreateIndexRequest request = new CreateIndexRequest("book13");
  24.  
  25.             // 2.索引setting配置
  26.             /*request.settings(Settings.builder().put("index.number_of_shards",5)
  27.                     .put("index.number_of_replicas", 2) // 副本数
  28.                     .put("analysis.analyzer.default.tokenizer","standard")
  29.             );*/
  30.  
  31.             // 3.设置索引的mapping
  32.             // 3.1方式一、直接给出json串
  33.             /*      request.mapping("_doc",
  34.                     "  {\n" +
  35.                             "    \"_doc\": {\n" +
  36.                             "      \"properties\": {\n" +
  37.                             "        \"message\": {\n" +
  38.                             "          \"type\": \"text\"\n" +
  39.                             "        }\n" +
  40.                             "      }\n" +
  41.                             "    }\n" +
  42.                             "  }",
  43.                     XContentType.JSON);*/
  44.  
  45.             // 3.2方式二、给出封装成Map
  46.  
  47.             /*   Map<String, Object> jsonMap = new HashMap<>();
  48.             Map<String, Object> message = new HashMap<>();
  49.             message.put("type", "text");
  50.             Map<String, Object> properties = new HashMap<>();
  51.             properties.put("message", message);
  52.             Map<String, Object> _doc = new HashMap<>();
  53.             _doc.put("properties", properties);
  54.             jsonMap.put("_doc", _doc);
  55.             request.mapping("_doc", jsonMap);*/
  56.  
  57.             // 3.3方式三、使用XContentBuilder
  58.            /* XContentBuilder builder = XContentFactory.jsonBuilder();
  59.             builder.startObject();
  60.             {
  61.                 builder.startObject("_doc");
  62.                 {
  63.                     builder.startObject("properties");
  64.                     {
  65.                         builder.startObject("message");
  66.                         {
  67.                             builder.field("type", "text");
  68.                         }
  69.                         builder.endObject();
  70.                         builder.startObject("message1");
  71.                         {
  72.                             builder.field("type", "text");
  73.                         }
  74.                         builder.endObject();
  75.                     }
  76.                     builder.endObject();
  77.                 }
  78.                 builder.endObject();
  79.             }
  80.             builder.endObject();
  81.             request.mapping("_doc", builder);*/
  82.  
  83.             // 3.4方式四、使用XContentBuilder
  84.             request.source("{\n" +
  85.                     "    \"settings\" : {\n" +
  86.                     "        \"number_of_shards\" : 1,\n" +
  87.                     "        \"number_of_replicas\" : 0\n" +
  88.                     "    },\n" +
  89.                     "    \"mappings\" : {\n" +
  90.                     "        \"_doc\" : {\n" +
  91.                     "            \"properties\" : {\n" +
  92.                     "                \"message\" : { \"type\" : \"text\" },\n" +
  93.                     "                \"message1\" : { \"type\" : \"text\" }\n" +
  94.                     "            }\n" +
  95.                     "        }\n" +
  96.                     "    },\n" +
  97.                     "    \"aliases\" : {\n" +
  98.                     "        \"lab2\" : {}\n" +
  99.                     "    }\n" +
  100.                     "}", XContentType.JSON);
  101.  
  102.             // 设置索引别名
  103.             //request.alias(new Alias("lab1"));
  104.  
  105.             // 5.发送请求
  106.             // 5.1同步方式
  107.             CreateIndexResponse response = client.indices().create(request);
  108.  
  109.             // 处理响应
  110.             boolean acknowledged = response.isAcknowledged();
  111.             boolean shardsAcknowledged = response.isShardsAcknowledged();
  112.  
  113.             System.out.println("请求结果---------------");
  114.             System.out.println("acknowledged:"+acknowledged);
  115.             System.out.println("shardsAcknowledged:"+shardsAcknowledged);
  116.  
  117.             // 5.2 异步方式发送请求
  118.            /* ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
  119.  
  120.                 @Override
  121.                 public void onResponse(CreateIndexResponse createIndexResponse) {
  122.                     boolean acknowledged = createIndexResponse.isAcknowledged();
  123.                     boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
  124.                     System.out.println("请求结果---------------");
  125.                     System.out.println("acknowledged:"+acknowledged);
  126.                     System.out.println("shardsAcknowledged:"+shardsAcknowledged);
  127.                 }
  128.  
  129.                 @Override
  130.                 public void onFailure(Exception e) {
  131.                     e.printStackTrace();
  132.                 }
  133.             };
  134.  
  135.             client.indices().createAsync(request, listener);*/
  136.  
  137.         }catch (Exception e){
  138.             e.printStackTrace();
  139.         }
  140.     }
  141. }

更多用法参考官方：java索引API

2. index  document

索引文档，即往索引里面放入文档数据.类似于数据库里面向表里面插入一行数据，一行数据就是一个文档

  1. package com.es.demo;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.ElasticsearchException;
  6. import org.elasticsearch.action.DocWriteResponse;
  7. import org.elasticsearch.action.index.IndexRequest;
  8. import org.elasticsearch.action.index.IndexResponse;
  9. import org.elasticsearch.action.support.replication.ReplicationResponse;
  10. import org.elasticsearch.client.RestHighLevelClient;
  11. import org.elasticsearch.common.xcontent.XContentType;
  12. import org.elasticsearch.rest.RestStatus;
  13.  
  14. public class IndexDocumentDemo {
  15.     private static Logger logger = LogManager.getRootLogger();
  16.  
  17.     public static  void main(String args[]){
  18.         try(RestHighLevelClient client = InitClient.getClient()){
  19.             // 1、创建索引请求
  20.             IndexRequest request = new IndexRequest(
  21.                     "mess",   //索引
  22.                     "_doc",     // mapping type
  23.                     "");     //文档id
  24.  
  25.             // 2、准备文档数据
  26.             // 方式一：直接给JSON串
  27.             String jsonString = "{" +
  28.                     "\"user\":\"kimchy\"," +
  29.                     "\"postDate\":\"2013-01-30\"," +
  30.                     "\"message\":\"trying out Elasticsearch\"" +
  31.                     "}";
  32.             request.source(jsonString, XContentType.JSON);
  33.  
  34.             // 方式二：以map对象来表示文档
  35.             /*
  36.             Map<String, Object> jsonMap = new HashMap<>();
  37.             jsonMap.put("user", "kimchy");
  38.             jsonMap.put("postDate", new Date());
  39.             jsonMap.put("message", "trying out Elasticsearch");
  40.             request.source(jsonMap);
  41.             */
  42.  
  43.             // 方式三：用XContentBuilder来构建文档
  44.             /*
  45.             XContentBuilder builder = XContentFactory.jsonBuilder();
  46.             builder.startObject();
  47.             {
  48.                 builder.field("user", "kimchy");
  49.                 builder.field("postDate", new Date());
  50.                 builder.field("message", "trying out Elasticsearch");
  51.             }
  52.             builder.endObject();
  53.             request.source(builder);
  54.             */
  55.  
  56.             // 方式四：直接用key-value对给出
  57.             /*
  58.             request.source("user", "kimchy",
  59.                             "postDate", new Date(),
  60.                             "message", "trying out Elasticsearch");
  61.             */
  62.  
  63.             //3、其他的一些可选设置
  64.             /*
  65.             request.routing("routing");  //设置routing值
  66.             request.timeout(TimeValue.timeValueSeconds(1));  //设置主分片等待时长
  67.             request.setRefreshPolicy("wait_for");  //设置重刷新策略
  68.             request.version(2);  //设置版本号
  69.             request.opType(DocWriteRequest.OpType.CREATE);  //操作类别
  70.             */
  71.  
  72.             //4、发送请求
  73.             IndexResponse indexResponse = null;
  74.             try {
  75.                 // 同步方式
  76.                 indexResponse = client.index(request);
  77.             } catch(ElasticsearchException e) {
  78.                 // 捕获，并处理异常
  79.                 //判断是否版本冲突、create但文档已存在冲突
  80.                 if (e.status() == RestStatus.CONFLICT) {
  81.                     logger.error("冲突了，请在此写冲突处理逻辑！\n" + e.getDetailedMessage());
  82.                 }
  83.  
  84.                 logger.error("索引异常", e);
  85.             }
  86.  
  87.             //5、处理响应
  88.             if(indexResponse != null) {
  89.                 String index = indexResponse.getIndex();
  90.                 String type = indexResponse.getType();
  91.                 String id = indexResponse.getId();
  92.                 long version = indexResponse.getVersion();
  93.                 if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
  94.                     System.out.println("新增文档成功!");
  95.                 } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
  96.                     System.out.println("修改文档成功!");
  97.                 }
  98.                 // 分片处理信息
  99.                 ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
  100.                 if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
  101.  
  102.                 }
  103.                 // 如果有分片副本失败，可以获得失败原因信息
  104.                 if (shardInfo.getFailed() > ) {
  105.                     for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
  106.                         String reason = failure.reason();
  107.                         System.out.println("副本失败原因：" + reason);
  108.                     }
  109.                 }
  110.             }
  111.  
  112.             //异步方式发送索引请求
  113.             /*ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() {
  114.                 @Override
  115.                 public void onResponse(IndexResponse indexResponse) {
  116.  
  117.                 }
  118.  
  119.                 @Override
  120.                 public void onFailure(Exception e) {
  121.  
  122.                 }
  123.             };
  124.             client.indexAsync(request, listener);
  125.             */
  126.  
  127.         }catch (Exception e){
  128.             e.printStackTrace();
  129.         }
  130.     }
  131.  
  132. }

结果：

  1. 新增文档成功!

官方文档：API

3. get  document

  1. package com.es.demo;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.ElasticsearchException;
  6. import org.elasticsearch.action.get.GetRequest;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.client.RestHighLevelClient;
  9. import org.elasticsearch.common.Strings;
  10. import org.elasticsearch.rest.RestStatus;
  11. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  12.  
  13. import java.io.IOException;
  14. import java.util.Map;
  15.  
  16. public class GetDocumentDemo {
  17.     private static Logger logger = LogManager.getRootLogger();
  18.  
  19.     public static void main(String[] args) {
  20.         try (RestHighLevelClient client = InitClient.getClient();) {
  21.             // 1、创建获取文档请求
  22.             GetRequest request = new GetRequest(
  23.                     "book13",   //索引
  24.                     "_doc",     // mapping type
  25.                     "");     //文档id
  26.  
  27.             // 2、可选的设置
  28.             //request.routing("routing");
  29.             //request.version(2);
  30.  
  31.             //request.fetchSourceContext(new FetchSourceContext(false)); //是否获取_source字段
  32.             //选择返回的字段
  33.             String[] includes = new String[]{"message", "*Date","user"};
  34.             String[] excludes = Strings.EMPTY_ARRAY;
  35.             FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
  36.             request.fetchSourceContext(fetchSourceContext);
  37.  
  38.             // 取stored字段
  39.             /*request.storedFields("message");
  40.             GetResponse getResponse = client.get(request);
  41.             String message = getResponse.getField("message").getValue();*/
  42.  
  43.             //3、发送请求
  44.             GetResponse getResponse = null;
  45.             try {
  46.                 // 同步请求
  47.                 getResponse = client.get(request);
  48.             } catch (ElasticsearchException e) {
  49.                 if (e.status() == RestStatus.NOT_FOUND) {
  50.                     logger.error("没有找到该id的文档" );
  51.                 }
  52.                 if (e.status() == RestStatus.CONFLICT) {
  53.                     logger.error("获取时版本冲突了，请在此写冲突处理逻辑！" );
  54.                 }
  55.                 logger.error("获取文档异常", e);
  56.             }
  57.  
  58.             //4、处理响应
  59.             if(getResponse != null) {
  60.                 String index = getResponse.getIndex();
  61.                 String type = getResponse.getType();
  62.                 String id = getResponse.getId();
  63.                 if (getResponse.isExists()) { // 文档存在
  64.                     long version = getResponse.getVersion();
  65.                     String sourceAsString = getResponse.getSourceAsString(); //结果取成 String
  66.                     Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();  // 结果取成Map
  67.                     byte[] sourceAsBytes = getResponse.getSourceAsBytes();    //结果取成字节数组
  68.  
  69.                     logger.info("index:" + index + "  type:" + type + "  id:" + id);
  70.                     logger.info(sourceAsString);
  71.  
  72.                 } else {
  73.                     logger.error("没有找到该id的文档" );
  74.                 }
  75.             }
  76.  
  77.             //异步方式发送获取文档请求
  78.             /*
  79.             ActionListener<GetResponse> listener = new ActionListener<GetResponse>() {
  80.                 @Override
  81.                 public void onResponse(GetResponse getResponse) {
  82.  
  83.                 }
  84.  
  85.                 @Override
  86.                 public void onFailure(Exception e) {
  87.  
  88.                 }
  89.             };
  90.             client.getAsync(request, listener);
  91.             */
  92.  
  93.         } catch (IOException e) {
  94.             e.printStackTrace();
  95.         }
  96.     }
  97.  
  98. }

结果：

  1. ::40.943 [main] INFO   - index:book13  type:_doc  id:
  2. ::40.943 [main] INFO   - {"postDate":"2013-01-30","message":"trying out Elasticsearch","user":"kimchy"}

4. Bulk

批量索引文档，即批量往索引里面放入文档数据.类似于数据库里面批量向表里面插入多行数据，一行数据就是一个文档

BulkDemo.java

  1. package com.es.demo;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.action.DocWriteRequest;
  6. import org.elasticsearch.action.DocWriteResponse;
  7. import org.elasticsearch.action.bulk.BulkItemResponse;
  8. import org.elasticsearch.action.bulk.BulkRequest;
  9. import org.elasticsearch.action.bulk.BulkResponse;
  10. import org.elasticsearch.action.delete.DeleteResponse;
  11. import org.elasticsearch.action.index.IndexRequest;
  12. import org.elasticsearch.action.index.IndexResponse;
  13. import org.elasticsearch.action.update.UpdateResponse;
  14. import org.elasticsearch.client.RestHighLevelClient;
  15. import org.elasticsearch.common.xcontent.XContentType;
  16.  
  17. import java.io.IOException;
  18. import java.util.Date;
  19.  
  20. public class BulkDemo {
  21.     private static Logger logger = LogManager.getRootLogger();
  22.  
  23.     public static void main(String[] args) {
  24.         try (RestHighLevelClient client = InitClient.getClient();) {
  25.  
  26.             // 1、创建批量操作请求参数
  27.             BulkRequest request = new BulkRequest();
  28.             request.add(new IndexRequest("book13", "_doc", "")
  29.                     .source(XContentType.JSON,"postDate", new Date()));
  30.             request.add(new IndexRequest("book13", "_doc", "")
  31.                     .source(XContentType.JSON,"user", "liming"));
  32.             request.add(new IndexRequest("book13", "_doc", "")
  33.                     .source(XContentType.JSON,"message", "add a doc"));
  34.  
  35.             /*
  36.             request.add(new DeleteRequest("mess", "_doc", "3"));
  37.             request.add(new UpdateRequest("mess", "_doc", "2")
  38.                     .doc(XContentType.JSON,"other", "test"));
  39.             request.add(new IndexRequest("mess", "_doc", "4")
  40.                     .source(XContentType.JSON,"field", "baz"));
  41.             */
  42.  
  43.             // 2、可选的设置
  44.             /*
  45.             request.timeout("2m");
  46.             request.setRefreshPolicy("wait_for");
  47.             request.waitForActiveShards(2);
  48.             */
  49.  
  50.             //3、发送请求
  51.  
  52.             // 同步请求
  53.             BulkResponse bulkResponse = client.bulk(request);
  54.  
  55.             //4、处理响应
  56.             if(bulkResponse != null) {
  57.                 for (BulkItemResponse bulkItemResponse : bulkResponse) {
  58.                     DocWriteResponse itemResponse = bulkItemResponse.getResponse();
  59.  
  60.                     if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX
  61.                             || bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE) {
  62.                         IndexResponse indexResponse = (IndexResponse) itemResponse;
  63.                         //TODO 新增成功的处理
  64.                         logger.info("新增成功");
  65.  
  66.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
  67.                         UpdateResponse updateResponse = (UpdateResponse) itemResponse;
  68.                         //TODO 修改成功的处理
  69.                         logger.info("修改成功");
  70.  
  71.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
  72.                         DeleteResponse deleteResponse = (DeleteResponse) itemResponse;
  73.                         //TODO 删除成功的处理
  74.                         logger.info("删除成功");
  75.                     }
  76.                 }
  77.             }
  78.  
  79.             //异步方式发送批量操作请求
  80.             /*
  81.             ActionListener<BulkResponse> listener = new ActionListener<BulkResponse>() {
  82.                 @Override
  83.                 public void onResponse(BulkResponse bulkResponse) {
  84.  
  85.                 }
  86.  
  87.                 @Override
  88.                 public void onFailure(Exception e) {
  89.  
  90.                 }
  91.             };
  92.             client.bulkAsync(request, listener);
  93.             */
  94.  
  95.         } catch (IOException e) {
  96.             e.printStackTrace();
  97.         }
  98.     }
  99.  
  100. }

结果：

  1. ::41.726 [main] INFO   - 新增成功
  2. ::41.730 [main] INFO   - 新增成功
  3. ::41.730 [main] INFO   - 新增成功

重复运行多次，并没有返回修改成功，也是新增成功，这可能是个bug，实际上第一次以后运行都是修改操作了。

  1. package com.es.demo;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.action.DocWriteRequest;
  6. import org.elasticsearch.action.DocWriteResponse;
  7. import org.elasticsearch.action.bulk.BulkItemResponse;
  8. import org.elasticsearch.action.bulk.BulkRequest;
  9. import org.elasticsearch.action.bulk.BulkResponse;
  10. import org.elasticsearch.action.delete.DeleteResponse;
  11. import org.elasticsearch.action.index.IndexRequest;
  12. import org.elasticsearch.action.index.IndexResponse;
  13. import org.elasticsearch.action.update.UpdateResponse;
  14. import org.elasticsearch.client.RestHighLevelClient;
  15. import org.elasticsearch.common.xcontent.XContentType;
  16.  
  17. import java.io.IOException;
  18. import java.util.Date;
  19.  
  20. public class BulkDemo {
  21.     private static Logger logger = LogManager.getRootLogger();
  22.  
  23.     public static void main(String[] args) {
  24.         try (RestHighLevelClient client = InitClient.getClient();) {
  25.  
  26.             // 1、创建批量操作请求参数
  27.             BulkRequest request = new BulkRequest();
  28.             request.add(new IndexRequest("book13", "_doc", "")
  29.                     .source(XContentType.JSON,"postDate", new Date()));
  30.             request.add(new IndexRequest("book13", "_doc", "")
  31.                     .source(XContentType.JSON,"user", "liming"));
  32.             request.add(new IndexRequest("book13", "_doc", "")
  33.                     .source(XContentType.JSON,"message", "add a doc"));
  34.  
  35.             /*
  36.             request.add(new DeleteRequest("mess", "_doc", "3"));
  37.             request.add(new UpdateRequest("mess", "_doc", "2")
  38.                     .doc(XContentType.JSON,"other", "test"));
  39.             request.add(new IndexRequest("mess", "_doc", "4")
  40.                     .source(XContentType.JSON,"field", "baz"));
  41.             */
  42.  
  43.             // 2、可选的设置
  44.             /*
  45.             request.timeout("2m");
  46.             request.setRefreshPolicy("wait_for");
  47.             request.waitForActiveShards(2);
  48.             */
  49.  
  50.             //3、发送请求
  51.  
  52.             // 同步请求
  53.             BulkResponse bulkResponse = client.bulk(request);
  54.  
  55.             //4、处理响应
  56.             if(bulkResponse != null) {
  57.                 for (BulkItemResponse bulkItemResponse : bulkResponse) {
  58.                     DocWriteResponse itemResponse = bulkItemResponse.getResponse();
  59.  
  60.                     if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX
  61.                             || bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE) {
  62.                         IndexResponse indexResponse = (IndexResponse) itemResponse;
  63.                         //TODO 新增成功的处理
  64.                         logger.info("新增成功,{}",indexResponse.toString());
  65.  
  66.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
  67.                         UpdateResponse updateResponse = (UpdateResponse) itemResponse;
  68.                         //TODO 修改成功的处理
  69.                         logger.info("修改成功,{}",updateResponse.toString());
  70.  
  71.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
  72.                         DeleteResponse deleteResponse = (DeleteResponse) itemResponse;
  73.                         //TODO 删除成功的处理
  74.                         logger.info("删除成功,{}",deleteResponse.toString());
  75.                     }
  76.                 }
  77.             }
  78.  
  79.             //异步方式发送批量操作请求
  80.             /*
  81.             ActionListener<BulkResponse> listener = new ActionListener<BulkResponse>() {
  82.                 @Override
  83.                 public void onResponse(BulkResponse bulkResponse) {
  84.  
  85.                 }
  86.  
  87.                 @Override
  88.                 public void onFailure(Exception e) {
  89.  
  90.                 }
  91.             };
  92.             client.bulkAsync(request, listener);
  93.             */
  94.  
  95.         } catch (IOException e) {
  96.             e.printStackTrace();
  97.         }
  98.     }
  99.  
  100. }

结果：

  1. ::44.095 [main] INFO   - 新增成功,IndexResponse[index=book13,type=_doc,id=,version=,result=updated,seqNo=,primaryTerm=,shards={"total":,"successful":,"failed":}]
  2. ::44.099 [main] INFO   - 新增成功,IndexResponse[index=book13,type=_doc,id=,version=,result=updated,seqNo=,primaryTerm=,shards={"total":,"successful":,"failed":}]
  3. ::44.099 [main] INFO   - 新增成功,IndexResponse[index=book13,type=_doc,id=,version=,result=updated,seqNo=,primaryTerm=,shards={"total":,"successful":,"failed":}]

postMan对比查看结果：

  1. {
  2.     "took": ,
  3.     "timed_out": false,
  4.     "_shards": {
  5.         "total": ,
  6.         "successful": ,
  7.         "skipped": ,
  8.         "failed":
  9.     },
  10.     "hits": {
  11.         "total": ,
  12.         "max_score": ,
  13.         "hits": [
  14.             {
  15.                 "_index": "book13",
  16.                 "_type": "_doc",
  17.                 "_id": "",
  18.                 "_score": ,
  19.                 "_source": {
  20.                     "postDate": "2018-09-09T12:25:41.302Z"
  21.                 }
  22.             },
  23.             {
  24.                 "_index": "book13",
  25.                 "_type": "_doc",
  26.                 "_id": "",
  27.                 "_score": ,
  28.                 "_source": {
  29.                     "user": "liming"
  30.                 }
  31.             },
  32.             {
  33.                 "_index": "book13",
  34.                 "_type": "_doc",
  35.                 "_id": "",
  36.                 "_score": ,
  37.                 "_source": {
  38.                     "message": "add a doc"
  39.                 }
  40.             }
  41.         ]
  42.     }
  43. }

5. search

搜索数据

SearchDemo.java

  1. package com.es.demo;
  2.  
  3. import java.io.IOException;
  4. import java.util.Map;
  5. import java.util.concurrent.TimeUnit;
  6.  
  7. import org.apache.logging.log4j.LogManager;
  8. import org.apache.logging.log4j.Logger;
  9. import org.elasticsearch.action.search.SearchRequest;
  10. import org.elasticsearch.action.search.SearchResponse;
  11. import org.elasticsearch.action.search.ShardSearchFailure;
  12. import org.elasticsearch.client.RestHighLevelClient;
  13. import org.elasticsearch.common.unit.TimeValue;
  14. import org.elasticsearch.index.query.QueryBuilders;
  15. import org.elasticsearch.rest.RestStatus;
  16. import org.elasticsearch.search.SearchHit;
  17. import org.elasticsearch.search.SearchHits;
  18. import org.elasticsearch.search.builder.SearchSourceBuilder;
  19.  
  20. /**
  21.  *
  22.  * @Description: 搜索数据
  23.  * @author lgs
  24.  * @date 2018年6月23日
  25.  *
  26.  */
  27. public class SearchDemo {
  28.  
  29.     private static Logger logger = LogManager.getRootLogger();
  30.  
  31.     public static void main(String[] args) {
  32.         try (RestHighLevelClient client = InitClient.getClient();) {
  33.  
  34.             // 1、创建search请求
  35.             //SearchRequest searchRequest = new SearchRequest();
  36.             SearchRequest searchRequest = new SearchRequest("book13");
  37.             searchRequest.types("_doc");
  38.  
  39.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  40.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  41.  
  42.             //构造QueryBuilder
  43.             /*QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")
  44.                     .fuzziness(Fuzziness.AUTO)
  45.                     .prefixLength(3)
  46.                     .maxExpansions(10);
  47.             sourceBuilder.query(matchQueryBuilder);*/
  48.  
  49.             sourceBuilder.query(QueryBuilders.termQuery("user", "liming"));
  50.             sourceBuilder.from();
  51.             sourceBuilder.size();
  52.             sourceBuilder.timeout(new TimeValue(, TimeUnit.SECONDS));
  53.  
  54.             //是否返回_source字段
  55.             //sourceBuilder.fetchSource(false);
  56.  
  57.             //设置返回哪些字段
  58.             /*String[] includeFields = new String[] {"title", "user", "innerObject.*"};
  59.             String[] excludeFields = new String[] {"_type"};
  60.             sourceBuilder.fetchSource(includeFields, excludeFields);*/
  61.  
  62.             //指定排序
  63.             //sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
  64.             //sourceBuilder.sort(new FieldSortBuilder("_uid").order(SortOrder.ASC));
  65.  
  66.             // 设置返回 profile
  67.             //sourceBuilder.profile(true);
  68.  
  69.             //将请求体加入到请求中
  70.             searchRequest.source(sourceBuilder);
  71.  
  72.             // 可选的设置
  73.             //searchRequest.routing("routing");
  74.  
  75.             // 高亮设置
  76.             /*
  77.             HighlightBuilder highlightBuilder = new HighlightBuilder();
  78.             HighlightBuilder.Field highlightTitle =
  79.                     new HighlightBuilder.Field("title");
  80.             highlightTitle.highlighterType("unified");
  81.             highlightBuilder.field(highlightTitle);
  82.             HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");
  83.             highlightBuilder.field(highlightUser);
  84.             sourceBuilder.highlighter(highlightBuilder);*/
  85.  
  86.             //加入聚合
  87.             /*TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_company")
  88.                     .field("company.keyword");
  89.             aggregation.subAggregation(AggregationBuilders.avg("average_age")
  90.                     .field("age"));
  91.             sourceBuilder.aggregation(aggregation);*/
  92.  
  93.             //做查询建议
  94.             /*SuggestionBuilder termSuggestionBuilder =
  95.                     SuggestBuilders.termSuggestion("user").text("kmichy");
  96.                 SuggestBuilder suggestBuilder = new SuggestBuilder();
  97.                 suggestBuilder.addSuggestion("suggest_user", termSuggestionBuilder);
  98.             sourceBuilder.suggest(suggestBuilder);*/
  99.  
  100.             //3、发送请求
  101.             SearchResponse searchResponse = client.search(searchRequest);
  102.  
  103.             //4、处理响应
  104.             //搜索结果状态信息
  105.             RestStatus status = searchResponse.status();
  106.             TimeValue took = searchResponse.getTook();
  107.             Boolean terminatedEarly = searchResponse.isTerminatedEarly();
  108.             boolean timedOut = searchResponse.isTimedOut();
  109.  
  110.             //分片搜索情况
  111.             int totalShards = searchResponse.getTotalShards();
  112.             int successfulShards = searchResponse.getSuccessfulShards();
  113.             int failedShards = searchResponse.getFailedShards();
  114.             for (ShardSearchFailure failure : searchResponse.getShardFailures()) {
  115.                 // failures should be handled here
  116.             }
  117.  
  118.             //处理搜索命中文档结果
  119.             SearchHits hits = searchResponse.getHits();
  120.  
  121.             long totalHits = hits.getTotalHits();
  122.             float maxScore = hits.getMaxScore();
  123.  
  124.             SearchHit[] searchHits = hits.getHits();
  125.             for (SearchHit hit : searchHits) {
  126.                 // do something with the SearchHit
  127.  
  128.                 String index = hit.getIndex();
  129.                 String type = hit.getType();
  130.                 String id = hit.getId();
  131.                 float score = hit.getScore();
  132.  
  133.                 //取_source字段值
  134.                 String sourceAsString = hit.getSourceAsString(); //取成json串
  135.                 Map<String, Object> sourceAsMap = hit.getSourceAsMap(); // 取成map对象
  136.                 //从map中取字段值
  137.                 /*
  138.                 String documentTitle = (String) sourceAsMap.get("title");
  139.                 List<Object> users = (List<Object>) sourceAsMap.get("user");
  140.                 Map<String, Object> innerObject = (Map<String, Object>) sourceAsMap.get("innerObject");
  141.                 */
  142.                 logger.info("index:" + index + "  type:" + type + "  id:" + id);
  143.                 logger.info(sourceAsString);
  144.  
  145.                 //取高亮结果
  146.                 /*Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  147.                 HighlightField highlight = highlightFields.get("title");
  148.                 Text[] fragments = highlight.fragments();
  149.                 String fragmentString = fragments[0].string();*/
  150.             }
  151.  
  152.             // 获取聚合结果
  153.             /*
  154.             Aggregations aggregations = searchResponse.getAggregations();
  155.             Terms byCompanyAggregation = aggregations.get("by_company");
  156.             Bucket elasticBucket = byCompanyAggregation.getBucketByKey("Elastic");
  157.             Avg averageAge = elasticBucket.getAggregations().get("average_age");
  158.             double avg = averageAge.getValue();
  159.             */
  160.  
  161.             // 获取建议结果
  162.             /*Suggest suggest = searchResponse.getSuggest();
  163.             TermSuggestion termSuggestion = suggest.getSuggestion("suggest_user");
  164.             for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {
  165.                 for (TermSuggestion.Entry.Option option : entry) {
  166.                     String suggestText = option.getText().string();
  167.                 }
  168.             }
  169.             */
  170.  
  171.             //异步方式发送获查询请求
  172.             /*
  173.             ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {
  174.                 @Override
  175.                 public void onResponse(SearchResponse getResponse) {
  176.                     //结果获取
  177.                 }
  178.  
  179.                 @Override
  180.                 public void onFailure(Exception e) {
  181.                     //失败处理
  182.                 }
  183.             };
  184.             client.searchAsync(searchRequest, listener);
  185.             */
  186.  
  187.         } catch (IOException e) {
  188.             logger.error(e);
  189.         }
  190.     }
  191. }

结果：

  1. ::50.762 [main] INFO   - index:book13  type:_doc  id:
  2. ::50.766 [main] INFO   - {"user":"liming"}

6. highlight 高亮

HighlightDemo.java

  1. package com.es.demo;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.action.search.SearchRequest;
  6. import org.elasticsearch.action.search.SearchResponse;
  7. import org.elasticsearch.client.RestHighLevelClient;
  8. import org.elasticsearch.common.text.Text;
  9. import org.elasticsearch.index.query.QueryBuilder;
  10. import org.elasticsearch.index.query.QueryBuilders;
  11. import org.elasticsearch.rest.RestStatus;
  12. import org.elasticsearch.search.SearchHit;
  13. import org.elasticsearch.search.SearchHits;
  14. import org.elasticsearch.search.builder.SearchSourceBuilder;
  15. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  16. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
  17.  
  18. import java.io.IOException;
  19. import java.util.Map;
  20.  
  21. public class HighlightDemo {
  22.  
  23.     private static Logger logger = LogManager.getRootLogger();
  24.  
  25.     public static void main(String[] args) {
  26.         try (RestHighLevelClient client = InitClient.getClient();) {
  27.  
  28.             // 1、创建search请求
  29.             SearchRequest searchRequest = new SearchRequest("book1");
  30.  
  31.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  32.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  33.  
  34.             //构造QueryBuilder
  35.             QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "test");
  36.             sourceBuilder.query(matchQueryBuilder);
  37.  
  38.             //分页设置
  39.             /*sourceBuilder.from(0);
  40.             sourceBuilder.size(5); ;*/
  41.  
  42.             // 高亮设置
  43.             HighlightBuilder highlightBuilder = new HighlightBuilder();
  44.             highlightBuilder.requireFieldMatch(false).field("name").field("age")
  45.                     .preTags("<strong>").postTags("</strong>");
  46.             //不同字段可有不同设置，如不同标签
  47.             /*HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title");
  48.             highlightTitle.preTags("<strong>").postTags("</strong>");
  49.             highlightBuilder.field(highlightTitle);
  50.             HighlightBuilder.Field highlightContent = new HighlightBuilder.Field("content");
  51.             highlightContent.preTags("<b>").postTags("</b>");
  52.             highlightBuilder.field(highlightContent).requireFieldMatch(false);*/
  53.  
  54.             sourceBuilder.highlighter(highlightBuilder);
  55.  
  56.             searchRequest.source(sourceBuilder);
  57.  
  58.             //3、发送请求
  59.             SearchResponse searchResponse = client.search(searchRequest);
  60.  
  61.             //4、处理响应
  62.             if (RestStatus.OK.equals(searchResponse.status())) {
  63.                 //处理搜索命中文档结果
  64.                 SearchHits hits = searchResponse.getHits();
  65.                 long totalHits = hits.getTotalHits();
  66.  
  67.                 SearchHit[] searchHits = hits.getHits();
  68.                 for (SearchHit hit : searchHits) {
  69.                     String index = hit.getIndex();
  70.                     String type = hit.getType();
  71.                     String id = hit.getId();
  72.                     float score = hit.getScore();
  73.  
  74.                     //取_source字段值
  75.                     //String sourceAsString = hit.getSourceAsString(); //取成json串
  76.                     Map<String, Object> sourceAsMap = hit.getSourceAsMap(); // 取成map对象
  77.                     //从map中取字段值
  78.                     /*String title = (String) sourceAsMap.get("title");
  79.                     String content  = (String) sourceAsMap.get("content"); */
  80.                     logger.info("index:" + index + "  type:" + type + "  id:" + id);
  81.                     logger.info("sourceMap : " + sourceAsMap);
  82.                     //取高亮结果
  83.                     Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  84.                     HighlightField highlight = highlightFields.get("name");
  85.                     if (highlight != null) {
  86.                         Text[] fragments = highlight.fragments();  //多值的字段会有多个值
  87.                         if (fragments != null) {
  88.                             String fragmentString = fragments[].string();
  89.                             logger.info("title highlight : " + fragmentString);
  90.                             //可用高亮字符串替换上面sourceAsMap中的对应字段返回到上一级调用
  91.                             //sourceAsMap.put("title", fragmentString);
  92.                         }
  93.                     }
  94.  
  95.                     highlight = highlightFields.get("age");
  96.                     if (highlight != null) {
  97.                         Text[] fragments = highlight.fragments();  //多值的字段会有多个值
  98.                         if (fragments != null) {
  99.                             String fragmentString = fragments[].string();
  100.                             logger.info("content highlight : " + fragmentString);
  101.                             //可用高亮字符串替换上面sourceAsMap中的对应字段返回到上一级调用
  102.                             //sourceAsMap.put("content", fragmentString);
  103.                         }
  104.                     }
  105.                 }
  106.             }
  107.  
  108.         } catch (IOException e) {
  109.             logger.error(e);
  110.         }
  111.     }
  112. }

结果：

  1. ::29.702 [main] INFO   - index:book1  type:english  id:5oVDQ2UBRzBxBrDgtIl0
  2. ::29.706 [main] INFO   - sourceMap : {name=test goog my money, addr=中国, class=dsfdsf, age=}
  3. ::29.706 [main] INFO   - title highlight : <strong>test</strong> goog my money
  4. ::29.706 [main] INFO   - index:book1  type:english  id:6IUkUmUBRzBxBrDgFok2
  5. ::29.710 [main] INFO   - sourceMap : {name=test goog my money, addr=中国, class=dsfdsf, age=[, , , ]}
  6. ::29.710 [main] INFO   - title highlight : <strong>test</strong> goog my money
  7. ::29.710 [main] INFO   - index:book1  type:english  id:
  8. ::29.710 [main] INFO   - sourceMap : {name=test, age=}
  9. ::29.710 [main] INFO   - title highlight : <strong>test</strong>
  10. ::29.710 [main] INFO   - index:book1  type:english  id:
  11. ::29.710 [main] INFO   - sourceMap : {name=test, age=}
  12. ::29.710 [main] INFO   - title highlight : <strong>test</strong>
  13. ::29.710 [main] INFO   - index:book1  type:english  id:54UiUmUBRzBxBrDgfIl9
  14. ::29.710 [main] INFO   - sourceMap : {name=test goog my money, addr=中国, class=dsfdsf, age=[, , ]}
  15. ::29.710 [main] INFO   - title highlight : <strong>test</strong> goog my money

7. suggest 查询建议

SuggestDemo.java（本demo只有单词纠错和前缀自动补全）

  1. package com.es.demo;
  2. import java.io.IOException;
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.Logger;
  5. import org.elasticsearch.action.search.SearchRequest;
  6. import org.elasticsearch.action.search.SearchResponse;
  7. import org.elasticsearch.client.RestHighLevelClient;
  8. import org.elasticsearch.rest.RestStatus;
  9. import org.elasticsearch.search.builder.SearchSourceBuilder;
  10. import org.elasticsearch.search.suggest.Suggest;
  11. import org.elasticsearch.search.suggest.SuggestBuilder;
  12. import org.elasticsearch.search.suggest.SuggestBuilders;
  13. import org.elasticsearch.search.suggest.SuggestionBuilder;
  14. import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
  15. import org.elasticsearch.search.suggest.term.TermSuggestion;
  16.  
  17. /**
  18.  *
  19.  * @Description: 查询建议
  20.  * @author lgs
  21.  * @date 2018年6月23日
  22.  *
  23.  */
  24. public class SuggestDemo {
  25.  
  26.     private static Logger logger = LogManager.getRootLogger();
  27.  
  28.     //词项建议拼写检查，检查用户的拼写是否错误，如果有错给用户推荐正确的词，appel->apple
  29.     public static void termSuggest() {
  30.         try (RestHighLevelClient client = InitClient.getClient();) {
  31.  
  32.             // 1、创建search请求
  33.             //SearchRequest searchRequest = new SearchRequest();
  34.             SearchRequest searchRequest = new SearchRequest("book1");
  35.  
  36.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  37.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  38.  
  39.             sourceBuilder.size();
  40.  
  41.             //做查询建议
  42.             //词项建议
  43.             SuggestionBuilder termSuggestionBuilder =
  44.                     SuggestBuilders.termSuggestion("name").text("text");
  45.             SuggestBuilder suggestBuilder = new SuggestBuilder();
  46.             suggestBuilder.addSuggestion("suggest_user", termSuggestionBuilder);
  47.             sourceBuilder.suggest(suggestBuilder);
  48.  
  49.             searchRequest.source(sourceBuilder);
  50.  
  51.             //3、发送请求
  52.             SearchResponse searchResponse = client.search(searchRequest);
  53.  
  54.             //4、处理响应
  55.             //搜索结果状态信息
  56.             if(RestStatus.OK.equals(searchResponse.status())) {
  57.                 // 获取建议结果
  58.                 Suggest suggest = searchResponse.getSuggest();
  59.                 TermSuggestion termSuggestion = suggest.getSuggestion("suggest_user");
  60.                 for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {
  61.                     logger.info("text: " + entry.getText().string());
  62.                     for (TermSuggestion.Entry.Option option : entry) {
  63.                         String suggestText = option.getText().string();
  64.                         logger.info("   suggest option : " + suggestText);
  65.                     }
  66.                 }
  67.             }
  68.             /*
  69.               "suggest": {
  70.                 "my-suggestion": [
  71.                   {
  72.                     "text": "tring",
  73.                     "offset": 0,
  74.                     "length": 5,
  75.                     "options": [
  76.                       {
  77.                         "text": "trying",
  78.                         "score": 0.8,
  79.                         "freq": 1
  80.                       }
  81.                     ]
  82.                   },
  83.                   {
  84.                     "text": "out",
  85.                     "offset": 6,
  86.                     "length": 3,
  87.                     "options": []
  88.                   },
  89.                   {
  90.                     "text": "elasticsearch",
  91.                     "offset": 10,
  92.                     "length": 13,
  93.                     "options": []
  94.                   }
  95.                 ]
  96.               }*/
  97.  
  98.         } catch (IOException e) {
  99.             logger.error(e);
  100.         }
  101.     }
  102.  
  103.     //自动补全，根据用户的输入联想到可能的词或者短语
  104.     public static void completionSuggester() {
  105.         try (RestHighLevelClient client = InitClient.getClient();) {
  106.  
  107.             // 1、创建search请求
  108.             //SearchRequest searchRequest = new SearchRequest();
  109.             SearchRequest searchRequest = new SearchRequest("book5");
  110.  
  111.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  112.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  113.  
  114.             sourceBuilder.size();
  115.  
  116.             //做查询建议
  117.             //自动补全
  118.             /*POST music/_search?pretty
  119.                     {
  120.                         "suggest": {
  121.                             "song-suggest" : {
  122.                                 "prefix" : "lucene s",
  123.                                 "completion" : {
  124.                                     "field" : "suggest" ,
  125.                                     "skip_duplicates": true
  126.                                 }
  127.                             }
  128.                         }
  129.                     }*/
  130.  
  131.             SuggestionBuilder termSuggestionBuilder =
  132.                     SuggestBuilders.completionSuggestion("suggest").prefix("tes")
  133.                             .skipDuplicates(true);
  134.             SuggestBuilder suggestBuilder = new SuggestBuilder();
  135.             suggestBuilder.addSuggestion("song-suggest", termSuggestionBuilder);
  136.             sourceBuilder.suggest(suggestBuilder);
  137.  
  138.             searchRequest.source(sourceBuilder);
  139.  
  140.             //3、发送请求
  141.             SearchResponse searchResponse = client.search(searchRequest);
  142.  
  143.             //4、处理响应
  144.             //搜索结果状态信息
  145.             if(RestStatus.OK.equals(searchResponse.status())) {
  146.                 // 获取建议结果
  147.                 Suggest suggest = searchResponse.getSuggest();
  148.                 CompletionSuggestion termSuggestion = suggest.getSuggestion("song-suggest");
  149.                 for (CompletionSuggestion.Entry entry : termSuggestion.getEntries()) {
  150.                     logger.info("text: " + entry.getText().string());
  151.                     for (CompletionSuggestion.Entry.Option option : entry) {
  152.                         String suggestText = option.getText().string();
  153.                         logger.info("   suggest option : " + suggestText);
  154.                     }
  155.                 }
  156.             }
  157.  
  158.         } catch (IOException e) {
  159.             logger.error(e);
  160.         }
  161.     }
  162.  
  163.     public static void main(String[] args) {
  164.         termSuggest();
  165.  
  166.         logger.info("--------------------------------------");
  167.  
  168.         completionSuggester();
  169.     }
  170. }

结果：

  1. 21:24:40.416 [main] INFO   - text: text
  2. 21:24:40.420 [main] INFO   -    suggest option : test
  3. 21:24:40.420 [main] INFO   -    suggest option : term
  4. 21:24:40.420 [main] INFO   - --------------------------------------
  5. 21:24:40.624 [main] INFO   - text: tes
  6. 21:24:40.624 [main] INFO   -    suggest option : test english
  7. 21:24:40.624 [main] INFO   -    suggest option : test my book1

8. aggregation 聚合分析

AggregationDemo.java

  1. package com.es.demo;
  2.  
  3. import java.io.IOException;
  4.  
  5. import org.apache.logging.log4j.LogManager;
  6. import org.apache.logging.log4j.Logger;
  7. import org.elasticsearch.action.search.SearchRequest;
  8. import org.elasticsearch.action.search.SearchResponse;
  9. import org.elasticsearch.client.RestHighLevelClient;
  10. import org.elasticsearch.rest.RestStatus;
  11. import org.elasticsearch.search.aggregations.AggregationBuilders;
  12. import org.elasticsearch.search.aggregations.Aggregations;
  13. import org.elasticsearch.search.aggregations.BucketOrder;
  14. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
  15. import org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket;
  16. import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
  17. import org.elasticsearch.search.aggregations.metrics.avg.Avg;
  18. import org.elasticsearch.search.builder.SearchSourceBuilder;
  19.  
  20. public class AggregationDemo {
  21.  
  22.     private static Logger logger = LogManager.getRootLogger();
  23.  
  24.     public static void main(String[] args) {
  25.         try (RestHighLevelClient client = InitClient.getClient();) {
  26.  
  27.             // 1、创建search请求
  28.             //SearchRequest searchRequest = new SearchRequest();
  29.             SearchRequest searchRequest = new SearchRequest("book1");
  30.  
  31.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  32.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  33.  
  34.             sourceBuilder.size();
  35.  
  36.             //加入聚合
  37.             //字段值项分组聚合
  38.             TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_age")
  39.                     .field("age").order(BucketOrder.aggregation("average_balance", true));
  40.             //计算每组的平均balance指标
  41.             aggregation.subAggregation(AggregationBuilders.avg("average_balance")
  42.                     .field("age"));
  43.             sourceBuilder.aggregation(aggregation);
  44.  
  45.             searchRequest.source(sourceBuilder);
  46.  
  47.             //3、发送请求
  48.             SearchResponse searchResponse = client.search(searchRequest);
  49.  
  50.             //4、处理响应
  51.             //搜索结果状态信息
  52.             if(RestStatus.OK.equals(searchResponse.status())) {
  53.                 // 获取聚合结果
  54.                 Aggregations aggregations = searchResponse.getAggregations();
  55.                 Terms byAgeAggregation = aggregations.get("by_age");
  56.                 logger.info("aggregation by_age 结果");
  57.                 logger.info("docCountError: " + byAgeAggregation.getDocCountError());
  58.                 logger.info("sumOfOtherDocCounts: " + byAgeAggregation.getSumOfOtherDocCounts());
  59.                 logger.info("------------------------------------");
  60.                 for(Bucket buck : byAgeAggregation.getBuckets()) {
  61.                     logger.info("key: " + buck.getKeyAsNumber());
  62.                     logger.info("docCount: " + buck.getDocCount());
  63.                     logger.info("docCountError: " + buck.getDocCountError());
  64.                     //取子聚合
  65.                     Avg averageBalance = buck.getAggregations().get("average_balance");
  66.  
  67.                     logger.info("average_balance: " + averageBalance.getValue());
  68.                     logger.info("------------------------------------");
  69.                 }
  70.                 //直接用key 来去分组
  71.                 /*Bucket elasticBucket = byCompanyAggregation.getBucketByKey("24");
  72.                 Avg averageAge = elasticBucket.getAggregations().get("average_age");
  73.                 double avg = averageAge.getValue();*/
  74.  
  75.             }
  76.  
  77.         } catch (IOException e) {
  78.             logger.error(e);
  79.         }
  80.     }
  81. }

结果：

  1. ::24.681 [main] INFO   - aggregation by_age 结果
  2. ::24.685 [main] INFO   - docCountError:
  3. ::24.685 [main] INFO   - sumOfOtherDocCounts:
  4. ::24.685 [main] INFO   - ------------------------------------
  5. ::24.685 [main] INFO   - key:
  6. ::24.685 [main] INFO   - docCount:
  7. ::24.685 [main] INFO   - docCountError:
  8. ::24.685 [main] INFO   - average_balance: 1.0
  9. ::24.685 [main] INFO   - ------------------------------------
  10. ::24.685 [main] INFO   - key:
  11. ::24.685 [main] INFO   - docCount:
  12. ::24.685 [main] INFO   - docCountError:
  13. ::24.685 [main] INFO   - average_balance: 12.0
  14. ::24.685 [main] INFO   - ------------------------------------
  15. ::24.685 [main] INFO   - key:
  16. ::24.685 [main] INFO   - docCount:
  17. ::24.689 [main] INFO   - docCountError:
  18. ::24.689 [main] INFO   - average_balance: 12.666666666666666
  19. ::24.689 [main] INFO   - ------------------------------------
  20. ::24.689 [main] INFO   - key:
  21. ::24.689 [main] INFO   - docCount:
  22. ::24.689 [main] INFO   - docCountError:
  23. ::24.689 [main] INFO   - average_balance: 12.75
  24. ::24.689 [main] INFO   - ------------------------------------
  25. ::24.689 [main] INFO   - key:
  26. ::24.689 [main] INFO   - docCount:
  27. ::24.689 [main] INFO   - docCountError:
  28. ::24.689 [main] INFO   - average_balance: 16.0
  29. ::24.689 [main] INFO   - ------------------------------------
  30. ::24.689 [main] INFO   - key:
  31. ::24.689 [main] INFO   - docCount:
  32. ::24.689 [main] INFO   - docCountError:
  33. ::24.689 [main] INFO   - average_balance: 21.0
  34. ::24.689 [main] INFO   - ------------------------------------
  35. ::24.689 [main] INFO   - key:
  36. ::24.689 [main] INFO   - docCount:
  37. ::24.689 [main] INFO   - docCountError:
  38. ::24.689 [main] INFO   - average_balance: 26.428571428571427
  39. ::24.689 [main] INFO   - ------------------------------------
  40. ::24.689 [main] INFO   - key:
  41. ::24.689 [main] INFO   - docCount:
  42. ::24.689 [main] INFO   - docCountError:
  43. ::24.689 [main] INFO   - average_balance: 33.0
  44. ::24.689 [main] INFO   - ------------------------------------
  45. ::24.689 [main] INFO   - key:
  46. ::24.689 [main] INFO   - docCount:
  47. ::24.689 [main] INFO   - docCountError:
  48. ::24.689 [main] INFO   - average_balance: 36.75
  49. ::24.689 [main] INFO   - ------------------------------------
  50. ::24.689 [main] INFO   - key:
  51. ::24.689 [main] INFO   - docCount:
  52. ::24.689 [main] INFO   - docCountError:
  53. ::24.689 [main] INFO   - average_balance: 36.75
  54. ::24.689 [main] INFO   - ------------------------------------

9. 官网资料

各种查询对应的QueryBuilder：

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-query-builders.html

各种聚合对应的AggregationBuilder：

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-aggregation-builders.html

10.源码

https://github.com/Star-Lordxing/ES-java-client-api

五、Java Client

1. Java Client 说明

java client 使用 TransportClient，各种操作本质上都是异步的(可以用 listener，或返回 Future ）。
注意：ES的发展规划中在7.0版本开始将废弃 TransportClient，8.0版本中将完全移除 TransportClient，取而代之的是High Level REST Client。
High Level REST Client 中的操作API和java client 大多是一样的，除了连接方式InitClient代码不一样。

2. 官方学习链接

https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/index.html

3. 兼容性说明

请使用与服务端ES版本一致的客户端版本

4. Java Client maven 集成

  1.         <dependency>
  2.             <groupId>org.elasticsearch.client</groupId>
  3.             <artifactId>transport</artifactId>
  4.             <version>6.3.</version>
  5.         </dependency>
  6.         <!--日志-->
  7.         <dependency>
  8.             <groupId>org.apache.logging.log4j</groupId>
  9.             <artifactId>log4j-api</artifactId>
  10.             <version>2.11.</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.apache.logging.log4j</groupId>
  14.             <artifactId>log4j-core</artifactId>
  15.             <version>2.11.</version>
  16.         </dependency>

5.将log4j2.xml编译到classes路径下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration status="OFF">
  3.     <appenders>
  4.         <Console name="Console" target="SYSTEM_OUT">
  5.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
  6.         </Console>
  7.     </appenders>
  8.     <loggers>
  9.         <root level="info">
  10.             <appender-ref ref="Console"/>
  11.         </root>
  12.     </loggers>
  13. </configuration>

六.Transport API使用示例

1.创建连接InitClient.java

  1. package com.es.demo;
  2.  
  3. import org.elasticsearch.client.transport.TransportClient;
  4. import org.elasticsearch.common.settings.Settings;
  5. import org.elasticsearch.common.transport.TransportAddress;
  6. import org.elasticsearch.transport.client.PreBuiltTransportClient;
  7.  
  8. import java.net.InetAddress;
  9. import java.net.UnknownHostException;
  10.  
  11. public class InitClient {
  12.  
  13.     private static TransportClient client;
  14.  
  15.     public static TransportClient getClient() throws UnknownHostException {
  16.  
  17.         if(client == null) {
  18.             //client = new PreBuiltTransportClient(Settings.EMPTY)
  19.  
  20.             // 连接集群的设置
  21.             Settings settings = Settings.builder()
  22.                     .put("cluster.name", "my-application") //如果集群的名字不是默认的elasticsearch，需指定
  23.                     .put("client.transport.sniff", false) //自动嗅探
  24.                     .build();
  25.             client = new PreBuiltTransportClient(settings)
  26.                     //.addTransportAddress(new TransportAddress(InetAddress.getByName("localhost"), 9300));
  27.                     .addTransportAddress(new TransportAddress(InetAddress.getByName("start.com"), ));
  28.  
  29.             //可用连接设置参数说明
  30.             /*
  31.             cluster.name
  32.                 指定集群的名字，如果集群的名字不是默认的elasticsearch，需指定。
  33.             client.transport.sniff
  34.                 设置为true,将自动嗅探整个集群，自动加入集群的节点到连接列表中。
  35.             client.transport.ignore_cluster_name
  36.                 Set to true to ignore cluster name validation of connected nodes. (since 0.19.4)
  37.             client.transport.ping_timeout
  38.                 The time to wait for a ping response from a node. Defaults to 5s.
  39.             client.transport.nodes_sampler_interval
  40.                 How often to sample / ping the nodes listed and connected. Defaults to 5s.
  41.             */
  42.  
  43.         }
  44.         return client;
  45.     }
  46.  
  47. }

client.transport.sniff:false //自动嗅探 ，我本机单节点设置为true会报错。

1. Create index 创建索引

CreateIndexDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.ExecutionException;
  5.  
  6. import org.elasticsearch.action.admin.indices.alias.Alias;
  7. import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
  8. import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
  9. import org.elasticsearch.client.transport.TransportClient;
  10. import org.elasticsearch.common.settings.Settings;
  11. import org.elasticsearch.common.xcontent.XContentType;
  12.  
  13. public class CreateIndexDemo {
  14.  
  15.     public static void main(String[] args) {
  16.         //这里和RESTful风格不同
  17.         try (TransportClient client = InitDemo.getClient();) {
  18.  
  19.             // 1、创建 创建索引request
  20.             CreateIndexRequest request = new CreateIndexRequest("mess");
  21.  
  22.             // 2、设置索引的settings
  23.             request.settings(Settings.builder().put("index.number_of_shards", 3) // 分片数
  24.                     .put("index.number_of_replicas", 2) // 副本数
  25.                     .put("analysis.analyzer.default.tokenizer", "ik_smart") // 默认分词器
  26.             );
  27.  
  28.             // 3、设置索引的mappings
  29.             request.mapping("_doc",
  30.                     "  {\n" +
  31.                     "    \"_doc\": {\n" +
  32.                     "      \"properties\": {\n" +
  33.                     "        \"message\": {\n" +
  34.                     "          \"type\": \"text\"\n" +
  35.                     "        }\n" +
  36.                     "      }\n" +
  37.                     "    }\n" +
  38.                     "  }",
  39.                     XContentType.JSON);
  40.  
  41.             // 4、 设置索引的别名
  42.             request.alias(new Alias("mmm"));
  43.  
  44.             // 5、 发送请求 这里和RESTful风格不同
  45.             CreateIndexResponse createIndexResponse = client.admin().indices()
  46.                     .create(request).get();
  47.  
  48.             // 6、处理响应
  49.             boolean acknowledged = createIndexResponse.isAcknowledged();
  50.             boolean shardsAcknowledged = createIndexResponse
  51.                     .isShardsAcknowledged();
  52.             System.out.println("acknowledged = " + acknowledged);
  53.             System.out.println("shardsAcknowledged = " + shardsAcknowledged);
  54.  
  55.             // listener方式发送请求
  56.             /*ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
  57.                 @Override
  58.                 public void onResponse(
  59.                         CreateIndexResponse createIndexResponse) {
  60.                     // 6、处理响应
  61.                     boolean acknowledged = createIndexResponse.isAcknowledged();
  62.                     boolean shardsAcknowledged = createIndexResponse
  63.                             .isShardsAcknowledged();
  64.                     System.out.println("acknowledged = " + acknowledged);
  65.                     System.out.println(
  66.                             "shardsAcknowledged = " + shardsAcknowledged);
  67.                 }
  68.  
  69.                 @Override
  70.                 public void onFailure(Exception e) {
  71.                     System.out.println("创建索引异常：" + e.getMessage());
  72.                 }
  73.             };
  74.             client.admin().indices().create(request, listener);
  75.             */
  76.         } catch (IOException | InterruptedException | ExecutionException e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  80. }

2. index document

索引文档，即往索引里面放入文档数据.类似于数据库里面向表里面插入一行数据，一行数据就是一个文档
IndexDocumentDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.ExecutionException;
  5.  
  6. import org.apache.logging.log4j.LogManager;
  7. import org.apache.logging.log4j.Logger;
  8. import org.elasticsearch.ElasticsearchException;
  9. import org.elasticsearch.action.DocWriteResponse;
  10. import org.elasticsearch.action.index.IndexRequest;
  11. import org.elasticsearch.action.index.IndexResponse;
  12. import org.elasticsearch.action.support.replication.ReplicationResponse;
  13. import org.elasticsearch.client.transport.TransportClient;
  14. import org.elasticsearch.common.xcontent.XContentType;
  15. import org.elasticsearch.rest.RestStatus;
  16.  
  17. public class IndexDocumentDemo {
  18.  
  19.     private static Logger logger = LogManager.getRootLogger();  
  20.  
  21.     public static void main(String[] args) {
  22.         //这里和RESTful风格不同
  23.         try (TransportClient client = InitDemo.getClient();) {
  24.             // 1、创建索引请求
  25.             IndexRequest request = new IndexRequest(
  26.                     "mess",   //索引
  27.                     "_doc",     // mapping type
  28.                     "11");     //文档id  
  29.  
  30.             // 2、准备文档数据
  31.             // 方式一：直接给JSON串
  32.             String jsonString = "{" +
  33.                     "\"user\":\"kimchy\"," +
  34.                     "\"postDate\":\"2013-01-30\"," +
  35.                     "\"message\":\"trying out Elasticsearch\"" +
  36.                     "}";
  37.             request.source(jsonString, XContentType.JSON); 
  38.  
  39.             // 方式二：以map对象来表示文档
  40.             /*
  41.             Map<String, Object> jsonMap = new HashMap<>();
  42.             jsonMap.put("user", "kimchy");
  43.             jsonMap.put("postDate", new Date());
  44.             jsonMap.put("message", "trying out Elasticsearch");
  45.             request.source(jsonMap);
  46.             */
  47.  
  48.             // 方式三：用XContentBuilder来构建文档
  49.             /*
  50.             XContentBuilder builder = XContentFactory.jsonBuilder();
  51.             builder.startObject();
  52.             {
  53.                 builder.field("user", "kimchy");
  54.                 builder.field("postDate", new Date());
  55.                 builder.field("message", "trying out Elasticsearch");
  56.             }
  57.             builder.endObject();
  58.             request.source(builder);
  59.             */
  60.  
  61.             // 方式四：直接用key-value对给出
  62.             /*
  63.             request.source("user", "kimchy",
  64.                             "postDate", new Date(),
  65.                             "message", "trying out Elasticsearch");
  66.             */
  67.  
  68.             //3、其他的一些可选设置
  69.             /*
  70.             request.routing("routing");  //设置routing值
  71.             request.timeout(TimeValue.timeValueSeconds(1));  //设置主分片等待时长
  72.             request.setRefreshPolicy("wait_for");  //设置重刷新策略
  73.             request.version(2);  //设置版本号
  74.             request.opType(DocWriteRequest.OpType.CREATE);  //操作类别
  75.             */
  76.  
  77.             //4、发送请求
  78.             IndexResponse indexResponse = null;
  79.             try {
  80.                 //方式一： 用client.index 方法，返回是 ActionFuture<IndexResponse>，再调用get获取响应结果
  81.                 indexResponse = client.index(request).get();
  82.  
  83.                 //方式二：client提供了一个 prepareIndex方法，内部为我们创建IndexRequest
  84.                 /*IndexResponse indexResponse = client.prepareIndex("mess","_doc","11")
  85.                         .setSource(jsonString, XContentType.JSON)
  86.                         .get();*/
  87.  
  88.                 //方式三：request + listener
  89.                 //client.index(request, listener);    
  90.  
  91.             } catch(ElasticsearchException e) {
  92.                 // 捕获，并处理异常
  93.                 //判断是否版本冲突、create但文档已存在冲突
  94.                 if (e.status() == RestStatus.CONFLICT) {
  95.                     logger.error("冲突了，请在此写冲突处理逻辑！\n" + e.getDetailedMessage());
  96.                 }
  97.  
  98.                 logger.error("索引异常", e);
  99.             }catch (InterruptedException | ExecutionException e) {
  100.                 logger.error("索引异常", e);
  101.             }
  102.  
  103.             //5、处理响应
  104.             if(indexResponse != null) {
  105.                 String index = indexResponse.getIndex();
  106.                 String type = indexResponse.getType();
  107.                 String id = indexResponse.getId();
  108.                 long version = indexResponse.getVersion();
  109.                 if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
  110.                     System.out.println("新增文档成功，处理逻辑代码写到这里。");
  111.                 } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
  112.                     System.out.println("修改文档成功，处理逻辑代码写到这里。");
  113.                 }
  114.                 // 分片处理信息
  115.                 ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
  116.                 if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
  117.  
  118.                 }
  119.                 // 如果有分片副本失败，可以获得失败原因信息
  120.                 if (shardInfo.getFailed() > 0) {
  121.                     for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
  122.                         String reason = failure.reason();
  123.                         System.out.println("副本失败原因：" + reason);
  124.                     }
  125.                 }
  126.             }
  127.  
  128.             //listener 方式
  129.             /*ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() {
  130.                 @Override
  131.                 public void onResponse(IndexResponse indexResponse) {
  132.  
  133.                 }
  134.  
  135.                 @Override
  136.                 public void onFailure(Exception e) {
  137.  
  138.                 }
  139.             };
  140.             client.index(request, listener);
  141.             */
  142.  
  143.         } catch (IOException e) {
  144.             e.printStackTrace();
  145.         }
  146.     }
  147. }

3. get document

获取文档数据
GetDocumentDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.Map;
  5. import java.util.concurrent.ExecutionException;
  6.  
  7. import org.apache.logging.log4j.LogManager;
  8. import org.apache.logging.log4j.Logger;
  9. import org.elasticsearch.ElasticsearchException;
  10. import org.elasticsearch.action.get.GetRequest;
  11. import org.elasticsearch.action.get.GetResponse;
  12. import org.elasticsearch.client.transport.TransportClient;
  13. import org.elasticsearch.common.Strings;
  14. import org.elasticsearch.rest.RestStatus;
  15. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  16.  
  17. public class GetDocumentDemo {
  18.  
  19.     private static Logger logger = LogManager.getRootLogger();  
  20.  
  21.     public static void main(String[] args) {
  22.         //这里和RESTful风格不同
  23.         try (TransportClient client = InitDemo.getClient();) {
  24.             // 1、创建获取文档请求
  25.             GetRequest request = new GetRequest(
  26.                     "mess",   //索引
  27.                     "_doc",     // mapping type
  28.                     "11");     //文档id  
  29.  
  30.             // 2、可选的设置
  31.             //request.routing("routing");
  32.             //request.version(2);
  33.  
  34.             //request.fetchSourceContext(new FetchSourceContext(false)); //是否获取_source字段
  35.             //选择返回的字段
  36.             String[] includes = new String[]{"message", "*Date"};
  37.             String[] excludes = Strings.EMPTY_ARRAY;
  38.             FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
  39.             request.fetchSourceContext(fetchSourceContext); 
  40.  
  41.             //也可写成这样
  42.             /*String[] includes = Strings.EMPTY_ARRAY;
  43.             String[] excludes = new String[]{"message"};
  44.             FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
  45.             request.fetchSourceContext(fetchSourceContext);*/
  46.  
  47.             // 取stored字段
  48.             /*request.storedFields("message");
  49.             GetResponse getResponse = client.get(request);
  50.             String message = getResponse.getField("message").getValue();*/
  51.  
  52.             //3、发送请求
  53.             GetResponse getResponse = null;
  54.             try {
  55.                 getResponse = client.get(request).get();
  56.             } catch (ElasticsearchException e) {
  57.                 if (e.status() == RestStatus.NOT_FOUND) {
  58.                     logger.error("没有找到该id的文档" );
  59.                 }
  60.                 if (e.status() == RestStatus.CONFLICT) {
  61.                     logger.error("获取时版本冲突了，请在此写冲突处理逻辑！" );
  62.                 }
  63.                 logger.error("获取文档异常", e);
  64.             }catch (InterruptedException | ExecutionException e) {
  65.                 logger.error("索引异常", e);
  66.             }
  67.  
  68.             //4、处理响应
  69.             if(getResponse != null) {
  70.                 String index = getResponse.getIndex();
  71.                 String type = getResponse.getType();
  72.                 String id = getResponse.getId();
  73.                 if (getResponse.isExists()) { // 文档存在
  74.                     long version = getResponse.getVersion();
  75.                     String sourceAsString = getResponse.getSourceAsString(); //结果取成 String
  76.                     Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();  // 结果取成Map
  77.                     byte[] sourceAsBytes = getResponse.getSourceAsBytes();    //结果取成字节数组
  78.  
  79.                     logger.info("index:" + index + "  type:" + type + "  id:" + id);
  80.                     logger.info(sourceAsString);
  81.  
  82.                 } else {
  83.                     logger.error("没有找到该id的文档" );
  84.                 }
  85.             }
  86.  
  87.             //异步方式发送获取文档请求
  88.             /*
  89.             ActionListener<GetResponse> listener = new ActionListener<GetResponse>() {
  90.                 @Override
  91.                 public void onResponse(GetResponse getResponse) {
  92.  
  93.                 }
  94.  
  95.                 @Override
  96.                 public void onFailure(Exception e) {
  97.  
  98.                 }
  99.             };
  100.             client.getAsync(request, listener);
  101.             */
  102.  
  103.         } catch (IOException e) {
  104.             e.printStackTrace();
  105.         }
  106.     }
  107. }

4. Bulk

批量索引文档，即批量往索引里面放入文档数据.类似于数据库里面批量向表里面插入多行数据，一行数据就是一个文档
BulkDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.ExecutionException;
  5.  
  6. import org.apache.logging.log4j.LogManager;
  7. import org.apache.logging.log4j.Logger;
  8. import org.elasticsearch.action.DocWriteRequest;
  9. import org.elasticsearch.action.DocWriteResponse;
  10. import org.elasticsearch.action.bulk.BulkItemResponse;
  11. import org.elasticsearch.action.bulk.BulkRequest;
  12. import org.elasticsearch.action.bulk.BulkResponse;
  13. import org.elasticsearch.action.delete.DeleteResponse;
  14. import org.elasticsearch.action.index.IndexRequest;
  15. import org.elasticsearch.action.index.IndexResponse;
  16. import org.elasticsearch.action.update.UpdateResponse;
  17. import org.elasticsearch.client.transport.TransportClient;
  18. import org.elasticsearch.common.xcontent.XContentType;
  19.  
  20. public class BulkDemo {
  21.  
  22.     private static Logger logger = LogManager.getRootLogger();  
  23.  
  24.     public static void main(String[] args) {
  25.         //这里和RESTful风格不同
  26.         try (TransportClient client = InitDemo.getClient();) {
  27.  
  28.             // 1、创建批量操作请求
  29.             BulkRequest request = new BulkRequest();
  30.             request.add(new IndexRequest("mess", "_doc", "1")
  31.                     .source(XContentType.JSON,"field", "foo"));
  32.             request.add(new IndexRequest("mess", "_doc", "2")
  33.                     .source(XContentType.JSON,"field", "bar"));
  34.             request.add(new IndexRequest("mess", "_doc", "3")
  35.                     .source(XContentType.JSON,"field", "baz"));
  36.  
  37.             /*
  38.             request.add(new DeleteRequest("mess", "_doc", "3"));
  39.             request.add(new UpdateRequest("mess", "_doc", "2")
  40.                     .doc(XContentType.JSON,"other", "test"));
  41.             request.add(new IndexRequest("mess", "_doc", "4")
  42.                     .source(XContentType.JSON,"field", "baz"));
  43.             */
  44.  
  45.             // 2、可选的设置
  46.             /*
  47.             request.timeout("2m");
  48.             request.setRefreshPolicy("wait_for");
  49.             request.waitForActiveShards(2);
  50.             */
  51.  
  52.             //3、发送请求        
  53.  
  54.             // 同步请求
  55.             BulkResponse bulkResponse = client.bulk(request).get();
  56.  
  57.             //4、处理响应
  58.             if(bulkResponse != null) {
  59.                 for (BulkItemResponse bulkItemResponse : bulkResponse) {
  60.                     DocWriteResponse itemResponse = bulkItemResponse.getResponse(); 
  61.  
  62.                     if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX
  63.                             || bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE) {
  64.                         IndexResponse indexResponse = (IndexResponse) itemResponse;
  65.                         //TODO 新增成功的处理
  66.  
  67.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
  68.                         UpdateResponse updateResponse = (UpdateResponse) itemResponse;
  69.                        //TODO 修改成功的处理
  70.  
  71.                     } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
  72.                         DeleteResponse deleteResponse = (DeleteResponse) itemResponse;
  73.                         //TODO 删除成功的处理
  74.                     }
  75.                 }
  76.             }
  77.  
  78.             //异步方式发送批量操作请求
  79.             /*
  80.             ActionListener<BulkResponse> listener = new ActionListener<BulkResponse>() {
  81.                 @Override
  82.                 public void onResponse(BulkResponse bulkResponse) {
  83.  
  84.                 }
  85.  
  86.                 @Override
  87.                 public void onFailure(Exception e) {
  88.  
  89.                 }
  90.             };
  91.             client.bulkAsync(request, listener);
  92.             */
  93.  
  94.         } catch (IOException | InterruptedException | ExecutionException e) {
  95.             e.printStackTrace();
  96.         }
  97.     }
  98. }

5. search

搜索数据
SearchDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.Map;
  5. import java.util.concurrent.ExecutionException;
  6. import java.util.concurrent.TimeUnit;
  7.  
  8. import org.apache.logging.log4j.LogManager;
  9. import org.apache.logging.log4j.Logger;
  10. import org.elasticsearch.action.search.SearchRequest;
  11. import org.elasticsearch.action.search.SearchResponse;
  12. import org.elasticsearch.action.search.ShardSearchFailure;
  13. import org.elasticsearch.client.transport.TransportClient;
  14. import org.elasticsearch.common.unit.TimeValue;
  15. import org.elasticsearch.index.query.QueryBuilders;
  16. import org.elasticsearch.rest.RestStatus;
  17. import org.elasticsearch.search.SearchHit;
  18. import org.elasticsearch.search.SearchHits;
  19. import org.elasticsearch.search.builder.SearchSourceBuilder;
  20.  
  21. public class SearchDemo {
  22.  
  23.     private static Logger logger = LogManager.getRootLogger();  
  24.  
  25.     public static void main(String[] args) {
  26.         try (TransportClient client = InitDemo.getClient();) {
  27.  
  28.             // 1、创建search请求
  29.             //SearchRequest searchRequest = new SearchRequest();
  30.             SearchRequest searchRequest = new SearchRequest("bank");
  31.             searchRequest.types("_doc");
  32.  
  33.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  34.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
  35.  
  36.             //构造QueryBuilder
  37.             /*QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")
  38.                     .fuzziness(Fuzziness.AUTO)
  39.                     .prefixLength(3)
  40.                     .maxExpansions(10);
  41.             sourceBuilder.query(matchQueryBuilder);*/
  42.  
  43.             sourceBuilder.query(QueryBuilders.termQuery("age", 24));
  44.             sourceBuilder.from(0);
  45.             sourceBuilder.size(10);
  46.             sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS)); 
  47.  
  48.             //是否返回_source字段
  49.             //sourceBuilder.fetchSource(false);
  50.  
  51.             //设置返回哪些字段
  52.             /*String[] includeFields = new String[] {"title", "user", "innerObject.*"};
  53.             String[] excludeFields = new String[] {"_type"};
  54.             sourceBuilder.fetchSource(includeFields, excludeFields);*/
  55.  
  56.             //指定排序
  57.             //sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
  58.             //sourceBuilder.sort(new FieldSortBuilder("_uid").order(SortOrder.ASC));
  59.  
  60.             // 设置返回 profile
  61.             //sourceBuilder.profile(true);
  62.  
  63.             //将请求体加入到请求中
  64.             searchRequest.source(sourceBuilder);
  65.  
  66.             // 可选的设置
  67.             //searchRequest.routing("routing");
  68.  
  69.             // 高亮设置
  70.             /*
  71.             HighlightBuilder highlightBuilder = new HighlightBuilder();
  72.             HighlightBuilder.Field highlightTitle =
  73.                     new HighlightBuilder.Field("title");
  74.             highlightTitle.highlighterType("unified");
  75.             highlightBuilder.field(highlightTitle);
  76.             HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");
  77.             highlightBuilder.field(highlightUser);
  78.             sourceBuilder.highlighter(highlightBuilder);*/
  79.  
  80.             //加入聚合
  81.             /*TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_company")
  82.                     .field("company.keyword");
  83.             aggregation.subAggregation(AggregationBuilders.avg("average_age")
  84.                     .field("age"));
  85.             sourceBuilder.aggregation(aggregation);*/
  86.  
  87.             //做查询建议
  88.             /*SuggestionBuilder termSuggestionBuilder =
  89.                     SuggestBuilders.termSuggestion("user").text("kmichy");
  90.                 SuggestBuilder suggestBuilder = new SuggestBuilder();
  91.                 suggestBuilder.addSuggestion("suggest_user", termSuggestionBuilder);
  92.             sourceBuilder.suggest(suggestBuilder);*/
  93.  
  94.             //3、发送请求
  95.             SearchResponse searchResponse = client.search(searchRequest).get();
  96.  
  97.             //4、处理响应
  98.             //搜索结果状态信息
  99.             RestStatus status = searchResponse.status();
  100.             TimeValue took = searchResponse.getTook();
  101.             Boolean terminatedEarly = searchResponse.isTerminatedEarly();
  102.             boolean timedOut = searchResponse.isTimedOut();
  103.  
  104.             //分片搜索情况
  105.             int totalShards = searchResponse.getTotalShards();
  106.             int successfulShards = searchResponse.getSuccessfulShards();
  107.             int failedShards = searchResponse.getFailedShards();
  108.             for (ShardSearchFailure failure : searchResponse.getShardFailures()) {
  109.                 // failures should be handled here
  110.             }
  111.  
  112.             //处理搜索命中文档结果
  113.             SearchHits hits = searchResponse.getHits();
  114.  
  115.             long totalHits = hits.getTotalHits();
  116.             float maxScore = hits.getMaxScore();
  117.  
  118.             SearchHit[] searchHits = hits.getHits();
  119.             for (SearchHit hit : searchHits) {
  120.                 // do something with the SearchHit
  121.  
  122.                 String index = hit.getIndex();
  123.                 String type = hit.getType();
  124.                 String id = hit.getId();
  125.                 float score = hit.getScore();
  126.  
  127.                 //取_source字段值
  128.                 String sourceAsString = hit.getSourceAsString(); //取成json串
  129.                 Map<String, Object> sourceAsMap = hit.getSourceAsMap(); // 取成map对象
  130.                 //从map中取字段值
  131.                 /*
  132.                 String documentTitle = (String) sourceAsMap.get("title");
  133.                 List<Object> users = (List<Object>) sourceAsMap.get("user");
  134.                 Map<String, Object> innerObject = (Map<String, Object>) sourceAsMap.get("innerObject");
  135.                 */
  136.                 logger.info("index:" + index + "  type:" + type + "  id:" + id);
  137.                 logger.info(sourceAsString);
  138.  
  139.                 //取高亮结果
  140.                 /*Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  141.                 HighlightField highlight = highlightFields.get("title");
  142.                 Text[] fragments = highlight.fragments();
  143.                 String fragmentString = fragments[0].string();*/
  144.             }
  145.  
  146.             // 获取聚合结果
  147.             /*
  148.             Aggregations aggregations = searchResponse.getAggregations();
  149.             Terms byCompanyAggregation = aggregations.get("by_company");
  150.             Bucket elasticBucket = byCompanyAggregation.getBucketByKey("Elastic");
  151.             Avg averageAge = elasticBucket.getAggregations().get("average_age");
  152.             double avg = averageAge.getValue();
  153.             */
  154.  
  155.             // 获取建议结果
  156.             /*Suggest suggest = searchResponse.getSuggest();
  157.             TermSuggestion termSuggestion = suggest.getSuggestion("suggest_user");
  158.             for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {
  159.                 for (TermSuggestion.Entry.Option option : entry) {
  160.                     String suggestText = option.getText().string();
  161.                 }
  162.             }
  163.             */
  164.  
  165.             //异步方式发送获查询请求
  166.             /*
  167.             ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {
  168.                 @Override
  169.                 public void onResponse(SearchResponse getResponse) {
  170.                     //结果获取
  171.                 }
  172.  
  173.                 @Override
  174.                 public void onFailure(Exception e) {
  175.                     //失败处理
  176.                 }
  177.             };
  178.             client.searchAsync(searchRequest, listener);
  179.             */
  180.  
  181.         } catch (IOException | InterruptedException | ExecutionException e) {
  182.             logger.error(e);
  183.         }
  184.     }
  185. }

6. highlight 高亮

HighlightDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.Map;
  5. import java.util.concurrent.ExecutionException;
  6.  
  7. import org.apache.logging.log4j.LogManager;
  8. import org.apache.logging.log4j.Logger;
  9. import org.elasticsearch.action.search.SearchRequest;
  10. import org.elasticsearch.action.search.SearchResponse;
  11. import org.elasticsearch.client.transport.TransportClient;
  12. import org.elasticsearch.common.text.Text;
  13. import org.elasticsearch.index.query.QueryBuilder;
  14. import org.elasticsearch.index.query.QueryBuilders;
  15. import org.elasticsearch.rest.RestStatus;
  16. import org.elasticsearch.search.SearchHit;
  17. import org.elasticsearch.search.SearchHits;
  18. import org.elasticsearch.search.builder.SearchSourceBuilder;
  19. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  20. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
  21.  
  22. public class HighlightDemo {
  23.  
  24.     private static Logger logger = LogManager.getRootLogger();  
  25.  
  26.     public static void main(String[] args) {
  27.         try (TransportClient client = InitDemo.getClient();) {
  28.  
  29.             // 1、创建search请求
  30.             SearchRequest searchRequest = new SearchRequest("hl_test"); 
  31.  
  32.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  33.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
  34.  
  35.             //构造QueryBuilder
  36.             QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "lucene solr");
  37.             sourceBuilder.query(matchQueryBuilder);
  38.  
  39.             //分页设置
  40.             /*sourceBuilder.from(0);
  41.             sourceBuilder.size(5); ;*/ 
  42.  
  43.             // 高亮设置
  44.             HighlightBuilder highlightBuilder = new HighlightBuilder();
  45.             highlightBuilder.requireFieldMatch(false).field("title").field("content")
  46.                 .preTags("<strong>").postTags("</strong>");
  47.             //不同字段可有不同设置，如不同标签
  48.             /*HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title");
  49.             highlightTitle.preTags("<strong>").postTags("</strong>");
  50.             highlightBuilder.field(highlightTitle);
  51.             HighlightBuilder.Field highlightContent = new HighlightBuilder.Field("content");
  52.             highlightContent.preTags("<b>").postTags("</b>");
  53.             highlightBuilder.field(highlightContent).requireFieldMatch(false);*/
  54.  
  55.             sourceBuilder.highlighter(highlightBuilder);
  56.  
  57.             searchRequest.source(sourceBuilder);
  58.  
  59.             //3、发送请求
  60.             SearchResponse searchResponse = client.search(searchRequest).get();
  61.  
  62.             //4、处理响应
  63.             if(RestStatus.OK.equals(searchResponse.status())) {
  64.                 //处理搜索命中文档结果
  65.                 SearchHits hits = searchResponse.getHits();
  66.                 long totalHits = hits.getTotalHits();
  67.  
  68.                 SearchHit[] searchHits = hits.getHits();
  69.                 for (SearchHit hit : searchHits) {
  70.                     String index = hit.getIndex();
  71.                     String type = hit.getType();
  72.                     String id = hit.getId();
  73.                     float score = hit.getScore();
  74.  
  75.                     //取_source字段值
  76.                     //String sourceAsString = hit.getSourceAsString(); //取成json串
  77.                     Map<String, Object> sourceAsMap = hit.getSourceAsMap(); // 取成map对象
  78.                     //从map中取字段值
  79.                     /*String title = (String) sourceAsMap.get("title");
  80.                     String content  = (String) sourceAsMap.get("content"); */
  81.                     logger.info("index:" + index + "  type:" + type + "  id:" + id);
  82.                     logger.info("sourceMap : " +  sourceAsMap);
  83.                     //取高亮结果
  84.                     Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  85.                     HighlightField highlight = highlightFields.get("title");
  86.                     if(highlight != null) {
  87.                         Text[] fragments = highlight.fragments();  //多值的字段会有多个值
  88.                         if(fragments != null) {
  89.                             String fragmentString = fragments[0].string();
  90.                             logger.info("title highlight : " +  fragmentString);
  91.                             //可用高亮字符串替换上面sourceAsMap中的对应字段返回到上一级调用
  92.                             //sourceAsMap.put("title", fragmentString);
  93.                         }
  94.                     }
  95.  
  96.                     highlight = highlightFields.get("content");
  97.                     if(highlight != null) {
  98.                         Text[] fragments = highlight.fragments();  //多值的字段会有多个值
  99.                         if(fragments != null) {
  100.                             String fragmentString = fragments[0].string();
  101.                             logger.info("content highlight : " +  fragmentString);
  102.                             //可用高亮字符串替换上面sourceAsMap中的对应字段返回到上一级调用
  103.                             //sourceAsMap.put("content", fragmentString);
  104.                         }
  105.                     }
  106.                 }
  107.             }
  108.  
  109.         } catch (IOException | InterruptedException | ExecutionException e) {
  110.             logger.error(e);
  111.         }
  112.     }
  113. }

7. suggest 查询建议

SuggestDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.ExecutionException;
  5.  
  6. import org.apache.logging.log4j.LogManager;
  7. import org.apache.logging.log4j.Logger;
  8. import org.elasticsearch.action.search.SearchRequest;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.client.transport.TransportClient;
  11. import org.elasticsearch.rest.RestStatus;
  12. import org.elasticsearch.search.builder.SearchSourceBuilder;
  13. import org.elasticsearch.search.suggest.Suggest;
  14. import org.elasticsearch.search.suggest.SuggestBuilder;
  15. import org.elasticsearch.search.suggest.SuggestBuilders;
  16. import org.elasticsearch.search.suggest.SuggestionBuilder;
  17. import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
  18. import org.elasticsearch.search.suggest.term.TermSuggestion;
  19.  
  20. public class SuggestDemo {
  21.  
  22.     private static Logger logger = LogManager.getRootLogger();  
  23.  
  24.     //拼写检查
  25.     public static void termSuggest(TransportClient client) {
  26.  
  27.         // 1、创建search请求
  28.         //SearchRequest searchRequest = new SearchRequest();
  29.         SearchRequest searchRequest = new SearchRequest("mess"); 
  30.  
  31.         // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  32.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
  33.  
  34.         sourceBuilder.size(0); 
  35.  
  36.         //做查询建议
  37.         //词项建议
  38.         SuggestionBuilder termSuggestionBuilder =
  39.                 SuggestBuilders.termSuggestion("user").text("kmichy");
  40.         SuggestBuilder suggestBuilder = new SuggestBuilder();
  41.         suggestBuilder.addSuggestion("suggest_user", termSuggestionBuilder);
  42.         sourceBuilder.suggest(suggestBuilder);
  43.  
  44.         searchRequest.source(sourceBuilder);    
  45.  
  46.         try{
  47.             //3、发送请求
  48.             SearchResponse searchResponse = client.search(searchRequest).get();
  49.  
  50.             //4、处理响应
  51.             //搜索结果状态信息
  52.             if(RestStatus.OK.equals(searchResponse.status())) {
  53.                 // 获取建议结果
  54.                 Suggest suggest = searchResponse.getSuggest();
  55.                 TermSuggestion termSuggestion = suggest.getSuggestion("suggest_user");
  56.                 for (TermSuggestion.Entry entry : termSuggestion.getEntries()) {
  57.                     logger.info("text: " + entry.getText().string());
  58.                     for (TermSuggestion.Entry.Option option : entry) {
  59.                         String suggestText = option.getText().string();
  60.                         logger.info("   suggest option : " + suggestText);
  61.                     }
  62.                 }
  63.             }
  64.  
  65.         } catch (InterruptedException | ExecutionException e) {
  66.             logger.error(e);
  67.         }
  68.             /*
  69.               "suggest": {
  70.                 "my-suggestion": [
  71.                   {
  72.                     "text": "tring",
  73.                     "offset": 0,
  74.                     "length": 5,
  75.                     "options": [
  76.                       {
  77.                         "text": "trying",
  78.                         "score": 0.8,
  79.                         "freq": 1
  80.                       }
  81.                     ]
  82.                   },
  83.                   {
  84.                     "text": "out",
  85.                     "offset": 6,
  86.                     "length": 3,
  87.                     "options": []
  88.                   },
  89.                   {
  90.                     "text": "elasticsearch",
  91.                     "offset": 10,
  92.                     "length": 13,
  93.                     "options": []
  94.                   }
  95.                 ]
  96.               }*/
  97.  
  98.     }
  99.     //自动补全
  100.     public static void completionSuggester(TransportClient client) {
  101.  
  102.         // 1、创建search请求
  103.         //SearchRequest searchRequest = new SearchRequest();
  104.         SearchRequest searchRequest = new SearchRequest("music"); 
  105.  
  106.         // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  107.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
  108.  
  109.         sourceBuilder.size(0); 
  110.  
  111.         //做查询建议
  112.         //自动补全
  113.         /*POST music/_search?pretty
  114.                 {
  115.                     "suggest": {
  116.                         "song-suggest" : {
  117.                             "prefix" : "lucene s",
  118.                             "completion" : {
  119.                                 "field" : "suggest" ,
  120.                                 "skip_duplicates": true
  121.                             }
  122.                         }
  123.                     }
  124.                 }*/
  125.  
  126.         SuggestionBuilder termSuggestionBuilder =
  127.                 SuggestBuilders.completionSuggestion("suggest").prefix("lucene s")
  128.                 .skipDuplicates(true);
  129.         SuggestBuilder suggestBuilder = new SuggestBuilder();
  130.         suggestBuilder.addSuggestion("song-suggest", termSuggestionBuilder);
  131.         sourceBuilder.suggest(suggestBuilder);
  132.  
  133.         searchRequest.source(sourceBuilder);    
  134.  
  135.         try {
  136.             //3、发送请求
  137.             SearchResponse searchResponse = client.search(searchRequest).get();
  138.  
  139.             //4、处理响应
  140.             //搜索结果状态信息
  141.             if(RestStatus.OK.equals(searchResponse.status())) {
  142.                 // 获取建议结果
  143.                 Suggest suggest = searchResponse.getSuggest();
  144.                 CompletionSuggestion termSuggestion = suggest.getSuggestion("song-suggest");
  145.                 for (CompletionSuggestion.Entry entry : termSuggestion.getEntries()) {
  146.                     logger.info("text: " + entry.getText().string());
  147.                     for (CompletionSuggestion.Entry.Option option : entry) {
  148.                         String suggestText = option.getText().string();
  149.                         logger.info("   suggest option : " + suggestText);
  150.                     }
  151.                 }
  152.             }
  153.  
  154.         } catch (InterruptedException | ExecutionException e) {
  155.             logger.error(e);
  156.         }
  157.     }
  158.  
  159.     public static void main(String[] args) {
  160.         try (TransportClient client = InitDemo.getClient();) {
  161.             termSuggest(client);
  162.  
  163.             logger.info("--------------------------------------");
  164.  
  165.             completionSuggester(client);
  166.         } catch (IOException e) {
  167.             logger.error(e);
  168.         }
  169.     }
  170. }

8. aggregation 聚合分析

AggregationDemo.java

  1. package com.study.es_java_client;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.ExecutionException;
  5.  
  6. import org.apache.logging.log4j.LogManager;
  7. import org.apache.logging.log4j.Logger;
  8. import org.elasticsearch.action.search.SearchRequest;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.client.transport.TransportClient;
  11. import org.elasticsearch.rest.RestStatus;
  12. import org.elasticsearch.search.aggregations.AggregationBuilders;
  13. import org.elasticsearch.search.aggregations.Aggregations;
  14. import org.elasticsearch.search.aggregations.BucketOrder;
  15. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
  16. import org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket;
  17. import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
  18. import org.elasticsearch.search.aggregations.metrics.avg.Avg;
  19. import org.elasticsearch.search.builder.SearchSourceBuilder;
  20.  
  21. public class AggregationDemo {
  22.  
  23.     private static Logger logger = LogManager.getRootLogger();  
  24.  
  25.     public static void main(String[] args) {
  26.         try (TransportClient client = InitDemo.getClient();) {
  27.  
  28.             // 1、创建search请求
  29.             //SearchRequest searchRequest = new SearchRequest();
  30.             SearchRequest searchRequest = new SearchRequest("bank"); 
  31.  
  32.             // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
  33.             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
  34.  
  35.             sourceBuilder.size(0); 
  36.  
  37.             //加入聚合
  38.             //字段值项分组聚合
  39.             TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_age")
  40.                     .field("age").order(BucketOrder.aggregation("average_balance", true));
  41.             //计算每组的平均balance指标
  42.             aggregation.subAggregation(AggregationBuilders.avg("average_balance")
  43.                     .field("balance"));
  44.             sourceBuilder.aggregation(aggregation);
  45.  
  46.             searchRequest.source(sourceBuilder);
  47.  
  48.             //3、发送请求
  49.             SearchResponse searchResponse = client.search(searchRequest).get();
  50.  
  51.             //4、处理响应
  52.             //搜索结果状态信息
  53.             if(RestStatus.OK.equals(searchResponse.status())) {
  54.                 // 获取聚合结果
  55.                 Aggregations aggregations = searchResponse.getAggregations();
  56.                 Terms byAgeAggregation = aggregations.get("by_age");
  57.                 logger.info("aggregation by_age 结果");
  58.                 logger.info("docCountError: " + byAgeAggregation.getDocCountError());
  59.                 logger.info("sumOfOtherDocCounts: " + byAgeAggregation.getSumOfOtherDocCounts());
  60.                 logger.info("------------------------------------");
  61.                 for(Bucket buck : byAgeAggregation.getBuckets()) {
  62.                     logger.info("key: " + buck.getKeyAsNumber());
  63.                     logger.info("docCount: " + buck.getDocCount());
  64.                     //logger.info("docCountError: " + buck.getDocCountError());
  65.                     //取子聚合
  66.                     Avg averageBalance = buck.getAggregations().get("average_balance"); 
  67.  
  68.                     logger.info("average_balance: " + averageBalance.getValue());
  69.                     logger.info("------------------------------------");
  70.                 }
  71.                 //直接用key 来去分组
  72.                 /*Bucket elasticBucket = byCompanyAggregation.getBucketByKey("24");
  73.                 Avg averageAge = elasticBucket.getAggregations().get("average_age");
  74.                 double avg = averageAge.getValue();*/
  75.  
  76.             }
  77.  
  78.         } catch (IOException | InterruptedException | ExecutionException e) {
  79.             logger.error(e);
  80.         }
  81.     }
  82. }

9. 官网文档

Document API 文档操作API：

https://www.elastic.co/guide/en/elasticsearch/client/java-api/6.2/java-docs.html

Search API：

https://www.elastic.co/guide/en/elasticsearch/client/java-api/6.2/java-search.html

10.源代码获取地址

https://github.com/Star-Lordxing/ES-java-client-api

七、集成Spring

1.集成spring参考官方文档

官网链接：

https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/

代码库：

https://github.com/spring-projects/spring-data-elasticsearch

2.集成spring boot

参考博客：https://blog.csdn.net/yejingtao703/article/details/78414874

spring 最新集成包只有ES 5.5，推荐使用ES提供原生Client包

参考

Elasticsearch API

https://www.cnblogs.com/leeSmall/p/9218779.html

ES系列十五、ES常用Java Client API的更多相关文章

  1. ES系列十、ES常用查询API

    1.term查询 { "query": { "term": { "title": "crime" } } } 1.1.指 ...

  2. java十五个常用类学习及方法举例

    <code class="language-java">import java.util.Scanner; import java.util.Properties; i ...

  3. 十五个常用的jquery代码段【转】

    好的文章顶一个 回到顶部按钮 通过使用 jQuery 中的 animate 和 scrollTop 方法,你无需插件便可创建一个简单地回到顶部动画: 1 // Back to top 2 $('a.t ...

  4. 十五个常用的jquery代码段

    十五个常用的jquery代码段 回到顶部按钮 通过使用 jQuery 中的 animate 和 scrollTop 方法,你无需插件便可创建一个简单地回到顶部动画: 1 // Back to top ...

  5. ES系列十六、集群配置和维护管理

    一.修改配置文件 1.节点配置 1.vim elasticsearch.yml # ======================== Elasticsearch Configuration ===== ...

  6. 五、RabbitMQ Java Client基本使用详解

    Java Client的5.x版本系列需要JDK 8,用于编译和运行.在Android上,仅支持Android 7.0或更高版本.4.x版本系列支持7.0之前的JDK 6和Android版本. 加入R ...

  7. 学习ASP.NET Core Razor 编程系列十五——文件上传功能（三）

    学习ASP.NET Core Razor 编程系列目录 学习ASP.NET Core Razor 编程系列一 学习ASP.NET Core Razor 编程系列二——添加一个实体 学习ASP.NET ...

  8. 聊聊MySQL的加锁规则《死磕MySQL系列 十五》

    大家好,我是咔咔 不期速成,日拱一卒 本期来聊聊MySQL的加锁规则,知道这些规则后可以判断SQL语句的加锁范围,同时也可以写出更好的SQL语句,防止幻读问题的产生,在能力范围内最大程度的提升MySQ ...

  9. 聊聊高并发（二十五）解析java.util.concurrent各个组件（七） 理解Semaphore

    前几篇分析了一下AQS的原理和实现.这篇拿Semaphore信号量做样例看看AQS实际是怎样使用的. Semaphore表示了一种能够同一时候有多个线程进入临界区的同步器,它维护了一个状态表示可用的票 ...

随机推荐

  1. Jlink使用技巧之读取STM32内部的程序

    前言 上一篇Jlink系列文章介绍了如何使用J-Flash来下载Hex或Bin文件到单片机,具体可参考Jlink使用技巧之单独下载HEX文件到单片机,本篇文章介绍,如何使用JFlash来读取单片机的程 ...

  2. echarts 实时获取数据

    html: <div id="realTimeInvoke" class="chart" style="height: 400px;" ...

  3. WebApi集成Swagger

    1.新建一个WebApi空项目 2.新建一个Person实体类: public class Person { public int ID { get; set; } public string Use ...

  4. Intellij IDEA创建的Web项目配置Tomcat并启动Maven项目

    本篇博客讲解IDEA如何配置Tomcat. 大部分是直接上图哦. 点击如图所示的地方,进行添加Tomcat配置页面 弹出页面后,按照如图顺序找到,点击+号 tomcat Service -> L ...

  5. 什么是CLOS架构?

    Clos架构,诞生于1952年,是由一位叫Charles Clos的人提出的,所以它并不是一个新的概念. 这个架构主要描述了一种多级电路交换网络的结构.Clos最大的优点就是对Crossbar结构的改 ...

  6. 我的2017&2018

    最近项目进入验收阶段,所以上班没那么忙碌了,但是怎么说呢,我可能天生是闲不住的主,觉得浑身不自在(我这样的人是不是特别不会享福),此处应该有个笑脸哈. 翻看了博客园好几个大牛写的技术文章,感慨大牛不愧 ...

  7. H5 marquee标签

    39-marquee标签 内容 属性: direction: 设置滚动方向 left/right/up/down scrollamount: 设置滚动速度, 值越大就越快 loop: 设置滚动次数, ...

  8. 深度学习之概述(Overview)

    2016年被称为人工智能的元年,2017年是人能智能应用的元年:深度学习技术和应用取得飞速发展:深度学习在互联网教育场景也得到广泛应用.本文主要介绍机器学习及深度学习之定义及基本概念.相关网络结构等. ...

  9. iOS iCloud云存储数据

    https://www.jianshu.com/p/ce8cfaf6030e 2017.11.29 16:05* 字数 452 阅读 302评论 0喜欢 1 因为上一次做了用keychain来持久化存 ...

  10. PAT L2-023 图着色问题

    https://pintia.cn/problem-sets/994805046380707840/problems/994805057298481152 图着色问题是一个著名的NP完全问题.给定无向 ...