Docker搭建elasticsearch和java high level esClient实例

最新推荐文章于 2024-07-18 23:06:28 发布
最新推荐文章于 2024-07-18 23:06:28 发布
阅读量507 收藏
点赞数
文章标签： elasticsearch java es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangzhe9/article/details/105439667
版权

一、docker安装ELK

1.安装下载docker，从docker官网下载，windows和mac版都可以

链接https://www.docker.com/products/docker-desktop

2.启动docker桌面版

docker pull elasticsearch:7.5.0

docker pull logstash:7.5.0

docker pull kibana:7.5.0

 

版本最好统一，不然会有兼容类问题

等待镜像下载完成，docker images 可查看下载的镜像

二、启动elasticsearch和kibana

1、启动es

docker run -d -e ES_JAVA_POTS="-Xms256m -Xmx256m" -e "discovery.type=single-node" -p 9200:9200 -p 9300:9300 --name elasticsearch elasticsearch:7.5.0

这里指定了启动时的最大和最小内存，指定es的9200和9300端口，name为elasticsearch

启动完成后，在浏览器输入http://localhost:9200/ 可看到

代表es启动成功

2、启动kibana

docker run -d -p 5601:5601 --name kibana --link elasticsearch -e "ELASTICSEARCH_URL=http://127.0.0.1:9200" kibana:7.5.0

在浏览器输入localhost:5601可能会出现

Kibana server is not ready yet

说明还没有完全启动成功，等待片刻刷新页面就启动完成

3.可进入kibana上的DEV Tools 进行es Query 语句的书写

链接https://www.elastic.co/guide/cn/elasticsearch/guide/current/index.html

es的中文官方指南，只支持到了2.X版本，之后都只支持英文版本

三、基于RestHighLevelClient的Elasticsearchza在java中使用

1.pom包引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </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-client</artifactId>
            <version>7.5.0</version>
        </dependency>

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.5.0</version>
        </dependency>

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.5.0</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>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

pom包，记得一定要引入rest-high-level-clien和rest-client包，不然生成es的client会报错

2.创建es-Client

package com.example.demo.esUtil;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

/**
 * esClient
 * @author devin
 * @date 2020/4/10 20:39
 */
public class EsClient {


    private static int port = 9200;
    private static String host = "127.0.0.1";   //可以写 ip  但是 logstash 配置要修改

    public static RestHighLevelClient getClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                                new HttpHost(host, port, "http")
                        // 可以指定集群的多个节点地址，将客户端负载均衡地向这个节点地址集发请求
                        ));
        return client;
    }

}

3.通过java代码创建索引index

package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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.xcontent.XContentType;

import java.io.IOException;

/**
 * 创建索引
 * @author devin
 * @date 2020/4/10 20:45
 */
public class CreateIndexDemo {
    private static Logger logger = LogManager.getRootLogger();

    public static void main(String[] args) {

        RestHighLevelClient client = EsClient.getClient();
        // 创建索引
//        CreateIndexRequest request = new CreateIndexRequest("demo_index");
        CreateIndexRequest request = new CreateIndexRequest("cars");
        // 索引setting配置
        request.settings(Settings.builder().put("index.number_of_shards", 5)
                .put("index.number_of_replicas", 2) // 副本数
                .put("analysis.analyzer.default.tokenizer", "standard")
        );

//        request.mapping("{" +
//                "\"properties\": {" +
//                "\"user\": {" +
//                "\"type\": \"text\"" +
//                "}," +
//                "\"postDate\": {" +
//                "\"type\": \"date\"" +
//                "}," +
//                "\"message\": {" +
//                "\"type\": \"text\"" +
//                "}" +
//                "}" +
//                "}", XContentType.JSON);

        CreateIndexResponse response = null;
        try {
            response = client.indices().create(request, RequestOptions.DEFAULT);

            if (response != null) {
                boolean acknowledged = response.isAcknowledged();
                boolean shardsAcknowledged = response.isShardsAcknowledged();

                System.out.println("请求结果---------------");
                System.out.println("acknowledged:" + acknowledged);
                System.out.println("shardsAcknowledged:" + shardsAcknowledged);
            }
        } catch (IOException e) {
            logger.error("创建index失败", e);
        } finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }
    }
}

mapping可以根据需求自己制定需要的字段格式类型text，integer，date等，如果不指定mapping，那么在执行插入文档的时候会自动创建mapping和properties

4.新增单个文档

package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

/**
 * 新增文档
 * @author devin
 * @date 2020/4/11 10:54
 */
public class IndexDocumentDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "demo_index";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();
        // 创建索引
        IndexRequest request = new IndexRequest(INDEX).id("1");

        // 1.String方式添加数据
        String jsonString = "{" +
                "\"user\":\"devin\"," +
                "\"postDate\":\"2020-04-01\"," +
                "\"message\":\"today is a lucky day\"" +
                "}";
        request.source(jsonString, XContentType.JSON);

        /* 2.通过map设置数据
        Map<String, Object> jsonMap = new HashMap<>();
        jsonMap.put("user", "devin");
        jsonMap.put("postDate", "2020-04-01");
        jsonMap.put("message", "today is a lucky day");
        request.source(jsonMap);
          */

        /* 3.通过Builder设置数据
        try {
            XContentBuilder xContentBuilder = XContentFactory.jsonBuilder();
            xContentBuilder.startObject();
            xContentBuilder.field("user", "devin");
            xContentBuilder.field("postDate", "2020-04-01");
            xContentBuilder.field("message", "today is a lucky day");
            xContentBuilder.endObject();
            request.source(xContentBuilder);

        } catch (IOException e) {
            e.printStackTrace();
        }
         */

        /* 4.直接使用key-value
         request.source(
         "user","devin",
         "postDate", "2020-04-01",
         "message","today is a lucky day"
         );
          */

            /* 其他的一些可选设置
            request.routing("routing");  //设置routing值
            request.timeout(TimeValue.timeValueSeconds(1));  //设置主分片等待时长
            request.setRefreshPolicy("wait_for");  //设置重刷新策略
            request.version(2);  //设置版本号
            request.opType(DocWriteRequest.OpType.CREATE);  //操作类别
            */
        IndexResponse indexResponse = null;
        try {
            indexResponse = client.index(request, RequestOptions.DEFAULT);
        } catch (ElasticsearchException e) {
            if (e.status().equals(RestStatus.CONFLICT)) {
                logger.error("文档已存在冲突");
            }
            logger.error("创建文档异常", e);
        }catch (IOException e){
            logger.error(e);
        }finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }

        // 处理响应
        if(indexResponse != null) {
            String index = indexResponse.getIndex();
            String id = indexResponse.getId();
            if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
                System.out.println("新增文档成功!");
            } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
                System.out.println("修改文档成功!");
            }
            System.out.println("index:" + index);
            System.out.println("id:" + id);
        }

    }
}

新增doc有多种形式，jsonString类型，map类型，Builder类型，直接key-value类型；

5.批量新增文档

package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

/**
 * 批量新增文档
 *
 * @author devin
 * @date 2020/4/11 15:00
 */
public class BulkDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "demo_index";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();

        BulkRequest request = new BulkRequest(INDEX);
        request.add(new IndexRequest(INDEX).id("1")
                .source("user", "jack")
        );
        request.add(new IndexRequest(INDEX).id("2")
                .source("postDate", "2020-04-02")
        );
        request.add(new IndexRequest(INDEX).id("3")
                .source("message", "today is a happy day")
        );

        BulkResponse response = null;
        try {
            response = client.bulk(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            logger.error(e);
        } finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }
        if (response != null) {
            for (BulkItemResponse bulkItemResponse : response) {
                DocWriteResponse docWriteResponse = bulkItemResponse.getResponse();
                if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE
                        || bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX) {
                    // 多次执行也只是匹配到的type为新增，其实操作为update
                    IndexResponse indexResponse = (IndexResponse) docWriteResponse;
                    logger.info("新增成功id:{}", indexResponse.getId());
                } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
                    UpdateResponse updateResponse = (UpdateResponse) docWriteResponse;
                    logger.info("更新成功id:{}", updateResponse.getId());
                } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
                    DeleteResponse deleteResponse = (DeleteResponse) docWriteResponse;
                    logger.info("删除成功id{}", deleteResponse.getId());
                }
            }
        }

    }
}

6.根据文档id获取文档doc

package com.example.demo.esUtil;


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

/**
 * 获取文档
 * @author devin
 * @date 2020/4/11 14:45
 */
public class GetDocumentDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "demo_index";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();

        GetRequest request = new GetRequest(INDEX).id("1");
        GetResponse response = null;
        try {
            response = client.get(request, RequestOptions.DEFAULT);
        } catch (ElasticsearchException e) {
            if (e.status() == RestStatus.NOT_FOUND) {
                logger.error("没有找到文档");
            }
        } catch (IOException e) {
            logger.error("获取文档异常", e);
        }finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }

        if (response != null) {
            String index = response.getIndex();
            String id = response.getId();
            if (response.isExists()) {
                String sourceAsString = response.getSourceAsString();
                logger.info("index:" + index + "  id:" + id);
                logger.info(sourceAsString);
            }
        }
    }
}

7.搜索语句获取文档

package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;

import java.io.IOException;
import java.util.Arrays;

/**
 * 搜索文档
 * @author devin
 * @date 2020/4/11 15:58
 */
public class SearchDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "demo_index";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();

        SearchRequest request = new SearchRequest(INDEX);
        // 其实这些最后都会转化为String类型的 es query查询语句，只不过java封装了可以省却了写原生query语句
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        // 全匹配查询
        /*
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        searchSourceBuilder.query(matchAllQueryBuilder);
        */

        // 精确查询
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("user", "devin");
        searchSourceBuilder.query(termQueryBuilder);


        searchSourceBuilder.from(0);
        searchSourceBuilder.size(10);

        //指定排序
        /*
        searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
        searchSourceBuilder.sort(new FieldSortBuilder("_id").order(SortOrder.ASC));
        */

        request.source(searchSourceBuilder);
        SearchResponse response = null;
        try {
            response = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            logger.error(e);
        }finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }
        if(response != null){
            SearchHits hits = response.getHits();
            SearchHit[] searchHits = hits.getHits();
            Arrays.stream(searchHits).forEach( h ->
                    logger.info(h.toString())
            );
        }

    }

}

8.聚合查询aggs

此聚合查询使用的是官方文档中的cars index，附带批量插入cars代码

官方文档链接：

https://www.elastic.co/guide/cn/elasticsearch/guide/current/_aggregation_test_drive.html
package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;

/**
 * 批量新增文档 根据官方文档数据
 * https://www.elastic.co/guide/cn/elasticsearch/guide/current/_aggregation_test_drive.html
 * @author devin
 * @date 2020/4/11 15:00
 */
public class CarsBulkDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "cars";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();

        BulkRequest request = new BulkRequest(INDEX);
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 10000, \"color\" : \"red\", \"make\" : \"honda\", \"sold\" : \"2014-10-28\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 20000, \"color\" : \"red\", \"make\" : \"honda\", \"sold\" : \"2014-11-05\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 30000, \"color\" : \"green\", \"make\" : \"ford\", \"sold\" : \"2014-05-18\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 15000, \"color\" : \"blue\", \"make\" : \"toyota\", \"sold\" : \"2014-07-02\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 12000, \"color\" : \"green\", \"make\" : \"toyota\", \"sold\" : \"2014-08-19\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 20000, \"color\" : \"red\", \"make\" : \"honda\", \"sold\" : \"2014-11-05\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 80000, \"color\" : \"red\", \"make\" : \"bmw\", \"sold\" : \"2014-01-01\" }", XContentType.JSON
                )
        );
        request.add(new IndexRequest(INDEX)
                .source("{ \"price\" : 25000, \"color\" : \"blue\", \"make\" : \"ford\", \"sold\" : \"2014-02-12\" }", XContentType.JSON
                )
        );


        BulkResponse response = null;
        try {
            response = client.bulk(request, RequestOptions.DEFAULT);
        } catch (
                IOException e) {
            logger.error(e);
        } finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }
        if (response != null) {
            for (BulkItemResponse bulkItemResponse : response) {
                DocWriteResponse docWriteResponse = bulkItemResponse.getResponse();
                if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE
                        || bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX) {
                    // 多次执行也只是匹配到的type为新增，其实操作为update
                    IndexResponse indexResponse = (IndexResponse) docWriteResponse;
                    logger.info("新增成功id:{}", indexResponse.getId());
                } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
                    UpdateResponse updateResponse = (UpdateResponse) docWriteResponse;
                    logger.info("更新成功id:{}", updateResponse.getId());
                } else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
                    DeleteResponse deleteResponse = (DeleteResponse) docWriteResponse;
                    logger.info("删除成功id{}", deleteResponse.getId());
                }
            }
        }

    }

}

聚合查询

package com.example.demo.esUtil;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.Avg;
import org.elasticsearch.search.aggregations.metrics.Max;
import org.elasticsearch.search.aggregations.metrics.Min;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

/**
 * 聚合查询 已官方文档中的cars为例
 * https://www.elastic.co/guide/cn/elasticsearch/guide/current/_one_final_modification.html
 *
 * @author devin
 * @date 2020/4/11 16:17
 */
public class AggregationDemo {
    private static Logger logger = LogManager.getRootLogger();

    private static final String INDEX = "cars";

    public static void main(String[] args) {
        RestHighLevelClient client = EsClient.getClient();

        // 1、创建search请求
        SearchRequest request = new SearchRequest(INDEX);


        // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.size(0);

        //加入聚合
        //字段值项分组聚合
        TermsAggregationBuilder aggregation = AggregationBuilders.terms("colors")
                .field("color.keyword");

        // 计算通过color分组后的平均价格
        aggregation.subAggregation(
                AggregationBuilders.avg("avg_price").field("price")
        );
        aggregation.subAggregation(
                AggregationBuilders.terms("make").field("make.keyword")
                        .subAggregation(AggregationBuilders.max("max_price").field("price"))
                        .subAggregation(AggregationBuilders.min("min_price").field("price"))
        );


        searchSourceBuilder.aggregation(aggregation);

        System.out.println("----------");
        System.out.println(searchSourceBuilder.toString());
        request.source(searchSourceBuilder);

        //3、发送请求
        SearchResponse response = null;
        try {
            response = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            logger.error(e);
        } finally {
            try {
                client.close();
            } catch (IOException e) {
                logger.error(e);
            }
        }

        if (response != null && response.status() == RestStatus.OK) {
            Aggregations aggregations = response.getAggregations();
            Terms colors = aggregations.get("colors");
            for (Terms.Bucket bucket : colors.getBuckets()) {
                logger.info("------------------");
                logger.info("color:{}", bucket.getKeyAsString());
                Aggregations aggregations1 = bucket.getAggregations();
                Avg avg_price = aggregations1.get("avg_price");
                logger.info("avg_price:{}", avg_price.getValue());
                Terms make = bucket.getAggregations().get("make");
                for (Terms.Bucket bucket2 : make.getBuckets()) {
                    logger.info("make:{}", bucket2.getKeyAsString());
                    Max max_price = bucket2.getAggregations().get("max_price");
                    Min min_price = bucket2.getAggregations().get("min_price");
                    logger.info("max_price=" + max_price.getValue());
                    logger.info("min_price=" + min_price.getValue());
                }
            }
        }
    }

}

 

附带gitHub代码地址

https://github.com/liangzhe9/elasticsearch

斜阳QvQ
关注
Docker安装 ElasticSearch
可可很爱玩！
08-05 226
准备工作：docker环境准备完毕 单机使用docker建立elasticsearch集群：用于开发环境进行测试 就是同一个机器上面安装俩个es服务，伪集群 创建es集群 使用docker建立elasticsearch集群 到这里默认机器已经安装完毕docker 注意事项： ES集群环境中： 集群内所有节点的集群名称必须一致：即 cluster.name 集群内节点名...
docker安装elasticsearch
qq_35137375的博客
02-06 281
为什么需要使用Elasticsearch？ Elasticsearch底层采用倒排索引对文档的内容进行关键词分词，每个关键词对应多个文档出现具体位置信息，后期查询的时候直接通过分词定位到相关的文档信息，默认情况下Elasticsearch对中文分词不是很友好，可以采用第三方Ik分词器或者自定义热词。 docker安装ES 1.首先安装好jdk环境（此处省略…） 2.下载ES镜像 docker ...
安装elasticsearch
Prozac17的博客
06-21 353
安装elasticsearch镜像 docker pull elasticsearch:7.4.0 安装可视化检索数据 docker pull kibana:7.4.0 创建实例 mkdir -p /mydata/elasticsearch/config mkdir -p /mydata/elasticsearch/data echo "http.host:0.0.0.0">>/mydata/elasticsearch/config/elasticsearch.yml dock
Docker安装ElasticSearch
热门推荐
u014526891的博客
09-24 1万+
上一篇我们介绍了Docker的一些入门，这篇我们来实战安装下ElasticSearch。 一、Docker 部署 ElasticSearch 1、从仓库中查找所有ElasticSearch的镜像 [root@iZwz99dhxbd6xwly17tb3bZ app]# docker search elasticsearch INDEX NAME ...
docker部署Elasticsearch和Kibana
youxmm的博客
07-18 865
是一个开源的分布式搜索和分析引擎，用于处理大规模数据的实时搜索、分析和存储。它构建在Apache Lucene搜索引擎库的基础上，提供了一个RESTful API和易于使用的工具，使得在大数据量情况下进行搜索和分析变得高效和简单。
Elasticsearch Java Rest Client API 整理总结 (三)——Building Queries
dianqiulai2465的博客
11-21 184
目录 上篇回顾 Building Queries 匹配所有的查询 全文查询 Full Text Queries 什么是全文查询？ Match 全文查询 API 列表 基于词项的查询 Term...
原生Java开发的路该怎么走？大牛最佳总结
m0_57767600的博客
07-15 112
第一个 分布式：限流 1.1 ZooKeeper+Nginx面试常备题（附答案） ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括:配置维护、域名服务、分布式同步、组服务等。ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户。 ZooKeeper 是什么？ ZooKeeper 提供了
Docker部署ElasticSearch
Oumuv的博客
08-27 477
前提 ElasticSearch 6.5.2 步骤 一、docker下载ES镜像 docker pull docker.io/elasticsearch:6.5.2 二、启动ES docker run -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms256m -Xms256m" --name es docker.io/elasticsearch:6.5.2 -e ES_JAVA_OPTS="-Xms256m -Xms256m"解决ES启动，初始化内存不
Docker 安装mysql nginx elasticsearch redis RabbitMQ
chengqingshihuishui的博客
08-01 319
Docker安装Nginx
【异常】Docker安装elasticsearch7, 浏览使用 9200 无法打开
seowen的开发 小本子
02-27 1872
查看 容器日志如下： {"type": "server", "timestamp": "2020-02-27T11:29:46,236+08:00", "level": "INFO", "component": "o.e.p.PluginsService", "cluster.name": "docker-cluster", "node.name": "hadoop_elasticsearch...
docker-compose搭建部署 Skywalking
qq_27735079的博客
10-11 2295
谷歌在 2010 年 4 月发表了一篇论文《Dapper, a Large-Scale Distributed Systems Tracing Infrastructure》介绍了分布式追踪的概念，之后很多互联网公司都开始根据这篇论文打造自己的分布式链路追踪系统。APM 系统的核心技术就是分布式链路追踪。
docker安装elasticsearch 配置用户
最新发布
07-24
现在你已经拥有了一个包含 Elasticsearch 实例的 Docker 镜像，可以运行容器并启动 Elasticsearch： ```bash docker run -d --name elasticsearch_container -p 9200:9200 my-elasticsearch ``` 这里，`-d` 表示...
elk7.10.2分布式集群安装（docker版）
leveretz的博客
02-18 806
elk7.10.2分布式集群安装（docker版） 结构设计 首先，logstash 具有日志采集、过滤、筛选等功能，功能完善但同时体量也会比较大，消耗系统资源自然也多。filebeat作为一个轻量级日志采集工具，虽然没有过滤筛选功能，但是仅仅部署在应用服务器作为我们采集日志的工具可以是说最好的选择。但我们有些时候可能又需要logstash的过滤筛选功能，所以我们在采集日志时用filebeat，然后交给logstash过滤筛选。 其次，logstash的吞吐量是有限的，一旦短时间内fileb.
docker安装elasticsearch,springboot整合elasticsearch报错
shushanxianlv22的博客
08-17 427
docker安装elasticsearch docker run -d -e ES_JAVA_POTS="-Xms256m -Xmx256m" -e “discovery.type=single-node” -p 9200:9200 -p 9300:9300 --name ES3 8f46db60ddd6(镜像id) ES_JAVA_POTS限制分配内存大小 springboot整合elasti...
ES基本操作
LeungKiChen
03-14 213
ES基本操作
Elasticsearch java api 6.6 Document APIs(5) Update API
小虫滴博客
04-11 489
Update API Update Request UpdateRequest需要以下参数: UpdateRequest request = new UpdateRequest( "posts", "doc", "1"); Update API允许通过使用脚本或传递部分文档来更新现有文档。 使用脚本进行更新 该脚本可以作为内联脚...
python使用request库把响应结果写入excel
weixin_44857268的博客
01-31 1420
新的一年了，又开始打工了，现在产品需求还没定，把年前测好的需求回归完，没啥事做就倒腾了一下代码。写这个代码是因为年前男朋友说家里查电费那个网站现在查询更多得开会员才行，我直接一个好家伙啊，当时想的是那就写一个定时任务每天跑一下查询并保存嘛。结果我抓到请求在postman里一调用，发现这个网站只有前端校验了日期，后端根本就没校验，想查多久就查多久。那事情就变得简单了。我是用 requests 库实现接口请求， xlwt 库进行excel操作；
Es7.x使用RestHighLevelClient进行增删改和批量操作
杜海的博客
01-27 1万+
引入依赖 初始化RestHighLevelClient和BulkProcessor对象 增删改操作 3.1 数据准备 3.2 单条数据异步插入 3.3 单条数据同步插入 3.4 批量插入 3.5 更新操作 3.6 带条件的更新语句 3.7 批量更新 3.8 删除操作 3.9 条件删除 Java层面操作elasticSearch7.x，为了便于操作，不集成Spring，使用main方法进行调用。 1. 引入依赖 <!--解决：java.lang.NoCla
ElasticSearch5.4 基本增删查改、搜索模板类
theonlytao的博客
07-13 1130
import lombok.Data; import org.elasticsearch.action.DocWriteResponse; import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse; import org.elasticsearch.action.admin.indices.exists.
Docker搭建Java Web运行环境详解
要搭建Java Web运行环境，首先我们需要一个包含Java运行时环境（JRE）和Web服务器（如Tomcat）的Docker镜像。通常，我们可以从Docker Hub上拉取预构建的官方镜像，如`tomcat:latest`。 接下来，我们将介绍如何创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值