安科网

Elasticsearch实战Java High Level REST Client实现员工管理案例

IceStreamLab

IceStreamLab

2019-11-18

关注 关注

开发环境：

elasticsearch:7.0.0
kibana:7.0.0
JDK: 1.8.0_201
maven: 3.6.1

这里讲的是实战对于如何安装elasticsearch，配置java环境变量，配置maven不做讲解

详细请查看：
elasticsearch学习笔记（四）——在windows上安装和启动Elasticsearch
https://segmentfault.com/a/11...
增量同步mysql 数据到elasticsearch canal adapter方式(binlog)实现（从零到一超级详
https://segmentfault.com/a/11...
里面有做详细讲解，对于搭建ES集群目前还没有写相关文章，读者可以自行google

1、在springboot项目的pom文件中添加elasticsearch的依赖

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

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

2、实现员工信息的增删改查

（1）构建client

我的ES机器IP是192.168.254.131，读者可自行更换

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200, "http")
                )
        );
client.close();

对于多个ip的情况，直接使用如下格式即可：

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("IP", PORT, "http"),
                        new HttpHost("IP", PORT, "http")
                        ...
                )
        );
client.close();

（2）创建员工信息

我个人比较喜欢这种格式的实现：
还有基于json字符串和map的，读者可查看：
https://www.elastic.co/guide/...
格式如下

XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field(name, value);
            builder.field(name, value);
            builder.field(name, value);
            builder.field(name, value);
            builder.field(name, value);
            ...
        }
        builder.endObject();
        IndexRequest request = new IndexRequest(index).id(id).source(builder);
        IndexResponse indexResponse =  client.index(request, RequestOptions.DEFAULT);

示例：

XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("name", "jack");
            builder.field("age", 27);
            builder.field("position", "technique");
            builder.field("country", "china");
            builder.field("join_date", "2017-01-01");
            builder.field("salary", 10000);
        }
        builder.endObject();
        IndexRequest request = new IndexRequest("employee").id("1").source(builder);
        IndexResponse indexResponse =  client.index(request, RequestOptions.DEFAULT);

（3）根据ID获取员工信息

详细请查看：
https://www.elastic.co/guide/...
格式：

GetRequest request = new GetRequest(index, id);
        GetResponse response = client.get(request, RequestOptions.DEFAULT);

示例：

GetRequest request = new GetRequest("employee", "1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);

（4）修改员工信息

详细请查看：
https://www.elastic.co/guide/...
格式：

XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field(name, value);
        }
        builder.endObject();
        UpdateRequest request = new UpdateRequest(index, id).doc(builder);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

示例：

XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("position", "technique");
        }
        builder.endObject();
        UpdateRequest request = new UpdateRequest("employee", "1").doc(builder);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

（5）删除员工信息

详细请查看：
https://www.elastic.co/guide/...
格式：

DeleteRequest request = new DeleteRequest(index, id);
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

示例：

DeleteRequest request = new DeleteRequest("employee", "1");
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

（6）测试员工信息的增删改查

完整测试代码：

/**
     * 创建员工信息
     * @param client
     * @throws Exception
     */
    private static void createEmployee(RestHighLevelClient client) throws Exception {
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("name", "jack");
            builder.field("age", 27);
            builder.field("position", "technique");
            builder.field("country", "china");
            builder.field("join_date", "2017-01-01");
            builder.field("salary", 10000);
        }
        builder.endObject();
        IndexRequest request = new IndexRequest("employee").id("1").source(builder);
        IndexResponse indexResponse =  client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.getResult());
    }

    /**
     * 获取员工信息
     * @param client
     */
    private static void getEmployee(RestHighLevelClient client) throws IOException {
        GetRequest request = new GetRequest("employee", "1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        System.out.println(response.getSourceAsString());
    }

    /**
     * 修改员工信息
     * @param client
     */
    private static void updateEmployee(RestHighLevelClient client) throws IOException {
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("position", "technique");
        }
        builder.endObject();
        UpdateRequest request = new UpdateRequest("employee", "1").doc(builder);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println(response.getResult());
    }

    /**
     * 删除员工信息
     * @param client
     */
    private static void deleteEmployee(RestHighLevelClient client) throws IOException {
        DeleteRequest request = new DeleteRequest("employee", "1");
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(response.getResult());
    }

1、测试新增

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200, "http")
                )
        );
        createEmployee(client);
        client.close();
    }

结果：

CREATED

2、测试获取数据

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200, "http")
                )
        );

        getEmployee(client);
        client.close();
    }

结果：

{"name":"jack","age":27,"position":"technique manager","country":"china","join_date":"2017-01-01","salary":10000}

3、测试更新数据

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200, "http")
                )
        );

        getEmployee(client);
        updateEmployee(client);
        getEmployee(client)
        client.close();
    }

结果：

{"name":"jack","age":27,"position":"technique manager","country":"china","join_date":"2017-01-01","salary":10000}
UPDATE
{"name":"jack","age":27,"position":"technique","country":"china","join_date":"2017-01-01","salary":10000}

4、测试删除数据

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200, "http")
                )

        );
        getEmployee(client);
        deleteEmployee(client);
        getEmployee(client);
        client.close();
    }

结果：

{"name":"jack","age":27,"position":"technique","country":"china","join_date":"2017-01-01","salary":10000}
DELETED
null

3、对员工信息进行复杂的搜索操作

需求：
（1）搜索职位中包含technique的员工
（2）同时要求age在30到40岁之间
（3）分页查询，查找第一页
准备数据：

private static void prepareData(RestHighLevelClient client) throws IOException {
        client.index(new IndexRequest("employee").id("1").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "jack")
                .field("age", 27)
                .field("position", "technique software")
                .field("country", "china")
                .field("join_date", "2017-01-01")
                .field("salary", 10000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("2").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "marry")
                .field("age", 35)
                .field("position", "technique manager")
                .field("country", "china")
                .field("join_date", "2017-01-01")
                .field("salary", 12000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("3").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "tom")
                .field("age", 32)
                .field("position", "senior technique software")
                .field("country", "china")
                .field("join_date", "2016-01-01")
                .field("salary", 11000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("4").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "jen")
                .field("age", 25)
                .field("position", "junior finance")
                .field("country", "usa")
                .field("join_date", "2016-01-01")
                .field("salary", 7000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("5").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "mike")
                .field("age", 37)
                .field("position", "finance manager")
                .field("country", "usa")
                .field("join_date", "2015-01-01")
                .field("salary", 15000)
                .endObject()
        ), RequestOptions.DEFAULT);

    }

执行：

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200)
                )
        );
        prepareData(client);
        client.close();
    }

然后构建查询语句：

GET /employee/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "position": "technique"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 30,
            "lte": 40
          }
        }
      }
    }
  },
  "from": 0,
  "size": 1
}
{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.5598161,
    "hits" : [
      {
        "_index" : "employee",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.5598161,
        "_source" : {
          "name" : "marry",
          "age" : 35,
          "position" : "technique manager",
          "country" : "china",
          "join_date" : "2017-01-01",
          "salary" : 12000
        }
      }
    ]
  }
}

代码：

private static void executeSearch(RestHighLevelClient client) throws IOException {
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("position", "technique"));
        builder.postFilter(QueryBuilders.rangeQuery("age").from(30).to(40));
        builder.from(0);
        builder.size(1);
        SearchRequest request = new SearchRequest();
        request.indices("employee");
        request.source(builder);
        SearchResponse response =  client.search(request, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

执行：

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200)
                )
        );
        executeSearch(client);
        client.close();
    }

结果：

{"name":"marry","age":35,"position":"technique manager","country":"china","join_date":"2017-01-01","salary":12000}

4、对员工信息进行聚合分析

需求：
（1）首先按照country国家来进行分组
（2）然后在每个country分组内，再按照入职年限进行分组
（3）最后计算每个分组内的平均薪资

GET /employee/_search
{
  "size": 0, 
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country.keyword"
      },
      "aggs": {
        "group_by_join_date": {
          "date_histogram": {
            "field": "join_date",
            "interval": "year"
          },
          "aggs": {
            "avg_salary": {
              "avg": {
                "field": "salary"
              }
            }
          }
        }
      }
    }
  }
}
{
  "took" : 46,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 5,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "group_by_country" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "china",
          "doc_count" : 3,
          "group_by_join_date" : {
            "buckets" : [
              {
                "key_as_string" : "2016-01-01T00:00:00.000Z",
                "key" : 1451606400000,
                "doc_count" : 1,
                "avg_salary" : {
                  "value" : 11000.0
                }
              },
              {
                "key_as_string" : "2017-01-01T00:00:00.000Z",
                "key" : 1483228800000,
                "doc_count" : 2,
                "avg_salary" : {
                  "value" : 11000.0
                }
              }
            ]
          }
        },
        {
          "key" : "usa",
          "doc_count" : 2,
          "group_by_join_date" : {
            "buckets" : [
              {
                "key_as_string" : "2015-01-01T00:00:00.000Z",
                "key" : 1420070400000,
                "doc_count" : 1,
                "avg_salary" : {
                  "value" : 15000.0
                }
              },
              {
                "key_as_string" : "2016-01-01T00:00:00.000Z",
                "key" : 1451606400000,
                "doc_count" : 1,
                "avg_salary" : {
                  "value" : 7000.0
                }
              }
            ]
          }
        }
      ]
    }
  }
}

执行：

public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.254.131", 9200)
                )
        );
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.terms("group_by_country").field("country.keyword")
                            .subAggregation(AggregationBuilders.dateHistogram("group_by_join_date").field("join_date")
                                            .dateHistogramInterval(DateHistogramInterval.YEAR)
                                            .subAggregation(AggregationBuilders.avg("avg_salary").field("salary"))));
        SearchRequest request = new SearchRequest();
        request.indices("employee");
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        Map<String, Aggregation> aggregationMap = response.getAggregations().asMap();
        ParsedStringTerms group_by_country = (ParsedStringTerms)  aggregationMap.get("group_by_country");
        for (Terms.Bucket groupByCountryBucket : group_by_country.getBuckets()) {
            System.out.println(groupByCountryBucket.getKey() + ":" + groupByCountryBucket.getDocCount());

            Histogram groupByJoinDate = (Histogram) groupByCountryBucket.getAggregations().asMap().get("group_by_join_date");
            for (Histogram.Bucket groupByJoinDateBucket : groupByJoinDate.getBuckets()) {
                System.out.println(groupByJoinDateBucket.getKey() + ":" + groupByJoinDateBucket.getDocCount());

                Avg avg = (Avg) groupByJoinDateBucket.getAggregations().asMap().get("avg_salary");
                System.out.println(avg.getValue());
            }
        }
        client.close();
    }

结果：

china:3
2016-01-01T00:00Z:1
11000.0
2017-01-01T00:00Z:2
11000.0
usa:2
2015-01-01T00:00Z:1
15000.0
2016-01-01T00:00Z:1
7000.0

附上完整代码：

EmployeeCRUDApp.java

import org.apache.http.HttpHost;
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.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;

import java.io.IOException;

public class EmployeeCRUDApp {

    public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )

        );

        createEmployee(client);
        getEmployee(client);
        updateEmployee(client);
        getEmployee(client);
        deleteEmployee(client);
        getEmployee(client);
        client.close();
    }

    /**
     * 创建员工信息
     * @param client
     * @throws Exception
     */
    private static void createEmployee(RestHighLevelClient client) throws Exception {
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("name", "jack");
            builder.field("age", 27);
            builder.field("position", "technique manager");
            builder.field("country", "china");
            builder.field("join_date", "2017-01-01");
            builder.field("salary", 10000);
        }
        builder.endObject();
        IndexRequest request = new IndexRequest("employee").id("1").source(builder);
        IndexResponse indexResponse =  client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.getResult());
    }

    /**
     * 获取员工信息
     * @param client
     */
    private static void getEmployee(RestHighLevelClient client) throws IOException {
        GetRequest request = new GetRequest("employee", "1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        System.out.println(response.getSourceAsString());
    }

    /**
     * 修改员工信息
     * @param client
     */
    private static void updateEmployee(RestHighLevelClient client) throws IOException {
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("position", "technique");
        }
        builder.endObject();
        UpdateRequest request = new UpdateRequest("employee", "1").doc(builder);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println(response.getResult());
    }

    /**
     * 删除员工信息
     * @param client
     */
    private static void deleteEmployee(RestHighLevelClient client) throws IOException {
        DeleteRequest request = new DeleteRequest("employee", "1");
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(response.getResult());
    }

}

EmployeeSearchApp.java

import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

/**
 * 员工搜索应用程序
 */
public class EmployeeSearchApp {

    public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200)
                )
        );
        prepareData(client);
        executeSearch(client);
        client.close();
    }

    /**
     * 执行搜索操作
     * @param client
     */
    private static void executeSearch(RestHighLevelClient client) throws IOException {
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("position", "technique"));
        builder.postFilter(QueryBuilders.rangeQuery("age").from(30).to(40));
        builder.from(0);
        builder.size(1);
        SearchRequest request = new SearchRequest();
        request.indices("employee");
        request.source(builder);
        SearchResponse response =  client.search(request, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

    /**
     * 准备数据
     * @param client
     */
    private static void prepareData(RestHighLevelClient client) throws IOException {
        client.index(new IndexRequest("employee").id("1").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "jack")
                .field("age", 27)
                .field("position", "technique software")
                .field("country", "china")
                .field("join_date", "2017-01-01")
                .field("salary", 10000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("2").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "marry")
                .field("age", 35)
                .field("position", "technique manager")
                .field("country", "china")
                .field("join_date", "2017-01-01")
                .field("salary", 12000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("3").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "tom")
                .field("age", 32)
                .field("position", "senior technique software")
                .field("country", "china")
                .field("join_date", "2016-01-01")
                .field("salary", 11000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("4").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "jen")
                .field("age", 25)
                .field("position", "junior finance")
                .field("country", "usa")
                .field("join_date", "2016-01-01")
                .field("salary", 7000)
                .endObject()
        ), RequestOptions.DEFAULT);
        client.index(new IndexRequest("employee").id("5").source(XContentFactory.jsonBuilder()
                .startObject()
                .field("name", "mike")
                .field("age", 37)
                .field("position", "finance manager")
                .field("country", "usa")
                .field("join_date", "2015-01-01")
                .field("salary", 15000)
                .endObject()
        ), RequestOptions.DEFAULT);

    }

}

EmployeeAggrApp.java

public class EmployeeAggrApp {

    public static void main(String[] args) throws Exception {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200)
                )
        );
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.terms("group_by_country").field("country.keyword")
                            .subAggregation(AggregationBuilders.dateHistogram("group_by_join_date").field("join_date")
                                            .dateHistogramInterval(DateHistogramInterval.YEAR)
                                            .subAggregation(AggregationBuilders.avg("avg_salary").field("salary"))));
        SearchRequest request = new SearchRequest();
        request.indices("employee");
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        Map<String, Aggregation> aggregationMap = response.getAggregations().asMap();
        ParsedStringTerms group_by_country = (ParsedStringTerms)  aggregationMap.get("group_by_country");
        for (Terms.Bucket groupByCountryBucket : group_by_country.getBuckets()) {
            System.out.println(groupByCountryBucket.getKey() + ":" + groupByCountryBucket.getDocCount());

            Histogram groupByJoinDate = (Histogram) groupByCountryBucket.getAggregations().asMap().get("group_by_join_date");
            for (Histogram.Bucket groupByJoinDateBucket : groupByJoinDate.getBuckets()) {
                System.out.println(groupByJoinDateBucket.getKey() + ":" + groupByJoinDateBucket.getDocCount());

                Avg avg = (Avg) groupByJoinDateBucket.getAggregations().asMap().get("avg_salary");
                System.out.println(avg.getValue());
            }
        }
        client.close();
    }
}

elasticsearch rest

IceStreamLab

IceStreamLab

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

Elasticsearch py客户端库安装及使用方法解析

elasticsearch-py是一个官方提供的low-level的elasticsearch python客户端库。因为它只是对elasticsearch的rest API接口做了一层简单的封装，因此提供了最大的灵活性，但是于此同时使用起来就不是太方便。

newbornzhao 2020-09-14

ElasticSearch最全详细使用教程

本文介绍了ElasticSearch的必备知识：从入门、索引管理到映射详解。Green - everything is good ，即最佳状态。Yellow - all data is available but some replicas are not

做对一件事很重要 2020-09-07

十张图说清Elasticsearch原理！

说到 Elasticsearch，其中最明显的一个特点就是 near real-time 准实时，当文档存储在 Elasticsearch 中时，将在 1 秒内以几乎实时的方式对其进行索引和完全搜索。Segment：也叫段，类似于倒排索引，相当于一个数据

renjinlong 2020-09-03

ElasticSearch 交互使用

tcp 0 0 10.0.0.121:5601 0.0.0.0:* LISTEN 88636/node

李玉志 2020-08-19

django 对接elasticsearch实现全文检索

# python manage.py rebuild_index #数据库有多少条数据，全部会被同步到es中。object = BookSerializer # 只读,不可以进行反序列化。fields = # text 由索引类进行返回, object

明瞳 2020-08-19

Spring Boot 集成 Elasticsearch 实战

可以在 ES 官方文档中发现，ES 为 Java REST Client 提供了两种方式的 Client：Java Low Level Client 和 Java High Level REST Client。低级别客户端，它允许通过 HTTP 请求与 E

李玉志 2020-08-19

如何对 ElasticSearch 集群进行压力测试

当 ElasticSearch 的业务量足够大，比如每天都会产生数百 GB 数据的时候，你就会自然而然的需要一个性能更强的 ElasticSearch 集群。特别是当你使用的场景是一些典型的大量数据进入的场景，比如网站日志、用户行为记录、大型电商网站的站内

mengyue 2020-08-07

操作ElasticSearch插件和可视化工具 Kibana

当 ElasticSearch 的实例并运行，您可以使用 localhost:9200,基于 JSON 的 REST API 与ElasticSearch 进行通信。在 ElasticSearch 自己的文档中，所有示例都使用 curl。但是，当使用 AP

molong0 2020-08-06

Elasticsearch实战 | match_phrase搜不出来，怎么办？

title=公路局正在治理解放大道路面积水问题。实际应用中可能需要： 1）检索关键词”理解”、”解放”、”道路”、“理解放大”，都能搜出这篇文档。标准分析仪是默认分析仪，如果没有指定，则默认使用该分词器。但，会出现冗余数据非常多。针对要求2），排除matc

AFei00 2020-08-03

Elasticsearch聚合后分页深入详解

不支持，看看Elasticsearch员工如何解读。这个问题，2014年在github上有很长的讨论。究其为什么ES不支持聚合后分页？可概括如下： 1）性能角度——聚合分页会在大量的记录中产生性能问题。2）正确性角度——聚合的文档计数不准确。所以奇怪的事情

molong0 2020-08-03

Elasticsearch大文件检索性能提升20倍实践（干货）

ES建立索引完成全文检索的前提是将待检索的信息导入Elaticsearch。项目中，有时候需要将一些扫描件、PDF文档、Word、Excel、PPT等文档内容导入Elasticsearch。比如：将《深入理解Elasticsearch》这边书导入ES，而这

wenwentana 2020-08-03

重磅 | 死磕Elasticsearch方法论认知清单（国庆更新版）

每个人都会犯错，别再让相同的错误一再发生，别再让我们为那些错误付出沉痛的代价。清单不是写在纸上的，而是印在心上的。我们别无选择，清单，正在一步步变革我们的生活，变革这个复杂的世界......——[美] 阿图-葛尔德《清单革命》。实战 | Elasticse

YYDU 2020-08-03

Elasticsearch实战 | 必要的时候，还得空间换时间!

另外一部分，则需要先做聚类、分类处理，将聚合出的分类结果存入ES集群的聚类索引中。数据处理层的聚合结果存入ES中的指定索引，同时将每个聚合主题相关的数据存入每个document下面的某个field下。

sifeimeng 2020-08-03

Elasticsearch索引增量统计及定时邮件实现

如何以相对简单的图形化效果展示数据的增量呢？本文给出思路和实现。2）crontab实现定时任务处理。步骤1，步骤2数据可以Excel统计得出。步骤3:Excel生成图表。3）开发中其他相关物理机器内存、CPU、磁盘读写性能等指标的监控等。

心丨悦 2020-08-03

如何在Linux下安装部署分布式全文搜索引擎

Elasticsearch是一个开源的分布式全文本搜索和分析引擎。它支持RESTful操作，并允许您实时存储，搜索和分析大量数据。Elasticsearch是最流行的搜索引擎之一，可为具有复杂搜索要求的应用程序提供动力，例如大型电子商务商店和分析应用程序。

liangwenrong 2020-07-31

ElasticSearch的下载、安装使用

下载ik中文分词器。浏览器访问是否启动成功。安装ik中文分词插件。解压分词插件包—->放到es的plugins目录下—->重新启动es即可

sifeimeng 2020-08-01

我也是才知道ElasticSearch条件更新是这么玩的

ElasticSearch 的使用度越来越普及了，很多公司都在使用。有做日志搜索的，有做商品搜索的，有做订单搜索的。大部分使用场景都是通过程序定期去导入数据到 ElasticSearch 中，或者通过 CDC 的方式来构建索引。在这种场景下，更新数据都是单

mengyue 2020-07-30

读写成功率达99.999%，提升ElasticSearch系统稳定性的秘密

ElasticSearch 是一个分布式的开源搜索和分析引擎，因其功能强大、简单易用而被应用到很多业务场景。在生产环境使用 ES 时，如果未进行优化则服务的稳定性可能得不到保障，目前我们使用 ES 作为账单平台的基础组件为微信支付提供服务时就遇到这种问题。

tigercn 2020-07-29

es快照备份到minio

用 API 删除快照很重要，而不能用其他机制。因为快照是增量的，有可能很多快照依赖于过去的段。deleteAPI 知道哪些数据还在被更多近期快照使用，然后会只删除不再被使用的段。但是，如果你做了一次人工文件删除，你将会面临备份严重损坏的风险，因为你在删除的

IceStreamLab 2020-07-29

Elasticsearch是一把梭，用起来再说？！

我们这边es 都是我们在推,很多开发不会用或者用的不规范！问题3：不评估可行性和高可用性，先搞起来。如下图，某公司26岁的程序员王某的Elasitcsearch一把梭用法，能很形象的说出了问题产生的根因。2019年12月初安全事件《Elasticsearc

IceStreamLab 2020-07-29
IceStreamLab

IceStreamLab

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号