1. 文档

官方文档：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/_index_apis.html 找和自己版本、语言相对应的文档

image.pngimage.pngimage.png
Java REST Client 有两种风格：

  • Java Low Level REST Client ：用于Elasticsearch的官方低级客户端。它允许通过http与Elasticsearch集群通信。将请求编排和响应反编排留给用户自己处理。它兼容所有的Elasticsearch版本。（PS：学过WebService的话，对编排与反编排这个概念应该不陌生。可以理解为对请求参数的封装，以及对响应结果的解析）

  • Java High Level REST Client ：用于Elasticsearch的官方高级客户端。它是基于低级客户端的，它提供很多API，并负责请求的编排与响应的反编排。（PS：就好比是，一个是传自己拼接好的字符串，并且自己解析返回的结果；而另一个是传对象，返回的结果也已经封装好了，直接是对象，更加规范了参数的名称以及格式，更加面对对象一点）

Tip：我们使用 High Level REST Client

2. 使用步骤

2.1 创建 springboot 项目

2.2 配置依赖（改pom）

  1. <properties>
  2.      <java.version>1.8</java.version>
  3.   <!-- 这里SpringBoot默认配置的版本和使用的es不匹配，我们需要自己配置版本！ -->
  4.   <elasticsearch.version>7.6.1</elasticsearch.version>
  5. </properties>
  7. <!-- 这里的依赖可用去maven仓库寻找 -->
  8. <dependency>
  9.   <groupId>org.springframework.boot</groupId>
  10.   <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  11. </dependency>

2.3 自定义config

  1. import org.apache.http.HttpHost;
  2. import org.elasticsearch.client.RestClient;
  3. import org.elasticsearch.client.RestHighLevelClient;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  7. @Configuration
  8. public class EsConfig {
  9.     @Bean
  10.     RestHighLevelClient restHighLevelClient() {
  11.         return new RestHighLevelClient(
  12.                 // 配置ip和端口
  13.                 RestClient.builder(
  14.                     new HttpHost("localhost", 9201, "http"), // 构建客户端对象
  15.                     new HttpHost("localhost", 9200)));
  16.     }
  17. }

2.4 测试代码

  1. package com.edward;
  3. import com.alibaba.fastjson.JSON;
  4. import com.edward.entity.User;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  7. import org.elasticsearch.action.bulk.BulkRequest;
  8. import org.elasticsearch.action.bulk.BulkResponse;
  9. import org.elasticsearch.action.delete.DeleteRequest;
  10. import org.elasticsearch.action.delete.DeleteResponse;
  11. import org.elasticsearch.action.get.GetRequest;
  12. import org.elasticsearch.action.get.GetResponse;
  13. import org.elasticsearch.action.index.IndexRequest;
  14. import org.elasticsearch.action.index.IndexResponse;
  15. import org.elasticsearch.action.search.SearchRequest;
  16. import org.elasticsearch.action.search.SearchResponse;
  17. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  18. import org.elasticsearch.action.update.UpdateRequest;
  19. import org.elasticsearch.action.update.UpdateResponse;
  20. import org.elasticsearch.client.RequestOptions;
  21. import org.elasticsearch.client.RestHighLevelClient;
  22. import org.elasticsearch.client.indices.CreateIndexRequest;
  23. import org.elasticsearch.client.indices.CreateIndexResponse;
  24. import org.elasticsearch.client.indices.GetIndexRequest;
  25. import org.elasticsearch.client.indices.GetIndexResponse;
  26. import org.elasticsearch.common.xcontent.XContentType;
  27. import org.elasticsearch.index.query.QueryBuilder;
  28. import org.elasticsearch.index.query.QueryBuilders;
  29. import org.elasticsearch.rest.RestStatus;
  30. import org.elasticsearch.search.SearchHit;
  31. import org.elasticsearch.search.builder.SearchSourceBuilder;
  32. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  33. import org.junit.jupiter.api.Test;
  34. import org.springframework.beans.factory.annotation.Autowired;
  35. import org.springframework.beans.factory.annotation.Qualifier;
  36. import org.springframework.boot.test.context.SpringBootTest;
  38. import java.io.IOException;
  39. import java.util.ArrayList;
  41. @Slf4j
  42. @SpringBootTest
  43. class EsDemoApplicationTests {
  45.     @Autowired
  46.     private RestHighLevelClient restHighLevelClient;
  48.     /*
  49.     *-------------------------索引--------------------------
  50.     * 创建索引
  51.     * */
  52.     @Test
  53.     void testCreateIndices() throws IOException {
  54.         CreateIndexRequest request = new CreateIndexRequest("es_index_demo");
  55.         CreateIndexResponse response = restHighLevelClient.
  56.                     indices().create(request, RequestOptions.DEFAULT);
  57.         log.info("create index result：{}", response.isAcknowledged()); // true（成功） |  失败抛异常
  58.     }
  60.     /*
  61.     * 测试索引是否存在
  62.     * */
  63.     @Test
  64.     void testExistIndices() throws IOException {
  65.         GetIndexRequest request = new GetIndexRequest("es_index_demo");
  66.         boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
  67.         log.info("res：{}", exists); // true（存在） | false（不存在）
  68.     }
  70.     /*
  71.     * 测试删除索引
  72.     * */
  73.     @Test
  74.     void testDeleteIndices() throws IOException {
  75.         DeleteIndexRequest request = new DeleteIndexRequest("es_index_demo");
  76.         AcknowledgedResponse response = restHighLevelClient.
  77.                 indices().delete(request, RequestOptions.DEFAULT);
  78.         log.info("deleteRes：{}", response.isAcknowledged()); // true（删除成功，若无这个索引也返回true）
  79.     }
  82.     /*
  83.     *-------------------------文档--------------------------
  84.     * 测试添加文档
  85.     * */
  86.     @Test
  87.     void testAddDocument() throws IOException {
  88.         User user = User.builder().name("大龙").age(20).build();
  89.         IndexRequest request = new IndexRequest("es_index_demo")
  90.                 .id("1") // id 不指定则生成随机字符串
  91.                 .source(JSON.toJSONString(user), XContentType.JSON);
  92.         // 发送请求
  93.         IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
  94.         log.info("status：{}",response.status()); // CREATED（没这条文档，初次创建） | OK（更新）
  95.         log.info("getResult：{}",response.getResult()); // CREATED（没这条文档，初次创建） | UPDATED（更新）
  96.     }
  98.     /*
  99.     * 测试文档是否存在（根据索引和文档id判断）
  100.     * */
  101.     @Test
  102.     void testExistDocument() throws IOException {
  103.         GetRequest request = new GetRequest("es_index_demo","1");
  104.         // 不获取 _source 上下文
  105.         request.fetchSourceContext(new FetchSourceContext(false));
  106.         // 不获取 stored fields
  107.         request.storedFields("_none_");
  108.         // 判断是否存在
  109.         boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);
  110.         log.info("exist：{}", exists); // true（存在） | false（不存在）
  111.     }
  113.     /*
  114.     * 测试更新某个文档（根据文档id）
  115.     * */
  116.     @Test
  117.     void testUpdateDocument() throws IOException {
  118.         User user = User.builder().name("小龙").age(1).build();
  119.         // 构建请求信息
  120.         UpdateRequest request = new UpdateRequest("es_index_demo", "1");
  121.         request.doc(JSON.toJSONString(user), XContentType.JSON);
  122.         // 发送更新请求
  123.         UpdateResponse response = restHighLevelClient.update(request, RequestOptions.DEFAULT);
  124.         log.info("res：{}", response);
  125.         log.info("res - status：{}", response.status()); // OK（成功）
  126.     }
  129.     /*
  130.      * 测试删除某个文档（根据文档id）
  131.      * */
  132.     @Test
  133.     void testDeleteDocument() throws IOException {
  134.         DeleteRequest request = new DeleteRequest("es_index_demo", "1");
  135.         DeleteResponse response = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
  136.         log.info("response：{}",response.status()); // OK（删除成功） | NOT_FOUND（未找到）
  137.         log.info("RestStatus.OK，{}", RestStatus.OK); // OK
  138.     }
  140.     /*
  141.     * 测试根据索引和文档id获取文档信息
  142.     * */
  143.     @Test
  144.     void testGetDocument() throws IOException {
  145.         GetRequest request = new GetRequest("es_index_demo", "1");
  146.         GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
  147.         log.info("result_source_String：{}",response.getSourceAsString()); // 获取 _source 的内容并转为字符串 | 没数据返回null
  148.         log.info("result_source_Map：{}",response.getSourceAsMap()); // 获取 _source 的内容并转为map | 没数据返回 null
  149.     }
  151.     /*
  152.      * 批量添加文档
  153.      * */
  154.     @Test
  155.     void testBulkDocument() throws IOException {
  156.         ArrayList<User> userList = new ArrayList<>();
  157.         userList.add(new User("edward1",3));
  158.         userList.add(new User("edward2",3));
  159.         userList.add(new User("edward3",3));
  160.         userList.add(new User("damon1",3));
  161.         userList.add(new User("damon2",3));
  162.         userList.add(new User("damon3",3));
  164.         // 构建请求数据
  165.         BulkRequest bulkRequest = new BulkRequest();
  167.         for (User user : userList) {
  168.             bulkRequest.add(new IndexRequest("es_index_demo")
  169.                     .source(JSON.toJSONString(user), XContentType.JSON));
  170.         }
  172.         // 发送请求
  173.         BulkResponse response = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
  175.         log.info("response-status，{}", response.status()); // OK
  176.         log.info("response-hasFailures，{}", response.hasFailures()); // false
  177.     }
  179.     /*
  180.      * 查询测试
  181.      * */
  182.     @Test
  183.     void testSearch() throws IOException {
  184.         SearchRequest request = new SearchRequest("es_index_demo");
  185.         // 构件查询信息
  186.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  187.         searchSourceBuilder.query(QueryBuilders.matchQuery("name", "edward1"));
  188.         // 将查询信息放入 request 中
  189.         request.source(searchSourceBuilder);
  190.         // 发送请求
  191.         SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
  192.         log.info("res_hits：{}",response.getHits());
  193.         // 遍历结果集
  194.         for (SearchHit hit : response.getHits().getHits()) {
  195.             log.info("hit：{}",hit.getSourceAsMap()); // {name=edward1, age=3}
  196.         }
  197.     }
  198. }

3. es 工具类封装

  1. import com.alibaba.fastjson.JSON;
  2. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  3. import org.elasticsearch.action.bulk.BulkRequest;
  4. import org.elasticsearch.action.bulk.BulkResponse;
  5. import org.elasticsearch.action.delete.DeleteRequest;
  6. import org.elasticsearch.action.delete.DeleteResponse;
  7. import org.elasticsearch.action.get.GetRequest;
  8. import org.elasticsearch.action.get.GetResponse;
  9. import org.elasticsearch.action.index.IndexRequest;
  10. import org.elasticsearch.action.index.IndexResponse;
  11. import org.elasticsearch.action.search.SearchRequest;
  12. import org.elasticsearch.action.search.SearchResponse;
  13. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  14. import org.elasticsearch.action.update.UpdateRequest;
  15. import org.elasticsearch.action.update.UpdateResponse;
  16. import org.elasticsearch.client.RequestOptions;
  17. import org.elasticsearch.client.RestHighLevelClient;
  18. import org.elasticsearch.client.indices.CreateIndexRequest;
  19. import org.elasticsearch.client.indices.CreateIndexResponse;
  20. import org.elasticsearch.client.indices.GetIndexRequest;
  21. import org.elasticsearch.common.unit.TimeValue;
  22. import org.elasticsearch.common.xcontent.XContentType;
  23. import org.elasticsearch.index.query.QueryBuilders;
  24. import org.elasticsearch.rest.RestStatus;
  25. import org.elasticsearch.search.builder.SearchSourceBuilder;
  26. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  27. import org.springframework.beans.factory.annotation.Autowired;
  28. import org.springframework.beans.factory.annotation.Qualifier;
  29. import org.springframework.stereotype.Component;
  30. import java.io.IOException;
  31. import java.util.List;
  32. import java.util.concurrent.TimeUnit;
  34. @Component
  35. public class EsUtils<T> {
  37.     @Autowired
  38.     @Qualifier("restHighLevelClient")
  39.     private RestHighLevelClient client;
  41.     /**
  42.     * 判断索引是否存在
  43.     * @param index
  44.     * @return
  45.     * @throws IOException
  46.     */
  47.     public boolean existsIndex(String index) throws IOException {
  48.         GetIndexRequest request = new GetIndexRequest(index);
  49.         boolean exists = client.indices().exists(request,
  50.         RequestOptions.DEFAULT);
  51.         return exists;
  52.     }
  54.     /**
  55.     * 创建索引
  56.     * @param index
  57.     * @throws IOException
  58.     */
  59.     public boolean createIndex(String index) throws IOException {
  60.         CreateIndexRequest request = new CreateIndexRequest(index);
  61.         CreateIndexResponse createIndexResponse=client.indices()
  62.                                                 .create(request,RequestOptions.DEFAULT);
  63.         return createIndexResponse.isAcknowledged();
  64.     }
  66.     /**
  67.     * 删除索引
  68.     * @param index
  69.     * @return
  70.     * @throws IOException
  71.     */
  72.     public boolean deleteIndex(String index) throws IOException {
  73.         DeleteIndexRequest deleteIndexRequest = new
  74.         DeleteIndexRequest(index);
  75.         AcknowledgedResponse response =client.indices()
  76.                                         .delete(deleteIndexRequest, RequestOptions.DEFAULT);
  77.         return response.isAcknowledged();
  78.     }
  80.     /**
  81.     * 判断某索引下文档id是否存在
  82.     * @param index
  83.     * @param id
  84.     * @return
  85.     * @throws IOException
  86.     */
  87.     public boolean docExists(String index, String id) throws IOException {
  88.         GetRequest getRequest = new GetRequest(index,id);
  89.         // 只判断索引是否存在不需要获取_source
  90.         getRequest.fetchSourceContext(new FetchSourceContext(false));
  91.         getRequest.storedFields("_none_");
  92.         boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
  93.         return exists;
  94.     }
  96.     /**
  97.     * 添加文档记录
  98.     * @param index
  99.     * @param id
  100.     * @param t 要添加的数据实体类
  101.     * @return
  102.     * @throws IOException
  103.     */
  104.     public boolean addDoc(String index,String id,T t) throws IOException {
  105.         IndexRequest request = new IndexRequest(index);
  106.         request.id(id);
  108.         //timeout
  109.         request.timeout(TimeValue.timeValueSeconds(1));
  110.         request.timeout("1s");
  111.         request.source(JSON.toJSONString(t), XContentType.JSON);
  113.         IndexResponse indexResponse = client.index(request,RequestOptions.DEFAULT);
  114.         RestStatus Status = indexResponse.status();
  115.         return Status==RestStatus.OK||Status== RestStatus.CREATED;
  116.     }
  118.     /**
  119.     * 根据id来获取记录
  120.     * @param index
  121.     * @param id
  122.     * @return
  123.     * @throws IOException
  124.     */
  125.     public GetResponse getDoc(String index, String id) throws IOException {
  126.         GetRequest request = new GetRequest(index,id);
  127.         GetResponse getResponse = client.get(request,RequestOptions.DEFAULT);
  128.         return getResponse;
  129.     }
  131.     /**
  132.     * 批量添加文档记录
  133.     * 没有设置id ES会自动生成一个，如果要设置 IndexRequest的对象.id()即可
  134.     * @param index
  135.     * @param list
  136.     * @return
  137.     * @throws IOException
  138.     */
  139.     public boolean bulkAdd(String index, List<T> list) throws IOException {
  140.         BulkRequest bulkRequest = new BulkRequest();
  141.         //timeout
  142.         bulkRequest.timeout(TimeValue.timeValueMinutes(2));
  143.         bulkRequest.timeout("2m");
  144.         for (int i =0;i<list.size();i++){
  145.             bulkRequest.add(new IndexRequest(index)
  146.                                 .source(JSON.toJSONString(list.get(i))));
  147.         }
  148.         BulkResponse bulkResponse = client.bulk(bulkRequest,RequestOptions.DEFAULT);
  149.         return !bulkResponse.hasFailures();
  150.     }
  152.     /**
  153.     * 批量删除和更新就不写了可根据上面几个方法来写
  154.     */
  155.     /**
  156.     * 更新文档记录
  157.     * @param index
  158.     * @param id
  159.     * @param t
  160.     * @return
  161.     * @throws IOException
  162.     */
  163.     public boolean updateDoc(String index,String id,T t) throws IOException{
  164.         UpdateRequest request = new UpdateRequest(index,id);
  165.         request.doc(JSON.toJSONString(t));
  166.         request.timeout(TimeValue.timeValueSeconds(1));
  167.         request.timeout("1s");
  168.         UpdateResponse updateResponse = client.update(
  169.         request, RequestOptions.DEFAULT);
  170.         return updateResponse.status()==RestStatus.OK;
  171.     }
  173.     /**
  174.     * 删除文档记录
  175.     * @param index
  176.     * @param id
  177.     * @return
  178.     * @throws IOException
  179.     */
  180.     public boolean deleteDoc(String index,String id) throws IOException {
  181.         DeleteRequest request = new DeleteRequest(index,id);
  182.         //timeout
  183.         request.timeout(TimeValue.timeValueSeconds(1));
  184.         request.timeout("1s");
  185.         DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
  186.         return deleteResponse.status()== RestStatus.OK;
  187.     }
  189.     /**
  190.     * 根据某字段来搜索
  191.     * @param index
  192.     * @param field
  193.     * @param key 要收搜的关键字
  194.     * @throws IOException
  195.     */
  196.     public void search(String index,String field ,String key,Integer from,Integer size) throws IOException {
  197.         SearchRequest searchRequest = new SearchRequest(index);
  198.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  199.         sourceBuilder.query(QueryBuilders.termQuery(field, key));
  201.         //控制搜素
  202.         sourceBuilder.from(from);
  203.         sourceBuilder.size(size);
  205.         //最大搜索时间。
  206.         sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
  207.         searchRequest.source(sourceBuilder);
  208.         SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
  209.         System.out.println(JSON.toJSONString(searchResponse.getHits()));
  210.     }
  211. }