使用java代码提供一个全面的根据泛型返回的ElasticSearch查询工具类

好的，以下是一个全面的根据泛型返回的 Elasticsearch 查询工具类的代码示例：

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;

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

public class ElasticsearchUtils<T> {

    private final RestHighLevelClient client;

    public ElasticsearchUtils(RestHighLevelClient client) {
        this.client = client;
    }

    /**
     * 根据关键词查询ES中的数据
     *
     * @param indexName 索引名称
     * @param keyword   查询关键词
     * @param clazz     查询结果类型
     * @param size      返回结果数量
     * @return 返回查询结果列表
     */
    public List<T> searchByKeyword(String indexName, String keyword, Class<T> clazz, int size) throws IOException {
        List<T> resultList = new ArrayList<>();

        // 创建查询请求
        SearchRequest searchRequest = new SearchRequest(indexName);

        // 构建查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("content", keyword));
        searchSourceBuilder.timeout(TimeValue.timeValueSeconds(60));
        searchSourceBuilder.size(size);

        // 构建高亮显示
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("content");
        highlightBuilder.requireFieldMatch(false);
        highlightBuilder.preTags("<span style=\"color:red\">");
        highlightBuilder.postTags("</span>");

        searchSourceBuilder.highlighter(highlightBuilder);

        searchRequest.source(searchSourceBuilder);

        // 执行查询
        SearchResponse searchResponse = client.search(searchRequest);

        // 解析查询结果
        SearchHit[] searchHits = searchResponse.getHits().getHits();
        for (SearchHit hit : searchHits) {
            T obj = parseHitSource(hit.getSourceAsMap(), clazz);

            // 解析高亮显示
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            for (Map.Entry<String, HighlightField> entry : highlightFields.entrySet()) {
                String fieldName = entry.getKey();
                HighlightField highlightField = entry.getValue();
                if (highlightField != null) {
                    Field field = getField(clazz, fieldName);
                    if (field != null) {
                        setFieldValue(obj, field, highlightField.fragments()[0].toString());
                    }
                }
            }

            resultList.add(obj);
        }

        return resultList;
    }

    /**
     * 解析查询结果中的hit源数据，并转换为指定类型的对象
     *
     * @param sourceMap hit源数据
     * @param clazz     目标类型
     * @return 返回转换后的对象
     */
    private T parseHitSource(Map<String, Object> sourceMap, Class<T> clazz) {
        Map<String, Object> resultMap = new HashMap<>();

        // 将Map中的key转换为小写，避免与Java类中的字段出现不匹配
        for (Map.Entry<String, Object> entry : sourceMap.entrySet()) {
            resultMap.put(entry.getKey().toLowerCase(), entry.getValue());
        }

        return JsonUtils.fromJson(JsonUtils.toJson(resultMap), clazz);
    }

    /**
     * 获取Java类中指定名称的字段
     *
     * @param clazz      Java类
     * @param fieldName  字段名称
     * @return 返回字段对象
     */
    private Field getField(Class<?> clazz, String fieldName) {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.getName().equalsIgnoreCase(fieldName)) {
                field.setAccessible(true);
                return field;
            }
        }
        return null;
    }

    /**
     * 设置Java对象中指定字段的值
     *
     * @param obj    Java对象
     * @param field  字段对象
     * @param value  字段值
     */
    private void setFieldValue(T obj, Field field, String value) {
        try {
            if (field.getType() == String.class) {
                field.set(obj, value);
            } else if (field.getType() == Integer.class || field.getType() == int.class) {
                field.set(obj, Integer.parseInt(value));
            } else if (field.getType() == Long.class || field.getType() == long.class) {
                field.set(obj, Long.parseLong(value));
            } else if (field.getType() == Double.class || field.getType() == double.class) {
                field.set(obj, Double.parseDouble(value));
            } else if (field.getType() == Float.class || field.getType() == float.class) {
                field.set(obj, Float.parseFloat(value));
            } else if (field.getType() == Boolean.class || field.getType() == boolean.class) {
                field.set(obj, Boolean.parseBoolean(value));
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

这个工具类的主要作用是根据关键词查询 Elasticsearch 中的数据，并返回查询结果列表。其中，使用了 Elasticsearch 的 Java 客户端 RestHighLevelClient，以及构建查询条件的 SearchSourceBuilder。查询条件中使用了 matchQuery 方法，可以通过关键词查询指定字段（这里是 content 字段）的匹配结果。同时，还使用了 HighlightBuilder 对结果中匹配的内容进行高亮显示。在解析查询结果时，使用了反射机制将 Elasticsearch 中的 hit 源数据转换为指定类型的 Java 对象，并在解析高亮显示时，使用反射机制设置 Java 对象中指定字段的值。