java操作elasticsearch实现分页、去重查询、统计去重后的实际数量

公司要重构一个项目，有部分数据是用阿里的云elasticsearch作为数据存储，大概两千万，这边Java主要是做查询，由于阿里云文档不全，记录下一些比较困难的操作~由于项目紧急，以下仅为个人理解，勿喷。

1.Java连接elasticsearch

引入elasticsearch依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

创建elasticsearch连接

        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials("es客户端用户名", "es客户端密码"));

        restClient = RestClient.builder(new HttpHost("es地址", 9200, "http"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                }).build();

设置请求方式，查询就用get或者post

        String method = "POST";

设置要查询的库、表的名称

        String endpoint = "/date/date/_search";

至此，基础设置已经完成。

2.多个字段的模糊查询

这里就类似于MySQL中的 select * from user where name like '%张三%' and tel like '%155%';

{
    "query":{
        "bool":{
            "must":[
                {
                    "match_phrase":{
                        "name":"张三"
                    }
                },
                {
                    "match_phrase":{
                        "tel":"188"
                    }
                }
            ],
            "minimum_should_match":1
        }
    }
    }

must: must的两个条件都必须满足,类似于mysql中的and，如果想用or的话，可以替换成should

match_phrase：不分词，不分词，不分词，也就是说符合条件的字段内容中必须包含你要搜索的信息，等同于模糊查询。

3.去重查询

{
    "query":{
        "collapse":{
            "field":"tel"
        },
        "bool":{
            "must":[
                {
                    "match_phrase":{
                        "name":"小明"
                    }
                },
                {
                    "match_phrase":{
                        "tel":"188"
                    }
                }
            ],
            "minimum_should_match":1
        }
    }
}

field:tel 以tel为条件把重复的数据进行折叠，来达到去重的效果，可是到这里还有问题，查询出来的条数还是折叠之前的条数，下面我们要统计一下，折叠之后的条数。

{
    "query":{
        "collapse":{
            "field":"tel"
        },
        "bool":{
            "must":[
                {
                    "match_phrase":{
                        "name":"天津"
                    }
                },
                {
                    "match_phrase":{
                        "tel":"188"
                    }
                }
            ],
            "minimum_should_match":1
        }
    },
    "aggs":{
        "count":{
            "cardinality":{
                "field":"tel"
            }
        }
    },
    "size":10,
    "from":0
}

使用aggs count 来统计折叠之后的条数，解析JSON时就可以获取到了

解析时使用fastjson进行解析~

4.发送请求（查询）

        Response response = restClient.performRequest(method, endpoint, Collections.<String, String>emptyMap(), entity);

我使用的springboot内置的restclient发送的http请求

5.接收请求并进行解析

//响应的数据        
String str = EntityUtils.toString(response.getEntity());
//获得总条数
Object countObject = JSON.parseObject(str).get("aggregations");
Object total = JSON.parseObject(countObject.toString()).get("count");
        total = JSON.parseObject(total.toString()).get("value");

//获得响应的数据
Object json_test = JSON.parseObject(str).get("hits");

Object o = JSON.parseObject(json_test.toString()).get("hits");

List<restEntity> list = JSON.parseArray(o.toString(), restEntity.class);