Elasticsearch RestHighLevelClient操作

已于 2023-05-09 14:58:57 修改
阅读量7.4k 收藏 8
点赞数 2
分类专栏： java 文章标签： elasticsearch 搜索引擎
于 2022-03-14 11:19:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g3230863/article/details/123474534
版权

RestHighLevelClient操作

       <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.15.2</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.15.2</version>
        </dependency>


import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class RestClientConfig  {

    @Value("${es.iphosts:localhost:9200}")
    private String ipHosts;
    @Value("${es.password:null}")
    private String password;
    @Value("${es.username:null}")
    private String username;

    @Bean(destroyMethod = "close")
    public RestHighLevelClient restHighLevelClient() {
        List<HttpHost> hosts = new ArrayList<>();
        String[] iphostArray = ipHosts.split(";");
        for (int i = 0; i < iphostArray.length; i++) {
            if (StringUtils.isEmpty(iphostArray[i])) {
                continue;
            }
            hosts.add(new HttpHost(iphostArray[i].split(":")[0],
                    Integer.valueOf(iphostArray[i].split(":")[1]),"http"));
        }
        Header[] headers = new BasicHeader[2];
        headers[0] = new BasicHeader("username",username);
        headers[1] = new BasicHeader("password",password);

        RestClientBuilder builder = RestClient.builder(hosts.stream().toArray(HttpHost[]::new))
                .setDefaultHeaders(headers)
                .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
                    @Override
                    public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder builder) {
                        return builder.setConnectTimeout(5000 * 1000)
                                /** 套接字超时（默认为30秒）//更改客户端的超时限制默认30秒现在改为100*1000分钟 */
                                .setSocketTimeout(6000 * 1000); //
                    }
                });
        RestHighLevelClient client =  new RestHighLevelClient(builder);
        return client;
    }
}



import com.alibaba.fastjson.JSONObject;
import com.example.demo.es.entity.Product;
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.SearchResponse;
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.common.settings.Settings;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedDoubleTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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


@SpringBootTest
public class EsTest {
    @Autowired
    private  RestHighLevelClient client;

//    @Autowired
//    public EsTest(RestHighLevelClient restHighLevelClient){
//        this.client=restHighLevelClient;
//    }

    /**
     *  查看官网的api
     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.17/java-rest-high-create-index.html
     * @throws IOException
     */

    /**
     * 创建索引,使用ik分词器
     * @throws IOException
     */
   @Test
    public void createIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("products");
        request.settings(Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 2)
        );
        request.mapping(
                "{\n" +
                        "        \"properties\": {\n" +
                        "            \"id\": {\n" +
                        "                \"type\": \"integer\"\n" +
                        "            },\n" +
                        "            \"title\": {\n" +
                        "                \"type\": \"keyword\"\n" +
                        "            },\n" +
                        "            \"price\": {\n" +
                        "                \"type\": \"double\"\n" +
                        "            },\n" +
                        "            \"created_at\": {\n" +
                        "                \"type\": \"date\"\n" +
                        "            },\n" +
                        "            \"description\": {\n" +
                        "                \"type\": \"text\",\n" +
                        "                \"analyzer\":\"ik_max_word\"\n" +
                        "            },\n" +
                        "             \"brand\": {\n" +
                        "                \"type\": \"keyword\"\n" +
                        "            }\n" +
                        "        }\n" +
                        "    }",
                XContentType.JSON);
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse.isAcknowledged());

    }

    /**
     * 插入文档
     * @throws IOException
     */
    @Test
    public void insertDoc() throws IOException {
        IndexRequest request=new IndexRequest("products");

        Product product=new Product();
        product.setId(1);
        product.setTitle("小米手机");
        product.setPrice(1999.9d);
        product.setDescription("小米手机正好");
        request.id(product.getId().toString());
        request.source(JSONObject.toJSONString(product), XContentType.JSON);
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.getResult());

    }

    /**
     * 根据Id文档
     * @throws IOException
     */
    @Test
    public void updateDocById() throws IOException {

        UpdateRequest request=new UpdateRequest();
        request.index("products").id("1");
        Product product=new Product();
        product.setDescription("小米发烧为生");
        request.doc(JSONObject.toJSONString(product), XContentType.JSON);
        UpdateResponse  updateResponse = client.update(request, RequestOptions.DEFAULT);
        System.out.println(updateResponse.getResult());

    }

    /**
     * 根据Id删除文档
     * @throws IOException
     */
    @Test
    public void delDocById() throws IOException {
        //3.删除数据
        DeleteRequest deleteRequest=new DeleteRequest();
        deleteRequest.index("products").id("1");
        DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.getResult());
    }

    /**
     * 根据Id查询文档
     * @throws IOException
     */
    @Test
    public void getDocById() throws IOException {
        GetRequest getRequest=new GetRequest();
        getRequest.index("products").id("1");
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println("查出的数据为："+ getResponse.getSourceAsString());
    }



    /**
     * 查询所有文档
     * @throws IOException
     */
    @Test
    public void matchAllTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        query(queryBuilder);
    }

    public void query(QueryBuilder queryBuilder )throws IOException{
        SearchRequest searchRequest=new SearchRequest();
        searchRequest.indices("products");
        searchRequest.source(new SearchSourceBuilder().query(queryBuilder));
        System.out.println("查询DSL为:"+searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("返回结果为:"+searchRes.toString());
        System.out.println("总条数为:"+searchRes.getHits().getTotalHits().value);
        System.out.println("最大分数为:"+searchRes.getHits().getMaxScore());
        SearchHit[] hits = searchRes.getHits().getHits();
        for (SearchHit hit: hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        client.close();
    }


    /**
     * 根据关键词term查询
     * @throws IOException
     */
    @Test
    public void termTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.termQuery("description","小米");
        query(queryBuilder);
    }

    /**
     * 范围range查询
     * @throws IOException
     */
    @Test
    public void rangeTest() throws IOException {
        RangeQueryBuilder queryBuilder=QueryBuilders.rangeQuery("price");
        queryBuilder.gte(100);
        queryBuilder.lt(300);
        query(queryBuilder);
    }

    /**
     * 前缀prefix查询
     * @throws IOException
     */
    @Test
    public void prefixTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.prefixQuery("description","小米");
        query(queryBuilder);
    }

    /**
     * 通配符wildcard查询，?匹配一个，*匹配多个
     * title 为keyword，不分词
     * @throws IOException
     */
    @Test
    public void wildcardTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("title","*红*");
        query(queryBuilder);
    }


    /**
     * 模糊fuzzy查询
     *
     * fuzzy 模糊查询，最大模糊错误，必须现在0-2之间
     * 1.搜索关键词长度为2，不允许存在模糊
     * 2.搜索关键词长度为3-5，允许一次模糊
     * 3.搜索关键词长度大于5，允许最大2次模糊
     * @throws IOException
     */
    @Test
    public void fuzzyTest() throws IOException {
        FuzzyQueryBuilder queryBuilder = QueryBuilders.fuzzyQuery("title", "红米大机").fuzziness(Fuzziness.TWO);
        query(queryBuilder);
    }


    /**
     * ids查询
     * @throws IOException
     */
    @Test
    public void idsTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.idsQuery().addIds("1","3");
        query(queryBuilder);
    }

    /**
     * multiMatch多字段查询,基于分词器
     * @throws IOException
     */
    @Test
    public void multiMatchTest() throws IOException {
        QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery("真棒").field("title").field("description");
        query(queryBuilder);
    }

    /**
     * 分页查询 form 起始位，size条数
     * 排序查询 sort
     * 包含和排查字段
     * @throws IOException
     */
    @Test
    public void pageTest() throws IOException {
        SearchRequest searchRequest=new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder query = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
        //默认10条
        query.from(0).size(2);
        query.sort("price", SortOrder.DESC);
        //需要的字段名称
        String[] include={};
        //不需要的字段名称
        String[] exclude={"created_at"};
        query.fetchSource(include,exclude);
        searchRequest.source(query);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("总条数为:"+searchRes.getHits().getTotalHits().value);
        System.out.println("最大分数为:"+searchRes.getHits().getMaxScore());
        SearchHit[] hits = searchRes.getHits().getHits();
        for (SearchHit hit: hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        client.close();
    }



    /**
     * 高亮查询,不能用matchAllQuery查询
     * @throws IOException
     */
    @Test
    public void  highlightTest() throws IOException {
        SearchRequest searchRequest=new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder query = new SearchSourceBuilder().query(QueryBuilders.termQuery("description","苹果"));
        HighlightBuilder highlightBuilder=new HighlightBuilder();
        highlightBuilder.preTags("<font color='red'>");
        highlightBuilder.postTags("</font>");
        /**
         * 需要高亮的字段
         */
        highlightBuilder.field("title").field("description");
        highlightBuilder.requireFieldMatch(false);
        query.highlighter(highlightBuilder);
        searchRequest.source(query);
        System.out.println("查询DSL为:"+searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("返回结果为:"+searchRes.toString());
        System.out.println("总条数为:"+searchRes.getHits().getTotalHits().value);
        System.out.println("最大分数为:"+searchRes.getHits().getMaxScore());
        SearchHit[] hits = searchRes.getHits().getHits();
        for (SearchHit hit: hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
           if(highlightFields.containsKey("description")){
               System.out.println("description高亮的结果:"+highlightFields.get("description").fragments()[0]);
           }
            if(highlightFields.containsKey("title")){
                System.out.println("title高亮的结果:"+highlightFields.get("title").fragments()[0]);
            }
        }
        client.close();
    }



    /**
     * query ：精确查询，查询计算文档得分，并根据得分进行返回
     * filter query：过滤查询，用在大数量中筛选出本地查询相关数据，不会计算文档得分，经常使用filter query 结果进行缓存
     * 注意：一旦使用query和filter query 。ES 优先执行filter,然后再执行query
     *  postFilter 中可以搭配term,terms,range,ids,exists
     * @throws IOException
     */
    @Test
    public void  filterTest() throws IOException {
        SearchRequest searchRequest=new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.termQuery("description","手机"));

        //builder.postFilter(QueryBuilders.rangeQuery("price").gt(100).lt(200));
        //builder.postFilter(QueryBuilders.idsQuery().addIds("1","2"));
        //如果某个字段存在
        builder.postFilter(QueryBuilders.existsQuery("title"));
        searchRequest.source(builder);
        System.out.println("查询DSL为:"+searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("返回结果为:"+searchRes.toString());
        System.out.println("总条数为:"+searchRes.getHits().getTotalHits().value);
        System.out.println("最大分数为:"+searchRes.getHits().getMaxScore());
        SearchHit[] hits = searchRes.getHits().getHits();
        for (SearchHit hit: hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        client.close();
    }


    /**
     * aggs ：聚合查询(aggs) -sql中分组
     * @throws IOException
     */
    @Test
    public void  composeTest() throws IOException {
        SearchRequest searchRequest=new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.termQuery("title","红米手机"));
        boolQueryBuilder.should(QueryBuilders.rangeQuery("price").gt(100).lt(200));
        builder.query(boolQueryBuilder);
        searchRequest.source(builder);
        System.out.println("查询DSL为:"+searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("返回结果为:"+searchRes.toString());
        System.out.println("总条数为:"+searchRes.getHits().getTotalHits().value);
        System.out.println("最大分数为:"+searchRes.getHits().getMaxScore());
        SearchHit[] hits = searchRes.getHits().getHits();
        for (SearchHit hit: hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        client.close();

    }

    /**
     * aggs ：聚合查询(aggs) -sql中分组
     * @throws IOException
     */
    @Test
    public void  aggsTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        AggregationBuilder aggregationBuilder = AggregationBuilders.terms("priceGroup").field("price");
        builder.aggregation(aggregationBuilder);

        /**
         * 如果不需要返回查询的结果，size=0
         *      builder.size(0);
         */

        searchRequest.source(builder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        Aggregations aggregations = searchRes.getAggregations();
        /**
           因为是根据Price来分组，price是double类型的，所以用ParsedDoubleTerms,适用于k->v这种的
         */
        ParsedDoubleTerms parsedDoubleTerms = aggregations.get("priceGroup");
        List<? extends Terms.Bucket> buckets = parsedDoubleTerms.getBuckets();
        for (Terms.Bucket bucket:buckets){
            System.out.println("key:为"+bucket.getKeyAsString()+",count数量为:"+bucket.getDocCount());
        }
        client.close();

    }


    /**
     * aggs ：聚合查询(aggs) -聚合函数max，min,avg,sum
     * @throws IOException
     */
    @Test
    public void  aggsOperateTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        AggregationBuilder aggregationBuilder = AggregationBuilders.sum("priceSum").field("price");
        builder.aggregation(aggregationBuilder);

        /**
         * 如果不需要返回查询的结果，size=0
         *      builder.size(0);
         */

        searchRequest.source(builder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("id:为"+hit.getId()+",数据为:"+hit.getSourceAsString());
        }
        Aggregations aggregations = searchRes.getAggregations();

        /**
         max 使用ParsedMax处理
         min 使用ParsedMin处理
         avg 使用 ParsedAvg处理
         sum 使用ParsedSum处理
         */
        ParsedSum parsedSum = aggregations.get("priceSum");
        double sumValue = parsedSum.getValue();
        System.out.println("求和值为:"+sumValue);
        client.close();
    }

 /**
     * collapse ：折叠，比如根据菜系折叠，从每个菜系中选前2名好吃的菜
     * <p>
     * 下面是根据价格折叠，然后再每个子域中按照title折叠
     *
     * @throws IOException
     */
    @Test
    public void collapseTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();

        QueryBuilder queryBuilder = QueryBuilders.matchQuery("brand", "vivo");
        builder.query(queryBuilder);
        CollapseBuilder collapseBuilder = new CollapseBuilder("price");
        List<InnerHitBuilder> innerHits = new ArrayList<>();
        InnerHitBuilder innerHitBuilder = new InnerHitBuilder();
        innerHitBuilder.setName("r_date");
        innerHitBuilder.addSort(SortBuilders.fieldSort("created_at").order(SortOrder.DESC));
        innerHitBuilder.setSize(10);
        innerHitBuilder.setInnerCollapse(new CollapseBuilder("title"));
        innerHits.add(innerHitBuilder);
        collapseBuilder.setInnerHits(innerHits);
        builder.collapse(collapseBuilder);
        searchRequest.source(builder);
        System.out.println("查询DSL为:" + searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("id:为" + hit.getId() + ",数据为:" + hit.getSourceAsString());
            Map<String, SearchHits> innerHitsRes = hit.getInnerHits();
            for (Map.Entry<String, SearchHits> map : innerHitsRes.entrySet()) {
                String fieldKey = map.getKey();
                SearchHits innerSearchHits = map.getValue();
                SearchHit[] innerHitRes = innerSearchHits.getHits();
                for (SearchHit h : innerHitRes) {
                    System.out.println("collapse field: " + fieldKey + ",id:为" + h.getId() + ",数据为:" + h.getSourceAsString());
                }
            }

        }
        client.close();
    }


    /**
     * aggs ：聚合查询(aggs) -top_hits 取分组中的前几位
     *
     * @throws IOException
     */
    @Test
    public void aggsTopHitsTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        AggregationBuilder aggregationBuilder = AggregationBuilders.topHits("price_top").sort(SortBuilders.fieldSort("price").order(SortOrder.DESC)).size(2);
        builder.aggregation(aggregationBuilder);

        /**
         * 如果不需要返回查询的结果，size=0
         *      builder.size(0);
         */
        builder.size(0);
        searchRequest.source(builder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("id:为" + hit.getId() + ",数据为:" + hit.getSourceAsString());
        }
        Aggregations aggregations = searchRes.getAggregations();
        TopHits topHits = aggregations.get("price_top");
        SearchHits hitsRes = topHits.getHits();

        for (SearchHit hit : hitsRes.getHits()) {
            System.out.println("id:为" + hit.getId() + ",数据为:" + hit.getSourceAsString());
        }
        client.close();

    }



    /**
     * aggs ：聚合查询(aggs) -percentile_ranks 百分比排名
     *
     * 统计手机在不同的价格区间的占比
     * @throws IOException
     */
    @Test
    public void aggsPercentileRanksTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("products");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        double[] rankVal={200d,300d,500d};
        PercentileRanksAggregationBuilder aggregationBuilder = AggregationBuilders.percentileRanks("price_ranks",rankVal);
        aggregationBuilder.field("price");
        builder.aggregation(aggregationBuilder);

        /**
         * 如果不需要返回查询的结果，size=0
         *      builder.size(0);
         */
        builder.size(0);
        searchRequest.source(builder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("id:为" + hit.getId() + ",数据为:" + hit.getSourceAsString());
        }
        Aggregations aggregations = searchRes.getAggregations();
        PercentileRanks rercentileRanks  = aggregations.get("price_ranks");
        for (Percentile entry : rercentileRanks) {
            double percent = entry.getPercent();    // Percent
            double value = entry.getValue();        // Value
            System.out.println("value:"+value+"percent:"+percent);
        }
        client.close();

    }

 /**
     * 自动补全功能，使用拼音分词器搜索
     *
     * @throws IOException
     */
    @Test
    public void autoCompleteTest() throws IOException {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("stars");
        SearchSourceBuilder builder = new SearchSourceBuilder();

        CompletionSuggestionBuilder completionSuggestionBuilder=new CompletionSuggestionBuilder("name").skipDuplicates(true).size(10);
        completionSuggestionBuilder.prefix("liu");
        SuggestBuilder suggestBuilder=new SuggestBuilder();
        suggestBuilder.addSuggestion("star_name_suggest",completionSuggestionBuilder);
        builder.suggest(suggestBuilder);
        /**
         * 如果不需要返回查询的结果，size=0
         *      builder.size(0);
         */
        builder.size(0);
        /**
         * 不需要Source可以去掉
         */
        builder.fetchSource(false);
        searchRequest.source(builder);
        System.out.println("查询DSL为:" + searchRequest.source().toString());
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);

        CompletionSuggestion
               suggest = searchRes.getSuggest().getSuggestion("star_name_suggest");
        ArrayList<String> list=new ArrayList<>();
        suggest.forEach(c->c.getOptions().forEach(f->
                list.add(   f.getText().toString())
        ));
        list.forEach(System.out::println);
        client.close();

    }

}

自定义打分

根据业务规则来定制排序规则，如果同时使用sort，那么按照sort来排序，脚本无效

     SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termsQuery("brand", "vivo"));
        Map<String, Object> params = new HashMap(8);
        Map<String, Double> scoreMap = new HashMap<>(16);
        scoreMap.put("vivo手机", 2d);
        scoreMap.put("NEX手机", 1.5d);
        scoreMap.put("xplay手机", 1d);
        scoreMap.put("iQOO手机", 3d);
        params.put("scoreMap", scoreMap);

        final String scoreScript =
                "HashMap scoreMap = (HashMap)params.scoreMap;double score = 0d;" +
                        "String title = doc['title'].value;" +
                        "double price = doc['price'].value;" +
                        "double phoneScore = 0d; " +
                        "if(scoreMap.get(title)!=null){" +
                        "phoneScore = (double)scoreMap.get(title);" +
                        "} " +
                        "score = phoneScore*price+_score;" +
                        "return score;";

        ScriptScoreFunctionBuilder scriptScoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(new Script(Script.DEFAULT_SCRIPT_TYPE, Script.DEFAULT_SCRIPT_LANG, scoreScript, params));
        FunctionScoreQueryBuilder functionScoreQueryBuilder = new FunctionScoreQueryBuilder(boolQueryBuilder, scriptScoreFunctionBuilder).
                scoreMode(FunctionScoreQuery.ScoreMode.SUM).boostMode(CombineFunction.SUM);
        searchSourceBuilder.query(functionScoreQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("分数为:"+hit.getScore()+",数据为:" + hit.getSourceAsString());
        }
        client.close();

在这里插入图片描述

自定义打分(在搜索结果中增加权重)

1.更改了脚本分数的计算方式，增加了Math.log10()函数，让结果更加平稳
2.增加了weight()函数，使结果可以二次排序

  SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termsQuery("brand", "vivo"));
        Map<String, Object> params = new HashMap(8);
        Map<String, Double> scoreMap = new HashMap<>(16);
        scoreMap.put("vivo手机", 2d);
        scoreMap.put("NEX手机", 1.5d);
        scoreMap.put("xplay手机", 1d);
        scoreMap.put("iQOO手机", 3d);
        params.put("scoreMap", scoreMap);

        final String scoreScript =
                "HashMap scoreMap = (HashMap)params.scoreMap;double score = 0d;" +
                        "String title = doc['title'].value;" +
                        "double price = doc['price'].value;" +
                        "double phoneScore = 0d; " +
                        "if(scoreMap.get(title)!=null){" +
                        "phoneScore = (double)scoreMap.get(title);" +
                        "} " +
                        "score = Math.log10(1d+phoneScore*price)+_score;" +
                        "return score;";

        List<FunctionScoreQueryBuilder.FilterFunctionBuilder> filterFunctionBuilderList =  new ArrayList<>();
        filterFunctionBuilderList.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.termQuery("price","899.99"),
                ScoreFunctionBuilders.weightFactorFunction(10)));
        ScriptScoreFunctionBuilder scriptScoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(new Script(Script.DEFAULT_SCRIPT_TYPE, Script.DEFAULT_SCRIPT_LANG, scoreScript, params));
        FunctionScoreQueryBuilder.FilterFunctionBuilder filterFunctionBuilder = new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchAllQuery(), scriptScoreFunctionBuilder);
        filterFunctionBuilderList.add(filterFunctionBuilder);
        FunctionScoreQueryBuilder.FilterFunctionBuilder[] filterFunctionBuilders = filterFunctionBuilderList.toArray(new FunctionScoreQueryBuilder.FilterFunctionBuilder[filterFunctionBuilderList.size()]);
        FunctionScoreQueryBuilder functionScoreQueryBuilder = new FunctionScoreQueryBuilder(boolQueryBuilder, filterFunctionBuilders).
                scoreMode(FunctionScoreQuery.ScoreMode.SUM).boostMode(CombineFunction.SUM);
        searchSourceBuilder.query(functionScoreQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("分数为:"+hit.getScore()+",数据为:" + hit.getSourceAsString());
        }

DSL如下

{
  "function_score" : {
    "query" : {
      "bool" : {
        "filter" : [
          {
            "terms" : {
              "brand" : [
                "vivo"
              ],
              "boost" : 1.0
            }
          }
        ],
        "adjust_pure_negative" : true,
        "boost" : 1.0
      }
    },
    "functions" : [
      {
        "filter" : {
          "term" : {
            "price" : {
              "value" : "899.99",
              "boost" : 1.0
            }
          }
        },
        "weight" : 10.0
      },
      {
        "filter" : {
          "match_all" : {
            "boost" : 1.0
          }
        },
        "script_score" : {
          "script" : {
            "source" : "HashMap scoreMap = (HashMap)params.scoreMap;double score = 0d;String title = doc['title'].value;double price = doc['price'].value;double phoneScore = 0d; if(scoreMap.get(title)!=null){phoneScore = (double)scoreMap.get(title);} score = Math.log10(1d+phoneScore*price)+_score;return score;",
            "lang" : "painless",
            "params" : {
              "scoreMap" : {
                "iQOO手机" : 3.0,
                "NEX手机" : 1.5,
                "vivo手机" : 2.0,
                "xplay手机" : 1.0
              }
            }
          }
        }
      }
    ],
    "score_mode" : "sum",
    "boost_mode" : "sum",
    "max_boost" : 3.4028235E38,
    "boost" : 1.0
  }
}

nested 查询

在这里插入图片描述

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("blog_new");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String nestedPath="comments";
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        MatchQueryBuilder nameMatch = QueryBuilders.matchQuery("comments.name", "steve");
        MatchQueryBuilder ageMatch = QueryBuilders.matchQuery("comments.age", 66);
        BoolQueryBuilder queryBuilder = boolQueryBuilder.must(nameMatch).must(ageMatch);
        NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery(nestedPath, queryBuilder, ScoreMode.None);
        searchSourceBuilder.query(nestedQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchRes = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchRes.getHits();
        for (SearchHit hit : hits) {
            System.out.println("数据为:" + hit.getSourceAsString());
        }

Nested 更新

    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String nestedPath="comments";
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        MatchQueryBuilder nameMatch = QueryBuilders.matchQuery("comments.name", "steve");
        BoolQueryBuilder queryBuilder = boolQueryBuilder.must(nameMatch);
        NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery(nestedPath, queryBuilder, ScoreMode.None);
        searchSourceBuilder.query(nestedQueryBuilder);
        UpdateByQueryRequest updateByQueryRequest =new UpdateByQueryRequest();
        updateByQueryRequest.indices("blog_new");
        updateByQueryRequest.setMaxRetries(3);
        String script=" for(e in ctx._source.comments){if (e.name == params.name) {e.age = params.age; e.comment= 'very very good article...';}}";
        Map<String, Object> params =new HashMap<>();
        params.put("name","steve");
        params.put("age",48);
        updateByQueryRequest.setScript(new Script(ScriptType.INLINE, "painless", script, params));
        updateByQueryRequest.setQuery(nestedQueryBuilder);
        client.updateByQuery(updateByQueryRequest,RequestOptions.DEFAULT);

通过Http向ES发送请求，测试于ES7.10版本


 public static void httpToES() throws Exception {

        try {
            RestTemplate restTemplate = new RestTemplate();

            String endpoint = "http://localhost:9200/synonym_index/_analyze";

            // 设置请求头和请求体
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));

            Map<String, Object> requestMap = new HashMap<>();
            requestMap.put("analyzer", "ik_max_word");
            requestMap.put("text", "Hello World");

            // 创建 HttpEntity 对象
            HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestMap, headers);

            // 发送 POST 请求，并处理 Elasticsearch 返回的响应
            ResponseEntity<String> responseEntity = restTemplate.exchange(endpoint, HttpMethod.POST, requestEntity, String.class);
            String responseBody = responseEntity.getBody();

            System.out.println(responseBody);

        } catch (Exception e){
            e.printStackTrace();
        }

返回结果
在这里插入图片描述

有一些写法可以参考
https://www.kgraph.cn/218.html

Elasticsearch的使用RestHighLevelClient
zwc953685177的博客
09-14 1314
一、准备 1.1、依赖 <elasticsearch.version>7.12.1</elasticsearch.version> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version&g
ElasticSearch-RestHighLevelClient操作es（六）
qq_42218187的博客
12-01 2539
引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> 配置yml spring: data: elasticsearch: cluster-nodes: 172.
Elasticsearch——RestHighLevelClient
qin_weilong的博客
07-11 3672
介绍 java rest client有两个实现类，分别是RestClient和RestHighLevelClient。前者是一个低级客户端，通过Http与elasticsearch集群进行通信，可以做到 负载均衡、故障转移、持久化链接、自动发现集群节点等功能，同时支持所有elasticsearch版本，但是需要自己对请求和相应做编解码（自己写JSON）；后者是一个高级客户端，对增删改差进行了封...
ElasticsearchClient入门指南
最新发布
exlink2012的专栏
10-11 417
在本教程中,我们将探讨如何使用Elasticsearch的官方Java客户端 - ElasticsearchClient。这个强大的工具允许您的Java应用程序与Elasticsearch集群进行交互,执行各种操作,如索引文档、执行搜索查询等。
elasticsearch-rest-high-level-client
WGYHAPPY的博客
03-07 2896
文章目录Gradle 依赖Client 初始化RequestOptions支持的API单文档APIIndex APIGet APIGetSourceApiExists APIDelete APIUpdate APITerms Vectors API多文档APIBulk APIMulti-Get APIReindex APIUpdate By Query APIDeleted By Query APIRethrollte APIMulti Terms API Gradle 依赖 dependencies {
elasticsearch学习（七）：es客户端RestHighLevelClient
weixin_40482816的博客
09-24 3万+
Java Low Level REST Client：ES官方的低级客户端。低级别的客户端通过http与Elasticearch集群通信。Java High Level REST Client：ES官方的高级客户端。基于上面的低级客户端，也是通过HTTP与ES集群进行通信。它提供了更多的接口。客户端(Client) Jar包的版本尽量不要大于Elasticsearch本体的版本，否则可能出现客户端中使用的某些API在Elasticsearch中不支持。
中间件：ElasticSearch组件RestHighLevelClient用法详解
【积累】，是一个长期持续的过程。
01-25 8775
RestHighLevelClient的API作为ElasticSearch备受推荐的客户端组件，其封装系统操作ES的方法，包括索引结构管理，数据增删改查管理，常用查询方法，并且可以结合原生ES查询原生语法，功能十分强大。在使用RestHighLevelClient的语法时，通常涉及上面几个方面，在掌握基础用法之上可以根据业务特点进行一些自定义封装，这样可以更优雅的解决业务需求。...
ElasticSearch RestHighLevelClient 关于索引库、文档的基础操作
11-20
它的RestHighLevelClient是官方推荐的Java客户端，提供了一种与Elasticsearch服务器进行交互的高级接口，支持RESTful API，使得开发者能更方便地执行各种操作，如创建、更新、查询索引库以及管理文档。 首先，我们...
ElasticSearch RestHighLevelClient 教程（一）通用操作
热门推荐
paditang的博客
12-14 12万+
前言 ​ 项目中使用到ElasticSearch作为搜索引擎。而ES的环境搭建自然是十分简单，且本身就适应于分布式环境，因此这块就不多赘述。而其本身特性和查询语句这篇博文不会介绍，如果有机会会深入介绍。 ​ 所以这篇博文主要还是介绍Java客户端中如何使用查询搜索引擎中的数据。而使用的Java客户端是官方新推出的RestHighLevelClient，使用Http连接查询结果。但是网上
Elasticsearch RestHighLevelClient实现类似于SQL中in的操作
牙刷冰冰的博客
02-04 2085
需求：查询年龄在10岁、20岁、30岁的人员 Rest请求 GET person/_search { "query": { "bool" : { "filter" : [ { "terms" : { "age" : [ 10, 20, 30 ] } } ] } } } Java实现 boolQueryBu
【ElasticSearch】RestHighLevelClient方式对ES进行操作（三）
天涯共明月的博客
03-27 2626
使用 RestHighLevelClient 对ES进行操作（三） 目录使用 RestHighLevelClient 对ES进行操作（三）环境准备0 查询所有1 等值查询 =2 多值查询 in3 范围查询4 模糊查询5 通配符模糊查询6 统计查询（最大、最小、平均、求和）7 去重8 分组聚合9 分组排序10 多值分组聚合 上文【ElasticSearch】spring-data方式操作elasticsearch（一） 的延续 环境准备 1.添加依赖 <!-- 添加 elasticsearc.
es-elasticsearch-RestHighLevelClient-高阶
weixin_45149147的博客
07-26 343
RestHighLevelClient 注意事项 必须是jdk1.8，另外es必须是6.0版本以上
ES客户端RestHighLevelClient的使用
J_bean的博客
12-14 5599
ES客户端RestHighLevelClient的使用介绍
RestHighLevelClient的简单使用
m0_67402341的博客
06-12 3922
二、代码 1、添加索引结构到es 2、获取索引信息 3、删除索引 4、添加数据到索引中 5、局部更新索引中的数据 6、根据文档id查询索引中的数据 7、根据文档id删除索引中的数据 8、根据查询条件删除索引中的数据 9、批量插入数据到索引中 10、批量删除索引中的数据 11、高级查询之查询全部数据 12、高级查询之term精准匹配 13、高级查询之分页查询 14、高级查询之排序查询 15、高级查询之source获取部分字段内容 16、高级查询之should匹配 17、高级查询
Springboot引入elasticsearch-rest-high-level-client
怀着一颗学徒的心
11-23 2838
🌻初始化RestClient 🌻创建索引库 🌻删除索引库 🌻判断索引库是否存在 🌻小结 🌻RestClient操作文档 🌻增加文档数据 🌻 查询文档 🌻根据Id查询 🌻根据多个Id查询 🌻分页查询文档 🌻删除文档 🌻修改文档 🌻 批量导入文档 🌻 小结
Elasticsearch-RestHighLevelClient的使用
迷路剑客个人博客
11-07 5489
Elasticsearch-RestHighLevelClient的使用 1 概述 RestHighLevelClient设计在之前的Rest Client（现在称为Java Low Level REST Client）之上，主要为了替换之前的TransportClient。 相较于TransportClient，RestHighLevelClient最优之处在于可以兼容当前版本及以后版本的ES ...
ElasticSearch 使用 High Level REST Client 实现搜索等功能实战
Java知音
06-29 900
点击关注公众号，实用技术文章及时了解ES 全称 Elasticsearch 是一款分布式的全文搜索引擎，在互联网公司中，这款搜索引擎一直被程序员们所推崇。常见的使用场景如ELK日志分析，电商APP的商品推荐，社交APP的同城用户推荐等等。在ES的官网文档中，目前主要提供了两种方式访问，一种叫做Low Client，一种叫做High Level Rest Client。在今...
Springboot 整合 Elasticsearch（五）：使用RestHighLevelClient操作ES ②
原名：@程序员大禹
03-12 2535
Springboot 整合 Elasticsearch（四）：使用RestHighLevelClient操作ES ②
ElasticSearch学习笔记(二)文档操作、RestHighLevelClient的使用
挑灯日记 记录自己
06-20 1592
ElasticSearch学习笔记(一)倒排索引、ES和Kibana安装、索引操作。
Java Elasticsearch RestHighLevelClient
05-29
Java Elasticsearch RestHighLevelClient是Elasticsearch Java客户端中的一种高级REST客户端，它提供了简单易用的API，可以用于连接到Elasticsearch集群，并执行各种操作，如索引、搜索、删除、更新等。使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值