来聊一聊 ElasticSearch 最新版的 Java 客户端-低调大师

来聊一聊 ElasticSearch 最新版的 Java 客户端

2022-12-16 375

可能不少小伙伴都注意到了，从 ElasticSearch7.17 这个版本开始，原先的 Java 高级客户端 Java High Level REST Client 废弃了，不支持了。老实说，ElasticSearch 算是我用过的所有 Java 工具中，更新最为激进的一个了，在 Es7 中废弃了 TransportClient，7.17 又废弃了 TransportClient，那么现在用啥呢？现在的客户端叫做 Elasticsearch Java API Client。

一直偷懒选择无视 Elasticsearch Java API Client，不过最近工作中用到了，所以还是整篇文章和小伙伴们简单梳理一下 Elasticsearch Java API Client 的玩法。

下面的介绍我主要从索引操作和文档操作两个方面来给大家介绍。

不过需要跟大家强调的是，ElasticSearch 的 Java 客户端想要用的 6，必须要熟悉 ElasticSearch 的查询脚本，大家平时在工作中遇到 Es 相关的问题，我也都是建议先在 Kibana 中把操作脚本写好，然后再翻译成 Java 代码，或者直接拷贝到 Java 代码中，非常不建议上来就整 Java 代码，那样很容易出错。

如果你对 Es 的操作不熟悉，松哥录了免费的视频教程，大家可以参考：

https://www.bilibili.com/video/BV1ft4y1e7tq/

不想看视频，也可以在微信公众号后台回复 es，有文档教程。

1. Elasticsearch Java API Client

Elasticsearch Java API Client 是 Elasticsearch 的官方 Java API，这个客户端为所有 Elasticsearch APIs 提供强类型的请求和响应。

> 这里跟大家解释下什么是强类型的请求和响应：因为所有的 Elasticsearch APIs 本质上都是一个 RESTful 风格的 HTTP 请求，所以当我们调用这些 Elasticsearch APIs 的时候，可以就当成普通的 HTTP 接口来对待，例如使用 HttpUrlConnection 或者 RestTemplate 等工具来直接调用，如果使用这些工具直接调用，就需要我们自己组装 JSON 参数，然后自己解析服务端返回的 JSON。而强类型的请求和响应则是系统把请求参数封装成一个对象了，我们调用对象中的方法去设置就可以了，不需要自己手动拼接 JSON 参数了，请求的结果系统也会封装成一个对象，不需要自己手动去解析 JSON 参数了。

小伙伴们看一下下面这个例子，我想查询 books 索引中，书名中包含 Java 关键字的图书：

public class EsDemo02 {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://localhost:9200/books/_search?pretty");
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestMethod("GET");
        con.setRequestProperty("content-type","application/json;charset=utf-8");
        //允许输出流/允许参数
        con.setDoOutput(true);
        //获取输出流
        OutputStream out = con.getOutputStream();
        String params = "{\n" +
                "  \"query\": {\n" +
                "    \"term\": {\n" +
                "      \"name\": {\n" +
                "        \"value\": \"java\"\n" +
                "      }\n" +
                "    }\n" +
                "  }\n" +
                "}";
        out.write(params.getBytes());
        if (con.getResponseCode() == 200) {
            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String str = null;
            while ((str = br.readLine()) != null) {
                System.out.println(str);
            }
            br.close();
        }
    }
}

小伙伴们看到，这就是一个普通的 HTTP 请求，请求参数就是查询的条件，这个条件是一个 JSON 字符串，需要我们自己组装，请求的返回值也是一个 JSON 字符串，这个 JSON 字符串也需要我们自己手动去解析，这种可以算是弱类型的请求和响应。

Elasticsearch Java API Client 具有如下特性：

为所有 Elasticsearch APIs 提供强类型的请求和响应。
所有 API 都有阻塞和异步版本。
使用构建器模式，在创建复杂的嵌套结构时，可以编写简洁而可读的代码。
通过使用对象映射器（如 Jackson 或任何实现了 JSON-B 的解析器），实现应用程序类的无缝集成。
将协议处理委托给一个 http 客户端，如 Java Low Level REST Client，它负责所有传输级的问题。HTTP 连接池、重试、节点发现等等由它去完成。

关于第三点，松哥吐槽一句，确实简洁，但是可读性一般般吧。

另外还有两点需要注意：

Elasticsearch Java 客户端是向前兼容的，即该客户端支持与 Elasticsearch 的更大或相等的次要版本进行通信。
Elasticsearch Java 客户端只向后兼容默认的发行版本，并且没有做出保证。

好了，那就不废话了，开整吧。

2. 引入 Elasticsearch Java API Client

首先需要我们加依赖，对 JDK 的版本要求是 1.8，我们需要添加如下两个依赖：

<dependency>
  <groupid>co.elastic.clients</groupid>
  <artifactid>elasticsearch-java</artifactid>
  <version>8.5.1</version>
</dependency>

<dependency>
  <groupid>com.fasterxml.jackson.core</groupid>
  <artifactid>jackson-databind</artifactid>
  <version>2.12.3</version>
</dependency>

如果是 Spring Boot 项目，就不用添加第二个依赖了，因为 Spring Boot 的 Web 中默认已经加了这个依赖了，但是 Spring Boot 一般需要额外添加下面这个依赖，出现这个原因是由于从 JavaEE 过渡到 JakartaEE 时衍生出来的一些问题，这里我就不啰嗦了，咱们直接加依赖即可：

<dependency>
  <groupid>jakarta.json</groupid>
  <artifactid>jakarta.json-api</artifactid>
  <version>2.0.1</version>
</dependency>

3. 建立连接

接下来我们需要用我们的 Java 客户端和 ElasticSearch 之间建立连接，建立连接的方式如下：

RestClient restClient = RestClient.builder(
    new HttpHost("localhost", 9200)).build();
ElasticsearchTransport transport = new RestClientTransport(
    restClient, new JacksonJsonpMapper());
ElasticsearchClient client = new ElasticsearchClient(transport);

小伙伴们看到，这里一共有三个步骤：

首先创建一个低级客户端，这个其实松哥之前的视频中和大家讲过低级客户端的用法，这里就不再赘述。
接下来创建一个通信 Transport，并利用 JacksonJsonpMapper 做数据的解析。
最后创建一个阻塞的 Java 客户端。

上面这个是创建了一个阻塞的 Java 客户端，当然我们也可以创建非阻塞的 Java 客户端，如下：

RestClient restClient = RestClient.builder(
        new HttpHost("localhost", 9200)).build();
ElasticsearchTransport transport = new RestClientTransport(
        restClient, new JacksonJsonpMapper());
ElasticsearchAsyncClient client = new ElasticsearchAsyncClient(transport);

只有第三步和前面的不一样，其他都一样。

> 利用阻塞的 Java 客户端操作 Es 的时候会发生阻塞，也就是必须等到 Es 给出响应之后，代码才会继续执行；非阻塞的 Java 客户端则不会阻塞后面的代码执行，非阻塞的 Java 客户端一般通过回调函数处理请求的响应值。

有时候，我们可能还需要和 Es 之间建立 HTTPS 连接，那么需要在前面代码的基础之上，再套上一层 SSL，如下：

String fingerprint = "<certificate fingerprint>";
SSLContext sslContext = TransportUtils
    .sslContextFromCaFingerprint(fingerprint); 
BasicCredentialsProvider credsProv = new BasicCredentialsProvider(); 
credsProv.setCredentials(
    AuthScope.ANY, new UsernamePasswordCredentials(login, password)
);
RestClient restClient = RestClient
    .builder(new HttpHost(host, port, "https")) 
    .setHttpClientConfigCallback(hc -&gt; hc
        .setSSLContext(sslContext) 
        .setDefaultCredentialsProvider(credsProv)
    )
    .build();
ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
ElasticsearchClient client = new ElasticsearchClient(transport);

好了，关于建立连接，差不多就这些点。

4. 索引操作

Elasticsearch Java API Client 中最大的特色就是建造者模式+Lambda 表达式。例如，我想创建一个索引，方式如下：

@Test
public void test99() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    CreateIndexResponse createIndexResponse = client.indices().create(
            c -&gt;
                    c.index("javaboy_books")
                            .settings(s -&gt;
                                    s.numberOfShards("3")
                                            .numberOfReplicas("1"))
                            .mappings(m -&gt;
                                    m.properties("name", p -&gt; p.text(f -&gt; f.analyzer("ik_max_word")))
                                            .properties("birthday", p -&gt; p.date(d -&gt; d.format("yyyy-MM-dd"))))
                            .aliases("books_alias", f -&gt; f.isWriteIndex(true)));
    System.out.println("createResponse.acknowledged() = " + createIndexResponse.acknowledged());
    System.out.println("createResponse.index() = " + createIndexResponse.index());
    System.out.println("createResponse.shardsAcknowledged() = " + createIndexResponse.shardsAcknowledged());
}

小伙伴们看到，这里都是建造者模式和 Lambda 表达式，方法名称其实都很好理解（前提是你得熟悉 ElasticSearch 操作脚本），例如：

index 方法表示设置索引名称
settings 方法表示配置 setting 中的参数
numberOfShards 表示索引的分片数
numberOfReplicas 表示配置索引的副本数
mapping 表示配置索引中的映射规则
properties 表示配置索引中的具体字段
text 方法表示字段是 text 类型的
analyzer 表示配置字段的分词器
aliases 表示配置索引的别名

反正这里的方法都是见名知义的，上面这个就类似于下面这个请求：

PUT javaboy_books
{
  "settings": {
    "number_of_replicas": 1,
    "number_of_shards": 3
  },
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "birthday":{
        "type": "date",
        "format": "yyyy-MM-dd"
      }
    }
  },
  "aliases": {
    "xxxx":{
      
    }
  }
}

小伙伴们在写的时候，脑子里要先有下面这个脚本，然后 Java 方法可以顺手拈来了。

最终创建好的索引如下图：

有的小伙伴可能觉得调这一大堆方法太啰里啰唆了，来个简单的，直接上 JSON，那也不是不可以，如下：

@Test
public void test98() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    StringReader json = new StringReader("{\n" +
            "  \"settings\": {\n" +
            "    \"number_of_replicas\": 1,\n" +
            "    \"number_of_shards\": 3\n" +
            "  },\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      },\n" +
            "      \"birthday\":{\n" +
            "        \"type\": \"date\",\n" +
            "        \"format\": \"yyyy-MM-dd\"\n" +
            "      }\n" +
            "    }\n" +
            "  },\n" +
            "  \"aliases\": {\n" +
            "    \"xxxx\":{\n" +
            "      \n" +
            "    }\n" +
            "  }\n" +
            "}");
    CreateIndexResponse createIndexResponse = client.indices().create(
            c -&gt;
                    c.index("javaboy_books").withJson(json));
    System.out.println("createResponse.acknowledged() = " + createIndexResponse.acknowledged());
    System.out.println("createResponse.index() = " + createIndexResponse.index());
    System.out.println("createResponse.shardsAcknowledged() = " + createIndexResponse.shardsAcknowledged());
}

这是直接把 JSON 参数给拼接出来，就不需要一堆建造者+Lambda 了。

如果你想删除索引呢？如下：

@Test
public void test06() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    //删除一个索引
    DeleteIndexResponse delete = client.indices().delete(f -&gt;
            f.index("my-index")
    );
    System.out.println("delete.acknowledged() = " + delete.acknowledged());
}

这个表示删除一个名为 my-index 的索引。

好了，关于索引的操作我就说这两点。

可能有的小伙伴会说，ElasticSearch 中创建索引可以配置很多参数你都没讲。在我看来，哪些很多参数其实跟这个 Java API 没有多大关系，只要你会写查询脚本，就自然懂得 Java API 中该调用哪个方法，退一万步讲，你会脚本，不懂 Java API 的方法，那么就像上面那样，直接把你的 JSON 拷贝过来，作为 Java API 的参数即可。

5. 文档操作

5.1 添加文档

先来看文档的添加操作。

如下表示我想给一个名为 books 的索引中添加一个 id 为 890 的书：

@Test
public void test07() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    Book book = new Book();
    book.setId(890);
    book.setName("深入理解Java虚拟机");
    book.setAuthor("xxx");
    //添加一个文档
    //这是一个同步请求，请求会卡在这里
    IndexResponse response = client.index(i -&gt; i.index("books").document(book).id("890"));
    System.out.println("response.result() = " + response.result());
    System.out.println("response.id() = " + response.id());
    System.out.println("response.seqNo() = " + response.seqNo());
    System.out.println("response.index() = " + response.index());
    System.out.println("response.shards() = " + response.shards());
}

添加成功之后，返回的 IndexResponse 对象其实就是对下面这个 JSON 的封装：

现在我们只需要调用相应的方法，就可以获取到 JSON 相关的属性了。

5.2 删除文档

如下表示删除 books 索引中 id 为 891 的文档：

@Test
public void test09() {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchAsyncClient client = new ElasticsearchAsyncClient(transport);
    client.delete(d -&gt; d.index("books").id("891")).whenComplete((resp, e) -&gt; {
        System.out.println("resp.result() = " + resp.result());
    });
}

删除这里我用了异步非阻塞的客户端来给小伙伴们演示的，异步非阻塞的话，就使用 whenComplete 方法处理回调就行了，里边有两个参数，一个是正常情况下返回的对象，另外一个则是出错时候的异常。

5.3 查询文档

最后，就是查询了。这应该是大家日常开发中使用较多的功能项了，不过我还是前面的态度，查询的关键不在 Java API，而在于你对 ElasticSearch 脚本的掌握程度。

所以我这里举个简单的例子，小伙伴们大致了解下 Java API 的方法即可：

@Test
public void test01() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    SearchRequest request = new SearchRequest.Builder()
            //去哪个索引里搜索
            .index("books")
            .query(QueryBuilders.term().field("name").value("java").build()._toQuery())
            .build();
    SearchResponse<book> search = client.search(request, Book.class);
    System.out.println("search.toString() = " + search.toString());
    long took = search.took();
    System.out.println("took = " + took);
    boolean b = search.timedOut();
    System.out.println("b = " + b);
    ShardStatistics shards = search.shards();
    System.out.println("shards = " + shards);
    HitsMetadata<book> hits = search.hits();
    TotalHits total = hits.total();
    System.out.println("total = " + total);
    Double maxScore = hits.maxScore();
    System.out.println("maxScore = " + maxScore);
    List<hit<book>&gt; list = hits.hits();
    for (Hit<book> bookHit : list) {
        System.out.println("bookHit.source() = " + bookHit.source());
        System.out.println("bookHit.score() = " + bookHit.score());
        System.out.println("bookHit.index() = " + bookHit.index());
    }
}

上面这个例子是一个 term 查询，查询 books 索引中书名 name 中包含 java 关键字的图书，等价于下面这个查询：

GET books/_search
{
  "query": {
    "term": {
      "name": {
        "value": "java"
      }
    }
  }
}

如果希望能够对查询关键字分词之后查询，那么可以使用 match 查询，如下：

@Test
public void test03() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    SearchResponse<book> search = client.search(s -&gt; {
        s.index("books")
                .query(q -&gt; {
                    q.match(m -&gt; {
                        m.field("name").query("美术计算机");
                        return m;
                    });
                    return q;
                });
        return s;
    }, Book.class);
    System.out.println("search.toString() = " + search.toString());
    long took = search.took();
    System.out.println("took = " + took);
    boolean b = search.timedOut();
    System.out.println("b = " + b);
    ShardStatistics shards = search.shards();
    System.out.println("shards = " + shards);
    HitsMetadata<book> hits = search.hits();
    TotalHits total = hits.total();
    System.out.println("total = " + total);
    Double maxScore = hits.maxScore();
    System.out.println("maxScore = " + maxScore);
    List<hit<book>&gt; list = hits.hits();
    for (Hit<book> bookHit : list) {
        System.out.println("bookHit.source() = " + bookHit.source());
        System.out.println("bookHit.score() = " + bookHit.score());
        System.out.println("bookHit.index() = " + bookHit.index());
    }
}

> 为了让小伙伴们看到这个 Java 客户端的不同用法，上面两个查询的例子，我分别使用了构造查询请求和建造者+Lambda 的方式。

match 查询就调用 match 方法就行了，设置查询关键字即可，这个查询等价于下面这个查询：

GET books/_search
{
  "query": {
    "match": {
      "name": "美术计算机"
    }
  }
}

如果你觉得这种调用各种方法拼接参数的方式不习惯，那么也可以直接上 JSON，如下：

@Test
public void test04() throws IOException {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)).build();
    ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper());
    ElasticsearchClient client = new ElasticsearchClient(transport);
    String key = "java";
    StringReader sr = new StringReader("{\n" +
            "  \"query\": {\n" +
            "    \"term\": {\n" +
            "      \"name\": {\n" +
            "        \"value\": \"" + key + "\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}");
    SearchRequest request = new SearchRequest.Builder()
            .withJson(sr)
            .build();
    SearchResponse<book> search = client.search(request, Book.class);
    System.out.println("search.toString() = " + search.toString());
    long took = search.took();
    System.out.println("took = " + took);
    boolean b = search.timedOut();
    System.out.println("b = " + b);
    ShardStatistics shards = search.shards();
    System.out.println("shards = " + shards);
    HitsMetadata<book> hits = search.hits();
    TotalHits total = hits.total();
    System.out.println("total = " + total);
    Double maxScore = hits.maxScore();
    System.out.println("maxScore = " + maxScore);
    List<hit<book>&gt; list = hits.hits();
    for (Hit<book> bookHit : list) {
        System.out.println("bookHit.source() = " + bookHit.source());
        System.out.println("bookHit.score() = " + bookHit.score());
        System.out.println("bookHit.index() = " + bookHit.index());
    }
}

可以看到，直接把查询的 JSON 参数传进来也是可以的。这样我们就可以先在 Kibana 中写好脚本，然后直接将脚本拷贝到 Java 代码中来执行就行了。

好啦，关于 Es 中新的 Java 客户端，我就和大家说这么多，最后再强调一下，这其实不是重点，玩 Es 的重点是把 Es 的各种查询参数搞懂，那么 Java 代码其实就是顺手拈来的事了。

最后，如果大家对 Es 不熟悉，可以看看松哥录的这个免费视频教程：

https://www.bilibili.com/video/BV1ft4y1e7tq/

</book></hit<book></book></book></book></hit<book></book></book></book></hit<book></book></book></certificate>

微信关注我们

原文链接：https://my.oschina.net/lenve/blog/5610310

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

PreSTU：一个专门为场景文本理解而设计的简单预训练模型

摘要：在视觉与语言（V&L）模型中，阅读和推理图像中的文本的能力往往是缺乏的。我们如何才能学习出强大的场景文本理解（STU）的V&L模型呢？本文分享自华为云社区《场景文本理解预训练PreSTU》，作者： Hint 。【论文摘要】在视觉与语言（V&L）模型中，阅读和推理图像中的文本的能力往往是缺乏的。我们如何才能学习出强大的场景文本理解（STU）的V&L模型呢？本文提出了PreSTU，一个专门为场景文本理解而设计的简单预训练模型。PreSTU将一个简单的OCR感知预训练目标与一个具有现成OCR信号的大规模图像-文本数据集相结合。我们在TextVQA、TextCaps、ST-VQA和VizWiz-VQA上经验性地证明了这个预训练目标的优越性。我们还研究了哪些因素会影响STU的性能，其中我们强调了图像分辨率和数据集规模在预训练中的重要性。【出发点】在真实世界中的视觉语言任务中，有大量的图像是包含场景文本的。理解图像中的文本对于视觉语言任务来说，往往是重要的，例如发票识别整理、机器人理解环境等。而现有模型经常忽略这一信息。通过对图像OCR信号引入，可以...

2022-12-16

432

FytSoa Admin 更新内容【新增】多租户支持-数据分离【优化】代码生成支持对列显示的选项支持前端服务端演示地址：fytsoa 超管账号：admin 密码：admin 租户账号：fyadmin 密码：123456 Swagger增强UI -关联项目 fytapi.mui 介绍 FytSoa Admin是一个快速搭建中后台解决方案，后台基于NetCore 6 和前端VUE3+Element+Plus实现。使用最新的前沿技术栈，提供各类使用组件方便在业务开发时调用，并且持续性的提供丰富的业务模块，帮助你快速搭建企业级中后台任务。支持数据分离多租户平台（SaaS）前端基于SCUI搭建架构图特点模块化：全新的架构和模块化的开发机制，便于灵活扩展和二次开发动态API DDD模式-领域驱动设计技术点 NetCore SDK 6.0+ ORM SqlSugar Mysql 后台教程 # 数据库连接在doc文件夹，通过数据库工具执行fytsoa.sql脚本 # 修改连接字符串打开FytSoa.ApiService,找到appset...

2022-12-16

434

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。