es配合java使用--代码示范

本地搭建es镜像环境及谷歌插件可视化环境

https://blog.csdn.net/qq_60191219/article/details/125867721?spm=1001.2014.3001.5501

一：配置文件 --用于配置链接

elasticsearch:
  host: 127.0.0.1
  port: 9200
  scheme: http
  delayTime: 10
  index:
    event: event
    people: people
    place: place

二：es工具类 --为service提供方法

package com.spacesystech.config;

import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.IOException;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Getter
@Configuration
public class ElasticSearchConfig {

    @Value("${elasticsearch.host}")
    private String esHost;

    @Value("${elasticsearch.port}")
    private int esPort;

    @Value("${elasticsearch.scheme}")
    private String scheme;

    @Value("${elasticsearch.index.event:event}")
    private String eventIndex;

    @Value("${elasticsearch.index.people:people}")
    private String peopleIndex;

    @Value("${elasticsearch.index.place:place}")
    private String placeIndex;

    private RestHighLevelClient client;

    @PostConstruct
    public void init(){
        HttpHost[] httpHosts = Stream.of(StringUtils.split(esHost, ","))
                .map(o -> new HttpHost(o, esPort, scheme))
                .collect(Collectors.toList()).toArray(new HttpHost[]{});
        RestClientBuilder builder = RestClient.builder(httpHosts);
        client = new RestHighLevelClient(builder);
    }

    @Bean
    public RestHighLevelClient client(){
        return client;
    }

    @PreDestroy
    public void destroy(){
        if (client != null){
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三：es专有service，为其他service提供ES方法

package com.spacesystech.service.inner.impl;

import com.alibaba.fastjson.JSON;
import com.spacesystech.exception.BaseException;
import com.spacesystech.model.resp.PageResp;
import com.spacesystech.service.inner.EsDataInnerService;
import com.spacesystech.validate.annotation.ESQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.ElasticsearchException;
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.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ReflectionUtils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
public class EsDataInnerServiceImpl implements EsDataInnerService {

    @Autowired
    private RestHighLevelClient client;

    @Override
    public  List queryDocumentByParam(String index, Object query, boolean likeSearch,
                                            int pageNum, int pageSize, Class targetClass) {
        SearchResponse response = queryDocument(index, query, likeSearch, pageNum, pageSize);
        return convertResponse(response, targetClass);
    }

    @Override
    public  PageResp queryPageDocumentByParam (String index, Object query, boolean likeSearch,
                                                     int pageNum, int pageSize, Class targetClass) {
        SearchResponse response = queryDocument(index, query, likeSearch, pageNum, pageSize);
        List data = convertResponse(response, targetClass);
        long total = response.getHits().getTotalHits().value;
        return new PageResp<>(pageNum, pageSize, total, data);
    }

    private SearchResponse queryDocument(String index, Object query, boolean likeSearch,
                                         int pageNum, int pageSize) {
        int from = (pageNum - 1) * pageSize;
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //筛选 query:条件 likeSearch是否模糊
        builder.query(makeupQueryBuilder(query, likeSearch));
        builder.from(from);
        builder.size(pageSize);
        SearchRequest searchRequest = new SearchRequest(index);
        searchRequest.source(builder);
        try {
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            if (response.status() != RestStatus.OK){
                throw new BaseException("es查询失败");
            }
            return response;
        } catch (IOException e) {
            throw new BaseException("es查询连接出错：" + e.getMessage());
        }catch (ElasticsearchException e){
            throw new BaseException("es查询出错：" + e.getMessage());
        }
    }

    
    private  List convertResponse(SearchResponse response, Class clazz) {
        List list = new ArrayList<>();
        for (SearchHit hit : response.getHits()) {
            String result = hit.getSourceAsString();
            T parseObject = JSON.parseObject(result, clazz);
            if (parseObject != null) {
                Field idField = ReflectionUtils.findField(clazz, "id");
                if (idField != null) {
                    ReflectionUtils.makeAccessible(idField);
                    ReflectionUtils.setField(idField, parseObject, hit.getId());
                }
                list.add(parseObject);
            }
        }
        return list;
    }

    
    private BoolQueryBuilder makeupQueryBuilder(Object query, boolean likeSearch) {
        BoolQueryBuilder mustBuilder = new BoolQueryBuilder();
        BoolQueryBuilder shouldBuilder = new BoolQueryBuilder();
        Class clazz = query.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            ESQuery esQuery = field.getDeclaredAnnotation(ESQuery.class);
            if (esQuery == null) {
                continue;
            }
            boolean filter = esQuery.filter();
            boolean keyword = esQuery.keyword();
            boolean wildcard = esQuery.wildcard();
            String fieldName = field.getName();
            ReflectionUtils.makeAccessible(field);
            Object value = ReflectionUtils.getField(field, query);
            if (valueIsEmpty(value)) {
                continue;
            }
            if (filter) {
                //筛选项必须单独满足
                if (wildcard){
                    String likeValue = "*" + value.toString() + "*";
                    mustBuilder.must(QueryBuilders.wildcardQuery(fieldName, likeValue));
                }else {
                    mustBuilder.must(QueryBuilders.matchQuery(fieldName, value));
                }
            } else {
                //非keyword类型的数据会被分词，已经是模糊查询
                if (likeSearch && keyword) {
                    String likeValue = "*" + value.toString() + "*";
                    shouldBuilder.should(QueryBuilders.wildcardQuery(fieldName, likeValue));
                } else {
                    shouldBuilder.should(QueryBuilders.matchQuery(fieldName, value).operator(Operator.AND));
                }
            }
        }
        mustBuilder.must(shouldBuilder);
        return mustBuilder;
    }

    
    private static boolean valueIsEmpty(Object value) {
        if (value instanceof String) {
            return StringUtils.isBlank((String) value);
        }
        return value == null;
    }

    public RestHighLevelClient getClient() {
        return client;
    }

    public void setClient(RestHighLevelClient client) {
        this.client = client;
    }

}

四：为其他service提供了两个方法，list和分页

 List queryDocumentByParam(String index, Object query, boolean likeSearch,
                                 int pageNum, int pageSize, Class targetClass);

 PageResp queryPageDocumentByParam (String index, Object query, boolean likeSearch,
                                          int pageNum, int pageSize, Class targetClass);