springboot集成elasticSearch（附带工具类）

集成springboot

pom：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.4.0</version>
</dependency>
 
properties中需要指定es版本：
<elasticsearch.version>7.4.0</elasticsearch.version>

实例1

    @Bean
    public RestHighLevelClient esRestClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                		new HttpHost("192.168.77.130", 9200, "http"))
                		// 多个host直接在这后面拼接
                	);
        return  client;
    }

import com.alibaba.fastjson.JSON;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
 
@RequestMapping("/es")
@Controller
public class ElasticsearchController {
 
    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;
 
    /**
     * 索引
     */
    @RequestMapping("/test1")
    public void test1() throws IOException {
        // 创建索引
        CreateIndexRequest indexCui = new CreateIndexRequest("cui");
        CreateIndexResponse resp = client.indices().create(indexCui, RequestOptions.DEFAULT);
        System.out.println(resp);
 
        // 判断索引是否存在
        GetIndexRequest getIndexRequest = new GetIndexRequest("cui");
        boolean exists = client.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
 
        //删除索引
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("cui");
        AcknowledgedResponse delete = client.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        System.out.println(delete);
    }
    /**
     * POST添加数据
     */
    @RequestMapping("/test2")
    public void test2() throws IOException {
        EsUser esUser = new EsUser();
        esUser.age =18;
        esUser.name = "张三";
        // 连接索引
        IndexRequest cui = new IndexRequest("cui");
 
        //规则 /cui/_doc/1
        cui.id("1");
        cui.timeout(TimeValue.timeValueSeconds(10));
        //cui.timeout("10s");
 
        // 请求体放进去
        cui.source(JSON.toJSONString(esUser), XContentType.JSON);
 
        //客户端发送请求
        IndexResponse index = client.index(cui, RequestOptions.DEFAULT);
        System.out.println(index);// 第一次是created，以后再添加就是update了
    }
 
    /**
     * 文档操作
     */
    @RequestMapping("/test3")
    public void test3() throws IOException {
        /**
         * 判断文档是否存在
         */
        GetRequest cui = new GetRequest("cui", "1");
        //不获取返回的上下文（_source）
        cui.fetchSourceContext(new FetchSourceContext(false));
        cui.storedFields("_none_");
        boolean exists = client.exists(cui, RequestOptions.DEFAULT);
        System.out.println(exists);
 
        GetRequest idx = new GetRequest("cui", "1");
        GetResponse documentFields = client.get(idx, RequestOptions.DEFAULT);
        System.out.println(documentFields.getSourceAsString());// 打印文档内容
        System.out.println(documentFields); // 返回的全部内容和命令是一样的
 
        /**
         * 更新
         */
        EsUser esUser = new EsUser();
        esUser.age =19;
        esUser.name = "张四";
 
        UpdateRequest cui1 = new UpdateRequest("cui", "1");
        cui1.timeout("1s");
        cui1.doc(JSON.toJSONString(esUser), XContentType.JSON);
 
        UpdateResponse update = client.update(cui1, RequestOptions.DEFAULT);
        System.out.println(update);
 
        /**
         * 删除
         */
        DeleteRequest cui2 = new DeleteRequest("cui", "1");
        cui2.timeout("1s");
        DeleteResponse delete = client.delete(cui2, RequestOptions.DEFAULT);
        System.out.println(delete);
    }
 
    /**
     * 批量操作
     */
    @RequestMapping("/test4")
    public void test4() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        ArrayList<EsUser> list = new ArrayList<>();
        list.add(new EsUser("崔1", 21));
        list.add(new EsUser("崔2", 22));
        list.add(new EsUser("崔3", 23));
        list.add(new EsUser("崔4", 24));
        list.add(new EsUser("崔5", 25));
        list.add(new EsUser("崔6", 26));
        list.add(new EsUser("崔7", 27));
        //批处理
        for (int i = 0; i < list.size(); i++) {
            // 批量修改删除，对应修改即可
            bulkRequest.add(
                    new IndexRequest("cui")
                    .id(i + 1 + "") // 不写id会随机生成id
                    .source(JSON.toJSONString(list.get(i)), XContentType.JSON)
            );
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk);
    }
 
    /**
     * 查询
     * 就是对应基本的所有命令
     */
    @RequestMapping("/test5")
    public void test5() throws IOException {
        SearchRequest searchRequest = new SearchRequest("cui");
 
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //使用QueryBuilders，快速匹配查询条件
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "崔1");
        searchSourceBuilder.query(matchQueryBuilder)
                .from(0)// 分页
                .size(10)
                .timeout(new TimeValue(10, TimeUnit.SECONDS));
        //searchSourceBuilder.highlighter();// 高亮
 
        searchRequest.source(searchSourceBuilder);// 把查询条件放到searchRequest
 
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(search.getHits());// 文档内容
        System.out.println(search);
        for (SearchHit documentFields : search.getHits().getHits()) {
            System.out.println(documentFields.getSourceAsMap());// 遍历
        }
 
    }
 
}
 
class EsUser{
    public String name;
    public Integer age;
 
    public EsUser(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
 
    public EsUser() {
    }
}

实例2

import com.alibaba.fastjson.JSON;
import com.xunqi.gulimall.search.config.GulimallElasticSearchConfig;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.Avg;
import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.io.IOException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class GulimallSearchApplicationTests {


    @Resource
    private RestHighLevelClient client;

    @ToString
    @Data
    static class Account {
        private int account_number;
        private int balance;
        private String firstname;
        private String lastname;
        private int age;
        private String gender;
        private String address;
        private String employer;
        private String email;
        private String city;
        private String state;
    }


    /**
     * 复杂检索:在bank中搜索address中包含mill的所有人的年龄分布以及平均年龄，平均薪资
     *
     * @throws IOException
     */
    @Test
    public void searchData() throws IOException {
        //1. 创建检索请求
        SearchRequest searchRequest = new SearchRequest();

        //1.1）指定索引
        searchRequest.indices("bank");
        //1.2）构造检索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchQuery("address", "Mill"));


        //1.2.1)按照年龄分布进行聚合
        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);
        sourceBuilder.aggregation(ageAgg);

        //1.2.2)计算平均年龄
        AvgAggregationBuilder ageAvg = AggregationBuilders.avg("ageAvg").field("age");
        sourceBuilder.aggregation(ageAvg);
        //1.2.3)计算平均薪资
        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");
        sourceBuilder.aggregation(balanceAvg);

        System.out.println("检索条件：" + sourceBuilder);
        searchRequest.source(sourceBuilder);
        //2. 执行检索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("检索结果：" + searchResponse);

        //3. 将检索结果封装为Bean
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit searchHit : searchHits) {
            String sourceAsString = searchHit.getSourceAsString();
            Account account = JSON.parseObject(sourceAsString, Account.class);
            System.out.println(account);

        }

        //4. 获取聚合信息
        Aggregations aggregations = searchResponse.getAggregations();

        Terms ageAgg1 = aggregations.get("ageAgg");

        for (Terms.Bucket bucket : ageAgg1.getBuckets()) {
            String keyAsString = bucket.getKeyAsString();
            System.out.println("年龄：" + keyAsString + " ==> " + bucket.getDocCount());
        }
        Avg ageAvg1 = aggregations.get("ageAvg");
        System.out.println("平均年龄：" + ageAvg1.getValue());

        Avg balanceAvg1 = aggregations.get("balanceAvg");
        System.out.println("平均薪资：" + balanceAvg1.getValue());
    }


    /**
     * @throws IOException
     */
    @Test
    public void searchState() throws IOException {
        //1. 创建检索请求
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //        sourceBuilder.query(QueryBuilders.termQuery("city", "Nicholson"));
        //        sourceBuilder.from(0);
        //        sourceBuilder.size(5);
        //        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("state", "AK");
        //                .fuzziness(Fuzziness.AUTO)
        //                .prefixLength(3)
        //                .maxExpansions(10);
        sourceBuilder.query(matchQueryBuilder);
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("bank");
        searchRequest.source(sourceBuilder);
        //2. 执行检索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(searchResponse);

    }

    /**
     * 测试ES数据
     * 更新也可以
     */
    @Test
    public void indexData() throws IOException {

        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");   //数据的id

        // 可以用key-value对设置内容
        // indexRequest.source("userName","zhangsan","age",18,"gender","男");

        User user = new User();
        user.setUserName("zhangsan");
        user.setAge(18);
        user.setGender("男");

        String jsonString = JSON.toJSONString(user);
        // 也可以转json设置内容
        indexRequest.source(jsonString, XContentType.JSON);  //要保存的内容

        //执行操作
        IndexResponse index = client.index(indexRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);

        //提取有用的响应数据
        System.out.println(index);

    }

    @Getter
    @Setter
    class User {
        private String userName;
        private String gender;
        private Integer age;
    }

    @Test
    public void contextLoads() {

        System.out.println(client);

    }
}

工具类

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.boot.security.server.myUtils.elasticsearch.bean.GroupByListItem;
import com.boot.security.server.myUtils.elasticsearch.jsonFormat.DefaultJsonFormat;
import com.boot.security.server.myUtils.elasticsearch.jsonFormat.JsonFormatInterface;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.action.DocWriteResponse.Result;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.*;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortBuilder;

import java.io.IOException;
import java.util.*;

/**
 * ElasticSearch 操作
 *
 */
public class ElasticSearchUtil {
	private RestHighLevelClient restHighLevelClient;
	private RestClient restClient;
	
	private String hostname = "127.0.0.1";
	private int port = 9200;
	private String scheme = "http";
	private String username = "";	//elasticsearch链接的用户名，如果es本身没设置使用用户名密码的，那这里就不用设置
	private String password = "";	//elasticsearch链接的密码，如果es本身没设置使用用户名密码的，那这里就不用设置
	private JsonFormatInterface jsonFormatInterface; //JSON格式化接口。默认使用 DefaultJsonFormat();
	private HttpHost[] httpHosts;
	
	/**
	 * 缓存。
	 * key:  indexName
	 * value： 要打包提交的 List
	 */
	public Map<String, List<Map<String, Object>>> cacheMap;
	public int cacheMaxNumber = 100; //如果使用缓存，这里是缓存中的最大条数，超过这些条就会自动打包提交
	
	/**
	 * 通过传入自定义 {@link HttpHost} 的方式，创建工具类
	 * @param client 传入如：
	 * 	<pre>
	 *   new HttpHost("127.0.0.1", "9200", "http"))
	 * 	</pre>
	 */
	public ElasticSearchUtil(HttpHost... httpHosts) {
		this.httpHosts = httpHosts;
		cacheMap = new HashMap<String, List<Map<String,Object>>>();
		jsonFormatInterface = new DefaultJsonFormat();
	}
	
	/**
	 * 初始化 ElasticSearchUtil
	 * @param hostname elasticsearch所在的ip，传入如 127.0.0.1
	 */
	public ElasticSearchUtil(String hostname) {
		this.hostname = hostname;
		cacheMap = new HashMap<String, List<Map<String,Object>>>();
		jsonFormatInterface = new DefaultJsonFormat();
	}
	
	/**
	 * 初始化 ElasticSearchUtil
	 * @param hostname elasticsearch所在的ip，传入如 127.0.0.1
	 * @param port elasticsearch服务的端口号，传入如 9200
	 * @param scheme 协议，传入如 http
	 */
	public ElasticSearchUtil(String hostname, int port, String scheme) {
		this.hostname = hostname;
		this.port = port;
		this.scheme = scheme;
		cacheMap = new HashMap<String, List<Map<String,Object>>>();
		jsonFormatInterface = new DefaultJsonFormat();
	}
	
	/**
	 * 初始化 ElasticSearchUtil
	 * @param hostname elasticsearch所在的ip，传入如 127.0.0.1
	 * @param port elasticsearch服务的端口号，传入如 9200
	 * @param scheme 协议，传入如 http
	 * @param username 如果ElasticSearch 有设置用户名密码登录的方式，这里要传入设置的用户名。如果没有密码，这里传入null或者空字符串都行
	 * @param password 如果ElasticSearch 有设置用户名密码登录的方式，这里要传入设置的密码。如果没有密码，这里传入null或者空字符串都行
	 */
	public ElasticSearchUtil(String hostname, int port, String scheme, String username, String password) {
		this.hostname = hostname;
		this.port = port;
		this.scheme = scheme;
		if(username != null && username.length() > 0) {
			this.username = username;
		}
		if(password != null && password.length() > 0) {
			this.password = password;
		}
		cacheMap = new HashMap<String, List<Map<String,Object>>>();
		jsonFormatInterface = new DefaultJsonFormat();
	}
	
	/**
	 * 设置elasticsearch的username、password。此行一般是在
	 * <pre>
	 * 	ElasticSearchUtil(String hostname, int port, String scheme)
	 * </pre>
	 * 这下面就使用，如果elasticsearch有用户名、密码的话。
	 * @param username 如果ElasticSearch 有设置用户名密码登录的方式，这里要传入设置的用户名。如果没有密码，这里传入null或者空字符串都行
	 * @param password 如果ElasticSearch 有设置用户名密码登录的方式，这里要传入设置的密码。如果没有密码，这里传入null或者空字符串都行
	 */
	public void setUsernameAndPassword(String username, String password) {
		if(username != null && username.length() > 0) {
			this.username = username;
		}
		if(password != null && password.length() > 0) {
			this.password = password;
		}
	}
	
	/**
	 * 设置缓存中最大缓存的条数。超过这些条就会自动打包提交。 这里自动提交的便是 {@link #cache(Map)} 所缓存的数据
	 * @param cacheMaxNumber 缓存的条数。如果不设置，默认是100
	 */
	public void setCacheMaxNumber(int cacheMaxNumber) {
		this.cacheMaxNumber = cacheMaxNumber;
	}

	/**
	 * JSON格式化接口。如果不设置此处，默认使用 {@link DefaultJsonFormat}
	 * @param jsonFormatInterface 设置自定义json序列化方法
	 */
	public void setJsonFormatInterface(JsonFormatInterface jsonFormatInterface) {
		this.jsonFormatInterface = jsonFormatInterface;
	}

	/**
	 * 获取操作的 {@link RestHighLevelClient} 对象
	 * @return {@link RestHighLevelClient}
	 */
	public RestHighLevelClient getRestHighLevelClient(){
		if(this.restHighLevelClient == null){
			if(this.httpHosts == null){
				//没有直接传入 httpshosts，那么就是使用单个的
				HttpHost httpHost = new HttpHost(this.hostname, this.port, this.scheme);
				this.httpHosts = new HttpHost[1];
				this.httpHosts[0] = httpHost;
			}
			if(this.username.length() > 0 && this.password.length() > 0) {
				//当前elasticsearch 设置了连接的用户名密码
				final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
				credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials(username, password));  //es账号密码（默认用户名为elastic）
				this.restHighLevelClient =new RestHighLevelClient(
					RestClient.builder(this.httpHosts).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
						public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
							httpClientBuilder.disableAuthCaching();
							return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
						}
					})
				);
			}else{
				this.restHighLevelClient = new RestHighLevelClient(RestClient.builder(this.httpHosts));
			}
		}
		return this.restHighLevelClient;
	}
	
	/**
	 * 获取操作的 {@link RestClient} 对象
	 * @return {@link RestClient}
	 */
	public RestClient getRestClient(){
		if(this.restClient == null){
			if(this.httpHosts == null){
				//没有直接传入 httpshosts，那么就是使用单个的
				HttpHost httpHost = new HttpHost(this.hostname, this.port, this.scheme);
				this.httpHosts = new HttpHost[1];
				this.httpHosts[0] = httpHost;
			}
			if(this.username.length() > 0 && this.password.length() > 0) {
				//当前elasticsearch 设置了连接的用户名密码
				final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
				credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials(username, password));  //es账号密码（默认用户名为elastic）
				this.restClient = RestClient.builder(this.httpHosts).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
					public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
						httpClientBuilder.disableAuthCaching();
						return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
					}
				}).build();
			}
			this.restClient = RestClient.builder(this.httpHosts).build();
		}
		return this.restClient;
	}
	
	/**
	 * 将之提交到缓存Cache中。这里不同意put,put是直接提交到ElasticSearch中，而这个只是提交到Java缓存中，等积累到一定条数之后，在一起将Java缓存中的打包一次性提交到 Elasticsearch中
	 * <p>默认同一个indexName索引中，缓存最大条数是100条，达到100条会自动提交到 elasticsearch。 这个最大条数，可以通过  {@link #setCacheMaxNumber(int)} 进行设置。建议不要超过4000条 </p>
	 * @param params 要增加的数据，key-value形式。 其中map.value 支持的类型有 String、int、long、float、double、boolean
	 * @param indexName 索引名字，类似数据库的表，是将数据添加进哪个表
	 */
	public synchronized void cache(Map<String, Object> params, String indexName){
		List<Map<String,Object>> list = cacheMap.get(indexName);
		if(list == null){
			list = new LinkedList<Map<String,Object>>();
		}
		list.add(params);
		
		if(list.size() >= this.cacheMaxNumber){
			//提交
			boolean submit = cacheSubmit(indexName);
			if(submit){
				//提交成功，那么清空indexName的list
				list.clear();
			}
		}
		
		//重新赋予cacheMap
		cacheMap.put(indexName, list);
	}
	
	/**
	 * 将当前缓存中某个索引中的数据提交到elasticsearch中
	 * @param indexName 索引名字，类似数据库的表，是将数据添加进哪个表
	 * @return true:成功；  false:提交失败
	 */
	public synchronized boolean cacheSubmit(String indexName){
		List<Map<String,Object>> list = cacheMap.get(indexName);
		if(list == null){
			return true;
		}
		
		BulkResponse res = puts(list, indexName);
		if(res == null || res.hasFailures()){
			//出现错误，那么不清空list
			return false;
		}else{
			//成功，那么清空缓存中这个索引的数据
			list.clear();
			cacheMap.put(indexName, list);
			return true;
		}
	}
	
    /**
     * 创建索引
     * @param indexName 要创建的索引的名字，传入如： testindex
     * @return 创建索引的响应对象。可以使用 {@link CreateIndexResponse#isAcknowledged()} 来判断是否创建成功。如果为true，则是创建成功
     */
    public CreateIndexResponse createIndex(String indexName) throws IOException {
    	CreateIndexResponse response;
    	if(existIndex(indexName)){
    		response = new CreateIndexResponse(false, false, indexName);
            return response;
        }
    	
        CreateIndexRequest request = new CreateIndexRequest(indexName);
        response = getRestHighLevelClient().indices().create(request, RequestOptions.DEFAULT);
        return response;
    }
	
    public static void log(String text){
    	System.out.println(text);
    }

    /**
     * 判断索引是否存在
     * @param indexName 要判断是否存在的索引的名字，传入如： testindex
     * @return 返回是否存在。
     * 		<ul>
     * 			<li>true:存在</li>
     * 			<li>false:不存在</li>
     * 		</ul>
     */
    public boolean existIndex(String index){
        GetIndexRequest request = new GetIndexRequest();
        request.indices(index);
        boolean exists;
		try {
			exists = getRestHighLevelClient().indices().exists(request, RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
        return exists;
    }
	
    /**
     * 数据添加，网 elasticsearch 中添加一条数据
     * @param params 要增加的数据，key-value形式。 其中map.value 支持的类型有 String、int、long、float、double、boolean
     * @param indexName 索引名字，类似数据库的表，是添加进那个表
     * @param id 要添加的这条数据的id, 如果传入null，则由es系统自动生成一个唯一ID
     * @return 创建结果。如果 {@link IndexResponse#getId()} 不为null、且id长度大于0，那么就成功了
     */
    public IndexResponse put(Map<String, Object> params, String indexName, String id){
        //创建请求
        IndexRequest request = new IndexRequest(indexName);
        if(id != null){
        	request.id(id);
    	}
        request.timeout(TimeValue.timeValueSeconds(5));
        
        IndexResponse response = null;
		try {
			response = getRestHighLevelClient().index(request.source(jsonFormatInterface.mapToJsonString(params), XContentType.JSON), RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
		}
        return response;
    }
    

    /**
     * 数据添加，网 elasticsearch 中添加一条数据
     * @param params 要增加的数据，key-value形式。 其中map.value 支持的类型有 String、int、long、float、double、boolean
     * @param indexName 索引名字，类似数据库的表，是添加进那个表
     * @param id 要添加的这条数据的id, 如果传入null，则由es系统自动生成一个唯一ID
     * @return 创建结果。如果 {@link IndexResponse#getId()} 不为null、且id长度大于0，那么就成功了
     */
    public IndexResponse put(Map<String, Object> params, String indexName){
        return put(params, indexName, null);
    }
    
    /**
     * 批量添加数据
     * @param list 批量添加的数据的List
     * @param indexName 索引名字，类似数据库的表，是添加进那个表
     * @return {@link BulkResponse} ，如果没提交，或者提交的是空，或者出错，那么会返回null。判断其有没有提交成功可以使用  (res != null && !res.hasFailures())    
     */
    public BulkResponse puts(List<Map<String, Object>> list, String indexName){
    	if(list.size() < 1){
    		return null;
    	}
    	
    	//批量增加
        BulkRequest bulkAddRequest = new BulkRequest();
        IndexRequest indexRequest;
        for (int i = 0; i < list.size(); i++) {
        	indexRequest = new IndexRequest(indexName);
        	indexRequest.source(jsonFormatInterface.mapToJsonString(list.get(i)), XContentType.JSON);
        	bulkAddRequest.add(indexRequest);
		}
        
        BulkResponse bulkAddResponse = null;
        try {
        	bulkAddResponse = getRestHighLevelClient().bulk(bulkAddRequest, RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
		}
        return bulkAddResponse;
    }

    /**
     * 查询并分页
     * @param indexName 索引名字
     * @param query 查询条件， {@link SearchSourceBuilder}
     * @param from 从第几条开始查询，相当于 limit a,b 中的a ，比如要从最开始第一条查，可传入： 0
     * @param size 本次查询最大查询出多少条数据 ,相当于 limit a,b 中的b
     * @return {@link SearchResponse} 结果，可以通过 response.status().getStatus() == 200 来判断是否执行成功
     */
    public SearchResponse search(String indexName, SearchSourceBuilder searchSourceBuilder, Integer from, Integer size){
        SearchRequest request = new SearchRequest(indexName);
        searchSourceBuilder.from(from);
        searchSourceBuilder.size(size);
        request.source(searchSourceBuilder);
        SearchResponse response = null;
		try {
			response = getRestHighLevelClient().search(request, RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
		}
        return response;
    }
    

    /**
     * 查询数据
     * @param indexName 索引名字
     * @param queryString 查询条件，传入如： name:guanleiming AND age:123
     * @param from 从第几条开始查询，相当于 limit a,b 中的a ，比如要从最开始第一条查，可传入： 0
     * @param size 本次查询最大查询出多少条数据 ,相当于 limit a,b 中的b
     * @param sort 排序方式。如果不需要排序，传入null即可。 比如要根据加入时间time由大到小，传入的便是： SortBuilders.fieldSort("time").order(SortOrder.DESC)
     * @return 查询的结果，封装成list返回。list中的每条都是一条结果。如果链接es出错或者查询异常又或者什么都没查出，那么都是返回一个 new ArrayList<Map<String,Object>>(); ，任何情况返回值不会为null
     * 		<p>返回的结果集中，每条会自动加入一项 esid ，这个是在es中本条记录的唯一id编号，es自动赋予的。</p> 
     */
    public List<Map<String,Object>> search(String indexName, String queryString, Integer from, Integer size, SortBuilder sort){
    	List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
    	
    	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    	if(queryString != null && queryString.length() > 0){
    		//有查询条件，才会进行查询，否则会查出所有
    		QueryBuilder queryBuilder = QueryBuilders.queryStringQuery(queryString);
    		searchSourceBuilder.query(queryBuilder);
    	}
    	
        //判断是否使用排序
        if(sort != null){
        	searchSourceBuilder.sort(sort);
        }
        SearchResponse response = search(indexName, searchSourceBuilder, from, size);
        if(response.status().getStatus() == 200){
        	SearchHit shs[] = response.getHits().getHits();
        	for (int i = 0; i < shs.length; i++) {
        		Map<String, Object> map = shs[i].getSourceAsMap();
        		map.put("esid", shs[i].getId());
				list.add(map);
			}
        }else{
        	//异常
        }
        
        return list;
    }
    

    /**
     * 查询数据
     * <p>如果数据超过100条，那么只会返回前100条数据。<p>
     * @param indexName 索引名字
     * @param queryString 查询条件，传入如： name:guanleiming AND age:123
     * @return 查询的结果，封装成list返回。list中的每条都是一条结果。如果链接es出错或者查询异常又或者什么都没查出，那么都是返回一个 new ArrayList<Map<String,Object>>(); ，任何情况返回值不会为null
     * 		<p>返回的结果集中，每条会自动加入一项 esid ，这个是在es中本条记录的唯一id编号，es自动赋予的。</p> 
     */
    public List<Map<String,Object>> search(String indexName, String queryString){
    	return search(indexName, queryString, 0, 100, null);
    }
    
    

    /**
     * 通过elasticsearch数据的id，获取这条数据
     * @param indexName 索引名字
     * @param id elasticsearch数据的id
     * @return 这条数据的内容。 如果返回null，则是没有找到这条数据，或者执行过程出错。
     */
    public Map<String,Object> searchById(String indexName, String id){
        GetRequest request = new GetRequest(indexName, id);
        GetResponse response = null;
		try {
			response = getRestHighLevelClient().get(request, RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
		if(response.isSourceEmpty()){
			//没有这条数据
			return null;
		}
		
        Map<String, Object> map = response.getSource();
        //为返回的数据添加id
        map.put("esid",response.getId());
        return map;
    }
    

    /**
     * 通过elasticsearch数据的id，来删除这条数据
     * @param indexName 索引名字
     * @param id 要删除的elasticsearch这行数据的id
     */
    public boolean deleteById(String indexName, String id) {
        DeleteRequest request = new DeleteRequest(indexName, id);
        DeleteResponse delete = null;
		try {
			delete = getRestHighLevelClient().delete(request, RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
			//删除失败
			return false;
		}
		
		if(delete == null){
			//这种情况应该不存在
			return false;
		}
		if(delete.getResult().equals(Result.DELETED)){
			return true;
		}else{
			return false;
		}
    }
    
    /**
     * 以 sql查询语句的形式，搜索 elasticsearch
     * @param sqlQuery sql查询语句，传入如： select * from user WHERE username = 'guanleiming'
     * @return List结果
     */
    public List<Map<String, Object>> searchBySqlQuery(String sqlQuery){
    	List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
    	
    	String method = "GET";
        String endPoint = "/_sql";
        Request request = new Request(method, endPoint);
        request.addParameter("format", "json");
        request.setJsonEntity("{\"query\":\""+sqlQuery+"\"}");
    	
    	try {
			Response response = getRestClient().performRequest(request);
			String text = EntityUtils.toString(response.getEntity());
			
			JSONObject json = JSONObject.parseObject(text);
			JSONArray columnsJsonArray = json.getJSONArray("columns");
			String columns[] = new String[columnsJsonArray.size()];
			//遍历columns
			for (int i = 0; i < columnsJsonArray.size(); i++) {
				JSONObject columnJsonObject = columnsJsonArray.getJSONObject(i);
				columns[i] = columnJsonObject.getString("name");
			}
			
			//遍历数据
			JSONArray rowsJsonArray = json.getJSONArray("rows");
			for (int i = 0; i < rowsJsonArray.size(); i++) {
				JSONArray row = rowsJsonArray.getJSONArray(i);
				
				Map<String, Object> map = new HashMap<String, Object>();
				for (int j = 0; j < row.size(); j++) {
					Object obj = row.get(j);
					if(obj != null){
						//如果此项不为null，那么加入 map
						map.put(columns[j], obj);
					}
				}
				list.add(map);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
    	
    	return list;
    }
    
    /**
     * group by 统计
     * @param indexName 要统计的是哪个索引（数据库表）
     * @param field 针对的是哪个字段，也就是 group by field ，如传入 username
     * @param queryBuilder 查询条件，传入如
     * <pre>
     * //查询time > 1 AND time < 10 
     * QueryBuilders.rangeQuery("time").gt(1).lt(10);
     * </pre>
     * 		其中: 
     * 			<ul>
     * 				<li>gt : 大于</li>
     * 				<li>gte : 大于等于</li>
     * 				<li>lt : 小于</li>
     * 				<li>lte : 小于等于</li>
     * 			</ul>
     * @return 结果，按照统计条数有大到小排序。如果失败，那么返回的 list.size() 为0
     */
    public List<GroupByListItem> groupBy(String indexName, String field, QueryBuilder queryBuilder){
    	SearchRequest searchRequest = new SearchRequest();
    	searchRequest.indices(indexName);
    	TermsAggregationBuilder aggregation = AggregationBuilders.terms("termsname").field(field+".keyword").order(BucketOrder.count(false)).size(100);
    	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    	searchSourceBuilder.aggregation(aggregation);
    	if(queryBuilder != null){
    		searchSourceBuilder.query(queryBuilder);
    	}
    	searchRequest.source(searchSourceBuilder);
    	
    	List<GroupByListItem> list = new ArrayList<GroupByListItem>();
    	SearchResponse response;
    	try {
			response = getRestHighLevelClient().search(searchRequest, RequestOptions.DEFAULT);
			Terms byAgeAggregation = response.getAggregations().get("termsname");
			for (Terms.Bucket buck : byAgeAggregation.getBuckets()) {
				GroupByListItem item = new GroupByListItem();
				item.setName(buck.getKeyAsString());
				item.setCount(buck.getDocCount());
				list.add(item);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
    	
    	return list;
    }
    
    /**
     * @param countSql 统计的sql语句，传入格式如： 
     * 	<pre>
     * select count(*) from useraction WHERE action='我是字符串类型' AND time > 1624001953
     * 	</pre>
     * @return 执行统计语句所获取到的结果，返回值为int类型
     */
    public int count(String countSql){
    	List<Map<String, Object>> list = searchBySqlQuery(countSql);
    	int count = (Integer) list.get(0).values().stream().findAny().get();
	    return count;
    }
    
    
    public static void main(String[] args) {
    	String indexName = "testind";
    	Map<String, Object> map = new HashMap<String, Object>();
    	map.put("username", "zhangqun222");
    	map.put("age", 17);
    	map.put("price", 12.6f);
    	map.put("a", true);
    	
//    	List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
//    	list.add(map);
//    	map.put("age", 14);
//    	list.add(map);
//    	map.put("age", 15);
//    	list.add(map);
    	
//    	final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
//    	credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("admin", "123456Abc"));
//    	RestHighLevelClient client = new RestHighLevelClient(
//                RestClient.builder(
//                        new HttpHost("114.116.251.118", 9200, "https")
//                ).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
//                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
//                        httpClientBuilder.disableAuthCaching();
//                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
//                    }
//                })
                
//                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
//                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
//                        httpClientBuilder.disableAuthCaching();
//                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
//                    }
//                })
//        );
    	
    	ElasticSearchUtil es = new ElasticSearchUtil("192.168.31.24");
    	if(!es.existIndex(indexName)){
    		try {
				es.createIndex(indexName);
			} catch (IOException e) {
				e.printStackTrace();
			}
    	}
    	
//    	IndexResponse ir = es.put(map, indexName);
//    	BulkResponse ir = es.puts(list, indexName);
//    	System.out.println(ir);
    	
//    	QueryBuilder queryBuilder = QueryBuilders.queryStringQuery("age:12 AND a:false");
//    	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//        searchSourceBuilder.query(queryBuilder);
//		System.out.println(es.searchListData(indexName, searchSourceBuilder, 0, 10).toString());

    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
    	es.cache(map, indexName);
//    	System.out.println(es.cacheSubmit(indexName));
    	
    	
//    	String method = "GET";
//        String endPoint = "/_sql";
//        Request request = new Request(method, endPoint);
//        request.addParameter("format", "json");
//        
//        String sql = "update testind set age = 18 WHERE username = 'zhangqun222'";
//        //String sql = "select * from testind WHERE username = 'zhangqun222'";
//        
//        request.setJsonEntity("{\"query\":\""+sql+"\"}");
//
//        Response response = es.getClient().p
        		.performRequest(request);
//    	
    	
//    	RestHighLevelClient
//    	RestClient restClient = RestClient.builder(
//                new HttpHost("192.168.31.24", 9200, "http")
//         ).build();
//    	try {
//			Response response = restClient.performRequest(request);
//			String text = EntityUtils.toString(response.getEntity());
//			System.out.println(text);
//			
//			JSONObject json = JSONObject.parseObject(text);
					parseObject(EntityUtils.toString(response.getEntity()));
//			System.out.println(json);
//			JSONArray columnsJsonArray = json.getJSONArray("columns");
//			String columns[] = new String[columnsJsonArray.size()];
//			//遍历columns
//			for (int i = 0; i < columnsJsonArray.size(); i++) {
//				JSONObject columnJsonObject = columnsJsonArray.getJSONObject(i);
//				columns[i] = columnJsonObject.getString("name");
//				System.out.println(columns[i]);
//			}
//			System.out.println(columns);
//			
//			//遍历数据
//			JSONArray rowsJsonArray = json.getJSONArray("rows");
//			for (int i = 0; i < rowsJsonArray.size(); i++) {
//				JSONArray row = rowsJsonArray.getJSONArray(i);
//				System.out.println(row);
//			}
//			
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
    	
    	
//    	List<Map<String, Object>> lists = es.search("useraction", "", 0, 100, null);
//    	List<Map<String, Object>> lists = es.search("useraction", "SELECT username, COUNT(*) as number GROUP BY username");
//    	List<Map<String, Object>> lists = es.search(indexName, "SELECT * FROM testind WHERE username='zhangqun222'");
//    	for (int i = 0; i < lists.size(); i++) {
//			System.out.println(lists.get(i));
//		}
//    	System.out.println(lists.size());
//    	
    	
//    	Map<String, Object> m = es.searchById(indexName, "ffcb76770ecb40dcb74bdd5b9a993164");
//    	System.out.println(m);
//    	boolean b = es.deleteById(indexName, "9902241cc47445458e17bc8d5520cb22");
//    	System.out.println(b);
    	
    	
//    	List<Map<String, Object>> list = es.searchBySqlQuery("SELECT * FROM useraction WHERE username = 'wangzhan' AND time > 1610340207219 ORDER BY time ASC LIMIT 10");
//    	for (int i = 0; i < list.size(); i++) {
//			System.out.println(list.get(i));
//		}
//		
    	
    	List<Map<String,Object>> list = es.search("useraction", "sum(*)");
    	for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
    	
    	
	}
    
}

/**
 * 进行group by统计的结果返回
 */
public class GroupByListItem {
	private String name;	//group by 搜索的列的值
	private long count;		//统计的条数
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getCount() {
		return count;
	}
	public void setCount(long count) {
		this.count = count;
	}
	@Override
	public String toString() {
		return "GroupByList [name=" + name + ", count=" + count + "]";
	}
	
}

import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSON;

/**
 * 默认的json格式化接口
 *
 */
public class DefaultJsonFormat implements JsonFormatInterface{
	
	/**
     * 将Map<String, Object>转化为json字符串
     * @param params {@link Map}
     */
	public String mapToJsonString(Map<String, Object> params) {
    	if(params == null){
    		params = new HashMap<String, Object>();
    	}
        
        return JSON.toJSONString(params);
	}
	
}

import java.util.Map;

/**
 * JSON转换相关
 *
 */
public interface JsonFormatInterface {
	
	/**
	 * 将 {@link Map} 转化为JSON格式字符串
	 * @param params {@link Map}String, Object
	 * @return JSON格式字符串。如果传入的 map为null，那么这里返回 {} 也就是空的JSON字符串。
	 * 		<p>返回如： {"username":"cxf","age":29}</p>
	 */
	public String mapToJsonString(Map<String, Object> params);
}

import java.util.Map;

/**
 * 简单的的json格式化接口，只支持map.value的类型是 String、int、long、float、double、boolean 这几个的转换
 *
 */
public class SimpleJsonFormat implements JsonFormatInterface{
	
	/**
     * 将Map<String, Object>转化为json字符串
     * @param params 其中map.value 支持的类型有 String、int、long、float、double、boolean
     */
	public String mapToJsonString(Map<String, Object> params) {
    	if(params == null){
    		return "{}";
    	}
    	StringBuffer sb = new StringBuffer();
        sb.append("{");
        for(Map.Entry<String, Object> entry : params.entrySet()){
        	Object obj = entry.getValue();
        	if(sb.length() > 1){
        		sb.append(",");
        	}
        	
        	if(obj == null){
        		sb.append("\""+entry.getKey()+"\":\"\"");
        	}else if(obj instanceof String){
        		sb.append("\""+entry.getKey()+"\":\""+((String)obj).replaceAll("\"", "\\\\\"")+"\"");
        	}else if(obj instanceof Integer){
        		sb.append("\""+entry.getKey()+"\":"+(Integer)obj+"");
        	}else if(obj instanceof Long){
        		sb.append("\""+entry.getKey()+"\":"+(Long)obj+"");
        	}else if(obj instanceof Float){
        		sb.append("\""+entry.getKey()+"\":"+(Float)obj+"");
        	}else if( obj instanceof Double){
        		sb.append("\""+entry.getKey()+"\":"+(Double)obj+"");
        	}else if(obj instanceof Boolean){
        		sb.append("\""+entry.getKey()+"\":"+(Boolean)obj+"");
        	}else{
        		//其他类型全当成toString()来处理
        		sb.append("\""+entry.getKey()+"\":"+obj.toString()+"");
        	}
        }
        sb.append("}");
        
        return sb.toString();
	}
	
	
}