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

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

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

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

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

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

<!-- Elasticsearch服务 -->
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.11.1</version>
</dependency>

<!-- Elasticsearch高级客户端 -->
<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();
    }
}

执行结果：