es 判断空字符串字段 ，null 值

package com.xx.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.gtcom.config.RestClientConfig;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.*;

/**
 * @author tongyinlong
 * @version 1.0
 * @description: TODO
 * @date 2021/11/4 16:47
 */
@Slf4j
@Component
public class EsUtils {


    @Autowired
    @Qualifier(RestClientConfig.ES_CLIENT_1)
    private RestHighLevelClient esClient1;

    @Autowired
    @Qualifier(RestClientConfig.ES_CLIENT_2)
    private RestHighLevelClient esClient2;


    /**
     * ES 批量修改数据（同步）
     *
     * @param indexName:      索引名称
     * @param primaryKeyName: 主键名称
     * @param paramListJson:  数据集合JSON
     * @return 批量修改结果
     * @date 2021/11/4 16:40
     * @author tongyinlong
     **/
    public boolean updateDataBatch(String indexName, String primaryKeyName, String paramListJson) {

        BulkRequest bulkRequest = packBulkUpdateRequest(indexName, primaryKeyName, paramListJson);
        if (bulkRequest.requests().isEmpty()) {
            return false;
        }
        bulkRequest.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
        try {
            // 同步执行
            BulkResponse bulk = esClient1.bulk(bulkRequest, RequestOptions.DEFAULT);
            if (bulk.hasFailures()) {
                for (BulkItemResponse item : bulk.getItems()) {
                    log.error("索引[{}],主键[{}]修改操作失败,状态为:[{}],错误信息:{}", indexName, item.getId(),
                            item.status(), item.getFailureMessage());
                }
                return false;
            }

            // 记录索引新增与修改数量
            Integer createdCount = 0;
            Integer updatedCount = 0;
            for (BulkItemResponse item : bulk.getItems()) {
                if (IndexResponse.Result.CREATED.equals(item.getResponse().getResult())) {
                    createdCount++;
                } else if (IndexResponse.Result.UPDATED.equals(item.getResponse().getResult())) {
                    updatedCount++;
                }
            }
            log.info("索引[{}]批量修改更新成功,共新增[{}]个,修改[{}]个", indexName, createdCount, updatedCount);
        } catch (IOException e) {
            log.error("索引[{}]批量修改更新出现异常", indexName);
            return false;
        }
        return true;
    }

    /**
     * 获取批量操作的Request
     *
     * @param indexName:      索引名称
     * @param primaryKeyName: 主键名称
     * @param paramListJson:  数据集合JSON
     * @return BulkRequest对象
     * @date 2021/11/4 15:40
     * @author tongyinlong
     **/
    private BulkRequest packBulkUpdateRequest(String indexName, String primaryKeyName, String paramListJson) {
        BulkRequest bulkRequest = new BulkRequest();
        JSONArray jsonArray = JSONArray.parseArray(paramListJson);
        if (jsonArray == null && jsonArray.size() == 0) {
            return bulkRequest;
        }

        jsonArray.forEach(obj -> {
            Map<String, Object> map = (Map<String, Object>) obj;
            UpdateRequest updateRequest = new UpdateRequest(indexName, String.valueOf(map.get(primaryKeyName)));
            // 如果修改索引中不存在则进行新增
            updateRequest.docAsUpsert(true);
            updateRequest.doc(JSON.toJSONString(obj), XContentType.JSON);
            bulkRequest.add(updateRequest);
        });
        return bulkRequest;
    }

    /**
     * 获取批量操作的Request
     *
     * @param indexName: 索引名称
     * @param flied:  过滤值
     * @param fliedValue:  过滤字段
     * @return BulkRequest对象
     * @date 2021/11/4 17:28
     * @author tongyinlong
     **/
    public List queryFilter(String indexName,String flied,String fliedValue) {
        List resList= new ArrayList<>();
        // 获取页码、页面大小
        int pageStart = 0;
        int pageSize = 10000;
        // 封装boolBuilder
        QueryBuilder boolBuilder = queryBuilder(flied,fliedValue);
        // 封装SearchSourceBuilder
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                // 设置查询关键词
                .query(boolBuilder)
                // 设置查询数据的位置,分页用
                .from(pageStart)
                // 设置查询结果集的最大条数
                .size(pageSize)
                // 不展示分析逻辑
                .explain(false);
        //指定查询包含的字段，指定查询不包含的字段
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchSourceBuilder.storedFields(new ArrayList<String>() {{
            add("dataId");
            
        }});
        searchRequest.source(searchSourceBuilder);
        searchRequest.searchType(SearchType.DFS_QUERY_THEN_FETCH);
        SearchResponse response = null;
        try {
            response = esClient1.search(searchRequest, RequestOptions.DEFAULT);
            SearchHits searchHits = response.getHits();
            log.debug("共匹配到:" + searchHits.getTotalHits().value + "条记录!");
            SearchHit[] hits = searchHits.getHits();
            for (SearchHit searchHit : hits) {
                Map map= new HashMap<>(5);
                String result=searchHit.getSourceAsString();
                map.put(searchHit.getIndex(),result);
                resList.add(map);
            }
        } catch (IOException e) {
            System.out.println("==============");
        }
        return resList;
    }

    private BoolQueryBuilder queryBuilder(String flied,String fliedValue) {
        BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
        // filter精准查询
        QueryBuilder termQueryBuilder = QueryBuilders.termQuery(flied, fliedValue);
        BoolQueryBuilder filterQueryBuilder = QueryBuilders.boolQuery().filter(termQueryBuilder);
        boolBuilder.must(filterQueryBuilder);
        return boolBuilder;
    }

    /***
     * 聚合字典 字段
     * @return
     */
    public List aggData(String aggFiled) throws IOException {
        SearchSourceBuilder query = new SearchSourceBuilder();
        // 根据会议id进行分组
        TermsAggregationBuilder topBuilder=AggregationBuilders.terms("title").field(aggFiled);
        // 返回分组数
        topBuilder.size(10000);
        // 分组排序规则
        // 聚合查询
        query.aggregation(topBuilder);

        SearchRequest request = Requests.searchRequest("news_*").
                searchType(SearchType.QUERY_THEN_FETCH )
                .source(query);
        SearchResponse response = esClient1.search(request, RequestOptions.DEFAULT);
        // 需要返回的list
        List<Map<String, Object>> list = new ArrayList<>();
        // 获取查询结果的aggregation部分
        Aggregations aggregations = response.getAggregations();
        List dictList= new ArrayList<>();
        if (RestStatus.OK.equals(response.status())) {
            // 分桶
            Terms byCompanyAggregation = aggregations.get("title");
            List<? extends Terms.Bucket> buckets = byCompanyAggregation.getBuckets();
            log.info("聚合总量{}", buckets.size());
            for (Terms.Bucket bucket : buckets) {
                dictList.add(bucket.getKeyAsString());
            }
        }
        return dictList;
    }


    public List queryMustNot(String indexName,String flied,List fliedValue){
        List<Map<String,String>> resList= new ArrayList<>();
        // 获取页码、页面大小
        int pageStart = 0;
        int pageSize = 10000;
        // 封装boolBuilder
        QueryBuilder boolBuilder = queryMustNotBuilder(flied,fliedValue);
        // 封装SearchSourceBuilder
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                // 设置查询关键词
                .query(boolBuilder)
                // 设置查询数据的位置,分页用
                .from(pageStart)
                // 设置查询结果集的最大条数
                .size(pageSize)
                // 不展示分析逻辑
                .explain(false);
        //指定查询包含的字段，指定查询不包含的字段
        searchSourceBuilder.storedFields(new ArrayList<String>() {{
            add("dataId");
           
        }});
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(searchSourceBuilder);
        searchRequest.searchType(SearchType.DFS_QUERY_THEN_FETCH);
        SearchResponse response = null;
        try {
            response = esClient1.search(searchRequest, RequestOptions.DEFAULT);
            SearchHits searchHits = response.getHits();
            log.info("共匹配到:" + searchHits.getTotalHits().value + "条记录!");
            SearchHit[] hits = searchHits.getHits();
            for (SearchHit searchHit : hits) {
                Map map= new HashMap<>(5);
                String result=searchHit.getSourceAsString();
                map.put(searchHit.getIndex(),result);
                resList.add(map);
            }
        } catch (IOException e) {
            log.error("es 查询错误{}",e);
        }
        return  resList;
    }


    private BoolQueryBuilder queryMustNotBuilder(String flied,List<String> fliedValueS) {
        BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
        BoolQueryBuilder exersiceBoolQuery = QueryBuilders.boolQuery();
        for (String fliedValue: fliedValueS){
           exersiceBoolQuery.mustNot(QueryBuilders.termQuery(flied, fliedValue));
        }
        return exersiceBoolQuery;
    }

   public List fliteNullValue(String indexName, String flied){
       List resList= new ArrayList<>();
       // 获取页码、页面大小
       int pageStart = 0;
       int pageSize = 10000;
       // 封装boolBuilder
       QueryBuilder boolBuilder = queryBuilderIsNull(flied);
       // 封装SearchSourceBuilder
       SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
       searchSourceBuilder
               // 设置查询关键词
               .query(boolBuilder)
               // 设置查询数据的位置,分页用
               .from(pageStart)
               // 设置查询结果集的最大条数
               .size(pageSize)
               // 不展示分析逻辑
               .explain(false);
       //指定查询包含的字段，指定查询不包含的字段
       SearchRequest searchRequest = new SearchRequest(indexName);
       searchSourceBuilder.storedFields(new ArrayList<String>() {{
           add("dataId");
           
       }});
       searchRequest.source(searchSourceBuilder);
       searchRequest.searchType(SearchType.DFS_QUERY_THEN_FETCH);
       SearchResponse response = null;
       try {
           response = esClient1.search(searchRequest, RequestOptions.DEFAULT);
           SearchHits searchHits = response.getHits();
           log.info("共匹配到:" + searchHits.getTotalHits().value + "条记录!");
           SearchHit[] hits = searchHits.getHits();
           for (SearchHit searchHit : hits) {
               Map map= new HashMap<>(5);
               String result=searchHit.getSourceAsString();
               map.put(searchHit.getIndex(),result);
               resList.add(map);
           }
       } catch (IOException e) {
           System.out.println("==============");
       }
       return resList;
   }

    private BoolQueryBuilder queryBuilderIsNull(String flied) {
        BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
        // filter精准查询
        QueryBuilder termQueryBuilder = QueryBuilders.existsQuery(flied);
        BoolQueryBuilder filterQueryBuilder = QueryBuilders.boolQuery().filter(termQueryBuilder);
        boolBuilder.mustNot(filterQueryBuilder);
        return boolBuilder;
    }








}