springboot集成ElasticSearch操作demo

逃离我推掉我的手 2022-05-20 09:20 230阅读 0赞

使用的是5.6.9版本

<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-elasticsearch</artifactId>
    			<version>3.0.7.RELEASE</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.elasticsearch</groupId>
    			<artifactId>elasticsearch</artifactId>
    			<version>5.6.9</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.elasticsearch.client</groupId>
    			<artifactId>transport</artifactId>
    			<version>5.6.9</version>
    			<exclusions>
    				<exclusion>
    					<groupId>org.elasticsearch</groupId>
    					<artifactId>elasticsearch</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.39</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.4</version>
    		</dependency>

application.properties配置

# Elasticsearch
    # 9200端口是用来让HTTP REST API来访问ElasticSearch，而9300端口是传输层监听的默认端口
    elasticsearch.ip=127.0.0.1
    elasticsearch.port=9300
    elasticsearch.pool=5
    elasticsearch.cluster.name=elasticsearch

elasticsearch配置

import org.elasticsearch.client.transport.TransportClient;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.transport.InetSocketTransportAddress;
    import org.elasticsearch.common.transport.TransportAddress;
    import org.elasticsearch.transport.client.PreBuiltTransportClient;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    /**
     * @Configuration用于定义配置类，可替换xml配置文件
     */
    @Configuration
    public class ElasticsearchConfig {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(ElasticsearchConfig.class);
    
        /**
         * elk集群地址
         */
        @Value("${elasticsearch.ip}")
        private String hostName;
    
        /**
         * 端口
         */
        @Value("${elasticsearch.port}")
        private Integer port;
    
        /**
         * 集群名称
         */
        @Value("${elasticsearch.cluster.name}")
        private String clusterName;
    
        /**
         * 连接池
         */
        @Value("${elasticsearch.pool}")
        private String poolSize;
    
        /**
         * Bean name default  函数名字
         *
         * @return
         */
        @Bean(name = "transportClient")
        public TransportClient transportClient() {
            LOGGER.info("Elasticsearch初始化开始。。。。。");
    
            TransportClient transportClient = null;
            try {
                // 配置信息
                Settings esSetting = Settings.builder()
                        .put("cluster.name", clusterName) //集群名字
                        .put("client.transport.sniff", true)//增加嗅探机制，找到ES集群
                        .put("thread_pool.search.size", Integer.parseInt(poolSize))//增加线程池个数，暂时设为5
                        .build();
                //配置信息Settings自定义
                transportClient = new PreBuiltTransportClient(esSetting)
                        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(hostName), port));
            } catch (Exception e) {
                LOGGER.error("elasticsearch TransportClient create error!!", e);
            }
            return transportClient;
        }
    
    }

util工具类

package com.example.demo13.util;
    
    import com.alibaba.fastjson.JSONObject;
    import com.example.demo13.bean.EsPage;
    import org.apache.commons.lang3.StringUtils;
    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.BulkRequestBuilder;
    import org.elasticsearch.action.bulk.BulkResponse;
    import org.elasticsearch.action.delete.DeleteResponse;
    import org.elasticsearch.action.get.GetRequestBuilder;
    import org.elasticsearch.action.get.GetResponse;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.action.search.SearchRequestBuilder;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.action.search.SearchType;
    import org.elasticsearch.action.update.UpdateRequest;
    import org.elasticsearch.client.transport.TransportClient;
    import org.elasticsearch.common.text.Text;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.aggregations.Aggregation;
    import org.elasticsearch.search.aggregations.AggregationBuilders;
    import org.elasticsearch.search.aggregations.Aggregations;
    import org.elasticsearch.search.aggregations.bucket.global.Global;
    import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
    import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
    import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.avg.InternalAvg;
    import org.elasticsearch.search.aggregations.metrics.max.Max;
    import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
    import org.elasticsearch.search.aggregations.metrics.min.InternalMin;
    import org.elasticsearch.search.aggregations.metrics.sum.InternalSum;
    import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCount;
    import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCountAggregationBuilder;
    import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
    import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
    import org.elasticsearch.search.sort.SortBuilders;
    import org.elasticsearch.search.sort.SortOrder;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import java.util.*;
    
    @Component
    public class ElasticsearchUtil {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(ElasticsearchUtil.class);
    
        @Autowired
        private TransportClient transportClient;
    
        private static TransportClient client;
    
        /**
         * @PostContruct是spring框架的注解 spring容器初始化的时候执行该方法
         */
        @PostConstruct
        public void init() {
            client = this.transportClient;
        }
    
        /**
         * 创建索引
         *
         * @param index
         * @return
         */
        public static boolean createIndex(String index) {
            if (!isIndexExist(index)) {
                LOGGER.info("Index is not exits!");
            } else {
                // return false;
            }
            CreateIndexResponse indexresponse = client.admin().indices().prepareCreate(index).execute().actionGet();
            LOGGER.info("执行建立成功？" + indexresponse.isAcknowledged());
            return indexresponse.isAcknowledged();
        }
    
        /**
         * 删除索引
         *
         * @param index
         * @return
         */
        public static boolean deleteIndex(String index) {
            if (!isIndexExist(index)) {
                LOGGER.info("Index is not exits!");
            }
            DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(index).execute().actionGet();
            if (dResponse.isAcknowledged()) {
                LOGGER.info("delete index " + index + "  successfully!");
            } else {
                LOGGER.info("Fail to delete index " + index);
            }
            return dResponse.isAcknowledged();
        }
    
        /**
         * 判断索引是否存在
         *
         * @param index
         * @return
         */
        public static boolean isIndexExist(String index) {
            IndicesExistsResponse inExistsResponse = client.admin().indices().exists(new IndicesExistsRequest(index)).actionGet();
            if (inExistsResponse.isExists()) {
                LOGGER.info("Index [" + index + "] is exist!");
            } else {
                LOGGER.info("Index [" + index + "] is not exist!");
            }
            return inExistsResponse.isExists();
        }
    
        /**
         * 数据添加，正定ID
         *
         * @param jsonObject 要增加的数据
         * @param index      索引，类似数据库
         * @param type       类型，类似表
         * @param id         数据ID
         * @return
         */
        public static String addData(JSONObject jsonObject, String index, String type, String id) {
    
            IndexResponse response = client.prepareIndex(index, type, id).setSource(jsonObject).get();
    
            LOGGER.info("addData response status:{},id:{}", response.status().getStatus(), response.getId());
    
            return response.getId();
        }
    
        /**
         * 批量数据添加，正定ID
         *
         * @param list  要增加的数据集合
         * @param index 索引，类似数据库
         * @param type  类型，类似表
         */
        public static void addDataBatch(List<JSONObject> list, String index, String type) {
            BulkRequestBuilder bulk = client.prepareBulk();
    
            boolean flag;
    
            int i = 0;
            for (JSONObject obj : list) {
                bulk.add(client.prepareIndex(index, type, obj.getString("id")).setSource(obj));
                i++;
    
                if (i % 10000 == 0) {
                    BulkResponse bulkResponse = bulk.execute().actionGet();
    
                }
            }
    
            BulkResponse bulkResponse = bulk.execute().actionGet();
    
    
            LOGGER.info(""+bulkResponse.hasFailures());
            LOGGER.info("111");
        }
    
    
        /**
         * 数据添加
         *
         * @param jsonObject 要增加的数据
         * @param index      索引，类似数据库
         * @param type       类型，类似表
         * @return
         */
        public static String addData(JSONObject jsonObject, String index, String type) {
            return addData(jsonObject, index, type, UUID.randomUUID().toString().replaceAll("-", "").toUpperCase());
        }
    
        /**
         * 通过ID删除数据
         *
         * @param index 索引，类似数据库
         * @param type  类型，类似表
         * @param id    数据ID
         */
        public static void deleteDataById(String index, String type, String id) {
    
            DeleteResponse response = client.prepareDelete(index, type, id).execute().actionGet();
    
            LOGGER.info("deleteDataById response status:{},id:{}", response.status().getStatus(), response.getId());
        }
    
        /**
         * 通过ID 更新数据
         *
         * @param jsonObject 要增加的数据
         * @param index      索引，类似数据库
         * @param type       类型，类似表
         * @param id         数据ID
         * @return
         */
        public static void updateDataById(JSONObject jsonObject, String index, String type, String id) {
    
            UpdateRequest updateRequest = new UpdateRequest();
    
            updateRequest.index(index).type(type).id(id).doc(jsonObject);
    
            client.update(updateRequest);
    
        }
    
        /**
         * 通过ID获取数据
         *
         * @param index  索引，类似数据库
         * @param type   类型，类似表
         * @param id     数据ID
         * @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
         * @return
         */
        public static Map<String, Object> searchDataById(String index, String type, String id, String fields) {
    
            GetRequestBuilder getRequestBuilder = client.prepareGet(index, type, id);
    
            if (StringUtils.isNotEmpty(fields)) {
                getRequestBuilder.setFetchSource(fields.split(","), null);
            }
    
            GetResponse getResponse = getRequestBuilder.execute().actionGet();
    
            return getResponse.getSource();
        }
    
    
        /**
         * 使用分词查询,并分页
         *
         * @param index          索引名称
         * @param type           类型名称,可传入多个type逗号分隔
         * @param startPage      当前页
         * @param pageSize       每页显示条数
         * @param query          查询条件
         * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
         * @param sortField      排序字段
         * @param highlightField 高亮字段
         * @return
         */
        public static EsPage searchDataPage(String index, String type, int startPage, int pageSize,
                                            QueryBuilder query, String fields, String sortField, String highlightField) {
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
            if (StringUtils.isNotEmpty(type)) {
                searchRequestBuilder.setTypes(type.split(","));
            }
    
    
            searchRequestBuilder.setSearchType(SearchType.QUERY_THEN_FETCH);
    
            // 需要显示的字段，逗号分隔（缺省为全部字段）
            if (StringUtils.isNotEmpty(fields)) {
                searchRequestBuilder.setFetchSource(fields.split(","), null);
            }
    
            //排序字段
            if (StringUtils.isNotEmpty(sortField)) {
                searchRequestBuilder.addSort(sortField, SortOrder.DESC);
            }
    
            // 高亮（xxx=111,aaa=222）
            if (StringUtils.isNotEmpty(highlightField)) {
                HighlightBuilder highlightBuilder = new HighlightBuilder();
    
                //highlightBuilder.preTags("<span style='color:red' >");//设置前缀
                //highlightBuilder.postTags("</span>");//设置后缀
    
                // 设置高亮字段
                highlightBuilder.field(highlightField);
                searchRequestBuilder.highlighter(highlightBuilder);
            }
    
            //searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
            searchRequestBuilder.setQuery(query);
    
            // 分页应用
            searchRequestBuilder.setFrom(startPage).setSize(pageSize);
    
            // 设置是否按查询匹配度排序
            searchRequestBuilder.setExplain(true);
    
            //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
            LOGGER.info("\n{}", searchRequestBuilder);
    
            // 执行搜索,返回搜索响应信息
            SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
    
            long totalHits = searchResponse.getHits().totalHits;
            long length = searchResponse.getHits().getHits().length;
    
            LOGGER.debug("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);
    
            if (searchResponse.status().getStatus() == 200) {
                // 解析对象
                List<Map<String, Object>> sourceList = setSearchResponse(searchResponse, highlightField);
    
                return new EsPage(startPage, pageSize, (int) totalHits, sourceList);
            }
    
            return null;
    
        }
    
    
        /**
         * 使用分词查询
         *
         * @param index          索引名称
         * @param type           类型名称,可传入多个type逗号分隔
         * @param query          查询条件
         * @param size           文档大小限制
         * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
         * @param sortField      排序字段
         * @param highlightField 高亮字段
         * @return
         */
        public static List<Map<String, Object>> searchListData(String index, String type, QueryBuilder query, Integer size, String fields, String sortField, String highlightField) {
    
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
            if (StringUtils.isNotEmpty(type)) {
                searchRequestBuilder.setTypes(type.split(","));
            }
    
            if (StringUtils.isNotEmpty(highlightField)) {
                HighlightBuilder highlightBuilder = new HighlightBuilder();
                // 设置高亮字段
                highlightBuilder.field(highlightField);
                highlightBuilder.preTags("<span style=\"color:red\">");
                highlightBuilder.postTags("</span>");
    
                searchRequestBuilder.highlighter(highlightBuilder);
            }
    
            searchRequestBuilder.setQuery(query);
    
            if (StringUtils.isNotEmpty(fields)) {
                searchRequestBuilder.setFetchSource(fields.split(","), null);
            }
            searchRequestBuilder.setFetchSource(true);
    
            if (StringUtils.isNotEmpty(sortField)) {
                searchRequestBuilder.addSort(SortBuilders.fieldSort(sortField).order(SortOrder.DESC));
            }
    
            if (size != null && size > 0) {
                searchRequestBuilder.setSize(size);
            }
    
            //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
            LOGGER.info("\n{}", searchRequestBuilder);
    
            SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
    
            long totalHits = searchResponse.getHits().totalHits;
            long length = searchResponse.getHits().getHits().length;
    
            LOGGER.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);
    
            if (searchResponse.status().getStatus() == 200) {
                // 解析对象
                return setSearchResponse(searchResponse, highlightField);
            }
    
            return null;
    
        }
    
    
        /**
         * 高亮结果集 特殊处理
         *
         * @param searchResponse
         * @param highlightField
         */
        private static List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
            List<Map<String, Object>> sourceList = new ArrayList<Map<String, Object>>();
            StringBuffer stringBuffer = new StringBuffer();
    
            for (SearchHit searchHit : searchResponse.getHits().getHits()) {
                searchHit.getSourceAsMap().put("id", searchHit.getId());
    
                if (StringUtils.isNotEmpty(highlightField)) {
    
                    System.out.println("遍历 高亮结果集，覆盖 正常结果集" + searchHit.getSourceAsMap());
                    HighlightField highlightField1 = searchHit.getHighlightFields().get(highlightField);
    
                    if (highlightField1 != null) {
                        Text[] text = searchHit.getHighlightFields().get(highlightField).fragments();
    
                        if (text != null) {
                            for (Text str : text) {
                                stringBuffer.append(str.string());
                            }
                            //遍历 高亮结果集，覆盖 正常结果集
                            searchHit.getSourceAsMap().put(highlightField, stringBuffer.toString());
                        }
                    }
    
    
                }
                sourceList.add(searchHit.getSourceAsMap());
            }
    
            return sourceList;
        }
    
        /**
         *
         * 获取最小值
         *
         * @param index
         * @param type
         * @return
         */
        public static double min(String index, String type) {
            SearchResponse response = client
                    .prepareSearch(index)
                    .addAggregation(AggregationBuilders.min("min").field("age"))
                    .get();
    
            InternalMin min = response.getAggregations().get("min");
            System.out.println(min.getValue());
    
            return min.getValue();
        }
    
    
        /**
         *
         * 获取最大值 https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.6/_metrics_aggregations.html
         *
         * @param index
         * @param type
         * @return
         */
        public static double max(String index, String type) {
    
            MaxAggregationBuilder aggregation = AggregationBuilders.max("agg").field("age");
    
            SearchResponse response = client
                    .prepareSearch(index)
                    .addAggregation(aggregation)
                    .execute().actionGet();
    
            Max max = response.getAggregations().get("agg");
            System.out.println(max.getValue());
    
            return max.getValue();
        }
    
        /**
         *
         * 统计条数
         *
         * @param index
         * @param type
         * @return
         */
        public static long count(String index, String type) {
            ValueCountAggregationBuilder aggregation = AggregationBuilders.count("agg").field("age");
            SearchResponse response = client
                    .prepareSearch(index)
                    .addAggregation(aggregation)
                    .execute().actionGet();
            ValueCount agg = response.getAggregations().get("agg");
            long value = agg.getValue();
    
            return value;
        }
    
        /**
         *
         * 聚合统计模板方法
         *
         * @param index
         * @param type
         * @param queryBuilder
         * @return
         */
        public static SearchResponse test(String index, String type, QueryBuilder queryBuilder) {
    
            SearchResponse sr = client.prepareSearch(index).setTypes(type).setQuery(queryBuilder)
                    .addAggregation(
                            AggregationBuilders.terms("by_name").field("name")
                                    /*.subAggregation(AggregationBuilders.dateHistogram("by_date")
                                            .field("createTime")
                                            .dateHistogramInterval(DateHistogramInterval.YEAR)*/
                                            .subAggregation(AggregationBuilders.avg("avg_age").field("age"))
                                    //)
                    )
                    .execute().actionGet();
    
            return sr;
    
    
            /*SearchResponse sr = client.prepareSearch()
                    .setQuery(queryBuilder )
                    .addAggregation( AggregationBuilders)
                    .execute().actionGet();*/
        }
    
        public static SearchResponse test2(String index, String type){
    
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index).setTypes(type);
            searchRequestBuilder.addAggregation(AggregationBuilders.terms("play_age").field("name"));
    
            //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
            LOGGER.info("\n{}", searchRequestBuilder);
    
            SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
    
            return  searchResponse;
        }
    
        /*public void test5(String index, String type){
            SearchResponse response = client.prepareSearch(index)
                    .setTypes(type)
                    //.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
                    .setQuery(QueryBuilders.termQuery("multi", "test"))                 // Query
                    .setPostFilter(QueryBuilders.rangeQuery("age").from(12).to(18))     // Filter
                    .setFrom(0).setSize(60).setExplain(true)
                    .get();
        }*/
    
    
       /* public static void test5(String index, String type){
    
            TermsAggregationBuilder teamAgg= AggregationBuilders.terms("_name ").field("name");
            TermsAggregationBuilder posAgg= AggregationBuilders.terms("_age").field("age");
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index).setTypes(type)
                    .addAggregation(AggregationBuilders.global("agg").subAggregation(teamAgg.subAggregation(posAgg)));
    
            //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
            LOGGER.info("\n{}", searchRequestBuilder);
    
            SearchResponse response = searchRequestBuilder.execute().actionGet();
            Aggregations agg = response.getAggregations();
    
            Map<String, Aggregation> aggMap = agg.asMap();
            StringTerms tea11mAgg= (StringTerms) aggMap.get("agg");
            parse(response);
    
            System.out.println(111);
    
    
    
    
        }*/
    
      /*  public static void test5(String index, String type){
    
            TermsAggregationBuilder posAgg= AggregationBuilders.terms("_age").field("age");
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index).setTypes(type)
                    .addAggregation(posAgg);
    
            //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
            LOGGER.info("\n{}", searchRequestBuilder);
    
            SearchResponse response = searchRequestBuilder.execute().actionGet();
    
            response.getAggregations()
    
            parse(response)
    
            System.out.println(111);
        }*/
    
    
        public static void parse(SearchResponse response){
            Map<String, Aggregation> aggMap = response.getAggregations().asMap();
            StringTerms teamAgg= (StringTerms) aggMap.get("_age");
            Iterator<StringTerms.Bucket> teamBucketIt = teamAgg.getBuckets().iterator();
            while (teamBucketIt .hasNext()) {
                StringTerms.Bucket buck = teamBucketIt .next();
                //球队名
                String team = (String) buck.getKey();
                //记录数
                long count = buck.getDocCount();
                //得到所有子聚合
                Map subaggmap = buck.getAggregations().asMap();
                //avg值获取方法
                double avg_age= ((InternalAvg) subaggmap.get("avg_age")).getValue();
                //sum值获取方法
                double total_salary = ((InternalSum) subaggmap.get("total_salary")).getValue();
                //...
                //max/min以此类推
            }
        }
    
    }

/**
     * @title DateUtil.java
     * @package com.baizhu.util
     * @projectName VolunteerAPI
     * @date 2014年5月13日
     * @Copyright: 2014 www.byzhu.com Inc. All rights reserved.
     */
    package com.example.demo13.util;
    
    import java.sql.Timestamp;
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 日期辅助类.
     * 
     * @author xiachengyun xiachengyun@baizhu.cc
     * @version V1.0
     */
    public class DateUtil {
    	/**
    	 * 当前日期转换为字符串.格式:yyyy-MM-dd HH:mm:ss
    	 *
    	 * @param date 日期.
    	 * @return 日期的字符串.
    	 */
    	public static String formatDate(Date date) {
    		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		return format.format(date);
    	}
    
    	/**
    	 * 返回特定格式的日期字符串.eg:yyyy-MM-dd HH:mm:ss
    	 *
    	 * @param date
    	 * @param patten
    	 * @return
    	 */
    	public static String formatDate(Date date, String patten) {
    		SimpleDateFormat format = new SimpleDateFormat(patten);
    		return format.format(date);
    	}
    
    	/**
    	 * 当前日期转换为字符串.格式:yyyy-MM-dd
    	 *
    	 * @param date 日期.
    	 * @return 日期的字符串.
    	 */
    	public static String formatDateWithoutSecond(Date date) {
    		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    		return format.format(date);
    	}
    
    	/**
    	 * 当前日期.
    	 *
    	 * @return
    	 */
    	public static Timestamp currrentDate() {
    		return new Timestamp(System.currentTimeMillis());
    	}
    
    	/**
    	 * 相隔天数
    	 *
    	 * @return
    	 */
    	public static boolean getTimeOut(Date createdDate, Date endDate) {
    		Calendar createdCalendar = Calendar.getInstance();
    		Calendar endCalendar = Calendar.getInstance();
    		createdCalendar.setTime(createdDate);
    		endCalendar.setTime(endDate);
    		createdCalendar.add(Calendar.YEAR, 1);
    		return endCalendar.before(createdCalendar);
    	}
    
    	/**
    	 * 判断白天黑夜
    	 *
    	 * @return
    	 */
    
    	public static String getDayOrNight(String beginTime, String dateBeginTime, String dateEndTime) {
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
    		try {
    			Date startDate = format.parse(beginTime.split(" ")[1]);
    			format.applyPattern("HH:mm");
    			Date sDate = format.parse(dateBeginTime);
    			Date eDate = format.parse(dateEndTime);
    			if (sDate.compareTo(startDate) <= 0 && eDate.compareTo(startDate) > 0) {
    				return "HOUR";
    			} else {
    				return "ALL";
    			}
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 当前日期转换为字符串.格式:yyyy年MM月dd日 HH时mm分ss秒
    	 *
    	 * @param date 日期.
    	 * @return 日期的字符串.
    	 * @throws ParseException
    	 */
    	public static String formatTimeCH(Date date) {
    		DateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    		return format.format(date);
    	}
    
    	/**
    	 * 将字符串转换为Date类型
    	 */
    	public static Date formatToDate(String time) {
    		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    		Date date = null;
    		try {
    			date = format.parse(time);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return date;
    	}
    
    	public static String getDayString(Date date) {
    		return new SimpleDateFormat("yyyy-MM-dd").format(date);
    	}
    
    	public static String getHourString(Date date) {
    		return new SimpleDateFormat("HH").format(date);
    	}
    
    	public static Date HfStrToDate(String str) {
    		Calendar current = Calendar.getInstance();
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    		Date date = null;
    		try {
    			date = sdf.parse(str);
    			current.setTime(date);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    
    		return date;
    	}
    
    	/**
    	 * 时间段比大小
    	 *
    	 * @param firstTime
    	 * @param secondTime
    	 * @return
    	 */
    	public static int compareTime(String firstTime, String secondTime) {
    		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		try {
    			Date fDate = format.parse(firstTime);
    			Date sDate = format.parse(secondTime);
    			if (sDate.compareTo(fDate) < 0) {
    				return 1;
    			} else {
    				return 2;
    			}
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return 0;
    	}
    
    	/**
    	 * 判断是否混合收费
    	 */
    	public static int judgeNd(String beginTime, String endTime, String beginTimee, String endTimee) {
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm");
    		SimpleDateFormat format3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		Calendar ca1 = Calendar.getInstance();
    		Calendar ca2 = Calendar.getInstance();
    		Calendar calendar = Calendar.getInstance();
    		Calendar calendar2 = Calendar.getInstance();
    		Calendar calendar3 = Calendar.getInstance();
    		Calendar calendar4 = Calendar.getInstance();
    		long timeMinutes = 15 * 60 * 60 * 1000;
    		long timeTwoMinutes = 9 * 60 * 60 * 1000;
    		try {
    			ca1.setTime(format3.parse(beginTime));
    			ca2.setTime(format3.parse(endTime));
    			calendar.setTime(format.parse(beginTime.split(" ")[1]));
    			calendar2.setTime(format.parse(endTime.split(" ")[1]));
    			calendar3.setTime(format.parse(beginTimee));
    			calendar4.setTime(format.parse(endTimee));
    			System.err.println(ca2.getTimeInMillis());
    			System.err.println(ca1.getTimeInMillis());
    			System.err.println(ca2.getTimeInMillis() - ca1.getTimeInMillis());
    			if (calendar.compareTo(calendar3) > 0 && calendar2.compareTo(calendar4) < 0 && ca2.getTimeInMillis() - ca1.getTimeInMillis() <= timeTwoMinutes) {
    				return 0;
    			}
    			if (calendar.compareTo(calendar4) > 0 && ca2.getTimeInMillis() - ca1.getTimeInMillis() <= timeMinutes) {
    				return 1;
    			}
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return 3;
    	}
    
    	/**
    	 * 将字符串转换为Date
    	 * format:yyyy-MM-dd HH:mm:ss
    	 * @param time
    	 * @return
    	 */
    	public static Date formatToDateM(String time) {
    		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		Date date = null;
    		try {
    			date = format.parse(time);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return date;
    	}
    
    	/**
    	 * 相隔天数判断
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static boolean xjday(Date bDate, Date eDate, int minDay, int maxDay) {
    		return ((eDate.getTime() - bDate.getTime()) / 1000 >= (minDay * 24 * 60 * 60) && (eDate.getTime() - bDate.getTime()) / 1000 <= (maxDay * 24 * 60 * 60));
    	}
    
    
    	/**
    	 * 相隔小时判断
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static boolean xjhour(Date bDate, Date eDate, int minHour, int maxHour) {
    		return ((eDate.getTime() - bDate.getTime()) / 1000 >= (minHour * 60 * 60) && (eDate.getTime() - bDate.getTime()) / 1000 <= (maxHour * 60 * 60));
    	}
    
    	/**
    	 * 判断是否能整除小时
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static boolean divideHour(Date bDate, Date eDate) {
    		return ((eDate.getTime() - bDate.getTime()) / 1000) % (60 * 60) != 0;
    	}
    
    	/**
    	 * 判断是否能整除天
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static boolean divideDay(Date bDate, Date eDate) {
    		return ((eDate.getTime() - bDate.getTime()) / 1000) % (24 * 60 * 60) != 0;
    	}
    
    	/**
    	 * 相差几个小时
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static int computerDivideHour(Date bDate, Date eDate) {
    		return (int) (((eDate.getTime() - bDate.getTime()) / 1000) / (60 * 60));
    	}
    
    	/**
    	 * 相差几天
    	 *
    	 * @param bDate
    	 * @param eDate
    	 * @return
    	 */
    	public static int computerDivideDay(Date bDate, Date eDate) {
    		return (int) (((eDate.getTime() - bDate.getTime()) / 1000) / (24 * 60 * 60));
    	}
    
    	public static Map<String, Integer> timea(Date bDate, Date eDate) {
    		Map<String, Integer> map = new HashMap<String, Integer>();
    		Integer day = (int) (((bDate.getTime() - eDate.getTime()) / 1000) / (24 * 60 * 60));
    		Integer hour = (int) (((bDate.getTime() - eDate.getTime()) / 1000) / (60 * 60)) - (day * 24);
    		Integer min = (int) (((bDate.getTime() - eDate.getTime()) / 1000) / (60) - (day * 24 * 60) - (hour * 60));
    		Integer sec = (int) (((bDate.getTime() - eDate.getTime()) / 1000) / (60) - (day * 24 * 60 * 60) - (hour * 60 * 60) - (min * 60));
    		map.put("day", day);
    		map.put("hour", hour);
    		map.put("min", min);
    		map.put("sec", sec);
    		System.err.println(day + "天");
    		System.err.println(hour + "小时");
    		System.err.println(min + "分钟");
    		System.err.println(sec + "秒");
    		return map;
    	}
    
    	public static String formatDateWithoutDay(Date date) {
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
    		return format.format(date);
    	}
    }

bean

package com.example.demo13.bean;
    
    import java.util.Date;
    
    /**
    * @Title: EsModel
    * @Description:  Elasticsearc 测试类
    * @author chy
    * @date 2018/4/25 15:43
    */
    public class EsModel {
    
        private Object id;
    
        private String name;
    
        private int age;
    
        private Date date;
    
        public Object getId() {
            return id;
        }
    
        public void setId(Object id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Date getDate() {
            return date;
        }
    
        public void setDate(Date date) {
            this.date = date;
        }
    }

package com.example.demo13.bean;
    
    import java.util.List;
    import java.util.Map;
    
    public class EsPage {
    
        /**
         * 当前页
         */
        private int currentPage;
        /**
         * 每页显示多少条
         */
        private int pageSize;
    
        /**
         * 总记录数
         */
        private int recordCount;
        /**
         * 本页的数据列表
         */
        private List<Map<String, Object>> recordList;
    
        /**
         * 总页数
         */
        private int pageCount;
        /**
         * 页码列表的开始索引（包含）
         */
        private int beginPageIndex;
        /**
         * 页码列表的结束索引（包含）
         */
        private int endPageIndex;
    
        /**
         * 只接受前4个必要的属性，会自动的计算出其他3个属性的值
         *
         * @param currentPage
         * @param pageSize
         * @param recordCount
         * @param recordList
         */
        public EsPage(int currentPage, int pageSize, int recordCount, List<Map<String, Object>> recordList) {
            this.currentPage = currentPage;
            this.pageSize = pageSize;
            this.recordCount = recordCount;
            this.recordList = recordList;
    
            // 计算总页码
            pageCount = (recordCount + pageSize - 1) / pageSize;
    
            // 计算 beginPageIndex 和 endPageIndex
            // >> 总页数不多于10页，则全部显示
            if (pageCount <= 10) {
                beginPageIndex = 1;
                endPageIndex = pageCount;
            }
            // >> 总页数多于10页，则显示当前页附近的共10个页码
            else {
                // 当前页附近的共10个页码（前4个 + 当前页 + 后5个）
                beginPageIndex = currentPage - 4;
                endPageIndex = currentPage + 5;
                // 当前面的页码不足4个时，则显示前10个页码
                if (beginPageIndex < 1) {
                    beginPageIndex = 1;
                    endPageIndex = 10;
                }
                // 当后面的页码不足5个时，则显示后10个页码
                if (endPageIndex > pageCount) {
                    endPageIndex = pageCount;
                    beginPageIndex = pageCount - 10 + 1;
                }
            }
        }
    
    
        public int getCurrentPage() {
            return currentPage;
        }
    
        public void setCurrentPage(int currentPage) {
            this.currentPage = currentPage;
        }
    
        public int getPageSize() {
            return pageSize;
        }
    
        public void setPageSize(int pageSize) {
            this.pageSize = pageSize;
        }
    
        public int getRecordCount() {
            return recordCount;
        }
    
        public void setRecordCount(int recordCount) {
            this.recordCount = recordCount;
        }
    
        public List<Map<String, Object>> getRecordList() {
            return recordList;
        }
    
        public void setRecordList(List<Map<String, Object>> recordList) {
            this.recordList = recordList;
        }
    
        public int getPageCount() {
            return pageCount;
        }
    
        public void setPageCount(int pageCount) {
            this.pageCount = pageCount;
        }
    
        public int getBeginPageIndex() {
            return beginPageIndex;
        }
    
        public void setBeginPageIndex(int beginPageIndex) {
            this.beginPageIndex = beginPageIndex;
        }
    
        public int getEndPageIndex() {
            return endPageIndex;
        }
    
        public void setEndPageIndex(int endPageIndex) {
            this.endPageIndex = endPageIndex;
        }
    
    }

controller

package com.example.demo13.controller;
    
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.rocketmq.client.exception.MQBrokerException;
    import com.alibaba.rocketmq.client.exception.MQClientException;
    import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
    import com.alibaba.rocketmq.client.producer.MessageQueueSelector;
    import com.alibaba.rocketmq.client.producer.SendResult;
    import com.alibaba.rocketmq.common.message.Message;
    import com.alibaba.rocketmq.common.message.MessageQueue;
    import com.alibaba.rocketmq.remoting.exception.RemotingException;
    import com.example.demo13.bean.EsModel;
    import com.example.demo13.bean.EsPage;
    import com.example.demo13.util.DateUtil;
    import com.example.demo13.util.ElasticsearchUtil;
    import org.apache.commons.lang3.StringUtils;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.*;
    
    @RestController
    @RequestMapping("/es")
    public class EsController {
    
        /**
         * 测试索引
         */
        private String indexName = "test_index_1";
    
        /**
         * 类型
         */
        private String esType = "external";
    
        /**
         * http://127.0.0.1:8080/es/createIndex
         * 创建索引
         *
         * @param request
         * @param response
         * @return
         */
        @RequestMapping("/createIndex")
        public String createIndex(HttpServletRequest request, HttpServletResponse response) {
            if (!ElasticsearchUtil.isIndexExist(indexName)) {
                ElasticsearchUtil.createIndex(indexName);
            } else {
                return "索引已经存在";
            }
            return "索引创建成功";
        }
    
        /**
         * 插入记录
         *
         * @return
         */
        @RequestMapping("/insertJson")
        public String insertJson() {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("id", DateUtil.formatDate(new Date()));
            jsonObject.put("age", 25);
            jsonObject.put("name", "j-" + new Random(100).nextInt());
            jsonObject.put("date", new Date());
            String id = ElasticsearchUtil.addData(jsonObject, indexName, esType, jsonObject.getString("id"));
            return id;
        }
    
        /**
         *
         * 批量插入
         *
         * @return
         */
        @RequestMapping("/insertJsonBatch")
        public String insertJsonBatch() {
    
            List<JSONObject> list = new ArrayList<>();
            for(int i=0; i<15; i++){
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("id", "00" + i);
                jsonObject.put("age", new Random().nextInt(100));
                jsonObject.put("name", "j-" + new Random(100).nextInt());
                jsonObject.put("date", new Date());
    
                list.add(jsonObject);
            }
            ElasticsearchUtil.addDataBatch(list, indexName, esType);
            return "OK";
        }
    
    
        /**
         * 插入记录
         *
         * @return
         */
        @RequestMapping("/insertModel")
        public String insertModel() {
            EsModel esModel = new EsModel();
            esModel.setId(DateUtil.formatDate(new Date()));
            esModel.setName("m-" + new Random(100).nextInt());
            esModel.setAge(30);
            esModel.setDate(new Date());
            JSONObject jsonObject = (JSONObject) JSONObject.toJSON(esModel);
            String id = ElasticsearchUtil.addData(jsonObject, indexName, esType, jsonObject.getString("id"));
            return id;
        }
    
        /**
         * 删除记录
         *
         * @return
         */
        @RequestMapping("/delete")
        public String delete(String id) {
    
            if (StringUtils.isNoneBlank(id)) {
                ElasticsearchUtil.deleteDataById(indexName, esType, id);
                return "删除id=" + id;
            } else {
                return "id为空";
            }
        }
    
        /**
         * 更新数据
         *
         * @return
         */
        @RequestMapping("/update")
        public String update(String id) {
            if (StringUtils.isNoneBlank(id)) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("id", id);
                jsonObject.put("age", 31);
                jsonObject.put("name", "wpfffff");
                jsonObject.put("date", new Date());
                ElasticsearchUtil.updateDataById(jsonObject, indexName, esType, id);
                return "id=" + id;
            } else {
                return "id为空";
            }
        }
    
        /**
         * 获取数据
         * http://127.0.0.1:8080/es/getData?id=2018-04-25%2016:33:44
         *
         * @param id
         * @return
         */
        @RequestMapping("/getData")
        public String getData(String id) {
    
            if (StringUtils.isNoneBlank(id)) {
                Map<String, Object> map = ElasticsearchUtil.searchDataById(indexName, esType, id, null);
                return JSONObject.toJSONString(map);
            } else {
                return "id为空";
            }
        }
    
        public static void main(String[] args) {
    
            for (int i=0;i<100;i++){
                System.out.println(new Random().nextInt(100));
            }
    
    
            String a = "123";
    
            String b = "";
            String c = null;
            System.out.println("a is not blank: " + StringUtils.isNoneBlank(a));
            System.out.println("a is not blank: " + StringUtils.isNoneBlank(b));
            System.out.println("a is not blank: " + StringUtils.isNoneBlank(c));
        }
    
        /**
         * 查询数据
         * 模糊查询
         *
         * @return
         */
        @RequestMapping("/queryMatchData")
        public String queryMatchData() {
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolean matchPhrase = false;
            if (matchPhrase == Boolean.TRUE) {
                boolQuery.must(QueryBuilders.matchPhraseQuery("name", "wpfffff"));
            } else {
                boolQuery.must(QueryBuilders.matchQuery("name", "wpfffff"));
            }
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 10, null, null, null);
            return JSONObject.toJSONString(list);
        }
    
        /**
         * 通配符查询数据
         * 通配符查询 ?用来匹配1个任意字符，*用来匹配零个或者多个字符
         *
         * @return
         */
        @RequestMapping("/queryWildcardData")
        public String queryWildcardData() {
    
            //BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("name.keyword", "*");
    
           // boolQuery.must(QueryBuilders.wildcardQuery("name.keyword", "*"));
           // boolQuery.must(QueryBuilders.rangeQuery("age").from(1)
           //         .to(125));
    
    
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, queryBuilder, 10, null, null, null);
            return JSONObject.toJSONString(list);
        }
    
        /**
         * 正则查询
         *
         * @return
         */
        @RequestMapping("/queryRegexpData")
        public String queryRegexpData() {
            QueryBuilder queryBuilder = QueryBuilders.regexpQuery("name.keyword", "j--[0-9]{1,11}");
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, queryBuilder, 10, null, null, null);
            return JSONObject.toJSONString(list);
        }
    
        /**
         * 查询数字范围数据
         *
         * @return
         */
        @RequestMapping("/queryIntRangeData")
        public String queryIntRangeData() {
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.must(QueryBuilders.rangeQuery("age").from(21)
                    .to(25));
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 10, null, null, null);
            return JSONObject.toJSONString(list);
        }
    
        /**
         * 查询日期范围数据
         *
         * @return
         */
        @RequestMapping("/queryDateRangeData")
        public String queryDateRangeData() {
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.must(QueryBuilders.rangeQuery("date").from("2018-04-25T08:33:44.840Z")
                    .to("2018-04-25T10:03:08.081Z"));
    
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 10, null, null, null);
            return JSONObject.toJSONString(list);
        }
    
        /**
         *
         * 查询所有数据
         *
         * @return
         */
        @GetMapping("/queryAllData")
        public String queryAllData(){
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    
            List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 5, "id,name,age", "age", "age");
            return JSONObject.toJSONString(list);
        }
    
        /**
         * 查询分页
         *
         * @param startPage 第几条记录开始
         *                  从0开始
         *                  第1页 ：http://127.0.0.1:8080/es/queryPage?startPage=0&pageSize=2
         *                  第2页 ：http://127.0.0.1:8080/es/queryPage?startPage=2&pageSize=2
         * @param pageSize  每页大小
         * @return
         */
        @RequestMapping("/queryPage")
        public String queryPage(String startPage, String pageSize) {
    
    
            if (StringUtils.isNoneBlank(startPage) && StringUtils.isNoneBlank(pageSize)) {
                BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
               /* boolQuery.must(QueryBuilders.rangeQuery("date").from("2017-04-25T08:33:44.840Z")
                        .to("2019-04-25T10:03:08.081Z"));*/
                EsPage list = ElasticsearchUtil.searchDataPage(indexName, esType, Integer.parseInt(startPage), Integer.parseInt(pageSize), boolQuery, null, null, null);
                return JSONObject.toJSONString(list);
            } else {
                return "startPage或者pageSize缺失";
            }
        }
    
       /* public static void main(String[] args) {
    
            DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
    
        //   producer.sendOneway();
    
            String msg = "aa";
    
            Message message = new Message();
            message.setBody("aaa".getBytes());
    
            Object orderId = 1000;
    
            try {
                SendResult sendResult = producer.send(message, new MessageQueueSelector()  {
                    @Override
                    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                        Integer id = (Integer) arg;
                        int index = id % mqs.size();
                        return mqs.get(index);
                    }
                }, orderId);
            } catch (MQClientException e) {
                e.printStackTrace();
            } catch (RemotingException e) {
                e.printStackTrace();
            } catch (MQBrokerException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/
    
    
    }