ElasticSearch入门

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.boot.autoconfigure.elasticsearch.rest;

import java.time.Duration;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

class RestClientConfigurations {
    RestClientConfigurations() {
    }

    @Configuration(
        proxyBeanMethods = false
    )
  // RestClient  普通客户端
    static class RestClientFallbackConfiguration {
        RestClientFallbackConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder) {
            return builder.build();
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({RestHighLevelClient.class})
  // RestHighLevelClient  高级客户端
    static class RestHighLevelClientConfiguration {
        RestHighLevelClientConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        RestHighLevelClient elasticsearchRestHighLevelClient(RestClientBuilder restClientBuilder) {
            return new RestHighLevelClient(restClientBuilder);
        }

        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder, ObjectProvider<RestHighLevelClient> restHighLevelClient) {
            RestHighLevelClient client = (RestHighLevelClient)restHighLevelClient.getIfUnique();
            return client != null ? client.getLowLevelClient() : builder.build();
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
  // RestClientBuilder
    static class RestClientBuilderConfiguration {
        RestClientBuilderConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        RestClientBuilder elasticsearchRestClientBuilder(RestClientProperties properties, ObjectProvider<RestClientBuilderCustomizer> builderCustomizers) {
            HttpHost[] hosts = (HttpHost[])properties.getUris().stream().map(HttpHost::create).toArray((x$0) -> {
                return new HttpHost[x$0];
            });
            RestClientBuilder builder = RestClient.builder(hosts);
            PropertyMapper map = PropertyMapper.get();
            map.from(properties::getUsername).whenHasText().to((username) -> {
                CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                Credentials credentials = new UsernamePasswordCredentials(properties.getUsername(), properties.getPassword());
                credentialsProvider.setCredentials(AuthScope.ANY, credentials);
                builder.setHttpClientConfigCallback((httpClientBuilder) -> {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                });
            });
            builder.setRequestConfigCallback((requestConfigBuilder) -> {
                properties.getClass();
                map.from(properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis).to(requestConfigBuilder::setConnectTimeout);
                properties.getClass();
                map.from(properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis).to(requestConfigBuilder::setSocketTimeout);
                return requestConfigBuilder;
            });
            builderCustomizers.orderedStream().forEach((customizer) -> {
                customizer.customize(builder);
            });
            return builder;
        }
    }
}

package com.wangba;

import com.alibaba.fastjson.JSON;
import com.wangba.enity.User;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.util.QueryBuilder;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.repository.query.Param;
import org.w3c.dom.ls.LSOutput;

import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class SpringbootEsApiApplicationTests {

    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    /**
     * @Description: 创建索引
     * @Param: []
     * @return: void
     * @Author: wang ba
     * @Date: 2020/7/29
     */
    @Test
    void createIndex() throws IOException {
        // 1. 创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("test");
        // 2. 让客户端执行请求 indicesClient
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

        System.out.println(createIndexResponse);
    }

    /**
    * @Description: 查询索引
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void existIndex() throws IOException {

        GetIndexRequest request = new GetIndexRequest("test");

        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

      System.out.println(exists);

    }

    /**
    * @Description: 删除索引
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void deleteIndex() throws IOException {

      DeleteIndexRequest request = new DeleteIndexRequest("test");

      AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

      System.out.println(delete);

   }

   /**
   * @Description: 添加文档 PUT test/_doc/1
   * @Param: []
   * @return: void
   * @Author: wang ba
   * @Date: 2020/7/29
   */
   @Test
   void addDocument() throws IOException {
      // 创建对象
      User user = new User("wangba", 25);
      // 创建请求
      IndexRequest request = new IndexRequest("test");
      // 规则：  ==>   PUT test/_doc/1
      request.id("1");
      request.timeout("1s");
      // 将我们的数据放入请求中   JSON格式
      request.source(JSON.toJSONString(user), XContentType.JSON);
      // 客户端发送请求，返回结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

        System.out.println(indexResponse);
        System.out.println(indexResponse.toString());
        System.out.println(indexResponse.status());   // 对应的状态就是 CREATED 等


    }

    /**
    * @Description: 文档是否存在
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void existDocument() throws IOException {
        // GET test/_doc/1
        GetRequest request = new GetRequest("test", "1");
        // _source 不显示上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none_");

        boolean exists = client.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    /**
    * @Description: 查询文档数据  GET test/_doc/1
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void getDocument() throws IOException {

        GetRequest request = new GetRequest("test", "1");

        GetResponse documentFields = client.get(request, RequestOptions.DEFAULT);

        System.out.println(documentFields.getSourceAsString());
        System.out.println(documentFields);


    }

    /**
    * @Description: 更新文档
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void updateDocument() throws IOException {
        UpdateRequest request = new UpdateRequest("test", "1");
        User user = new User("zhansan", 22);
        request.doc(JSON.toJSONString(user), XContentType.JSON);
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);

        System.out.println(update);
        System.out.println(update.status());
    }



    /**
    * @Description: 删除文档  DELETE test/_doc/1
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void deleteDocument() throws IOException {

        DeleteRequest request = new DeleteRequest("test", "1");

        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(delete);
    }

    /**
    * @Description: 批处理请求
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    @Test
    void addBulkDocument() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");

        ArrayList<User> userArrayList = new ArrayList<>();
        userArrayList.add(new User("zhangsan", 5));
        userArrayList.add(new User("lisi", 10));
        userArrayList.add(new User("xiaoxin", 25));

        for (int i = 0; i < userArrayList.size(); i++) {
            bulkRequest.add(
                    new IndexRequest("test")
                    .id(""+(i+1))
                    .source(JSON.toJSONString(userArrayList.get(i)), XContentType.JSON)
            );
        }

        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);

        System.out.println(bulk);
        System.out.println(bulk.status());
        System.out.println(bulk.hasFailures());

    }

    /**
    * @Description: 按条件搜索
    * @Param: []
    * @return: void
    * @Author: wang ba
    * @Date: 2020/7/29
    */
    /*
        查询：
        SearchRequest          搜索请求
        SearchSourceBuilder    条件构造
        HighlightBuilder       高亮构造
        TermQueryBuilder       精确查询
        MatchAllQueryBuilder   所有查询
        // xxxBuilder
     */
    @Test
    void searchDocument() throws IOException {
        // 创建搜索请求
        SearchRequest searchRequest = new SearchRequest("test");

        // 构造搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // QueryBuilders.termQuery 精确查询
        // QueryBuilders.matchAllQuery 查询所有

        //TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("age", "25");
        //searchSourceBuilder.query(termQueryBuilder);

        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        searchSourceBuilder.query(matchAllQueryBuilder);

        // 分页
        // searchSourceBuilder.from();
        // searchSourceBuilder.size();

        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        searchRequest.source(searchSourceBuilder);

        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(search.getHits()));
        System.out.println("+++++++++++++我是分割线++++++++++++++");
        for (SearchHit documentFields : search.getHits().getHits()) {
            System.out.println(documentFields.getSourceAsMap());
        }
    }
}