<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.3.4.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.ai.bss.es</groupId>

    <artifactId>es-manage</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>es-manage</name>

    <description>es manage for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

        <!-- 这里必须要填写，因为springboot2.3.2默认的elasticsearch版本为7.6.2,我们使用的是7.4.2，不更改会产生版本不兼容等问题 -->

        <elasticsearch.version>7.4.2</elasticsearch.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

<!--         这里我使用的是elasticsearch的high-level-client 版本要和你的elasticsearch版本对应-->

<!--        <dependency>-->

<!--            <groupId>org.elasticsearch.client</groupId>-->

<!--            <artifactId>elasticsearch-rest-high-level-client</artifactId>-->

<!--            <version>7.4.2</version>-->

<!--            <exclusions>-->

<!--                <exclusion>-->

<!--                    <groupId>org.elasticsearch</groupId>-->

<!--                    <artifactId>elasticsearch</artifactId>-->

<!--                </exclusion>-->

<!--            </exclusions>-->

<!--        </dependency>-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

            <exclusions>

                <exclusion>

                    <groupId>org.junit.vintage</groupId>

                    <artifactId>junit-vintage-engine</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

        <dependency>

            <groupId>org.projectlombok</groupId>

            <artifactId>lombok</artifactId>

            <version>1.18.12</version>

        </dependency>

        <dependency>

            <groupId>com.ai.abc</groupId>

            <artifactId>persistence-es</artifactId>

            <version>2.0-SNAPSHOT</version>

            <exclusions>

                <exclusion>

                    <groupId>org.springframework.boot</groupId>

                    <artifactId>spring-boot-starter-log4j2</artifactId>

                </exclusion>

<!--                <exclusion>-->

<!--                    <groupId>org.elasticsearch</groupId>-->

<!--                    <artifactId>elasticsearch</artifactId>-->

<!--                </exclusion>-->

<!--                <exclusion>-->

<!--                    <groupId>org.elasticsearch.client</groupId>-->

<!--                    <artifactId>elasticsearch-rest-high-level-client</artifactId>-->

<!--                </exclusion>-->

<!--                <exclusion>-->

<!--                    <groupId>org.projectlombok</groupId>-->

<!--                    <artifactId>lombok</artifactId>-->

<!--                </exclusion>-->

            </exclusions>

        </dependency>

    </dependencies>

    <build>

        <resources>

            <resource>

                <directory>src/main/resources</directory>

                <excludes>

                    <exclude>environment/dev/**</exclude>

                    <exclude>environment/product/**</exclude>

                    <exclude>environment/test/**</exclude>

                </excludes>

            </resource>

            <resource>

                <directory>${project.basedir}/src/main/resources/environment/${env}</directory>

            </resource>

        </resources>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

            <!--            <plugin>

                            <groupId>org.apache.maven.plugins</groupId>

                            <artifactId>maven-resources-plugin</artifactId>

                            <executions>

                                <execution>

                                    <id>copy-resources</id>

                                    <phase>package</phase>

                                    <goals>

                                        <goal>copy-resources</goal>

                                    </goals>

                                    <configuration>

                                        <encoding>UTF-8</encoding>

                                        <outputDirectory>

                                            ${project.build.directory}/config

                                        </outputDirectory>

                                        <resources>

                                            <resource>

                                                <directory>src/main/resources/environment/${env}</directory>

                                                <includes>

                                                    <include>**/*.properties</include>

                                                    <include>**/*.xml</include>

                                                </includes>

                                            </resource>

                                        </resources>

                                    </configuration>

                                </execution>

                            </executions>

                        </plugin>-->

            <!-- The configuration of maven-jar-plugin -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-jar-plugin</artifactId>

                <version>2.4</version>

                <!-- The configuration of the plugin -->

                <configuration>

                    <!-- Configuration of the archiver -->

                    <archive>

                        <!--生成的jar中，不要包含pom.xml和pom.properties这两个文件-->

                        <addMavenDescriptor>false</addMavenDescriptor>

                        <!-- Manifest specific configuration -->

                        <manifest>

                            <!--是否要把第三方jar放到manifest的classpath中-->

                            <addClasspath>true</addClasspath>

                            <!--生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/-->

                            <classpathPrefix>lib/</classpathPrefix>

                            <!--应用的main class-->

                            <mainClass>com.ai.bss.es.esmanage.EsManageApplication</mainClass>

                        </manifest>

                        <manifestEntries>

                            <Class-Path>./config/</Class-Path>

                        </manifestEntries>

                    </archive>

                    <!--过滤掉不希望包含在jar中的文件-->

                    <excludes>

                        <exclude>**/*.properties</exclude>

                        <exclude>**/*.xml</exclude>

                    </excludes>

                </configuration>

            </plugin>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-dependency-plugin</artifactId>

                <version>2.10</version>

                <executions>

                    <execution>

                        <id>copy-dependencies</id>

                        <phase>package</phase>

                        <goals>

                            <goal>copy-dependencies</goal>

                        </goals>

                        <configuration>

                            <outputDirectory>${project.build.directory}/lib</outputDirectory>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

            <!-- The configuration of maven-assembly-plugin -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-assembly-plugin</artifactId>

                <version>2.4</version>

                <!-- The configuration of the plugin -->

                <configuration>

                    <!-- Specifies the configuration file of the assembly plugin -->

                    <descriptors>

                        <descriptor>${project.basedir}/src/main/assembly/package.xml</descriptor>

                    </descriptors>

                </configuration>

                <executions>

                    <execution>

                        <id>make-assembly</id>

                        <phase>package</phase>

                        <goals>

                            <goal>single</goal>

                        </goals>

                    </execution>

                </executions>

            </plugin>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <configuration>

                    <skip>true</skip>

                </configuration>

            </plugin>

        </plugins>

    </build>

</project>

<assembly>

  <id>bin</id>

  <!-- 最终打包成一个用于发布的zip文件 -->

  <formats>

    <format>zip</format>

  </formats>

  <!-- Adds dependencies to zip package under lib directory -->

  <dependencySets>

    <dependencySet>

      <!-- 不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录 -->

      <useProjectArtifact>false</useProjectArtifact>

      <outputDirectory>lib</outputDirectory>

      <unpack>false</unpack>

      <scope>runtime</scope>

    </dependencySet>

  </dependencySets>

  <fileSets>

    <!-- 把项目相关的说明文件，打包进zip文件的根目录 -->

    <fileSet>

      <directory>${project.basedir}</directory>

      <outputDirectory>/</outputDirectory>

      <includes>

        <include>README*</include>

        <include>LICENSE*</include>

        <include>NOTICE*</include>

      </includes>

    </fileSet>

    <!-- 把项目的配置文件，打包进zip文件的config目录 -->

    <fileSet>

<!--      <directory>/src/main/resources/environment/${env}</directory>-->

      <directory>/src/main/resources</directory>

      <outputDirectory>/config</outputDirectory>

      <includes>

        <include>**/*.properties</include>

        <include>**/*.xml</include>

      </includes>

    </fileSet>

    <!-- 把项目的脚本文件目录（ src/main/scripts ）中的启动脚本文件，打包进zip文件的跟目录 -->

    <fileSet>

      <directory>${project.build.scriptSourceDirectory}</directory>

      <outputDirectory></outputDirectory>

      <includes>

        <include>startup.*</include>

      </includes>

    </fileSet>

    <!-- 把项目自己编译出来的jar文件，打包进zip文件的根目录 -->

    <fileSet>

      <directory>${project.build.directory}</directory>

      <outputDirectory></outputDirectory>

      <includes>

        <include>*.jar</include>

      </includes>

    </fileSet>

  </fileSets>

</assembly>

package com.ai.bss.es.esmanage;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class EsManageApplication {

    public static void main(String[] args) {

        SpringApplication.run(EsManageApplication.class, args);

    }

}

package com.ai.bss.es.esmanage.controller;

import com.ai.bss.es.esmanage.service.EsService;

import com.ai.bss.es.esmanage.utils.RequestEntity;

import com.ai.bss.es.esmanage.utils.ResponseResult;

import org.elasticsearch.action.index.IndexRequest;

import org.elasticsearch.action.index.IndexResponse;

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.common.xcontent.XContentType;

import org.elasticsearch.index.query.BoolQueryBuilder;

import org.elasticsearch.index.query.MatchQueryBuilder;

import org.elasticsearch.index.query.QueryBuilders;

import org.elasticsearch.search.SearchHit;

import org.elasticsearch.search.aggregations.AggregationBuilders;

import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;

import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;

import org.elasticsearch.search.builder.SearchSourceBuilder;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

@RestController

@RequestMapping("/es")

public class EsController {

    @Autowired

    private RestHighLevelClient client;

    @Autowired

    private EsService esService;

    @PostMapping("/execute")

    ResponseResult execute(@RequestBody RequestEntity requestEntity) throws IOException {

//        SearchRequest requestEs = null;

//        String entity = requestEntity.getEntity();

//        String methods = requestEntity.getMethods();

//        String tableName = requestEntity.getTableName();

//        String type = requestEntity.getType();

//        if("search".equals(methods)){

//            requestEs =  new SearchRequest(tableName);

//            SearchResponse searchResponse = client.search(requestEs, RequestOptions.DEFAULT);

//

//            //6、开始处理返回的数据

//            SearchHit[] hits = searchResponse.getHits().getHits();

//            List<String> list = new ArrayList<String>();

//            for (SearchHit hit : hits) {

//                String hitString = hit.getSourceAsString();

//                System.out.println(hitString);

//                list.add(hitString);

//            }

//            ResponseResult.sucess(list);

//        }

//

//        if("GET".equals(methods)){

//            requestEs =  new SearchRequest(tableName);

//            SearchResponse searchResponse = null;//purePersist(requestEs, RequestOptions.DEFAULT);

//

//            //6、开始处理返回的数据

//            SearchHit[] hits = searchResponse.getHits().getHits();

//            List<String> list = new ArrayList<String>();

//            for (SearchHit hit : hits) {

//                String hitString = hit.getSourceAsString();

//                System.out.println(hitString);

//                list.add(hitString);

//            }

//            ResponseResult.sucess(list);

//        }

        return esService.executeEsEntity(requestEntity);

    }

    @RequestMapping("/test")

    List<String> contextLoads() throws IOException {

        //1、创建查询请求，规定查询的索引

        SearchRequest request = new SearchRequest("es_terminal_event");

        //2、创建条件构造

        SearchSourceBuilder builder = new SearchSourceBuilder();

        //3、构造条件

        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "Lane");

        builder.query(matchQueryBuilder);

        //聚合年龄分布

        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age");

        builder.aggregation(ageAgg);

//

//        //聚合平均年龄

        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");

        builder.aggregation(balanceAvg);

        List<String> ids = new ArrayList();

        ids.add("981489");

        ids.add("155682");

        BoolQueryBuilder exersiceBoolQuery = QueryBuilders.boolQuery();

        for (String exerciseId: ids)

        {

            exersiceBoolQuery.must(QueryBuilders.termQuery("resourceId", exerciseId));

        }

        builder.query(exersiceBoolQuery);

        //4、将构造好的条件放入请求中

        request.source(builder);

        //5、开始执行发送request请求

        SearchResponse searchResponse = client.search(request, RequestOptions.DEFAULT);

        //6、开始处理返回的数据

        SearchHit[] hits = searchResponse.getHits().getHits();

        List<String> list = new ArrayList<String>();

        for (SearchHit hit : hits) {

            String hitString = hit.getSourceAsString();

            System.out.println(hitString);

            list.add(hitString);

        }

        return list;

    }

}

package com.ai.bss.es.esmanage.service;

import com.ai.bss.es.esmanage.utils.RequestEntity;

import com.ai.bss.es.esmanage.utils.ResponseResult;

public interface EsService {

    ResponseResult executeEsEntity(RequestEntity requestEntity);

}

package com.ai.bss.es.esmanage.service.impl;

import com.ai.abc.jpa.elastic.model.ElasticPage;

import com.ai.abc.jpa.elastic.model.PageInfo;

import com.ai.abc.jpa.elastic.model.TimeInfo;

import com.ai.abc.jpa.elastic.repository.ElasticEntityRepository;

import com.ai.abc.jpa.elastic.repository.impl.ElasticEntityRepositoryImpl;

import com.ai.bss.es.esmanage.service.EsService;

import com.ai.bss.es.esmanage.utils.RequestEntity;

import com.ai.bss.es.esmanage.utils.ResponseResult;

import com.alibaba.fastjson.JSONArray;

import com.alibaba.fastjson.JSONObject;

import com.alibaba.fastjson.TypeReference;

import lombok.extern.slf4j.Slf4j;

import org.elasticsearch.index.query.QueryBuilders;

import org.elasticsearch.index.query.TermsQueryBuilder;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;

import org.springframework.util.StringUtils;

import java.util.*;

@Slf4j

@Service

public class EsServiceImpl implements EsService {

    @Value("${es.server:47.105.160.21:10020}")

    String esServer ;

    ElasticEntityRepository elasticEntityRepository = null;

    private ElasticEntityRepository getElasticEntityRepository(){

        if(elasticEntityRepository==null){

            elasticEntityRepository = new ElasticEntityRepositoryImpl();

            elasticEntityRepository.initServer(esServer);

        }

        return elasticEntityRepository;

    }

    @Override

    public ResponseResult executeEsEntity(RequestEntity requestEntity) {

        if(requestEntity==null){

            return null;

        }

        String methods = requestEntity.getMethods();

        if("SAVE".equals(methods)){

            saveEsEntity(requestEntity);

            return ResponseResult.sucess();

        }else{

            return findEsEntityList(requestEntity);

        }

    }

    private void saveEsEntity(RequestEntity requestEntity){

        getElasticEntityRepository().purePersist(requestEntity.getTableName(), "", requestEntity.getEntity());

    }

    private ResponseResult findEsEntityList(RequestEntity requestEntity) {

        PageInfo pageInfo = new PageInfo();

        int pageSize = requestEntity.getPageSize() == null ? 0 : requestEntity.getPageSize();

        int startNum = requestEntity.getStartNumber() == null ? 0 : requestEntity.getStartNumber()*pageSize;

        pageInfo.setStartNumber(startNum);

        pageInfo.setPageSize(pageSize);

        Map entityMap = null;

        if (!StringUtils.isEmpty(requestEntity.getEntity())) {

            String entityStr = requestEntity.getEntity();

            entityMap = JSONObject.parseObject(entityStr, new TypeReference<Map<String, Object>>() {});

        }

        Map fieldMap = null;

        String entityKey;

        if (entityMap != null && !entityMap.isEmpty()) {

            fieldMap = new HashMap();

            Iterator var10 = entityMap.entrySet().iterator();

            while(var10.hasNext()) {

                Map.Entry<String, Object> entry = (Map.Entry)var10.next();

                entityKey = (String)entry.getKey();

                if (entry.getValue() != null) {

                    TermsQueryBuilder termsQueryBuilder = null;

                    if (entry.getValue().getClass() == JSONArray.class) {

//                        this.log.debug("mapKey=" + sortType + ",entry.getValue()=" + entry.getValue());

//                        termsQueryBuilder = QueryBuilders.termsQuery(sortType, (ArrayList)entry.getValue());

                        fieldMap.put(entityKey,JSONArrayToArrayList((JSONArray)entry.getValue()));

                    } else {

                        String mapValue = entry.getValue().toString();

//                        termsQueryBuilder = QueryBuilders.termsQuery(sortType, new String[]{mapValue});

                        fieldMap.put(entityKey,mapValue);

                    }

                }

//                fieldMap.put(entityKey)

            }

        }

        Map sortMap = new HashMap();

        if(!StringUtils.isEmpty(requestEntity.getSortFieldName())){

            sortMap.put("sortFieldName",requestEntity.getSortFieldName());

            sortMap.put("sortType",requestEntity.getSortType());

        }

        TimeInfo timeInfo =new TimeInfo();

        timeInfo.setStartTime(requestEntity.getStartTime());

        timeInfo.setEndTime(requestEntity.getEndTime());

        timeInfo.setFieldName(requestEntity.getTimeFieldName());

        ElasticPage elasticPage = getElasticEntityRepository().findEntity(requestEntity.getTableName(), fieldMap, timeInfo, pageInfo,sortMap);

        return ResponseResult.sucess(elasticPage.getTotalSize(),elasticPage.getResults());

    }

    private ArrayList<String> JSONArrayToArrayList(JSONArray jsonArray){

        ArrayList<String> listdata = null;

        if (jsonArray != null) {

            listdata = new ArrayList<String>();

            for (int i=0;i<jsonArray.size();i++){

                listdata.add(jsonArray.getString(i));

            }

        }

        return listdata;

    }

    private Object findEsEntity(){

        return null;

    }

}

package com.ai.bss.es.esmanage.utils;

/**

 * 公共常量类

 *

 * @author chencai

 */

public class CommonConsts {

    /**

     * 接口调用返回的成功编码

     */

    public static final String RESULT_CODE_SUCCESSFUL = "0";

    /**

     * 接口调用返回的失败编码

     */

    public static final String RESULT_CODE_FAILED = "1";

    /**

     * 接口调用返回的成功描述信息

     */

    public static final String RESULT_MSG_SUCCESSFUL = "成功";

    /**

     * 接口调用返回的失败的描述信息

     */

    public static final String RESULT_MSG_FAILED = "失败";

    /**

     * CSV文件列分隔符

     */

    public static final String CSV_COLUMN_SEPARATOR = ",";

    public static final String CSV_COLUMN_SEPARATOR2 = "|";

    /**

     * CSV文件列分隔符

     */

    public static final String CSV_RN = "\r\n";

    /**

     * 最小误差

     */

    public static final double EPSILON = 0.00000000000000022204;

    /**

     * 时间格式转化 yyyyMMdd_HHmmss

     */

    public static final String DATE_FORMAT_YYYYMMDD_HHMMSS = "yyyyMMdd_HHmmss";

    /**

     * 时间格式转化 yyyyMM

     */

    public static final String DATE_FORMAT_YYYYMM = "yyyyMM";

    /**

     * 时间格式转化 yyyyMMdd

     */

    public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";

    /**

     *

     */

    public static final String RESULT_MSG_CREATE_CSV_FAILED = "生成csv文件失败";

    /**

     * uspa组织类型-基础平台

     */

    public static final String USPA_ORG_TYPE_PLATFORM_ORG = "PLATFORM_ORG";

    /**

     * uspa组织类型-行业云

     */

    public static final String USPA_ORG_TYPE_INDUSTRY_ORG = "INDUSTRY_ORG";

    /**

     * uspa组织类型-客户

     */

    public static final String USPA_ORG_TYPE_CUSTOMER_ORG = "CUSTOMER_ORG";

    public static final String CHARSET_UTF8 = "UTF-8";

    public static final String HTTP_CONTENT_TYPE_JSON = "application/json; charset=utf-8";

    private CommonConsts() {}

//

//    /** 

//     * callsTimesMap存放方法被调用的次数O 

//     */

//    public  static ThreadLocal<Map<String, Long >> callsTimesMap = new ThreadLocal<Map<String, Long>>();// new ThreadLocal<>();

//    /** 

//     * methodTotalTmieMap存放方法总耗时 

//     */

//    public  static ThreadLocal<Map<String, Long >> methodTotalTmieMap = new ThreadLocal<Map<String, Long>>();

}

package com.ai.bss.es.esmanage.utils;

import org.apache.http.HttpHost;

import org.elasticsearch.client.RestClient;

import org.elasticsearch.client.RestHighLevelClient;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

 * 给容器中注入一个RestHighLevelClient

 */

@Configuration

public class ElasticSearchConfig {

    @Value("${es.server:47.105.160.21}")

    String esServer ;

    @Value("${es.server.port:10020}")

    Integer esServerPort ;

    @Bean

    public RestHighLevelClient esRestClient(){

        RestHighLevelClient client = new RestHighLevelClient(

                RestClient.builder(

                        //在这里配置你的elasticsearch的情况

                        new HttpHost(esServer, esServerPort, "http")

                )

        );

        return client;

    }

}

package com.ai.bss.es.esmanage.utils;

import lombok.Getter;

import lombok.Setter;

@Setter

@Getter

public class RequestEntity {

    private String tableName;

    private String type;

    private String methods;

    private String entity;

    private Integer startNumber;

    private Integer pageSize;

    private String startTime;

    private String endTime;

    private String timeFieldName;

    private String sortFieldName;

    private String sortType;

}

package com.ai.bss.es.esmanage.utils;

import lombok.Getter;

import lombok.NoArgsConstructor;

import lombok.Setter;

/**

 * 接口响应参数公共类

 *

 * @author chencai

 */

@NoArgsConstructor

@Getter

@Setter

public class ResponseResult<T> {

    /**

     * 结果编码

     */

    private String resultCode;

    /**

     * 结果信息

     */

    private String resultMsg;

    /**

     * 调用轨迹标识

     */

    private Long traceId;

    /**

     * 结果集数量

     */

    private Long totalResultNumber;

    /**

     * 结果集信息

     */

    private T result;

    private ResponseResult(String resultCode, String resultMsg) {

        this.resultCode = resultCode;

        this.resultMsg = resultMsg;

    }

    private ResponseResult(String resultCode, String resultMsg, T result) {

        this.resultCode = resultCode;

        this.resultMsg = resultMsg;

        this.result = result;

    }

    private ResponseResult(String resultCode, String resultMsg, Long totalResuleNumber,

                           T result) {

        this.resultCode = resultCode;

        this.resultMsg = resultMsg;

        this.totalResultNumber = totalResuleNumber;

        this.result = result;

    }

    private ResponseResult(String resultCode, String resultMsg, Long traceId, Long totalResuleNumber,

                           T result) {

        this.resultCode = resultCode;

        this.resultMsg = resultMsg;

        this.traceId = traceId;

        this.totalResultNumber = totalResuleNumber;

        this.result = result;

    }

    public static <T> ResponseResult<T> sucess() {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_SUCCESSFUL, CommonConsts.RESULT_MSG_SUCCESSFUL);

    }

    public static <T> ResponseResult<T> sucess(String resultMsg) {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_SUCCESSFUL, resultMsg);

    }

    public static <T> ResponseResult<T> sucess(T result) {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_SUCCESSFUL, CommonConsts.RESULT_MSG_SUCCESSFUL, result);

    }

    public static <T> ResponseResult<T> sucess(long totalResuleNumber, T result) {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_SUCCESSFUL, CommonConsts.RESULT_MSG_SUCCESSFUL, totalResuleNumber, result);

    }

    public static <T> ResponseResult<T> sucess(Long traceId, Long totalResuleNumber, T result) {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_SUCCESSFUL, CommonConsts.RESULT_MSG_SUCCESSFUL, traceId, totalResuleNumber, result);

    }

    public static <T> ResponseResult<T> error() {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_FAILED, CommonConsts.RESULT_MSG_FAILED);

    }

    public static <T> ResponseResult<T> error(String errorMsg) {

        return new ResponseResult<T>(CommonConsts.RESULT_CODE_FAILED, errorMsg);

    }

    public static <T> ResponseResult<T> error(String resultCode, String errorMsg) {

        return new ResponseResult<T>(resultCode, errorMsg);

    }

    public static <T> ResponseResult<T> error(String resultCode, String errorMsg, Long traceId) {

        return new ResponseResult<T>(resultCode, errorMsg, traceId, 0L, null);

    }

}

server.port=8111

spring.application.name=elastic

es.server=47.105.160.21:10020

es.server.port=10020

server.port=8111

spring.application.name=elastic

es.server=47.105.160.21:10020

es.server.port=10020

server.port=8111

spring.application.name=elastic

es.server=47.105.160.21:10020

es.server.port=10020

server.port=8111

spring.application.name=elastic

es.server=47.105.160.21:10020

es.server.port=10020

package com.ai.bss.es.esmanage;

import com.ai.abc.jpa.elastic.model.ElasticPage;

import com.ai.abc.jpa.elastic.model.PageInfo;

import com.ai.abc.jpa.elastic.model.TimeInfo;

import com.ai.abc.jpa.elastic.repository.ElasticEntityRepository;

import com.ai.abc.jpa.elastic.repository.impl.ElasticEntityRepositoryImpl;

import com.alibaba.fastjson.JSONObject;

import com.alibaba.fastjson.TypeReference;

import org.elasticsearch.action.search.SearchRequest;

import org.elasticsearch.action.search.SearchRequestBuilder;

import org.elasticsearch.action.search.SearchResponse;

import org.elasticsearch.client.RequestOptions;

import org.elasticsearch.client.RestHighLevelClient;

import org.elasticsearch.index.query.BoolQueryBuilder;

import org.elasticsearch.index.query.MatchQueryBuilder;

import org.elasticsearch.index.query.QueryBuilders;

import org.elasticsearch.search.SearchHit;

import org.elasticsearch.search.aggregations.AggregationBuilders;

import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;

import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;

import org.elasticsearch.search.builder.SearchSourceBuilder;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.*;

@SpringBootTest

class EsManageApplicationTests {

    @Autowired

    private RestHighLevelClient client;

    @Test

    void contextLoads()  {

        ElasticEntityRepository elasticEntityRepository = new ElasticEntityRepositoryImpl();

        elasticEntityRepository.initServer("47.105.160.21:10020");

//        JSONObject jsonObject = new JSONObject();

//        jsonObject.put("id", "113");

//        jsonObject.put("type", "1");

//        jsonObject.put("name", "yaxin12");

//        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//        jsonObject.put("create_date", df.format(new Date()));

//

//        //插入

//        String entity = jsonObject.toString();