Springboot集成Elasticsearch High Level REST Client实现增删改查实战

于 2024-07-25 14:48:00 发布
阅读量553 收藏 17
点赞数 6
分类专栏： # ElasticSearch # 玩转Spring Boot 文章标签： spring boot elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IndexMan/article/details/140611813
版权

在这里插入图片描述

获取源码🚩

需要完整代码资料，请一键三连后评论区留下邮箱，安排发送！！！🤖

什么是High Level REST Client？

Elasticsearch 的 High Level REST Client 是一个用于与 Elasticsearch 进行交互的 Java 客户端库，它提供了比低级别的 REST 客户端更高级别的抽象。High Level REST Client 使用了 OkHttp 库作为底层的 HTTP 客户端，并且提供了自动重试、连接管理和错误处理等功能。它允许开发人员以面向对象的方式构建请求和解析响应，从而简化了与 Elasticsearch 的 REST API 的交互过程。

✔️优点：

  • 易用性：High Level REST Client 提供了丰富的 API，使得常见的 Elasticsearch 操作变得简单直观。
  • 自动重试和错误处理：它能够处理网络故障和重试失败的请求，减少了开发人员需要处理的异常情况。
  • 封装了 JSON 处理：它自动处理了请求和响应的序列化和反序列化，使得开发人员无需直接处理 JSON 字符串。
  • 连接管理：它提供了连接池管理，可以复用连接，提高性能。

❌缺点：

  • 依赖较大：由于其提供了丰富的功能，因此其依赖库和整体大小相对较大。
  • 性能开销：高层面的抽象可能会引入额外的性能开销，尤其是在高并发场景下。

High Level REST Client的核心

索引管理

CreateIndexRequest 和 CreateIndexResponse：用于创建一个新的索引。
GetIndexRequest 和 GetIndexResponse：用于获取索引的元数据。
DeleteIndexRequest 和 DeleteIndexResponse：用于删除一个索引。

文档操作

IndexRequest 和 IndexResponse：用于索引（或更新）一个文档。
UpdateRequest 和 UpdateResponse：用于更新已存在的文档。
GetRequest 和 GetResponse：用于检索一个文档。
DeleteRequest 和 DeleteResponse：用于删除一个文档。

搜索和聚合

SearchRequest 和 SearchResponse：用于执行搜索查询和聚合。
CountRequest 和 CountResponse：用于计算满足给定条件的文档数量。
ScrollRequest 和 ScrollResponse：用于滚动搜索结果，获取大量数据。

批量操作

BulkRequest 和 BulkResponse：用于执行批量操作，如批量索引、更新或删除多个文档。

request.source()等于DSL中query{}

Sprinboot集成High Level REST Client

创建索引

可以使用postman或者谷歌浏览器插件Elasticvue 创建：
在这里插入图片描述

{
  "article_doc": {
    "aliases": {},
    "mappings": {
      "properties": {
        "author": {
          "type": "keyword"
        },
        "category": {
          "type": "keyword"
        },
        "content": {
          "type": "text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_smart"
        },
        "createTime": {
          "type": "date",
          "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
        },
        "id": {
          "type": "keyword"
        },
        "readCount": {
          "type": "integer"
        },
        "title": {
          "type": "text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_smart"
        }
      }
    },
    "settings": {
      "index": {
        "routing": {
          "allocation": {
            "include": {
              "_tier_preference": "data_content"
            }
          }
        },
        "number_of_shards": "1",
        "provided_name": "article_doc",
        "creation_date": "1721725035763",
        "number_of_replicas": "1",
        "uuid": "r55CXBCLSxO8aFWPtL1Niw",
        "version": {
          "created": "7130299"
        }
      }
    }
  }
}

添加pom依赖

<dependency>
	<groupId>org.elasticsearch</groupId>
	<artifactId>elasticsearch</artifactId>
	<version>7.14.0</version>
</dependency>

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

编写配置类

@Configuration
public class ElasticsearchConfig {
    @Value("${elasticsearch.host}")
    private String host;

    @Value("${elasticsearch.port}")
    private int port;

    /*@Value("${elasticsearch.username}")
    private String userName;

    @Value("${elasticsearch.password}")
    private String password;*/

    /**
     * 如果@Bean没有指定bean的名称，那么这个bean的名称就是方法名
     */
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        return new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost(host, port, "http")
                )
        );
    }


}

编写模型

@Data
@TableName("tb_article")
public class Article {
    private String id;
    private String author;
    private String category;
    private String title;
    private String content;
    private Integer readCount;
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;
}

编写接口服务类

获取索引结构接口

http://localhost:9000/articleDoc/getMapping
在这里插入图片描述

数据同步接口

/**
     *  批量从数据库导入
     * @throws IOException
     */
    public void importFromDb() throws IOException {
        List<Article> articleList = articleService.list();
        BulkRequest bulkRequest = new BulkRequest();
        for (Article doc : articleList) {
            String data = JSON.toJSONString(doc);
            IndexRequest indexRequest = new IndexRequest(Constant.ARTICLE_INDEX);
            indexRequest.id(doc.getId()).source(data, XContentType.JSON);
            bulkRequest.add(indexRequest);
        }
        BulkResponse response = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        log.info("批量导入状态：{}, 耗时{}", response.status(), response.getTook().getSeconds());
    }

在这里插入图片描述

精确查询

public List<Article> searchByAuthor(String author) {
        try {
            // 构建查询条件（注意：termQuery 支持多种格式查询，如 boolean、int、double、string 等，这里使用的是 string 的查询）
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.termQuery("author", author));
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            // 执行查询，然后处理响应结果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根据状态和数据条数验证是否返回了数据
            List<Article> articleList = new ArrayList<>();
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    Article doc = JSON.parseObject(hit.getSourceAsString(), Article.class);
                    articleList.add(doc);
                }
            }
            return articleList;
        } catch (IOException e) {
            log.error("精确查询异常：", e);
            return null;
        }
    }

在这里插入图片描述

全文查询

  • 查全部，
    java MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
    太简单，不再演示。
/**
     *  全文查询
     */
    public List<Article> matchQuery(String keyword) {
        try {
            // 构建查询条件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.multiMatchQuery(keyword,"title","content"));
            // 创建查询请求对象，将查询对象配置到其中
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            // 执行查询，然后处理响应结果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            return getArticleListFromSearchResponse(searchResponse);
        } catch (IOException e) {
            log.error("全文查询异常", e);
            return null;
        }
    }

在这里插入图片描述

分页查询（带排序）

/**
     *  分页查询
     * @param page
     */
    public void pageSortQuery(Page<Article> page) {
        try {
            // 构建查询条件
            MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
            // 创建查询源构造器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchAllQueryBuilder);
            // 设置分页
            searchSourceBuilder.from((int) ((page.getCurrent()-1)*page.getSize()));
            searchSourceBuilder.size((int) page.getSize());
            // 按照阅读量排序
            searchSourceBuilder.sort("readCount", SortOrder.DESC);
            // 创建查询请求对象，将查询对象配置到其中
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            // 执行查询，然后处理响应结果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根据状态和数据条数验证是否返回了数据
            page.setTotal(getHitTotal(searchResponse));
            page.setRecords(getArticleListFromSearchResponse(searchResponse));
        } catch (IOException e) {
            log.error("分页查询失败", e);
        }
    }

在这里插入图片描述

高亮查询✨

public List<Article> highlightQuery(String keyword) {
        try {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", keyword);
            HighlightBuilder highlightBuilder = new HighlightBuilder().field("title").preTags("<font color='red'>").postTags("</font>");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchQueryBuilder);
            searchSourceBuilder.highlighter(highlightBuilder);
            searchSourceBuilder.size(100);
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            List<Article> articleList = new ArrayList<>();
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    Article doc = JSON.parseObject(hit.getSourceAsString(), Article.class);
                    // 获取高亮的数据
                    HighlightField highlightField = hit.getHighlightFields().get("title");
                    System.out.println("高亮名称：" + highlightField.getFragments()[0].string());
                    // 替换掉原来的数据
                    Text[] fragments = highlightField.getFragments();
                    if (fragments != null && fragments.length > 0) {
                        StringBuilder title = new StringBuilder();
                        for (Text fragment : fragments) {
                            title.append(fragment);
                        }
                        doc.setTitle(title.toString());
                    }
                    articleList.add(doc);
                }
            }
            return articleList;
        } catch (Exception e) {
            log.error("高亮查询失败", e);
            return null;
        }
    }

在这里插入图片描述

范围查询

/**
     *  范围查询
     *  时间文档表达式：https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#date-math
     * @return
     */
    public List<Article> rangeQuery() {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //searchSourceBuilder.query(QueryBuilders.rangeQuery("price").gte(10000));
            searchSourceBuilder.query(QueryBuilders.rangeQuery("createTime")
                    .gte("now-2d").includeLower(true).includeUpper(true));
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            return getArticleListFromSearchResponse(searchResponse);
        } catch (Exception e) {
            log.error("范围查询失败", e);
            return null;
        }
    }

在这里插入图片描述

布尔查询（BooleanQuery）

bool 查询可以用来合并多个条件查询结果的布尔逻辑，它包含一下操作符：

must：多个查询条件必须完全匹配，相当于关系型数据库中的 and。
should：至少有一个查询条件匹配，相当于关系型数据库中的 or。
must_not： 多个查询条件的相反匹配，相当于关系型数据库中的 not。
filter：过滤满足条件的数据。
range：条件筛选范围。
gt：大于，相当于关系型数据库中的 >。
gte：大于等于，相当于关系型数据库中的 >=。
lt：小于，相当于关系型数据库中的 <。
lte：小于等于，相当于关系型数据库中的 <=。

public List<Article> highlightQuery(String keyword) {
        try {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", keyword);
            HighlightBuilder highlightBuilder = new HighlightBuilder().field("title").preTags("<font color='red'>").postTags("</font>");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchQueryBuilder);
            searchSourceBuilder.highlighter(highlightBuilder);
            searchSourceBuilder.size(100);
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            List<Article> articleList = new ArrayList<>();
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    Article doc = JSON.parseObject(hit.getSourceAsString(), Article.class);
                    // 获取高亮的数据
                    HighlightField highlightField = hit.getHighlightFields().get("title");
                    System.out.println("高亮名称：" + highlightField.getFragments()[0].string());
                    // 替换掉原来的数据
                    Text[] fragments = highlightField.getFragments();
                    if (fragments != null && fragments.length > 0) {
                        StringBuilder title = new StringBuilder();
                        for (Text fragment : fragments) {
                            title.append(fragment);
                        }
                        doc.setTitle(title.toString());
                    }
                    articleList.add(doc);
                }
            }
            return articleList;
        } catch (Exception e) {
            log.error("高亮查询失败", e);
            return null;
        }
    }

在这里插入图片描述

聚合查询

在使用Elasticsearch时，更多会用到聚合操作，它类似SQL中的groupby操作。ES的聚合查询是先查出结果，然后对结果使用聚合函数做处理，常用的操作有：avg：求平均、max：最大值、min：最小值、sum：求和等。

在ES中聚合分为指标聚合和分桶聚合：

Metric 指标聚合：指标聚合对一个数据集求最大、最小、和、平均值等
Bucket 分桶聚合：除了有上面的聚合函数外，还可以对查询出的数据进行分组group by，再在组上进行游标聚合。

  • Metric 指标聚合
/**
     *  指标查询
     */
    public int metricQuery() {
        try {
            MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchAllQueryBuilder);
            AggregationBuilder mostPopular = AggregationBuilders.max("mostPopular").field("readCount");
            searchSourceBuilder.aggregation(mostPopular);
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
//            log.info("查询结果：{}", JSON.toJSONString(searchResponse));
            Aggregations aggregations = searchResponse.getAggregations();
            ParsedMax max = aggregations.get("mostPopular");
            return (int) max.getValue();
        } catch (Exception e) {
            log.error("指标查询失败", e);
            return -1;
        }
    }

在这里插入图片描述

  • Bucket 分桶聚合

根据文章分类，统计文章数量。

/**
     *  分桶聚合
     * @return
     */
    public Map<String,Object> bucketQuery() {
        try {
            // 构建查询条件
            MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
            // 创建查询源构造器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchAllQueryBuilder);

            // 根据商品分类进行分组查询
            TermsAggregationBuilder categoryGroup = AggregationBuilders.terms("categoryGroup").field("category");
            searchSourceBuilder.aggregation(categoryGroup);

            // 创建查询请求对象，将查询对象配置到其中
            SearchRequest searchRequest = new SearchRequest(Constant.ARTICLE_INDEX);
            searchRequest.source(searchSourceBuilder);
            // 执行查询，然后处理响应结果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            Aggregations aggregations = searchResponse.getAggregations();
            ParsedStringTerms agg = aggregations.get("categoryGroup");
            Map<String,Object> resultMap = new HashMap<>();
            for (Terms.Bucket bucket : agg.getBuckets()) {
                resultMap.put(bucket.getKeyAsString(), bucket.getDocCount());
            }
            return resultMap;
        } catch (Exception e) {
            log.error("分桶聚合查询失败", e);
            return null;
        }
    }

在这里插入图片描述

为什么8.0版本要弃用？

在 Elasticsearch 8.0 版本中，High Level REST Client 被标记为弃用，主要是因为以下几个原因：

  • 维护成本：High Level REST Client 的维护成本较高，因为它需要随着 Elasticsearch 的发展而持续更新，以保持与 REST API 的兼容性。
  • 性能考量：为了提高性能和减少内存消耗，Elasticsearch 开发团队决定移除一些高成本的组件，High Level REST Client 因其封装层次较多而成为目标之一。
  • 替代方案：Elasticsearch 推出了新的 Java API Client，这是一个更轻量级、更高效的选择，它直接使用了 Elasticsearch 的内部协议，从而提供了更好的性能和更低的延迟。
    新的 Java API Client 能够更好地利用 Elasticsearch 的内部机制，减少序列化和反序列化的开销，同时也提供了更细粒度的控制和更高的灵活性。因此，Elasticsearch 推荐用户迁移到新的 Java API Client 上。

所以后续我会再整理个新的Java API Client 用法。与时俱进。

点赞收藏加评论

用到的时候再来看，收获更大。

罗汉爷
关注
  • 6
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合Java High Level REST Client调动elasticsearch进行增删改查
terry711的专栏
04-09 6582
现在java常用的有两种模式 Java TransportClient API 客户端 在 Elasticsearch 7 中已经说明该客户端将在 8.0 版本被废弃。 具体使用可参考 https://www.elastic.co/guide/en/elasticsearch/client/java-api/7.2/java-api.html Java REST Client API 客户端 REST Client 有两个版本，一个是 Low Level，提供了比较简单的 HTTP 客户端功能。具体可参考
java集成elasticsearch-rest-high-level-client实现增删改查
u010825190的博客
05-12 936
依赖 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.15.2</version> </dependency> <dependency> <groupI
SpringBoot整合ElasticSearch之Java High Level REST Client
ClinEvol的博客
03-20 1649
注意：使用@Autowired注入RestHighLevelClient 如果报红线，则是因为配置类所在的包和测试类所在的包，包名不一致造成的。需求：同时完成【删除，更新，添加】操作 这里的JSON格式不能格式化。这里可以不写在配置，可以直接写在代码中，只是这样做会专业一点。记得把maven的单元测试关了。操作索引要索引的对象来进行操作。添加文档,使用map作为数据。添加文档,使用对象作为数据。
一篇实现springboot集成elasticsearch的增删改查
qq_48804275的博客
04-03 3002
准备工作 springboot版本 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.5.RELEASE</version> </parent> elasticsearc
SpringBoot集成Elasticsearch实现增删改查的功能代码
06-21
在本文中，我们将深入探讨如何将SpringBoot与Elasticsearch集成，以实现高效的数据增删改查功能。Elasticsearch是一种流行的开源搜索引擎，常用于大数据分析、日志收集和全文检索。SpringBoot作为轻量级的Java框架，...
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
elasticsearch-rest-high-level-client-6.8.3-API文档-中英对照版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
spring boot2 实现elasticsearch 增删改查实例elasticsearch-rest-high-leve
06-21
spring boot2 实现elasticsearch 增删改查实例。elasticsearch-rest-high-level-client 软件架构 软件架构说明 安装教程 启动类启动 启动成功后：http://localhost:8080/els/search?mess=78787
SpringBoot整合Elasticsearch7.2.0的实现方法
08-25
<artifactId>elasticsearch-rest-high-level-client ${elasticsearch.version} ``` 在 application.yml 配置文件中，我们需要添加以下配置： ```yaml elasticsearch: ip: 192.168.52.132:9200 ``` 客户端连接...
【spring boot】初学者项目快速练手
m0_67357141的博客
07-17 1062
快速生成一个初始的项目代码，会生成一个demo文件打开intellj idea，导入demo文件。
Spring Boot配置文件的语法规则
2301_77053417的博客
07-21 1026
名字是很固定的，必须是：application.properties或者application.yml，这两个都是配置文件的格式，一般我们使用其中一个即可（一般yml使用的较多）。（3）当项目中properties和yml都存在，并且里面的内容冲突时，会以properties中的为配置项，也就是其优先级更高。一般双引号里面的东西不会被被转义，单引号里面的会被转义，也就是\n在单引号下就只是一个串，在双引号下是换行。=左边的就是key，=右边的是value，在获取配置文件时，需要填入完整的key。
使用AOP优化Spring Boot Controller参数：自动填充常用字段的技巧
todoitbo的博客
07-21 854
本篇博客将深入介绍如何利用AOP技术，在Spring Boot应用中实现对Controller保存方法参数的重写。我们将重点讨论如何利用AOP切面，自动填充常用字段（如创建时间、修改时间、创建人、修改人），以提高代码的重用性和可维护性。
spring boot 实现token验证登陆状态
WenZhengshi的博客
07-18 380
3、启动服务器测试下,写个controller和html,客户端请求获取token。1、添加maven依赖到pom.xml。html （请求token）
Spring Boot中的 6 种API请求参数读取方式
恒安软件
07-13 941
使用Spring Boot开发API的时候，读取请求参数是服务端编码中最基本的一项操作，Spring Boot中也提供了多种机制来满足不同的API设计要求。接下来，就通过本文，为大家总结6种常用的请求参数读取方式。如果你发现自己知道的不到6种，那么赶紧来查漏补缺一下。如果你知道的不止6种，那么告诉大家，一起互相学习一下吧～
Spring Boot + Spring Cloud 入门
一个大佬的博客
07-21 1325
Log4j2、ERROR -》 log4j2-spring.xml 或 log4j2.xml。#将名为spring.log写入到指定的文件夹中，如（/var/log）#将日志写入到指定的文件中，默认为相对路径，可以设置成绝对路径。《SpringCloud微服务架构开发实战》《SpringBoot企业应用开发实战》《网页UI与用户体验设计 5 要素》#比如 mybatis sql日志。《分布式系统常用技术及案例分析》《Spring5开发大全》《java核心编程》《VR，AR与MR》
Spring Boot与微服务架构：快速开发指南
最新发布
哎 你看的博客
07-24 980
随着微服务架构的兴起，越来越多的企业选择将应用拆分成一系列小型、独立且松耦合的服务。Spring Boot作为Spring Framework的扩展，提供了快速开发微服务的能力。本文将深入探讨如何使用Spring Boot快速开发微服务，包括服务发现、配置管理等关键技术。
Spring Boot 日志
m0_60963435的博客
07-23 917
T04BF👋专栏:🫵 今天你敲代码了吗。
Spring Boot 笔记1(启动类与控制器)
wangmingshi666的博客
07-21 522
采用Spring Tool Suit 4学习启动类与控制器。
怎么用Java High Level REST Client 6.2.3的版本查询Elasticsearch 中索引的映射
06-07
使用Java High Level REST Client 6.2.3版本可以通过以下步骤查询Elasticsearch中索引的映射： 1. 创建Elasticsearch客户端： ```java RestHighLevelClient client = new RestHighLevelClient( RestClient.builder( new HttpHost("localhost", 9200, "http"))); ``` 2. 构建获取索引映射的请求： ```java GetMappingsRequest request = new GetMappingsRequest(); request.indices("your_index_name"); ``` 3. 发送请求并处理响应： ```java try { GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT); Map<String, MappingMetaData> mappings = response.mappings(); // 处理Mappings } catch (IOException e) { e.printStackTrace(); } finally { try { client.close(); } catch (IOException e) { e.printStackTrace(); } } ``` 在上面的代码中，我们首先创建了一个Elasticsearch客户端。然后，我们构建了一个获取索引映射的请求，并指定了要获取映射的索引名称。最后，我们发送请求并处理响应。响应中包含了所有映射信息，我们可以从响应中获取映射相关的元数据并进行处理。 需要注意的是，以上代码中的`your_index_name`需要替换为你要查询映射的索引名称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值