Elastic Search Java Api

前路迢迢 2018-01-16

前言

前文我们提到过Elastic Search 操作索引的 Rest Api。实际上 Elastic Search 的 Rest Api 提供了所有的操作接口。在编程语言中可以直接这么使用 Rest Api 可以调用 Elastic Search 的所有功能，但是非常的不方便和直观，所以Elastic Search 官方也为很多语言提供了访问的 Api 接口。官方提供的编程语言接口包括：

  • Java
  • JavaScript
  • Groovy
  • PHP
  • .NET
  • Perl
  • Python
  • Ruby

同时编程社区也提供了大量的编程语言的 Api。目前主要有

  • B4J
  • Clojure
  • ColdFusion (CFML)
  • Erlang
  • Go
  • Groovy
  • Haskell
  • Java
  • JavaScript
  • kotlin
  • Lua
  • .NET
  • OCaml
  • Perl
  • PHP
  • Python
  • R
  • Ruby
  • Rust
  • Scala
  • Smalltalk
  • Vert.x

平时我们都是用 Java 进行开发。所以这里我会谈谈 Elastic Search 的 Java Api 的使用方式

准备工作

为了说明 Java Api 的功能，我们准备了一个场景。在这里我们假定有一批作者，每个作者都有标识、姓名、性别、年龄，描述着几个字段。我们需要通过姓名、年龄、描述中的关键词来查询作者，

在这里，程序主要通过 JUnit 测试用例的方式来运行，所以首先引入了 JUnit 的依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

Java Api 概述

Elastic Search 提供了官方的 Java Api。这里包括两类，一类是 Low Level Rest Api（低级 Rest Api）和 High Leve Rest Api（高级 Rest Api）。

所谓低级 Api 并不是功能比较弱，而是指 Api 离底层实现比较近。官方提供的低级 Api 是对原始的 Rest Api 的第一层封装。只是把 Http 调用的细节封装起来。程序还是要自己组装查询的条件字符串、解析返回的结果 json 字符串等。同时也要处理 http 协议的 各种方法、协议头等内容。

高级 api 是在低级 api 上的进一步封装，不用在在意接口的方法，协议头，也不用人工组合调用的参数字符串，同时对返回的 json 字符串有一定的解析。使用上更方便一些。但是高级 api 并没有实现所有低级 api 实现的功能。所以如果遇到这种情况，还需要利用低级 api 来实现自己功能。

第三方 Java 客户端是有社区自己开发的 Elastic Search 客户端。官方提到了两个开源在 GitHub 上的项目 Flummi、Jest

Java Low Level Rest Api 使用说明

低级 Api 的优势在于依赖的其他库非常少，而且功能完备。缺点在于封装不够高级，所以使用起来还是非常的繁琐。我们这里先来看看低级的 api 是怎么使用的。

引入依赖

在前面建立的 Maven Java 工程中，要使用 Elastic Search 的低级 Api，首先要引入 低级 Api 的依赖。如下所示

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>6.1.1</version>
</dependency>

建立客户端

RestClient restClient = RestClient.builder(
        new HttpHost("localhost", 9200, "http"),
        new HttpHost("localhost", 9201, "http")).build();

我们通过 RestClient 对象的静态方法 builder(HttpHost... hosts) 和 builder()建立一个 Elastic Search 的 Rest 客户端。其中 hosts 是一个可变参数，用来指定 Elastic Cluster 集群的节点的 ip、端口、协议。

方法调用

建立了客户端以后，通过两类方法来调用 Rest Api。一类是同步调用，一类是异步调用。

同步调用

同步调用主要的方法声明如下所示：

public Response performRequest(String method, String endpoint, Header... headers) throws IOException

public Response performRequest(String method, String endpoint, Map<String, String> params, Header... headers) throws IOException

public Response performRequest(String method, String endpoint, Map<String, String> params,
                                   HttpEntity entity, Header... headers) throws IOException

这是三个重载的方法，参数 method 代表的是 Rest Api 的方法，例如 PUT、GET、POST、DELETE等；参数 endpoint 代表的是 Rest Api 参数的地址，从 Rest Api 的 URL 的 ip:port 字段之后开始；params 是通过 url 参数形式传递的参数；entity 是通过 http body 传递的参数；headers 是一个可变参数，可以传入对应的 http 头信息。

例如，我要查看一个索引 author_test 的信息，我们可以用如下的代码来获取

Response response = restClient.performRequest("GET", "/author_test");

再比如，我们要查看一个索引 author_test 中 des 字段中包含软件的文档信息，我们可以用如下代码来获取：

String queryJson = "{\n" +
        "    \"query\": {\n" +
        "        \"match\": {\n" +
        "            \"des\": \"软件\"\n" +
        "        }\n" +
        "    }\n" +
        "}";
Response response = restClient.performRequest("POST",
        "/author_test/_search",
        new HashMap<String, String>(),
        new NStringEntity(queryJson,ContentType.APPLICATION_JSON));

异步调用

异步调用和同步调用的参数是一样的，但是异步调用没有返回值，而是在参数中有一个 ResponseListener 回调对象，在调用完成后自动调用。这个回调对象是一个接口，需要程序员自己来实现。

异步调用的方法声明如下所示：

public void performRequestAsync(String method, String endpoint, ResponseListener responseListener, Header... headers)

public void performRequestAsync(String method, String endpoint, Map<String, String> params,
                                    ResponseListener responseListener, Header... headers)

public void performRequestAsync(String method, String endpoint, Map<String, String> params,
                                    HttpEntity entity, ResponseListener responseListener, Header... headers)

例如，我要用异步调用的方式查询 author_test 索引中 des 中包含 “软件” 的所有文档，则代码实现如下

String queryJson = "{\n" +
        "    \"query\": {\n" +
        "        \"match\": {\n" +
        "            \"des\": \"软件\"\n" +
        "        }\n" +
        "    }\n" +
        "}";


restClient.performRequestAsync("POST",
        "/author_test/_search",
        new HashMap<String, String>(),
        new NStringEntity(queryJson, ContentType.APPLICATION_JSON), new ResponseListener() {
            public void onSuccess(Response response) {
                try {
                    String responseData = readResposne(response);
                    System.out.println("******* search success ******");
                    System.out.println(responseData);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            public void onFailure(Exception exception) {
                exception.printStackTrace();
            }
        });

Java High Level Rest Api 使用说明

Elastic Search 的 Java 高级 Api 相对低级 Api 来说，抽象程度更高一些。不过我个人觉得还是挺难用的。而且高级 Api 并不支持所有的 Rest Api 的功能。官方有高级 Api 支持的功能列表。从这里看，如果你只是做查询，用高级 Api 接口还是够用的。

引入依赖

在前面建立的 Maven Java 工程中，要使用 Elastic Search 的低级 Api，首先要引入 低级 Api 的依赖。如下所示

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

建立客户端

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));

和低级接口类似，先通过 RestClient 对象的静态方法 builder(HttpHost... hosts)方法建立一个 RestClientBuilder 对象，然后作为 RestHighLevelClient 对象构造函数的参数，来创建一个新的高级客户端对象。其中 hosts 是一个可变参数，用来指定 Elastic Cluster 集群的节点的 ip、端口、协议。

方法调用

这里用高级接口来实现低级接口中第一个查询的功能。代码如下

SearchRequest searchRequest = new SearchRequest("author_test");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("des", "软件"));
sourceBuilder.from(0);
sourceBuilder.size(5);
searchRequest.source(sourceBuilder);
SearchResponse response = restClient.search(searchRequest);

其他的接口的调用都可以查找对应的 api 文档说明来完成

完整代码

最后一个章节将完整的代码贴出来。

初始化代码

这部分代码负责初始化测试的索引和索引文档。需要注意一下，前面我们说过 Elastic Search 是一个准实时的系统，所以索引完文档后，如果马上查询，可能查询不到数据，需要有一个小的延迟。

package com.x9710.es.test;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.entity.ContentType;
import org.apache.http.nio.entity.NStringEntity;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

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

public class IndexInitUtil {
    public RestClient initLowLevelClient() {
        // 通过 ip 、port 和协议建立 Elastic Search 客户端
        RestClient restClient = RestClient.builder(
                new HttpHost("10.110.2.53", 9200, "http")).build();


        try {
            initIndex(restClient);

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

    public RestHighLevelClient initHighLevelClient() {
        // 通过 ip 、port 和协议建立 Elastic Search 客户端
        RestHighLevelClient highLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("10.110.2.53", 9200, "http"))
        );

        RestClient restClient = RestClient.builder(
                new HttpHost("10.110.2.53", 9200, "http")).build();

        try {
            initIndex(restClient);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                restClient.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


        return highLevelClient;
    }

    private void initIndex(RestClient restClient) {

        String authIndexDefine = "{\n" +
                "\t\"settings\" : {\n" +
                "        \"index\" : {\n" +
                "            \"number_of_shards\" : 6,\n" +
                "            \"number_of_replicas\" : 0\n" +
                "        }\n" +
                "    },\n" +
                "    \"mappings\": {\n" +
                "        \"doc\": {\n" +
                "            \"properties\": {\n" +
                "            \t\"id\": {\"type\": \"text\"},\n" +
                "                \"name\": {\"type\": \"text\"},\n" +
                "                \"sex\": {\"type\": \"text\"},\n" +
                "                \"age\": {\"type\": \"integer\"},\n" +
                "                \"des\":{\n" +
                "                \t\"type\":\"text\",\n" +
                "                \t\"analyzer\": \"ik_max_word\",\n" +
                "\t\t\t\t\t\"search_analyzer\": \"ik_max_word\"\n" +
                "                }\n" +
                "            }\n" +
                "        }\n" +
                "    }\n" +
                "}";

        HttpEntity authorIndexEntity = new NStringEntity(authIndexDefine, ContentType.APPLICATION_JSON);
        //初始化要索引的 author 文档列表
        List<HttpEntity> authorDocs = new ArrayList<HttpEntity>();
        authorDocs.add(new NStringEntity(" {\n" +
                "\t\"id\":\"A1001\",\n" +
                "\t\"name\":\"任盈盈\",\n" +
                "\t\"age\":24,\n" +
                "\t\"sex\":\"女\",\n" +
                "\t\"des\":\"IT软件工程师，擅长Java和软件架构\"\n" +
                " }", ContentType.APPLICATION_JSON));
        authorDocs.add(new NStringEntity(" {\n" +
                "\t\"id\":\"A1002\",\n" +
                "\t\"name\":\"风清扬\",\n" +
                "\t\"age\":47,\n" +
                "\t\"sex\":\"男\",\n" +
                "\t\"des\":\"IT软件技术经理，擅长技术管理过程控制\"\n" +
                " }", ContentType.APPLICATION_JSON));


        try {
            //创建 author_test 索引
            restClient.performRequest("PUT", "/author_test", new HashMap<String, String>(), authorIndexEntity);

            //索引 author_index 文档
            for (int i = 0; i < authorDocs.size(); i++) {
                restClient.performRequest("POST", "/author_test/doc", new HashMap<String, String>(), authorDocs.get(i));
            }
            //注意索引文档完成后，做一个小的延迟，保证后续查询能查到数据
            Thread.currentThread().sleep(1000);

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

低级 Api 测试样例

package com.x9710.es.test;

import org.apache.http.entity.ContentType;
import org.apache.http.nio.entity.NStringEntity;
import org.codehaus.jettison.json.JSONObject;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.ResponseListener;
import org.elasticsearch.client.RestClient;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;

/**
 * Elastic Search 低级 Api 测试类
 *
 * @author 杨高超
 * @since 2018-01-11
 */
public class LowLeveApiTest {
    RestClient restClient = null;

    @Before
    public void before() {
        restClient = new IndexInitUtil().initLowLevelClient();
    }

    @Test
    public void testLocateAuthorIndex() {
        try {
            Response response = restClient.performRequest("GET", "/author_test");
            String responseData = readResposne(response);
            Assert.assertTrue(new JSONObject(responseData).has("author_test"));
            System.out.println(responseData);
        } catch (Exception e) {
            e.printStackTrace();
            Assert.assertTrue(false);
        }
    }


    @Test
    public void testQueryAuthDoc() {
        try {
            String queryJson = "{\n" +
                    "    \"query\": {\n" +
                    "        \"match\": {\n" +
                    "            \"des\": \"Java\"\n" +
                    "        }\n" +
                    "    }\n" +
                    "}";
            Response response = restClient.performRequest("POST",
                    "/author_test/_search",
                    new HashMap<String, String>(),
                    new NStringEntity(queryJson, ContentType.APPLICATION_JSON));

            String responseData = readResposne(response);
            JSONObject responseJson = new JSONObject(responseData);
            Assert.assertTrue(responseJson.has("hits")
                    && responseJson.getJSONObject("hits").getInt("total") == 1);
            System.out.println(responseData);
        } catch (Exception e) {
            e.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testQueryAuthDocAsy() {
        try {
String queryJson = "{\n" +
        "    \"query\": {\n" +
        "        \"match\": {\n" +
        "            \"des\": \"软件\"\n" +
        "        }\n" +
        "    }\n" +
        "}";


restClient.performRequestAsync("POST",
        "/author_test/_search",
        new HashMap<String, String>(),
        new NStringEntity(queryJson, ContentType.APPLICATION_JSON), new ResponseListener() {
            public void onSuccess(Response response) {
                try {
                    String responseData = readResposne(response);
                    System.out.println("******* search success ******");
                    System.out.println(responseData);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            public void onFailure(Exception exception) {
                exception.printStackTrace();
            }
        });
        } catch (Exception e) {
            e.printStackTrace();
            Assert.assertTrue(false);
        }
    }


    @After
    public void after() {
        try {
            if (restClient != null) {
                restClient.performRequest("DELETE", "/author_test");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (restClient != null) {
                try {
                    restClient.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private String readResposne(Response response) throws Exception {
        BufferedReader brd = new BufferedReader(new BufferedReader(new InputStreamReader(response.getEntity().getContent())));
        String line;
        StringBuilder respongseContext = new StringBuilder();

        while ((line = brd.readLine()) != null) {
            respongseContext.append(line).append("\n");
        }
        //rd.close();
        if (respongseContext.length() > 0) {
            respongseContext.deleteCharAt(respongseContext.length() - 1);
        }
        return respongseContext.toString();
    }
}

高级 Api 测试样例

package com.x9710.es.test;

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * Elastic Search 高级 Api 测试类
 *
 * @author 杨高超
 * @since 2018-01-11
 */
public class HighLevelApiTest {
    RestHighLevelClient restClient = null;

    @Before
    public void before() {
        restClient = new IndexInitUtil().initHighLevelClient();
    }


    @Test
    public void testQueryAuthDoc() {
        try {
SearchRequest searchRequest = new SearchRequest("author_test");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("des", "软件"));
sourceBuilder.from(0);
sourceBuilder.size(5);
searchRequest.source(sourceBuilder);
SearchResponse response = restClient.search(searchRequest);
            Assert.assertTrue(response.getHits().getTotalHits() == 2);
            System.out.println(response.toString());
        } catch (Exception e) {
            e.printStackTrace();
            Assert.assertTrue(false);
        }
    }


    @After
    public void after() {
        try {
            if (restClient != null) {
                restClient.indices().deleteIndex(new DeleteIndexRequest("author_test"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (restClient != null) {
                try {
                    restClient.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

后记

前面也提到了，社区也贡献了很多 Elastic Search 的客户端库，但是没有时间去研究。如果有人用过觉得好用，希望推荐。

前路迢迢

前路迢迢

相关推荐

Elastic Stack：Centos7安装Kibana7.7.1以及开机自启

配置文件的修改：。如果elasticsearch和kibana在一台机器上，则不需要改动。进入kibana的bin目录下，执行命令。kibana默认的端口是5601，在浏览器输入ip地址:5601,即可访问。添加到系统服务，开机自启

技术与更多 / 0评论 2020-06-06

浅尝 Elastic Stack (五) Logstash + Beats + Kafka

在 Elasticsearch、Kibana、Beats 安装 中讲到推荐架构：。本文基于 Logstash + Beats 读取 Spring Boot 日志 将其改为上述架构

goodstudy / 0评论 2020-06-05

elastic search分布式?作原理

　　Elasticsearch 是分布式的，但是对于我们开发者来说并未过多的参与其中，我们只需启动对应数量的节点，并给它们分配相同的 cluster.name 让它们归属于同?个集群，创建索引的 时候只需指定索引主分?数 即可，其他的都交给了 ES 内部?

亦碎流年 / 0评论 2020-05-04

Elastic Search 的原理

Elastic Search 是分布式的，但是对于我们开发者来说并未过多的参与其中，我们只需启动对应数量的节点，并给它们分配相同的 cluster.name，让它们归属于同一个集群，创建索引的时候只需指定索引主分片数和副分片数即可，其他的都交给了 ES 内

shawsun / 0评论 2020-04-07

时间序列数据库(TSDB)初识与选择(InfluxDB、OpenTSDB、Druid、Elastic

大数据、人工智能、物联网、机器学习、商业智能、智能预警啊等等。现在业务已经不仅仅满足于这种简单的管理和控制了。数据可视化分析，大数据信息挖掘，统计预测，建模仿真，智能控制成了各种业务的追求。时间序列数据库主要用于指处理带时间标签的数据，带时间标签的数据也称

chognzhihongseu / 0评论 2020-03-06

Elasticsearch 概念理解

当主节点和数据节点配置都设置为false的时候，该节点只能处理路由请求，处理搜索，分发索引操作等，从本质上来说该客户节点表现为智能负载平衡器。数据节点主要是存储索引数据的节点，主要对文档进行增删改查操作，聚合操作等。数据节点对cpu，内存，io要求较高，主

houhow / 0评论 2019-12-22

Elastic：如何在一个机器上同时模拟多个node

现在，我们将展示如何启动您的第一个实例。为此，请打开终端并转到Elasticsearch的安装目录。然后使用以下命令启动名为node1的节点：。此命令使用选项-E将参数node.name设置为node1。要启动其他两个实例非常简单：您只需要使用相同的命令，

阳光岛主 / 0评论 2019-12-21

Elastic 使用索引生命周期管理实现热温冷架构

索引生命周期管理 是在 Elasticsearch 6.6（公测版）首次引入并在 6.7 版正式推出的一项功能。在本篇博客中，我们将探讨如何使用 ILM 实现热温冷架构。热温冷架构常用于日志或指标类的时序数据。例如，假设正在使用 Elasticsearc

IT小小鸟 / 0评论 2019-12-21

如何在 RHEL8 /CentOS8 上建立多节点 Elastic stack 集群

Elastic stack 俗称 ELK stack，是一组包括 Elasticsearch、Logstash 和 Kibana 在内的开源产品。Elastic Stack 由 Elastic 公司开发和维护。使用 Elastic stack，可以将系统日

神龙架游记javaee / 0评论 2019-11-25

如何在RHEL8/CentOS8上建立多节点Elastic stack集群

Elastic stack 俗称 ELK stack，是一组包括 Elasticsearch、Logstash 和 Kibana 在内的开源产品。Elastic Stack 由 Elastic 公司开发和维护。使用 Elastic stack，可以将系统

向往天空的鱼 / 0评论 2019-09-27

Elastic Stack 日志分析平台搭建笔记

Elastic Stack 由 Elasticsearch、Logstash、Kibana 和 Beats 四个组件组成：。Beats，是轻量型采集器的平台，从边缘机器向 Logstash 和 Elasticsearch 发送数据。Logstash，集中、

偏头痛杨 / 0评论 2019-06-30

主流全文索引工具的比较（ Lucene, Sphinx, solr, elastic search)

））， 我发现了两个不错的候选：1. lucene 2. sphinx两者都有很不错的口碑。所以今天更加进一步的调查。） Sphinx 使用字典进行分词，所以driving 和 drive 返回的搜索结果是一样的。------------回答2.I don

年轻就要对味 / 0评论 2015-01-25

Elastic Stack实战学习教程~日志数据的收集、分析与可视化

Elastic Stack介绍近几年，互联网生成数据的速度不断递增，为了便于用户能够更快更精准的找到想要的内容，站内搜索或应用内搜索成了不可缺少了的功能之一。同时，企业积累的数据也再不断递增，对海量数据分析处理、可视化的需求也越来越高。

huizhejian / 0评论 2019-06-29

主流全文索引工具的比较（ Lucene, Sphinx, solr, elastic search)

前几天的调研（Rails3下的fulltextsearch(全文本搜索，全文匹配？）），我发现了两个不错的候选：。两者都有很不错的口碑。所以今天更加进一步的调查。把看到的有价值的文章记录在这里：。结果相关度是排序的默认条件。你也可以自行指定，也可以配置不同

momomoniqwer / 0评论 2012-06-15

Opbeat已死，请用Elastic APM

今天收到Opbeat即将关闭的邮件。APM服务众多，Opbeat有什么优势呢？简单，UI简洁可以和Git集成，方便看版本发布后性能变化类似sentry的错误收集功能后来Opbeat被Elastic收购了，做成了Elastic APM，过了快一年终于迎来关服

七夕小子 / 0评论 2019-06-27

探索 - Elastic Stack（ELK）实时日志分析平台

简介Elasticsearch搜索、分析和存储您的数据。Logstash Logstash 是动态数据收集管道，拥有可扩展的插件生态系统，能够与 Elasticsearch 产生强大的协同作用。Beats Beats 是轻量型采集器的平台，从边缘机器向

小周周i / 0评论 2019-06-27

Elastic Stack技术栈深入研究

目前beats支持以下几种：。logstash的hello worldlogstash -e 'input { stdin { } } output { stdout {} }'在logstash中有输，过滤，输出即：input，filter，output

cullinans / 0评论 2019-06-21

搜索引擎Elastic 今日在纽交所上市，股价最高暴涨122%

10 月 6 日，Elastic 正式在纽约证券交易所上市，股票代码为"ESTC"。开盘之后股价直线拉升，最高点涨幅达122%，截止到收盘涨幅回落到94%，意味着上市第一天估值接近翻倍。700 万普通股募集资金约 1.92 亿美元，上市

chaojilaji / 0评论 2018-10-08

日志分析工具Elastic Stack新版发布，加强可视化和协作工具

近日，开源搜索和分析公司Elastic发布了其Elastic Stack开源实用程序套件6.5版本，在Elastic APM工具中引入了基础架构监控，分布式跟踪支持以及Java和Go代理。虽然此版本可能被标记为“次要版本”，但Elastic解释说，基础堆栈

狐狸小七 / 0评论 2018-11-15

腾讯技术课｜基于Elastic Stack 搭建日志分析平台

随着互联网、物联网的飞速发展，软硬件系统架构变得越来越复杂，分析各种系统产生的日志也变得越来越困难。在日志分析过程中，相信大部分同学会碰到以下问题：。在错误信息的上下文中，查找与问题相关的日志时，只能通过一些简单的less、grep等命令来做过滤，效率比较

slibraL / 0评论 2018-08-31

如何在CentOS 7上安装Elastic Stack

Elasticsearch 是基于 Lucene 由 Java 开发的开源搜索引擎。)，并带有 HTTP 仪表盘的 Web 界面。数据会被 Elasticsearch 查询、检索，并且使用 JSON 文档方案存储。Elasticsearch 是一个可扩

ivanlxf / 0评论 2017-05-03

详解centos7上elastic search安装及填坑记

-Xmx2g → -Xmx512m错误2： can not run elasticsearch as root. 在 Linux 环境中，elasticsearch 不允许以 root 权限来运行！所以需要创建一个非root用户，以非root用户来起es.

IceStreamLab / 0评论 2018-01-13

elastic search(es)安装

全文搜索属于最常见的需求，开源的Elasticsearch是目前全文搜索引擎的首选。它可以快速地储存、搜索和分析海量数据。维基百科、Stack Overflow、Github 都采用它。Elastic 的底层是开源库Lucene。但是，你没法直接用 Luc

MATLAB / 0评论 2018-05-08

Elastic Search搜索引擎在SpringBoot中的实践

实验环境ES版本：5.3.0spring bt版本：1.5.9首先当然需要安装好elastic search环境，最好再安装上可视化插件 elasticsearch-head来便于我们直观地查看数据。注意在新建项目时记得勾选web和NoSQL中的Elast

学习编程 / 0评论 2018-01-10