`
dreamoftch
  • 浏览: 485821 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

elastic search java api入门

elasticsearchesjavaapi 
阅读更多

 

 

参考资料：https://www.elastic.co/guide/en/elasticsearch/client/java-api/2.4/index.html

注：es版本为2.4.0

 

1.下载安装：

下载地址：https://www.elastic.co/downloads/elasticsearch

下载之后解压，运行 bin/elasticsearch 即可

 

2.maven依赖：

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>2.4.0</version>
</dependency>
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.8</version>
</dependency>

 

3.具体的demo:

package com.tch.test.elasticsearch.test;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.sort.SortOrder;
import com.alibaba.fastjson.JSON;
public class ElasticSearchTest {
  public static final String INDEX = "test";
  public static final String TYPE = "organization";
  public static TransportClient buildClient() throws UnknownHostException {
    return TransportClient.builder().build()
        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("localhost"), 9300));
  }
  public static void closeClient(TransportClient client) {
    if(client != null) {
      client.close();
    }
  }
  /**
   * 创建mapping（类似数据库的表结构）
   *
   * @param client
   *            es client
   * @param index
   *            索引名字
   * @param type
   *            索引下type的名字
   * @throws Exception
   */
  public static void createOrgMapping(TransportClient client) throws Exception {
    IndicesExistsResponse res = client.admin().indices().prepareExists(INDEX).execute().actionGet();
    if (res.isExists()) {
      DeleteIndexRequestBuilder delIdx = client.admin().indices().prepareDelete(INDEX);
      delIdx.execute().actionGet();
    }
    CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(INDEX);
    final XContentBuilder organizationBuilder = XContentFactory.jsonBuilder()
        .startObject()
        .startObject(TYPE)
        .startObject("properties")
        .startObject("id")
        .field("type", "long")
        .endObject()
        .startObject("name")
        .field("type", "string")
        .endObject()
        .startObject("type")
        .field("type", "integer")
        .endObject()
        .startObject("industrialModeCodes")
        .field("type", "integer")
        .endObject()
        .startObject("updatedAt")
        .field("type", "date")
        .endObject()
        .endObject()
        .endObject()
        .endObject();
    createIndexRequestBuilder.addMapping(TYPE, organizationBuilder);
    // MAPPING DONE
    createIndexRequestBuilder.execute().actionGet();
  }
  /**
   * 往索引中添加数据
   *
   * @param client
   */
  public static void index(TransportClient client, ESOrganization organization) {
    IndexResponse response = client.prepareIndex(INDEX, TYPE, String.valueOf(organization.getId()))
        .setSource(JSON.toJSONString(organization)).get();
    System.out.println(response.getId());
  }
  public static void getById(TransportClient client, String id) {
    GetResponse response = client.prepareGet(INDEX, TYPE, id).get();
    System.out.println(response.getSourceAsString());
  }
  public static void deleteById(TransportClient client, String id) {
    DeleteResponse response = client.prepareDelete(INDEX, TYPE, id).get();
    System.out.println(response);
  }
  public static void update(TransportClient client, ESOrganization organization)
      throws InterruptedException, ExecutionException {
    UpdateRequest updateRequest = new UpdateRequest(INDEX, TYPE, String.valueOf(organization.getId()))
        .doc(JSON.toJSONString(organization));
    UpdateResponse response = client.update(updateRequest).get();
    System.out.println(response);
  }
  public static void multiGet(TransportClient client, String... ids) {
    MultiGetResponse multiGetItemResponses = client.prepareMultiGet().add(INDEX, TYPE, ids).get();
    for (MultiGetItemResponse itemResponse : multiGetItemResponses) {
      GetResponse response = itemResponse.getResponse();
      if (response.isExists()) {
        String json = response.getSourceAsString();
        System.out.println(json);
      }
    }
  }
  /**
   * 复杂一点的搜索
   * @param client
   * @param searchReq
   */
  public static void search(TransportClient client, OrgSearchReq searchReq) {
    BoolQueryBuilder orgQueryBuilder = QueryBuilders.boolQuery();
    if (searchReq.getKeyword() != null && searchReq.getKeyword().length > 0) {
      BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
      for (String keyword : searchReq.getKeyword()) {
        queryBuilder.should(QueryBuilders.matchQuery("name", keyword));
      }
      orgQueryBuilder.must(queryBuilder);
    }
    if (!CollectionUtils.isEmpty(searchReq.getTypes())) {
      BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
      for (Integer type : searchReq.getTypes()) {
        queryBuilder.should(QueryBuilders.matchQuery("type", type));
      }
      orgQueryBuilder.must(queryBuilder);
    }
    if (!CollectionUtils.isEmpty(searchReq.getIndustrialModeCodes())) {
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        for (Integer industrialMode : searchReq.getIndustrialModeCodes()) {
          queryBuilder.should(QueryBuilders.matchQuery("industrialModeCodes", industrialMode));
        }
        orgQueryBuilder.must(queryBuilder);
      }
    if (searchReq.getUpdatedAt() != null && searchReq.getUpdatedAt().length > 0) {
        if (searchReq.getUpdatedAt()[0] != null) {
          orgQueryBuilder.must(QueryBuilders.rangeQuery("updatedAt").from(searchReq.getUpdatedAt()[0]));
        }
        if (searchReq.getUpdatedAt().length == 2 && searchReq.getUpdatedAt()[1] != null) {
          orgQueryBuilder.must(QueryBuilders.rangeQuery("updatedAt").to(searchReq.getUpdatedAt()[1]));
        }
      }
    if (StringUtils.isEmpty(searchReq.getSortField())) {
      searchReq.setSortField("updatedAt");
    }
    System.out.println("orgQueryBuilder: " +orgQueryBuilder);
    SearchResponse searchResponse = client.prepareSearch(INDEX).setTypes(TYPE)
        .setQuery(orgQueryBuilder)
        .addSort(searchReq.getSortField(), getSortOrder(searchReq.getSortType()))
        .setFrom(searchReq.getOffset())
        .setSize(searchReq.getSize())
        .execute()
        .actionGet();
    List<ESOrganization> orgs = new ArrayList<>();
    for (SearchHit hit : searchResponse.getHits()) {
      ESOrganization org = JSON.parseObject(hit.getSourceAsString(), ESOrganization.class);
      orgs.add(org);
    }
    System.out.println(JSON.toJSONString(orgs, true));
  }
  private static SortOrder getSortOrder(String str) {
      if (StringUtils.isEmpty(str)) {
        return SortOrder.ASC;
      }
      for (SortOrder sortOrder : SortOrder.values()) {
        if (sortOrder.name().equalsIgnoreCase(str)) {
          return sortOrder;
        }
      }
      return SortOrder.ASC;
    }
  private static ESOrganization getUpdateOrg() {
    ESOrganization organization = new ESOrganization();
    organization.setId(1l);
    organization.setType(1111111111);
    return organization;
  }
  public static void addIndex(TransportClient client) {
    String[] orgNames = {
        "小米科技有限责任公司",
        "乐视网信息技术（北京）股份有限公司",
        "网易（杭州）网络有限公司",
        "阿里巴巴（中国）有限公司",
        "上海希格斯网络科技有限公司",
        "running man",
        "chicken run",
        "tom runs fast"
    };
    for (int i = 0; i< orgNames.length; i++) {
      ESOrganization organization = new ESOrganization();
      organization.setId(Long.valueOf(i+1));
      organization.setName(orgNames[i]);
      organization.setType(i * 1);
      organization.setIndustrialModeCodes(new Integer[]{1+i, 20+i, 30+i});
      organization.setUpdatedAt(new Date());
      index(client, organization);
    }
  }
   
  public static void main(String[] args) throws Exception {
    TransportClient client = null;
    try {
      client = buildClient();
      createOrgMapping(client);
      addIndex(client);
      update(client, getUpdateOrg());
      getById(client, "1");
      multiGet(client, "2", "3");
      deleteById(client, "8");
      //索引创建成功之后1秒钟左右，才会变得可用
      TimeUnit.SECONDS.sleep(1);
      search(client, getSearchReq());
    } finally {
      closeClient(client);
    }
     
     
     
  }
  private static OrgSearchReq getSearchReq() {
    OrgSearchReq req = new OrgSearchReq();
    req.setKeyword(new String[]{"阿里巴巴", "乐视"});
    req.setTypes(Arrays.asList(3));
    req.setIndustrialModeCodes(Arrays.asList(23,33));
    req.setUpdatedAt(new Date[]{null, new Date()});
    return req;
  }
}
package com.tch.test.elasticsearch.test;
import java.util.Date;
public class ESOrganization {
  private Long id;
  private String name;
  private Integer type;
  private Integer[] industrialModeCodes;
  private Date updatedAt;
  public Long getId() {
    return id;
  }
  public void setId(Long id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public Integer getType() {
    return type;
  }
  public void setType(Integer type) {
    this.type = type;
  }
  public Integer[] getIndustrialModeCodes() {
    return industrialModeCodes;
  }
  public void setIndustrialModeCodes(Integer[] industrialModeCodes) {
    this.industrialModeCodes = industrialModeCodes;
  }
  public Date getUpdatedAt() {
    return updatedAt;
  }
  public void setUpdatedAt(Date updatedAt) {
    this.updatedAt = updatedAt;
  }
}
package com.tch.test.elasticsearch.test;
import java.util.Date;
import java.util.List;
public class OrgSearchReq {
  private String[] keyword;
  private List<Integer> types;
  private List<Integer> industrialModeCodes;
  private Date[] updatedAt;
  private Integer page;
  private Integer size;
  private String sortField;
  private String sortType;
  private static final int FIRST_PAGE = 1;
  private static final int PAGE_SIZE = 10;
  public String[] getKeyword() {
    return keyword;
  }
  public void setKeyword(String[] keyword) {
    this.keyword = keyword;
  }
  public List<Integer> getTypes() {
    return types;
  }
  public void setTypes(List<Integer> types) {
    this.types = types;
  }
  public List<Integer> getIndustrialModeCodes() {
    return industrialModeCodes;
  }
  public void setIndustrialModeCodes(List<Integer> industrialModeCodes) {
    this.industrialModeCodes = industrialModeCodes;
  }
  public Date[] getUpdatedAt() {
    return updatedAt;
  }
  public void setUpdatedAt(Date[] updatedAt) {
    this.updatedAt = updatedAt;
  }
  public Integer getPage() {
    if (page == null || page < 0) {
      return FIRST_PAGE;
    }
    return page;
  }
  public void setPage(Integer page) {
    this.page = page;
  }
  public Integer getSize() {
    if (size == null || size < 0) {
      return PAGE_SIZE;
    }
    return size;
  }
  public void setSize(Integer size) {
    this.size = size;
  }
  public String getSortField() {
    return sortField;
  }
  public void setSortField(String sortField) {
    this.sortField = sortField;
  }
  public String getSortType() {
    return sortType;
  }
  public void setSortType(String sortType) {
    this.sortType = sortType;
  }
  public int getOffset() {
    return (getPage() - 1) * getSize();
  }
}

 

4.demo解释：

上面的demo中，ESOrganization.java为存到es中的数据结构，OrgSearchReq.java为搜索的条件包装类。

简单的CRUD就不说了，下面主要说一下搜索（search）的部分：

搜索中使用了

BoolQueryBuilder orgQueryBuilder = QueryBuilders.boolQuery();

在搜索条件复杂的情况下，我们只需要根据自己的需求使用 BoolQueryBuilder 的 must 和 should来添加 query 的条件，

这里的 must 类似 sql 中的 and， should 类似 sql 中的 or

例如上面的demo中：

BoolQueryBuilder orgQueryBuilder = QueryBuilders.boolQuery();
if (searchReq.getKeyword() != null && searchReq.getKeyword().length > 0) {
  BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
  for (String keyword : searchReq.getKeyword()) {
    queryBuilder.should(QueryBuilders.matchQuery("name", keyword));
  }
  orgQueryBuilder.must(queryBuilder);
}
if (!CollectionUtils.isEmpty(searchReq.getTypes())) {
  BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
  for (Integer type : searchReq.getTypes()) {
    queryBuilder.should(QueryBuilders.matchQuery("type", type));
  }
  orgQueryBuilder.must(queryBuilder);
}
if (!CollectionUtils.isEmpty(searchReq.getIndustrialModeCodes())) {
    BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
    for (Integer industrialMode : searchReq.getIndustrialModeCodes()) {
      queryBuilder.should(QueryBuilders.matchQuery("industrialModeCodes", industrialMode));
    }
    orgQueryBuilder.must(queryBuilder);
  }
if (searchReq.getUpdatedAt() != null && searchReq.getUpdatedAt().length > 0) {
    if (searchReq.getUpdatedAt()[0] != null) {
      orgQueryBuilder.must(QueryBuilders.rangeQuery("updatedAt").from(searchReq.getUpdatedAt()[0]));
    }
    if (searchReq.getUpdatedAt().length == 2 && searchReq.getUpdatedAt()[1] != null) {
      orgQueryBuilder.must(QueryBuilders.rangeQuery("updatedAt").to(searchReq.getUpdatedAt()[1]));
    }
  }
if (StringUtils.isEmpty(searchReq.getSortField())) {
  searchReq.setSortField("updatedAt");
}

 

对应到sql语句就是：

where (name = 'xxx1' or name = 'xxx2') and (type = xxx3 or type = xxx4) and (industrialModeCodes = xxx5 or industrialModeCodes = xxx6) and updatedAt > xxx7 and updatedAt < xxx8
.addSort(searchReq.getSortField(), getSortOrder(searchReq.getSortType()))
.setFrom(searchReq.getOffset())
.setSize(searchReq.getSize())

对应的就是sql中的排序和分页。

但有一点不同就是

QueryBuilders.matchQuery("name", keyword)

和sql中的 name=xxx还有一点不同，因为前者会做分词，例如name为'小米有限公司' 经过分词之后，我们使用matchQuery搜索的时候，keyword输入 '小米' 也能搜到这个记录。

如果要完全等同，那就要使用：

QueryBuilders.termQuery("name", "小米")

termQuery不会使用分词，而会使用精确匹配。

范围搜索则是使用rangeQuery:

QueryBuilders.rangeQuery("updatedAt").from(xxx)

 

5.查看索引的mapping:

http://localhost:9200/test/organization/_mapping?pretty

 

6.查看索引中的记录：

http://localhost:9200/test/organization/_search?pretty

 

7.es中index和type的区别

https://www.elastic.co/blog/index-vs-type

 

 8.

2.0之后，filter已经和query合并：

 

9.elastic如何trouble shooting:

 

 

 

分享到：
| elastic search index和type
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ElasticSearch JAVA开发手册

    本手册不仅详细描述了如何使用Java作为客户端访问ElasticSearch的代码和方法，同时也描述了在使用ElasticSearch遇到的坑和解决方案，是新手入门不可多得的教材，也是老手借鉴提高的材料。

    (狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战)

    (狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战),包含了小狂神讲的东西，特别适合新手学习，笔记保存下来可以多看看。好记性不如烂笔头哦~，ElasticSearch，简称es，es是一个...

    Elasticsearch7.8X 入门到精通

    001 - 开篇.mp4 002 - 技术选型.mp4 003 - 教学大纲.mp4 008 - 入门 - HTTP - 索引 - 创建.mp4 009 - 入门 - HTTP - 索引 - 查询 & 删除.mp4 010 - 入门 - HTTP - 文档 - 创建 （Put & ...025 - 入门 - JavaAPI - 文档

    ElasticSearch分布式全文检索入门视频教程

    Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。 我们建立一个网站或应用程序，并要...

    Elasticsearch 2.1.1 学习资料 java client demo 代码

    Elasticsearch 2.1.1服务端集群搭建.及java客户端demo代码实现。Elasticsearch权威指南（中文版,Elasticsearch java api 学习入门源码部署相关资料

    ElasticSearch入门.pdf

    Elaticsearch，简称为es， es是一个开源的高扩展的分布式...es也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

    elasticsearch-tutorial:使用测试用例的ElasticSearch Java API教程

    弹性搜索教程使用测试用例的ElasticSearch Java API教程。 本教程以使用junit测试用例针对不同功能的示例为例，说明了 Java api的用法。第1部分介绍ElasticSearch集群设置以及ES入门。 索引，文档类型，节点，分片/...

    Elasticsearch 技术解析与实战.zip

    6 1.3.2 JSON介绍 10 1.4 安装配置 12 1.4.1 安装Java 12 1.4.2 安装Elasticsearch 12 1.4.3 配置 13 1.4.4 运行 15 1.4.5 停止 17 1.4.6 作为服务 17 1.4.7 版本升级 19 1.5 对外接口 21 1.5.1 API约定 22 1.5 .2 ...

    word源码java-ElasticSearch-Simple-Share:组内关于ElasticSearch的简单使用说明内容分享

    Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。 Elasticsearch 不仅仅是 Lucene，

    SpringBoot2.x：Elasticsearch快速入门

    Elasticsearch是一个基于Lucene的搜索服务器，Elasticsearch也是使用Java编写的，它的内部使用Lucene做索引与搜索，但是它的目的是使用全文检索变得简单，通过隐藏Lucene的复杂性，取而代之的提供一套简单一致的...

    Lucene+ElasticSearch入门至项目实战（Java高级、架构师必备套餐）

    课程提供所有代码笔记素材...2、ElasticSearch下载安装(window以及linux下安装) 3、集群环境搭建 4、客户端Kibana安装与使用 5、集群管理插件head安装使用 6、java api 操作 ES 7、电商项目实战应用等等 .....

    java8集合源码-udemy_ElasticSearch:udemy_ElasticSearch

    讲座：Elasticsearch 完整指南 重要更新：由于版本 7 类型将被删除，默认类型应替换为_doc类型 第 1 部分 - 入门 第 2 课 - Elasticsearch 介绍 Elasticsearch 是一个分析和全文搜索引擎。 它在应用程序中启用搜索...

    ES-核心知识篇（上半季）课件-1.rar

    比如说本套课程中，既全面包括了从入门使用，到分布式文档系统操作，到搜索引擎操作，到索引管理，最后到Java API使用，这样完整的知识体系。同时还细致到包含很多独家的知识点，比如说Elasticsearch如何突破扩容...

    elasticsearch-7.2.1：elasticsearch 7.2.1源码阅读

    弹性搜索分布式RESTful搜索引擎 Elasticsearch是为云构建的分布式RESTful搜索引擎。 功能包括： 分布式且高度可用的搜索引擎。 每个索引均使用可配置数量的分片进行完全分片。 每个分片可以具有一个或多个副本。 对...

    eskotlin:用于Kotlin的Elasticsearch查询DSL

    该库旨在最大程度地减少Elasticsearch JSON查询DSL与编写kotlin应用程序时使用的API之间的差距。 它与现有的Java API集成在一起，仅提供了更好的语法来构建查询。 入门 Gradle repositories { mavenCentral() .. ...

    elasticshell:一个用于 elasticsearch 的 javascript shell

    elasticshell - 用于弹性搜索的外壳 ...elasticshell 版本与 elasticsearch 版本紧密耦合，因为它使用其 Java API 连接到它。 目前有三个活跃的开发分支：一个用于 0.19.x，一个用于 0.20.x，一个用于 0.90.x

    ELK入门到精通

    是一套开放REST和JAVA API等结构提供高效搜索功能，可扩展的分布式系统。它构建于Apache Lucene搜索引擎库之上。 Logstash是一个用来搜集、分析、过滤日志的工具。它支持几乎任何类型的日志，包括系统日志、错误...

    全文搜索引擎Solr与ElasticSearch入门至集群及项目实战(Solr+ES)

    本课程提供所有代码笔记...14、ElasticSearch下载安装(window以及linux下安装) 15、集群环境搭建 16、客户端Kibana安装与使用 17、集群管理插件head安装使用 18、java api 操作 ES 19、电商项目实战应用等等 ....

    Java进阶教程数据层全栈方案SpringData高级应用视频教程

    4.SpringData ElasticSearch入门案例 5.SpringData ElasticSearch实现CRUD操作 第九章 SpringData MongDB 1.SpringData MongDB简介 2.MongDB环境搭建 3.MongDB基础知识回顾 4.SpringData MongDB入门案例 5.Spring...

Magicbox
Global site tag (gtag.js) - Google Analytics