初始化模块

/**
 * 目的地搜索对象
 */
@Getter
@Setter
@Document(indexName = DestinationEs.INDEX_NAME)
public class DestinationEs implements Serializable {
    public static final String INDEX_NAME = "destination";

    @Id
    //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
    @Field(type = FieldType.Long)
    private Long id;  //目的地id

    @Field(type = FieldType.Keyword)
    private String name;

    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String info;
}

/**
 * 攻略搜索对象
 */
@Getter
@Setter
@Document(indexName = StrategyEs.INDEX_NAME)
public class StrategyEs implements Serializable {

    public static final String INDEX_NAME = "strategy";

    //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
    @Id
    @Field(type = FieldType.Long)
    private Long id;  //攻略id
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String title;  //攻略标题
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String subTitle;  //攻略标题
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String summary; //攻略简介
}

/**
 * 游记搜索对象
 */
@Getter
@Setter
@Document(indexName = TravelEs.INDEX_NAME)
public class TravelEs implements Serializable {
    public static final String INDEX_NAME = "travel";
    //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
    @Id
    @Field(type = FieldType.Long)
    private Long id;  //游记id
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String title;  //游记标题
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String summary; //游记简介
}

/**
 * 用户搜索对象
 */
@Getter
@Setter
@Document(indexName = UserInfoEs.INDEX_NAME)
public class UserInfoEs implements Serializable {
    public static final String INDEX_NAME = "userinfo";
    @Id
    //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
    @Field(type = FieldType.Long)
    private Long id;  //用户id
    @Field(type = FieldType.Keyword)
    private String city;
    @Field(analyzer = "ik_max_word", searchAnalyzer = "ik_max_word", type = FieldType.Text)
    private String info;
}

@EnableFeignClients
@SpringBootApplication
public class TripSearchApplication {
    public static void main(String[] args) {
        SpringApplication.run(TripSearchApplication.class, args);
    }
}

/**
 * ES 搜索类型解析器
 * 函数式接口: 这个接口必须有一个抽象方法, 并且只能有一个抽象方法
 * 使用 lambda 实现函数是接口, 这个 lambda 就可以理解为这个函数式接口的实现类 === 匿名内部类
 */
@FunctionalInterface
public interface ElasticsearchTypeParser<T> {

    T parse(Class<T> clazz, String id);
}

public abstract class BeanUtils {

    public static void copyProperties(Object source, Object target) throws BeansException {
        copyProperties(source, target, (Class) null, (String[]) null);
    }

    public static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException {
        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");
        Class<?> actualEditable = target.getClass();
        if (editable != null) {
            if (!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");
            }

            actualEditable = editable;
        }

        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = ignoreProperties != null ? Arrays.asList(ignoreProperties) : null;
        PropertyDescriptor[] var7 = targetPds;
        int var8 = targetPds.length;

        for (int var9 = 0; var9 < var8; ++var9) {
            PropertyDescriptor targetPd = var7[var9];
            Method writeMethod = targetPd.getWriteMethod();
            if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if (sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if (readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                        try {
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                readMethod.setAccessible(true);
                            }

                            Object value = readMethod.invoke(source);
                            if (value == null) {
                                continue;
                            }

                            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                writeMethod.setAccessible(true);
                            }

                            writeMethod.invoke(target, value);
                        } catch (Throwable var15) {
                            throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var15);
                        }
                    }
                }
            }
        }
    }
}

import com.swx.common.core.qo.QueryObject;
import com.swx.search.parser.ElasticsearchTypeParser;
import org.springframework.data.domain.Page;

public interface ElasticsearchService {

    /**
     * 新增方法
     * @param entity ES 实体对象
     */
    public void save(Object entity);

    /**
     * 批量新增方法
     * @param iterable ES 实体对象集合
     */
    public void save(Iterable<?> iterable);

    /**
     * 删除方法
     * @param id 主键
     * @param clazz 实体类型
     */
    public void deleteById(String id, Class<?> clazz);

    /**
     * 通用的高亮分页搜索接口
     *
     * @param esclz  ES 模型字段字节码对象 => ES 查询的对象
     * @param dtoclz domain 字节码对象 => 最终希望返回的对象
     * @param qo     查询对象 => 封装分页参数
     * @param parser 解析器对象 => 利用 ES 对象中的 id 属性，从数据库中查到对应完整的模型对象，返回最终结果
     * @param fields 需要进行高亮查询的字段
     * @param <T>
     * @return 高亮分页数据对象
     */
    <T> Page<T> searchWithHighlight(Class<?> esclz, Class<T> dtoclz, QueryObject qo, ElasticsearchTypeParser<T> parser, String... fields);
}

import com.alibaba.fastjson2.JSON;
import com.swx.common.core.qo.QueryObject;
import com.swx.search.parser.ElasticsearchTypeParser;
import com.swx.search.service.ElasticsearchService;
import com.swx.search.utils.BeanUtils;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.*;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ElasticsearchServiceImpl implements ElasticsearchService {

    public static final Logger log = LoggerFactory.getLogger(ElasticsearchServiceImpl.class);

    @Autowired
    private ElasticsearchRestTemplate template;

    @Override
    public void save(Object entity) {
        template.save(entity);
    }

    @Override
    public void save(Iterable<?> iterable) {
        template.save(iterable);
    }

    @Override
    public void deleteById(String id, Class<?> clazz) {
        template.delete(id, clazz);
    }

    @Override
    public <T> Page<T> searchWithHighlight(Class<?> esclz, Class<T> dtoclz, QueryObject qo, ElasticsearchTypeParser<T> parser, String... fields) {
        //高亮显示
        /*"query":{
            "multi_match": {
                "query": "广州",
                "fields": ["title","subTitle","summary"]
            }
        },*/
        MultiMatchQueryBuilder queryBuilder = QueryBuilders.multiMatchQuery(qo.getKeyword(), fields);
        HighlightBuilder highlightBuilder = new HighlightBuilder(); // 生成高亮查询器
        for (String field : fields) {
            highlightBuilder.field(field);// 高亮查询字段
        }
        highlightBuilder.requireFieldMatch(false); // 如果要多个字段高亮,这项要为false
        highlightBuilder.preTags("<span style='color:red'>"); // 高亮设置
        highlightBuilder.postTags("</span>");
        highlightBuilder.fragmentSize(800000); // 最大高亮分片数
        highlightBuilder.numOfFragments(0); // 从第一个分片获取高亮片段
        /**
         "from": 0,
         "size":3,
         */
        Pageable pageable = PageRequest.of(qo.getCurrent() - 1, qo.getSize(),
                Sort.Direction.ASC, "_id");// 设置分页参数

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(queryBuilder) // match查询
                .withPageable(pageable)
                .withHighlightBuilder(highlightBuilder) // 设置高亮
                .build();

        // 高亮查询, 得到命中的数据
        SearchHits<?> searchHits = template.search(searchQuery, esclz);

        // 最终返回的 list 对象
        List<T> list = new ArrayList<>();
        for (SearchHit<?> searchHit : searchHits) { // 获取搜索到的数据
            // 具体解析操作: 交给外部调用者去实现
            T target = parser.parse(dtoclz, searchHit.getId());

            // 处理高亮
            Map<String, String> map = highlightFieldsCopy(searchHit.getHighlightFields(), fields);

            //1：spring 框架中 BeanUtils 类，如果是map集合是无法进行属性复制
            //   copyProperties(源， 目标)
            //2: apache  BeanUtils 类 可以进map集合属性复制
            //   copyProperties(目标， 源)
            try {
                T highlight = JSON.parseObject(JSON.toJSONString(map), dtoclz);
                BeanUtils.copyProperties(highlight, target);
            } catch (Exception e) {
                log.warn("[高亮搜索] 拷贝属性失败", e);
            }
            list.add(target);
        }

        return new PageImpl<>(list, pageable, searchHits.getTotalHits());
    }

    //fields: title subTitle summary
    private Map<String, String> highlightFieldsCopy(Map<String, List<String>> map, String... fields) {
        Map<String, String> mm = new HashMap<>();
        //title:  "有娃必看，<span style='color:red;'>广州</span>长隆野生动物园全攻略"
        //subTitle: "<span style='color:red;'>广州</span>长隆野生动物园"
        //summary: "如果要说动物园，楼主强烈推荐带娃去<span style='color:red;'>广州</span>长隆野生动物园
        //title subTitle summary
        for (String field : fields) {
            List<String> hfs = map.get(field);
            if (hfs != null && !hfs.isEmpty()) {
                //获取高亮显示字段值, 因为是一个数组, 所有使用string拼接

                StringBuilder sb = new StringBuilder();
                for (String hf : hfs) {
                    sb.append(hf);
                }
                mm.put(field, sb.toString());  //使用map对象将所有能替换字段先缓存, 后续统一替换
            }
        }
        return mm;
    }
}