一、设计需要满足的功能场景

为了满足在工作中，不用频繁的去写繁琐的 ES 存储的代码，一切都是为了偷懒，闲暇之余（想多了）经过多方考虑，将 ES 的存储进行了通用化封装。

封装必须保证通用型，绝大多数场景都能够直接通过调用来实现存储，而不再需要大量编码
封装的入参应该越简单越好，封装一定要保证好用
可以牺牲一定的灵活性以保证标准化以及易用性

二、约定

所谓的约定，就是牺牲一定的灵活性，以保证排除不可控性，来保障封装的可用，易用性

约定如下：

ES 内存储的字段，代码中必须存在对象且字段与 ES 字段一一对应。这么做的目的不言而喻，一方面保证代码的可读性，易读性，ES 内的字段可以通过代码中 ES 对象很直观的看出有哪些字段，且不参杂其他乱七八糟的无用数据。另一方面，通过这种标准化的对象，能够保证 ES 内数据的精确性，大幅度降低出问题的风险，也易于排查问题。
对象中尽量以 id 字段作为 ES 的 _id。 这一点虽然很想定死，但是考虑到可能确实存在此参数需要灵活定义的情况，所以做了一些妥协，通过配置的形式指定，默认就配置为 id 即可。
枚举标准化。 将所有可自定义的参数标准化到枚举中，配置时以枚举来配置，这样便于维护，不至于各写各的乱七八糟。

三、功能封装

1、枚举

indexName： 很明确，ES 对应的索引名称。
name： 索引的名称，让别人明确知道这个索引是什么东西的索引干什么用的，起到一个说明的作用。
clazz： ES 对象对应的类，就是前文约定的标准化类。

/**
 1. ES索引枚举
 */
@Getter
@AllArgsConstructor
public enum EsIndexEnum {

    EsTestDTO("xxxx", "xx列表", EsTestDTO.class, "id")

    ;

    /**
     * 索引名
     */
    private String indexName;

    /**
     * 名称
     */
    private String name;

    /**
     * ES数据对象对应Class类型
     */
    private Class clazz;

    /**
     * _ID对应字段映射
     */
    private String idFieldName;
}

2、定义接口

定一个一个单条处理的接口，一个批量处理的接口

/**
 2. ES操作API
 */
public interface EsOperationApi {

    /**
     * 保存ES数据（单条数据）
     * @param data 数据
     * @param esIndexEnum ES对应索引
     * @param <T>
     * @param <R>
     */
    <T, R> void saveOne(T data, EsIndexEnum esIndexEnum);

    /**
     * 保存ES数据
     * @param data 数据
     * @param esIndexEnum ES对应索引
     * @param <T>
     * @param <R>
     */
    <T, R> void save(List<T> data, EsIndexEnum esIndexEnum);
}

3、功能实现

将范性对象转化为标准化的对象
构建 ES 的批量处理器 Bulk
将 ES 的操作依次添加进批量处理器中，用 upsert 方法，如果存在则更新，不存在则新增
获取返回结果，打印错误便与排查

/**
 * @author Jinpeng Lin
 * @description ES操作封装
 * @date 2022-05-30
 */
@Slf4j
@Service
public class EsOperationApiImpl implements EsOperationApi {

    @Resource
    private RestHighLevelClient restClient;

    @Override
    public <T, R> void saveOne(T data, EsIndexEnum esIndexEnum) {
        if (data != null) {
            this.save(CollUtil.newArrayList(data), esIndexEnum);
        }
    }

    @Override
    public <T, R> void save(List<T> data, EsIndexEnum esIndexEnum) {
        if (CollUtil.isEmpty(data) || esIndexEnum == null) {
            return;
        }
        // 数据和指定的 ES 对应进行对象映射，转化为 ES 标准化的对象
        List<R> datas = ReflectUtils.map(data, esIndexEnum.getClazz());
        // 批量处理器
        BulkRequest bulkRequest = new BulkRequest();
        // 向批量处理器里添加要处理的数据
        Map<String, Object> dataMap;
        for (R item : datas) {
            dataMap = BeanUtil.beanToMap(item, true, false);
            bulkRequest.add(new UpdateRequest(esIndexEnum.getIndexName(),
                String.valueOf(ReflectUtil.getFieldValue(item, esIndexEnum.getIdFieldName()))).doc(dataMap)
                    .upsert(dataMap));
        }

        try {
            // 发送处理，并接收结果
            BulkResponse response = this.restClient.bulk(bulkRequest, RequestOptions.DEFAULT);
            if (response.hasFailures()) {
                for (BulkItemResponse bulkItemResponse : response) {
                    if (bulkItemResponse.isFailed()) {
                        BulkItemResponse.Failure failure = bulkItemResponse.getFailure();
                        log.error("ES 数据同步单条数据失败，索引:{}，ID:{}，错误信息:{}", esIndexEnum.getIndexName(),
                            failure.getId(), failure.getMessage());
                    }
                }
            }
        } catch (Exception e) {
            log.error("ES 数据同步失败，索引:{}，错误信息:{}", esIndexEnum.getIndexName(), e.getMessage());
        }
    }
}