ES使用笔记

父类Service服务接口

 1 package com.lcb.soa.search.item.service;
 2 
 3 import com.lcb.soa.misc.service.IService;
 4 import com.lcb.soa.search.item.contract.IndexAliasVO;
 5 
 6 import java.util.Collection;
 7 import java.util.List;
 8 
 9 /**
10  * @author caiyike
11  * @version 1.0
12  * @date 2019-03-03 16:09
13  */
14 public interface ISearchService extends IService {
15 
16     /**
17      * 获取IndexAliasVO
18      */
19     IndexAliasVO getIndexAlias(String staticIndexName, List<String> staticAllIndexName);
20 
21     void resetIndex(String indexName, String settingFile, String mappingFile, String type);
22 
23     void refreshIndex(String indexName);
24 
25     boolean indexExists(String indexName);
26 
27     boolean switchIndexAlias(List<String> staticAllIndexName, String staticIndexName, String newIndexName);
28 
29     /**
30      * 插入单条数据
31      */
32     String indexItem(List<String> staticAllIndexName, String staticIndexName, String indexName, Object doc);
33 
34     /**
35      * 插入多条数据
36      *
37      */
38     boolean indexItems(List<String> staticAllIndexName, String staticIndexName, String indexName, Collection<?> docs);
39 }

父类abstract class

  1 package com.lcb.soa.search.item.service;
  2 
  3 import com.lcb.soa.misc.common.helper.SoaHelper;
  4 import com.lcb.soa.misc.common.util.GeneralHelper;
  5 import com.lcb.soa.search.item.contract.IndexAliasVO;
  6 import lombok.extern.slf4j.Slf4j;
  7 import org.apache.commons.collections.CollectionUtils;
  8 import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
  9 import org.elasticsearch.action.admin.indices.alias.get.GetAliasesAction;
 10 import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequestBuilder;
 11 import org.elasticsearch.client.Client;
 12 import org.elasticsearch.cluster.metadata.AliasMetaData;
 13 import org.elasticsearch.common.collect.ImmutableOpenMap;
 14 import org.elasticsearch.common.text.Text;
 15 import org.elasticsearch.search.suggest.Suggest;
 16 import org.slf4j.Logger;
 17 import org.slf4j.LoggerFactory;
 18 import org.springframework.beans.factory.annotation.Autowired;
 19 import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
 20 import org.springframework.data.elasticsearch.core.query.IndexQuery;
 21 
 22 import java.io.UnsupportedEncodingException;
 23 import java.text.MessageFormat;
 24 import java.util.ArrayList;
 25 import java.util.Collection;
 26 import java.util.List;
 27 import java.util.Map;
 28 
 29 /**
 30  * @author caiyike
 31  * @version 1.0
 32  * @date 2019-03-03 16:11
 33  */
 34 @Slf4j
 35 public abstract class SearchService implements ISearchService {
 36 
 37     private static Logger logger = LoggerFactory.getLogger(SearchService.class);
 38 
 39     @Autowired
 40     private Client esClient;
 41 
 42     @Autowired
 43     private ElasticsearchTemplate esTemplate;
 44 
 45     @Override
 46     public IndexAliasVO getIndexAlias(String staticIndexName, List<String> staticAllIndexName) {
 47         GetAliasesAction act = GetAliasesAction.INSTANCE;
 48         GetAliasesRequestBuilder req = act.newRequestBuilder(esClient);
 49         req.setAliases(staticIndexName);
 50         ImmutableOpenMap<String, List<AliasMetaData>> resp = req.execute().actionGet().getAliases();
 51         IndexAliasVO vo = new IndexAliasVO();
 52         vo.setAlias(staticIndexName);
 53 
 54         List<String> candidateIndices = new ArrayList<>(staticAllIndexName);
 55         vo.setCandidateIndices(candidateIndices);
 56         for (String index : staticAllIndexName) {
 57             if (SoaHelper.isNotNullOrEmpty(resp.get(index))) {
 58                 vo.setCurrentIndex(index);
 59                 candidateIndices.remove(index);
 60                 break;
 61             }
 62         }
 63         return vo;
 64     }
 65 
 66     @Override
 67     public void resetIndex(String indexName, String settingFile, String mappingFile, String type) {
 68         if (esTemplate.indexExists(indexName))
 69             esTemplate.deleteIndex(indexName);
 70 
 71         createIndexIfNotExists(indexName, settingFile, mappingFile, type);
 72     }
 73 
 74 
 75     @Override
 76     public void refreshIndex(String indexName) {
 77         esTemplate.refresh(indexName);
 78     }
 79 
 80     @Override
 81     public boolean indexExists(String indexName) {
 82         return esTemplate.indexExists(indexName);
 83     }
 84 
 85     @Override
 86     public boolean switchIndexAlias(List<String> staticAllIndexName, String staticIndexName, String newIndexName) {
 87         checkIndexName(staticAllIndexName, staticIndexName, newIndexName, false);
 88 
 89         if (!esTemplate.indexExists(newIndexName)) {
 90             throw new RuntimeException(String.format("index not exists: '%s'", newIndexName));
 91         }
 92 
 93         IndexAliasVO vo = getIndexAlias(staticIndexName, staticAllIndexName);
 94 
 95         if (newIndexName.equals(vo.getCurrentIndex()))
 96             return true;
 97 
 98         refreshIndex(newIndexName);
 99 
100         IndicesAliasesRequestBuilder req = esClient.admin().indices().prepareAliases();
101         if (GeneralHelper.isStrNotEmpty(vo.getCurrentIndex())) {
102             req.removeAlias(vo.getCurrentIndex(), staticIndexName);
103         }
104         return req.addAlias(newIndexName, staticIndexName).execute().actionGet().isAcknowledged();
105     }
106 
107 
108     @Override
109     public String indexItem(List<String> staticAllIndexName, String staticIndexName, String indexName, Object doc) {
110         checkIndexName(staticAllIndexName, staticIndexName, indexName, true);
111 
112         IndexQuery req = new IndexQuery();
113         req.setIndexName(indexName);
114         req.setObject(doc);
115         return esTemplate.index(req);
116     }
117 
118 
119     @Override
120     public boolean indexItems(List<String> staticAllIndexName, String staticIndexName, String indexName, Collection<?> docs) {
121 
122         try {
123             checkIndexName(staticAllIndexName, staticIndexName, indexName, true);
124 
125             if (SoaHelper.isNullOrEmpty(docs))
126                 return false;
127 
128             List<IndexQuery> list = new ArrayList<>(docs.size());
129 
130             for (Object doc : docs) {
131                 IndexQuery req = new IndexQuery();
132                 req.setIndexName(indexName);
133                 req.setObject(doc);
134                 list.add(req);
135             }
136 
137             if (CollectionUtils.isNotEmpty(list)) {
138                 logger.info("导入es数据量: {}", list.size());
139                 logger.info("导入批次item起始: {}----item结束: {}", list.get(0).getObject().toString(), list.get(list.size() - 1).getObject().toString());
140             }
141 
142             esTemplate.bulkIndex(list);
143         } catch (RuntimeException e) {
144             logger.info("导入商品入es失败index: {}", indexName);
145 
146             e.printStackTrace();
147         }
148         return true;
149     }
150 
151 
152     private void createIndexIfNotExists(String indexName, String settingFile, String mappingFile, String type) {
153         if (!esTemplate.indexExists(indexName)) {
154             String setting = ElasticsearchTemplate.readFileFromClasspath(settingFile);
155             String mapping = ElasticsearchTemplate.readFileFromClasspath(mappingFile);
156 
157             try {
158                 esTemplate.createIndex(indexName, setting);
159                 esTemplate.putMapping(indexName, type, mapping);
160             } catch (Exception e) {
161                 if (esTemplate.indexExists(indexName))
162                     esTemplate.deleteIndex(indexName);
163 
164                 String msg = MessageFormat.format("create index {0} fail", indexName);
165                 log.error(msg, e);
166                 throw new RuntimeException(msg, e);
167             }
168         }
169     }
170 
171     private void checkIndexName(List<String> staticAllIndexName, String staticIndexName, String indexName, boolean withAliasName) {
172         boolean isOK = staticAllIndexName.contains(indexName);
173 
174         if (!isOK && withAliasName)
175             isOK = staticIndexName.equals(indexName);
176 
177         if (!isOK)
178             throw new RuntimeException(String.format("invald indexName: '%s'", indexName));
179     }
180 
181     public String getStartChinese(String text) {
182         StringBuffer sb = new StringBuffer();
183         for (int i = 0; i < text.length(); i++) {
184             char c = text.charAt(i);
185             try {
186                 if (String.valueOf(c).getBytes("UTF-8").length > 1) {
187                     sb.append(c);
188                 } else {
189                     break;
190                 }
191             } catch (UnsupportedEncodingException e) {
192                 e.printStackTrace();
193             }
194         }
195         if (sb.length() != 0) {
196             return sb.toString();
197         }
198         return null;
199     }
200 
201     public Map<String, Integer> getOptionMap(Map<String, Integer> map, Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestion) {
202         if (suggestion != null) {
203             Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option> entry = suggestion.getEntries().get(0);
204             if (entry != null) {
205                 List<? extends Suggest.Suggestion.Entry.Option> pinyinoptions = entry.getOptions();
206                 if (CollectionUtils.isNotEmpty(pinyinoptions)) {
207                     for (Suggest.Suggestion.Entry.Option pinyinoption : pinyinoptions) {
208                         Text text = pinyinoption.getText();
209                         Integer integer = map.get(text.toString());
210                         if (integer == null) {
211                             map.put(text.toString(), 1);
212                         } else {
213                             map.put(text.toString(), integer + 1);
214                         }
215                     }
216                 }
217             }
218         }
219         return map;
220     }
221 }

Service  interface

 1 package com.lcb.soa.search.item.service;
 2 
 3 import com.lcb.soa.search.item.contract.IndexAliasVO;
 4 import com.lcb.soa.search.item.contract.resp.originalItem.OriItemAutoMatchingResponse;
 5 import com.lcb.soa.search.item.model.OriginalItemDoc;
 6 
 7 import java.util.List;
 8 
 9 /**
10  * @author caiyike
11  * @version 1.0
12  * @date 2019-03-03 17:05
13  */
14 public interface IOriginalItemSearchService extends ISearchService {
15 
16     /**
17      * 获取IndexAliasVO
18      */
19     IndexAliasVO getIndexAlias();
20 
21     /**
22      * 重置 (先删除再新建)
23      */
24     void resetIndex(String indexName);
25 
26     /**
27      * 更新
28      */
29     void refreshIndex();
30 
31     /**
32      * 更新
33      *
34      * @param indexName
35      */
36     void refreshIndex(String indexName);
37 
38     /**
39      * 索引是否存在
40      *
41      * @param indexName
42      * @return
43      */
44     boolean indexExists(String indexName);
45 
46     /**
47      * 切换
48      */
49     boolean switchIndexAlias(String newIndexName);
50 
51     /**
52      * 插入数据
53      */
54     boolean indexItems(String indexName, List<OriginalItemDoc> docs);
55 
56 
57     //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
58 
59 
60     OriItemAutoMatchingResponse autoMatching(String text);
61 
62 
63 }

Service impl

  1 package com.lcb.soa.search.item.service;
  2 
  3 import com.alibaba.dubbo.config.annotation.Service;
  4 import com.lcb.soa.search.item.constanct.RegexConstanct;
  5 import com.lcb.soa.search.item.contract.IndexAliasVO;
  6 import com.lcb.soa.search.item.contract.resp.originalItem.OriItemAutoMatchingResponse;
  7 import com.lcb.soa.search.item.domain.OriginalItemDocInner;
  8 import com.lcb.soa.search.item.model.OriginalItemDoc;
  9 import lombok.extern.slf4j.Slf4j;
 10 import org.apache.commons.collections.CollectionUtils;
 11 import org.apache.commons.lang.StringUtils;
 12 import org.elasticsearch.action.search.SearchRequestBuilder;
 13 import org.elasticsearch.action.search.SearchResponse;
 14 import org.elasticsearch.action.search.SearchType;
 15 import org.elasticsearch.client.Client;
 16 import org.elasticsearch.search.SearchHit;
 17 import org.elasticsearch.search.builder.SearchSourceBuilder;
 18 import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
 19 import org.elasticsearch.search.suggest.Suggest;
 20 import org.elasticsearch.search.suggest.SuggestBuilder;
 21 import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
 22 import org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder;
 23 import org.slf4j.Logger;
 24 import org.slf4j.LoggerFactory;
 25 import org.springframework.beans.factory.annotation.Autowired;
 26 import org.elasticsearch.search.suggest.Suggest.Suggestion;
 27 import org.elasticsearch.search.suggest.Suggest.Suggestion.Entry;
 28 import org.elasticsearch.search.suggest.Suggest.Suggestion.Entry.Option;
 29 
 30 import java.util.ArrayList;
 31 import java.util.HashMap;
 32 import java.util.List;
 33 import java.util.Map;
 34 
 35 import static com.lcb.soa.search.item.domain.OriginalItemConfig.*;
 36 
 37 
 38 /**
 39  * @author caiyike
 40  * @version 1.0
 41  * @date 2019-03-03 17:08
 42  */
 43 @Slf4j
 44 @Service(timeout = 5000)
 45 public class OriginalItemSearchService extends SearchService implements IOriginalItemSearchService {
 46 
 47     private static Logger logger = LoggerFactory.getLogger(OriginalItemSearchService.class);
 48 
 49     @Autowired
 50     private Client esClient;
 51 
 52 
 53     @Override
 54     public IndexAliasVO getIndexAlias() {
 55         return super.getIndexAlias(INDEX_NAME, ALL_INDEX_NAMES);
 56     }
 57 
 58     @Override
 59     public void resetIndex(String indexName) {
 60         super.resetIndex(indexName, INDEX_SETTING_FILE, INDEX_ITEM_TYPE_MAPPING_FILE, ITEM_TYPE);
 61     }
 62 
 63 
 64     @Override
 65     public void refreshIndex() {
 66         super.refreshIndex(INDEX_NAME);
 67     }
 68 
 69     @Override
 70     public boolean switchIndexAlias(String newIndexName) {
 71         return super.switchIndexAlias(ALL_INDEX_NAMES, INDEX_NAME, newIndexName);
 72     }
 73 
 74     @Override
 75     public boolean indexItems(String indexName, List<OriginalItemDoc> docs) {
 76         for (OriginalItemDoc doc : docs) {
 77             if (doc.getId() == null) {
 78                 throw new RuntimeException("doc id is null");
 79             }
 80 
 81         }
 82         ArrayList<OriginalItemDocInner> docList = new ArrayList<>();
 83         try {
 84             for (OriginalItemDoc doc : docs) {
 85                 docList.add(OriginalItemDocInner.formDoc(doc));
 86             }
 87         } catch (Exception e) {
 88 
 89         }
 90         return super.indexItems(ALL_INDEX_NAMES, INDEX_NAME, indexName, docList);
 91     }
 92 
 93     @Override
 94     public OriItemAutoMatchingResponse autoMatching(String text) {
 95         OriItemAutoMatchingResponse response = new OriItemAutoMatchingResponse();
 96         String trim = StringUtils.trim(text);
 97         if (StringUtils.isBlank(trim)) {
 98             return response;
 99         }
100         response = searchAutoMatching(text);
101         return response;
102     }
103 
104     private OriItemAutoMatchingResponse searchAutoMatching(String text) {
105         OriItemAutoMatchingResponse response = new OriItemAutoMatchingResponse();
106         // 指定库
107         String indexName = INDEX_NAME;
108         SearchRequestBuilder prepareSearch = esClient.prepareSearch(indexName).setSearchType(SearchType.DEFAULT);
109 
110         // 设置指定返回字段
111         setSourceFields(prepareSearch);
112 
113         // 文本查询
114         SuggestBuilder suggestBuilder = setSearchConditionForAutoComplete(text);
115         prepareSearch = prepareSearch.suggest(suggestBuilder);
116         // 执行查询
117         logger.info("itemSearchAutoComplete search query: -> {}", prepareSearch.toString());
118         SearchResponse searchResponse = prepareSearch.execute().actionGet();
119         if (suggestBuilder == null) {
120             return response;
121         }
122 
123         Suggestion<? extends Entry<? extends Option>> keyWordsSuggestion = searchResponse.getSuggest()
124                 .getSuggestion("keywords");
125         Suggestion<? extends Entry<? extends Option>> pinyinSuggestion = searchResponse.getSuggest()
126                 .getSuggestion("pinyinKeywords");
127 
128 
129         Map<String, String> hashMap = new HashMap<>();
130         addOptionMap(hashMap, keyWordsSuggestion);
131         addOptionMap(hashMap, pinyinSuggestion);
132         response.setAutoComplete(hashMap);
133         return response;
134     }
135 
136     private Map<String, String> addOptionMap(Map<String, String> map, Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestion) {
137         if (suggestion != null) {
138             List entries = suggestion.getEntries();
139             if (CollectionUtils.isNotEmpty(entries)) {
140                 CompletionSuggestion.Entry entry = (CompletionSuggestion.Entry) entries.get(0);
141                 if (entry != null) {
142                     List<CompletionSuggestion.Entry.Option> options = entry.getOptions();
143                     if (CollectionUtils.isNotEmpty(options)) {
144                         for (CompletionSuggestion.Entry.Option option : options) {
145                             SearchHit hit = option.getHit();
146                             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
147                             String itemName = sourceAsMap.get("itemName").toString();
148                             String oeNumber = sourceAsMap.get("oeNumber").toString();
149                             map.put(itemName,oeNumber);
150                         }
151                     }
152                 }
153             }
154         }
155         return map;
156     }
157 
158     private void setSourceFields(SearchRequestBuilder prepareSearch) {
159         String[] fields = {"oeNumber", "itemName"};
160 
161         FetchSourceContext sourceContext = new FetchSourceContext(true, fields, null);
162 
163         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
164 
165         searchSourceBuilder.fetchSource(sourceContext);
166 
167         prepareSearch.setSource(searchSourceBuilder);
168     }
169 
170     private SuggestBuilder setSearchConditionForAutoComplete(String text) {
171         SuggestBuilder suggestBuilder = null;
172         text = StringUtils.trim(text);
173         CompletionSuggestionBuilder csb = null;
174         CompletionSuggestionBuilder pinyinCsb = null;
175         if (StringUtils.isNotBlank(text)) {
176             suggestBuilder = new SuggestBuilder();
177             if (text.matches(RegexConstanct.ALL_ENGLISH_ALPHABET)) {
178                 pinyinCsb = new CompletionSuggestionBuilder("keywords.pinyin").text(text).size(10000);
179                 suggestBuilder.addSuggestion("pinyinKeywords", pinyinCsb);
180             } else {
181                 String quertString = getStartChinese(text);
182                 if (quertString == null) {
183                     quertString = text;
184                 }
185                 csb = new CompletionSuggestionBuilder("keywords.suggest").text(quertString).size(10000);
186                 suggestBuilder.addSuggestion("keywords", csb);
187 
188             }
189         }
190 
191         return suggestBuilder;
192     }
193 
194 }

model

 1 package com.lcb.soa.search.item.model;
 2 
 3 import lombok.Data;
 4 
 5 import java.io.Serializable;
 6 import java.util.Set;
 7 
 8 /**
 9  * @author caiyike
10  * @version 1.0
11  * @date 2019-03-04 10:47
12  */
13 @Data
14 public class OriginalItemDoc implements Serializable {
15 
16     private Long id;
17 
18     private String oeNumber;
19 
20     private String itemName;
21 
22     private Long manufacturerId;
23 
24     private String manufacturerName;
25 
26     private Long categoryId;
27 
28     private String categoryName;
29 
30     private Long createdTime;
31 
32     private Long updatedTime;
33 
34     private Set<String> keywords;
35 
36     private Set<String> pinyinKeywords;
37 }

modelDoc

 1 package com.lcb.soa.search.item.domain;
 2 
 3 import com.lcb.soa.search.item.model.OriginalItemDoc;
 4 import org.springframework.data.elasticsearch.annotations.Document;
 5 import org.springframework.data.elasticsearch.annotations.Mapping;
 6 import org.springframework.data.elasticsearch.annotations.Setting;
 7 
 8 import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_NAME;
 9 import static com.lcb.soa.search.item.domain.OriginalItemConfig.ITEM_TYPE;
10 import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_ITEM_TYPE_MAPPING_FILE;
11 import static com.lcb.soa.search.item.domain.OriginalItemConfig.INDEX_SETTING_FILE;
12 
13 /**
14  * @author caiyike
15  * @version 1.0
16  * @date 2019-03-04 14:22
17  */
18 @Setting(settingPath = INDEX_SETTING_FILE)
19 @Mapping(mappingPath = INDEX_ITEM_TYPE_MAPPING_FILE)
20 @Document(indexName = INDEX_NAME, type = ITEM_TYPE, createIndex = false)
21 public class OriginalItemDocInner extends OriginalItemDoc {
22 
23     public static OriginalItemDocInner formDoc(OriginalItemDoc doc) {
24         if (doc == null)
25             return null;
26         OriginalItemDocInner inner = new OriginalItemDocInner();
27         copy(doc, inner);
28         return inner;
29     }
30 
31     public static OriginalItemDoc toDoc(OriginalItemDocInner inner) {
32         if (inner == null)
33             return null;
34         OriginalItemDoc doc = new OriginalItemDoc();
35         copy(inner, doc);
36         return doc;
37     }
38 
39     private static void copy(OriginalItemDoc source, OriginalItemDoc target) {
40         target.setId(source.getId());
41         target.setOeNumber(source.getOeNumber());
42         target.setItemName(source.getItemName());
43         target.setManufacturerId(source.getManufacturerId());
44         target.setManufacturerName(source.getManufacturerName());
45         target.setCategoryId(source.getCategoryId());
46         target.setCategoryName(source.getCategoryName());
47         target.setCreatedTime(source.getCreatedTime());
48         target.setUpdatedTime(source.getUpdatedTime());
49         target.setKeywords(source.getKeywords());
50         target.setPinyinKeywords(source.getPinyinKeywords());
51     }
52 }

Config

 1 package com.lcb.soa.search.item.domain;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 /**
 7  * @author caiyike
 8  * @version 1.0
 9  * @date 2019-03-04 14:24
10  */
11 public class OriginalItemConfig {
12 
13     public static final String INDEX_NAME                    = "lcb_original_item";
14     public static final String INDEX_NAME_A                    = "lcb_original_item_a";
15     public static final String INDEX_NAME_B                    = "lcb_original_item_b";
16     public static final List<String> ALL_INDEX_NAMES        = Arrays.asList(INDEX_NAME_A, INDEX_NAME_B);
17     public static final String INDEX_SETTING_FILE            = "index-item-setting.json";
18     public static final String ITEM_TYPE                    = "item";
19     public static final String INDEX_ITEM_TYPE_MAPPING_FILE    = "index-type-originalItem-mapping.json";
20 }

Respository

 1 package com.lcb.soa.search.item.repository;
 2 
 3 import com.lcb.soa.search.item.domain.OriginalItemDocInner;
 4 import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
 5 
 6 /**
 7  * @author caiyike
 8  * @version 1.0
 9  * @date 2019-03-04 14:39
10  */
11 public interface OriginalItemRespository extends ElasticsearchRepository<OriginalItemDocInner,Long> {
12 }

spring-elasticsearch.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans
 6                         http://www.springframework.org/schema/beans/spring-beans.xsd
 7                         http://www.springframework.org/schema/data/elasticsearch
 8                         http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
 9 
10     <!-- 配置elasticsearch 连接 -->
11     <elasticsearch:transport-client id="esClient" cluster-nodes="${es.cluster.nodes}"
12                                     client-transport-ignore-cluster-name="true"/>
13 
14     <!-- spring data elasticsearch DAO 必须依赖 elasticsearchTemplate  -->
15     <bean id="esTemplate"
16           class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
17         <constructor-arg name="client" ref="esClient"/>
18     </bean>
19 
20     <!-- 扫描DAO包 自动创建实现 -->
21     <elasticsearch:repositories base-package="com.lcb.soa.search.item.repository"
22                                 elasticsearch-template-ref="esTemplate"/>
23 
24 </beans>

index-item-setting.json

 1 {
 2     "index": {
 3         "number_of_shards": 5,
 4         "number_of_replicas": 1,
 5         "refresh_interval": "3s",
 6         "mapper": {"dynamic":false},
 7         "analysis": {
 8             "analyzer": {
 9                 "pinyin_analyzer": {
10                     "tokenizer": "pinyin_tokenizer"
11                 },
12                 "lc_keyword_analyzer": {
13                     "type": "custom",
14                     "filter": "lowercase",
15                     "tokenizer": "keyword"
16                 },
17                 "uc_keyword_analyzer": {
18                     "type": "custom",
19                     "filter": "uppercase",
20                     "tokenizer": "keyword"
21                 },
22                 "comma_analyzer": {
23                     "type": "pattern",
24                     "pattern": ","
25                 },
26                 "comma_space_analyzer": {
27                     "type": "pattern",
28                     "pattern": "[, \t]"
29                 },
30                 "semicolon_analyzer": {
31                     "type": "pattern",
32                     "pattern": ";"
33                 },
34                 "semicolon_space_analyzer": {
35                     "type": "pattern",
36                     "pattern": "[; \t]"
37                 },
38                 "separator_analyzer": {
39                     "type": "pattern",
40                     "pattern": "[,; \t]"
41                 },
42                 "space_analyzer": {
43                     "type": "pattern",
44                     "pattern": "[ \t]"
45                 }
46             },
47             "tokenizer" : {
48                 "pinyin_tokenizer" : {
49                     "type": "pinyin",
50                     "keep_separate_first_letter": false,
51                     "keep_full_pinyin": true,
52                     "keep_original": false,
53                     "limit_first_letter_length": 16,
54                     "lowercase": true,
55                     "remove_duplicated_term": true
56                 }
57             }
58         }
59     }
60 }

index-type-originalItem-mapping.json

 1 {
 2     "_all": {"enabled": true, "analyzer": "ik_smart"},
 3     "include_in_all": false,
 4     "properties": {
 5         "id": {
 6             "type": "long"
 7         },
 8         "oeNumber": {
 9             "type": "text",
10             "analyzer": "ik_smart",
11             "include_in_all": true
12         },
13         "itemName": {
14             "type": "text",
15             "analyzer": "ik_smart",
16             "include_in_all": true
17         },
18         "manufacturerId": {
19             "type": "integer"
20         },
21         "manufacturerName": {
22             "type": "text",
23             "analyzer": "ik_smart"
24         },
25         "categoryId": {
26             "type": "long"
27         },
28         "categoryName": {
29             "type": "text",
30             "analyzer": "ik_smart"
31         },
32         "createdTime": {
33             "type": "date",
34             "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
35         },
36         "updatedTime": {
37             "type": "date",
38             "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
39         },
40         "keywords": {
41             "type": "text",
42             "analyzer": "uc_keyword_analyzer",
43             "include_in_all": true,
44             "fields": {
45                 "fuzzy": {
46                     "type": "text",
47                     "analyzer": "ik_smart"
48                 },
49                 "suggest": {
50                     "type": "completion",
51                     "analyzer": "ik_smart"
52                 },
53                 "pinyin": {
54                     "type": "completion",
55                     "analyzer": "pinyin_analyzer"
56                 }
57             }
58         },
59         "pinyinKeywords":{
60             "type":"text",
61             "analyzer": "pinyin_analyzer"
62         }
63     }
64 }

IndexVo

 1 @Getter
 2 @Setter
 3 @SuppressWarnings("serial")
 4 public class IndexAliasVO implements Serializable
 5 {
 6     String alias;
 7     String currentIndex;
 8     List<String> candidateIndices;
 9     
10     public String getOtherIndex()
11     {
12         return candidateIndices.get(0);
13     }
14 }

 1     public String switchIndexAlias() {
 2         IndexAliasVO indexAlias = originalItemSearchService.getIndexAlias();
 3         String newIndex = indexAlias.getOtherIndex();
 4         originalItemSearchService.resetIndex(newIndex);
 5         importDoc(newIndex);
 6         originalItemSearchService.switchIndexAlias(newIndex);
 7         return newIndex;
 8     }
 9 
10 
11     private void importDoc(String newIndex) {
12 
13         Long lastId = 0L;
14 
15         while (true) {
16 
17             List<ItOriginalItemInformation> itemInfo = getItemInfoLimit(ITEM_LIMIT_END, lastId);
18 
19             if (itemInfo.isEmpty()) {
20                 break;
21             }
22 
23             List<OriginalItemDoc> itemDocList = parseDoc(itemInfo);
24 
25             if (!originalItemSearchService.indexItems(newIndex, itemDocList)) {
26                 throw new ServiceException("批量将商品数据导入ES索引库失败");
27             }
28 
29             if (itemInfo.size() < ITEM_LIMIT_END) {
30                 break;
31             }
32 
33             lastId = itemInfo.get(itemInfo.size() - 1).getId();
34         }
35 
36     }
37 
38 
39    private List<ItOriginalItemInformation> getItemInfoLimit(int endIndex, Long maxId) {
40         ItOriginalItemInformationExample e = new ItOriginalItemInformationExample();
41         e.setLimitStart(0);
42         e.setLimitEnd(endIndex);
43         e.setOrderByClause("id ASC ");
44         e.createCriteria().andIdGreaterThan(maxId);
45         List<ItOriginalItemInformation> items = itOriginalItemInformationMapper.selectByExample(e);
46         return items;
47     }

ES默认服务端口9300

外部通信端口9200

head插件端口9100

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