详解spring中使用Elasticsearch的代码实现

2024-10-10 00:25:09

在使用Elasticsearch之前，先给大家聊一点干货。

1. ES和solr都是作为全文搜索引擎出现的。都是基于Lucene的搜索服务器。

2. ES不是可靠的存储系统，不是数据库，它有丢数据的风险。

3. ES不是实时系统，数据写入成功只是trans log成功（类似于MySQL的bin log），写入成功后立刻查询查不到是正常的。因为数据此刻可能还在内存里而不是进入存储引擎里。同理，删除一条数据后也不是马上消失。写入何时可查询？ES内部有一个后台线程，定时将内存中的一批数据写入到存储引擎，此后数据可见。默认后台线程一秒运行一次。该线程运行的越频繁，写入性能越低。运行的频率越低，写入的性能越高（不会无限高）。

4. 目前已知的单ES集群可以存储PB级别的数据，不过这个就非常费劲了。TB级别数据没压力。

5. 如果使用ES官方提供的jar包访问，需要JDK1.7及以上。

6. 使用对应的版本访问ES server。如果ES server端的版本是1.7，那么请使用ES 1.7的client。如果ES server是2.1，请使用2.1的client。

7. ES索引存在Linux服务器的文件系统之上（背后是文件系统，不是类似于HDFS的分布式文件系统）

8. ES Java client是线程安全的，全局构建一个即可满足读写需求，不要每次都创建ES client。每次访问ES都构建新的es client即会抛出次异常。

9. 非常不建议使用ES的动态识别和创建的机制，因为很多情况下这并非你所需要。推荐的做法是在写数据之前仔细的创建mapping。

10. 强烈不建议在ES中使用深分页。可能会导致集群不可用。

11. ES是静态分片，一旦分片数在创建索引时确定那么后继不能修改。

12. ES里提供了type，很多人以为type是物理表，一个type的数据是独立存储的；但是在ES内部并不是这样，type在ES内部仅仅是一个字段。所以在很多数据能分为独立index的情况下，不要放到一个index里用type去分。只有嵌套类和父子类的情况下使用type才是合理的。

13. ES并不提供原生的中文分词的能力。有第三方的中文分词的插件，比如ik等。Ik是个toy分词器，有严肃的分词需求的话，请在使用ES之前使用独立的分词器分好词后向ES写入。

14. ES中的index，首先会进行分片，每一个分片数据一般都会有自己的副本数据，ES分配分片的策略会保证同一个分片数据和自己的副本不会分配到同一个节点上。当集群中的某一节点宕机后，ES的master在ping该节点时通过一定的策略会发现该节点不存活；会开启ES的恢复过程

15. ES没有update的能力。所有的update都是标记删除老文档，然后重新insert一条新文档。

好了，回归正题。

首先：

增加我们的spring配置

<bean id="client" factory-bean="esClientBuilder" factory-method="init" destroy-method="close"/> 

  <bean id="esClientBuilder" class="com.***.EsClientBuilder">
    <property name="clusterName" value="集群名称" />
    <property name="nodeIpInfo" value="集群地址" />
  </bean>

其次：

编写我们的EsClientBuilder类初始化我们的ES参数

package ***;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
public class EsClientBuilder { 

  private String clusterName;
  private String nodeIpInfo;
  private TransportClient client; 

  public Client init(){
    //设置集群的名字
    Settings settings = Settings.settingsBuilder()
        .put("client.transport.sniff", false)
        .put("cluster.name", clusterName)
        .build();
    //创建集群client并添加集群节点地址
    client = TransportClient.builder().settings(settings).build();
    Map<String, Integer> nodeMap = parseNodeIpInfo();
    for (Map.Entry<String,Integer> entry : nodeMap.entrySet()){
      try {
        client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(entry.getKey()), entry.getValue()));
      } catch (UnknownHostException e) {
        e.printStackTrace();
      }
    } 

    return client;
  } 

  /**
   * 解析节点IP信息,多个节点用逗号隔开,IP和端口用冒号隔开
   *
   * @return
   */
  private Map<String, Integer> parseNodeIpInfo(){
    String[] nodeIpInfoArr = nodeIpInfo.split(",");
    Map<String, Integer> map = new HashMap<String, Integer>(nodeIpInfoArr.length);
    for (String ipInfo : nodeIpInfoArr){
      String[] ipInfoArr = ipInfo.split(":");
      map.put(ipInfoArr[0], Integer.parseInt(ipInfoArr[1]));
    }
    return map;
  } 

  public String getClusterName() {
    return clusterName;
  } 

  public void setClusterName(String clusterName) {
    this.clusterName = clusterName;
  } 

  public String getNodeIpInfo() {
    return nodeIpInfo;
  } 

  public void setNodeIpInfo(String nodeIpInfo) {
    this.nodeIpInfo = nodeIpInfo;
  }
}

最后：

下面我们就可以写自己的service类了，此类就可以通过es的原生api来操作我们的es（这里我们展示的2.X版本的）
indexName相当于数据库名，typeName相当于表名

请参考EsServiceImpl.Java文件

package ***; 

@Service("esService")
public class EsServiceImpl{ 

  @Autowired
  private Client client; 

  /**
   * 用docId获取document
   * @param indexName
   * @param typeName
   * @param docId
   */
  private static void getWithId(String indexName, String typeName, String docId) {
    //get with id
    GetResponse gResponse = client.prepareGet(indexName, typeName, docId).execute().actionGet();
    System.out.println(gResponse.getIndex());
    System.out.println(gResponse.getType());
    System.out.println(gResponse.getVersion());
    System.out.println(gResponse.isExists());
    Map<String, Object> results = gResponse.getSource();
    if(results != null) {
      for(String key : results.keySet()) {
        Object field = results.get(key);
        System.out.println(key);
        System.out.println(field);
      }
    }
  }
  private static void indexWithBulk(String index, String type) {
        //指定索引名称，type名称和documentId(documentId可选，不设置则系统自动生成)创建document
        IndexRequest ir1 = new IndexRequest();
        String source1 = "{" + "\"user\":\"kimchy\"," + "\"price\":\"6.3\"," + "\"tid\":\"20001\"," + "\"message\":\"Elasticsearch\"" + "}";
        ir1.index(index).type(type).id("100").source(source1);
        IndexRequest ir2 = new IndexRequest();
        String source2 = "{" + "\"user\":\"kimchy2\"," + "\"price\":\"7.3\"," + "\"tid\":\"20002\"," + "\"message\":\"Elasticsearch\"" + "}";
        ir2.index(index).type(type).id("102").source(source2);
        IndexRequest ir3 = new IndexRequest();
        String source3 = "{" + "\"user\":\"kimchy3\"," + "\"price\":\"8.3\"," + "\"tid\":\"20003\"," + "\"message\":\"Elasticsearch\"" + "}";
        ir3.index(index).type(type).id("103").source(source3);
        BulkResponse response = client.prepareBulk().add(ir1).add(ir2).add(ir3).execute().actionGet();
        BulkItemResponse[] responses = response.getItems();
        if(responses != null && responses.length > 0) {
          for(BulkItemResponse r : responses) {
            String i = r.getIndex();
            String t = r.getType();
            System.out.println(i+","+t);
          }
        } 

  }
  private static void sumCountSearch(String indexName, String typeName,
    String sumField, String countField, String searchField, String searchValue) {
    SumBuilder sb = AggregationBuilders.sum("sumPrice").field(sumField);
    TermQueryBuilder tb = QueryBuilders.termQuery(searchField, searchValue);
    SearchResponse sResponse = client.prepareSearch(indexName).setTypes(typeName).setQuery(tb).addAggregation(sb).execute().actionGet();
    Map<String, Aggregation> aggMap = sResponse.getAggregations().asMap();
    if(aggMap != null && aggMap.size() > 0) {
      for(String key : aggMap.keySet()) {
        if("sumPrice".equals(key)) {
          Sum s = (Sum)aggMap.get(key);
          System.out.println(key + "," + s.getValue());
        }
        else if("countTid".equals(key)) {
          StatsBuilder c = (StatsBuilder)aggMap.get(key);
          System.out.println(key + "," + c.toString());
        }
      }
    }
  }
  private static void updateDoc(String indexName, String typeName, String id) throws IOException, InterruptedException, ExecutionException {
    UpdateRequest updateRequest = new UpdateRequest();
    updateRequest.index(indexName);
    updateRequest.type(typeName);
    updateRequest.id(id);
    updateRequest.doc(jsonBuilder().startObject().field("gender", "male").endObject());
    UpdateResponse resp = client.update(updateRequest).get();
    resp.getClass();
  }
  private static void scrollSearch(String indexName, String typeName, String... ids) {
    IdsQueryBuilder qb = QueryBuilders.idsQuery().addIds(ids);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        .setSearchType(SearchType.SCAN)
        .setQuery(qb)
        .setScroll(new TimeValue(100))
        .setSize(50)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards+","+timeCost+","+sShards); 

    while (true) {
      SearchHits hits = sResponse.getHits();
      SearchHit[] hitArray = hits.getHits();
      for(int i = 0; i < hitArray.length; i++) {
        SearchHit hit = hitArray[i];
        Map<String, Object> fields = hit.getSource();
        for(String key : fields.keySet()) {
          System.out.println(key);
          System.out.println(fields.get(key));
        }
      }
      sResponse = client.prepareSearchScroll(sResponse.getScrollId()).setScroll(new TimeValue(100)).execute().actionGet();
      if (sResponse.getHits().getHits().length == 0) {
        break;
      }
    }
  }
  private static void deleteDocuments(String string, String string2) {
    SearchResponse sResponse = client.prepareSearch(string)
        .setTypes(string2)
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        .setQuery(QueryBuilders.matchAllQuery())
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    List<String> ids = new ArrayList<String>(hitArray.length);
    for(int i = 0; i < count; i++) {
      System.out.println("==================================");
      SearchHit hit = hitArray[i];
      ids.add(hit.getId()); 

    }
    for(String id : ids) {
      DeleteResponse response = client.prepareDelete(string, string2, id).execute().actionGet();
    }
  }
  private static void dateRangeSearch(String indexName, String typeName,
      String termName, String from, String to) {
    // 构建range query
    //2015-08-20 12:27:11
        QueryBuilder qb = QueryBuilders.rangeQuery(termName).from(from).to(to);
        SearchResponse sResponse = client.prepareSearch(indexName)
            .setTypes(typeName)
            // 设置search type
            // 常用search type用：query_then_fetch
            // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
            .setSearchType(SearchType.QUERY_THEN_FETCH)
            // 查询的termName和termvalue
            .setQuery(qb)
            // 设置排序field
            .addSort(termName, SortOrder.DESC)
            // 设置分页
            .setFrom(0).setSize(60).execute().actionGet();
        int tShards = sResponse.getTotalShards();
        long timeCost = sResponse.getTookInMillis();
        int sShards = sResponse.getSuccessfulShards();
        System.out.println(tShards + "," + timeCost + "," + sShards);
        SearchHits hits = sResponse.getHits();
        long count = hits.getTotalHits();
        SearchHit[] hitArray = hits.getHits();
        for (int i = 0; i < count; i++) {
          SearchHit hit = hitArray[i];
          Map<String, Object> fields = hit.getSource();
          for (String key : fields.keySet()) {
            System.out.println(key);
            System.out.println(fields.get(key));
          }
        }
  }
  private static void dateRangeSearch2(String indexName, String typeName,
      String termName, String from, String to) {
    // 构建range query
      QueryBuilder qb = QueryBuilders.rangeQuery(termName).from(from).to(to);
      SearchResponse sResponse = client.prepareSearch(indexName)
          .setTypes(typeName)
          // 设置search type
          // 常用search type用：query_then_fetch
          // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
          .setSearchType(SearchType.QUERY_THEN_FETCH)
          // 查询的termName和termvalue
          .setQuery(qb)
          // 设置排序field
          .addSort(termName, SortOrder.DESC)
          // 设置分页
          .setFrom(0).setSize(60).execute().actionGet();
      int tShards = sResponse.getTotalShards();
      long timeCost = sResponse.getTookInMillis();
      int sShards = sResponse.getSuccessfulShards();
      System.out.println(tShards + "," + timeCost + "," + sShards);
      SearchHits hits = sResponse.getHits();
      long count = hits.getTotalHits();
      SearchHit[] hitArray = hits.getHits();
      for (int i = 0; i < count; i++) {
        SearchHit hit = hitArray[i];
        Map<String, Object> fields = hit.getSource();
        for (String key : fields.keySet()) {
          System.out.println(key);
          System.out.println(fields.get(key));
        }
      }
  }
  private static void countWithQuery(String indexName, String typeName, String termName, String termValue, String sortField, String highlightField) {
    //search result get source
        CountResponse cResponse = client.prepareCount(indexName)
            .setTypes(typeName)
            .setQuery(QueryBuilders.termQuery(termName, termValue))
            .execute()
            .actionGet();
        int tShards = cResponse.getTotalShards();
        int sShards = cResponse.getSuccessfulShards();
        System.out.println(tShards+","+sShards);
        long count = cResponse.getCount();
  }
  private static void rangeSearchWithOtherSearch(String indexName, String typeName,
      String termName, String min, String max, String termQueryField) {
    // 构建range query
        QueryBuilder qb = QueryBuilders.rangeQuery(termName).from(min).to(max);
        TermQueryBuilder tb = QueryBuilders.termQuery(termName, termQueryField);
        BoolQueryBuilder bq = boolQuery().must(qb).must(tb);
        SearchResponse sResponse = client.prepareSearch(indexName)
            .setTypes(typeName)
            // 设置search type
            // 常用search type用：query_then_fetch
            // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
            .setSearchType(SearchType.QUERY_THEN_FETCH)
            // 查询的termName和termvalue
            .setQuery(bq)
            // 设置排序field
            .addSort(termName, SortOrder.DESC)
            // 设置分页
            .setFrom(0).setSize(60).execute().actionGet();
        int tShards = sResponse.getTotalShards();
        long timeCost = sResponse.getTookInMillis();
        int sShards = sResponse.getSuccessfulShards();
        System.out.println(tShards + "," + timeCost + "," + sShards);
        SearchHits hits = sResponse.getHits();
        long count = hits.getTotalHits();
        SearchHit[] hitArray = hits.getHits();
        for (int i = 0; i < count; i++) {
          SearchHit hit = hitArray[i];
          Map<String, Object> fields = hit.getSource();
          for (String key : fields.keySet()) {
            System.out.println(key);
            System.out.println(fields.get(key));
          }
        }
  }
  private static void termRangeSearch(String indexName, String typeName,
    String termName, String min, String max, String highlightField) {
    QueryBuilder qb = QueryBuilders.rangeQuery(termName).from(min).to(max);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        // 设置search type
        // 常用search type用：query_then_fetch
        // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        // 查询的termName和termvalue
        .setQuery(qb)
        // 设置排序field
        .addSort(termName, SortOrder.DESC)
        //设置高亮field
        .addHighlightedField(highlightField)
        // 设置分页
        .setFrom(0).setSize(60).execute().actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards + "," + timeCost + "," + sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for (int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for (String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  }
  private static void sumOneField(String indexName, String typeName, String fieldName) {
    SumBuilder sb = AggregationBuilders.sum("sum").field(fieldName);
    //search result get source
    SearchResponse sResponse = client.prepareSearch(indexName).setTypes(typeName).addAggregation(sb).execute().actionGet();
    Map<String, Aggregation> aggMap = sResponse.getAggregations().asMap();
    if(aggMap != null && aggMap.size() > 0) {
      for(String key : aggMap.keySet()) {
        Sum s = (Sum)aggMap.get(key);
        System.out.println(s.getValue());
      }
    }
  }
  private static void searchWithTermQueryAndRetureSpecifiedFields(String indexName, String typeName, String termName,String termValue, String sortField, String highlightField,String... fields) {
     SearchRequestBuilder sb = client.prepareSearch(indexName)
        .setTypes(typeName)
        // 设置search type
        // 常用search type用：query_then_fetch
        // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        // 查询的termName和termvalue
        .setQuery(QueryBuilders.termQuery(termName, termValue))
        // 设置排序field
        .addSort(sortField, SortOrder.DESC)
        // 设置高亮field
        .addHighlightedField(highlightField)
        // 设置分页
        .setFrom(0).setSize(60);
    for (String field : fields) {
      sb.addField(field);
    }
    SearchResponse sResponse = sb.execute().actionGet();
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for (int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, SearchHitField> fm = hit.getFields();
      for (String key : fm.keySet()) {
        SearchHitField f = fm.get(key);
        System.out.println(f.getName());
        System.out.println(f.getValue());
      }
    }
  }
  private static void searchWithIds(String indexName, String typeName, String sortField, String highlightField, String... ids) {
    IdsQueryBuilder qb = QueryBuilders.idsQuery().addIds(ids);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        //设置search type
        //常用search type用：query_then_fetch
        //query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        //查询的termName和termvalue
        .setQuery(qb)
        //设置排序field
        .addSort(sortField, SortOrder.DESC)
        //设置高亮field
        .addHighlightedField(highlightField)
        //设置分页
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards+","+timeCost+","+sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for(int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for(String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  } 

  /**
   * 在index:indexName, type:typeName中做通配符查询
   * @param indexName
   * @param typeName
   * @param termName
   * @param termValue
   * @param sortField
   * @param highlightField
   */
  private static void wildcardSearch(String indexName, String typeName, String termName, String termValue, String sortField, String highlightField) {
    QueryBuilder qb = QueryBuilders.wildcardQuery(termName, termValue);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        //设置search type
        //常用search type用：query_then_fetch
        //query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        //查询的termName和termvalue
        .setQuery(qb)
        //设置排序field
//       .addSort(sortField, SortOrder.DESC)
        //设置高亮field
//       .addHighlightedField(highlightField)
        //设置分页
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards+","+timeCost+","+sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for(int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for(String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  } 

  /**
   * 在index:indexName, type:typeName中做模糊查询
   * @param indexName
   * @param typeName
   * @param termName
   * @param termValue
   * @param sortField
   * @param highlightField
   */
  private static void fuzzySearch(String indexName, String typeName, String termName, String termValue, String sortField, String highlightField) {
     QueryBuilder qb = QueryBuilders.fuzzyQuery(termName, termValue);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        //设置search type
        //常用search type用：query_then_fetch
        //query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        //查询的termName和termvalue
        .setQuery(qb)
        //设置排序field
        .addSort(sortField, SortOrder.DESC)
        //设置高亮field
        .addHighlightedField(highlightField)
        //设置分页
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards+","+timeCost+","+sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for(int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for(String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  }
  /**
   * 在index:indexName, type:typeName中做区间查询
   * @param indexName
   * @param typeName
   * @param termName
   * @param min
   * @param max
   * @param highlightField
   */
  private static void numericRangeSearch(String indexName, String typeName,
      String termName, double min, double max, String highlightField) {
    // 构建range query
    QueryBuilder qb = QueryBuilders.rangeQuery(termName).from(min).to(max);
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        // 设置search type
        // 常用search type用：query_then_fetch
        // query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        // 查询的termName和termvalue
        .setQuery(qb)
        // 设置排序field
        .addSort(termName, SortOrder.DESC)
        //设置高亮field
        .addHighlightedField(highlightField)
        // 设置分页
        .setFrom(0).setSize(60).execute().actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards + "," + timeCost + "," + sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for (int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for (String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  }
  /**
   * 在索引indexName, type为typeName中查找两个term：term1(termName1, termValue1)和term2(termName2, termValue2)
   * @param indexName
   * @param typeName
   * @param termName1
   * @param termValue1
   * @param termName2
   * @param termValue2
   * @param sortField
   * @param highlightField
   */
  private static void searchWithBooleanQuery(String indexName, String typeName, String termName1, String termValue1,
       String termName2, String termValue2, String sortField, String highlightField) {
    //构建boolean query
    BoolQueryBuilder bq = boolQuery().must(termQuery(termName1, termValue1)).must(termQuery(termName2, termValue2));
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        //设置search type
        //常用search type用：query_then_fetch
        //query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        //查询的termName和termvalue
        .setQuery(bq)
        //设置排序field
        .addSort(sortField, SortOrder.DESC)
        //设置高亮field
        .addHighlightedField(highlightField)
        //设置分页
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    System.out.println(tShards+","+timeCost+","+sShards);
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for(int i = 0; i < count; i++) {
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for(String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  }
  /**
   * 在索引indexName, type为typeName中查找term(termName, termValue)
   * @param indexName
   * @param typeName
   * @param termName
   * @param termValue
   * @param sortField
   * @param highlightField
   */
  private static void searchWithTermQuery(String indexName, String typeName, String termName, String termValue, String sortField, String highlightField) {
    SearchResponse sResponse = client.prepareSearch(indexName)
        .setTypes(typeName)
        //设置search type
        //常用search type用：query_then_fetch
        //query_then_fetch是先查到相关结构，然后聚合不同node上的结果后排序
        .setSearchType(SearchType.QUERY_THEN_FETCH)
        //查询的termName和termvalue
        .setQuery(QueryBuilders.termQuery(termName, termValue))
        //设置排序field
//       .addSort(sortField, SortOrder.DESC)
        //设置高亮field
//       .addHighlightedField(highlightField)
        //设置分页
        .setFrom(0).setSize(60)
        .execute()
        .actionGet();
    int tShards = sResponse.getTotalShards();
    long timeCost = sResponse.getTookInMillis();
    int sShards = sResponse.getSuccessfulShards();
    SearchHits hits = sResponse.getHits();
    long count = hits.getTotalHits();
    SearchHit[] hitArray = hits.getHits();
    for(int i = 0; i < count; i++) {
      System.out.println("==================================");
      SearchHit hit = hitArray[i];
      Map<String, Object> fields = hit.getSource();
      for(String key : fields.keySet()) {
        System.out.println(key);
        System.out.println(fields.get(key));
      }
    }
  }
  /**
   * 用java的map构建document
   */
  private static void indexWithMap(String indexName, String typeName) {
    Map<String, Object> json = new HashMap<String, Object>();
    //设置document的field
    json.put("user","kimchy2");
    json.put("postDate",new Date());
    json.put("price",6.4);
    json.put("message","Elasticsearch");
    json.put("tid","10002");
    json.put("endTime","2015-08-25 09:00:00");
    //指定索引名称，type名称和documentId(documentId可选，不设置则系统自动生成)创建document
    IndexResponse response = client.prepareIndex(indexName, typeName, "2").setSource(json).execute().actionGet();
    //response中返回索引名称，type名称，doc的Id和版本信息
    String index = response.getIndex();
    String type = response.getType();
    String id = response.getId();
    long version = response.getVersion();
    boolean created = response.isCreated();
    System.out.println(index+","+type+","+id+","+version+","+created);
  } 

  /**
   * 用java字符串创建document
   */
  private static void indexWithStr(String indexName, String typeName) {
    //手工构建json字符串
    //该document包含user, postData和message三个field
    String json = "{" + "\"user\":\"kimchy\"," + "\"postDate\":\"2013-01-30\"," + "\"price\":\"6.3\"," + "\"tid\":\"10001\"," + "}";
    //指定索引名称，type名称和documentId(documentId可选，不设置则系统自动生成)创建document
    IndexResponse response = client.prepareIndex(indexName, typeName, "1")
        .setSource(json)
        .execute()
        .actionGet();
    //response中返回索引名称，type名称，doc的Id和版本信息
    String index = response.getIndex();
    String type = response.getType();
    String id = response.getId();
    long version = response.getVersion();
    boolean created = response.isCreated();
    System.out.println(index+","+type+","+id+","+version+","+created);
  } 

  private static void deleteDocWithId(String indexName, String typeName, String docId) {
    DeleteResponse dResponse = client.prepareDelete(indexName, typeName, docId).execute().actionGet();
    String index = dResponse.getIndex();
    String type = dResponse.getType();
    String id = dResponse.getId();
    long version = dResponse.getVersion();
    System.out.println(index+","+type+","+id+","+version);
  } 

  /**
   * 创建索引
   * 注意：在生产环节中通知es集群的owner去创建index
   * @param client
   * @param indexName
   * @param documentType
   * @throws IOException
   */
  private static void createIndex(String indexName, String documentType) throws IOException {
    final IndicesExistsResponse iRes = client.admin().indices().prepareExists(indexName).execute().actionGet();
    if (iRes.isExists()) {
      client.admin().indices().prepareDelete(indexName).execute().actionGet();
    }
    client.admin().indices().prepareCreate(indexName).setSettings(Settings.settingsBuilder().put("number_of_shards", 1).put("number_of_replicas", "0")).execute().actionGet();
    XContentBuilder mapping = jsonBuilder()
        .startObject()
           .startObject(documentType)
//           .startObject("_routing").field("path","tid").field("required", "true").endObject()
           .startObject("_source").field("enabled", "true").endObject()
           .startObject("_all").field("enabled", "false").endObject()
             .startObject("properties")
               .startObject("user")
                 .field("store", true)
                 .field("type", "string")
                 .field("index", "not_analyzed")
                .endObject()
                .startObject("message")
                 .field("store", true)
                 .field("type","string")
                 .field("index", "analyzed")
                 .field("analyzer", "standard")
                .endObject()
                .startObject("price")
                 .field("store", true)
                 .field("type", "float")
                .endObject()
                .startObject("nv1")
                 .field("store", true)
                 .field("type", "integer")
                 .field("index", "no")
                 .field("null_value", 0)
                .endObject()
                .startObject("nv2")
                 .field("store", true)
                 .field("type", "integer")
                 .field("index", "not_analyzed")
                 .field("null_value", 10)
                .endObject()
                .startObject("tid")
                 .field("store", true)
                 .field("type", "string")
                 .field("index", "not_analyzed")
                .endObject()
                .startObject("endTime")
                 .field("type", "date")
                 .field("store", true)
                 .field("index", "not_analyzed")
                 .field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd'T'HH:mm:ss.SSSZ")
                .endObject()
                .startObject("date")
                 .field("type", "date")
                .endObject()
             .endObject()
           .endObject()
          .endObject();
    client.admin().indices()
        .preparePutMapping(indexName)
        .setType(documentType)
        .setSource(mapping)
        .execute().actionGet();
  }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

基于Lucene的Java搜索服务器Elasticsearch安装使用教程

一.安装Elasticsearch Elasticsearch下载地址:http://www.elasticsearch.org/download/ ·下载后直接解压,进入目录下的bin,在cmd下运行elasticsearch.bat 即可启动Elasticsearch ·用浏览器访问: http://localhost:9200/ ,如果出现类似如下结果则说明安装成功: { "name" : "Benedict Kine", "cluster_na
Elasticsearch.Net使用教程 MVC4图书管理系统（2）

本文实例为大家分享了MVC4图书管理系统的制作教程,供大家参考,具体内容如下首先项目结构图: Model层的相关代码如下: Book.cs代码如下: public class Book { [Key] [DatabaseGenerated(DatabaseGeneratedOption.Identity)] public Guid Id { get; set; } [MaxLength(500)] [Display(Name = "标题")] public string Title
详解spring-boot集成elasticsearch及其简单应用

介绍记录将elasticsearch集成到spring boot的过程,以及一些简单的应用和helper类使用. 接入方式使用spring-boot中的spring-data-elasticsearch,可以使用两种内置客户端接入 1.节点客户端(node client): 配置文件中设置为local:false,节点客户端以无数据节点(node-master或node-client)身份加入集群,换言之,它自己不存储任何数据,但是它知道数据在集群中的具体位置,并且能够直接转发请求到对应的节
SpringBoot整合ElasticSearch实践

本节我们基于一个发表文章的案例来说明SpringBoot如何elasticsearch集成.elasticsearch本身可以是一个独立的服务,也可以嵌入我们的web应用中,在本案例中,我们讲解如何将elasticsearch嵌入我们的应用中. 案例背景:每个文章(Article)都要属于一个教程(Tutorial),而且每个文章都要有一个作者(Author). 一.实体设计: Tutorial.java public class Tutorial implements Serializable
Elasticsearch.Net使用入门教程（1）

本文实例为大家分享了Elasticsearch.Net使用教程,供大家参考,具体内容如下首先去官网下载Elasticsearch 2.3.4安装包,解压后,在cmd命令行进入安装目录,再进入 bin目录,运行elasticsearch.bat命令. elasticsearch插件elasticsearch-head安装: bin目录下执行命令plugin -install mobz/elasticsearch-head 然后开始.net编程,构建控制台应用程序 Program.cs代码如下:
详解centos7虚拟机安装elasticsearch5.0.x-安装篇

centos7虚拟机安装elasticsearch5.0.x-安装篇请预先安装jdk详细步骤请参考:http://www.jb51.net/softjc/193398.html 创建新用户(非root用户) elasticsearch只能用非root启动,这里我创建了一个叫seven的用户 [root@localhost ~]# useradd seven [root@localhost ~]# passwd seven 下载elasticsearch [root@localhost ~]#
elasticsearch插件开发教程

检索引擎Elasticsearch支持插件模式.有些时候你可能须要安装一些插件.甚至自己开发插件,这里就提供一个開始ES插件开发演示样例,ES版本号为1.5.2. 一.插件类继承自org.elasticsearch.plugins.AbstractPlugin package org.elasticsearch.plugin.helloworld; import java.util.ArrayList; import java.util.Collection; import java.util.
centos下root运行Elasticsearch异常问题解决

在CentOS 6.5 上运行Elasticsearch 2.3,异常如下: Exception in thread "main" java.lang.RuntimeException: don't run elasticsearch as root. at org.elasticsearch.bootstrap.Bootstrap.initializeNatives(Bootstrap.java:93) at org.elasticsearch.bootstrap.Bootstra
安装ElasticSearch搜索工具并配置Python驱动的方法

ElasticSearch是一个基于Lucene的搜索服务器.它提供了一个分布式多用户能力的全文搜索引擎,基于RESTful web接口.Elasticsearch是用Java开发的,并作为Apache许可条款下的开放源码发布,是第二流行的企业搜索引擎.设计用于云计算中,能够达到实时搜索,稳定,可靠,快速,安装使用方便. 我们建立一个网站或应用程序,并要添加搜索功能,令我们受打击的是:搜索工作是很难的.我们希望我们的搜索解决方案要快,我们希望有一个零配置和一个完全免费的搜索模式,我们希望能够简单
spring 操作elasticsearch查询使用方法

最近学习了一下elasticsearch使用,网上的资料又很少,真是一个头两个大.好歹最后终于了解了.留个笔记做日后查询. package com.gooddeep.dev.elasticsearch.commons.dao; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.elasticsearch.action.ActionFuture; import org.elasti

详解spring中使用Elasticsearch的代码实现

相关推荐

随机推荐