ES在java中采用原生json查询

记录代码:

jar包

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

查询代码

 1 package com.cmft.ff.base.elasticsearch;
 2 
 3 import com.cmft.ff.base.dao.BaseInfoDao;
 4 import com.cmft.ff.base.entity.EsInfoDO;
 5 import com.cmft.ff.param.enums.ServerType;
 6 import com.cmpay.lemon.common.utils.StringUtils;
 7 import io.searchbox.client.JestClient;
 8 import io.searchbox.client.JestClientFactory;
 9 import io.searchbox.client.config.HttpClientConfig;
10 import lombok.extern.slf4j.Slf4j;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.stereotype.Component;
13 import org.springframework.util.Assert;
14 
15 import javax.annotation.PostConstruct;
16 import javax.annotation.PreDestroy;
17 import java.io.IOException;
18 import java.util.*;
19 import java.util.concurrent.ConcurrentHashMap;
20 
21 /**
22  * @author xiaoxin
23  */
24 @Slf4j
25 @Component
26 public class EsJestClient {
27     @Autowired
28     private BaseInfoDao baseInfoDao;
29 
30     private Map<String, JestClient> jestClientMap = new ConcurrentHashMap<>(4);
31 
32     public JestClient getEsClient(String zoneId) {
33         return jestClientMap.get(zoneId);
34     }
35 
36     private static final String SCHEMA = "http://";
37 
38     @PostConstruct
39     public void init() {
40         try {
41             EsInfoDO serverInfoDO = new EsInfoDO();
42             serverInfoDO.setDelFlag(false);
43             serverInfoDO.setType(ServerType.ELASTICSEARCH);
44             //获取请求路径
45             List<EsInfoDO> lists = baseInfoDao.find(serverInfoDO);
46             Optional.ofNullable(lists).get().forEach(e ->
47                     jestClientMap.put(e.getZoneId(),
48                             applyProperties(StringUtils.split(e.getServerIp(), ";"))));
49         } catch (Exception e) {
50             log.error("EsJestClient init Exception{}", e);
51         }
52     }
53 
54     @PreDestroy
55     public void destroy() {
56         jestClientMap.forEach((k, v) -> {
57             try {
58                 v.close();
59             } catch (IOException e) {
60                 log.error("destroyEsJestClient,{}", e);
61             }
62         });
63     }
64 
65     private JestClient applyProperties(String[] nodes) {
66         List<String> httpHosts = new ArrayList<>();
67         JestClientFactory jestClientFactory = new JestClientFactory();
68         try {
69             Assert.state(nodes.length > 0, "Must be defined as 'nodes'");
70             Arrays.stream(nodes).forEach(e -> {
71                 httpHosts.add(SCHEMA + e);
72             });
73             HttpClientConfig httpClientConfig = new HttpClientConfig
74                     .Builder(httpHosts)
75                     .build();
76             jestClientFactory.setHttpClientConfig(httpClientConfig);
77         } catch (RuntimeException ex) {
78             throw new IllegalStateException("Invalid ES nodes " + "property '" + nodes + "'", ex);
79         }
80         return jestClientFactory.getObject();
81     }
82 }
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;
    }
}

 

posted @ 2020-12-09 09:59  小鑫学JAVA  阅读(1175)  评论(0)    收藏  举报