Elasticsearch Java Client

最新推荐文章于 2023-10-27 10:29:40 发布

森林森

最新推荐文章于 2023-10-27 10:29:40 发布

阅读量314

点赞数

分类专栏：其它

本文链接：https://blog.csdn.net/ko0491/article/details/110038631

版权

其它专栏收录该内容

20 篇文章 0 订阅

订阅专栏

ES提供多种不同的客户端：
1、TransportClient ES提供的传统客户端，官方计划8.0版本删除此客户端
2、RestClient RestClient是官方推荐使用的，它包括两种：Java Low Level REST Client和 Java High
Level REST Client。 ES在6.0之后提供 Java High Level REST Client，两种客户端官方更推荐使用 Java
High Level REST Client，使用时加入对应版本的依赖即可

SpringBoot 中使用 RestClient


<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.3.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.elasticsearch</groupId>
                    <artifactId>elasticsearch</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.3.0</version>
        </dependency>
    </dependencies>

配置文件

spring:
  application:
    name: boot-es-rest-client
mylasticsearch:
  elasticsearch:
    hostlist: 192.168.181.140:9200

配置类

package com.liu.es.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ElasticsearchConfig {


    @Value("${mylasticsearch.elasticsearch.hostlist}")
    private String hostlist;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        // 解析hostlist 信息
        String[] split = hostlist.split(",");
        // 创建HttpHost数组  封装es的主机和端口
        HttpHost[] httpHosts = new HttpHost[split.length];
        for (int i = 0; i < split.length; i++) {
            String iterm = split[i];
            httpHosts[i] = new HttpHost(iterm.split(":")[0], Integer.parseInt(iterm.split(":")[1]), "http");
        }
        return new RestHighLevelClient(RestClient.builder(httpHosts));
    }
}

测试

package com.liu.es;

import org.apache.lucene.search.TotalHits;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchScrollRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.IndicesClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.Scroll;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@RunWith(SpringRunner.class)
@SpringBootTest
public class TestIndex {

    @Autowired
    private RestHighLevelClient restHighLevelClient;



    /*
    //创建索引库
PUT /elasticsearch_test
{
"settings": {},
"mappings": {
"properties": {
"description": {
"type": "text",
"analyzer": "ik_max_word"
},
"name": {
"type": "keyword"
},
"pic": {
"type": "text",
"index": false
},
"studymodel": {
"type": "keyword"
}
}
}
} */

    @Test
    public void testCreateIndex() throws IOException {
        // 创建一个索引创建请求对象
        CreateIndexRequest  createIndexRequest  = new CreateIndexRequest("elasticsearch_test");
        //设置映射
        XContentBuilder   builder  = XContentFactory.jsonBuilder()
                .startObject()
                .field("properties")
                .startObject()
                .field("description").startObject().field("type","text").field("analyzer","ik_max_word").endObject()
                .field("name").startObject().field("type","keyword").endObject()
                .field("pic").startObject().field("type","text").field("index","false").endObject()
                .field("studymodel").startObject().field("type","keyword").endObject()
                .endObject()
                .endObject();
        createIndexRequest.mapping("doc",builder);



//        createIndexRequest.mapping("doc","{\n" +
//                "        \"properties\": {\n" +
//                "          \"description\": {\n" +
//                "            \"type\": \"text\",\n" +
//                "            \"analyzer\": \"ik_max_word\"\n" +
//                "          },\n" +
//                "          \"name\": {\n" +
//                "            \"type\": \"keyword\"\n" +
//                "          },\n" +
//                "          \"pic\": {\n" +
//                "            \"type\": \"text\",\n" +
//                "            \"index\": false\n" +
//                "          },\n" +
//                "          \"studymodel\": {\n" +
//                "            \"type\": \"keyword\"\n" +
//                "          }\n" +
//                "        }\n" +
//                "      }", XContentType.JSON);
        // 操作索引的客户端
        IndicesClient  indicesClient  = restHighLevelClient.indices();

        CreateIndexResponse  createIndexResponse = indicesClient.create(createIndexRequest, RequestOptions.DEFAULT);
        // 得到响应
        boolean  acknowledged = createIndexResponse.isAcknowledged();
        System.out.println("创建索引 testCreateIndex  :"+acknowledged);
    }


    @Test
    public void testDeleteIndex() throws IOException {
        // 构建 删除索引库的请求对象
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("elasticsearch_test");

        IndicesClient indicesClient = restHighLevelClient.indices();

        AcknowledgedResponse acknowledgedResponse = indicesClient.delete(deleteIndexRequest, RequestOptions.DEFAULT);

        // 得到响应
        System.out.println("删除索引 testDeleteIndex  :"+acknowledgedResponse.isAcknowledged());

    }

    //添加文档
    /*
    POST /elasticsearch_test/_doc/1
    {
      "name": "spring cloud实战",
      "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
      "studymodel":"201001",
      "timestamp": "2020-08-22 20:09:18",
      "price": 5.6
    }
     */
    @Test
    public void testAddDoc() throws IOException {
        //创建索引对象
        IndexRequest indexRequest =new IndexRequest("elasticsearch_test");

        //indexRequest.id("2");
        // 文档内容  准备json数据
        Map<String,Object> jsonMap = new HashMap<>();
        jsonMap.put("name","spring cloud实战");
        jsonMap.put("description","本课程主要从四个章节进行讲解3： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。");
        jsonMap.put("studymodel","3101001");
        jsonMap.put("timestamp","2020-07-22 20:09:18");
        jsonMap.put("price",35.6);

        indexRequest.source(jsonMap);


        //执行请求
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

        DocWriteResponse.Result  result = indexResponse.getResult();
        System.out.println(result);


    }

    // 查询文档
    @Test
    public  void testQueryDoc() throws IOException {
        GetRequest getRequest = new GetRequest("elasticsearch_test");
        getRequest.id("1");

        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);

        System.out.println(getResponse.getSourceAsMap());
    }


    //搜索全部记录
    /*
       GET   /elasticsearch_test/_search
        {
          "query":{
             "match_all":{}
          }
        }
    */
    @Test
    public void testMatchAll() throws IOException {

    //构建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("elasticsearch_test");

        // 搜索源构建对象
        SearchSourceBuilder  searchSourceBuilder = new SearchSourceBuilder();
        // 设置搜索方法
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        searchSourceBuilder.fetchSource(new String[]{"name","price","timestamp","description"},new String[]{});

// 请求对象设置 搜索源对象
        searchRequest.source(searchSourceBuilder);

        // 使用client  执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //搜索结果

        SearchHits hits = searchResponse.getHits();

        //获取总记录灵敏
        TotalHits totalHits = hits.getTotalHits();
        System.out.println("查询到的总记录数:"+totalHits.value);


        //获取命中数据
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit  hit : searchHits){
            String  id = hit.getId();
            // 源文档的内容
            Map<String,Object>  sourceMap = hit.getSourceAsMap();
            String  name  = (String)sourceMap.get("name");
            String  timestamp  = (String)sourceMap.get("timestamp");
            String  description  = (String)sourceMap.get("description");
            Double   price  = (Double)sourceMap.get("price");
            System.out.println(id+" \t" +name+" \t "+ timestamp +" \t "+ description +" \t "+price);

        }
    }


    @Test
    public void testTermQuery() throws IOException {

        //构建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("elasticsearch_test");

        // 搜索源构建对象
        SearchSourceBuilder  searchSourceBuilder = new SearchSourceBuilder();
        // 设置搜索方法
        searchSourceBuilder.query(QueryBuilders.termQuery("name","spring cloud实战3"));
//        searchSourceBuilder.query(QueryBuilders.termQuery("description","spring cloud"));
//        searchSourceBuilder.query(QueryBuilders.termQuery("description","spring"));

        searchSourceBuilder.fetchSource(new String[]{"name","price","timestamp","description"},new String[]{});

// 请求对象设置 搜索源对象
        searchRequest.source(searchSourceBuilder);

        // 使用client  执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //搜索结果

        SearchHits hits = searchResponse.getHits();

        //获取总记录灵敏
        TotalHits totalHits = hits.getTotalHits();
        System.out.println("查询到的总记录数:"+totalHits.value);


        //获取命中数据
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit  hit : searchHits){
            String  id = hit.getId();
            // 源文档的内容
            Map<String,Object>  sourceMap = hit.getSourceAsMap();
            String  name  = (String)sourceMap.get("name");
            String  timestamp  = (String)sourceMap.get("timestamp");
            String  description  = (String)sourceMap.get("description");
            Double   price  = (Double)sourceMap.get("price");
            System.out.println(id+" \t" +name+" \t "+ timestamp +" \t "+ description +" \t "+price);

        }
    }

    @Test
    public  void   testSearchAllPage()throws  IOException{

        //构建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("elasticsearch_test");

        // 搜索源构建对象
        SearchSourceBuilder  searchSourceBuilder = new SearchSourceBuilder();
        // 设置搜索方法
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        searchSourceBuilder.fetchSource(new String[]{"name","price","timestamp","description"},new String[]{});

        // 设置分页参数
        int  page = 1;
        int  size = 2;
        // 计算出 from
        int  form = (page-1)*size;

        searchSourceBuilder.from(form);
        searchSourceBuilder.size(size);
        searchSourceBuilder.sort("price", SortOrder.DESC);


// 请求对象设置 搜索源对象
        searchRequest.source(searchSourceBuilder);

        // 使用client  执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //搜索结果

        SearchHits hits = searchResponse.getHits();

        //获取总记录灵敏
        TotalHits totalHits = hits.getTotalHits();
        System.out.println("查询到的总记录数:"+totalHits.value);


        //获取命中数据
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit  hit : searchHits){
            String  id = hit.getId();
            // 源文档的内容
            Map<String,Object>  sourceMap = hit.getSourceAsMap();
            String  name  = (String)sourceMap.get("name");
            String  timestamp  = (String)sourceMap.get("timestamp");
            String  description  = (String)sourceMap.get("description");
            Double   price  = (Double)sourceMap.get("price");
            System.out.println(id+" \t" +name+" \t "+ timestamp +" \t "+ description +" \t "+price);

        }
    }
    public List<Map<String,Object> > searchQuestionBO(String scrollId){
        // 搜索请求对象
        SearchRequest  searchRequest = new SearchRequest("elasticsearch_test");
        // 搜索源构建对象
        SearchSourceBuilder  searchSourceBuilder = new SearchSourceBuilder();
        // 设置搜索方法
        searchSourceBuilder.query(QueryBuilders.termQuery("name","spring cloud实战"));
        searchSourceBuilder.fetchSource(new String[]{"name","price","timestamp"},new String[]{});
        // 设置price 降序
        searchSourceBuilder.sort("price",SortOrder.DESC);
        // 请求对象设置 搜索源对象
        searchRequest.source(searchSourceBuilder);
        List<Map<String,Object> > questionBOList = new ArrayList<>();
        SearchResponse searchResponse = null;
        boolean deepSearch = false;
        try {

            deepSearch = true;
            searchRequest.source().size(2);
            final Scroll scroll = new Scroll(TimeValue.timeValueMinutes(30L));
            searchRequest.scroll(scroll);
            searchResponse = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);

            SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
            scrollRequest.scroll(scroll);
            searchResponse = restHighLevelClient.scroll(scrollRequest,RequestOptions.DEFAULT);
            SearchHits searchHits = searchResponse.getHits();
            SearchHit[] searchHit = searchHits.getHits();
            long total = searchHits.getTotalHits().value;
            for (int i = 0;i < searchHit.length;i++) {
                SearchHit item = searchHit[i];
                questionBOList.add(item.getSourceAsMap());
            }
            return questionBOList;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return questionBOList;
    }

}