实现自己的SpringBoot starter

超、凢脫俗 2021-09-17 08:18 295阅读 0赞

在学习Spring Boot的过程中，接触最多的就是starter。可以认为starter是一种服务——使得使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，由Spring Boot自动通过classpath路径下的类发现需要的Bean，并织入bean。

本篇将通过一个简单的例子来演示如何编写自己的starter。

Starter要实现的功能，很简单，提供一个Service，包含一个能够将字符串加上前后缀的方法String wrap(String word)。而具体的前缀和后缀是通过读取SpringBoot配置文件而获取的。

这里说下artifactId的命名问题，Spring 官方 Starter通常命名为 `spring-boot-starter-{name} `如 `spring-boot-starter-web。`Spring官方建议非官方Starter命名应遵循 `{name}-spring-boot-starter `的格式。

添加必须的maven依赖：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>

注意其中 `spring-boot-configuration-processor `的作用是编译时生成 `spring-configuration-metadata.json `，此文件主要给IDE使用，用于提示使用。

本例讲解的是封装一个自定义的elasticsearch的start，因此还有添加必须的业务jar,完整的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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.ganinfo</groupId>
        <artifactId>elastic-spring-boot-starter</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
            <boot.processor.version>1.4.3.RELEASE</boot.processor.version>
            <boot.version>2.0.4.RELEASE</boot.version>
            <elasticsearch.version>5.6.1</elasticsearch.version>
            <google.gson.version>2.8.5</google.gson.version>
            <lombok.version>1.16.20</lombok.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
                <version>${boot.processor.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <version>${boot.processor.version}</version>
                <optional>true</optional>
            </dependency>
    
            
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>x-pack-transport</artifactId>
                <version>${elasticsearch.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${boot.version}</version>
                <optional>true</optional>
            </dependency>
    
            
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>${google.gson.version}</version>
                <optional>true</optional>
            </dependency>
    
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>1.5.10.RELEASE</version>
                    <configuration>
                        <skip>true</skip>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

属性类：

package com.ganinfo.elastic.config;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    /**
     * @package:com.ganinfo.elastic
     * @className:ElasticProperties
     * @description:
     * @author:Shuyu.Wang
     * @date:2018-12-09 22:06
     * @version:V1.0
     **/
    
    @ConfigurationProperties(prefix="ganinfo.elastic")
    @Data
    public class ElasticProperties {
        /**
         * @Field： 服务器地址
         */
        private String host;
        /**
         * @Field：端口
         */
        private int port;
        /**
         * @Field：节点名
         */
        private String clusterName;
    }

本例提供两个service类，分别是连接池的ClientHelper和提供接口服务的ESService；

package com.ganinfo.elastic;
    
    import com.ganinfo.elastic.config.ElasticProperties;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    import com.ganinfo.elastic.constant.ESConstant;
    import lombok.extern.slf4j.Slf4j;
    import org.elasticsearch.client.Client;
    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.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @package:com.ganinfo.elastic
     * @className:ClientHelper
     * @description:
     * @author:Shuyu.Wang
     * @date:2018-12-09 22:19
     * @version:V1.0
     **/
    @Slf4j
    public class ClientHelper {
    
        private ElasticProperties elasticProperties;
    
        public ClientHelper() {
        }
    
        public ClientHelper(ElasticProperties elasticProperties) {
            super();
            this.elasticProperties = elasticProperties;
        }
    
        private Settings setting;
    
        private ConcurrentHashMap<String, TransportClient> clientMap = new ConcurrentHashMap<String, TransportClient>();
    
        private Map<String, Integer> ips = new HashMap<String, Integer>();
    
        public static final ClientHelper getInstance() {
            return ClientHolder.INSTANCE;
        }
    
        private static class ClientHolder {
            private static final ClientHelper INSTANCE = new ClientHelper();
        }
    
        /**
         * @author:shuyu.wang
         * @description:初始化默认的client
         * @date: 2018/12/3 22:20
         * @param: null
         * @return: null
         */
        private void init() {
            log.info("host:" + elasticProperties.getHost());
            log.info("clusterName:" + elasticProperties.getClusterName());
            if (elasticProperties.getHost().contains(",")) {
                String[] split = elasticProperties.getHost().split(",");
                for (String ip : split) {
                    ips.put(ip, elasticProperties.getPort());
                }
            } else {
                ips.put(elasticProperties.getHost(), elasticProperties.getPort());
            }
            setting = Settings.builder().put(ESConstant.CLUSTER_NAME_STRING, elasticProperties.getClusterName()).put(ESConstant.CLIENT_TRANSPORT_SNIFF_STRING, true).build();
            addClient(setting, ips);
        }
    
        /**
         * @author:shuyu.wang
         * @description:获得所有的地址端口
         * @date: 2018/12/3 22:20
         * @param: ips
         * @return: null
         */
        private List<InetSocketTransportAddress> getAllAddress(Map<String, Integer> ips) {
            List<InetSocketTransportAddress> addressList = new ArrayList<InetSocketTransportAddress>();
            for (String ip : ips.keySet()) {
                try {
                    addressList.add(new InetSocketTransportAddress(InetAddress.getByName(ip), Integer.valueOf(ips.get(ip).toString())));
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
            }
            return addressList;
        }
    
        /**
         * @author:shuyu.wang
         * @description:获得client连接
         * @date: 2018/12/3 22:20
         * @param: null
         * @return: Client
         */
        public Client getClient() {
            if ((clientMap != null && !clientMap.isEmpty()) || (ips != null && !ips.isEmpty())) {
                init();
            }
            return getClient(elasticProperties.getClusterName());
        }
    
        /**
         * @author:shuyu.wang
         * @description:获得client连接
         * @date: 2018/12/3 22:20
         * @param: clusterName
         * @return: Client
         */
        public Client getClient(String clusterName) {
            if (clientMap == null || clientMap.isEmpty()) {
                init();
            }
            return clientMap.get(clusterName);
        }
    
        /**
         * @author:shuyu.wang
         * @description:建立client连接
         * @date: 2018/12/3 22:20
         * @param: clusterName
         * @return: Client
         */
        private void addClient(Settings setting, Map<String, Integer> ips) {
            TransportClient client = null;
            for (String ip : ips.keySet()) {
                try {
                    client = new PreBuiltTransportClient(setting).addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), Integer.valueOf(ips.get(ip).toString())));
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
            }
            if (client != null) {
                clientMap.put(setting.get(ESConstant.CLUSTER_NAME_STRING), client);
            }
    
        }
    }

/**
     * @package:com.ganinfo.elasticsearch
     * @className:ESQueryParams
     * @description:ESService
     * @author:Shuyu.Wang
     * @date:2018-12-03 22:13
     * @version:V1.0
     * @NOTICE：本内容仅限于新疆感知科技有限公司内部传阅,禁止外泄以及用于其他的商业目
     * @ Copyright © 2017-ganinfo. All rights reserved.
     **/
    public interface ESService {
    
        /**
         * @param index 索引
         * @param type  类型
         * @param obj   插入的对象
         * @author:shuyu.wang
         * @description:新增接口
         * @date: 2018/3/29 10:20
         * @return: Boolean
         */
        Boolean add(String index, String type, Object obj);
    
        /**
         * @param index           索引
         * @param type            类型
         * @param id
         * @param xContentBuilder 更新内容
         * @author:shuyu.wang
         * @description:更新接口
         * @date: 2018/4/9 12:05
         * @return: Boolean
         */
        Boolean update(String index, String type, String id, XContentBuilder xContentBuilder);
    
        /**
         * @param index        索引
         * @param type         类型
         * @param queryBuilder 拼接的查询条件
         * @param sort         排序字段，默认降序
         * @param from         起始记录位置
         * @param size         返回条数
         * @author:shuyu.wang
         * @description:查询接口
         * @date: 2018/3/29 10:33
         * @return: ESReturn<List<Map<String,Object>>>
         */
        ESReturn<List<Map<String, Object>>> query(String index, String type, QueryBuilder queryBuilder, String sort, Integer from, Integer size);
    
        /**
         * @param esQueryParams
         * @author:shuyu.wang
         * @description:es查询封装
         * @date: 2018/5/22 18:22
         * @return: ESReturn<List<Map<String,Object>>>
         */
        ESReturn<List<Map<String, Object>>> queryES(ESQueryParams esQueryParams);
    
    
        /**
         * @param index   索引
         * @param type    类型
         * @param id
         * @param jsonDoc json串数据
         * @author:shuyu.wang
         * @description:es查询封装
         * @date: 2018/5/22 18:22
         * @return: Boolean
         */
        Boolean updateES(String index, String type, String id, String jsonDoc);
    
    }

package com.ganinfo.elastic;
    
    import com.ganinfo.elastic.config.ElasticProperties;
    import com.ganinfo.elastic.service.ESService;
    import com.ganinfo.elastic.service.impl.ESServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    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 javax.sql.DataSource;
    
    /**
     * @package:com.ganinfo.elastic
     * @className:
     * @description:
     * @author:Shuyu.Wang
     * @date:2018-12-09 22:34
     * @version:V1.0
     **/
    @Configuration // 配置注解
    @EnableConfigurationProperties(ElasticProperties.class) // 开启指定类的配置
    @ConditionalOnClass(ClientHelper.class)// 当PersonService这个类在类路径中时，且当前容器中没有这个Bean的情况下，开始自动配置
    @ConditionalOnProperty(prefix = "ganinfo.elastic", value = "enabled", matchIfMissing = true)// 指定的属性是否有指定的值
    public class ElasticAutoConfiguration {
        @Autowired
        private ElasticProperties elasticProperties;
    
        @Bean("clientHelper")
        @ConditionalOnMissingBean(ClientHelper.class)// 当容器中没有指定Bean的情况下，自动配置PersonService类
        public ClientHelper getClientHelper() {
            ClientHelper cientHelper = new ClientHelper(elasticProperties);
            return cientHelper;
        }
    
    
        @Bean
        @ConditionalOnMissingBean(ESService.class)// 当容器中没有指定Bean的情况下，自动配置PersonService类
        public ESService getESService(@Qualifier("clientHelper") ClientHelper clientHelper) {
            ESServiceImpl esService = new ESServiceImpl(clientHelper);
            return esService;
        }
    }

其他辅助类：

package com.ganinfo.elastic.service.impl;
    
    
    import com.ganinfo.elastic.ClientHelper;
    import com.ganinfo.elastic.constant.ESConstant;
    import com.ganinfo.elastic.po.ESQueryParams;
    import com.ganinfo.elastic.po.ESReturn;
    import com.ganinfo.elastic.po.RangeEntity;
    import com.ganinfo.elastic.service.ESService;
    import com.ganinfo.elastic.util.CommonUtil;
    import com.google.gson.JsonObject;
    import lombok.extern.slf4j.Slf4j;
    import org.elasticsearch.action.bulk.BulkRequestBuilder;
    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.Client;
    import org.elasticsearch.common.xcontent.XContentBuilder;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.elasticsearch.index.query.*;
    import org.elasticsearch.rest.RestStatus;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.SearchHits;
    import org.elasticsearch.search.sort.SortBuilders;
    import org.elasticsearch.search.sort.SortOrder;
    import org.springframework.stereotype.Service;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ExecutionException;
    
    /**
     * @package:com.ganinfo.elasticsearch
     * @className:ESServiceImpl
     * @description:ES实现服务层
     * @author:Shuyu.Wang
     * @date:2018-12-03 22:13
     * @version:V1.0
     **/
    @Slf4j
    public class ESServiceImpl implements ESService {
    
        private ClientHelper clientHelper;
    
    
        public ESServiceImpl(ClientHelper clientHelper) {
            this.clientHelper=clientHelper;
        }
    
    
        @Override
        public Boolean add(String index, String type, Object obj) {
            JsonObject jsonObject = objToJson(obj);
            Client client = clientHelper.getClient();
            try {
                IndexResponse response = client.prepareIndex(index, type).setSource(jsonObject.toString(), XContentType.JSON).get();
                RestStatus status = response.status();
                int status1 = status.getStatus();
                log.info(">>>>>ES新增执行结果" + status1);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        @Override
        public Boolean update(String index, String type, String id, XContentBuilder xContentBuilder) {
            UpdateRequest updateRequest = new UpdateRequest();
            updateRequest.index(index);
            updateRequest.type(type);
            updateRequest.id(id);
            updateRequest.doc(xContentBuilder);
            Client client = clientHelper.getClient();
            try {
                UpdateResponse updateResponse = client.update(updateRequest).get();
                int status = updateResponse.status().getStatus();
                log.info(">>>>>ES更新执行结果：" + status);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        @Override
        public ESReturn<List<Map<String, Object>>> query(String index, String type, QueryBuilder queryBuilder, String sort, Integer from, Integer size) {
            ESReturn<List<Map<String, Object>>> esReturn = new ESReturn<List<Map<String, Object>>>();
            Client client = clientHelper.getClient();
            SearchRequestBuilder srb = client.prepareSearch(index).setTypes(type);
            SearchResponse sr = srb.setQuery(queryBuilder).setFrom(from).setSize(size).addSort(SortBuilders.fieldSort(sort).unmappedType("integer").order(SortOrder.DESC)).execute().actionGet(); // 分页排序所有
            long totalHits = sr.getHits().totalHits();
            esReturn.setTotal(totalHits);
            SearchHits hits = sr.getHits();
            List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
            for (SearchHit hit : hits) {
                Map<String, Object> map = (Map<String, Object>) hit.getSource();
                result.add(map);
            }
    //        log.info("返回结果：" + totalHits + "条数据");
            esReturn.setData(result);
            return esReturn;
        }
    
        public JsonObject objToJson(Object obj) {
            Field[] fields = obj.getClass().getDeclaredFields();
            JsonObject jsonObject = new JsonObject();
            for (int i = 0, len = fields.length; i < len; i++) {
                // 对于每个属性，获取属性名
                String varName = fields[i].getName();
                try {
                    // 获取原来的访问控制权限
                    boolean accessFlag = fields[i].isAccessible();
                    // 修改访问控制权限
                    fields[i].setAccessible(true);
                    // 获取在对象f中属性fields[i]对应的对象中的变量
                    Object o;
                    try {
                        o = fields[i].get(obj);
                        if (o != null) {
                            jsonObject.addProperty(varName, o.toString());
                        }
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                    // 恢复访问控制权限
                    fields[i].setAccessible(accessFlag);
                } catch (IllegalArgumentException ex) {
                    ex.printStackTrace();
                }
            }
            return jsonObject;
        }
    
        @Override
        public ESReturn<List<Map<String, Object>>> queryES(ESQueryParams esQueryParams) {
            ESReturn<List<Map<String, Object>>> esReturn = new ESReturn<List<Map<String, Object>>>();
            if (!CommonUtil.isNotNullEmpty(esQueryParams.getIndex())) {
                log.error(ESConstant.INDEX_NULL_STRING);
                return esReturn;
            }
            if (!CommonUtil.isNotNullEmpty(esQueryParams.getType())) {
                log.error(ESConstant.TYPE_NULL_STRING);
                return esReturn;
            }
            if (!CommonUtil.isNotNullEmpty(esQueryParams.getSort())) {
                log.error(ESConstant.SORT_NULL_STRING);
                return esReturn;
            }
            if (esQueryParams.getFrom() == null) {
                esQueryParams.setFrom(0);
            }
            if (esQueryParams.getSize() == null) {
                esQueryParams.setSize(10);
            }
            BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
            //完全不匹配查询
            if (CommonUtil.isNotMapNull(esQueryParams.getNoTermsList())) {
                for (String key : esQueryParams.getNoTermsList().keySet()) {
                    TermsQueryBuilder notTermsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getNoTermsList().get(key));
                    queryBuilder.mustNot(notTermsQueryBuilder);
                }
            }
            //完全匹配查询
            if (CommonUtil.isNotMapNull(esQueryParams.getTerms())) {
                for (String key : esQueryParams.getTerms().keySet()) {
                    TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getTerms().get(key));
                    queryBuilder.must(termsQueryBuilder);
                }
            }
            //完全匹配查询
            if (CommonUtil.isNotMapNull(esQueryParams.getTermsList())) {
                for (String key : esQueryParams.getTermsList().keySet()) {
                    TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getTermsList().get(key));
                    queryBuilder.must(termsQueryBuilder);
                }
            }
            //完全模糊查询
            if (CommonUtil.isNotMapNull(esQueryParams.getAllWildcards())) {
                for (String key : esQueryParams.getAllWildcards().keySet()) {
                    WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(key, "*" + esQueryParams.getAllWildcards().get(key) + "*");
                    queryBuilder.must(wildcardQueryBuilder);
                }
            }
    
            //右模糊查询
            if (CommonUtil.isNotMapNull(esQueryParams.getRightWildcards())) {
                for (String key : esQueryParams.getRightWildcards().keySet()) {
                    WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(key, esQueryParams.getRightWildcards().get(key) + "*");
                    queryBuilder.must(wildcardQueryBuilder);
                }
            }
            //范围查询
            if (CommonUtil.isNotMapNull(esQueryParams.getRanges())) {
                for (String key : esQueryParams.getRanges().keySet()) {
                    RangeEntity rangeEntity = (RangeEntity) esQueryParams.getRanges().get(key);
                    if (CommonUtil.isNotNullEmpty(rangeEntity.getFrom()) && CommonUtil.isNotNullEmpty(rangeEntity.getTo())) {
                        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key).from(rangeEntity.getFrom(), true).to(rangeEntity.getTo(), true);// 包含上届
                        queryBuilder.must(rangeQueryBuilder);
                    }
    
                    if (CommonUtil.isNotNullEmpty(rangeEntity.getFrom()) && !CommonUtil.isNotNullEmpty(rangeEntity.getTo())) {
                        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key).from(rangeEntity.getFrom(), true);// 包含上届
                        queryBuilder.must(rangeQueryBuilder);
                    }
                }
            }
            //判断字段非空
            if (CommonUtil.isNotListNull(esQueryParams.getExistsFiles())) {
                for (String name : esQueryParams.getExistsFiles()) {
                    queryBuilder.must(QueryBuilders.existsQuery(name));
                }
            }
    //        log.info("ES查询条件>>>" + GsonUtil.GsonString(queryBuilder));
            Client client = clientHelper.getClient();
            SearchRequestBuilder srb = client.prepareSearch(esQueryParams.getIndex()).setTypes(esQueryParams.getType());
            SearchResponse sr = srb.setQuery(queryBuilder).setFrom(esQueryParams.getFrom()).setSize(esQueryParams.getSize()).addSort(SortBuilders.fieldSort(esQueryParams.getSort()).unmappedType("integer").order(SortOrder.DESC)).execute().actionGet(); // 分页排序所有
            long totalHits = sr.getHits().totalHits();
            esReturn.setTotal(totalHits);
            SearchHits hits = sr.getHits();
            List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
            for (SearchHit hit : hits) {
                Map<String, Object> map = (Map<String, Object>) hit.getSource();
                map.put(ESConstant.ES_ID_STRING, hit.getId());
                result.add(map);
            }
    //        log.info("ES查询结果：" +esReturn.getTotal()+"条数据");
            esReturn.setData(result);
            return esReturn;
        }
    
        /**
         * @param index
         * @param type
         * @param jsonDoc json串数据  @author:shuyu.wang
         * @description:es查询封装
         * @date: 2018/5/22 18:22
         */
        @Override
        public Boolean updateES(String index, String type, String id, String jsonDoc) {
            Client client = clientHelper.getClient();
            BulkRequestBuilder prepareBulk = client.prepareBulk();
            UpdateResponse updateResponse = client.prepareUpdate(index, type, id).setDoc(jsonDoc, XContentType.JSON).get();
            RestStatus status = updateResponse.status();
            if (status.name().equals(ESConstant.OK_STRING)) {
    //            log.info("處理狀態—————————" + status.name());
                return true;
            }
            return false;
        }
    }

public class ESConstant {
    
        public static final String CLUSTER_NAME_STRING="cluster.name";
    
        public static final String CLIENT_TRANSPORT_SNIFF_STRING="client.transport.sniff";
    
        public static final String INDEX_NULL_STRING="索引不能为空！";
    
        public static final String TYPE_NULL_STRING="类型不能为空！";
    
        public static final String SORT_NULL_STRING="排序字段不能为空！";
    
        public static final String ES_ID_STRING="es_id";
    
        public static final String OK_STRING="OK";
    }

@Data
    public class ESReturn<T> {
    
        /**
         * @Field： Result data
         */
        private T data;
        /**
         * @Field：Total item size
         */
        private long total;
    
    }

@Data
    public class ESQueryParams {
        /**
        * @Field：索引
        */
        private String index;
        /**
         * @Field：类型
         */
        private String type;
        /**
         * @Field：完全匹配字段
         */
        private Map<String,String> terms;
        /**
         * @Field：完全不匹配字段
         */
        private Map<String,List<String>> noTermsList;
        /**
         * @Field：右模糊查询
         */
        private Map<String,String> rightWildcards;
        /**
         * @Field：完全模糊查询
         */
        private Map<String,String> allWildcards;
        /**
         * @Field：范围查询
         */
        private Map<String,RangeEntity> ranges;
        /**
         * @Field：一次匹配多个值
         */
        private Map<String,List<String>> termsList;
        /**
         * @Field：判断字段非空
         */
        private List<String> existsFiles=new ArrayList<String>();
    
        /**
         * @Field：排序字段
         */
        private String sort;
        /**
         * @Field：起始记录条数
         */
        private Integer from;
        /**
         * @Field：返回条数
         */
        private Integer size;
    
        public ESQueryParams() {
        }
    
        public ESQueryParams(String index, String type, String sort) {
            this.index = index;
            this.type = type;
            this.sort = sort;
        }
    
    }

@Data
    public class RangeEntity {
        private String from;
        private String to;
    }