SpringBoot整合ES


  • 一：整合方式介绍及选用：
  • 1、Java API：
  • 2、REST Clinet
  • 3、spring-data-elasticsearch
  • 二：ES之RestHighLevelClient 客户端连接基本配置
  • 1、pom.xml依赖
  • 2、配置文件application.properties
  • 3、配置类ElasticSearchConfig：获取客户端client
  • 4、启动类
  • 4、service层代码
  • 4.1、索引相关
  • 4.2、查询相关
  • 5、controller层
  • 6、结果展示和说明
  • 参考文章


前面还有：
springboot集成Elk做日志系统（一) 环境搭建
springboot集成Elk做日志系统（二）-切面/分词器快速定位日志
springboot集成Elk做日志系统（四）整合freemarker做日志系统前端页面

本文所用es版本为7.10.2

一：整合方式介绍及选用：

主要有三种方式（API、REST Client、Data-ES）

其中：

1、Java API：

官方已经明确表示在ES 7.0版本中将弃用TransportClient客户端，且在8.0版本中完全移除它 ；

只要你使用的es的版本超过6，就建议不要采用这种方式，否则会有各种错误；

2、REST Clinet

官方也给出了基于HTTP的客户端REST Client(推荐使用)，

官方给出来的REST Client有Java Low Level REST Client 和 Java Hight Level REST Client 两个，前者兼容所有版本的ES，后者是基于前者开发出来的，只暴露了部分API，待完善。此处使用Java Hight Level REST Client。

基于HTTP端口去通信的，便于操作，而且跟ES版本几乎没有关系

3、spring-data-elasticsearch

Spring也提供了本身基于SpringData实现的一套方案spring-data-elasticsearch

版本之间的搭配建议为：

spring data elasticsearch

elasticsearch

3.1.x

6.2.2

3.0.x

5.5.0

2.1.x

2.4.0

2.0.x

2.2.0

1.3.x

1.5.2

由于我之前采用的es的版本是7.10.2，版本过高，spring-data-elasticsearch可能不一定支持。之前尝试总是报错还未解决，所以暂不采用

二：ES之RestHighLevelClient 客户端连接基本配置

先看一下我们maven项目的目录结构

es接入rabbitmq日志 springboot集成es日志_java

1、pom.xml依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zjqf</groupId>
    <artifactId>logSystem0401_01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--SpringBoot的基本父级依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
    </parent>
    <dependencies>
        <!--必须要单独添加es的依赖，跟client版本一致，否则spring默认的es版本极低启动会报错-->
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.10.2</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--springboot对web项目的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.7</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8</version>
        </dependency>

        <!--引入json进行HTTP序列化-->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20160810</version>
        </dependency>

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.10.2</version>
        </dependency>
        <!--ElasticSearch组件RestHighLevelClient-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.10.2</version>
        </dependency>
        <!--httpclient一定要配置上这两个依赖，否则httpclient及httpcore版本过低不匹配导致项目启动失败-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.12</version>
        </dependency>



    </dependencies>




    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.1.0</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals><goal>shade</goal></goals>
                        <configuration>
                            <relocations>
                                <relocation>
                                    <pattern>org.apache.http</pattern>
                                    <shadedPattern>hidden.org.apache.http</shadedPattern>
                                </relocation>
                                <relocation>
                                    <pattern>org.apache.logging</pattern>
                                    <shadedPattern>hidden.org.apache.logging</shadedPattern>
                                </relocation>
                                <relocation>
                                    <pattern>org.apache.commons.codec</pattern>
                                    <shadedPattern>hidden.org.apache.commons.codec</shadedPattern>
                                </relocation>
                                <relocation>
                                    <pattern>org.apache.commons.logging</pattern>
                                    <shadedPattern>hidden.org.apache.commons.logging</shadedPattern>
                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>



</project>

2、配置文件application.properties

spring.application.name=eslog
spring.data.elasticsearch.cluster-name=my-esCluster
spring.data.elasticsearch.cluster-nodes=127.0.0.1:9200,127.0.0.1:9201,127.0.0.1:9202
spring.data.x-pack.authorization=elastic:changeme
spring.data.elasticsearch.repositories.enabled=true
spring.data.elasticsearch.properties.path.home=target/elastic
spring.data.elasticsearch.properties.transport.tcp.connect_timeout=120s

3、配置类ElasticSearchConfig：获取客户端client

package com.zjqf.highClientTest;

import java.io.IOException;

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(value = "spring.data.elasticsearch")
public class ElasticSearchConfig{
	/**
	 * 注入环境变量
	 */
    //@Resource
    //private Environment environment;
	@Value("${spring.data.elasticsearch.cluster-name}")
	private String clusterName;
	@Value("${spring.data.elasticsearch.cluster-nodes}")
	private String clusterNodes;
	@Value("${spring.data.x-pack.authorization}")
	private String xPackAuthorization;
	
	
    

	@Bean
	public RestClient restClient() throws IOException {
		String[] nodes = clusterNodes.split(",");
		HttpHost[] hosts = new HttpHost[nodes.length];
		for(int i=0,j=nodes.length;i<j;i++){
			String host = nodes[i].split(":")[0];
			Integer port = 9200;
			hosts[i] = new HttpHost(host,port);
		}
		final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
		credentialsProvider.setCredentials(AuthScope.ANY,
		        new UsernamePasswordCredentials(xPackAuthorization.split(":")[0], xPackAuthorization.split(":")[1]));
		RestClient restClient = RestClient.builder(hosts)
		        .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
		            @Override
		            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
		                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
		            }
		        })
		        .build();
		return restClient;
	}
	@Bean
	public RestHighLevelClient restHighLevelClient()
	{
		String[] nodes = clusterNodes.split(",");
		HttpHost[] hosts = new HttpHost[nodes.length];
		for(int i=0,j=nodes.length;i<j;i++){
			String host = nodes[i].split(":")[0];
			Integer port = 9200;
			hosts[i] = new HttpHost(host,port);
		}
		final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
		credentialsProvider.setCredentials(AuthScope.ANY,
		        new UsernamePasswordCredentials(xPackAuthorization.split(":")[0], xPackAuthorization.split(":")[1]));
		RestClientBuilder  builder = RestClient.builder(hosts)
		        .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
		            @Override
		            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
		                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
		            }
		        })	  ;

		RestHighLevelClient	restHighLevelClient = new RestHighLevelClient(builder);
		return restHighLevelClient;
	}
}

4、启动类

package com.zjqf.highClientTest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class logApplicationRunner {
    public static void main(String[] args) {
        SpringApplication.run(logApplicationRunner.class,args);
    }
}

4、service层代码

4.1、索引相关

package com.zjqf.highClientTest.service.Impl;

import com.zjqf.highClientTest.ElasticSearchConfig;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;

@Service
public class EsIndexOperation {

    private final RequestOptions options = RequestOptions.DEFAULT;

    @Autowired
    private RestHighLevelClient client;

    /**
     * 判断索引是否存在
     */
    public boolean checkIndex (String index) {

        try {
            return client.indices().exists(new GetIndexRequest(index), options);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return Boolean.FALSE ;
    }

    /**
     * 创建索引
     */
//    public boolean createIndex (String indexName , Map<String, Object> columnMap){
//        try {
//            if(!checkIndex(indexName)){
//                CreateIndexRequest request = new CreateIndexRequest(indexName);
//                if (columnMap != null && columnMap.size()>0) {
//                    Map<String, Object> source = new HashMap<String, Object>();
//                    source.put("properties", columnMap);
//                    request.mapping(source);
//                }
//                this.client.indices().create(request, options);
//                return Boolean.TRUE ;
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return Boolean.FALSE;
//    }

    /**
     * 删除索引
     */
    public boolean deleteIndex(String indexName) {
        try {
            if(checkIndex(indexName)){
                DeleteIndexRequest request = new DeleteIndexRequest(indexName);
                AcknowledgedResponse response = client.indices().delete(request, options);
                return response.isAcknowledged();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }
}

4.2、查询相关

package com.zjqf.highClientTest.service.Impl;

import com.zjqf.highClientTest.payload.EsQueryPayload;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.validation.Payload;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
public class EsQueryOperation {

    private final RequestOptions options = RequestOptions.DEFAULT;

    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询总数
     */
    public Long count (String indexName){
        // 指定筛选内容
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        queryBuilder.must(QueryBuilders.termQuery("message","切面"));

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(queryBuilder);

        CountRequest countRequest = new CountRequest(indexName);
        countRequest.source(sourceBuilder);
        try {
            CountResponse countResponse = client.count(countRequest, options);
            return countResponse.getCount();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0L;
    }

    /**
     * syl：根据payload查询此条件下的数据的数量
     * @param payload
     * @return
     */
    public Long count (EsQueryPayload payload){

        SearchSourceBuilder sourceBuilder = this.getSourceBuilderBuPayload(payload);

        CountRequest countRequest = new CountRequest(payload.getIndexName());
        countRequest.source(sourceBuilder);
        try {
            CountResponse countResponse = client.count(countRequest, options);
            return countResponse.getCount();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0L;
    }

    /**
     * 查询集合
     */
    public List<Map<String,Object>> list (String indexName) {
        // 查询条件,指定时间并过滤指定字段值
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
//        queryBuilder.must(QueryBuilders.termQuery("createTime", 1611378102795L));
        queryBuilder.must(QueryBuilders.termQuery("message","切面"));
        sourceBuilder.query(queryBuilder);
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {

            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<Map<String,Object>>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
//                Map<String, Object> temp = searchHit.getSource();
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }

    /**
     * 分页查询
     */
    public List<Map<String,Object>> page (String indexName,Integer offset,Integer size) {
        // 查询条件,指定时间并过滤指定字段值
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
//        queryBuilder.must(QueryBuilders.termQuery("createTime", 1611378102795L));
        queryBuilder.must(QueryBuilders.termQuery("message","切面"));
        sourceBuilder.query(queryBuilder);


        //计算出记录起始下标
        int from = (offset - 1) * size;
        //起始记录下标，从0开始
        sourceBuilder.from(from);
        sourceBuilder.size(size);
        sourceBuilder.sort("@timestamp", SortOrder.DESC);
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<Map<String,Object>>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
//                Map<String, Object> temp = searchHit.getSource();
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }

    /**
     * syl：根据索引名称查询该索引下包含特定字段的内容集合并分页
     * @param payload
     * @return
     */
    public List<Map<String, Object>> queryByPayload(EsQueryPayload payload) {
        // 查询条件:在切面的message中匹配内容
        String yearAndMonth = payload.getYearAndMonth();
        String indexName = payload.getIndexName();
        if (StringUtils.isNotEmpty(yearAndMonth)){
            indexName += yearAndMonth;
        }else{

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd");
            String nowDate = sdf.format(new Date());
            indexName += nowDate;
        }
        SearchSourceBuilder sourceBuilder = this.getSourceBuilderBuPayload(payload);

        Integer page = payload.getPageNumber();
        Integer size =payload.getPageSize();

        //计算出记录起始下标
        int from = (page - 1) * size;

        //起始记录下标，从0开始
        sourceBuilder.from(from);
        sourceBuilder.size(payload.getPageSize());

        sourceBuilder.sort("@timestamp", SortOrder.DESC);

        //设置高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<tag>");
        highlightBuilder.postTags("</tag>");
        highlightBuilder.fields().add(new HighlightBuilder.Field("message"));
//        highlightBuilder.fields().add(new HighlightBuilder.Field("description"));
        sourceBuilder.highlighter(highlightBuilder);


        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {


            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<Map<String,Object>>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
//                Map<String, Object> temp = searchHit.getSource();
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            payload.setIndexName(indexName);
            Long count = this.count(payload);
            System.out.println("aaa查询到的count是"+count);
            System.out.println("aaa查询到的日志数量是"+data.size());
            return data;
        } catch (Exception e) {
            e.printStackTrace();
            List<Map<String,Object>> data = new ArrayList<Map<String,Object>>() ;
        }
        return null ;
    }


    /**
     * syl：把payload转换成查询条件
     * @param payload
     * @return
     */
    public SearchSourceBuilder getSourceBuilderBuPayload(EsQueryPayload payload){

        String messages = payload.getMessages();


        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //boolQuery组合查询搜索方式
        //1.定义一个boolQuery
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if (StringUtils.isNotEmpty(payload.getMessages())){
            //2.定义一个MultiMatchQuery 匹配搜索多个字段
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(messages)
                    .minimumShouldMatch("100%");
            //3.放入匹配搜索
            boolQueryBuilder.must(multiMatchQueryBuilder);
        }
        //4.再定义一个termQuery关键字查询
//        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("message","切面");
//        boolQueryBuilder.must(termQueryBuilder);

        if (StringUtils.isNotEmpty(payload.getLogLevel())){
            //5.定义过滤器
//        boolQueryBuilder.filter(termQueryBuilder);
            boolQueryBuilder.filter(QueryBuilders.matchQuery("logLevel",payload.getLogLevel()));

        }



        sourceBuilder.query(boolQueryBuilder);
        return  sourceBuilder;
    }

}

5、controller层

package com.zjqf.highClientTest.controller;

import com.zjqf.highClientTest.payload.EsQueryPayload;
import com.zjqf.highClientTest.service.Impl.EsDataOperation;
import com.zjqf.highClientTest.service.Impl.EsIndexOperation;
import com.zjqf.highClientTest.service.Impl.EsQueryOperation;
import com.zjqf.highClientTest.service.Impl.EsSortOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/esLog")
public class EsLogTestController {

    //查索引
    @Autowired
    private EsIndexOperation esIndexOperation;

    //增删改
    @Autowired
    private EsDataOperation esDataOperation;

    //查询
    @Autowired
    private EsQueryOperation esQueryOperation;

    //排序
    @Autowired
    private EsSortOperation esSortOperation;


    /**
     * syl：根据索引名称查询索引是否存在
     * @param indexName 索引名
     * @return
     */
    @RequestMapping(value = "/getIndex", method = RequestMethod.GET)
    public ResponseEntity<String> get(@RequestParam("indexName") String indexName) {
        boolean b = esIndexOperation.checkIndex(indexName);
        if(b){
            return new ResponseEntity<String>("索引存在"+indexName, HttpStatus.OK);
        }else{
            return new ResponseEntity<String>("该索引不存在", HttpStatus.OK);
        }

    }

    /**
     * syl：根据索引名称查询该索引下包含特定字段的内容集合
     * @param indexName
     * @return
     */
    @RequestMapping(value = "/query")
    public HashMap<String, Object> queryByIndexName(@RequestParam("indexName") String indexName) {

        List<Map<String, Object>> list = esQueryOperation.list(indexName);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("code",0);
        map.put("msg","");
        map.put("count",list.size());
        map.put("data",list);
        return map;

    }

    
    /**
     * syl：根据索引名称查询该索引下包含特定字段的内容集合并分页
     * @param indexName
     * @param offset 页码
     * @param size 每页数量
     * @return
     */
    @RequestMapping(value = "/queryPage", method = RequestMethod.GET)
    public HashMap<String, Object> queryByIndexName(@RequestParam("indexName") String indexName,
                                                                      @RequestParam("offset") Integer offset,
                                                                      @RequestParam("size") Integer size) {

        List<Map<String, Object>> list = esQueryOperation.page(indexName,offset,size);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("code",0);
        map.put("msg","");
        map.put("count",list.size());
        map.put("data",list);
        return map;

    }

    /**
     * syl：根据索引名称查询该索引下包含特定字段的内容集合的数量
     * @param indexName
     * @return
     */
    @RequestMapping(value = "/getMessageCount", method = RequestMethod.GET)
    public ResponseEntity<String> getMessageCount(@RequestParam("indexName") String indexName) {
        Long count = esQueryOperation.count(indexName);
        return new ResponseEntity<String>("该索引下存在数据数量:"+count, HttpStatus.OK);


    }

    /**
     * syl：根据索引名称查询该索引下包含特定字段的内容集合并分页
     * @return
     */
    @RequestMapping(value = "/queryByPayload")
    public HashMap<String, Object> queryByPayload(@RequestParam("yearAndMonth") String yearAndMonth,
                                                  @RequestParam("messages") String messages,
                                                  @RequestParam("logLevel") String logLevel,
                                                  @RequestParam("page") Integer page,
                                                  @RequestParam("limit") Integer limit) {

        EsQueryPayload payload = new EsQueryPayload();
        if(StringUtils.isNotEmpty(yearAndMonth)){
            payload.setYearAndMonth(yearAndMonth);
        }else{
            //payload.setYearAndMonth("2021.03.30");
        }
        if(StringUtils.isNotEmpty(messages)){
            payload.setMessages(messages);
        }
        if(StringUtils.isNotEmpty(logLevel)){
            payload.setLogLevel(logLevel);
        }
        if (page!=null){
            payload.setPageNumber(page);
        }
        if(limit!=null){
            payload.setPageSize(limit);
        }

        List<Map<String, Object>> list = esQueryOperation.queryByPayload(payload);
        Long count = esQueryOperation.count(payload);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("code",0);
        map.put("msg","");
        map.put("count",count);
        map.put("data",list);
        return map;

    }

    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ResponseBody
    public ModelAndView list() {

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("log");
        //modelAndView.addObject("name","李四");  //绑定传递的数据
        return modelAndView;

    }
   /* @RequestMapping(value = "/log", method = RequestMethod.GET)
    public String log() {
        return "log111111111";

    }*/

    @RequestMapping(value = "/listPage", method = RequestMethod.GET)
    public ModelAndView listPage() {

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("logPage");
        //modelAndView.addObject("name","李四");  //绑定传递的数据
        return modelAndView;

    }

}

6、结果展示和说明

此处，我在service层的代码中是对该索引下 **message ** 字段包含了切面内容的数据进行了筛选；可见，结果是一直的；

如果需要对别的字段进行筛选，可自己写BoolQueryBuilder queryBuilder，自己组成不同的条件；

我这里日志系统比较简单，就是查指定索引下message的内容（因为我之前切面把所有信息都放进message里分词了）

es接入rabbitmq日志 springboot集成es日志_elasticsearch_02


es接入rabbitmq日志 springboot集成es日志_elasticsearch_03

参考文章

SpringBoot整合ES的三种方式（API、REST Client、Data-ES）

SpringBoot -ElasticSearch RestHighLevelClient 高级客户端使用(1) 初始化

使用RestHighLevelClient报错：ClassNotFoundException: org.elasticsearch.common.xcontent.DeprecationHandler

httpclient及httpcore版本过低不匹配导致
Invalid receiver type interface org.apache.http.Header； not a subtype of implementation type interface

java RestHighLevelClient方式操作es