ES在java中采用原生json查询

记录代码：

jar包

    api("io.searchbox:jest:6.3.1")

查询代码

package com.cmft.ff.base.elasticsearch;

import com.cmft.ff.base.dao.BaseInfoDao;
import com.cmft.ff.base.entity.EsInfoDO;
import com.cmft.ff.param.enums.ServerType;
import com.cmpay.lemon.common.utils.StringUtils;
import io.searchbox.client.JestClient;
import io.searchbox.client.JestClientFactory;
import io.searchbox.client.config.HttpClientConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author xiaoxin
 */
@Slf4j
@Component
public class EsJestClient {
    @Autowired
    private BaseInfoDao baseInfoDao;

    private Map<String, JestClient> jestClientMap = new ConcurrentHashMap<>(4);

    public JestClient getEsClient(String zoneId) {
        return jestClientMap.get(zoneId);
    }

    private static final String SCHEMA = "http://";

    @PostConstruct
    public void init() {
        try {
            EsInfoDO serverInfoDO = new EsInfoDO();
            serverInfoDO.setDelFlag(false);
            serverInfoDO.setType(ServerType.ELASTICSEARCH);
            //获取请求路径
            List<EsInfoDO> lists = baseInfoDao.find(serverInfoDO);
            Optional.ofNullable(lists).get().forEach(e ->
                    jestClientMap.put(e.getZoneId(),
                            applyProperties(StringUtils.split(e.getServerIp(), ";"))));
        } catch (Exception e) {
            log.error("EsJestClient init Exception{}", e);
        }
    }

    @PreDestroy
    public void destroy() {
        jestClientMap.forEach((k, v) -> {
            try {
                v.close();
            } catch (IOException e) {
                log.error("destroyEsJestClient,{}", e);
            }
        });
    }

    private JestClient applyProperties(String[] nodes) {
        List<String> httpHosts = new ArrayList<>();
        JestClientFactory jestClientFactory = new JestClientFactory();
        try {
            Assert.state(nodes.length > 0, "Must be defined as 'nodes'");
            Arrays.stream(nodes).forEach(e -> {
                httpHosts.add(SCHEMA + e);
            });
            HttpClientConfig httpClientConfig = new HttpClientConfig
                    .Builder(httpHosts)
                    .build();
            jestClientFactory.setHttpClientConfig(httpClientConfig);
        } catch (RuntimeException ex) {
            throw new IllegalStateException("Invalid ES nodes " + "property '" + nodes + "'", ex);
        }
        return jestClientFactory.getObject();
    }
}

package com.cmft.ff.base.elasticsearch;

import io.searchbox.core.Search;
import io.searchbox.core.SearchResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author xiaoxin
 */
@Component
@Slf4j
public class EsJestSearch {
    @Autowired
    private EsJestClient esJestClient;

    public SearchResult search(String queryStr, List<String> index, String type, String zoneId) {
        SearchResult response = null;
        try {
            Search.Builder searchBuilder = new Search.Builder(queryStr)
                    .addIndices(index)
                    .addType(type);
            response = esJestClient.getEsClient(zoneId).execute(searchBuilder.build());
        } catch (Exception e) {
            log.error("ES聚合查询 Exception{}", e);
        }
        return response;
    }
}

解析代码

package com.cmft.ff.base.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.cmft.ff.base.bo.EsResponseBO;
import com.cmpay.lemon.common.utils.JudgeUtils;
import io.searchbox.core.SearchResult;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * @author xiaoxin
 */
@Slf4j
public class EsResponseUtils {
    private static final String BUCKET = "buckets";
    private static final String KEY = "key";
    private static final String VALUE = "value";
    private static final Integer SUCCESS = 200;

    public static EsResponseBO resolver(SearchResult response) {
        EsResponseBO esResponseBO = new EsResponseBO();
        Map<String, String> newMap = new HashMap<>();
        try {
            if (response.getResponseCode() != SUCCESS) {
                esResponseBO.setError(response.getErrorMessage());
                return esResponseBO;
            }
            if (JudgeUtils.isNull(response) || JudgeUtils.isNull(response.getAggregations())) {
                esResponseBO.setError("该聚合查询返回数据为空");
                return esResponseBO;
            }
            JSONObject jsonObject = JSONObject.parseObject(response.getJsonString()).getJSONObject("aggregations");
            Map<String, String> map = new HashMap<>();
            if (JudgeUtils.isNull(jsonObject)) {
                esResponseBO.setError("该聚合查询返回数据为空");
                return esResponseBO;
            }
            //遍历JSONObject中的所有entry
            for (Map.Entry<String, Object> entrie : jsonObject.entrySet()) {
                JSONArray jsonArray = JSONObject.parseObject(String.valueOf(entrie.getValue())).getJSONArray(BUCKET);
                if (JudgeUtils.isNotNull(jsonArray)) {
                    map = digui(jsonArray);
                }
                String keyWord = entrie.getKey();
                Iterator it = map.keySet().iterator();
                while (it.hasNext()) {
                    Object keyMap = it.next();
                    newMap.put(keyWord + ":" + keyMap, map.get(keyMap));
                }
            }
            esResponseBO.setMap(newMap);
            esResponseBO.setTime(response.getJsonObject().get("took").getAsInt());
            return esResponseBO;
        } catch (Exception e) {
            log.error("EsResponseUtils resolver Exception{}", e);
            esResponseBO.setError("该聚合查询异常::" + e.getMessage());
            return esResponseBO;
        }
    }

    private static Map<String, String> digui(JSONArray jsonArray) {
        Map<String, String> newMap = new HashMap();
        if (JudgeUtils.isEmpty(jsonArray)) {
            return newMap;
        }
        String keyWord = "";
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = JSONObject.parseObject(jsonArray.getString(i));
            if (JudgeUtils.isNotNull(jsonObject.get(KEY))) {
                keyWord = jsonObject.getString(KEY);
            }
            Iterator it = jsonObject.keySet().iterator();
            while (it.hasNext()) {
                Object key = it.next();
                Object object = jsonObject.get(key);
                JSONArray jsonArray1;
                if (object == null || !(object instanceof JSONObject)) {
                    continue;
                } else {
                    jsonArray1 = JSON.parseObject(object.toString()).getJSONArray(BUCKET);
                }
                if (object instanceof JSONObject && JudgeUtils.isNotEmpty(jsonArray1)) {
                    Map<String, String> map1 = digui(jsonArray1);
                    Iterator it1 = map1.keySet().iterator();
                    while (it1.hasNext()) {
                        Object key1 = it1.next();
                        newMap.put(keyWord + ":" + key + ":" + key1, map1.get(key1));
                    }
                } else {
                    //获取最底层数据
                    if (JudgeUtils.isNotNull(keyWord) && !newMap.containsKey(keyWord)) {
                        newMap.put(keyWord + ":" + key, JSON.parseObject(object.toString()).getString(VALUE));
                    }
                }
            }
        }
        return newMap;
    }
}