springboot快速启动插件elasticsearch篇

末蓝、 2022-05-11 00:28 160阅读 0赞

之前已经介绍过如何编写自定义starter，如不明白请参考[springboot自定义Starter][springboot_Starter]

功能点：

*  封装es操作，简化开发

## 1.创建maven工程 ##

略

## 2.编写pom文件 ##

<?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">
        <parent>
            <artifactId>iotstarter</artifactId>
            <groupId>com.iot</groupId>
            <version>0.0.1-RELEASES</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <packaging>jar</packaging>
        <groupId>com.iot</groupId>
        <artifactId>iot-es-spring-boot-starter</artifactId>
        <version>0.0.1-RELEASES</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>transport</artifactId>
            </dependency>
        </dependencies>
    </project>

# 3.编写配置文件类实体 #

## 3.1 查询实体 ##

package com.iot.es.entity;
    
    import lombok.Getter;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.UUID;
    
    /**
     * 描述：es查询实体
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsSearchEntity {
        /**
         * 索引
         */
        private  String index;
        /**
         * 类型
         */
        private String type;
        /**
         *id
         */
        private String esId =UUID.randomUUID().toString();
        /**
         * 条件实体
         */
        private List<EsCondition> esConditionList;
        /**
         * 分页实体
         */
        private EsPage esPage;
    
        /**
         * 排序实体
         */
        private EsSort esSort;
    
        /**
         * 设置index
         * @param index
         * @return
         */
        public EsSearchEntity index(String index) {
            this.index=index;
            return this;
        }
    
        /**
         * 设置type
         * @param type
         * @return
         */
        public EsSearchEntity type(String type) {
            this.type=type;
            return this;
        }
    
        /**
         * 设置id
         * @param esId
         * @return
         */
        public EsSearchEntity esId(String esId) {
            this.esId = esId;
            return this;
        }
    
        /**
         * 添加查询实体
         * @param key
         * @param queryType
         * @param value
         * @param value1
         * @return
         */
        public EsSearchEntity addCondition(String key,String queryType,Object value,Object value1) {
            List<EsCondition> esConditions = this.getEsConditionList() == null ? new ArrayList<EsCondition>() : this.getEsConditionList();
            esConditions.add(new EsCondition(key,queryType,value,value1));
            this.esConditionList=esConditions;
            return this;
        }
    
        /**
         * 封装分页实体
         * @param pageNum 第几页 默认1
         * @param pageSize 每页总数 默认10
         * @return
         */
        public EsSearchEntity esPage(int pageNum,int pageSize) {
            this.esPage=new EsPage(pageNum,pageSize);
            return this;
        }
    
        /**
         * 设置排序字段
         * @param sortKey
         * @param sortDesc
         * @return
         */
        public EsSearchEntity esSort(String sortKey, boolean sortDesc) {
            this.esSort=new EsSort(sortKey,sortDesc);
            return this;
        }
    }

## 3.2 查询条件实体 ##

package com.iot.es.entity;
    
    import com.iot.es.constant.EsConstant;
    import lombok.Getter;
    
    /**
     * 描述：es查询实体
     *
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsCondition {
        /**
         * key
         */
        private String key ="***";
        /**
         * 值
         */
        private Object value=null;
        /**
         * 值2
         */
        private Object value2=null;
        /**
         * 查询条件
         */
        private String queryType=EsConstant.QUERY_TYPE_IS;
    
        protected EsCondition(String key,String queryType,Object value,Object value2){
            this.key=key;
            this.queryType=queryType;
            this.value=value;
            this.value2=value2;
        }
    
    
        /**
         * 匹配查询
         * @param key 列名
         * @param value 列值
         * @return EsCondition条件实体
         */
        private EsCondition is(String key,String value) {
            this.queryType= EsConstant.QUERY_TYPE_IS;
            this.key = key;
            this.value = value;
            return this;
        }
    
        /**
         * 范围查询
         * @param key 列名
         * @param rangeBegin 开始值
         * @param rangeEnd  结束值
         * @return
         */
        private EsCondition range(String key,String rangeBegin,String rangeEnd) {
            this.queryType = EsConstant.QUERY_TYPE_RANGE;
            this.key = key;
            this.value = rangeBegin;
            this.value2 = rangeEnd;
            return this;
        }
    
        /**
         * 大于
         * @param key 列名
         * @param value 列值
         * @return
         */
        private EsCondition gt(String key,String value) {
            this.queryType = EsConstant.QUERY_TYPE_GT;
            this.key = key;
            this.value = value;
            return this;
        }
    
        /**
         * 小于
         * @param key 列名
         * @param value 列值
         * @return
         */
        private EsCondition lt(String key,String value) {
            this.queryType = EsConstant.QUERY_TYPE_LT;
            this.key = key;
            this.value = value;
            return this;
        }
    
    }

## 3.3 分页实体 ##

package com.iot.es.entity;
    
    import lombok.Data;
    import lombok.Getter;
    
    /**
     * 描述：分页对象
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsPage {
        //当前页,从请求那边传过来。
        private int pageNum=1;
        //每页显示的数据条数。
        private int pageSize=10;
        //总的记录条数。查询数据库得到的数据
        private long totalRecord;
        private long totalPage;
        private int from;
    
        public EsPage(int pageNum,int pageSize){
            this.pageNum=pageNum;
            this.pageSize=pageSize;
            this.from=(pageNum-1)*pageSize;
        }
    
        /**
         * 设置总条数
         * @param totalRecord
         */
        public void setTotalRecord(long totalRecord) {
            this.totalRecord = totalRecord;
            this.totalPage=totalRecord%pageSize==0?totalRecord/pageSize:totalRecord/pageSize+1;
        }
    }

## 3.4 排序实体 ##

## 3.5 分页查询结果返回实体 ##

package com.iot.es.entity;
    
    import cn.hutool.json.JSONObject;
    import lombok.Data;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * 描述：查询结果返回实体
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Data
    public class EsSearchResult {
        /**
         * es分页实体
         */
        private EsPage esPage;
        /**
         * 返回结果
         */
        private List<Map<String,Object>> list;
    }

# 4.其他操作实体(添加、修改、删除) #

package com.iot.es.entity;
    
    import cn.hutool.json.JSONArray;
    import cn.hutool.json.JSONObject;
    import cn.hutool.json.JSONUtil;
    import lombok.Getter;
    
    import java.util.List;
    import java.util.UUID;
    
    /**
     * 描述：es添加实体
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsOtherEntity {
        /**
         * 索引
         */
        private  String index;
        /**
         * 类型
         */
        private String type;
        /**
         *id
         */
        private String esId= UUID.randomUUID().toString();
        /**
         * 数据对象
         */
        private JSONObject jsonObj;
        /**
         * 数据对象数组
         */
        private JSONArray jsonObjList;
        /**
         * 查询实体
         */
        private EsSearchEntity esSearchEntity;
        /**
         * 设置index
         * @param index
         * @return
         */
        public EsOtherEntity index(String index) {
            this.index=index;
            return this;
        }
    
        /**
         * 设置type
         * @param type
         * @return
         */
        public EsOtherEntity type(String type) {
            this.type=type;
            return this;
        }
    
        /**
         * 设置id
         * @param esId
         * @return
         */
        public EsOtherEntity esId(String esId) {
            this.esId = esId;
            return this;
        }
    
        /**
         * 设置对象
         * @param obj
         * @return
         */
        public EsOtherEntity jsonObj(Object obj) {
            this.jsonObj = JSONUtil.parseObj(obj);
            return this;
        }
    
        /**
         * 批量操作对象
         * @param array
         * @return
         */
        public EsOtherEntity jsonObjList(Object array) {
            this.jsonObjList = JSONUtil.parseArray(array);
            return this;
        }
    
        public EsOtherEntity setEsSearchEntity(EsSearchEntity esSearchEntity) {
            this.esSearchEntity = esSearchEntity;
            return this;
        }
    }

# 5.聚合查询相关实体 #

package com.iot.es.entity;
    
    import lombok.Getter;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 描述：聚合查询实体
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsAggregationEntity {
        /**
         * 索引
         */
        private  String index;
        /**
         * 类型
         */
        private String type;
        /**
         * 聚合条件
         */
        List<EsAggregation> esAggregations;
        /**
         * 查询实体
         */
        private EsSearchEntity esSearchEntity;
        /**
         * 长度
         */
        private int size=10;
    
        /**
         * 设置index
         * @param index
         * @return
         */
        public EsAggregationEntity index(String index) {
            this.index=index;
            return this;
        }
    
        /**
         * 设置type
         * @param type
         * @return
         */
        public EsAggregationEntity type(String type) {
            this.type=type;
            return this;
        }
    
        /**
         * 设置size
         * @param size
         * @return
         */
        public EsAggregationEntity size(int size) {
            this.size=size;
            return this;
        }
    
        /**
         * 添加聚合查询
         * @param key 列名
         * @param aggregationType 查询类型
         * @param alias 别名
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param key
         * @param aggregationType
         * @param alias
         * @param index
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias,int index) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias,index);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param key
         * @param aggregationType
         * @param alias
         * @param isSort
         * @param isDesc
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias,boolean isSort, boolean isDesc) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias,isSort,isDesc);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param key
         * @param aggregationType
         * @param alias
         * @param index
         * @param isSort
         * @param isDesc
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias,int index,boolean isSort, boolean isDesc) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias,index,isSort,isDesc);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param key
         * @param aggregationType
         * @param alias
         * @param isSort
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias,boolean isSort) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias,isSort);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param key
         * @param aggregationType
         * @param alias
         * @param index
         * @param isSort
         * @return
         */
        public EsAggregationEntity addEsAggregations(String key, String aggregationType,String alias,int index,boolean isSort) {
            EsAggregation esAggregation =new EsAggregation(key,aggregationType,alias,index,isSort);
            if(this.esAggregations==null){
                this.esAggregations=new ArrayList<>();
            }
            this.esAggregations.add(esAggregation);
            return this;
        }
    
        /**
         *
         * @param esSearchEntity
         * @return
         */
        public EsAggregationEntity setEsSearchEntity(EsSearchEntity esSearchEntity) {
            this.esSearchEntity = esSearchEntity;
            return this;
        }
    }

## 5.1 聚合条件实体 ##

package com.iot.es.entity;
    
    import lombok.Getter;
    
    /**
     * 描述：聚合查询
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Getter
    public class EsAggregation {
        /**
         * key
         */
        private String key;
        /**
         * 聚合方式
         */
        private String aggregationType;
        /**
         * 别名
         */
        private String alias;
        /**
         * 排序
         */
        private int index=0;
        /**
         * 是否排序
         */
        private boolean isSort=false;
        /**
         * 是否降序排列
         */
        private boolean isDesc=true;
    
        protected EsAggregation(String key, String aggregationType,String alias,int index) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias=alias;
            this.index=index;
        }
        protected EsAggregation(String key, String aggregationType,String alias) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias=alias;
        }
    
        protected EsAggregation(String key, String aggregationType, String alias, boolean isSort, boolean isDesc) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias = alias;
            this.isSort = isSort;
            this.isDesc = isDesc;
        }
    
        protected EsAggregation(String key, String aggregationType, String alias, boolean isSort) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias = alias;
            this.isSort = isSort;
        }
    
        protected EsAggregation(String key, String aggregationType, String alias, int index, boolean isSort) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias = alias;
            this.index = index;
            this.isSort = isSort;
        }
    
        protected EsAggregation(String key, String aggregationType, String alias, int index, boolean isSort, boolean isDesc) {
            this.key = key;
            this.aggregationType = aggregationType;
            this.alias = alias;
            this.index = index;
            this.isSort = isSort;
            this.isDesc = isDesc;
        }
    }

# 6.编写配置实体（读取配置文件信息） #

package com.iot.es.properties;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    /**
     * 描述:配置文件类
     * @author: myx
     * @date: 2018/5/3
     * Copyright © 2018-hotpot. All rights reserved.
     */
    @ConfigurationProperties(prefix = "iot-es")
    @Data
    public class ESProperties {
        private String hostName;
        private String port;
        private String clusterName;
        private String poolSize;
    }

# 7.编写总配置类（初始化单例bean） #

package com.iot.es.config;
    
    import com.iot.es.properties.ESProperties;
    import com.iot.es.service.ESSearchService;
    import com.iot.es.service.IotEsTemplate;
    import org.elasticsearch.client.transport.TransportClient;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.transport.InetSocketTransportAddress;
    import org.elasticsearch.transport.client.PreBuiltTransportClient;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.net.InetAddress;
    
    /**
     * 描述: els快捷操作配置
     * @author: myx
     * @date: 2018/5/3
     * Copyright © 2018-hotpot. All rights reserved.
     */
    @Configuration//开启配置
    @EnableConfigurationProperties(ESProperties.class)//开启使用映射实体对象
    @ConditionalOnClass(ESSearchService.class)//存在ESSearchService时初始化该配置类
    @ConditionalOnProperty//存在对应配置信息时初始化该配置类
            (
                    prefix = "iot-es",//存在配置前缀hello
                    name = "isopen",
                    havingValue = "true",//开启
                    matchIfMissing = true//缺失检查
            )
    public class ESConfiguration{
        private Logger log = LoggerFactory.getLogger(this.getClass());
        @Autowired
        private ESProperties esProperties;
        /**
         * 根据条件判断不存在ElsService时初始化新bean到SpringIoc
         * @return
         */
        @Bean//创建HelloService实体bean
        @ConditionalOnMissingBean(ESSearchService.class)//缺失HelloService实体bean时，初始化HelloService并添加到SpringIoc
        public ESSearchService eSSearchService()
                throws Exception{
            log.info(">>>The ESSearchService Not Found，Execute Creat New Bean.");
            ESSearchService eSSearchService = new ESSearchService();
            // 配置信息
            Settings esSetting = Settings.builder().put("cluster.name", esProperties.getClusterName()).put("client.transport.sniff", true)// 增加嗅探机制，找到ES集群
                    .put("thread_pool.search.size", Integer.parseInt(esProperties.getPoolSize()))// 增加线程池个数，暂时设为5
                    .build();
    
            TransportClient client = new PreBuiltTransportClient(esSetting);
            InetSocketTransportAddress inetSocketTransportAddress = new InetSocketTransportAddress(InetAddress.getByName(esProperties.getHostName()), Integer.valueOf(esProperties.getPort()));
            client.addTransportAddresses(inetSocketTransportAddress);
            eSSearchService.setClient(client);
            return eSSearchService;
        }
    
    
        /**
         * 根据条件判断不存在ElsService时初始化新bean到SpringIoc
         * @return
         */
        @Bean//创建HelloService实体bean
        @ConditionalOnMissingBean(IotEsTemplate.class)//缺失HelloService实体bean时，初始化HelloService并添加到SpringIoc
        public IotEsTemplate iotEsTemplate()
                throws Exception{
            log.info(">>>The ESSearchService Not Found，Execute Creat New Bean.");
            IotEsTemplate iotEsTemplate = new IotEsTemplate();
            // 配置信息
            Settings esSetting = Settings.builder().put("cluster.name", esProperties.getClusterName()).put("client.transport.sniff", true)// 增加嗅探机制，找到ES集群
                    .put("thread_pool.search.size", Integer.parseInt(esProperties.getPoolSize()))// 增加线程池个数，暂时设为5
                    .build();
    
            TransportClient client = new PreBuiltTransportClient(esSetting);
            InetSocketTransportAddress inetSocketTransportAddress = new InetSocketTransportAddress(InetAddress.getByName(esProperties.getHostName()), Integer.valueOf(esProperties.getPort()));
            client.addTransportAddresses(inetSocketTransportAddress);
            iotEsTemplate.setClient(client);
            return iotEsTemplate;
        }
    
    }

# 8.编写es操作类（核心） #

package com.iot.es.service;
    
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.json.JSONArray;
    import cn.hutool.json.JSONUtil;
    import com.iot.es.constant.EsConstant;
    import com.iot.es.entity.*;
    import lombok.Data;
    import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
    import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
    import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
    import org.elasticsearch.action.bulk.BulkItemResponse;
    import org.elasticsearch.action.bulk.BulkRequestBuilder;
    import org.elasticsearch.action.bulk.BulkResponse;
    import org.elasticsearch.action.delete.DeleteResponse;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.action.search.SearchRequestBuilder;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.action.update.UpdateRequest;
    import org.elasticsearch.action.update.UpdateResponse;
    import org.elasticsearch.client.transport.TransportClient;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.index.query.RangeQueryBuilder;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.aggregations.Aggregation;
    import org.elasticsearch.search.aggregations.AggregationBuilders;
    import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
    import org.elasticsearch.search.aggregations.bucket.terms.Terms;
    import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.avg.AvgAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.avg.InternalAvg;
    import org.elasticsearch.search.aggregations.metrics.max.InternalMax;
    import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.min.InternalMin;
    import org.elasticsearch.search.aggregations.metrics.min.MinAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.sum.InternalSum;
    import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
    import org.elasticsearch.search.sort.SortOrder;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.*;
    
    /**
     * 描述：操作es工具类
     * @author: ruikanwang
     * @date: 2017/11/16 0016 13:02
     * @version: V1.0
     */
    @Data
    public class IotEsTemplate {
        private Logger log = LoggerFactory.getLogger(this.getClass());
        /**
         * 客户端
         */
        private TransportClient client;
        /**
         * 判断索引是否存在
         * @return
         */
        public boolean isIndexExist(String index) {
            if(StrUtil.isEmpty(index)){
                log.error("查询索引：Index is null");
            }
            IndicesExistsResponse iep = client.admin().indices().exists(new IndicesExistsRequest(index)).actionGet();
            return iep.isExists();
        }
        /**
         * 创建索引
         * @param index
         * @return
         */
        public boolean buildIndex(String index) {
            if (isIndexExist(index)) {
                log.error("Index is exits!");
            }
            CreateIndexResponse buildIndexresponse = client.admin().indices().prepareCreate(index).execute().actionGet();
            log.info(" 创建索引的标志: " + buildIndexresponse.isAcknowledged());
            return buildIndexresponse.isAcknowledged();
        }
        /**
         * 删除索引
         * @param index
         * @return
         */
        public boolean deleteIndex(String index) {
            if (!isIndexExist(index)) {
                log.error("删除索引 索引不存在 ！！！！！!");
            }
            DeleteIndexResponse diResponse = client.admin().indices().prepareDelete(index).execute().actionGet();
            if (diResponse.isAcknowledged()) {
                log.info("删除索引**成功** index->>>>>>>" + index);
            } else {
                log.error("删除索引**失败** index->>>>> " + index);
            }
            return diResponse.isAcknowledged();
        }
    
        /**
         * 添加数据
         *  data  添加的数据类型 json格式的
         *  index 索引<----->关系型数据库
         *  type  类型<----->关系型数据表
         *  id    数据ID<----->id
         * @return
         */
        public String addEsData(EsOtherEntity esOtherEntity) {
            //正式添加数据进去
            IndexResponse response = client.prepareIndex(esOtherEntity.getIndex(), esOtherEntity.getType(), esOtherEntity.getEsId()).setSource(esOtherEntity.getJsonObj()).get();
            log.info("addEsData 添加数据的状态:{}"+response.status().getStatus());
            return response.getId();
        }
    
        /**
         * 批量添加数据
         * @param esOtherEntity
         * @return
         */
        public void addEsDataBatch(EsOtherEntity esOtherEntity) {
            BulkRequestBuilder bulkRequest = client.prepareBulk();
            JSONArray jsonObjList = esOtherEntity.getJsonObjList();
            for (Object o : jsonObjList) {
                bulkRequest.add(client.prepareIndex(esOtherEntity.getIndex(), esOtherEntity.getType(),null).setSource(JSONUtil.parseObj(o)));
            }
            //正式添加数据进去
            BulkResponse bulkResponse = bulkRequest.get();
            log.info("addEsDataBatch 添加数据的状态:{}"+bulkResponse.status().getStatus());
        }
        /**
         * 通过ID删除数据
         *  index 索引，类似数据库
         *  type  类型，类似表
         *  id    数据ID
         */
        public void delEsDataById(EsOtherEntity esOtherEntity) {
            if(esOtherEntity.getIndex() == null || esOtherEntity.getType() == null || esOtherEntity.getEsId() == null) {
                log.error(" 无法删除数据，缺唯一值!!!!!!! ");
                return;
            }
            //开始删除数据
            DeleteResponse response = client.prepareDelete(esOtherEntity.getIndex(), esOtherEntity.getType(), esOtherEntity.getEsId()).execute().actionGet();
            log.info("删除数据状态，status-->>>>{},"+response.status().getStatus());
        }
        /**
         * 查询删除
         * @param esOtherEntity
         */
        public void delEsDataBySearch(EsOtherEntity esOtherEntity){
            BulkRequestBuilder bulkRequest = client.prepareBulk();
            EsSearchEntity esSearchEntity = esOtherEntity.getEsSearchEntity();
            SearchResponse response = searchResponse(esSearchEntity.index(esOtherEntity.getIndex()).type(esOtherEntity.getType()));
            if(response.getHits().getTotalHits()==0){
                log.error("查询删除数据为空,无法删除！！");
                return;
            }
            for(SearchHit hit : response.getHits()){
                String id = hit.getId();
                bulkRequest.add(client.prepareDelete(esOtherEntity.getIndex(), esOtherEntity.getType(), id).request());
            }
            BulkResponse bulkResponse = bulkRequest.get();
            if (bulkResponse.hasFailures()) {
                for(BulkItemResponse item : bulkResponse.getItems()){
                    log.error("查询删除异常："+item.getFailureMessage());
                }
            }else {
                log.info("查询删除成功");
            }
        }
    
        /**
         * 更新数据
         *
         * data  添加的数据类型 json格式的
         * index 索引<----->关系型数据库
         * type  类型<----->关系型数据表
         * id    数据ID<----->id
         * @return
         */
        public void updateEsDataById(EsOtherEntity esOtherEntity) {
            if(esOtherEntity.getIndex() == null || esOtherEntity.getType() == null || esOtherEntity.getEsId() == null) {
                log.error(" 无法更新数据，缺唯一值!!!!!!! ");
                return;
            }
            //更新步骤
            UpdateRequest up = new UpdateRequest();
            up.index(esOtherEntity.getIndex()).type(esOtherEntity.getType()).id(esOtherEntity.getEsId()).doc(esOtherEntity.getJsonObj());
            //获取响应信息
            //.actionGet(timeoutMillis)，也可以用这个方法，当过了一定的时间还没得到返回值的时候，就自动返回。
            UpdateResponse response = client.update(up).actionGet();
            log.info("更新数据状态信息，status{}"+response.status().getStatus());
        }
    
        /**
         * 查询更新数据
         * data  添加的数据类型 json格式的
         * index 索引<----->关系型数据库
         * type  类型<----->关系型数据表
         * id    数据ID<----->id
         * @return
         */
        public void updateEsDataBySearch(EsOtherEntity esOtherEntity) {
            BulkRequestBuilder bulkRequest = client.prepareBulk();
            EsSearchEntity esSearchEntity = esOtherEntity.getEsSearchEntity();
            SearchResponse response = searchResponse(esSearchEntity.index(esOtherEntity.getIndex()).type(esOtherEntity.getType()));
            if(response.getHits().getTotalHits()==0){
                log.error("查询更新数据为空,无法更新！！");
                return;
            }
            for(SearchHit hit : response.getHits()){
                String id = hit.getId();
                bulkRequest.add(client.prepareUpdate(esOtherEntity.getIndex(),esOtherEntity.getType(), id).setDoc(esOtherEntity.getJsonObj()));
            }
            BulkResponse bulkResponse = bulkRequest.get();
            if (bulkResponse.hasFailures()) {
                for(BulkItemResponse item : bulkResponse.getItems()){
                    log.error("查询更新异常："+item.getFailureMessage());
                }
            }else {
                log.info("查询更新成功");
            }
        }
    
    
        /**
         * 查询文档
         * @param esSearchEntity
         * @return
         * @throws Exception
         */
        public SearchResponse searchResponse(EsSearchEntity esSearchEntity) {
            SearchRequestBuilder srb = getSearchRequestBuilder(esSearchEntity);
            if(srb==null){
                return null;
            }
            SearchResponse sr = srb.execute().actionGet();
            return sr;
        }
    
        /**
         * 封装查询条件
         * @param esSearchEntity
         * @return
         */
        private SearchRequestBuilder getSearchRequestBuilder(EsSearchEntity esSearchEntity){
            if (!isIndexExist(esSearchEntity.getIndex())) {
                log.error("Index is not exits!");
                return null;
            }
            SearchRequestBuilder srb = client.prepareSearch(esSearchEntity.getIndex()).setTypes(esSearchEntity.getType());
            BoolQueryBuilder bb = QueryBuilders.boolQuery();
            //获取查询条件
            List<EsCondition> esConditionList = esSearchEntity.getEsConditionList();
            if (esConditionList != null) {
                for (EsCondition esCondition : esConditionList) {
                    //判断查询类型
                    switch (esCondition.getQueryType()) {
                        case EsConstant.QUERY_TYPE_EXISTS://字段必须存在
                            QueryBuilder queryBuilderExists = QueryBuilders.existsQuery(esCondition.getKey());
                            bb = bb.must(queryBuilderExists);
                            break;
                        case EsConstant.QUERY_TYPE_NOTEXISTS://字段不存在
                            QueryBuilder queryBuilderNotExists = QueryBuilders.existsQuery(esCondition.getKey());
                            bb = bb.mustNot(queryBuilderNotExists);
                            break;
                        case EsConstant.QUERY_TYPE_IS://精确匹配
                            QueryBuilder queryBuilderIs = QueryBuilders.matchQuery(esCondition.getKey(), esCondition.getValue());
                            bb = bb.must(queryBuilderIs);
                            //searchRequestBuilder.setQuery(queryBuilderIs);
                            break;
                        case EsConstant.QUERY_TYPE_PREFIX://前缀查询
                            QueryBuilder queryBuilderPrefix = QueryBuilders.prefixQuery(esCondition.getKey(), esCondition.getValue().toString());
                            bb = bb.filter(queryBuilderPrefix);
                            break;
                        case EsConstant.QUERY_TYPE_WILDCARD://通配符查询
                            QueryBuilder queryBuilderWildcard = QueryBuilders.wildcardQuery(esCondition.getKey(), esCondition.getValue().toString());
                            bb = bb.filter(queryBuilderWildcard);
                            break;
                        case EsConstant.QUERY_TYPE_FUZZY://模糊匹配
                            QueryBuilder queryBuilderFuzzy = QueryBuilders.fuzzyQuery(esCondition.getKey(), esCondition.getValue());
                            bb = bb.filter(queryBuilderFuzzy);
                            //searchRequestBuilder.setQuery(queryBuilderIs);
                            break;
                        case EsConstant.QUERY_TYPE_REGEXP://正则匹配
                            QueryBuilder queryBuilderRegexp = QueryBuilders.regexpQuery(esCondition.getKey(), esCondition.getValue().toString());
                            bb = bb.filter(queryBuilderRegexp);
                            //searchRequestBuilder.setQuery(queryBuilderIs);
                            break;
                        case EsConstant.QUERY_TYPE_LT://小于
                            QueryBuilder queryBuilderLt = QueryBuilders.rangeQuery(esCondition.getKey()).lt(esCondition.getValue());
                            bb = bb.filter(queryBuilderLt);
                            //searchRequestBuilder.setQuery(queryBuilderLt);
                            break;
                        case EsConstant.QUERY_TYPE_GT://大于
                            QueryBuilder queryBuilderGt = QueryBuilders.rangeQuery(esCondition.getKey()).gt(esCondition.getValue());
                            bb = bb.filter(queryBuilderGt);
                            break;
                        case EsConstant.QUERY_TYPE_RANGE://范围查询
                            RangeQueryBuilder to = QueryBuilders.rangeQuery(esCondition.getKey()).from(esCondition.getValue()).to(esCondition.getValue2());
                            bb = bb.filter(to);
                            break;
                    }
                }
                srb.setQuery(bb);
            }
            if (esSearchEntity.getEsPage() != null) {
                srb.setFrom(esSearchEntity.getEsPage().getFrom()).setSize(esSearchEntity.getEsPage().getPageSize());
            }
            if (esSearchEntity.getEsSort() != null) {
                srb.addSort(esSearchEntity.getEsSort().getSortKey(), esSearchEntity.getEsSort().isSortDesc() ? SortOrder.DESC : SortOrder.ASC);
            }
            return srb;
        }
    
        /**
         * 查询list
         * @param esSearchEntity
         * @return
         */
        public EsSearchResult searchList(EsSearchEntity esSearchEntity) {
            EsSearchResult esSearchResult =new EsSearchResult();
            SearchResponse searchResponse = searchResponse(esSearchEntity);
            EsPage esPage = esSearchEntity.getEsPage()==null?new EsPage(1,10):esSearchEntity.getEsPage();
            long totalHits = searchResponse.getHits().getTotalHits();
            esPage.setTotalRecord(totalHits);
            esSearchResult.setEsPage(esPage);
            List<Map<String,Object>> list=new ArrayList<>();
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) {
                list.add(hit.getSourceAsMap());
            }
            esSearchResult.setList(list);
            return esSearchResult;
        }
    
        /**
         * 查询第一个(结合排序使用)
         * @param esSearchEntity
         * @return
         */
        public Map<String,Object> searchFirst(EsSearchEntity esSearchEntity) {
            SearchResponse searchResponse = searchResponse(esSearchEntity);
            SearchHit[] hits = searchResponse.getHits().getHits();
            Map<String,Object> map =null;
            if(hits.length>0){
                map=hits[0].getSourceAsMap();
            }
            return map;
        }
    
        /**
         * 聚合查询
         * @param esAggregationEntity
         * @return
         */
        public SearchResponse searchAggregation(EsAggregationEntity esAggregationEntity) {
            EsSearchEntity esSearchEntity= esAggregationEntity.getEsSearchEntity();
            esSearchEntity.index(esAggregationEntity.getIndex());
            esSearchEntity.type(esAggregationEntity.getType());
            SearchRequestBuilder srb = getSearchRequestBuilder(esSearchEntity);
            if(srb==null){
                return null;
            }
            List<EsAggregation> esAggregations=esAggregationEntity.getEsAggregations();
            //寻找主分组
            EsAggregation mainAggregation =null;
            for (EsAggregation esAggregation : esAggregations) {
                if(esAggregation.getAggregationType().equals(EsConstant.AGGREGATION_TYPE_GROUPBY)&&
                        esAggregation.getIndex()==0){
                    mainAggregation=esAggregation;
                }
            }
            if(mainAggregation==null){
                log.error("分组条件不能为空！！！");
                return null;
            }
            esAggregations.remove(mainAggregation);
            TermsAggregationBuilder mainAgg= AggregationBuilders.terms(mainAggregation.getAlias()).field(mainAggregation.getKey());
            for (EsAggregation esAggregation : esAggregations) {
                switch (esAggregation.getAggregationType()){
                    case EsConstant.AGGREGATION_TYPE_GROUPBY:
                        TermsAggregationBuilder groupAgg= AggregationBuilders.terms(esAggregation.getAlias()).field(esAggregation.getKey());
                        mainAgg.subAggregation(groupAgg);
                        break;
                    case EsConstant.AGGREGATION_TYPE_AVG:
                        AvgAggregationBuilder avgAggregationBuilder=AggregationBuilders.avg(esAggregation.getAlias()).field(esAggregation.getKey());
                        mainAgg.subAggregation(avgAggregationBuilder);
                        break;
                    case EsConstant.AGGREGATION_TYPE_MAX:
                        MaxAggregationBuilder maxAggregationBuilder= AggregationBuilders.max(esAggregation.getAlias()).field(esAggregation.getKey());
                        mainAgg.subAggregation(maxAggregationBuilder);
                        break;
                    case EsConstant.AGGREGATION_TYPE_MIN:
                        MinAggregationBuilder minAggregationBuilder=AggregationBuilders.min(esAggregation.getAlias()).field(esAggregation.getKey());
                        mainAgg.subAggregation(minAggregationBuilder);
                        break;
                    case EsConstant.AGGREGATION_TYPE_SUM:
                        SumAggregationBuilder sumAggregationBuilder=AggregationBuilders.sum(esAggregation.getAlias()).field(esAggregation.getKey());
                        mainAgg.subAggregation(sumAggregationBuilder);
                        break;
                }
            }
            //获取分组后的排序
            for (EsAggregation esAggregation : esAggregations) {
                if(esAggregation.isSort()){
                    mainAgg.order(Terms.Order.aggregation(esAggregation.getAlias(),esAggregation.isDesc()?false:true));
                }
            }
            mainAgg.size(esAggregationEntity.getSize());
            srb.addAggregation(mainAgg);
            SearchResponse response = srb.execute().actionGet();
            return response;
        }
    
    
        /**
         * 聚合查询数据
         * @param esAggregationEntity
         * @return
         */
        public List<Map<String,Object>> searchAggregationList(EsAggregationEntity esAggregationEntity) {
            List<Map<String,Object>> list =new ArrayList<>();
            EsAggregation mainAggregation =null;
            for (EsAggregation esAggregation : esAggregationEntity.getEsAggregations()) {
                if(esAggregation.getAggregationType().equals(EsConstant.AGGREGATION_TYPE_GROUPBY)&&
                        esAggregation.getIndex()==0){
                    mainAggregation=esAggregation;
                }
            }
            if(mainAggregation==null){
                log.error("分组条件不能为空！！！");
                return null;
            }
            SearchResponse response=searchAggregation(esAggregationEntity);
            Map<String, Aggregation> aggMap=response.getAggregations().asMap();
            StringTerms teamAgg= (StringTerms) aggMap.get(mainAggregation.getAlias());
            Iterator<StringTerms.Bucket> teamBucketIt =teamAgg.getBuckets().iterator();
            while (teamBucketIt .hasNext()) {
                Map<String,Object> map =new HashMap<>();
                StringTerms.Bucket buck = teamBucketIt.next();
                //主分组值
                String team = (String)buck.getKey();
                //记录数
                long count = buck.getDocCount();
                map.put(mainAggregation.getKey(),team);
                map.put(mainAggregation.getAggregationType(),count);
                //得到所有子聚合
                Map subaggmap = buck.getAggregations().asMap();
                for (EsAggregation esAggregation : esAggregationEntity.getEsAggregations()) {
                    if(esAggregation.getAggregationType().equals(EsConstant.AGGREGATION_TYPE_GROUPBY)&&
                            esAggregation.getIndex()==0){
                    }else{
                        Object o = subaggmap.get(esAggregation.getAlias());
                        switch (esAggregation.getAggregationType()){
                            case EsConstant.AGGREGATION_TYPE_GROUPBY:
                                break;
                            case EsConstant.AGGREGATION_TYPE_AVG:
                                map.put(esAggregation.getAlias(),((InternalAvg)o).getValue());
                                break;
                            case EsConstant.AGGREGATION_TYPE_MAX:
                                map.put(esAggregation.getAlias(),((InternalMax)o).getValue());
                                break;
                            case EsConstant.AGGREGATION_TYPE_MIN:
                                map.put(esAggregation.getAlias(),((InternalMin)o).getValue());
                                break;
                            case EsConstant.AGGREGATION_TYPE_SUM:
                                map.put(esAggregation.getAlias(),((InternalSum)o).getValue());
                                break;
                        }
                    }
                }
                list.add(map);
            }
            return list;
        }
    }

# 9.在resource/WEB-INF创建spring.factories #

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.iot.es.config.ESConfiguration

# ***更多springboot相关知识关注博客\[持续更新\]*** #

[springboot教程目录][springboot]

[springboot_Starter]: https://blog.csdn.net/qq_31463999/article/details/81628891
[springboot]: https://blog.csdn.net/qq_31463999/article/details/81627799