SpringBoot-ElasticSearch8

前沿

elasticsearch-rest-high-level-client在 7.15.0 中已弃用。
不推荐使用高级 REST 客户端，取而代之的是 Java API 客户端 。
spring-boot-starter-data-elasticsearch 也不推荐,虽然基础操作简化了很多,但是一旦使用了es高级特性,那么就如同进入了地狱,同时elasticsearch更新太快了spring-boot-starter-data-elasticsearch的版本根本就赶不上,导致升级会出现很多问题

现在在es官网推荐我们现在使用 Elasticsearch Java API 客户端 这个是相当于直接使用elasticsearch自身的接口Api所以不存在升级不兼容的问题

Java API 客户端官网地址

elasticsearch Api 操作大全 rest-api

需要的Maven

官网推荐依赖
经过各种的依赖冲突的解决,终于能跑起来了…

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
	<!--要和es版本一致-->
        <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.1.2</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.12.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>



        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>


    </dependencies>

创建客户端

        RestClient restClient = RestClient.builder(
                new HttpHost("localhost", 9200)).build();
        ElasticsearchTransport transport = new RestClientTransport(
                restClient, new JacksonJsonpMapper());
        //es 客户端
        ElasticsearchClient client = new ElasticsearchClient(transport);

创建索引和映射分片等…

官方文档没有关于怎么设置映射和索引的配置的,自能自己研究,经过千辛万苦看底层源代码(一点注释都没有),了解代码编写的逻辑,经过我不懈的努力终于实现了以下的基础配置,其他的高级配置可以进行参考下配置进行扩展

        //构建索引,并且起一个别名
        CreateIndexResponse createResponse = client.indices()
                .create(c -> c
                        .index("my-index") //创索引
                        .aliases("main-index", a -> a   //创别名
                                .isWriteIndex(true)
                        )
                        // 映射字段属性
                        .mappings((m)-> m
                                .properties("name",Property.of(p->p.text(TextProperty.of(p1->p1.analyzer("ik_max_word").searchAnalyzer("ik_smart")))))
                                .properties("sku" ,Property.of(p->p.text(TextProperty.of(p1->p1.analyzer("ik_max_word").searchAnalyzer("ik_smart")))))
                                .properties("price",Property.of(p->p.integer(IntegerNumberProperty.of(p1->p1))) )
                            )
                        //设置分片   ,numberOfShards分片     ,Replicas副本
                        .settings((s)->s.numberOfShards("1").numberOfReplicas("2"))
                );

        System.out.println(createResponse.index());

自己进行二次封装

把官方文档看完后,我只想说一句,真难用, 经过3天的代码封装,基本能解决es的百分之90%的使用场景,代码压缩和简化程度至少优化了50%,同时保留了原有的代码特性, 特殊场景提供了对外客户端自己也可以进行二次开发,特殊的操作需要自己通过es的api接口手动进行修操作,在后端操作es一般就是增删改查数据,以及聚合,高亮等

结构

application.yml

es:
  port: 9200
  hostname:  localhost
  alals: true  # 是否使用别名的方式访问

注解

@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface DocId {
}

@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface EsClass {

    /**
     * 索引: 前缀index +   默认类名( 自动转小写)
     * 默认类名可以修改为我们自定义
     * @return
     */
    String index() default "";
    /**
     * 别名: 前缀alias + 默认类名( 自动转小写)
     *默认类名可以修改为我们自定义
     * @return
     */
    String alias() default "" ;
    /*
     *  分片
     */
    int shards()default 1;

    /**
     *  分片副本
     * @return
     */
    int replicas()default 1;
}

@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface EsField {
    //默认属性名
    String name()default "" ;
    //数据类型
    EsDataType type();
    String analyzer()default ""; //分词
    String searchAnalyzer()default ""; //搜索分词
}

枚举

不一定都能用,有些可能随着es版本的变化,去掉了,需要啥自行修改

public enum EsDataType {
    TEXT("text"),
    KEYWORD("keyword"),


    FLOAT("float"),
    LONG("long"),
    INTEGER("integer"),
    SHORT("short"),
    DOUBLE("double"),
    HALF_FLOAT("half_float"),
    SCALED_FLOAT("scaled_float"),
    BYTE("byte"),


    DATE("date"),


    BOOLEAN("boolean"),
    RANGE("rang"),
    BINARY("binary"),
    ARRAY("array"),
    OBJECT("object"),
    NESTED("nested"),
    GEO_POINT("geo_point"),
    GEO_SHAPE("geo_shape"),
    IP("ip"),
    COMPLETION("completion"),
    TOKEN_COUNT("token_count"),
    ATTACHMENT("attachment"),
    PERCOLATOR("percolator");

    private String type;

    EsDataType(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

自定义es客户端工具类

package com.es8.utli;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregate;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.cat.aliases.AliasesRecord;
import co.elastic.clients.elasticsearch.cat.indices.IndicesRecord;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkResponseItem;
import co.elastic.clients.elasticsearch.core.search.Highlight;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.indices.Alias;
import co.elastic.clients.elasticsearch.indices.CreateIndexRequest;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import co.elastic.clients.util.ObjectBuilder;
import com.alibaba.fastjson.JSONObject;
import com.es8.an.DocId;
import com.es8.an.EsClass;
import com.es8.an.EsField;
import com.es8.esenum.EsDataType;
import com.obj.objcopy.ObjectCopyUtil;
import com.reflect.ClassUtls;
import com.string.PatternCommon;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.lang.reflect.Field;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Component("es8Client")
public class Es8Client implements InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(Es8Client.class);

    @Value("${es.port}")
    private int prot;

    @Value("${es.hostname}")
    private String hostname;

    @Value("${es.alals}")
    private boolean alals;

    private ElasticsearchClient client;
    private ElasticsearchAsyncClient asyncClient;
    private final String indexPrefix = "index-";
    private final String aliasPrefix = "alias-";

    // 同步客户端
    public ElasticsearchClient getClient() {
        return client;
    }

    // 异步客户端
    public ElasticsearchAsyncClient getAsyncClient() {
        return asyncClient;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        RestClient restClient = RestClient.builder(new HttpHost(hostname, prot)).build();
        ElasticsearchTransport transport =
                new RestClientTransport(restClient, new JacksonJsonpMapper());
        // es 客户端
        this.client = new ElasticsearchClient(transport);
        this.asyncClient = new ElasticsearchAsyncClient(transport);
    }

    /**
     * 如果索引或者别名已经存在,那么就不会在创建了
     * @return 是否成功
     * @throws Exception
     */
    public <T> boolean createIndexSettingsMappings(Class<T> tClass) throws Exception {

        EsClass annotation = tClass.getAnnotation(EsClass.class);
        String index = getClassIndex(tClass);
        String alias = getClassAlias(tClass);

        List<String> indexs = indexs();
        List<String> aliases = aliases();
        if(indexs.contains(index)||aliases.contains(alias)){
            return false;
        }
        int shards = annotation.shards();
        int replicas = annotation.replicas();
        StringBuilder stringBuilder = new StringBuilder("{");
        stringBuilder.append(
                "\"settings\": {\n"
                        + "    \"number_of_shards\": "
                        + shards
                        + ",\n"
                        + "    \"number_of_replicas\": "
                        + replicas
                        + "\n"
                        + "  },");
        stringBuilder.append("\"mappings\": {\n" + "    \"properties\": ");
        JSONObject jsonObject = new JSONObject();
        for (Field declaredField : tClass.getDeclaredFields()) {
            declaredField.setAccessible(true);
            JSONObject jsonObject1 = new JSONObject();
            DocId DocId = declaredField.getAnnotation(DocId.class);
            if (DocId != null) {
                jsonObject1.put("type", EsDataType.LONG.getType());
                jsonObject.put(declaredField.getName(), jsonObject1);
                continue;
            }

            EsField annotation1 = declaredField.getAnnotation(EsField.class);
            if (annotation1 != null) {
                String name = annotation1.name();
                name = "".equals(name) ? declaredField.getName() : name;
                EsDataType type = annotation1.type();
                String analyzer = annotation1.analyzer();
                String searchAnalyzer = annotation1.searchAnalyzer();
                jsonObject1.put("type", type.getType());
                if (!"".equals(analyzer)) {
                    jsonObject1.put("analyzer", analyzer);
                }
                if (!"".equals(searchAnalyzer)) {
                    jsonObject1.put("search_analyzer", searchAnalyzer);
                }
                jsonObject.put(name, jsonObject1);
            }
        }
        Assert.isTrue(jsonObject.size() > 0, "请添加es相关注解");
        stringBuilder.append(jsonObject);
        stringBuilder.append("}}");
        Reader queryJson = new StringReader(stringBuilder.toString());


        String finalIndex = index;
        String finalAlias = alias;
        CreateIndexRequest req =
                CreateIndexRequest.of(
                        b ->
                                b.index(finalIndex)
                                        .aliases(finalAlias, Alias.of(a -> a.isWriteIndex(true)))
                                        .withJson(queryJson));

        return client.indices().create(req).acknowledged();
    }

    // 查询全部索引
    public List<String> indexs() {
        List<IndicesRecord> indices = null;
        try {
            indices = client.cat().indices().valueBody();

        } catch (IOException e) {
            e.printStackTrace();
        }
        assert indices != null;
        return indices.stream().map(IndicesRecord::index).collect(Collectors.toList());
    }

    // 查询全部别名
    public List<String> aliases() {
        List<AliasesRecord> aliasesRecords = null;
        try {
            aliasesRecords = client.cat().aliases().valueBody();
        } catch (IOException e) {
            e.printStackTrace();
        }
        assert aliasesRecords != null;
        return aliasesRecords.stream().map(AliasesRecord::alias).collect(Collectors.toList());
    }


    //查询全部数据
    public <T> List<T> queryAll(Class<T> tClass) throws IOException {
        List<T> list = new ArrayList<>();
        String index = getClassAlalsOrIndex(tClass);
        SearchResponse<T> search = client.search(s -> s.index(index).query(q -> q.matchAll(m -> m)), tClass);
        for (Hit<T> hit : search.hits().hits()) {
            list.add(hit.source());
        }
        return list;
    }


    // 添加数据

    /**
     * @param o     数据源
     * @param async 是否异步 true异步 ,false同步 ,如果是异步那么永远返回null
     * @return
     */
    public <T> String addData(T o, boolean async) {
        Object id = null;
        for (Field declaredField : o.getClass().getDeclaredFields()) {
            declaredField.setAccessible(true);
            DocId annotation = declaredField.getAnnotation(DocId.class);
            if (annotation != null) {
                try {
                    id =  declaredField.get(o);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        if (id == null) {
            id = UUID.randomUUID().toString();
        }
        IndexResponse response = null;

        try {
            IndexRequest.Builder<T> indexReqBuilder = new IndexRequest.Builder<>();
            indexReqBuilder.index(getClassAlias(o.getClass()));
            indexReqBuilder.id(String.valueOf(id));
            indexReqBuilder.document(o);
            if (async) {
                asyncClient.index(indexReqBuilder.build());
                return null;
            }
            response = client.index(indexReqBuilder.build());
        } catch (IOException e) {
            e.printStackTrace();
        }
        assert response != null;
        return response.id();
    }

    //查询指定文档id数据是否存在
    public <T> boolean docIdexists(Class<T> tClass, String id) throws IOException {
        return client.exists(s -> s.index(getClassAlias(tClass)).id(id)).value();
    }


    // 批量添加
    public <T> void addDatas(List<T> list, boolean async) {

        BulkRequest.Builder br = new BulkRequest.Builder();
        for (T o : list) {
            Object id = null;
            for (Field declaredField : o.getClass().getDeclaredFields()) {
                declaredField.setAccessible(true);
                DocId annotation = declaredField.getAnnotation(DocId.class);
                if (annotation != null) {
                    try {
                        id =  declaredField.get(o);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
            if (id == null) {
                id = UUID.randomUUID().getMostSignificantBits();
            }
            Object finalId = id;
            br.operations(
                    op ->
                            op.index(
                                    idx ->
                                            idx.index(getClassAlias(o.getClass())).id(String.valueOf(finalId)).document(o)));
        }

        if (async) {
            asyncClient.bulk(br.build());
            return;
        }
        BulkResponse result = null;
        try {
            result = client.bulk(br.build());
        } catch (IOException e) {
            e.printStackTrace();
        }
        // Log errors, if any
        assert result != null;
        if (result.errors()) {
            log.error("Bulk had errors");
            for (BulkResponseItem item : result.items()) {
                if (item.error() != null) {
                    log.error(item.error().reason());
                }
            }
        }
    }

    public <T> T getDocId(String DocId, Class<T> clazz) {
        GetResponse<T> response = null;
        try {

            response = client.get(g -> g.index(getClassAlias(clazz)).id(DocId), clazz);
        } catch (IOException e) {
            e.printStackTrace();
        }

        assert response != null;
        return response.source();
    }

    public <T> List<T> complexQuery(Query query, Class<T> clazz) throws IOException {
        List<T> list = new ArrayList<>();

        SearchResponse<T> response =
                client.search(s -> s.index(getClassAlias(clazz)).query(query), clazz);
        List<Hit<T>> hits = response.hits().hits();
        for (Hit<T> hit : hits) {
            list.add(hit.source());
        }
        return list;
    }

    public <T> Aggregate complexQueryAggregations(
            Query query, Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn, Class<T> clazz)
            throws IOException {

        SearchResponse<T> response =
                client.search(
                        s ->
                                s.index(getClassAlias(clazz))
                                        .size(0) // 不需要显示数据 ,只想要聚合结果
                                        .query(query)
                                        .aggregations("aggregations", fn),
                        clazz);

        return response.aggregations().get("aggregations");
    }

    public <T> List<Map<String ,Object>> complexQueryHighlight(Query query, Class<T> clazz, String... fields) throws IOException {

        List<Map<String ,Object>> list =  new ArrayList<Map<String ,Object>>();

        String index = getClassAlalsOrIndex(clazz);
        Highlight of = Highlight.of(h -> {
                    for (String field : fields) {
                        h.fields(
                                field
                                ,
                                h1 -> h1.preTags("<font color='red'>").postTags("</font>"));
                    }
                    return h;
                }
        );
        SearchResponse<T> response = client.search(s -> s
                        .index(index)
                        .query(query)
                        .highlight(of)
                , clazz
        );

        for (Hit<T> hit : response.hits().hits()) {
            Map<String ,Object> map=new HashMap<>();
            map.put("source",hit.source());
            map.put("highlight",hit.highlight());
            list.add(map);
        }
        return list;
    }

    //根据id进行删除
    public  <T> void delDocId( String docId,Class<T> clazz) throws IOException {
        String index = getClassAlalsOrIndex(clazz);
        DeleteRequest de = DeleteRequest.of(d -> d.index(index).id(docId));
        client.delete(de);
    }
    //根据查询进行删除
    public  <T> void delQuery( Query query,Class<T> clazz) throws IOException {
        String index = getClassAlalsOrIndex(clazz);
        DeleteByQueryRequest de = DeleteByQueryRequest.of(d -> d.index(index).query(query));
        client.deleteByQuery(de);
    }

    public  <T> void upDocId(String docId,T o,boolean async) throws Exception {
        //先查询出来
        Object docId1 = getDocId(docId, o.getClass());
        if (docId1==null) {
            throw new Exception("没有docId:"+docId+"这条数据");
        }
        //进行对象拷贝
        ObjectCopyUtil.copy(o,docId1);
        String index = getClassAlalsOrIndex(o.getClass());
        if (async) {
            asyncClient.update(UpdateRequest.of(d -> d.index(index).id(docId).doc(o)), o.getClass());
            return;
        }
        client.update(UpdateRequest.of(d -> d.index(index).id(docId).doc(o)), o.getClass());

    }
    public  <T> void upQuery(Query query,T o,boolean async) throws Exception {
        Class<?> aClass = o.getClass();
        String index = getClassAlalsOrIndex(aClass);
        //获取全部字段和字段的名称以及需要修改的值
        StringBuilder stringBuilder=new StringBuilder();
        for (Field declaredField : aClass.getDeclaredFields()) {
            declaredField.setAccessible(true);
            Object o1 = declaredField.get(o);
            if (o1==null) {
                continue;
            }
            declaredField.setAccessible(true);
            EsField field = declaredField.getAnnotation(EsField.class);
            String name = field.name();
            name = "".equals(name) ? declaredField.getName() : name;
            String finalName = name;
            String str = PatternCommon.renderString("ctx._source['${name}'] = '${value}';", new HashMap() {{
                put("name", finalName);
                put("value",o1) ;
            }});
            stringBuilder.append(str);
        }

        UpdateByQueryRequest of = UpdateByQueryRequest.of(u -> u.index(index).query(query).script(s -> s.inline(i -> i.source(stringBuilder.toString()))));
        if (async) {
            asyncClient.updateByQuery(of);
            return;
        }
        client.updateByQuery(of);
    }

    /**
     * 使用索引还是使用别名
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> String getClassAlalsOrIndex(Class<T> clazz){
        if(alals){
            return getClassAlias(clazz);
        }
        return getClassIndex(clazz);

    }

    //获取类的索引名称(没有指定默认类名首字母小写,  前缀+索引)
    private  <T>  String getClassIndex(Class<T>  clazz){
        EsClass annotation = clazz.getAnnotation(EsClass.class);
        String index = annotation.index();
        index =
                "".equals(index)
                        ? Objects.requireNonNull(ClassUtls.getClassName(clazz)).toLowerCase()
                        : index.toLowerCase();
        return indexPrefix +index;
    }

    private  <T>  String getClassAlias(Class<T>  clazz){
        EsClass annotation = clazz.getAnnotation(EsClass.class);
        String alias = annotation.alias();
        alias =
                "".equals(alias)
                        ? Objects.requireNonNull(ClassUtls.getClassName(clazz)).toLowerCase()
                        : alias.toLowerCase();
        return aliasPrefix +alias;
    }

    //获取对象的文档id
    public   <T> Long  getObjId(T o){
        Long id = null;
        for (Field declaredField : o.getClass().getDeclaredFields()) {
            declaredField.setAccessible(true);
            DocId annotation = declaredField.getAnnotation(DocId.class);
            if (annotation != null) {
                try {
                    id = (Long) declaredField.get(o);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return  id;
    }

}

测试实体类

// 只能使用包装类型 ,不能使用基础类型 ,否则会导致一些高级特性有问题
@EsClass
@Data
public class UserEsEneity {

    @DocId
    private  Long id;
    @Field(type = EsDataType.KEYWORD   )
    private  String name;
    @Field(type =EsDataType.INTEGER)
    private  Integer age;
    @Field(type = EsDataType.TEXT,analyzer = "ik_max_word",searchAnalyzer = "ik_smart")
    private  String dec;
    @Field(type =EsDataType.KEYWORD)
    private  String sku;
    @Field(type =EsDataType.DOUBLE)
    private  Double price;
}

测试Junit类

package com.es8;

import co.elastic.clients.elasticsearch._types.aggregations.Aggregate;
import co.elastic.clients.elasticsearch._types.aggregations.LongTermsBucket;
import co.elastic.clients.elasticsearch._types.aggregations.StringTermsBucket;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import com.es8.eneity.UserEsEneity;
import com.es8.utli.Es8Client;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Es8Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Es8ApplictionTest {
    private static final Logger logger = LoggerFactory.getLogger(Es8Client.class);
    @Autowired
    private Es8Client es8Client;

    @Test
    public void createIndexSettingsMappings() throws Exception {
        es8Client.createIndexSettingsMappings(UserEsEneity.class);

    }

    @Test
    public void aliases() throws Exception {
        System.out.println(es8Client.aliases());
    }

    @Test
    public void indexs() throws Exception {
        System.out.println(es8Client.indexs());
    }

    @Test
    public void selectDocIdExists() throws Exception {
        if (es8Client.docIdexists(UserEsEneity.class, "1")) {
            System.out.println("product exists");
        }

    }

    @Test
    public void queryAll() throws Exception {
        List<UserEsEneity> querys = es8Client.queryAll(UserEsEneity.class);
        System.out.println(querys);

    }

    @Test
    public void addData() throws IOException {
        UserEsEneity userEsEneity = new UserEsEneity();
        userEsEneity.setId(22L);
        userEsEneity.setName("xxxxa");
        userEsEneity.setAge(22);
        userEsEneity.setDec("xxxxxxxx");
        userEsEneity.setPrice(22.1);
        userEsEneity.setSku("aaa1");
        String s = es8Client.addData(userEsEneity, true);
        System.out.println(s);
    }

    @Test
    public void addDatas() throws IOException {
        UserEsEneity userEsEneity = new UserEsEneity();
        userEsEneity.setId(23L);
        userEsEneity.setName("hu");
        userEsEneity.setAge(22);
        userEsEneity.setDec("游泳");
        userEsEneity.setPrice(22.1);
        userEsEneity.setSku("aaa1");

        UserEsEneity userEsEneity1 = new UserEsEneity();
        userEsEneity1.setId(24L);
        userEsEneity1.setName("an");
        userEsEneity1.setAge(22);
        userEsEneity1.setDec("");
        userEsEneity1.setPrice(22.2);
        userEsEneity1.setSku("vvvvvv");

        List<UserEsEneity> list = new ArrayList<>();
        list.add(userEsEneity);
        list.add(userEsEneity1);
        es8Client.addDatas(list, true);
    }

    @Test
    public void getDocId() throws IOException {
        UserEsEneity docId = es8Client.getDocId("24", UserEsEneity.class);
        System.out.println(docId);
    }

    @Test
    public void complexQuery_MatchAll() throws IOException {
        Query query = Query.of(q -> q.matchAll(m -> m));
        List<UserEsEneity> userEsEneities = es8Client.complexQuery(query, UserEsEneity.class);
        System.out.println(userEsEneities);
    }

    @Test
    public void complexQuery_MatchAll_Alals() throws IOException {
        Query query = Query.of(q -> q.matchAll(m -> m));
        List<UserEsEneity> userEsEneities = es8Client.complexQuery(query, UserEsEneity.class);
        System.out.println(userEsEneities);
    }

    @Test
    public void complexQuery_MatchQuery() throws IOException {
        Query query = Query.of(q -> q.match(m -> m.field("name").query("xxxxa")));
        List<UserEsEneity> userEsEneities = es8Client.complexQuery(query, UserEsEneity.class);
        System.out.println(userEsEneities);
    }

    @Test
    public void complexQuery_query_bool_must() throws IOException {
        Query age = Query.of(q -> q.match(m -> m.field("age").query(22)));
        Query price = Query.of(q -> q.match(m -> m.field("price").query(22.1)));

        Query bool = Query.of(q -> q.bool(b -> b.must(age).must(price)));
        List<UserEsEneity> userEsEneities = es8Client.complexQuery(bool, UserEsEneity.class);
        System.out.println(userEsEneities);
    }

    @Test
    public void complexQueryHighlight() throws IOException {
        Query dec = Query.of(q -> q.matchPhrase(m -> m.field("dec").query("匹配")));
        List<Map<String, Object>> maps = es8Client.complexQueryHighlight(dec, UserEsEneity.class, "dec");

        System.out.println(maps);
    }

    @Test
    public void complexQuery_query_complexQueryAggregations() throws IOException {
        Query query = Query.of(q -> q.matchAll(m -> m));

        Aggregate age = es8Client.complexQueryAggregations(query, a ->
                        a.terms(t -> t.field("age"))
                , UserEsEneity.class);

        for (LongTermsBucket longTermsBucket : age.lterms().buckets().array()) {

            System.out.println("key:" + longTermsBucket.key() + ":共多少:" + longTermsBucket.docCount());
        }

        Aggregate name = es8Client.complexQueryAggregations(query, a ->
                        a.terms(t -> t.field("name"))
                , UserEsEneity.class);

        for (StringTermsBucket stringTermsBucket : name.sterms().buckets().array()) {
            System.out.println("key:" + stringTermsBucket.key() + ":共多少:" + stringTermsBucket.docCount());
        }


        Aggregate price = es8Client.complexQueryAggregations(query, a ->
                        a.avg(t -> t.field("price"))
                , UserEsEneity.class);

        System.out.println(price.avg().value());
    }

    @Test
    public void delDocId() throws IOException {
        es8Client.delDocId("23", UserEsEneity.class);
    }

    @Test
    public void delQuery() throws IOException {
        Query price = Query.of(q -> q.match(m -> m.field("price").query("0.0")));
        es8Client.delQuery(price, UserEsEneity.class);
    }

    @Test
    public void upDocId() throws Exception {
        UserEsEneity userEsEneity1 = new UserEsEneity();
//        userEsEneity1.setId(24L);
//        userEsEneity1.setName("an");
        userEsEneity1.setAge(21);
        userEsEneity1.setDec("嘻嘻嘻嘻嘻嘻擦擦擦");
        userEsEneity1.setPrice(28.2);
        userEsEneity1.setSku("mmmmm");
        es8Client.upDocId("241", userEsEneity1, true);
    }

    @Test
    public void upQuery() throws Exception {

        UserEsEneity userEsEneity1 = new UserEsEneity();
//        userEsEneity1.setId(24L);
//        userEsEneity1.setName("an");
//        userEsEneity1.setAge(21);
        userEsEneity1.setDec("嘻嘻嘻嘻嘻嘻擦擦擦");
//        userEsEneity1.setPrice(28.2);
//        userEsEneity1.setSku("mmmmm");

        Query name = Query.of(q -> q.matchPhrase(m -> m.field("age").query("33")));
        es8Client.upQuery(name, userEsEneity1, true);
    }

}