在SpringBoot中使用Elasticsearch

一、SpringBoot模版方式接入(不建议)

其实一开始是准备用SpringBoot的模版来直接接入使用的，也就是以下这样的接入方式，也是网上大家都这么说的使用方式。

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

但是后面看java api的官方文档

Deprecated in 7.0.0.

The TransportClient is deprecated in favour of the Java High Level REST Client and will be removed in Elasticsearch 8.0. The migration guide describes all the steps needed to migrate.

再看看模版方式引入的源码

SpringBoot模版方式引入

直接模版方式的java api调用方式，后续官方会不支持了，不建议使用，要使用Java High Level REST Client来代替，Elasticsearch 8.0版本后直接移除，想想还是换人家建议的使用方式吧，免得以后更新换代还得做迁移，也就是我们现在准备的使用方式。

二、High Level Java REST Client方式接入

使用High Level Java REST Client进行Elasticsearch检索查询，第一步添加依赖

org.elasticsearch.client:elasticsearch-rest-client
org.elasticsearch:elasticsearch

2.1、添加依赖

在SpringBoot中的具体添加方式是在pom.xml中:

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>6.3.2</version>
        </dependency>

        <!-- Java High Level REST Client -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>6.3.2</version>
        </dependency>

2.2、添加配置地址

添加依赖之后即可进行初始化

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http")));

这个 client的内部会维护一个线程池，所以在任务完成后可以通过 client.close()来释放资源，但是这得看需求，如果需要频繁进行查询的话，就直接做成单例，避免线程池的不断创建和释放也会影响应用的性能，在SpringBoot的做法做成单例的话更简单。
application.yml配置文件中添加集群地址，我这边只有一个，有多个的可以用逗号分割然后自己解析。

elasticsearch:
  ip: localhost:9200

@Configuration
public class ElasticsearchRestClient {

    /**
     * ES地址,ip:port
     */
    @Value("${elasticsearch.ip}")
    String ipPort;

    @Bean
    public RestClientBuilder restClientBuilder() {

        return RestClient.builder(makeHttpHost(ipPort));
    }


    @Bean(name = "highLevelClient")
    public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
        restClientBuilder.setMaxRetryTimeoutMillis(60000);
        return new RestHighLevelClient(restClientBuilder);
    }


    private HttpHost makeHttpHost(String s) {
        String[] address = s.split(":");
        String ip = address[0];
        int port = Integer.parseInt(address[1]);
        
        return new HttpHost(ip, port, "http");
    }
}

我们这边只有一个地址，如果有多个地址，自己做下处理即可。

三、Elasticsearch检索查询

经过上一步骤之后就可以在项目中使用client来进行具体的检索及查询操作了，具体使用之前先清楚几个概念。

3.1 Elasticsearch数据结构

在我们这边的使用场景中，Elasticsearch是用来存储各个端的日志，在这种场景下，每一条日志就是一个Document(文档)，我们知道日志中包含了很多信息，比如上传时间，浏览器，ip等等，每条日志中包含多个字段信息就是Field(字段)，不同的日志可能有不同的类型，比如服务器日志，用户行为日志，这就是Type(类型)，每天的日志分开进行存储是Indice(索引)，可以类比于关系型数据库比如MySQL。

关系型数据库	Elasticsearch
Databases(数据库)	Indices(索引)
Tables(表)	Types(类型)
Rows(行)	Documents(文档)
Columns(列)	Fields(字段)

Elasticsearch包含多个索引(indices)（数据库），每个索引可以包含多个类型(types)（表），每个类型包含多个文档(documents)（行），每个文档包含多个字段(Fields)（列）。

举个栗子，手动添加一条日志，指定indice为customer，type为_doc，document的id为1。

localhost:9200/customer/_doc/1?pretty

{
    "city": "北京",
    "useragent": "Mobile Safari",
    "sys_version": "Linux armv8l",
    "province": "北京",
    "event_id": "",
    "log_time": 1559191912,
    "session": "343730"
}

然后再查询一下刚添加的日志。

GET localhost:9200/customer/_doc/1?pretty

{
    "_index": "customer",
    "_type": "_doc",
    "_id": "1",
    "_version": 3,
    "_seq_no": 2,
    "_primary_term": 1,
    "found": true,
    "_source": {
        "city": "北京",
        "useragent": "Mobile Safari",
        "sys_version": "Linux armv8l",
        "province": "北京",
        "event_id": "",
        "log_time": 1559191912,
        "session": "343730"
    }
}

3.2 Elasticsearch条件查询

第一步需要初始化SearchRequest，设置索引(indices)和类型(types)，以上面添加的日志为例。

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("customer");
        searchRequest.types("_doc");

然后需要组合查询条件，主要涉及到=、!=、>、<这几个条件的查询，需要更复杂的可以查看官方文档。

// 条件=
MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("city", "北京");
TermQueryBuilder termQuery = QueryBuilders.termQuery("province", "福建");

// 范围查询
RangeQueryBuilder timeFilter = QueryBuilders.rangeQuery("log_time").gt(12345).lt(343750);

构建好需要的查询条件后，需要进行组合查询，在组合查询里头实现!=条件查询，需要用到BoolQueryBuilder，BoolQueryBuilder包含4个方法:

must 相当于 &(与)条件。
must not 相当于~(非)条件。
should 相当于 | (或)条件。
filter 类似must，区别在于它不参与计算分值，在不需要用到分值计算的时候效率更高。

QueryBuilder totalFilter = QueryBuilders.boolQuery()
                .filter(matchQuery)
                .filter(timeFilter)
                .mustNot(termQuery);

3.3 Elasticsearch分页查询

可以设置每次查询返回的文档数量，如果不设置的话，默认只返回10条hits，这个数量可以手动设置:

sourceBuilder.query(totalFilter).size(100);

单单设置返回条数还不满足需求，因为我们这边是没有办法事先确定的，所以需要自己来实现分页，需要from()方法进行辅助。

完整示例代码如下:

@Service
    public class TestService {
        @Autowired
        RestHighLevelClient highLevelClient;

        private void search(RestHighLevelClient highLevelClient) throws IOException {

            SearchRequest searchRequest = new SearchRequest();
            searchRequest.indices("customer");
            searchRequest.types("_doc");

            // 条件=
            MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("city", "北京");
            TermQueryBuilder termQuery = QueryBuilders.termQuery("province", "福建");
            // 范围查询
            RangeQueryBuilder timeFilter = QueryBuilders.rangeQuery("log_time").gt(12345).lt(343750);
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

            QueryBuilder totalFilter = QueryBuilders.boolQuery()
                    .filter(matchQuery)
                    .filter(timeFilter)
                    .mustNot(termQuery);

            int size = 200;
            int from = 0;
            long total = 0;

            do {
                try {
                    sourceBuilder.query(totalFilter).from(from).size(size);
                    sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
                    searchRequest.source(sourceBuilder);

                    SearchResponse response = highLevelClient.search(searchRequest);
                    SearchHit[] hits = response.getHits().getHits();
                    for (SearchHit hit : hits) {
                        System.out.println(hit.getSourceAsString());
                    }

                    total = response.getHits().totalHits;

                    System.out.println("测试:[" + total + "][" + from + "-" + (from + hits.length) + ")");

                    from += hits.length;

                    // from + size must be less than or equal to: [10000]
                    if (from >= 10000) {
                      System.out.println("测试:超过10000条直接中断");
                      break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } while (from < total);
        }
    }

3.4 分页查询异常

在分页的过程中出现了一个问题是当查询的数据超过10000条的时候报了异常：

from + size must be less than or equal to: [10000]

这个问题最快捷的解决方式是增大窗口大小:

curl -XPUT http://127.0.0.1:9200/customer/_settings -d '{ "index" : { "max_result_window" : 500000}}'

但是对应增大窗口大小，会牺牲更多的服务器的内存、CPU资源，在我们这边的使用场景下，这样做是划不来的，因为我们的目的是做目标数据的搜索，而不是大规模的遍历，所以我们这边会直接放弃超过这个数量的查询，也就是上面的这段代码:

 // from + size must be less than or equal to: [10000]
  if (from > 10000) {
     System.out.println("测试:超过10000条直接中断");
     break;
  }

对于Elasticsearch其实也是很多地方还不熟悉，感兴趣的童鞋可以多多一起交流和指正，不然的话后续也只能在使用过程中来加深理解。

参考：
1、Elasticsearch: 权威指南
2、Elasticsearch: Java API [7.1]
3、Elasticsearch: Java REST Client [7.1]
4、Elasticsearch查询——布尔查询Bool Query
5、解决ElasticSearch深度分页机制中Result window is too large问题