ElasticSearch安装和使用

  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 }

 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 }