SpringBoot使用JestClient操作ElasticSearch

已于 2023-06-04 08:34:15 修改
阅读量3.2k 收藏 5
点赞数 2
分类专栏： Java&Javaweb 文章标签： elasticsearch spring boot java
于 2020-01-20 14:55:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/umgsai/article/details/104051558
版权
项目配置

项目中使用了Apollo进行配置管理

application.properties中配置如下

spring.elasticsearch.jest.uris = http://test-es.umgsai.com
spring.elasticsearch.jest.read-timeout = 3s
spring.elasticsearch.jest.connection-timeout = 2s

配置好之后就可以在项目中通过Resource注解拿到JestClient实例了

创建索引

创建index：POST http://localhost:8080/es/createIndex?index=main_order

@RequestMapping("/es")
@RestController
public class EsController {

    @Resource
    protected JestClient jestClient;

    @RequestMapping(value = "/createIndex", method = RequestMethod.POST)
    public Object createIndex(String index) throws IOException {
        CreateIndex createIndex = new CreateIndex.Builder(index).build();
        JestResult result = jestClient.execute(createIndex);
        if (result.isSucceeded()) {
            return Response.success(null);
        }
        return Response.fail(Code.ERROR_PARAM.getCode(), result.getErrorMessage());
    }
}
删除索引

删除index：DELETE http://localhost:8080/es/deleteIndex?index=main_order

@RequestMapping(value = "/deleteIndex", method = RequestMethod.DELETE)
public Object deleteIndex(String index) throws IOException {
    DeleteIndex deleteIndex = new DeleteIndex.Builder(index).build();
    JestResult result = jestClient.execute(deleteIndex);
    if (result.isSucceeded()) {
        return Response.success(null);
    }
    return Response.fail(Code.ERROR_PARAM.getCode(), result.getErrorMessage());
}
创建Mapping

PUT http://localhost:8080/es/putMapping

参数名值
indexmain_order
typemain_order
mapping如下JSON
{
    "main_order":{
        "properties":{
            "orderId":{
                "type":"keyword"
            },
            "tags":{
                "type":"long"
            },
            "version":{
                "type":"integer"
            },
            "createTime":{
                "type":"date",
                "format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
            },
            "updateTime":{
                "type":"date",
                "format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
            }
        }
    }
}

@RequestMapping(value = "/putMapping", method = RequestMethod.PUT)
public Object putMapping(String index, String type, String mapping) throws IOException {
    PutMapping putMapping = new PutMapping.Builder(
            index,
            type,
            mapping
    ).build();

    JestResult result = jestClient.execute(putMapping);
    if (result.isSucceeded()) {
        return Response.success(null);
    }
    return Response.fail(Code.ERROR_PARAM.getCode(), result.getErrorMessage());
}
查询Mapping
@RequestMapping(value = "/getMapping", method = RequestMethod.GET)
public Object getMapping(String index) throws IOException {

    Action getMapping = new GetMapping.Builder().addIndex(index).build();
    JestResult result = jestClient.execute(getMapping);

    if (result.isSucceeded()) {
        return Response.success(JSON.parse(result.getJsonString()));
    }
    return Response.fail(Code.ERROR_PARAM.getCode(), result.getErrorMessage());
}

ES不支持删除mapping，官方建议先删除一个index，然后重新创建index，重新创建mapping

 https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-delete-mapping.html
 It is no longer possible to delete the mapping for a type. Instead you should delete the index and recreate it with the new mappings.
异步写入数据
public <DATA> Response<Object> insertOrUpdate(String indexName, String typeName, List<DATA> dataList, String id, JestResultHandler<JestResult> jestResultHandler) {
    Bulk.Builder bulk = new Bulk.Builder();
    for (DATA data : dataList) {
        Index index = new Index.Builder(data).
                index(indexName).
                type(typeName).
                id(id).
                build();
        bulk.addAction(index);
    }
    jestClient.executeAsync(bulk.build(), jestResultHandler);
    return Response.success(null);
}
同步写入数据
    public <DATA> JestResult insertOrUpdate(String indexName, String typeName, List<DATA> dataList, String id) throws Exception {
        Bulk.Builder bulk = new Bulk.Builder();
        for (DATA data : dataList) {
            Index index = new Index.Builder(data).
                    index(indexName).
                    type(typeName).
                    id(id).
                    build();
            bulk.addAction(index);
        }
        return jestClient.execute(bulk.build());
    }
更新
public JestResult update(String indexName, String typeName, String id, Map<String, Object> paramMap) throws Exception {
    Map<String, Object> docMap = Maps.newHashMap();
    docMap.put("doc", paramMap);
    final Update update = new Update.Builder(docMap).id(id).build();
    final Bulk bulk = new Bulk.Builder()
            .addAction(update).defaultIndex(indexName).defaultType(typeName)
            .build();
    return jestClient.execute(bulk);
}
删除
// 异步删除
public Response<Object> deleteByKeyList(String indexName, String typeName, String deleteKeyName, List<String> deleteKeyList, JestResultHandler<JestResult> jestResultHandler) {
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().filter(QueryBuilders.termsQuery(deleteKeyName, deleteKeyList));
    DeleteByQuery deleteByQuery = new DeleteByQuery.Builder(new SearchSourceBuilder().query(boolQueryBuilder).toString())
            .addIndex(indexName)
            .addType(typeName)
            .refresh(true).build();
    jestClient.executeAsync(deleteByQuery, jestResultHandler);
    return Response.success(null);
}

// 同步删除
public JestResult deleteByKeyList(String indexName, String typeName, String deleteKeyName, List<String> deleteKeyList) throws Exception {
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().filter(QueryBuilders.termsQuery(deleteKeyName, deleteKeyList));
    DeleteByQuery deleteByQuery = new DeleteByQuery.Builder(new SearchSourceBuilder().query(boolQueryBuilder).toString())
            .addIndex(indexName)
            .addType(typeName)
            .refresh(true).build();
    return jestClient.execute(deleteByQuery);
}

// 按文档ID异步删除
public Response<Object> deleteById(String indexName, String typeName, String id, JestResultHandler<JestResult> jestResultHandler) {
    Delete.Builder builder = new Delete.Builder(id);
    Delete delete = builder.index(indexName).type(typeName).build();
    jestClient.executeAsync(delete, jestResultHandler);
    return Response.success(null);
}
查询数据

public <T> Response<PageResult<T>> query(BoolQueryBuilder boolQueryBuilder, String indexName, String typeName, Class<T> sourceType,
                                         String orderBy, Boolean desc, List<String> fieldList, Integer pageNum, Integer pageSize) {
    String query = "";
    Transaction transaction = Cat.newTransaction(TransactionType.ES_SEARCH_DATA, indexName);
    try {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(boolQueryBuilder);
        if (CollectionUtils.isNotEmpty(fieldList)) {
            //指定查询字段，不传则查询全部
            searchSourceBuilder.fetchSource(fieldList.toArray(new String[0]), null);
        }
        EsBuilder.pageParamBuilder(searchSourceBuilder, orderBy, desc, pageNum, pageSize);
        query = searchSourceBuilder.toString();
        int from = searchSourceBuilder.from();
        if (from > esSearchMaxFrom) {
            String errorMsg = String.format("从ES查询数据出现错误，indexName=%s, typeName=%s, query=%s, msg=不允许深度分页", indexName, typeName, query);
            log.error(errorMsg);
            orderErrorHandler.save("", OrderErrorTypeEnum.SEARCH_ES_ERROR, errorMsg);
            return Response.fail(Code.ERROR_PARAM.getCode(), "不允许深度分页，请检查参数");
        }
        log.info("SearchManager.query, indexName={}, typeName={}, query={}", indexName, typeName, query);
        Search search = new Search.Builder(query).addIndex(indexName).addType(typeName).build();
        SearchResult searchResult = jestClient.execute(search);
        if (!searchResult.isSucceeded()) {
            OrderSearchException orderSearchException = new OrderSearchException(ErrorCode.QUERY_ERROR);
            transaction.setStatus(orderSearchException);
            String errorMsg = String.format("从ES查询数据出现错误，indexName=%s, typeName=%s, query=%s, msg=%s", indexName, typeName, query, searchResult.getErrorMessage());
            log.error(errorMsg, orderSearchException);
            orderErrorHandler.save("", OrderErrorTypeEnum.SEARCH_ES_ERROR, errorMsg);
            return Response.fail(ErrorCode.QUERY_ERROR.getCode(), searchResult.getErrorMessage());
        }
        transaction.setStatus(Transaction.SUCCESS);
        long totalCount = searchResult.getTotal();
        PageResult<T> pageResult = new PageResult<>();
        pageResult.setCount(totalCount);
        List<T> resultList = Lists.newArrayList();
        List<SearchResult.Hit<T, Void>> hits = searchResult.getHits(sourceType);
        if (CollectionUtils.isNotEmpty(hits)) {
            for (SearchResult.Hit<T, Void> hit : hits) {
                resultList.add(hit.source);
            }
        }
        pageResult.setList(resultList);
        pageResult.setEnd(CollectionUtils.size(resultList) < searchSourceBuilder.size());
        return Response.success(pageResult);
    } catch (Exception e) {
        transaction.setStatus(e);
        String errorMsg = String.format("从ES查询数据出现异常，indexName=%s, typeName=%s, query=%s, msg=%s", indexName, typeName, query, e.getMessage());
        orderErrorHandler.save("", OrderErrorTypeEnum.SEARCH_ES_ERROR, errorMsg);
        log.error(errorMsg, e);
        return Response.fail(ErrorCode.QUERY_ERROR.getCode(), errorMsg);
    } finally {
        transaction.complete();
    }
}
查询数量
public Response<Long> queryCount(BoolQueryBuilder boolQueryBuilder, String indexName, String typeName) {
    String query = "";
    Transaction transaction = Cat.newTransaction(TransactionType.ES_SEARCH_COUNT, indexName);
    try {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(boolQueryBuilder);
        query = searchSourceBuilder.toString();
        Count count = new Count.Builder()
                .addIndex(indexName)
                .addType(typeName)
                .query(query)
                .build();
        log.info("SearchManager.queryCount, indexName={}, typeName={}, query={}", indexName, typeName, query);
        CountResult countResult = jestClient.execute(count);
        if (!countResult.isSucceeded()) {
            OrderSearchException orderSearchException = new OrderSearchException(ErrorCode.QUERY_ERROR);
            transaction.setStatus(orderSearchException);
            String errorMsg = String.format("从ES查询数量出现错误，indexName=%s, typeName=%s, query=%s, msg=%s", indexName, typeName, query, countResult.getErrorMessage());
            orderErrorHandler.save("", OrderErrorTypeEnum.SEARCH_ES_ERROR, errorMsg);
            log.error(errorMsg, orderSearchException);
            return Response.fail(ErrorCode.QUERY_ERROR.getCode(), countResult.getErrorMessage());
        }
        Double resultsCount = countResult.getCount();
        transaction.setStatus(Transaction.SUCCESS);
        return Response.success(resultsCount.longValue());
    } catch (Exception e) {
        transaction.setStatus(e);
        String errorMsg = String.format("从ES查询数量出现异常，indexName=%s, typeName=%s, query=%s, msg=%s", indexName, typeName, query, e.getMessage());
        log.error(errorMsg, e);
        orderErrorHandler.save("", OrderErrorTypeEnum.SEARCH_ES_ERROR, errorMsg);
        return Response.fail(ErrorCode.QUERY_ERROR.getCode(), errorMsg);
    } finally {
        transaction.complete();
    }
}
JestClient连接池

JestClient是基于HttpClient的，使用了http连接池和ES服务端进行通信。
httpclient通过maxTotal和defaultMaxPerRoute来配置连接池。
maxTotal：设置连接池的最大连接数，即整个池子的大小。初始值20
defaultMaxPerRoute：设置每一个路由的最大连接数，这里的路由是指IP+PORT，例如连接池大小(MaxTotal)设置为300，路由连接数设置为200(DefaultMaxPerRoute)，对于www.a.com与www.b.com两个路由来说，发起服务的主机连接到每个路由的最大连接数（并发数）不能超过200，两个路由的总连接数不能超过300。初始值2.
在defaultMaxPerRoute小于maxTotal时，主要是defaultMaxPerRoute起作用，因为在我这个例子中只有一个 ip+port
在这里插入图片描述
设置maxTotal和defaultMaxPerRoute的方法

@Slf4j
@Component
public class HttpSettingsCustomizer implements HttpClientConfigBuilderCustomizer {
 
    //Apollo配置
    @Value("${es.max.total.connection:100}")
    private Integer maxTotalConnection;
    @Value("${es.default.max.total.connection.per.route:35}")
    private Integer defaultMaxTotalConnectionPerRoute;
 
    @Override
    public void customize(HttpClientConfig.Builder builder) {
        log.info("set maxTotalConnection={}, defaultMaxTotalConnectionPerRoute={}", maxTotalConnection, defaultMaxTotalConnectionPerRoute);
        builder.maxTotalConnection(maxTotalConnection).defaultMaxTotalConnectionPerRoute(defaultMaxTotalConnectionPerRoute);
    }
}

参数设置过程可参考JestAutoConfiguration源码

@Configuration
@ConditionalOnClass(JestClient.class)
@EnableConfigurationProperties(JestProperties.class)
@AutoConfigureAfter(GsonAutoConfiguration.class)
public class JestAutoConfiguration {
 
   private final JestProperties properties;
 
   private final ObjectProvider<Gson> gsonProvider;
 
   private final List<HttpClientConfigBuilderCustomizer> builderCustomizers;
 
   public JestAutoConfiguration(JestProperties properties, ObjectProvider<Gson> gson,
         ObjectProvider<List<HttpClientConfigBuilderCustomizer>> builderCustomizers) {
      this.properties = properties;
      this.gsonProvider = gson;
      this.builderCustomizers = builderCustomizers.getIfAvailable();
   }
 
   @Bean(destroyMethod = "shutdownClient")
   @ConditionalOnMissingBean
   public JestClient jestClient() {
      JestClientFactory factory = new JestClientFactory();
      factory.setHttpClientConfig(createHttpClientConfig());
      return factory.getObject();
   }
 
   protected HttpClientConfig createHttpClientConfig() {
      HttpClientConfig.Builder builder = new HttpClientConfig.Builder(
            this.properties.getUris());
      PropertyMapper map = PropertyMapper.get();
      map.from(this.properties::getUsername).whenHasText().to((username) -> builder
            .defaultCredentials(username, this.properties.getPassword()));
      Proxy proxy = this.properties.getProxy();
      map.from(proxy::getHost).whenHasText().to((host) -> {
         Assert.notNull(proxy.getPort(), "Proxy port must not be null");
         builder.proxy(new HttpHost(host, proxy.getPort()));
      });
      map.from(this.gsonProvider::getIfUnique).whenNonNull().to(builder::gson);
      map.from(this.properties::isMultiThreaded).to(builder::multiThreaded);
      map.from(this.properties::getConnectionTimeout).whenNonNull()
            .asInt(Duration::toMillis).to(builder::connTimeout);
      map.from(this.properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis)
            .to(builder::readTimeout);
      customize(builder);
      return builder.build();
   }
 
   private void customize(HttpClientConfig.Builder builder) {
      if (this.builderCustomizers != null) {
         for (HttpClientConfigBuilderCustomizer customizer : this.builderCustomizers) {
            customizer.customize(builder);
         }
      }
   }
 
}

参考：https://www.jianshu.com/p/df5d89955eaa
https://docs.spring.io/spring-boot/docs/2.0.3.RELEASE/reference/htmlsingle/#boot-features-elasticsearch

商商-77
关注
专栏目录
使用JestClient操作ElasticSearch
LKET的博客
03-09 1366
1. 前言 ElasticSearch是一个在全文搜索引擎库Apache Lucene基础之上建立的开源服务，它提供了一个分布式、高扩展、高实时的搜索与数据分析引擎。 在Spring Boot中集成ElasticSearch有Spring Data Elasticsearch、REST Client和Jest等方式。其中Jest作为一个用于ElasticSearch的HTTP Java 客户端，提...
SpringBoot专题学习Part28：SpringBoot整合Elasticsearch(使用Jest和Spring Data Elasticsearch进行操作)
12-21
Spring Boot默认集成Spring Data Elasticsearch模块，但同时也支持使用Jest作为Elasticsearch的客户端。Jest是一个流行的选择，因为它通过HTTP与Elasticsearch服务器进行通信，简化了与Elasticsearch的交互过程。 ...
Elasticsearch-JestClient
02-21
java使用Jest Client操作Elasticsearch。自己修改了一些，测试完美运行。
SpringBoot 使用JestClient操作Elasticsearch
shehuinikaige的博客
12-05 389
操作Elasticsearch的客户端有很多，SpringBoot也提供了方式去操作，这里介绍另外一种方式去使用Elasticsearch ---JestClientJestClient是一款基于HTTP方式操作的Elasticsearch的客户端，支持同步和异步操作，同时也可以结合ElasticSearch的依赖进行操作Elasticsearch。
ES--创建--JestClient
Small_white_528的博客
09-23 1382
使用match查询时，Elasticsearch将对一个字段选择合适的分析器，所以可以确定，传给match查询的词条将被建立索引时相同的分析器处理。filterQueryBuilders.must(QueryBuilders.matchQuery("address", "程序员")).must(QueryBuilders.termQuery("male", "女"));词条查询是Elasticsearch中的一个简单查询。match：匹配的时候，会将查询的关键字进行分词，然后根据分词后的结果进行查询。
SpringBoot整合jest操作ElasticSearch
Wyangcsdb的博客
02-24 483
我们可以使用java代码的方式去操作ElasticSearch，而SpringBoot整合jest去操作ES不用担心es的各种版本问题，而且不用去考虑与reids发生版本冲突，自己刚上手，记录下，有不足的地方可以去网上找其他资料。 随着ElasticSearch的版本变更，相关的Java API也在做不断的调整，就是ElasticSearch服务端版本进行更改之后，客户端的代码可能需要重新编写。 因此介绍一个相当好用的第三方工具JestClient，它对ElasticSearch进行封装，填补了 Elas
springboot使用jest操作elasticsearch
weixin_34310127的博客
07-03 275
maven <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch&...
es结合jestClient完成对数据操作
goxingman的博客
11-15 1869
package cn.xgs.JestClient; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Map; import org.ela...
SpringBoot 使用JestClient操作Elasticsearch的查询步骤
最新发布
10-24
Spring Boot 中使用 JestClient 操作 Elasticsearch 的查询通常包括以下几个步骤： 1. **添加依赖**: 首先，在你的 `pom.xml` 或者 `build.gradle` 文件中添加 Jest 和 Elasticsearch 客户端的依赖。例如: ```xml...
SpringBoot 整合Jest
赵英超的博客
08-20 5940
  【1】添加Elasticsearch-starter pom文件添加starter如下： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-elasticsearch&lt;/artif...
elasticsearch java客户端Jest入门实例
04-18
本实例参考网上代码：http://www.ibm.com/developerworks/cn/java/j-javadev2-24/ 通过Jest和Junit单元测试的方法创建索引和检索 第一步:启动一个elasticsearch服务，bin目录下的elasticsearch.bat 第二步:建索引，执行MusicReviewIndex中的单元测试方法index() 第三步:检索测试，执行MusicReviewSearch中的单元测试方法search() 本实例基于： Jest 0.0.3，elasticsearch 0.20.5
【全文检索_07】JestClient 操作 Elasticsearch
Demo_Null
02-02 1043
JestClient 是一款基于 HTTP 方式操作的 Elasticsearch 的客户端，支持同步和异步操作，同时也可以结合 ElasticSearch 的依赖进行操作 Elasticsearch。
JestClient实现Elasticsearch操作
JesJiang的博客
12-10 525
1、保存并获得_id public Object insert(Object doc,String indexName,String type) { Bulk.Builder bulk = new Bulk.Builder(); Index index = new Index.Builder(doc).index(indexName).type(type).build(); bulk....
04-Elasticsearch的 JestClient
yk10010的博客
01-10 762
04-Elasticsearch的 JestClient 1. 介绍 任何使用过Elasticsearch的人都知道，使用基于rest的搜索API构建查询可能是单调乏味且容易出错的。 在本教程中，我们将研究Jest，一个用于Elasticsearch的HTTP Java客户端。Elasticsearch提供了自己原生的Java客户端，然而 Jest提供了更流畅的API和更容易使用的接口 2. Ma...
elasticsearch jestclient api
weixin_30699831的博客
05-23 687
1、es search sroll可以遍历索引下所有数据 public class TestDemo { @Test public void searchSroll() { JestClientFactory factory = new JestClientFactory(); factory.setHttpClientC...
SpringBoot学习之路---整合jest操作ElasticSearch
LeslieLau的博客
04-30 367
我们可以使用java代码的方式去操作ElasticSearch，而SpringBoot也为我们提供了整合的方式,整合ElasticSearch并操作的方式有两种，这一篇博客来记录其中的一种 (整合jest去操作ES) 老规矩，我们要使用某种技术，那么就要去导入它的maven相关依赖: <!-- https://mvnrepository.com/artifact/io.searchbox/...
Elasticsearch Jest实战深入详解
热门推荐
铭毅天下Elasticsearch
08-13 2万+
以Jest为例，假设我们之前没有用过Jest，对Jest的认知，需要经历的过程： 步骤1：Jest是什么？能既解决什么问题？ 步骤2: Jest的优势是什么？为什么会出现？ 步骤3：Jest如何安装与使用？ 步骤4：Jest的样例Demo。本文，就带你从认知的角度，一步步学会使用Jest。1、Jest介绍Jest是Elasticsearch 的Java Http Rest 客户端。Elast
【jestClient】springBoot2.6.x使用jestClient连接elasticsearch单机、集群的方法
qq_42695788的博客
09-05 227
由于springBoot2.6.x不再支持自动注入JestClient，直接使用@Autowired注入会报错。比较好的解决方法是在项目中添加一个jestConfig配置类，用于自动注入。以下是连接es单机与集群的配置类示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值