ElasticSearch安装和使用

Posted 2020-09-17

　　ElasticSearch是开源搜索平台的新成员，实时数据分析的神器。可以理解为作为搜索的数据库，可以提供搜索功能。对比关系型数据库，具有以下的相似关系：

关系型数据库	数据库	表	行	列
ElasticSearch	索引	类型	文档	字段

　　一个ES集群可以包含多个索引（数据库），每个索引又包含了很多类型（表），类型中包含了很多文档（行），每个文档又包含了很多字段（列）。

　　如果要实现对关系型数据库数据的搜索功能，需要将关系型数据库中的数据导入到ElasticSearch中，网上有解决方案。但是好像不支持最新的ElasticSearch5，可以使用我下面的Java代码实现数据的导入。

Ubuntu系统安装 Elasticsearch5

升级系统后安装 Oracle Java 7，既然 Elasticsearch 官方推荐使用 Oracle JDK 7 就不要尝试 JDK 8 和 OpenJDK 了：

1 $ sudo apt-get update
2 $ sudo apt-get upgrade
3  
4 $ sudo apt-get install software-properties-common
5 $ sudo add-apt-repository ppa:webupd8team/java
6 $ sudo apt-get update
7  
8 $ sudo apt-get install oracle-java7-installer

加入 Elasticsearch 官方源后安装 elasticsearch：

1 $ wget -O - http://packages.elasticsearch.org/GPG-KEY-elasticsearch | apt-key add -
2 $ sudo echo "deb http://packages.elasticsearch.org/elasticsearch/1.1/debian stable main" >> /etc/apt/sources.list
3  
4 $ sudo apt-get update
5 $ sudo apt-get install elasticsearch

加入到系统启动文件并启动 elasticsearch 服务，用 curl 测试一下安装是否成功：

 1 $ sudo update-rc.d elasticsearch defaults 95 1
 2  
 3 $ sudo /etc/init.d/elasticsearch start
 4  
 5 $ curl -X GET ‘http://localhost:9200‘
 6 {
 7   "status" : 200,
 8   "name" : "Fer-de-Lance",
 9   "version" : {
10     "number" : "1.1.1",
11     "build_hash" : "f1585f096d3f3985e73456debdc1a0745f512bbc",
12     "build_timestamp" : "2014-04-16T14:27:12Z",
13     "build_snapshot" : false,
14     "lucene_version" : "4.7"
15   },
16   "tagline" : "You Know, for Search"
17 }

Elasticsearch 的集群和数据管理界面 Marvel 非常赞，可惜只对开发环境免费，安装很简单，完成后重启服务访问 http://192.168.2.172:9200/_plugin/marvel/ 就可以看到界面：

1 $ sudo /usr/share/elasticsearch/bin/plugin -i elasticsearch/marvel/latest
2  
3 $ sudo /etc/init.d/elasticsearch restart
4  * Stopping Elasticsearch Server                                           [ OK ]
5  * Starting Elasticsearch Server                                           [ OK ]

另外可以安装elasticsearch-head作为管理Elasticsearch的web前端插件。

安装教程：Elasticsearch5中安装Elasticsearch-head插件

ElasticSearch Java调用

 　　命令调用的方式不再讲述了，网上很多。ElasticSearch最终是要在项目中使用的。官方的API文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html

 自己写了助手类，方便大家调用。可以实现索引的增删改查，查询提供多种方法，包括or、and查询，多个关键词查询，关键词高亮等，适用于不同场合。

首先是引用需要的jar包。使用maven管理jar包，需要的jar包有：

 1         <dependency>
 2             <groupId>org.elasticsearch</groupId>
 3             <artifactId>elasticsearch</artifactId>
 4             <version>5.3.1</version>
 5         </dependency>
 6         <dependency>
 7             <groupId>org.elasticsearch.client</groupId>
 8             <artifactId>transport</artifactId>
 9             <version>5.3.1</version>
10         </dependency>
11         <dependency>
12             <groupId>org.apache.logging.log4j</groupId>
13             <artifactId>log4j-api</artifactId>
14             <version>2.7</version>
15         </dependency>
16         <dependency>
17             <groupId>org.apache.logging.log4j</groupId>
18             <artifactId>log4j-core</artifactId>
19             <version>2.7</version>
20         </dependency>

 

然后是ElasticSearch配置文件，存储集群名称、集群IP、索引名称。配置文件命名为：elasticsearch.properties

cluster_name=elasticsearch
cluster_serverip=127.0.0.1
indexname=blogsystem

 

还需要配置日志配置文件，命名为：log4j2.properties

appender.console.type = Console
appender.console.name = console
appender.console.layout.type = PatternLayout

rootLogger.level = info
rootLogger.appenderRef.console.ref = console

 

最后是java的实现ElasticSearch助手类。为了方便使用，助手类分为具体实现和调用两个类。

ElasticSearch具体实现类：ElasticSearchUtilsImp.java

  1 package com.blog.utils;
  2 
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.lang.reflect.Method;
  6 import java.net.InetAddress;
  7 import java.net.UnknownHostException;
  8 import java.util.ArrayList;
  9 import java.util.HashMap;
 10 import java.util.List;
 11 import java.util.Map;
 12 import java.util.Properties;
 13 import java.util.concurrent.ExecutionException;
 14 
 15 import org.elasticsearch.action.delete.DeleteResponse;
 16 import org.elasticsearch.action.index.IndexResponse;
 17 import org.elasticsearch.action.search.SearchRequestBuilder;
 18 import org.elasticsearch.action.search.SearchResponse;
 19 import org.elasticsearch.action.update.UpdateRequest;
 20 import org.elasticsearch.client.transport.TransportClient;
 21 import org.elasticsearch.common.settings.Settings;
 22 import org.elasticsearch.common.text.Text;
 23 import org.elasticsearch.common.transport.InetSocketTransportAddress;
 24 import org.elasticsearch.common.xcontent.XContentBuilder;
 25 import org.elasticsearch.common.xcontent.XContentFactory;
 26 import org.elasticsearch.index.query.BoolQueryBuilder;
 27 import org.elasticsearch.index.query.QueryBuilder;
 28 import org.elasticsearch.index.query.QueryBuilders;
 29 import org.elasticsearch.rest.RestStatus;
 30 import org.elasticsearch.search.SearchHits;
 31 import org.elasticsearch.search.aggregations.AggregationBuilders;
 32 import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
 33 import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
 34 import org.elasticsearch.transport.client.PreBuiltTransportClient;
 35 
 36 /**
 37  * @author：Tim
 38  * @date：2017年5月3日 下午8:24:22
 39  * @description：ElasticSearch助手类具体实现
 40  */
 41 public class ElasticSearchUtilsImp {
 42 
 43     private static String cluster_name = null;// 实例名称
 44     private static String cluster_serverip = null;// elasticSearch服务器ip
 45     private static String indexname = null;// 索引名称
 46 
 47     static {
 48         try {
 49             // 读取db.properties文件
 50             Properties props = new Properties();
 51             InputStream in = ElasticSearchUtilsImp.class.getResourceAsStream("/elasticsearch.properties");
 52             props.load(in);// 加载文件
 53 
 54             // 读取信息
 55             cluster_name = props.getProperty("cluster_name");
 56             cluster_serverip = props.getProperty("cluster_serverip");
 57             indexname = props.getProperty("indexname");
 58         } catch (IOException e) {
 59             e.printStackTrace();
 60             System.out.println("加载数据库配置文件出错！");
 61         }
 62     }
 63 
 64     /**
 65      * 返回一个到ElasticSearch的连接客户端
 66      * 
 67      * @return
 68      */
 69     private static TransportClient getClient() {
 70         Settings settings = Settings.builder().put("cluster.name", cluster_name).build();// 设置集群名称
 71         @SuppressWarnings("unchecked")
 72         TransportClient client = new PreBuiltTransportClient(settings);// 创建client
 73         try {
 74             client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(cluster_serverip), 9300));// 增加地址和端口
 75         } catch (UnknownHostException e) {
 76             e.printStackTrace();
 77             System.out.println("ElasticSearch连接失败！");
 78         }
 79 
 80         return client;
 81     }
 82 
 83     /**
 84      * 将Map转换成builder
 85      * 
 86      * @param mapParam
 87      * @return
 88      * @throws Exception
 89      */
 90     private static XContentBuilder createMapJson(Map<String, String> mapParam) throws Exception {
 91         XContentBuilder source = XContentFactory.jsonBuilder().startObject();
 92 
 93         for (Map.Entry<String, String> entry : mapParam.entrySet()) {
 94             source.field(entry.getKey(), entry.getValue());
 95         }
 96 
 97         source.endObject();
 98 
 99         return source;
100     }
101 
102     /**
103      * 将实体转换成json
104      * 
105      * @param entity 实体
106      * @param fieldNameParm 实体中待转换成json的字段
107      * @return 返回json
108      * @throws Exception
109      */
110     private static XContentBuilder createEntityJson(Object entity, String... methodNameParm) throws Exception {
111         // 创建json对象, 其中一个创建json的方式
112         XContentBuilder source = XContentFactory.jsonBuilder().startObject();
113 
114         try {
115             for (String methodName : methodNameParm) {
116 
117                 if (!methodName.startsWith("get")) {
118                     throw new Exception("不是有效的属性！");
119                 }
120 
121                 Method method = entity.getClass().getMethod(methodName, null);
122                 String fieldValue = (String) method.invoke(entity, null);
123                 String fieldName = StringUtils.toLowerCaseFirstOne(methodName.replace("get", ""));// 去掉“get”，并将首字母小写
124 
125                 // 避免和elasticSearch中id字段重复
126                 if (fieldName == "_id") {
127                     fieldName = "id";
128                 }
129 
130                 source.field(fieldName, fieldValue);
131             }
132         } catch (NoSuchMethodException e) {
133             e.printStackTrace();
134             System.out.println("未找到方法！");
135         }
136 
137         source.endObject();
138 
139         return source;
140     }
141 
142     /**
143      * 将一个Map格式的数据（key,value）插入索引 （私有方法）
144      * 
145      * @param type 类型（对应数据库表）
146      * @param docId id，对应elasticSearch中的_id字段
147      * @param mapParam Map格式的数据
148      * @return
149      */
150     public static boolean addMapDocToIndex(String type, String docId, Map<String, String> mapParam) {
151         boolean result = false;
152 
153         TransportClient client = getClient();
154         XContentBuilder source = null;
155         try {
156             source = createMapJson(mapParam);
157         } catch (Exception e) {
158             e.printStackTrace();
159         }
160 
161         // 存json入索引中
162         IndexResponse response = null;
163         if (docId == null) {
164             // 使用默认的id
165             response = client.prepareIndex(indexname, type).setSource(source).get();
166         } else {
167             response = client.prepareIndex(indexname, type, docId).setSource(source).get();
168         }
169 
170         // 插入结果获取
171         String index = response.getIndex();
172         String gettype = response.getType();
173         String id = response.getId();
174         long version = response.getVersion();
175         RestStatus status = response.status();
176 
177         String strResult = "新增文档成功：" + index + " : " + gettype + ": " + id + ": " + version + ": " + status.getStatus();
178         System.out.println(strResult);
179 
180         if (status.getStatus() == 201) {
181             result = true;
182         }
183 
184         // 关闭client
185         client.close();
186 
187         return result;
188     }
189 
190     /**
191      * 将一个实体存入到默认索引的类型中（指定_id，一般是业务数据的id，及elasticSearch和关系型数据使用同一个id，方便同关系型数据库互动）
192      * （私有方法）
193      * 
194      * @param type 类型（对应数据库表）
195      * @param docId id，对应elasticSearch中的_id字段
196      * @param entity 要插入的实体
197      * @param methodNameParm 需要将实体中哪些属性作为字段
198      * @return
199      */
200     public static boolean addEntityDoc(String type, String docId, Object entity, String... methodNameParm) {
201         boolean result = false;
202 
203         TransportClient client = getClient();
204         XContentBuilder source = null;
205         try {
206             source = createEntityJson(entity, methodNameParm);
207         } catch (Exception e) {
208             e.printStackTrace();
209         }
210 
211         // 存json入索引中
212         IndexResponse response = null;
213         if (docId == null) {
214             // 使用默认的id
215             response = client.prepareIndex(indexname, type).setSource(source).get();
216         } else {
217             response = client.prepareIndex(indexname, type, docId).setSource(source).get();
218         }
219 
220         // 插入结果获取
221         String index = response.getIndex();
222         String gettype = response.getType();
223         String id = response.getId();
224         long version = response.getVersion();
225         RestStatus status = response.status();
226 
227         String strResult = "新增文档成功：" + index + " : " + gettype + ": " + id + ": " + version + ": " + status.getStatus();
228         System.out.println(strResult);
229 
230         if (status.getStatus() == 201) {
231             result = true;
232         }
233 
234         // 关闭client
235         client.close();
236 
237         return result;
238     }
239 
240     /**
241      * 删除文档
242      * 
243      * @param type 类型（对应数据库表）
244      * @param docId 类型中id
245      * @return
246      */
247     public static boolean deleteDoc(String type, String docId) {
248         boolean result = false;
249 
250         TransportClient client = getClient();
251         DeleteResponse deleteresponse = client.prepareDelete(indexname, type, docId).get();
252 
253         System.out.println("删除结果：" + deleteresponse.getResult().toString());
254         if (deleteresponse.getResult().toString() == "DELETED") {
255             result = true;
256         }
257 
258         // 关闭client
259         client.close();
260 
261         return result;
262     }
263 
264     /**
265      * 修改文档
266      * 
267      * @param type 类型
268      * @param docId 文档id
269      * @param updateParam 需要修改的字段和值
270      * @return
271      */
272     public static boolean updateDoc(String type, String docId, Map<String, String> updateParam) {
273         String strResult = "";
274         boolean result = false;
275 
276         TransportClient client = getClient();
277 
278         UpdateRequest updateRequest = new UpdateRequest();
279         updateRequest.index(indexname);
280         updateRequest.type(type);
281         updateRequest.id(docId);
282         try {
283             updateRequest.doc(createMapJson(updateParam));
284         } catch (Exception e) {
285             e.printStackTrace();
286         }
287         try {
288             strResult = client.update(updateRequest).get().getResult().toString();
289         } catch (InterruptedException e) {
290             e.printStackTrace();
291         } catch (ExecutionException e) {
292             e.printStackTrace();
293         }
294         System.out.println(strResult);
295 
296         if (strResult == "UPDATED") {
297             result = true;
298         }
299 
300         return result;
301     }
302 
303     /**
304      * TODO or查询命中条数
305      * @param type 类型
306      * @param shouldMap 查询条件
307      * @return
308      */
309     public static int multiOrSearchDocCount(String type, Map<String, String> shouldMap) {
310         TransportClient client = getClient();
311 
312         return 0;
313     }
314 
315     /**
316      * 高亮搜索
317      * 
318      * @param type 类型
319      * @param fieldName 段
320      * @param keyword 关键词
321      * @param from 开始行数
322      * @param size 每页大小
323      * @return
324      */
325     public static Map<String, Object> searchDocHighlight(String type, String fieldName, String keyword, int from,
326             int size) {
327         TransportClient client = getClient();
328 
329         // 高亮
330         HighlightBuilder hiBuilder = new HighlightBuilder();
331         hiBuilder.preTags("<span style=\\"color:red\\">");
332         hiBuilder.postTags("</span>");
333         hiBuilder.field(fieldName);
334 
335         QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery(fieldName, keyword);
336 
337         SearchRequestBuilder responsebuilder = client.prepareSearch(indexname).setTypes(type);
338         responsebuilder.setQuery(queryBuilder);
339         responsebuilder.highlighter(hiBuilder);
340         responsebuilder.setFrom(from);
341         responsebuilder.setSize(size);
342         responsebuilder.setExplain(true);
343 
344         SearchResponse myresponse = responsebuilder.execute().actionGet();
345         SearchHits searchHits = myresponse.getHits();
346 
347         // 总命中数
348         long total = searchHits.getTotalHits();
349         Map<String, Object> map = new HashMap<String, Object>();
350         map.put("total", total);
351         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
352         for (int i = 0; i < searchHits.getHits().length; i++) {
353             Map<String, HighlightField> highlightFields = searchHits.getHits()[i].getHighlightFields();
354 
355             // 段高亮
356             HighlightField titleField = highlightFields.get(fieldName);
357             Map<String, Object> source = searchHits.getHits()[i].getSource();
358             if (titleField != null) {
359                 Text[] fragments = titleField.fragments();
360                 String name = "";
361                 for (Text text : fragments) {
362                     name += text;
363                 }
364                 source.put(fieldName, name);
365             }
366 
367             list.add(source);
368         }
369         map.put("rows", list);
370 
371         return map;
372     }
373 
374     /**
375      * or条件查询高亮
376      * 
377      * @param type 类型
378      * @param shouldMap or条件和值
379      * @param from 开始行数
380      * @param size 每页大小
381      * @return
382      */
383     public static Map<String, Object> multiOrSearchDocHigh(String type, Map<String, String> shouldMap, int from,
384             int size) {
385         TransportClient client = getClient();
386 
387         SearchRequestBuilder responsebuilder = client.prepareSearch(indexname).setTypes(type);
388         responsebuilder.setFrom(from);
389         responsebuilder.setSize(size);
390         responsebuilder.setExplain(true);
391 
392         // 高亮
393         HighlightBuilder hiBuilder = new HighlightBuilder();
394         hiBuilder.preTags("<span style=\\"color:red\\">");
395         hiBuilder.postTags("</span>");
396 
397         // 高亮每个字段
398         for (String key : shouldMap.keySet()) {
399             hiBuilder.field(key);
400         }
401 
402         responsebuilder.highlighter(hiBuilder);
403 
404         if (null != shouldMap && shouldMap.size() > 0) {
405             // 创建一个查询
406             BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
407 
408             // 这里查询的条件用map传递
409             for (String key : shouldMap.keySet()) {
410                 queryBuilder.should(QueryBuilders.matchPhraseQuery(key, shouldMap.get(key)));// or连接条件
411             }
412             // 查询
413             responsebuilder.setQuery(queryBuilder);
414         }
415 
416         SearchResponse myresponse = responsebuilder.execute().actionGet();
417         SearchHits searchHits = myresponse.getHits();
418 
419         // 总命中数
420         long total = searchHits.getTotalHits();
421         Map<String, Object> map = new HashMap<String, Object>();
422         map.put("total", total);
423         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
424         for (int i = 0; i < searchHits.getHits().length; i++) {
425             Map<String, HighlightField> highlightFields = searchHits.getHits()[i].getHighlightFields();
426             Map<String, Object> source = searchHits.getHits()[i].getSource();
427 
428             for (String key : shouldMap.keySet()) {
429                 // 各个段进行高亮
430                 HighlightField titleField = highlightFields.get(key);
431                 if (titleField != null) {
432                     Text[] fragments = titleField.fragments();
433                     String name = "";
434                     for (Text text : fragments) {
435                         name += text;
436                     }
437                     source.put(key, name);
438                 }
439             }
440 
441             list.add(source);
442         }
443         map.put("rows", list);
444 
445         return map;
446     }
447 
448     /**
449      * 搜索
450      * 
451      * @param type 类型
452      * @param fieldName 待搜索的字段
453      * @param keyword 待搜索的关键词
454      * @param from 开始行数
455      * @param size 每页大小
456      * @return
457      */
458     public static Map<String, Object> searchDoc(String type, String fieldName, String keyword, int from, int size) {
459         List<String> hitResult = new ArrayList<String>();
460 
461         TransportClient client = getClient();
462 
463         QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery(fieldName, keyword);
464 
465         SearchRequestBuilder responsebuilder = client.prepareSearch(indexname).setTypes(type);
466         responsebuilder.setQuery(queryBuilder);
467         responsebuilder.setFrom(from);
468         responsebuilder.setSize(size);
469         responsebuilder.setExplain(true);
470 
471         SearchResponse myresponse = responsebuilder.execute().actionGet();
472         SearchHits hits = myresponse.getHits();
473         for (int i = 0; i < hits.getHits().length; i++) {
474             hitResult.add(hits.getHits()[i].getSourceAsString());
475         }
476 
477         // 将命中结果转换成Map输出
478         Map<String, Object> modelMap = new HashMap<String, Object>(2);
479         modelMap.put("total", hitResult.size());
480         modelMap.put("rows", hitResult);
481 
482         return modelMap;
483     }
484 
485     /**
486      * 多个条件进行or查询
487      * 
488      * @param type 类型
489      * @param shouldMap 进行or查询的段和值
490      * @param from 开始行数
491      * @param size 每页大小
492      * @return
493      */
494     public static Map<String, Object> multiOrSearchDoc(String type, Map<String, String> shouldMap, int from, int size) {
495         List<String> hitResult = new ArrayList<String>();
496 
497         TransportClient client = getClient();
498 
499         SearchRequestBuilder responsebuilder = client.prepareSearch(indexname).setTypes(type);
500         responsebuilder.setFrom(from);
501         responsebuilder.setSize(size);
502         responsebuilder.setExplain(true);
503 
504         if (null != shouldMap && shouldMap.size() > 0) {
505             // 创建一个查询
506             BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
507 
508             // 这里查询的条件用map传递
509             for (String key : shouldMap.keySet()) {
510                 queryBuilder.should(QueryBuilders.matchPhraseQuery(key, shouldMap.get(key)));// or连接条件
511             }
512             // 查询
513             responsebuilder.setQuery(queryBuilder);
514         }
515 
516         SearchResponse myresponse = responsebuilder.execute().actionGet();
517         SearchHits hits = myresponse.getHits();
518         for (int i = 0; i < hits.getHits().length; i++) {
519             hitResult.add(hits.getHits()[i].getSourceAsString());
520         }
521 
522         // 将命中结果转换成Map输出
523         Map<String, Object> modelMap = new HashMap<String, Object>(2);
524         modelMap.put("total", hitResult.size());
525         modelMap.put("rows", hitResult);
526 
527         return modelMap;
528     }
529 
530     /**
531      * 多个条件进行and查询
532      * 
533      * @param type 类型
534      * @param mustMap 进行and查询的段和值
535      * @param from 开始行数
536      * @param size 每页大小
537      * @return
538      */
539     public static Map<String, Object> multiAndSearchDoc(String type, Map<String, String> mustMap, int from, int size) {
540         List<String> hitResult = new ArrayList<String>();
541 
542         TransportClient client = getClient();
543 
544         SearchRequestBuilder responsebuilder = client.prepareSearch(indexname).setTypes(type);
545         responsebuilder.setFrom(from);
546         responsebuilder.setSize(size);
547         responsebuilder.setExplain(true);
548 
549         if (null != mustMap && mustMap.size() > 0) {
550             // 创建一个查询
551             BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
552 
553             // 这里查询的条件用map传递
554             for (String key : mustMap.keySet()) {
555                 queryBuilder.must(QueryBuilders.matchPhraseQuery(key, mustMap.get(key)));// and查询
556             }
557             // 查询
558             responsebuilder.setQuery(queryBuilder);
559         }
560 
561         SearchResponse myresponse = responsebuilder.execute().actionGet();
562         SearchHits hits = myresponse.getHits();
563         for (int i = 0; i < hits.getHits().length; i++) {
564             hitResult.add(hits.getHits()[i].getSourceAsString());
565         }
566 
567         // 将命中结果转换成Map输出
568         Map<String, Object> modelMap = new HashMap<String, Object>(2);
569         modelMap.put("total", hitResult.size());
570         modelMap.put("rows", hitResult);
571 
572         return modelMap;
573     }
574 }

ElasticSearchUtilsImp.java

 

ElasticSearch调用类，是对实现类的各种组合，供外部调用。调用类名称：ElasticSearchUtils.java

  1 package com.blog.utils;
  2 
  3 import java.util.Map;
  4 
  5 /**
  6  * @author：Tim
  7  * @date：2017年5月3日 下午8:24:22
  8  * @description：ElasticSearch助手类
  9  */
 10 public class ElasticSearchUtils {
 11 
 12     /**
 13      * 将一个Map格式的数据（key,value）插入索引（指定_id，一般是业务数据的id，及elasticSearch和关系型数据使用同一个id，方便同关系型数据库互动）
 14      * 
 15      * @param type 类型（对应数据库表）
 16      * @param docId id，对应elasticSearch中的_id字段
 17      * @param mapParam Map格式的数据
 18      * @return
 19      */
 20     public static boolean addDoc(String type, String docId, Map<String, String> mapParam) {
 21         return ElasticSearchUtilsImp.addMapDocToIndex(type, docId, mapParam);
 22     }
 23 
 24     /**
 25      * 将一个Map格式的数据（key,value）插入索引 （使用默认_id）
 26      * 
 27      * @param type 类型（对应数据库表）
 28      * @param mapParam Map格式的数据
 29      * @return
 30      */
 31     public static boolean addDoc(String type, Map<String, String> mapParam) {
 32         return ElasticSearchUtilsImp.addMapDocToIndex(type, null, mapParam);
 33     }
 34 
 35     /**
 36      * 将一个实体存入到默认索引的类型中（默认_id）
 37      * 
 38      * @param type 类型（对应数据库表）
 39      * @param entity 要插入的实体
 40      * @param methodNameParm 需要将实体中哪些属性作为字段
 41      * @return
 42      */
 43     public static boolean addDoc(String type, Object entity, String... methodNameParm) {
 44         return ElasticSearchUtilsImp.addEntityDoc(type, null, entity, methodNameParm);
 45     }
 46 
 47     /**
 48      * 将一个实体存入到默认索引的类型中（指定_id，一般是业务数据的id，及elasticSearch和关系型数据使用同一个id，方便同关系型数据库互动）
 49      * 
 50      * @param type 类型（对应数据库表）
 51      * @param docId id，对应elasticSearch中的_id字段
 52      * @param entity 要插入的实体
 53      * @param methodNameParm 需要将实体中哪些属性作为字段
 54      * @return
 55      */
 56     public static boolean addDoc(String type, String docId, Object entity, String... methodNameParm) {
 57         return ElasticSearchUtilsImp.addEntityDoc(type, docId, entity, methodNameParm);
 58     }
 59 
 60     /**
 61      * 删除文档
 62      * 
 63      * @param type 类型（对应数据库表）
 64      * @param docId 类型中id
 65      * @return
 66      */
 67     public static boolean deleteDoc(String type, String docId) {
 68         return ElasticSearchUtilsImp.deleteDoc(type, docId);
 69     }
 70 
 71     /**
 72      * 修改文档
 73      * 
 74      * @param type 类型
 75      * @param docId 文档id
 76      * @param updateParam 需要修改的字段和值
 77      * @return
 78      */
 79     public static boolean updateDoc(String type, String docId, Map<String, String> updateParam) {
 80         return ElasticSearchUtilsImp.updateDoc(type, docId, updateParam);
 81     }
 82 
 83     // --------------------以下是各种搜索方法--------------------------
 84 
 85     /**
 86      * 高亮搜索
 87      * 
 88      * @param type 类型
 89      * @param fieldName 段
 90      * @param keyword 段值
 91      * @return
 92      */
 93     public static Map<String, Object> searchDocHighlight(String type, String fieldName, String keyword) {
 94         return ElasticSearchUtilsImp.searchDocHighlight(type, fieldName, keyword, 0, 10);
 95     }
 96 
 97     /**
 98      * 高亮搜索
 99      * 
100      * @param type 类型
101      * @param fieldName 段
102      * @param keyword 关键词
103      * @param from 开始行数
104      * @param size 每页大小
105      * @return
106      */
107     public static Map<String, Object> searchDocHighlight(String type, String fieldName, String keyword, int from,
108             int size) {
109         return ElasticSearchUtilsImp.searchDocHighlight(type, fieldName, keyword, from, size);
110     }
111 
112     /**
113      * or条件查询高亮
114      * 
115      * @param type 类型
116      * @param shouldMap or条件和值
117      * @return
118      */
119     public static Map<String, Object> multiOrSearchDocHigh(String type, Map<String, String> shouldMap, int from,
120             int size) {
121         return ElasticSearchUtilsImp.multiOrSearchDocHigh(type, shouldMap, from, size);
122     }
123 
124     /**
125      * 搜索
126      * 
127      * @param type 类型
128      * @param fieldName 待搜索的字段
129      * @param keyword 待搜索的关键词
130      */
131     public static Map<String, Object> searchDoc(String type, String fieldName, String keyword) {
132         return ElasticSearchUtilsImp.searchDoc(type, fieldName, keyword, 0, 10);
133     }
134 
135     /**
136      * 多个条件进行or查询
137      * 
138      * @param type 类型
139      * @param shouldMap 进行or查询的段和值
140      * @return
141      */
142     public static Map<String, Object> multiOrSearchDoc(String type, Map<String, String> shouldMap) {
143         return ElasticSearchUtilsImp.multiOrSearchDoc(type, shouldMap, 0, 10);
144     }
145 
146     /**
147      * 多个条件进行and查询
148      * 
149      * @param type 类型
150      * @param mustMap 进行and查询的段和值
151      * @return
152      */
153     public static Map<String, Object> multiAndSearchDoc(String type, Map<String, String> mustMap) {
154         return ElasticSearchUtilsImp.multiAndSearchDoc(type, mustMap, 0, 10);
155     }
156 }

 

会使用到的其他助手类：StringUtils.java

 1 package com.blog.utils;
 2 
 3 import java.util.Map;
 4 
 5 import net.sf.json.JSONObject;
 6 
 7 /**
 8  * @author：Tim
 9  * @date：2017年5月6日 上午11:56:37
10  * @description：字符串助手类
11  */
12 public class StringUtils {
13 
14     /**
15      * 将Map转换成json字符串
16      * 
17      * @param map Map<String, Object>格式数据
18      * @return json数据
19      */
20     public static String map2String(Map<String, Object> map) {
21         return JSONObject.fromObject(map).toString();
22     }
23 
24     /**
25      * 首字母转小写
26      * 
27      * @param s 待转换的字符串
28      * @return
29      */
30     public static String toLowerCaseFirstOne(String s) {
31         if (Character.isLowerCase(s.charAt(0)))
32             return s;
33         else
34             return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
35     }
36 }

StringUtils.java

 

具体的使用在我的另一个项目中有使用实例，该项目使用这个助手类实现了索引的各种操作，以及搜索展现功能。项目位置：https://github.com/yangtzeyufei/EasyBlog