通过RestHighLevelClient操作ES

一、查询相关

在es查询中，must相当于sql语句中的and，should相当于or。当想要实现类似于"select * from table where a and (b or c or d)"的功能时可以借助于es中的bool。即RestHighLevelClient中的BoolQueryBuilder。示例如下：

//先构建一个bool对象用于存放or相关的条件
if (!StringUtils.isEmpty(realname)) {
   QueryBuilder realnameQuery = QueryBuilders.matchPhraseQuery("content", realname);
   boolQueryBuilder.should(realnameQuery);
}
if(!StringUtils.isEmpty(orgCode)) {
    QueryBuilder orgCodeQuery = QueryBuilders.matchPhraseQuery("content", orgCode);
    boolQueryBuilder.should(orgCodeQuery);
}
//and条件可以选择match_phrase短语查询
QueryBuilder wClass = QueryBuilders.matchPhraseQuery("source_ke", "sentiment");
//将所有条件再组装到一个bool对象中
BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
boolBuilder.must(boolQueryBuilder);
boolBuilder.must(wClass);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(boolBuilder)

根据时间范围作数据过滤时，通过RangeQueryBuilder和filter完成

SearchSourceBuilder builder = new SearchSourceBuilder();
RangeQueryBuilder timeQuery = QueryBuilders.rangeQuery("ctime");
if (!StringUtils.isEmpty(infoListQuery.getStartTime())) {
    Date date = DateUtil.parse(infoListQuery.getStartTime());
    long startSs = date.getTime();
    timeQuery.gte(String.valueOf(startSs));
}
if (!StringUtils.isEmpty(infoListQuery.getEndTime())) {
    Date date = DateUtil.parse(infoListQuery.getEndTime());
    long endSs = date.getTime();
    timeQuery.lte(String.valueOf(endSs));
}
builder.postFilter(timeQuery);

使用ES聚合函数获得统计值

//指定要聚合计算的字段，并为结果指定名称
TermsAggregationBuilder field = AggregationBuilders.terms("sentimentGroup").field("sentiment");
SearchSourceBuilder builder = new SearchSourceBuilder();
//不需要查看详细内容
builder.query(boolBuilder).aggregation(field).size(0);
//请求对象携带条件,查询类型,一般默认即可
SearchRequest searchRequest = new SearchRequest(tcEsidx).types(tcEsType);
searchRequest.source(builder).searchType(SearchType.DEFAULT);
try {
    //通过高级客户端执行查询请求,返回响应对象
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
    //解析统计响应数据
    Aggregations aggregations = searchResponse.getAggregations();
    Map<String, Object> resultMap = new HashMap<>();
    Terms sourceType = aggregations.get("sentimentGroup");
    for (Terms.Bucket bucket : sourceType.getBuckets()) {
         if ("-1".equals(bucket.getKeyAsString())) {
              resultMap.put("neg", bucket.getDocCount());
          } else if ("1".equals(bucket.getKeyAsString())) {
              resultMap.put("pos", bucket.getDocCount());
          } else {
              resultMap.put("neutral", bucket.getDocCount());
          }
      }

执行获取ES查询结果

//根据发布时间降序排列
SortBuilder sortBuilder = SortBuilders.fieldSort("ctime").order(SortOrder.DESC);
builder = builder.sort(sortBuilder);
//指定页码     
builder.from((infoListQuery.getPageNo()-1)*infoListQuery.getPageSize()).size(infoListQuery.getPageSize());
 try {
     //通过高级客户端执行查询请求,返回响应对象
     SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
     List<InfoDetailVO> infoDetails = new ArrayList<>();
     //拿到响应的匹配结果,遍历
     for (SearchHit hit : searchResponse.getHits().getHits()) {
         //接收对象并转化
         InfoEsHitBO infoEsHitBO = JSONObject.parseObject(hit.getSourceAsString(), InfoEsHitBO.class);
         String ctime = "";
          if (!StringUtils.isEmpty(infoEsHitBO.getCtime())) {
              ctime = DateUtil.formatDateTime(new Date(Long.valueOf(infoEsHitBO.getCtime())));
           }
     }
 }
//获得查询条件下的总的个数
SearchResponse searchResponseTotal = restHighLevelClient.search(searchRequestTotal);
result.setTotal(searchResponseTotal.getHits().getTotalHits());

执行查询结果中的返回字段

builder2.query(wClass).from(0).size(Integer.valueOf(String.valueOf(total))).fetchSource("include", "");

二、删除相关

查询数据后根据_id字段执行删除操作

SearchResponse response = restHighLevelClient.search(searchRequest);
SearchHits hits = response.getHits();
List<String> docIds = new ArrayList<>(hits.getHits().length);
for (SearchHit hit : hits) {
     docIds.add(hit.getId());
}
//BulkRequest bulkRequest = new BulkRequest();
//根据id进行删除
for (String id : docIds) {
	DeleteRequest deleteRequest = new DeleteRequest(tcEsidx, tcEsType, id);
    //bulkRequest.add(deleteRequest);
    restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
}

三、初始化

1. 引入maven依赖

           <dependency>
               <groupId>org.elasticsearch.client</groupId>
               <artifactId>elasticsearch-rest-high-level-client</artifactId>
               <version>6.4.2</version>
               <exclusions>
                   <exclusion>
                       <groupId>org.elasticsearch</groupId>
                       <artifactId>elasticsearch</artifactId>
                   </exclusion>
                   <exclusion>
                       <groupId>org.elasticsearch.client</groupId>
                       <artifactId>elasticsearch-rest-client</artifactId>
                   </exclusion>
               </exclusions>
           </dependency>
           <dependency>
               <groupId>org.elasticsearch</groupId>
               <artifactId>elasticsearch</artifactId>
               <version>6.4.2</version>
           </dependency>
           <!--rest low client-->
           <dependency>
               <groupId>org.elasticsearch.client</groupId>
               <artifactId>elasticsearch-rest-client</artifactId>
               <version>6.4.2</version>
           </dependency>
   

2. ES配置类

   public class ESClientSpringFactory {
       public static int CONNECT_TIMEOUT_MILLIS = 1000;
       public static int SOCKET_TIMEOUT_MILLIS = 30000;
       public static int CONNECTION_REQUEST_TIMEOUT_MILLIS = 500;
       public static int MAX_CONN_PER_ROUTE = 10;
       public static int MAX_CONN_TOTAL = 30;
       private static HttpHost HTTP_HOST;
       private RestClientBuilder builder;
       private RestClient restClient;
       private RestHighLevelClient restHighLevelClient;
       private static ESClientSpringFactory esClientSpringFactory = new ESClientSpringFactory();
       private ESClientSpringFactory(){}
   
       public static ESClientSpringFactory build(HttpHost httpHost, Integer maxConnectNum, Integer maxConnectPerRoute){
           HTTP_HOST = httpHost;
           MAX_CONN_TOTAL = maxConnectNum;
           MAX_CONN_PER_ROUTE = maxConnectPerRoute;
           return  esClientSpringFactory;
       }
   
       public static ESClientSpringFactory build(HttpHost httpHost,Integer connectTimeOut, Integer socketTimeOut, Integer connectionRequestTime,Integer maxConnectNum, Integer maxConnectPerRoute){
           HTTP_HOST = httpHost;
           CONNECT_TIMEOUT_MILLIS = connectTimeOut;
           SOCKET_TIMEOUT_MILLIS = socketTimeOut;
           CONNECTION_REQUEST_TIMEOUT_MILLIS = connectionRequestTime;
           MAX_CONN_TOTAL = maxConnectNum;
           MAX_CONN_PER_ROUTE = maxConnectPerRoute;
           return  esClientSpringFactory;
       }
   
       public void init(){
           builder = RestClient.builder(HTTP_HOST);
           setConnectTimeOutConfig();
           setMutiConnectConfig();
           restClient = builder.build();
           restHighLevelClient = new RestHighLevelClient(builder);
           System.out.println("init factory");
       }
       // 配置连接时间延时
       public void setConnectTimeOutConfig(){
           builder.setRequestConfigCallback(requestConfigBuilder -> {
               requestConfigBuilder.setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
               requestConfigBuilder.setSocketTimeout(SOCKET_TIMEOUT_MILLIS);
               requestConfigBuilder.setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT_MILLIS);
               return requestConfigBuilder;
           });
       }
       // 使用异步httpclient时设置并发连接数
       public void setMutiConnectConfig(){
           builder.setHttpClientConfigCallback(httpClientBuilder -> {
               httpClientBuilder.setMaxConnTotal(MAX_CONN_TOTAL);
               httpClientBuilder.setMaxConnPerRoute(MAX_CONN_PER_ROUTE);
               return httpClientBuilder;
           });
       }
   
       public RestClient getClient(){
           return restClient;
       }
   
       public RestHighLevelClient getRhlClient(){
           return restHighLevelClient;
       }
   
       public void close() {
           if (restClient != null) {
               try {
                   restClient.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           System.out.println("close client");
       }
   }
   

   @ComponentScan(basePackageClasses=ESClientSpringFactory.class)
   @Configuration
   public class XgEsConfig {
       @Value("${jeecg.elasticsearch.ip}")
       private String host;
       @Value("${jeecg.elasticsearch.port}")
       private int port;
       @Value("${jeecg.elasticsearch.connectNum}")
       private Integer connectNum;
       @Value("${jeecg.elasticsearch.connectPerRoute}")
       private Integer connectPerRoute;
       @Bean
       public HttpHost httpHost(){
           return new HttpHost(host, port,"http");
       }
       @Bean(initMethod="init", destroyMethod="close")
       public ESClientSpringFactory getFactory(){
           return ESClientSpringFactory.
                   build(httpHost(), connectNum, connectPerRoute);
       }
       @Bean
       @Scope("singleton")
       public RestClient getRestClient(){
           return getFactory().getClient();
       }
       @Bean(name = "rhlClient")
       @Scope("singleton")
       public RestHighLevelClient getRHLClient(){
           return getFactory().getRhlClient();
       }
       @Bean(name = "pullxg_executor")
       public Executor postExecutor() {
           ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
           executor.setCorePoolSize(1);
           executor.setMaxPoolSize(1);
           executor.setQueueCapacity(1);
           executor.setKeepAliveSeconds(120);
           executor.setThreadNamePrefix("pullxg_executor");
           executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
           return executor;
       }
   }