初始化数据到ES

@Slf4j
@RestController
@RequestMapping("/init")
@RefreshScope
public class ElasticsearchDataInitController {

    public static final String INIT_USER = "user";
    public static final String INIT_TRAVEL = "travel";
    public static final String INIT_STRATEGY = "strategy";
    public static final String INIT_DESTINATION = "destination";
    public static final Integer BATCH_COUNT = 200;
    private final Map<String, EsDataInitStrategy> DATA_HANDLER_STRATEGY_MAP = new HashMap<>();

    @Value("${es.init.key}")
    private String initKey;
    private final RedisService redisService;
    private final UserInfoFeignService userInfoFeignService;
    private final ArticleFeignService articleFeignService;
    private final ElasticsearchService elasticsearchService;

    public ElasticsearchDataInitController(RedisService redisService, UserInfoFeignService userInfoFeignService, ArticleFeignService articleFeignService, ElasticsearchService elasticsearchService) {
        this.redisService = redisService;
        this.userInfoFeignService = userInfoFeignService;
        this.articleFeignService = articleFeignService;
        this.elasticsearchService = elasticsearchService;
    }

    @Getter
    @Setter
    static class EsDataInitStrategy {
        private Function<QueryObject, R<List<Object>>> function;
        private Class<?> clazz;

        public EsDataInitStrategy(Function<QueryObject, R<List<Object>>> function, Class<?> clazz) {
            this.function = function;
            this.clazz = clazz;
        }
    }

    @PostConstruct
    public void postConstruct() {
        // 用户初始化
        EsDataInitStrategy userInit = new EsDataInitStrategy((qo) -> userInfoFeignService.findList(qo.getCurrent(), qo.getSize()), UserInfoEs.class);
        DATA_HANDLER_STRATEGY_MAP.put(INIT_USER, userInit);
        // 攻略文章初始化
        EsDataInitStrategy strategyInit = new EsDataInitStrategy(articleFeignService::strategySearch, StrategyEs.class);
        DATA_HANDLER_STRATEGY_MAP.put(INIT_STRATEGY, strategyInit);
        // 游记文章初始化
        EsDataInitStrategy travelInit = new EsDataInitStrategy(articleFeignService::travelSearch, TravelEs.class);
        DATA_HANDLER_STRATEGY_MAP.put(INIT_TRAVEL, travelInit);
        // 目的地初始化
        EsDataInitStrategy destinationInit = new EsDataInitStrategy(articleFeignService::destinationSearch, DestinationEs.class);
        DATA_HANDLER_STRATEGY_MAP.put(INIT_DESTINATION, destinationInit);
    }

    @GetMapping("/{key}/{type}")
    public ResponseEntity<?> init(@PathVariable("key") String key, @PathVariable("type") String type) {
        log.info("[ES 数据初始化] -------------------- 数据初始化开始 --------------------");
        if (StringUtils.isEmpty(key) || !initKey.equals(key)) {
            log.warn("[ES 数据初始化] 非法操作，请求参数有误 key={}, type={}, initKey={}", key, type, initKey);
            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
        }
        // 用户访问过，就不允许再访问了
        String redisKey = "es:init:" + key + type;
        Boolean ret = redisService.setnx(redisKey, "initialized");
        if (ret == null || !ret) {
            log.warn("[ES 数据初始化] 非法操作，已初始化过, redisKey={}, ret={}", redisKey, ret);
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }

        // 开始初始化数据
        this.doInit(type);
        log.info("[ES 数据初始化] -------------------- 数据初始化完成 --------------------");
        return ResponseEntity.ok().body("init success");
    }

    private void doInit(String type) {
        int current = 1;
        do {
            List<Object> list = handleRemoteDataList(current++, type);
            if (list == null || list.isEmpty()) {
                log.info("[ES 数据初始化] 数据初始化完成.");
                return;
            }
            elasticsearchService.save(list);
        } while (true);

    }

    /**
     * 获取并处理远程数据
     */
    private List<Object> handleRemoteDataList(Integer current, String type) {
        EsDataInitStrategy strategy = DATA_HANDLER_STRATEGY_MAP.get(type);
        if (strategy == null) {
            throw new BizException("初始化参数类型错误");
        }
        R<List<Object>> ret = strategy.getFunction().apply(new QueryObject(current, BATCH_COUNT));
        log.info("[ES 数据初始化] 初始化开始，查询{}数据 data={}", type, JSON.toJSONString(ret));
        List<Object> list = ret.checkAndGet();
        if (list == null || list.isEmpty()) {
            return list;
        }
        List<Object> dataList = new ArrayList<>(list.size());
        try {
            Class<?> clazz = strategy.getClazz();
            for (Object dto : list) {
                Object es = clazz.getDeclaredConstructor().newInstance();
                BeanUtils.copyProperties(es, dto);
                dataList.add(es);
            }
            return dataList;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

@FeignClient("article-service")
public interface ArticleFeignService {

    @GetMapping("/destinations/search")
    public R<List<Object>> destinationSearch(@RequestBody QueryObject qo);

    @PostMapping("/strategies/search")
    public R<List<Object>> strategySearch(@RequestBody QueryObject qo);

    @PostMapping("/travels/search")
    public R<List<Object>> travelSearch(@RequestBody QueryObject qo);
}

@FeignClient("user-service")
public interface UserInfoFeignService {
    /**
     * 如果 Feign 发起远程调用后，接收的类型没有明确具体类型是什么
     * Feign 会将返回的 JSON 结构转换为 LinkedHashMap 对象
     */
    @GetMapping("/users/")
    R<List<Object>> findList(@RequestParam Integer current, @RequestParam Integer limit);
}