Java 操作 ElasticSearch 的方式大体上可以分为两种
1. 直接发送 Http 请求
2. 通过 客户端

这里的ElasticSearch 版本 为 7.9.3

直接发送 Http 请求

这就是为什么老版的教程可以用 PostMan 向 ES 发请求，我们用的 kibana 也是这种方式，只不过加上提示，还有帮我们调整了格式。
具体的可以使用：

• HttpUrlConnection
• Http 请求库: HttpClient,OkHttp,RestTemplate(Spring)

这种情况下，我们需要自己组装 Http 请求的参数，解析响应结果
eg:
建立一个普通的 Java SE 工程，利用 HttpURLConnection 请求 ElasticSearch

public class HttpRequestTest {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://localhost:9200/books/_search");
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        if(urlConnection.getResponseCode()==200){

            BufferedReader reader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
            String str = null;
            while((str= reader.readLine())!=null){
                System.out.println(str);
            }
        }

    }
}

客户端

客户端有 Java Low Level REST Client 和 Java High Level REST Client

Java Low Level REST Client

同样的需要我们自己来组装请求的参数和解析响应。数据处理可能比较麻烦，
但是由于这个没有调用API，所以兼容性较强，兼容所有的版本。
eg:
创建项目，引入依赖

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

编写相关代码如下：
还是和上面一样， 构建请求参数 和响应解析都是由我们自己来干

 public static  void SynchronousCall() throws IOException{
        //1. 构建 RestClientBuilder 对象
        RestClientBuilder builder = RestClient.builder(
                new HttpHost("localhost", 9200, "http")
        );
        // 非必须，如果要在请求头中设置认证信息，可以通过这个 builder

        //2. 构建RestClient 对象
        RestClient restClient = builder.build();

        //3. 构建请求
        Request request = new Request("GET", "/books/_search");
        // 添加请求参数
        request.addParameter("pretty","true");

        //4. 发起请求 同步方式
        Response response = restClient.performRequest(request);

        // 5. 解析响应
        BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
        String str =null;
        while((str=reader.readLine())!=null){
            System.out.println(str);
        }
        reader.close();

        // 6. 关闭 RestClient
        restClient.close();
    }

这里是同步调用，在请求执行完成之前，后面的操作会被阻塞。
我们也可以改成异步调用，代码如下：

  public static void ASynchronousCall(){

        //1. 构建 RestClientBuilder 对象
        //2. 构建RestClient 对象
        //3. 构建请求
        // 以上 123 与同步相同

        // 发起请求 异步方式
        restClient.performRequestAsync(request, new ResponseListener() {

            @Override
            public void onSuccess(Response response) {
                BufferedReader reader = null;
                try {
                    reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                    String str =null;
                    while((str=reader.readLine())!=null){
                        System.out.println(str);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        reader.close();
                        /**
                         * 记得在这里关闭 restClient
                         * 如果像同步调用一样，放在后面，
                         * 由于这里是异步调用，不会阻塞后面的代码
                         * 就有可能出现请求来没请求完，后面的直接将 restClient 关闭了
                         */

                        restClient.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Exception e) {

            }
        });
    }

上面只是一个简单的请求，在实际操作的时候，还可以带上JSON参数。
如下：
在 kibana 中的请求

用 Java 实现的，这里只写了部分代码，其余部分是相同的，所以这里不展示了

Java High Level REST Client

基于 Java Low Level REST Client ，同时，提供了很多的 API，可以直接使用，而不是自己来处理请求参数和响应，
但是由于使用的是它提供的API，所以我们依赖的版本要和 ES 的版本对应，确保解析正确。
这种方式使用的较多，具体示例如下：