Elasticsearch使用Java初始化高级客户端（RestHighLevelClient类）

Love The Way You Lie 2021-07-24 11:34 668阅读 0赞

目前，官方计划在 Elasticsearch 7.0 版本中关闭 TransportClient，并且在8.0版本中完全删除 TransportClient。作为替代品，我们应该使用高级客户端。高级客户端可以执行 HTTP 请求，而不是序列化 Java 请求。

高级客户端的主要目标是公开特定的 API 方法，这些 API 方法将接收请求作为参数并返回响应结果，以便由客户端本身处理请求和响应结果。

**【示例】**Elasticsearch使用Java初始化高级客户端。

（1）创建第一个 SpringBoot 项目，项目结构如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70][]

（2）在pom.xml配置信息文件中，添加相关依赖文件：

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

（3）在 com.pjb.service 包中，创建Elasticsearch服务接口（MeetElasticsearchService.java）。

package com.pjb.service;
    
    /**
     * Elasticsearch服务接口
     * @author pan_junbiao
     **/
    public interface MeetElasticsearchService
    {
        /**
         * 初始化连接
         */
        public void initEs();
    
        /**
         * 关闭连接
         */
        public void closeEs();
    
        /**
         * 构建对Elasticsearch服务的请求
         */
        public void executeRequest();
    }

（4）在 com.pjb.service.impl 包中，创建Elasticsearch服务类（MeetElasticsearchServiceImpl.java）。

package com.pjb.service.impl;
    
    import com.pjb.service.MeetElasticsearchService;
    import org.apache.http.Header;
    import org.apache.http.HttpHost;
    import org.apache.http.RequestLine;
    import org.apache.http.util.EntityUtils;
    import org.apache.juli.logging.Log;
    import org.apache.juli.logging.LogFactory;
    import org.elasticsearch.client.Request;
    import org.elasticsearch.client.Response;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.PostConstruct;
    
    /**
     * Elasticsearch服务类
     * @author pan_junbiao
     **/
    @Service
    public class MeetElasticsearchServiceImpl implements MeetElasticsearchService
    {
        private static Log log = LogFactory.getLog(MeetElasticsearchServiceImpl.class);
    
        private RestHighLevelClient restClient; //高级客户端
    
        //================================ 初始化连接 ==============================
    
        /**
         * 初始化连接
         */
        @Override
        @PostConstruct
        public void initEs()
        {
            try
            {
                //初始化：高级客户端
                restClient = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1", 9200, "http"),
                        new HttpHost("127.0.0.1", 9201, "http")));
    
                System.out.println("成功启动Elasticsearch服务");
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
                System.out.println("启动Elasticsearch服务失败");
            }
        }
    
        /**
         * 关闭连接
         */
        @Override
        public void closeEs()
        {
            try
            {
                restClient.close();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    
        /**
         * 构建对Elasticsearch服务的请求
         */
        @Override
        public void executeRequest()
        {
            Request request = new Request("GET","/"); //在服务器上请求
    
            try
            {
                //方法一：使用performRequest同步请求方法
                //Response response = restClient.performRequest(request);
                Response response = restClient.getLowLevelClient().performRequest(request);
    
                //获取响应结果内容：
                //已执行请求的信息
                RequestLine requestLine = response.getRequestLine();
                System.out.println("请求的信息：" + requestLine.getUri());
    
                //Host返回的信息
                HttpHost host = response.getHost();
                System.out.println("Host返回的信息：" + host.toString());
    
                //响应状态，从中可以解析状态代码
                int statusCode = response.getStatusLine().getStatusCode();
                System.out.println("响应状态：" + statusCode);
    
                //响应头，也可以通过getheader(string)按名称获取
                Header[] headers = response.getHeaders();
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("响应头：" + responseBody);
                System.out.println("响应结果：" + response.toString());
    
                //方法二：使用performRequestAsync异步请求方法
                //使用异步时，下面的关闭方法要注释掉
                /*restClient.performRequestAsync(request, new ResponseListener()
                {
                    @Override
                    public void onSuccess(Response response)
                    {
                        System.out.println("使用performRequestAsync异步请求方法得到结果：" + response.toString());
                    }
    
                    @Override
                    public void onFailure(Exception e)
                    {
                        System.out.println("错误");
                    }
                });*/
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            finally
            {
                closeEs();
            }
        }
    }

> **@PostConstruct注解说明：**
> 
> @PostConstruct注解好多人以为是 Spring 提供的。其实是Java自己的注解。
> 
> @PostConstruct该注解被用来修饰一个非静态的 void() 方法。被 @PostConstruct 修饰的方法会在服务器加载 Servlet 的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行，init() 方法之前执行。

（5）创建Elasticsearch服务测试类（MeetElasticsearchTest.java）。

package com.pjb;
    
    import com.pjb.service.MeetElasticsearchService;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    /**
     * Elasticsearch服务测试类
     * @author pan_junbiao
     **/
    @SpringBootTest
    public class MeetElasticsearchTest
    {
        @BeforeEach
        void setUp()
        {
            System.out.println("@BeforeEach，测试开始");
        }
    
        @AfterEach
        void tearDown()
        {
            System.out.println("@AfterEach，测试结束");
        }
    
        @Autowired
        private MeetElasticsearchService meetElasticsearchService;
    
        /**
         * 测试：构建对Elasticsearch服务的请求
         */
        @Test
        public void executeRequest()
        {
            meetElasticsearchService.executeRequest();
        }
    }

**执行结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70]: /images/20210724/e84979c2e4044cb7a4245fa7149f149d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1]: /images/20210724/4e10a1ab3e2d4dc7bcf59e18c99e8311.png