14 低级客户端入门

最新推荐文章于 2024-01-03 15:33:34 发布
最新推荐文章于 2024-01-03 15:33:34 发布
阅读量307 收藏
点赞数
分类专栏： elastic-search
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyaoyao93/article/details/112345838
版权

文章目录

说明：一般来说不会使用低级客户端，都会选用高级客户端，这里只做简单的介绍，后面会面详细介绍高级客户端的使用，高级客户端也是基于低级客户端的。

1 环境准备

1.1 依赖

  1. 依赖
<dependencies>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-client</artifactId>
        <version>7.10.1</version>
    </dependency>
    <dependency>
    	<!--高级客户端-->
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>7.10.1</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
    </dependency>
 </dependencies>

1.2 索引库准备

PUT books
{
  "settings": {
    "number_of_shards": 3, 
    "number_of_replicas": 1
  }, 
  "mappings": {
      "properties": {
        "id":{
          "type": "long"
        },
        "title":{
          "type": "text",
          "analyzer": "ik_max_word"
        },
        "language":{
          "type": "keyword"
        },
        "author":{
          "type": "keyword"
        },
        "price":{
          "type": "double"
        },
        "year":{
          "type": "date",
          "format": "yyyy-MM-dd"
        },
        "description":{
          "type": "text",
          "analyzer": "ik_max_word"
        }
      }
    }
  
}

2 客户端初始化

2.1 基本用法

只需要设置es服务的ip和端口，以及通讯协议即可

 @Test
 public void testBuild() throws IOException {
     // 1 构造RestClient
     RestClient client = RestClient.builder(
             new HttpHost("localhost", 9200, "http")
     ).build();
     // 2 关闭
     client.close();
 }

public static RestClientBuilder builder(HttpHost... hosts) {
     if (hosts == null || hosts.length == 0) {
         throw new IllegalArgumentException("hosts must not be null nor empty");
     }
     List<Node> nodes = Arrays.stream(hosts).map(Node::new).collect(Collectors.toList());
     return new RestClientBuilder(nodes);
 }

可见这个方法接受的是一个可变参数，所以如果是集群，可以传HttpHost对象的数组即可

2.2 可配置项目

配置请求头
/**
 *  配置请求头
 */
public void testConfigHead() throws IOException {
    Header[] hears = new Header[]{new BasicHeader("key","value")} ;
    // 接受的是一个Header数组
    RestClient client = restClientBuilder.setDefaultHeaders(hears).build();
    client.close();
}
配置失败监听器
 /****
     * 配置监听器
     */
    @Test
    public void testConfigListener() throws IOException {
        // 设置一个监听器，该监听器在每次节点失败时都会收到通知，在启用嗅探时在内部使用。
        RestClient client = restClientBuilder.setFailureListener(new RestClient.FailureListener() {
            @Override
            public void onFailure(Node node) {
                super.onFailure(node);
            }
        }).build();
        client.close();
    }
配置节点选择器
/****
* 设置节点选择器
*/
@Test
public void testConfigNodeSelector() throws IOException {
   RestClient client = restClientBuilder.setNodeSelector(NodeSelector.SKIP_DEDICATED_MASTERS)
           .build();
   client.close();
}
配置超时时间
/****
  * 配置超时时间
  */
 @Test
 public void testConfigTimeout() throws IOException {
     RestClient client = restClientBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
         public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
             // 设置套接字超时时间
             requestConfigBuilder.setSocketTimeout(10000);
             // 链接超时时间
             requestConfigBuilder.setConnectTimeout(5000);
             return requestConfigBuilder;
         }
     }).build();
     client.close();
 }
配置线程数
/****
  * 配置线程数量
  * @throws IOException
  */
 @Test
 public void testConfigThread() throws IOException {
     RestClient client= restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
         @Override
         public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
            httpClientBuilder.setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(2).build());
             return httpClientBuilder;
         }
     }).build();
     client.close();
 }

完整的测试样例

package study.wyy.es.client.base;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.impl.nio.reactor.IOReactorConfig;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.Node;
import org.elasticsearch.client.NodeSelector;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2021/1/3 5:20 下午
 */
@Slf4j
public class RestClientBuilderTest {

    RestClientBuilder restClientBuilder;

    @Before
    public void initHost(){
        restClientBuilder = RestClient.builder(
                new HttpHost("localhost", 9200, "http")
        );

    }
    @Test
    public void hello(){
        log.info("hello world");
    }

    /**
     *  构造简单的es RestClient
     */
    @Test
    public void testBuild() throws IOException {
        // 1 构造RestClient
        RestClient client = RestClient.builder(
                new HttpHost("localhost", 9200, "http")
        ).build();
        // 2 关闭
        client.close();
    }

    /**
     *  配置请求头
     */
    public void testConfigHead() throws IOException {
        Header[] hears = new Header[]{new BasicHeader("key","value")} ;
        // 接受的是一个Header数组
        RestClient client = restClientBuilder.setDefaultHeaders(hears).build();
        client.close();
    }

    /****
     * 配置监听器
     */
    @Test
    public void testConfigListener() throws IOException {
        // 设置一个监听器，该监听器在每次节点失败时都会收到通知，在启用嗅探时在内部使用。
        RestClient client = restClientBuilder.setFailureListener(new RestClient.FailureListener() {
            @Override
            public void onFailure(Node node) {
                super.onFailure(node);
            }
        }).build();
        client.close();
    }

    /****
     * 设置节点选择器
     */
    @Test
    public void testConfigNodeSelector() throws IOException {
        RestClient client = restClientBuilder.setNodeSelector(NodeSelector.SKIP_DEDICATED_MASTERS)
                .build();
        client.close();
    }

    /****
     * 配置超时时间
     */
    @Test
    public void testConfigTimeout() throws IOException {
        RestClient client = restClientBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                // 设置套接字超时时间
                requestConfigBuilder.setSocketTimeout(10000);
                // 链接超时时间
                requestConfigBuilder.setConnectTimeout(5000);
                return requestConfigBuilder;
            }
        }).build();
        client.close();
    }

    /****
     * 配置线程数量
     * @throws IOException
     */
    @Test
    public void testConfigThread() throws IOException {
        RestClient client= restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
               httpClientBuilder.setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(2).build());
                return httpClientBuilder;
            }
        }).build();
        client.close();
    }
}

3 构建请求

@Test
public void testBuildRequest() throws IOException {
    // 构建一个请求：localhost:9200/
    Request request = new Request("GET", "/");
    Response response = restClient.performRequest(request); 
    log.info("response: {}", EntityUtils.toString(response.getEntity()));
    restClient.close();
}
  • 通过org.elasticsearch.client.Request进行构建请求参数的
    • 参数一：就是请求方法，GET，POST等
    • 参数二：就是请求的endPoint

关于响应结果的解析，后面在介绍。这里就是简单看一下日志的输出

{
  "name" : "01DR11620116651",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "tWcocvlyQxWfNFhIshS5Dw",
  "version" : {
    "number" : "7.10.1",
    "build_flavor" : "default",
    "build_type" : "zip",
    "build_hash" : "1c34507e66d7db1211f66f3513706fdf548736aa",
    "build_date" : "2020-12-05T01:00:33.671820Z",
    "build_snapshot" : false,
    "lucene_version" : "8.7.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

再比如查询我们上面准备的索引中_id=1的文档，注意下，这时索引库中一条数据还没有

@Test
public void testBuildRequest3() throws IOException {
    // 构建一个请求
    Request request = new Request("GET", "books/_doc/1");
    Response response = restClient.performRequest(request);
    log.info("response: {}", EntityUtils.toString(response.getEntity()));
    restClient.close();
}

执行发现404：

org.elasticsearch.client.ResponseException: method [GET], host [http://localhost:9200], URI [books/_doc/1], status line [HTTP/1.1 404 Not Found]
{"_index":"books","_type":"_doc","_id":"1","found":false}

但是是有结果的，日志里面已经看到：这不就是kibana上执行查询的结果


可点击key和value值进行编辑
{
    "_index":"books",
    "_type":"_doc",
    "_id":"1",
    "found":false
}

那么去kibana新增一条数据之后，在测试呢：

PUT books/_doc/1
{
    "id":"1",
    "title":"Java编程思想",
    "language":"java",
    "author":"Bruce Eckel",
    "price":70.2,
    "publish_time":"2007-10-01",
    "description":"Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉。"
}

此时就会发现不会出现404，测试不会报错了。

完整的测试代码

package study.wyy.es.client.base;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.RestClient;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

/**
 * @author wyaoyao
 * @description
 * @date 2021/1/8 10:47
 */
@Slf4j
public class BuildRequestTest {

    RestClient restClient;

    @Before
    public void buildRestClient(){
        restClient = RestClient.builder(new HttpHost("localhost", 9200, "http"))
                .build();
    }

    /***
     * 构建请求对象
     */
    @Test
    public void testBuildRequest() throws IOException {
        // 构建一个请求
        Request request = new Request("GET", "/");
        Response response = restClient.performRequest(request);
        log.info("response: {}", EntityUtils.toString(response.getEntity()));
        restClient.close();
    }

    @Test
    public void testBuildRequest2() throws IOException {
        // 构建一个请求
        Request request = new Request("GET", "_cat/indices");
        Response response = restClient.performRequest(request);
        log.info("response: {}", EntityUtils.toString(response.getEntity()));
        restClient.close();
    }

    @Test
    public void testBuildRequest3() throws IOException {
        // 构建一个请求
        Request request = new Request("GET", "books/_doc/1");
        Response response = restClient.performRequest(request);
        log.info("response: {}", EntityUtils.toString(response.getEntity()));
        restClient.close();
    }
}

4 执行请求

es的客户端提供了两种执行方式

  • 同步执行
  • 异步执行

4.1 同步执行

同步执行：restClient.performRequest()
前面的代码已经演示如何使用了，这里不多赘述

4.2 异步执行

当异步执行，客户端不需要等es服务返回响应。为了能够异步处理，所以需要一个监听器，来监听es服务的响应，进行相应的处理

API介绍

  1. 调用的方法的就是restClient.performRequestAsync()，接收两个参数

    • 请求对象Request
    • 监听器”：ResponseListener

  2. org.elasticsearch.client.ResponseListener

public interface ResponseListener {

    /**
     * Method invoked if the request yielded a successful response
     * // 执行成功的回调函数
     */
    void onSuccess(Response response);

    /**
     *  // 执行异常的回调函数
     */
    void onFailure(Exception exception);
}
示例
package study.wyy.es.client.base;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.ResponseListener;
import org.elasticsearch.client.RestClient;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

/**
 * @author wyaoyao
 * @description
 * @date 2021/1/8 13:49
 */
@Slf4j
public class PerformRequestTest {

    /***
     * 测试异步
     * @throws IOException
     */
    public static void main(String[] args) {
        RestClient restClient = RestClient.builder(new HttpHost("localhost", 9200, "http"))
                .build();
        // 构建一个请求
        Request request = new Request("GET", "/");
        restClient.performRequestAsync(request, new ResponseListener() {
            // 执行成功的回调函数
            public void onSuccess(Response response) {
                log.info("执行成功");
            }
            // 执行异常的回调函数
            public void onFailure(Exception exception) {
                log.error("执行异常:{}",exception.getMessage(),exception);
            }
        });
        // 不能在这关闭了，异步请求，可能还没有拿到结果，客户端关闭了
        //restClient.close();
    }
}

5 响应解析

package study.wyy.es.client.base;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.RequestLine;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.RestClient;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

/**
 * @author wyaoyao
 * @description
 * @date 2021/1/8 14:29
 */
@Slf4j
public class ParseResponseTest {
    RestClient restClient;

    @Before
    public void buildRestClient(){
        restClient = RestClient.builder(new HttpHost("localhost", 9200, "http"))
                .build();
    }


    @Test
    public void parseResponseTest() throws IOException {
        // 构建一个请求
        Request request = new Request("GET", "books/_doc/1");
        Response response = restClient.performRequest(request);
        // 拿到请求信息
        RequestLine requestLine = response.getRequestLine();
        log.info("请求信息: {}",requestLine);
        // 拿到host地址
        HttpHost host = response.getHost();
        log.info("es地址：{}",host);
        // 响应头
        Header[] headers = response.getHeaders();
        log.info("响应头：{}",headers);
        String contentType = response.getHeader("content-type");
        log.info("contentType：{}",contentType);
        // 状态码
        int statusCode = response.getStatusLine().getStatusCode();
        log.info("状态码：{}",statusCode);
        // 响应体
        String body = EntityUtils.toString(response.getEntity());
        log.info("响应体：{}",body);

    }

}

请求信息: GET books/_doc/1 HTTP/1.1
es地址：http://localhost:9200
响应头：content-type: application/json; charset=UTF-8
contentType：application/json; charset=UTF-8
 状态码：200
 响应体：{"_index":"books","_type":"_doc","_id":"1","_version":1,"_seq_no":4,"_primary_term":1,"found":true,"_source":{
    "id":"1",
    "title":"Java编程思想",
    "language":"java",
    "author":"Bruce Eckel",
    "price":70.2,
    "publish_time":"2007-10-01",
    "description":"Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉。"
}
}
wyaoyao93
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
五年客户端入门心路历程
沉迷单车的追风少年
05-15 1337
我刚来西电的时候(17年)，那时候客户端还是风头正旺，实验室很多同学都在搞客户端；不过很快，19年、20年开始，技术舆论大环境上都在唱衰客户端，前端跨平台开发越来越火。一面是all in 前端，一面是头条阿里等大厂重金招客户端；未来是怎样，无法罔下结论。 非科班出身，万事开头难。在西电这种全民计算机的氛围下，很多很多像我这样的人，之前学的是通信、或者电子信息、或者物理光电、甚至英语文学等等，靠自己自学技术，走上码农的不归路。但是万事开头难，一方面要兼顾自己的专业“无用”的专业课，一方面要挤出时间追求技术，中
客户端入门及数理逻辑初探
Hello,World.
06-13 671
白天被头儿说的急了，便激将他给我找了一些材料。发现数理逻辑也无非是为了规范逻辑推演而摒弃自然语言做了符号化规范；把它当韦恩图来理解一切都不神秘。我欠缺的是：由浅入深的逻辑训练；所以才会在复杂面前傻眼。好歹利用晚九点以后的时间把《客户端入门十二小时.ppt》看完了。睡觉时已经凌晨一点。这份文档的起点偏高，硬着头皮看了其中的几段代码，不知是什么语言，至少不是C，看程序语言的好处是，不知其原理，其字
游戏客户端入门十二小时
Skywind Inside
04-23 2589
本文代码见：http://blog.csdn.net/skywind/archive/2005/04/18/352045.aspx  
小白 JS 客户端从入门到放弃
GitChat
08-14 522
JS、CSS、HTML 属于前端最基础的一部分知识，同时也是面试当中会考的基本知识。小白也能通过学习 JS、CSS、HTML 这些基础，达到快速入门的作用，为以后更快速的学习框架，打下基础。也能够迅速的排除一些常见的错误。 本场 Chat 会着重讲解 JS。将会从最基础的 JS 的 Hello Word 说起，逐步扩展到 JS 的 DOM 模型，文档结构，以及 JS 的同源策略。将会详细解释浏览器...
ElasticSearch的client
最新发布
XuXing_java的专栏
01-03 851
4、elasticsearch-rest-high-level-client:6.4.3，高级客户端【es官方推荐】，依赖于低级客户端elasticsearch-rest-client和elasticsearch两个模块，使用面向对象的方式来形成dsl，和TransportClient不同的是，它是通过低级客户端的http协议和es服务器来交互。总的来说，High Level REST Client 是目前推荐使用的客户端，而 Transport Client 已经被废弃不建议使用。
elasticsearch-perl：Elasticsearch的Perl官方低级客户端
02-05
**Elasticsearch-perl：Perl官方低级客户端详解** Elasticsearch-perl是Elasticsearch官方为Perl编程语言提供的一个低级客户端库。这个库旨在为开发者提供与Elasticsearch服务器进行交互的基本功能，以便在Perl应用...
elasticSearch-JavaRest 高级客户端入门
dx15618816293的博客
05-12 494
6 JavaRest 高级客户端入门 1 JavaRest 高级客户端简介 elasticsearch 存在三种Java客户端。 Transport Client Java Low Level Rest Client（低级rest客户端） Java High Level REST Client（高级rest客户端） 这三者的区别是： TransportClient没有使用RESTful风格的接口，而是二进制的方式传输数据。 ES官方推出了Java Low Level REST Client,它支持RES
pings:通过低级套接字使用icmp数据包在Python 3中进行简单的ping客户端
05-08
通过低级套接字使用icmp数据包在Python 3中进行简单的ping客户端。 注意：此客户端只能由root （或admin）用户使用。 如何安装 要安装ping，只需： $ pip install pings 或从来源： $ python setup.py install ...
manticoresearch-[removed]Manticore搜索的官方Javascript客户端
05-13
Manticore搜索的低级客户端。 安装 npm install manticoresearch 要求 节点v8。 启用HTTP协议的最低Manticore搜索版本为2.5.1。 文献资料 完整的文档位于文件夹中。 Manticore搜索服务器文档： : 。 入门 一个...
ElasticStack(ELK)从入门到实践.pdf
06-11
在使用Java客户端和REST客户端进行数据操作时，需要构造相应的数据，并利用低级或高级客户端API完成数据的增删改查等操作。 Beats是轻量级的采集器集合，可以收集数据并发送到Elasticsearch或者Logstash。例如...
Java REST 客户端
一线大码
09-04 316
文章目录Java Low Level REST ClientJava High Level REST Client Java Low Level REST Client 低级客户端的特点包括： 最小函数依赖。 在所有可用节点上实现负载平衡。 在节点故障和特定响应代码的情况下进行故障转移。 失败连接惩罚（一个失败节点是否被重试取决于它连续失败的次数；失败的尝试越多，客户端在再次尝试相同节点之前等待的时间就越长）。 持久连接。 跟踪请求和响应的日志记录。 可选的自动发现集群节点。 Java High Le
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘elasticsearc
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
03-08 935
Springboot 2.3.11 与ES 7.x 搭建报错
springboot之redis集成(遇到的那些坑)
狂奔的蜗牛
07-14 9521
一.集成过程 redis在阿里云已经搭建好，本地用单元测试也通过了，本以为使用springboot接入很easy，但是遇到了很多的坑 首先列一下springboot接入redis的步骤 1.在yml中配置一下redis的地址及端口，配置host主机地址和port端口即可即可 2.创建JedisConnectionFactory连接，读取yml中的地址及端口；创建redisTemplate，...
服务器重启后导致子用户下redis启动报错
weixin_40694508的博客
03-30 832
服务器重启后导致子用户下redis启动报错 问题： 1.程序启动报RedisException : ERR unknown command 'CONFIG' ... 2.Redis报The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128 3.Redis报overcommit_memory is set to 0! Ba
java.lang.IllegalArgumentException: non null key required
热门推荐
qq_40051434的博客
09-07 3万+
redis缓存数据时报过这个错误，我的错误原因是存是数据是空，存之前加个非空判断就可以了
HttpClient：Target host must not be null, or set in parameters
天外来客1009
06-24 2702
HttpClient client = new DefaultHttpClient();  HttpGet get = new HttpGet("www.baidu.com");  HttpResponse response = client.execute(get); 抛出异常：Target host must not be null, or set in parameters原因是：url写法
lambda表达式中对接口优雅简写
qq_42697271的博客
07-29 186
最近写代码的时候发现了一段看不懂的代码，之后查了些资料，才知道是lambd的简写形式，在此记录一下 看不懂的代码 RestClientBuilder.RequestConfigCallback requestConfigCallback = builder -> { builder.setConnectTimeout(clientProperties.getConnTimeout()) .setSocketTimeout(clientProperties.getSo.
.NET开发入门：C#与分布式计算解析
CLR是.NET的核心，它负责代码的编译、执行和垃圾回收等任务，而中间语言（Intermediate Language, IL）则是由CLR理解的低级代码形式，确保了不同语言编写的代码能够在.NET平台上无缝交互。 Visual Studio.NET IDE是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值