java中的ElasticSearch搜索引擎介绍。

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。

安装

以windows操作系统和ES0.19.7版本为例：

①下载elasticsearch-6.4.1.zip

②直接解压至某目录，设置该目录为ES_HOME环境变量

③安装JDK，并设置JAVA_HOME环境变量

④在windows下，运行 %ES_HOME%\bin\elasticsearch.bat即可运行

安装插件

以head插件为例：

联网时，直接运行%ES_HOME%\bin\plugin --install mobz/elasticsearch-head

不联网时，下载elasticsearch-head的zipball的master包，然后运行%ES_HOME%\bin\plugin --url file:///[path-to-downloadfile] --install head，其中[path-to-downloadfile]是下载后master包的绝对路径

安装完成，重启服务，在浏览器打开 http://localhost:9200/_plugin/head/ 即可

ES工作原理

当ElasticSearch的节点启动后，它会利用多播(multicast)(或者单播，如果用户更改了配置)寻找集群中的其它节点，并与之建立连接。这个过程如下图所示： 

官方代码
1 RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                     new HttpHost("localhost", 9200, "http")));
 SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
 searchSourceBuilder.query(QueryBuilders.matchAllQuery());
 searchSourceBuilder.aggregation(AggregationBuilders.terms("top_10_states").field("state").size(10));
 SearchRequest searchRequest = new SearchRequest();
 searchRequest.indices("social-*");
 searchRequest.source(searchSourceBuilder);
 SearchResponse searchResponse = client.search(searchRequest);

创建索引

 /**
      * 创建索引
      *
      * @param index
      * @return
      */
     public boolean createIndex(String index) {
         if (!isIndexExist(index)) {
             logger.info("index is not exits!");
         }
         CreateIndexResponse indexresponse = client.admin().indices().prepareCreate(index).execute().actionGet();
         logger.info("success to create index " + indexresponse.isAcknowledged());

         return indexresponse.isAcknowledged();
     }

删除索引

 /**
      * 删除索引
      *
      * @param index
      * @return
      */
     public boolean deleteIndex(String index) {
         if (!isIndexExist(index)) {
             logger.info("index is not exits!");
         }
         DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(index).execute().actionGet();
         if (dResponse.isAcknowledged()) {
             logger.info("delete index " + index + "  successfully!");
         } else {
             logger.info("fail to delete index " + index);
         }
         return dResponse.isAcknowledged();
     }

判断

 /**
      * 判断索引是否存在
      *
      * @param index
      * @return
      */
     public boolean isIndexExist(String index) {
         IndicesExistsResponse inExistsResponse = client.admin().indices().exists(new IndicesExistsRequest(index)).actionGet();
         if (inExistsResponse.isExists()) {
             logger.info("index [" + index + "] is exist!");
         } else {
             logger.info("index [" + index + "] is not exist!");
         }
         return inExistsResponse.isExists();
     }

  /**
      * 通过ID获取数据
      *
      * @param index  索引，类似数据库
      * @param type   类型，类似表
      * @param id     数据ID
      * @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
      * @return
      */
     public Map<String, Object> searchDataById(String index, String type, String id, String fields) {
         GetRequestBuilder getRequestBuilder = client.prepareGet(index, type, id);
         if (StringUtils.isNotEmpty(fields)) {
             getRequestBuilder.setFetchSource(fields.split(","), null);
         }
         GetResponse getResponse =  getRequestBuilder.execute().actionGet();
         return getResponse.getSource();
     }

     /**
      * 使用分词查询
      *
      * @param index    索引名称
      * @param type     类型名称,可传入多个type逗号分隔
      * @param fields   需要显示的字段，逗号分隔（缺省为全部字段）
      * @param matchStr 过滤条件（xxx=111,aaa=222）
      * @return
      */
     public List<Map<String, Object>> searchListData(String index, String type, String fields, String matchStr) {
         return searchListData(index, type, 0, 0, null, fields, null, false, null, matchStr);
     }

     /**
      * 使用分词查询
      *
      * @param index       索引名称
      * @param type        类型名称,可传入多个type逗号分隔
      * @param fields      需要显示的字段，逗号分隔（缺省为全部字段）
      * @param sortField   排序字段
      * @param matchPhrase true 使用，短语精准匹配
      * @param matchStr    过滤条件（xxx=111,aaa=222）
      * @return
      */
     public List<Map<String, Object>> searchListData(String index, String type, String fields, String sortField, boolean matchPhrase, String matchStr) {
         return searchListData(index, type, 0, 0, null, fields, sortField, matchPhrase, null, matchStr);
     }

     /**
      * 使用分词查询
      *
      * @param index          索引名称
      * @param type           类型名称,可传入多个type逗号分隔
      * @param size           文档大小限制
      * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
      * @param sortField      排序字段
      * @param matchPhrase    true 使用，短语精准匹配
      * @param highlightField 高亮字段
      * @param matchStr       过滤条件（xxx=111,aaa=222）
      * @return
      */
     public List<Map<String, Object>> searchListData(String index, String type, Integer size, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) {
         return searchListData(index, type, 0, 0, size, fields, sortField, matchPhrase, highlightField, matchStr);
     }

     /**
      * 使用分词查询
      *
      * @param index          索引名称
      * @param type           类型名称,可传入多个type逗号分隔
      * @param startTime      开始时间
      * @param endTime        结束时间
      * @param size           文档大小限制
      * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
      * @param sortField      排序字段
      * @param matchPhrase    true 使用，短语精准匹配
      * @param highlightField 高亮字段
      * @param matchStr       过滤条件（xxx=111,aaa=222）
      * @return
      */
     public List<Map<String, Object>> searchListData(String index, String type, long startTime, long endTime, Integer size, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) {
         SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
         if (StringUtils.isNotEmpty(type)) {
             searchRequestBuilder.setTypes(type.split(","));
         }
         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

         if (startTime > 0 && endTime > 0) {
             boolQuery.must(QueryBuilders.rangeQuery("processTime")
                     .format("epoch_millis")
                     .from(startTime)
                     .to(endTime)
                     .includeLower(true)
                     .includeUpper(true));
         }

         //搜索的的字段
         if (StringUtils.isNotEmpty(matchStr)) {
             for (String s : matchStr.split(",")) {
                 String[] ss = s.split("=");
                 if (ss.length > 1) {
                     if (matchPhrase == Boolean.TRUE) {
                         boolQuery.must(QueryBuilders.matchPhraseQuery(s.split("=")[0], s.split("=")[1]));
                     } else {
                         boolQuery.must(QueryBuilders.matchQuery(s.split("=")[0], s.split("=")[1]));
                     }
                 }
             }
         }

         // 高亮（xxx=111,aaa=222）
         if (StringUtils.isNotEmpty(highlightField)) {
             HighlightBuilder highlightBuilder = new HighlightBuilder();

             //highlightBuilder.preTags("<span style='color:red' >");//设置前缀
             //highlightBuilder.postTags("</span>");//设置后缀

             // 设置高亮字段
             highlightBuilder.field(highlightField);
             searchRequestBuilder.highlighter(highlightBuilder);
         }

         searchRequestBuilder.setQuery(boolQuery);

         if (StringUtils.isNotEmpty(fields)) {
             searchRequestBuilder.setFetchSource(fields.split(","), null);
         }
         searchRequestBuilder.setFetchSource(true);

         if (StringUtils.isNotEmpty(sortField)) {
             searchRequestBuilder.addSort(sortField, SortOrder.DESC);
         }

         if (size != null && size > 0) {
             searchRequestBuilder.setSize(size);
         }

         //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
 //        logger.info("\n{}", searchRequestBuilder);

         SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();

         long totalHits = searchResponse.getHits().totalHits;
         long length = searchResponse.getHits().getHits().length;

 //        logger.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

         if (searchResponse.status().getStatus() == 200) {
             // 解析对象
             return setSearchResponse(searchResponse, highlightField);
         }
         return null;
     }

     /**
      * 使用分词查询,并分页
      *
      * @param index          索引名称
      * @param type           类型名称,可传入多个type逗号分隔
      * @param currentPage    当前页
      * @param pageSize       每页显示条数
      * @param startTime      开始时间
      * @param endTime        结束时间
      * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
      * @param sortField      排序字段
      * @param matchPhrase    true 使用，短语精准匹配
      * @param highlightField 高亮字段
      * @param matchStr       过滤条件（xxx=111,aaa=222）
      * @return
      */
     public EsPage searchDataPage(String index, String type, int currentPage, int pageSize, long startTime, long endTime, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) {
         SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
         if (StringUtils.isNotEmpty(type)) {
             searchRequestBuilder.setTypes(type.split(","));
         }
         searchRequestBuilder.setSearchType(SearchType.QUERY_THEN_FETCH);

         // 需要显示的字段，逗号分隔（缺省为全部字段）
         if (StringUtils.isNotEmpty(fields)) {
             searchRequestBuilder.setFetchSource(fields.split(","), null);
         }

         //排序字段
         if (StringUtils.isNotEmpty(sortField)) {
             searchRequestBuilder.addSort(sortField, SortOrder.DESC);
         }

         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

         if (startTime > 0 && endTime > 0) {
             boolQuery.must(QueryBuilders.rangeQuery("@timestamp")
                     .format("epoch_millis")
                     .from(startTime)
                     .to(endTime)
                     .includeLower(true)
                     .includeUpper(true));
         }

         // 查询字段
         if (StringUtils.isNotEmpty(matchStr)) {
             for (String s : matchStr.split(",")) {
                 String[] ss = s.split("=");
                 if (ss.length > 1) {
                     if (matchPhrase == Boolean.TRUE) {
                         boolQuery.must(QueryBuilders.matchPhraseQuery(s.split("=")[0], s.split("=")[1]));
                     } else {
                         boolQuery.must(QueryBuilders.matchQuery(s.split("=")[0], s.split("=")[1]));
                     }
                 }
             }
         }

         // 高亮（xxx=111,aaa=222）
         if (StringUtils.isNotEmpty(highlightField)) {
             HighlightBuilder highlightBuilder = new HighlightBuilder();

             //highlightBuilder.preTags("<span style='color:red' >");//设置前缀
             //highlightBuilder.postTags("</span>");//设置后缀

             // 设置高亮字段
             highlightBuilder.field(highlightField);
             searchRequestBuilder.highlighter(highlightBuilder);
         }

         searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
         searchRequestBuilder.setQuery(boolQuery);

         // 分页应用
         searchRequestBuilder.setFrom(currentPage).setSize(pageSize);

         // 设置是否按查询匹配度排序
         searchRequestBuilder.setExplain(true);

         //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
 //        logger.info("\n{}", searchRequestBuilder);

         // 执行搜索,返回搜索响应信息
         SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();

         long totalHits = searchResponse.getHits().totalHits;
         long length = searchResponse.getHits().getHits().length;

 //        logger.debug("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

         if (searchResponse.status().getStatus() == 200) {
             // 解析对象
             List<Map<String, Object>> sourceList = setSearchResponse(searchResponse, highlightField);

             return new EsPage(currentPage, pageSize, (int) totalHits, sourceList);
         }
         return null;
     }

     /**
      * 高亮结果集 特殊处理
      *
      * @param searchResponse
      * @param highlightField
      */
     private List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
         List<Map<String, Object>> sourceList = new ArrayList<Map<String, Object>>();
         StringBuffer stringBuffer = new StringBuffer();

         for (SearchHit searchHit : searchResponse.getHits().getHits()) {
             searchHit.getSource().put("id", searchHit.getId());

             if (StringUtils.isNotEmpty(highlightField)) {

                 System.out.println("遍历 高亮结果集，覆盖 正常结果集" + searchHit.getSource());
                 Text[] text = searchHit.getHighlightFields().get(highlightField).getFragments();

                 if (text != null) {
                     for (Text str : text) {
                         stringBuffer.append(str.string());
                     }
                     //遍历 高亮结果集，覆盖 正常结果集
                     searchHit.getSource().put(highlightField, stringBuffer.toString());
                 }
             }
             sourceList.add(searchHit.getSource());
         }
         return sourceList;
     }