ES使用笔记

父类Service服务接口

package com.lcb.soa.search.item.service;

import com.lcb.soa.misc.service.IService;
import com.lcb.soa.search.item.contract.IndexAliasVO;

import java.util.Collection;
import java.util.List;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-03 16:09
 */
public interface ISearchService extends IService {

    /**
     * 获取IndexAliasVO
     */
    IndexAliasVO getIndexAlias(String staticIndexName, List<String> staticAllIndexName);

    void resetIndex(String indexName, String settingFile, String mappingFile, String type);

    void refreshIndex(String indexName);

    boolean indexExists(String indexName);

    boolean switchIndexAlias(List<String> staticAllIndexName, String staticIndexName, String newIndexName);

    /**
     * 插入单条数据
     */
    String indexItem(List<String> staticAllIndexName, String staticIndexName, String indexName, Object doc);

    /**
     * 插入多条数据
     *
     */
    boolean indexItems(List<String> staticAllIndexName, String staticIndexName, String indexName, Collection<?> docs);
}

父类abstract class

package com.lcb.soa.search.item.service;

import com.lcb.soa.misc.common.helper.SoaHelper;
import com.lcb.soa.misc.common.util.GeneralHelper;
import com.lcb.soa.search.item.contract.IndexAliasVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesAction;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequestBuilder;
import org.elasticsearch.client.Client;
import org.elasticsearch.cluster.metadata.AliasMetaData;
import org.elasticsearch.common.collect.ImmutableOpenMap;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.search.suggest.Suggest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.IndexQuery;

import java.io.UnsupportedEncodingException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-03 16:11
 */
@Slf4j
public abstract class SearchService implements ISearchService {

    private static Logger logger = LoggerFactory.getLogger(SearchService.class);

    @Autowired
    private Client esClient;

    @Autowired
    private ElasticsearchTemplate esTemplate;

    @Override
    public IndexAliasVO getIndexAlias(String staticIndexName, List<String> staticAllIndexName) {
        GetAliasesAction act = GetAliasesAction.INSTANCE;
        GetAliasesRequestBuilder req = act.newRequestBuilder(esClient);
        req.setAliases(staticIndexName);
        ImmutableOpenMap<String, List<AliasMetaData>> resp = req.execute().actionGet().getAliases();
        IndexAliasVO vo = new IndexAliasVO();
        vo.setAlias(staticIndexName);

        List<String> candidateIndices = new ArrayList<>(staticAllIndexName);
        vo.setCandidateIndices(candidateIndices);
        for (String index : staticAllIndexName) {
            if (SoaHelper.isNotNullOrEmpty(resp.get(index))) {
                vo.setCurrentIndex(index);
                candidateIndices.remove(index);
                break;
            }
        }
        return vo;
    }

    @Override
    public void resetIndex(String indexName, String settingFile, String mappingFile, String type) {
        if (esTemplate.indexExists(indexName))
            esTemplate.deleteIndex(indexName);

        createIndexIfNotExists(indexName, settingFile, mappingFile, type);
    }


    @Override
    public void refreshIndex(String indexName) {
        esTemplate.refresh(indexName);
    }

    @Override
    public boolean indexExists(String indexName) {
        return esTemplate.indexExists(indexName);
    }

    @Override
    public boolean switchIndexAlias(List<String> staticAllIndexName, String staticIndexName, String newIndexName) {
        checkIndexName(staticAllIndexName, staticIndexName, newIndexName, false);

        if (!esTemplate.indexExists(newIndexName)) {
            throw new RuntimeException(String.format("index not exists: '%s'", newIndexName));
        }

        IndexAliasVO vo = getIndexAlias(staticIndexName, staticAllIndexName);

        if (newIndexName.equals(vo.getCurrentIndex()))
            return true;

        refreshIndex(newIndexName);

        IndicesAliasesRequestBuilder req = esClient.admin().indices().prepareAliases();
        if (GeneralHelper.isStrNotEmpty(vo.getCurrentIndex())) {
            req.removeAlias(vo.getCurrentIndex(), staticIndexName);
        }
        return req.addAlias(newIndexName, staticIndexName).execute().actionGet().isAcknowledged();
    }


    @Override
    public String indexItem(List<String> staticAllIndexName, String staticIndexName, String indexName, Object doc) {
        checkIndexName(staticAllIndexName, staticIndexName, indexName, true);

        IndexQuery req = new IndexQuery();
        req.setIndexName(indexName);
        req.setObject(doc);
        return esTemplate.index(req);
    }


    @Override
    public boolean indexItems(List<String> staticAllIndexName, String staticIndexName, String indexName, Collection<?> docs) {

        try {
            checkIndexName(staticAllIndexName, staticIndexName, indexName, true);

            if (SoaHelper.isNullOrEmpty(docs))
                return false;

            List<IndexQuery> list = new ArrayList<>(docs.size());

            for (Object doc : docs) {
                IndexQuery req = new IndexQuery();
                req.setIndexName(indexName);
                req.setObject(doc);
                list.add(req);
            }

            if (CollectionUtils.isNotEmpty(list)) {
                logger.info("导入es数据量: {}", list.size());
                logger.info("导入批次item起始: {}----item结束: {}", list.get(0).getObject().toString(), list.get(list.size() - 1).getObject().toString());
            }

            esTemplate.bulkIndex(list);
        } catch (RuntimeException e) {
            logger.info("导入商品入es失败index: {}", indexName);

            e.printStackTrace();
        }
        return true;
    }


    private void createIndexIfNotExists(String indexName, String settingFile, String mappingFile, String type) {
        if (!esTemplate.indexExists(indexName)) {
            String setting = ElasticsearchTemplate.readFileFromClasspath(settingFile);
            String mapping = ElasticsearchTemplate.readFileFromClasspath(mappingFile);

            try {
                esTemplate.createIndex(indexName, setting);
                esTemplate.putMapping(indexName, type, mapping);
            } catch (Exception e) {
                if (esTemplate.indexExists(indexName))
                    esTemplate.deleteIndex(indexName);

                String msg = MessageFormat.format("create index {0} fail", indexName);
                log.error(msg, e);
                throw new RuntimeException(msg, e);
            }
        }
    }

    private void checkIndexName(List<String> staticAllIndexName, String staticIndexName, String indexName, boolean withAliasName) {
        boolean isOK = staticAllIndexName.contains(indexName);

        if (!isOK && withAliasName)
            isOK = staticIndexName.equals(indexName);

        if (!isOK)
            throw new RuntimeException(String.format("invald indexName: '%s'", indexName));
    }

    public String getStartChinese(String text) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            try {
                if (String.valueOf(c).getBytes("UTF-8").length > 1) {
                    sb.append(c);
                } else {
                    break;
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        if (sb.length() != 0) {
            return sb.toString();
        }
        return null;
    }

    public Map<String, Integer> getOptionMap(Map<String, Integer> map, Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestion) {
        if (suggestion != null) {
            Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option> entry = suggestion.getEntries().get(0);
            if (entry != null) {
                List<? extends Suggest.Suggestion.Entry.Option> pinyinoptions = entry.getOptions();
                if (CollectionUtils.isNotEmpty(pinyinoptions)) {
                    for (Suggest.Suggestion.Entry.Option pinyinoption : pinyinoptions) {
                        Text text = pinyinoption.getText();
                        Integer integer = map.get(text.toString());
                        if (integer == null) {
                            map.put(text.toString(), 1);
                        } else {
                            map.put(text.toString(), integer + 1);
                        }
                    }
                }
            }
        }
        return map;
    }
}

Service  interface

package com.lcb.soa.search.item.service;

import com.lcb.soa.search.item.contract.IndexAliasVO;
import com.lcb.soa.search.item.contract.resp.originalItem.OriItemAutoMatchingResponse;
import com.lcb.soa.search.item.model.OriginalItemDoc;

import java.util.List;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-03 17:05
 */
public interface IOriginalItemSearchService extends ISearchService {

    /**
     * 获取IndexAliasVO
     */
    IndexAliasVO getIndexAlias();

    /**
     * 重置 (先删除再新建)
     */
    void resetIndex(String indexName);

    /**
     * 更新
     */
    void refreshIndex();

    /**
     * 更新
     *
     * @param indexName
     */
    void refreshIndex(String indexName);

    /**
     * 索引是否存在
     *
     * @param indexName
     * @return
     */
    boolean indexExists(String indexName);

    /**
     * 切换
     */
    boolean switchIndexAlias(String newIndexName);

    /**
     * 插入数据
     */
    boolean indexItems(String indexName, List<OriginalItemDoc> docs);


    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<


    OriItemAutoMatchingResponse autoMatching(String text);


}

Service impl

package com.lcb.soa.search.item.service;

import com.alibaba.dubbo.config.annotation.Service;
import com.lcb.soa.search.item.constanct.RegexConstanct;
import com.lcb.soa.search.item.contract.IndexAliasVO;
import com.lcb.soa.search.item.contract.resp.originalItem.OriItemAutoMatchingResponse;
import com.lcb.soa.search.item.domain.OriginalItemDocInner;
import com.lcb.soa.search.item.model.OriginalItemDoc;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.Client;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.suggest.Suggest;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
import org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.elasticsearch.search.suggest.Suggest.Suggestion;
import org.elasticsearch.search.suggest.Suggest.Suggestion.Entry;
import org.elasticsearch.search.suggest.Suggest.Suggestion.Entry.Option;

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

import static com.lcb.soa.search.item.domain.OriginalItemConfig.*;


/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-03 17:08
 */
@Slf4j
@Service(timeout = 5000)
public class OriginalItemSearchService extends SearchService implements IOriginalItemSearchService {

    private static Logger logger = LoggerFactory.getLogger(OriginalItemSearchService.class);

    @Autowired
    private Client esClient;


    @Override
    public IndexAliasVO getIndexAlias() {
        return super.getIndexAlias(INDEX_NAME, ALL_INDEX_NAMES);
    }

    @Override
    public void resetIndex(String indexName) {
        super.resetIndex(indexName, INDEX_SETTING_FILE, INDEX_ITEM_TYPE_MAPPING_FILE, ITEM_TYPE);
    }


    @Override
    public void refreshIndex() {
        super.refreshIndex(INDEX_NAME);
    }

    @Override
    public boolean switchIndexAlias(String newIndexName) {
        return super.switchIndexAlias(ALL_INDEX_NAMES, INDEX_NAME, newIndexName);
    }

    @Override
    public boolean indexItems(String indexName, List<OriginalItemDoc> docs) {
        for (OriginalItemDoc doc : docs) {
            if (doc.getId() == null) {
                throw new RuntimeException("doc id is null");
            }

        }
        ArrayList<OriginalItemDocInner> docList = new ArrayList<>();
        try {
            for (OriginalItemDoc doc : docs) {
                docList.add(OriginalItemDocInner.formDoc(doc));
            }
        } catch (Exception e) {

        }
        return super.indexItems(ALL_INDEX_NAMES, INDEX_NAME, indexName, docList);
    }

    @Override
    public OriItemAutoMatchingResponse autoMatching(String text) {
        OriItemAutoMatchingResponse response = new OriItemAutoMatchingResponse();
        String trim = StringUtils.trim(text);
        if (StringUtils.isBlank(trim)) {
            return response;
        }
        response = searchAutoMatching(text);
        return response;
    }

    private OriItemAutoMatchingResponse searchAutoMatching(String text) {
        OriItemAutoMatchingResponse response = new OriItemAutoMatchingResponse();
        // 指定库
        String indexName = INDEX_NAME;
        SearchRequestBuilder prepareSearch = esClient.prepareSearch(indexName).setSearchType(SearchType.DEFAULT);

        // 设置指定返回字段
        setSourceFields(prepareSearch);

        // 文本查询
        SuggestBuilder suggestBuilder = setSearchConditionForAutoComplete(text);
        prepareSearch = prepareSearch.suggest(suggestBuilder);
        // 执行查询
        logger.info("itemSearchAutoComplete search query: -> {}", prepareSearch.toString());
        SearchResponse searchResponse = prepareSearch.execute().actionGet();
        if (suggestBuilder == null) {
            return response;
        }

        Suggestion<? extends Entry<? extends Option>> keyWordsSuggestion = searchResponse.getSuggest()
                .getSuggestion("keywords");
        Suggestion<? extends Entry<? extends Option>> pinyinSuggestion = searchResponse.getSuggest()
                .getSuggestion("pinyinKeywords");


        Map<String, String> hashMap = new HashMap<>();
        addOptionMap(hashMap, keyWordsSuggestion);
        addOptionMap(hashMap, pinyinSuggestion);
        response.setAutoComplete(hashMap);
        return response;
    }

    private Map<String, String> addOptionMap(Map<String, String> map, Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestion) {
        if (suggestion != null) {
            List entries = suggestion.getEntries();
            if (CollectionUtils.isNotEmpty(entries)) {
                CompletionSuggestion.Entry entry = (CompletionSuggestion.Entry) entries.get(0);
                if (entry != null) {
                    List<CompletionSuggestion.Entry.Option> options = entry.getOptions();
                    if (CollectionUtils.isNotEmpty(options)) {
                        for (CompletionSuggestion.Entry.Option option : options) {
                            SearchHit hit = option.getHit();
                            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                            String itemName = sourceAsMap.get("itemName").toString();
                            String oeNumber = sourceAsMap.get("oeNumber").toString();
                            map.put(itemName,oeNumber);
                        }
                    }
                }
            }
        }
        return map;
    }

    private void setSourceFields(SearchRequestBuilder prepareSearch) {
        String[] fields = {"oeNumber", "itemName"};

        FetchSourceContext sourceContext = new FetchSourceContext(true, fields, null);

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        searchSourceBuilder.fetchSource(sourceContext);

        prepareSearch.setSource(searchSourceBuilder);
    }

    private SuggestBuilder setSearchConditionForAutoComplete(String text) {
        SuggestBuilder suggestBuilder = null;
        text = StringUtils.trim(text);
        CompletionSuggestionBuilder csb = null;
        CompletionSuggestionBuilder pinyinCsb = null;
        if (StringUtils.isNotBlank(text)) {
            suggestBuilder = new SuggestBuilder();
            if (text.matches(RegexConstanct.ALL_ENGLISH_ALPHABET)) {
                pinyinCsb = new CompletionSuggestionBuilder("keywords.pinyin").text(text).size(10000);
                suggestBuilder.addSuggestion("pinyinKeywords", pinyinCsb);
            } else {
                String quertString = getStartChinese(text);
                if (quertString == null) {
                    quertString = text;
                }
                csb = new CompletionSuggestionBuilder("keywords.suggest").text(quertString).size(10000);
                suggestBuilder.addSuggestion("keywords", csb);

            }
        }

        return suggestBuilder;
    }

}

model

package com.lcb.soa.search.item.model;

import lombok.Data;

import java.io.Serializable;
import java.util.Set;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-04 10:47
 */
@Data
public class OriginalItemDoc implements Serializable {

    private Long id;

    private String oeNumber;

    private String itemName;

    private Long manufacturerId;

    private String manufacturerName;

    private Long categoryId;

    private String categoryName;

    private Long createdTime;

    private Long updatedTime;

    private Set<String> keywords;

    private Set<String> pinyinKeywords;
}

modelDoc

package com.lcb.soa.search.item.domain;

import com.lcb.soa.search.item.model.OriginalItemDoc;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.annotations.Setting;

import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_NAME;
import static com.lcb.soa.search.item.domain.OriginalItemConfig.ITEM_TYPE;
import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_ITEM_TYPE_MAPPING_FILE;
import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_SETTING_FILE;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-04 14:22
 */
@Setting(settingPath = INDEX_SETTING_FILE)
@Mapping(mappingPath = INDEX_ITEM_TYPE_MAPPING_FILE)
@Document(indexName = INDEX_NAME, type = ITEM_TYPE, createIndex = false)
public class OriginalItemDocInner extends OriginalItemDoc {

    public static OriginalItemDocInner formDoc(OriginalItemDoc doc) {
        if (doc == null)
            return null;
        OriginalItemDocInner inner = new OriginalItemDocInner();
        copy(doc, inner);
        return inner;
    }

    public static OriginalItemDoc toDoc(OriginalItemDocInner inner) {
        if (inner == null)
            return null;
        OriginalItemDoc doc = new OriginalItemDoc();
        copy(inner, doc);
        return doc;
    }

    private static void copy(OriginalItemDoc source, OriginalItemDoc target) {
        target.setId(source.getId());
        target.setOeNumber(source.getOeNumber());
        target.setItemName(source.getItemName());
        target.setManufacturerId(source.getManufacturerId());
        target.setManufacturerName(source.getManufacturerName());
        target.setCategoryId(source.getCategoryId());
        target.setCategoryName(source.getCategoryName());
        target.setCreatedTime(source.getCreatedTime());
        target.setUpdatedTime(source.getUpdatedTime());
        target.setKeywords(source.getKeywords());
        target.setPinyinKeywords(source.getPinyinKeywords());
    }
}

Config

package com.lcb.soa.search.item.domain;

import java.util.Arrays;
import java.util.List;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-04 14:24
 */
public class OriginalItemConfig {

    public static final String INDEX_NAME                    = "lcb_original_item";
    public static final String INDEX_NAME_A                    = "lcb_original_item_a";
    public static final String INDEX_NAME_B                    = "lcb_original_item_b";
    public static final List<String> ALL_INDEX_NAMES        = Arrays.asList(INDEX_NAME_A, INDEX_NAME_B);
    public static final String INDEX_SETTING_FILE            = "index-item-setting.json";
    public static final String ITEM_TYPE                    = "item";
    public static final String INDEX_ITEM_TYPE_MAPPING_FILE    = "index-type-originalItem-mapping.json";
}

Respository

package com.lcb.soa.search.item.repository;

import com.lcb.soa.search.item.domain.OriginalItemDocInner;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * @author caiyike
 * @version 1.0
 * @date 2019-03-04 14:39
 */
public interface OriginalItemRespository extends ElasticsearchRepository<OriginalItemDocInner,Long> {
}

spring-elasticsearch.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/data/elasticsearch
                        http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">

    <!-- 配置elasticsearch 连接 -->
    <elasticsearch:transport-client id="esClient" cluster-nodes="${es.cluster.nodes}"
                                    client-transport-ignore-cluster-name="true"/>

    <!-- spring data elasticsearch DAO 必须依赖 elasticsearchTemplate  -->
    <bean id="esTemplate"
          class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
        <constructor-arg name="client" ref="esClient"/>
    </bean>

    <!-- 扫描DAO包 自动创建实现 -->
    <elasticsearch:repositories base-package="com.lcb.soa.search.item.repository"
                                elasticsearch-template-ref="esTemplate"/>

</beans>

index-item-setting.json

{
    "index": {
        "number_of_shards": 5,
        "number_of_replicas": 1,
        "refresh_interval": "3s",
        "mapper": {"dynamic":false},
        "analysis": {
            "analyzer": {
                "pinyin_analyzer": {
                    "tokenizer": "pinyin_tokenizer"
                },
                "lc_keyword_analyzer": {
                    "type": "custom",
                    "filter": "lowercase",
                    "tokenizer": "keyword"
                },
                "uc_keyword_analyzer": {
                    "type": "custom",
                    "filter": "uppercase",
                    "tokenizer": "keyword"
                },
                "comma_analyzer": {
                    "type": "pattern",
                    "pattern": ","
                },
                "comma_space_analyzer": {
                    "type": "pattern",
                    "pattern": "[, 	]"
                },
                "semicolon_analyzer": {
                    "type": "pattern",
                    "pattern": ";"
                },
                "semicolon_space_analyzer": {
                    "type": "pattern",
                    "pattern": "[; 	]"
                },
                "separator_analyzer": {
                    "type": "pattern",
                    "pattern": "[,; 	]"
                },
                "space_analyzer": {
                    "type": "pattern",
                    "pattern": "[ 	]"
                }
            },
            "tokenizer" : {
                "pinyin_tokenizer" : {
                    "type": "pinyin",
                    "keep_separate_first_letter": false,
                    "keep_full_pinyin": true,
                    "keep_original": false,
                    "limit_first_letter_length": 16,
                    "lowercase": true,
                    "remove_duplicated_term": true
                }
            }
        }
    }
}

index-type-originalItem-mapping.json

{
    "_all": {"enabled": true, "analyzer": "ik_smart"},
    "include_in_all": false,
    "properties": {
        "id": {
            "type": "long"
        },
        "oeNumber": {
            "type": "text",
            "analyzer": "ik_smart",
            "include_in_all": true
        },
        "itemName": {
            "type": "text",
            "analyzer": "ik_smart",
            "include_in_all": true
        },
        "manufacturerId": {
            "type": "integer"
        },
        "manufacturerName": {
            "type": "text",
            "analyzer": "ik_smart"
        },
        "categoryId": {
            "type": "long"
        },
        "categoryName": {
            "type": "text",
            "analyzer": "ik_smart"
        },
        "createdTime": {
            "type": "date",
            "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
        },
        "updatedTime": {
            "type": "date",
            "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
        },
        "keywords": {
            "type": "text",
            "analyzer": "uc_keyword_analyzer",
            "include_in_all": true,
            "fields": {
                "fuzzy": {
                    "type": "text",
                    "analyzer": "ik_smart"
                },
                "suggest": {
                    "type": "completion",
                    "analyzer": "ik_smart"
                },
                "pinyin": {
                    "type": "completion",
                    "analyzer": "pinyin_analyzer"
                }
            }
        },
        "pinyinKeywords":{
            "type":"text",
            "analyzer": "pinyin_analyzer"
        }
    }
}

IndexVo

@Getter
@Setter
@SuppressWarnings("serial")
public class IndexAliasVO implements Serializable
{
    String alias;
    String currentIndex;
    List<String> candidateIndices;
    
    public String getOtherIndex()
    {
        return candidateIndices.get(0);
    }
}

    public String switchIndexAlias() {
        IndexAliasVO indexAlias = originalItemSearchService.getIndexAlias();
        String newIndex = indexAlias.getOtherIndex();
        originalItemSearchService.resetIndex(newIndex);
        importDoc(newIndex);
        originalItemSearchService.switchIndexAlias(newIndex);
        return newIndex;
    }


    private void importDoc(String newIndex) {

        Long lastId = 0L;

        while (true) {

            List<ItOriginalItemInformation> itemInfo = getItemInfoLimit(ITEM_LIMIT_END, lastId);

            if (itemInfo.isEmpty()) {
                break;
            }

            List<OriginalItemDoc> itemDocList = parseDoc(itemInfo);

            if (!originalItemSearchService.indexItems(newIndex, itemDocList)) {
                throw new ServiceException("批量将商品数据导入ES索引库失败");
            }

            if (itemInfo.size() < ITEM_LIMIT_END) {
                break;
            }

            lastId = itemInfo.get(itemInfo.size() - 1).getId();
        }

    }


   private List<ItOriginalItemInformation> getItemInfoLimit(int endIndex, Long maxId) {
        ItOriginalItemInformationExample e = new ItOriginalItemInformationExample();
        e.setLimitStart(0);
        e.setLimitEnd(endIndex);
        e.setOrderByClause("id ASC ");
        e.createCriteria().andIdGreaterThan(maxId);
        List<ItOriginalItemInformation> items = itOriginalItemInformationMapper.selectByExample(e);
        return items;
    }

ES默认服务端口9300

外部通信端口9200

head插件端口9100

分享一个较全的使用   https://www.cnblogs.com/leeSmall/p/9218779.html