18.Elaticseach工具类

于 2022-01-25 09:54:53 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： Java工具类 文章标签： java
zlx
本文链接：https://blog.csdn.net/weixin_43741092/article/details/122679590
版权 
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.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.text.Text;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.metrics.Stats;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.stereotype.Component;

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

/**
 * @Auther: zlx
 * @Date: 2020/4/28 09:33
 * @Description:
 */
@Component
@Slf4j
public class EsUtil {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * @param index    索引名称
     * @param settings
     * @param mapping  需要设置的映射(配置是否分词,是否索引等)
     * @return
     * @throws IOException
     */
    public boolean createIndex(String index,
                               String settings,
                               String mapping) throws IOException {
        // 新建创建索引请求对象，然后设置索引类型（ES 7.0将不存在索引类型）和 mapping 与 index 配置
        CreateIndexRequest createIndexRequest = new CreateIndexRequest(index);
        createIndexRequest.settings(settings, XContentType.JSON);
        createIndexRequest.mapping(mapping, XContentType.JSON);
        // RestHighLevelClient 执行创建索引
        CreateIndexResponse createIndexResponse =
                restHighLevelClient.indices()
                        .create(createIndexRequest, RequestOptions.DEFAULT);
        // 判断是否创建成功
        return createIndexResponse.isAcknowledged();
    }

    /**
     * 删除索引
     *
     * @param index 索引名称
     * @return 是否删除成功
     * @throws IOException
     */
    public boolean deleteIndex(String index) throws IOException {
        // 新建删除索引请求对象
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(index);
        // 执行删除索引
        AcknowledgedResponse acknowledgedResponse =
                restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        // 判断是否删除成功
        return acknowledgedResponse.isAcknowledged();
    }

    /**
     * 判断索引是否存在
     *
     * @param index
     * @return
     * @throws IOException
     */
    public boolean existsIndex(String index) throws IOException {
        GetIndexRequest request = new GetIndexRequest(index);
        return restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
    }

    /**
     * 新增或修改单条数据
     *
     * @param index
     * @param entity
     * @return
     */
    public <T> boolean insertOrUpdateOne(String index, EsEntity<T> entity) {
        try {
            IndexRequest request = new IndexRequest(index);
            request.id(entity.getId());
            request.source(JSON.toJSONString(entity.getData()), XContentType.JSON);
            IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
            log.info("新增或修改状态：{}", response.getResult());
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 批量插入数据
     *
     * @param index
     * @param list
     * @return
     */
    public <T> boolean insertBatch(String index, List<EsEntity<T>> list) {
        try {
            BulkRequest request = new BulkRequest();
            list.forEach(item -> request.add(
                    new IndexRequest(index)
                            .id(item.getId())
                            .source(JSON.toJSONString(item.getData()), XContentType.JSON)
            ));
            BulkResponse bulk = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
            return !bulk.hasFailures();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 单条数据删除
     *
     * @param index
     * @param id
     * @return
     */
    public boolean deleteOne(String index, String id) {
        try {
            // 创建删除请求对象
            DeleteRequest request = new DeleteRequest(index);
            request.id(id);
            // 执行删除文档
            DeleteResponse response = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
            log.info("删除状态：{}", response.status());
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 批量删除
     *
     * @param ids
     * @param index
     * @return
     */
    public boolean deleteDataBatch(String index, Collection<String> ids) {
        try {
            BulkRequest request = new BulkRequest();
            ids.forEach(item -> request.add(new DeleteRequest(index, item)));
            restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 根据id查询
     *
     * @param index
     * @param id
     * @return
     */
    public <T> EsEntity<T> getById(String index, String id, Class<T> tClass) {
        EsEntity<T> esEntity = new EsEntity<>();
        try {
            // 获取请求对象
            GetRequest getRequest = new GetRequest(index, id);
            // 获取文档信息
            GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
            if (getResponse.getSourceAsString() != null) {
                T t = JSON.parseObject(getResponse.getSourceAsString(), tClass);
                esEntity.setData(t);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return esEntity;
    }


    /**
     * @param index           索引名称
     * @param fields          需要显示的字段，逗号分隔（缺省为全部字段）
     * @param query           查询条件
     * @param sortField       排序字段(倒序)
     * @param highlightFields 需要高亮的字段，逗号分隔（缺省为无）
     * @return List<T>
     */
    public <T> List<T> search(String index,
                              String fields,
                              QueryBuilder query,
                              String sortField,
                              String highlightFields,
                              Class<T> tClass) {
        //搜索对象
        SearchRequest searchRequest = new SearchRequest(index);

        //搜索源对象构建
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //搜索条件
        searchSourceBuilder.query(query);
        //设置按字段排序
        if (StringUtils.isNotEmpty(sortField)) {
            searchSourceBuilder.sort(sortField, SortOrder.DESC);
        }
        //过滤字段
        if (StringUtils.isNotEmpty(fields)) {
            searchSourceBuilder.fetchSource(fields.split(","), null);
        }

        //设置最低得分 得分低于1.75会被舍弃
        //searchSourceBuilder.minScore(1.75F);

        return trySearch(searchRequest, searchSourceBuilder, highlightFields, tClass);

    }


    /**
     * @param index           索引名称
     * @param fields          需要显示的字段，逗号分隔（缺省为全部字段）
     * @param query           查询条件
     * @param sortField       排序字段(倒序)
     * @param highlightFields 需要高亮的字段，逗号分隔（缺省为无）
     * @param pageNum         页码
     * @param pageSize        每页数量
     * @return Page<T>
     */
    public <T> Page<T> searchPage(String index,
                                  String fields,
                                  QueryBuilder query,
                                  String sortField,
                                  int pageNum,
                                  int pageSize,
                                  String highlightFields,
                                  Class<T> tClass) {
        Page<T> page = new Page<>();
        int total = 0;
        int count = 0;

        //搜索对象
        SearchRequest searchRequest = new SearchRequest(index);

        //搜索源对象构建
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //搜索条件
        searchSourceBuilder.query(query);
        //设置按字段排序
        if (StringUtils.isNotEmpty(sortField)) {
            searchSourceBuilder.sort(sortField, SortOrder.DESC);
        }
        //过滤字段
        if (StringUtils.isNotEmpty(fields)) {
            searchSourceBuilder.fetchSource(fields.split(","), null);
        }

        //设置最低得分 得分低于1.75会被舍弃
        //searchSourceBuilder.minScore(1.75F);

        //计算起始下标
        int from = (pageNum - 1) * pageSize;
        searchSourceBuilder.from(from);//起始下标,从0开始
        searchSourceBuilder.size(pageSize);//每页记录数
        List<T> res = trySearch(searchRequest, searchSourceBuilder, highlightFields, tClass);
        page.setPageNum(pageNum);
        page.setPageSize(pageSize);
        page.setTotal(total);
        page.setPageCount(count);
        page.setList(res);
        return page;

    }

    public <T> List<T> trySearch(SearchRequest searchRequest,
                                 SearchSourceBuilder searchSourceBuilder,
                                 String highlightFields,
                                 Class<T> tClass) {
        List<T> searchList = new ArrayList<>();
        //设置搜索源
        searchRequest.source(searchSourceBuilder);

        //设置高亮
        if (StringUtils.isNotEmpty(highlightFields)) {
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<span style='color:red'>");
            highlightBuilder.postTags("</span>");
            List<HighlightBuilder.Field> fields = highlightBuilder.fields();
            for (String highlightField : highlightFields.split(",")) {
                fields.add(new HighlightBuilder.Field(highlightField));
            }
            searchSourceBuilder.highlighter(highlightBuilder);
        }
        //执行搜索
        SearchResponse searchResponse = null;
        try {
            searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //搜索匹配结果
        assert searchResponse != null;
        SearchHits hits = searchResponse.getHits();
        //搜索总记录数
        long totalHits = hits.getTotalHits().value;
        System.out.println("总记录数:" + totalHits);
        if (totalHits > 0) {
            //匹配度较高的前n的文档
            SearchHit[] searchHits = hits.getHits();
            for (SearchHit hit : searchHits) {
                //获取源文档需要高亮的字段
                String name;
                //取出高亮字段
                Map<String, HighlightField> highlightFieldMap = hit.getHighlightFields();
                if (highlightFieldMap != null && !highlightFieldMap.isEmpty()) {
                    //取出高亮字段
                    for (String highlightField : highlightFields.split(",")) {
                        HighlightField nameField = highlightFieldMap.get(highlightField);
                        if (nameField != null) {
                            Text[] fragments = nameField.fragments();
                            StringBuilder stringBuffer = new StringBuilder();
                            for (Text text : fragments) {
                                stringBuffer.append(text);
                            }
                            name = stringBuffer.toString();
                            hit.getSourceAsMap().put(highlightField, name);
                        }
                    }
                }
                searchList.add(JSON.parseObject(JSONUtil.toJsonStr(hit.getSourceAsMap()), tClass));
            }
        }
        return searchList;
    }

    /**
     * @param index       索引名称
     * @param aggregation 聚合函数
     * @param isHits      是否查询具体数据
     * @return Aggregation
     */
    public Aggregation searchAggregation(String index,
                                         AggregationBuilder aggregation,
                                         boolean isHits) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        if (!isHits) {
            searchSourceBuilder.size(0);
        }
        SearchRequest searchRequest = new SearchRequest(index);
        searchSourceBuilder.aggregation(aggregation);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try {
            searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        assert searchResponse != null;
        Map<String, Aggregation> stringAggregationMap = searchResponse.getAggregations().asMap();
        return stringAggregationMap.get(aggregation.getName());
    }
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * @Auther: zlx
 * @Date: 2020/4/28 09:52
 * @Description: ES基础实体
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public final class EsEntity<T> {

    private String id;

    private T data;
}

import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * @Auther: zlx
 * @Date: 2020/4/28 09:53
 * @Description: 分页实体类
 */
@Data
public class Page<T> implements Serializable {

    //开始页数
    private int pageNum;

    //每页数量
    private int pageSize;

    //总记录数
    private int total;

    //页数
    private int pageCount;

    //列表
    private List<T> list;
}

三尺微命 一介书生
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值