ElasticSearch java封装

关于平时操作的一些常用操作封装，后续会持续更新。

/**
 * 查询语句执行
 * @param client 
 * @param query 查询条件
 * @param aggre 聚合条件
 * @param indexName 索引名称
 * @param type 索引类型
 * @param page 
 * @param size
 * @param sort 排序字段
 * @param order 排序方式
 * @param includes 要返回的字段
 * @param excludes 不反悔的字段
 * @return
 * @throws Exception
 */
public static SearchResponse searchAndAggres(TransportClient client,QueryBuilder query,List<AggregationBuilder> aggre,String indexName,String type,int page,int size,String sort,String order,String[] includes,String[] excludes) throws Exception{
   // 创建查询索引
   SearchRequestBuilder searchRequestBuilder = client
   .prepareSearch(indexName);
   // 设置查询索引类型
   searchRequestBuilder.setTypes(type);

   // 设置查询条件
   searchRequestBuilder.setQuery(query);

   // 分頁
   if ((page > 0) && (size > 0)) {
      // 设置查询数据的位置,分页用吧
      searchRequestBuilder.setFrom(size * (page - 1));
      // 设置查询结果集的最大条数
      searchRequestBuilder.setSize(size);
   }else {
      // 设置查询数据的位置,分页用吧
      searchRequestBuilder.setFrom(0);
      // 设置查询结果集的最大条数
      searchRequestBuilder.setSize(10);
   }

   // 字段排序
   SortOrder sortOrder = SortOrder.ASC;// 排序方式 默认升序
   // 排序方式
   if ("desc".equals(order)) {
      sortOrder = SortOrder.DESC;// 排序方式 註明降序
   }

   // 排序字段
   if (StringUtils.isNotBlank(sort)) {
      searchRequestBuilder.addSort(sort, sortOrder);// 升序
   }

   // 设置是否按查询匹配度排序
   searchRequestBuilder.setExplain(false);
   
   //设置聚合条件
   if(aggre!=null && aggre.size()>0) {
      for (AggregationBuilder aggregationBuilder : aggre) {
         searchRequestBuilder.addAggregation(aggregationBuilder);
      }
   }
   if(includes!=null || excludes!=null) {
      searchRequestBuilder.setFetchSource(includes, excludes);
   }
   try {
      // 最后就是返回搜索响应信息
      System.out.println(searchRequestBuilder.toString());//打印DSL
      SearchResponse response = searchRequestBuilder.execute().actionGet();
      return response;
   } catch (Exception e) {
      e.printStackTrace();
      throw e;
   }
}

/**
 * 查询结果处理
 * @param data 返回结果集
 * @param hits 待处理结果集
 * @return
 */
public static JSONObject hitsResult(JSONObject data,SearchHits hits) throws Exception {
   try {
      List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
      for(SearchHit hit:hits){
         Map<String, Object> map = hit.getSourceAsMap();
         list.add(map);
      }
      data.put("list", list);
      data.put("total", hits.getTotalHits());
   } catch (Exception e) {
      e.printStackTrace();
      throw e;
   }
   return data;
}

/**
 * 一级聚合结果处理
 * @param aggres 待处理聚合结果集
 * @param nextArea 聚合字段
 * @return
 */
public static JSONArray aggresResult(Aggregations aggres, String nextArea) throws Exception {
   try {
      Terms terms = aggres.get(nextArea);
      JSONArray buckets = new JSONArray();
      for(Terms.Bucket tm:terms.getBuckets()){
         JSONObject bucket = new JSONObject();
         String key = tm.getKeyAsString();
         long value = tm.getDocCount();
         bucket.put("key", key);
         bucket.put("value", value);
         buckets.add(bucket);
      }
      return buckets;
   } catch (Exception e) {
      e.printStackTrace();
      throw e;
   }
}

创建查询：

//创建查询
BoolQueryBuilder query = QueryBuilders.boolQuery();
query.must(QueryBuilders.termQuery(field, areaCode));
query.must(QueryBuilders.termQuery(field, value));//多条件

创建聚合：

//聚合
AggregationBuilder aggre = AggregationBuilders.terms(nextArea).field(nextArea).size(200);

//判断某个索引是否存在
    public static boolean indexExists(Client client,String index){
        IndicesExistsRequest request = new IndicesExistsRequest(index);
        IndicesExistsResponse response = client.admin().indices().exists(request).actionGet();
        if (response.isExists()) {
            return true;
        }
        return false;
    }

    /**
     * 获取es索引的字段及类型
     * @param client es客户端
     * @param index 索引名称
     * @param type 索引类型
     * @return
     */
    public static JSONObject getEsColumns(TransportClient client,String index,String type) {
        ImmutableOpenMap<String, MappingMetaData> mappings = client.admin().cluster().prepareState().execute()
                .actionGet().getState().getMetaData().getIndices().get(index).getMappings();
//        Map<String, Object> mapping = mappings.get("area_map").getSourceAsMap();
        String mapping = mappings.get(type).source().toString();
        JSONObject map = JSON.parseObject(mapping);
        System.out.println(mapping);
        JSONObject esColumMap = map.getJSONObject(type).getJSONObject("properties");
        JSONObject esColumns = new JSONObject();//存放es的字段及类型键值对
        Set<String> keySet = esColumMap.keySet();
        for (String key : keySet) {
            esColumns.put(key, esColumMap.getJSONObject(key).getString("type"));
        }
        return esColumns;
    }

/**
     * 取得实例
     * @return
     */
    public static synchronized TransportClient getTransportClient(String clusterName,String ip,int port) {
        TransportClient client = null ;
        try {
            Settings settings = Settings.builder().put("cluster.name", clusterName)
        /*            .put("client.transport.sniff", true)*/
                    .put("client.transport.ping_timeout", "30s").build();
            client = new PreBuiltTransportClient(settings);
            client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), port));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return client;
    }
 
    /**
     * 关闭连接
     * @param client   es客户端
     */
    public static void close(TransportClient client) {
        client.close();
    }

 

未完待续。。。。。。