4.7 ElasticSearch

一、ElasticSearch介绍

1.1 引言

  1.  在海量数据中执行搜索功能时，如果使用MySQL，效率太低。
  2. 如果关键字输入的不准确，一样可以搜索到想要的数据。
  3. 将搜索关键字，以红色的字体展示。

当在京东搜索手机壳的时候，可以搜索到千万级，上亿级的数量。如果用MySQL搜索，则SQL语句是select * from product where name like '%手机壳%'；但是我们知道当通配符开始就是'%'的时候，索引就会失效，此时效率之低，难以想象；此外，当我们在京东搜索'壳手机'的时候一样可以出现搜索结果，显然此时就不是MySQL能够完成的了；最后我们发现搜索之后，手机壳这三个字是用红色标注的，你可能觉得简单，只需要在每个字前面加上<form>标签即可，但是当数据量极大的时候，如何高效地操作，就是一个问题。

 

 

1.2 ES的介绍

ES是一个使用Java语言并且基于Lucene编写的搜索引擎框架，他提供了分布式的全文搜索功能，提供了一个统一的基于RESTful风格的WEB接口，官方客户端也对多种语言都提供了相应的API。

Lucene：Lucene本身就是一个搜索引擎的底层，是Apach的项目，其实就是Jar包，提供了一些搜索的API。但是呢？由于其过于底层，因此用起来比较麻烦。ElasticSearch在Lucene基础上进行封装。其实Apach本身也不建议直接使用ElasticSearch，他自己也封装了一个新的项目是Solr，因此会经常见到Solr和ElasticSearch的对比。

分布式：ES主要是为了突出他的横向扩展能力。

全文搜索：将一段词语进行分词，并且将分出的单个词语统一的放到一个分词库中，在索引时，根据关键字去分词库中检索，找到匹配的内容。(倒排索引)

RESTful风格的WEB接口：操作ES很简单，只需要发送一个HTTP请求，并且根据请求方式的不同，携带参数的不同，执行相应的功能。

应用广泛：Github.com，WIKI，Gold Man用ES每天维护将近10TB的数据。

1.3 ES的由来

 

 

1.4 ES和Slor

  1. Solr在查询死数据时，速度相对ES更快一些。但是数据如果是实时改变的，Solr的查询速度会降低很多，ES的查询的效率基本没有变化。
  2. Solr和SlasticSearch都是单节点的，如果Solr搭建集群需要依赖Zookeeper来帮助管理。ES本身就支持集群的搭建，不需要第三方的介入。
  3. 最开始Solr的社区可以说是非常火爆，针对国内的文档并不是很多。在ES出现之后，ES的社区火爆程度直线上升，ES的文档非常健全。
  4. ES对现在云计算和大数据支持的特别好。

1.5 倒排索引

将存放的数据，以一定的方式进行分词，并且将分词的内容存放到一个单独的分词库中。

当用户去查询数据时，会将用户的查询关键字进行分词。

然后去分词库中匹配内容，最终得到数据的id标识。

根据id标识去存放数据的位置拉取到指定的数据。

 

 

二、ElasticSearch安装

2.1 安装ES&Kibana

Kibana是ES的客户端，对于ES和Kibana，我们只需要用docker的compose容器去维护即可。

version: '2'
services:
  elasticsearch:
    container_name: elasticsearch
    image: daocloud.io/library/elasticsearch:6.5.4
    ports:
      - "9200:9200"
    environment:
      - "ES_JAVA_OPTS=-Xms64m -Xmx128m"
      - "discovery.type=single-node"
      - "COMPOSE_PROJECT_NAME=elasticsearch-server"
    restart: always

  kibana:
    container_name: kibana
    image: daocloud.io/library/kibana:6.5.4
    ports:
      - "5601:5601"
    restart: always
    environment:
      - ELASTICSEARCH_HOSTS=http://1.15.122.141:9200

 

对于上面的docker-compose.yml文件，由于Kibana需要依赖es，因此有了environment的配置。

上面这个yml不是老师的，老师那么启动后，无法连接es和kibana，因此换用了这个。安装步骤是：在/opt/目录下mkdir docker_elasticsearch；vi docker-compose.yml，并复制上面内容；docker-compose up -d启动。

启动后：浏览器输入http://1.15.122.141:9200/访问ES，要在ES可以访问的情况下访问Kibana，对于Kibana，我们只需要关注两个内容即可。

 

 

2.2 安装IK分词器

其实ES是有默认的分词器的，但是呢？其对汉语支持的不好。他会一个字一个字的分开，因此这里我们安装一个IK分词器。是国内的，对汉语分词效果好。

安装步骤：进入jithub；搜索ik，点击第一个进去；选择releases版本，最终选择6.5.4，和上面保持一致；右键复制链接：https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.5.4/elasticsearch-analysis-ik-6.5.4.zip

 

我们这里并不直接下载安装，而是在ES容器内部安装。步骤为：docker ps查看es的container id；docker exec -it ID bash进入容器内部，ls看一下列表，进入bin目录；看到elasticsearch-plugin（其实对ES而言，分词器就是一个插件）；输入命令：./elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.5.4/elasticsearch-analysis-ik-6.5.4.zip；输入y确认。

 

 

 下面我们就可以测试一波这个IK分词器了。其实在gitbuh的该项目下方也可以看到用法

 

 

 但是发现此时运行报错，说没有找到这个分词器。刚刚命名安装了呀！！！这是因为我们还需要重启一下es，因为IK分词器还没有生效。(这里不需要重启kibana，因为我们没有修改他；此外由于IK分词器是暗黄在容器的内部，因为我们以后尽量不要down这个容器，需要的话就restart重启)。重启之后再次测试，可以看到上图的结果。

 

 

 三、ElasticSearch基本操作

3.1 ES的结构

3.1.1 索引Index，分片和备份

ES的服务中，可以创建多个索引。每一个索引默认被分成5片存储。每一个分片都会存在至少一个备份分片。备份分片默认不会帮助苏检索数据，当ES检索压力特别大的时候，备份分片才会帮助检索数据。备份分片必须放在不同的服务器中。

 

3.1.2 类型Type

 一个索引下，可以创建多个类型。

Ps：根据版本不同，类型的创建也不同。

 

3.1.3 文档Doc

一个类型下，可以有多个文档，这个文档就类似于MySQL表中的多行数据。

 

3.1.4 属性Field

一个文档中，可以包含多个属性。类似于MySQL表中的一行数据存在多个列。

 

3.2 操作ES的RESTful语法

GET请求：

http://ip:port/index：查询索引信息

http://ip:port/index/type/doc_id：查询指定的文档信息

POST请求：

http://ip:port/index/type/_search：查询文档，可以在请求体中添加json字符串来标识查询条件

http://ip:port/index/type/doc_id/_update：修改文档，在请求体中指定json字符串代表修改的具体信息

PUT请求：

http://ip:port/index：创建一个索引，需要在请求体中指定索引的信息，类型，结构

http://ip:port/index/type/_mapping：代表创建索引时，指定索引文档存储的属性的信息

DELETE请求：

http://ip:port/index：删除跑路

http://ip:port/index/type/doc_id：删除指定的文档

4.3 索引的操作

4.3.1 创建一个索引

语法如下：

# 创建一个索引
PUT /person
{
  "settings": {
    "number_of_shards": 5
    "number_of_replicas": 1
  }
}

 

4.3.2 查看索引信息

一种是用Kibana查看

 

 另一种是用命令查看：

# 查看索引信息
GET /person

 

 

4.3.3 删除索引

一种是在Management页面中勾选并删除索引。截图略

另一种是通过命令的方式

# 删除索引
DELETE /person

 

3.4 ES中Field可以指定的类型

字符串类型：

  • text：一般被用于全文检索。将当前Field进行分词。
  • keyword：当前Field不会被分词。

数值类型：

  • long：
  • integer：
  • short：
  • byte：
  • double：
  • float：
  • half_float：精度比float小一半(16位精度)
  • scaled_float：根据一个long和scaled来表达一个浮点型，long-345，scaled-100 -> 3.45

时间类型：

  • data类型，针对时间类型指定具体的格式

布尔类型：

  • boolean类型，表达true和false

二进制类型：

  • binary类型暂时支持Base64 encode string

范围类型：

  • long_range：赋值时，无需指定具体的内容，只需要存储一个范围即可，指定gt，it，gte，lte
  • integer_range：同上
  • doucle_range：同上
  • float_range：同上
  • date_range：同上
  • ip_range：同上

经纬度类型：

  • geo_point：用来存储经纬度的

ip类型：

  • ip：可以存储IPV4和IPV6

其它的数据类型参考官网：https://www.elastic.co/guide/en/elasticsearch/reference/6.5/mapping.html#mapping-type

3.5 创建索引并指定数据结构

如法如下：

# 创建索引，指定数据结构
PUT /book
{
  "settings": {
　　 # 分片数
    "number_of_shards": 5,
　　 # 备份数
    "number_of_replicas": 1
  },
　 # 指定数据结构
  "mappings": {
　　 # 类型 Type
    "novel": {
　　　 # 文档存储的Field
      "properties": {
　　　　　# Field属性名
        "name": {
　　　　　　# 类型
          "type": "text",
　　　　　　# 指定分词器
          "analyzer": "ik_max_word",
　　　　　　# 指定当前Field可以被作为查询的条件
          "index": true,
　　　　　　# 是否需要额外存储
          "store": false
        },
        "author": {
          "type": "keyword"
        },
        "count": {
          "type": "long"
        },
        "on-sale": {
          "type": "date",
　　　　　　# 时间类型的格式化方式
          "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
        },
        "descr": {
          "type": "text",
          "analyzer": "ik_max_word"
        }
      }
    }
  }
}

 

上面索引已经创建好了，下面就是往里面添加内容了。

3.6 文档的操作

文档1ES服务中的唯一标识，_index，_type，_id三个内容为组合，锁定一个文档，操作是添加还是修改。

3.6.1 新建文档

自动生成_id

# 添加文档，自动生成id
POST /book/novel
{
  "name": "盘龙",
  "author": "我爱吃西红柿",
  "count": "1000000",
  "on-sale": "2000-01-01",
  "descr": "吸消息或或或和二二的1ddddddd的尺寸大大大毒贩夫妇过过过过"
}

 

 

 这种id是自动生成的，不容易记忆，不太推荐这种新建文档的方式。

手动指定_id  -- 还可以用于修改

# 添加文档，手动指定id
PUT /book/novel/1
{
  "name": "红楼梦",
  "author": "曹雪芹",
  "count": "100000000",
  "on-sale": "1985-01-01",
  "descr": "一个是阆苑仙葩，一个是美玉无瑕"
}

 

 

3.6.2 修改文档

覆盖式修改  -- 其实这个命令和添加文档，手动指定id一模一样了。

# 覆盖式修改文档 -- 根据id
# 此时的代码和 -- 添加文档，手动指定id  -- 一模一样
PUT /book/novel/1
{
  "name": "红楼梦",
  "author": "曹雪芹",
  "count": "223345",
  "on-sale": "1985-01-01",
  "descr": "一个是阆苑仙葩，一个是美玉无瑕"
}

doc修改方式  -- 更加推荐 

# 修改文档，基于doc方式
POST /book/novel/1/_update
{
  "doc": {
　　 # 指定上需要修改的field和对应的值
    "count": "1234565"
  }
}

3.6.3 删除文档

根据id删除

# 根据id删除文档
DELETE /book/novel/HBWGvncBq4wxPcelbe3V

上面是增  --  改  --  删。至于查，后面讲。

四、Java操作ElasticSearch

4.1 Java连接ES

创建Maven工程

导入依赖：需要4个依赖，其实是两个。1.elasticsearch，这个不用说；elasticsearch的高级API，这个是es推荐的，用这个API更容易操作；junit，方便测试；lombok。

<dependencies>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.5.4</version>
    </dependency>

    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>6.5.4</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
    </dependency>
</dependencies>

创建测试类，连接es

package com.qf.utils;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;

public class ESClient
{
    public static RestHighLevelClient getClient() {
        // 创建HttpHost对象
        HttpHost httpHost = new HttpHost("1.15.122.141", 9200);

        // 创建RestClientBuilder
        RestClientBuilder clientBuilder = RestClient.builder(httpHost);

        // 创建RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(clientBuilder);

        // 返回
        return client;
    }
}

 

然后用一个测试类去看一下RestHighLevelClient客户端，如果不报错，则说明上面的代码没有问题。

package com.qf.test;

import com.qf.utils.ESClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.Test;

public class Demo1
{
    @Test
    public void testConnect() {
        RestHighLevelClient client = ESClient.getClient();
        System.out.println("OK!!");
    }
}

4.2 Java操作索引

4.2.1 创建索引

创建索引的方式有很多，但是记着一个就足够了，因为其更常见一些。

package com.qf.test;

import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.settings.Settings.Builder;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.jupiter.api.Test;

public class Demo2
{
    RestHighLevelClient client = ESClient.getClient();
    String index = "person";
    String type = "man";

    @Test
    public void createIndex() throws IOException
    {
        // 1. 准备关于索引的settings
        Builder settings = Settings.builder()
                              .put("number_of_shards", 3)
                              .put("number_of_replicas", 1);

        // 2. 准备关于索引的结构mappings
        XContentBuilder mappings = JsonXContent.contentBuilder()
                                                      .startObject()
                                                      .startObject("properties")
                                                      .startObject("name")
                                                      .field("type", "text")
                                                      .endObject()
                                                      .startObject("age")
                                                      .field("type", "integer")
                                                      .endObject()
                                                      .startObject("birthday")
                                                      .field("type", "date")
                                                      .field("format", "yyyy-MM-dd")
                                                      .endObject()
                                                      .endObject()
                                                      .endObject();

        // 3. 将settings和mappings封装到一个Request对象
        CreateIndexRequest request = new CreateIndexRequest(index)
            .settings(settings)
            .mapping(type, mappings);

        // 4. 通过client对象去连接ES并执行创建索引
        CreateIndexResponse resp = client.indices().create(request, RequestOptions.DEFAULT);

        // 5. 输出
        System.out.println("resp:" + resp.toString());
    }
}

4.2.2 删除索引

@Test
public void delete() throws IOException
{
    // 1. 准备request对象
    DeleteIndexRequest request = new DeleteIndexRequest();
    request.indices(index);

    // 2. 通过client对象执行
    AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
    // 3. 获取返回结果
    System.out.println(delete.isAcknowledged());
}

 4.2.3 检查索引是否存在

@Test
public void exists() throws IOException
{
    // 1. 准备request对象
    GetIndexRequest request = new GetIndexRequest();
    request.indices(index);

    // 2. 通过client去操作
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

    // 3. 输出
    System.out.println(exists);
}

4.3 Java操作文档

4.3.1 添加文档操作

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import com.qf.utils.com.qf.entity.Person;
import java.io.IOException;
import java.util.Date;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;

public class Demo3
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "person";
    String type = "man";

    @Test
    public void createDoc() throws IOException
    {
        // 1. 准备一个json数据
        Person person = new Person(1, "张三", 23, new Date());
        String json = mapper.writeValueAsString(person);

        // 2. 准备一个request对象(手动指定id)
        IndexRequest request = new IndexRequest(index, type, person.getId().toString());
        request.source(json, XContentType.JSON);

        // 3. 通过client对象执行添加
        IndexResponse resp = client.index(request, RequestOptions.DEFAULT);

        // 4. 输出返回结果
        System.out.println(resp.getResult().toString());
    }
}

 这里的Person类的变化：

package com.qf.utils.com.qf.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person
{
    @JsonIgnore
    private Integer id;

    private String name;

    private Integer age;

    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
}

 

首先这里的id是要忽略的，也就是转换成json字符串时，要忽略这个id属性；其次，这里的birthday在转化成json格式的字符串时，是要YY-MM--DD的形式，因为我们上面创建索引的时候就是这个样式，否则会报错。由于这里用的是jackson，因此要导入这个依赖。

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.3</version>
</dependency>

 

添加文档后，可以在Kibana中查看。查看步骤是：Management  --  Index Patterns  --  create index pattern  --  在index pattern下面加person，*删除，点击Next step  -- 然后时间筛选条件选择字后一个，即不用时间筛选  -- 最后在Discover中选择查看。

4.3.2 修改文档

这里的修改方式，我们直接用Doc方式，不再用覆盖式方式进行修改。

@Test
    public void updateDoc() throws IOException
    {
        // 1. 创建一个Map，指定需要修改的内容
        Map<String, Object> doc = new HashMap<>();
        doc.put("name", "张大三");
        String docId = "1";

        // 2. 创建request对象，封装数据  --  这里需要封装的数据就包括  index type id 和 Map
        UpdateRequest request = new UpdateRequest(index, type, docId);
        request.doc(doc);

        // 3. 通过Client对象执行
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);

        // 4. 输出返回结果
        System.out.println(update.getResult().toString());
    }

4.3.3 删除文档

@Test
public void deleteDoc() throws IOException
{
    // 1. 封装Request对象
    DeleteRequest request = new DeleteRequest(index, type, "1");

    // 2. client执行
    DeleteResponse resp = client.delete(request, RequestOptions.DEFAULT);

    // 3. 输出结果
    System.out.println(resp.getResult().toString());
}

4.4 Java批量操作文档

由于一条套操作太过麻烦，因为我们进行批量操作。这里学习批量添加和删除。

4.4.1 批量添加

@Test
public void bulkCreateDoc() throws IOException
{
    // 1. 准备多个json数据
    Person p1 = new Person(1, "张三", 23, new Date());
    Person p2 = new Person(2, "李四", 24, new Date());
    Person p3 = new Person(3, "王五", 25, new Date());

    String json1 = mapper.writeValueAsString(p1);
    String json2 = mapper.writeValueAsString(p2);
    String json3 = mapper.writeValueAsString(p3);

    // 2. 创建Request，将准备好的数据封装进去
    BulkRequest request = new BulkRequest();
    request.add(new IndexRequest(index, type, p1.getId().toString()).source(json1, XContentType.JSON));
    request.add(new IndexRequest(index, type, p2.getId().toString()).source(json2, XContentType.JSON));
    request.add(new IndexRequest(index, type, p3.getId().toString()).source(json3, XContentType.JSON));
    
    // 3. 用client执行
    BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);
    
    // 4. 输出结果
    System.out.println(resp.toString());
}

 

4.4.2 批量删除

@Test
public void bulkDeleteDoc() throws IOException
{
    // 1. 封装Request对象
    BulkRequest request = new BulkRequest();
    request.add(new DeleteRequest(index, type, "1"));
    request.add(new DeleteRequest(index, type, "2"));
    request.add(new DeleteRequest(index, type, "3"));
    
    // 2. client执行
    BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);
    
    // 3. 输出
    System.out.println(resp);
}

 

下面呢？我们开始进行一些练习，咱们会创建一个相对而言比较复杂的一些索引以及他的数据结构，并且会应对与咱们后面的查询操作。

五、ElasticSearch练习

这个练习一方面是为了复习上面的知识，另一方面是为了后面的查询操作(数据准备)。

索引：sms-logs-index；类型：sms-logs-type

 

 实体类

package com.qf.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;



@Data
@NoArgsConstructor
@AllArgsConstructor
public class SmsLogs {

    private String id;// 唯一ID 1

    private Date createDate;// 创建时间

    private Date sendDate; // 发送时间

    private String longCode;// 发送的长号码

    private String mobile;// 下发手机号

    private String corpName;// 发送公司名称

    private String smsContent; // 下发短信内容

    private Integer state; // 短信下发状态 0 成功 1 失败

    private Integer operatorId; // '运营商编号 1 移动 2 联通 3 电信

    private String province;// 省份

    private String ipAddr; //下发服务器IP地址

    private Integer replyTotal; //短信状态报告返回时长（秒）

    private Integer fee;  // 费用

}

 

索引的创建和数据的添加

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.entity.SmsLogs;
import com.qf.utils.ESClient;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.Test;

import java.io.IOException;
import java.util.Date;

public class TestData {
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";
    
    @Test
    public void createSmsLogsIndex() throws IOException {

        //1. settings
        Settings.Builder settings = Settings.builder()
                .put("number_of_shards", 3)
                .put("number_of_replicas", 1);

        //2. mapping.
        XContentBuilder mapping = JsonXContent.contentBuilder()
                .startObject()
                    .startObject("properties")
                        .startObject("createDate")
                            .field("type", "date")
                        .endObject()
                        .startObject("sendDate")
                            .field("type", "date")
                        .endObject()
                        .startObject("longCode")
                            .field("type", "keyword")
                        .endObject()
                        .startObject("mobile")
                            .field("type", "keyword")
                        .endObject()
                        .startObject("corpName")
                            .field("type", "keyword")
                        .endObject()
                        .startObject("smsContent")
                            .field("type", "text")
                            .field("analyzer", "ik_max_word")
                        .endObject()
                        .startObject("state")
                            .field("type", "integer")
                        .endObject()
                        .startObject("operatorId")
                            .field("type", "integer")
                        .endObject()
                        .startObject("province")
                            .field("type", "keyword")
                        .endObject()
                        .startObject("ipAddr")
                            .field("type", "ip")
                        .endObject()
                        .startObject("replyTotal")
                            .field("type", "integer")
                        .endObject()
                        .startObject("fee")
                            .field("type", "long")
                        .endObject()
                    .endObject()
                .endObject();

        //3. 添加索引.
        CreateIndexRequest request = new CreateIndexRequest(index);
        request.settings(settings);
        request.mapping(type,mapping);
        client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("OK!!");
    }
    
    @Test
    public void addTestData() throws IOException {
        BulkRequest request = new BulkRequest();

        SmsLogs smsLogs = new SmsLogs();
        smsLogs.setMobile("13800000000");
        smsLogs.setCorpName("途虎养车");
        smsLogs.setCreateDate(new Date());
        smsLogs.setSendDate(new Date());
        smsLogs.setIpAddr("10.126.2.9");
        smsLogs.setLongCode("10690000988");
        smsLogs.setReplyTotal(10);
        smsLogs.setState(0);
        smsLogs.setSmsContent("【途虎养车】亲爱的张三先生/女士，您在途虎购买的货品(单号TH123456)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        smsLogs.setProvince("北京");
        smsLogs.setOperatorId(1);
        smsLogs.setFee(3);
        request.add(new IndexRequest(index, type, "21").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));

        smsLogs.setMobile("13700000001");
        smsLogs.setProvince("上海");
        smsLogs.setSmsContent("【途虎养车】亲爱的刘红先生/女士，您在途虎购买的货品(单号TH1234526)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        request.add(new IndexRequest(index, type, "22").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));


        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs1 = new SmsLogs();
        smsLogs1.setMobile("13100000000");
        smsLogs1.setCorpName("盒马鲜生");
        smsLogs1.setCreateDate(new Date());
        smsLogs1.setSendDate(new Date());
        smsLogs1.setIpAddr("10.126.2.9");
        smsLogs1.setLongCode("10660000988");
        smsLogs1.setReplyTotal(15);
        smsLogs1.setState(0);
        smsLogs1.setSmsContent("【盒马】您尾号12345678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "刘三，电话：13800000000");
        smsLogs1.setProvince("北京");
        smsLogs1.setOperatorId(2);
        smsLogs1.setFee(5);
        request.add(new IndexRequest(index, type, "23").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));

        smsLogs1.setMobile("18600000001");
        smsLogs1.setProvince("上海");
        smsLogs1.setSmsContent("【盒马】您尾号7775678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "王五，电话：13800000001");
        request.add(new IndexRequest(index, type, "24").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs2 = new SmsLogs();
        smsLogs2.setMobile("15300000000");
        smsLogs2.setCorpName("滴滴打车");
        smsLogs2.setCreateDate(new Date());
        smsLogs2.setSendDate(new Date());
        smsLogs2.setIpAddr("10.126.2.8");
        smsLogs2.setLongCode("10660000988");
        smsLogs2.setReplyTotal(50);
        smsLogs2.setState(1);
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        smsLogs2.setProvince("上海");
        smsLogs2.setOperatorId(3);
        smsLogs2.setFee(7);
        request.add(new IndexRequest(index, type, "25").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));

        smsLogs2.setMobile("18000000001");
        smsLogs2.setProvince("武汉");
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        request.add(new IndexRequest(index, type, "26").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));


        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs3 = new SmsLogs();
        smsLogs3.setMobile("13900000000");
        smsLogs3.setCorpName("招商银行");
        smsLogs3.setCreateDate(new Date());
        smsLogs3.setSendDate(new Date());
        smsLogs3.setIpAddr("10.126.2.8");
        smsLogs3.setLongCode("10690000988");
        smsLogs3.setReplyTotal(50);
        smsLogs3.setState(0);
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        smsLogs3.setProvince("上海");
        smsLogs3.setOperatorId(1);
        smsLogs3.setFee(8);
        request.add(new IndexRequest(index, type, "27").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));

        smsLogs3.setMobile("13990000001");
        smsLogs3.setProvince("武汉");
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        request.add(new IndexRequest(index, type, "28").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs4 = new SmsLogs();
        smsLogs4.setMobile("13700000000");
        smsLogs4.setCorpName("中国平安保险有限公司");
        smsLogs4.setCreateDate(new Date());
        smsLogs4.setSendDate(new Date());
        smsLogs4.setIpAddr("10.126.2.8");
        smsLogs4.setLongCode("10690000998");
        smsLogs4.setReplyTotal(18);
        smsLogs4.setState(0);
        smsLogs4.setSmsContent("【中国平安】奋斗的时代，更需要健康的身体。中国平安为您提供多重健康保 障，在奋斗之路上为您保驾护航。退订请回复TD");
        smsLogs4.setProvince("武汉");
        smsLogs4.setOperatorId(1);
        smsLogs4.setFee(5);
        request.add(new IndexRequest(index, type, "29").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));

        smsLogs4.setMobile("13990000002");
        smsLogs4.setProvince("武汉");
        smsLogs4.setSmsContent("【招商银行】尊贵的王五先生,恭喜您获得iphone 56抽奖资格,还可领5 元打" + "车红包,仅限100天");
        request.add(new IndexRequest(index, type, "30").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------


        SmsLogs smsLogs5 = new SmsLogs();
        smsLogs5.setMobile("13600000000");
        smsLogs5.setCorpName("中国移动");
        smsLogs5.setCreateDate(new Date());
        smsLogs5.setSendDate(new Date());
        smsLogs5.setIpAddr("10.126.2.8");
        smsLogs5.setLongCode("10650000998");
        smsLogs5.setReplyTotal(60);
        smsLogs5.setState(0);
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****0000，5月话费账单已送达您的139邮箱，" + "点击查看账单详情 http://y.10086.cn/; " + " 回Q关闭通知，关注“中国移动139邮箱”微信随时查账单【中国移动 139邮箱】");
        smsLogs5.setProvince("武汉");
        smsLogs5.setOperatorId(1);
        smsLogs5.setFee(4);
        request.add(new IndexRequest(index, type, "31").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));

        smsLogs5.setMobile("13990001234");
        smsLogs5.setProvince("山西");
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****1234，8月话费账单已送达您的126邮箱，\" + \"点击查看账单详情 http://y.10086.cn/; \" + \" 回Q关闭通知，关注“中国移动126邮箱”微信随时查账单【中国移动 126邮箱】");
        request.add(new IndexRequest(index, type, "32").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------

        client.bulk(request,RequestOptions.DEFAULT);

        System.out.println("OK!");
    }




}

 

六、ElasticSearch的各种查询

下面就是ES的重头戏，查询，而ES查询的量是非常大的，咱们慢慢来。

6.1 term&terms查询

6.1.1 term查询

咱们知道ES有一个全文搜素，稍微有点类似MySQL的模糊查询。term查询不是全文搜素，term的查询是代表完全匹配，搜索之前不会对你搜索的关键字进行分词，对你的关键字去文档分词库中匹配内容。(这里在创建索引时，Province这个字段设置的就是keyWord，本来这个省份就不需要分词。比如"河南"，不需要分成"河"、"南"、"河南"进行完全匹配。因此这里用这个字段进行Term完全匹配练习)

# term查询
POST /sms-logs-index/sms-logs-type/_search
{
  "from": 0,  # limit ?
  "size": 5,  # limit x, ?
  "query": {
    "term": {
      "province": {
        "value": "北京"
      }
    }
  }
}

 

在Kibana中用命令查看后的结果如下：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 1.3862944,
    "hits" : [
      {
        "_index" : "sms-logs-index",
        "_type" : "sms-logs-type",
        "_id" : "23",
        "_score" : 1.3862944,
        "_source" : {
          "id" : null,
          "createDate" : 1613964404865,
          "sendDate" : 1613964404865,
          "longCode" : "10660000988",
          "mobile" : "13100000000",
          "corpName" : "盒马鲜生",
          "smsContent" : "【盒马】您尾号12345678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：刘三，电话：13800000000",
          "state" : 0,
          "operatorId" : 2,
          "province" : "北京",
          "ipAddr" : "10.126.2.9",
          "replyTotal" : 15,
          "fee" : 5
        }
      },
      {
        "_index" : "sms-logs-index",
        "_type" : "sms-logs-type",
        "_id" : "21",
        "_score" : 1.2039728,
        "_source" : {
          "id" : null,
          "createDate" : 1613964404801,
          "sendDate" : 1613964404801,
          "longCode" : "10690000988",
          "mobile" : "13800000000",
          "corpName" : "途虎养车",
          "smsContent" : "【途虎养车】亲爱的张三先生/女士，您在途虎购买的货品(单号TH123456)已 到指定安装店多日，现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。",
          "state" : 0,
          "operatorId" : 1,
          "province" : "北京",
          "ipAddr" : "10.126.2.9",
          "replyTotal" : 10,
          "fee" : 3
        }
      }
    ]
  }
}

 

用Java命令进行操作term查询

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import java.util.Map;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo4
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void termQuery() throws IOException
    {
        // 1. 创建Request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.from(0);
        builder.size(5);
        builder.query(QueryBuilders.termQuery("province", "北京"));

        request.source(builder);

        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 获取到_source中的数据，并展示
        for (SearchHit hit : resp.getHits().getHits())
        {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }

    }
}

 

再次说明：用term查询，不会对词进行分词，而是直接去分词库匹配内容。

6.1.2 terms查询

terms和term的查询机制是一样的，都不会将指定的查询关键字进行分词，直接去分词库中匹配，找到相应文档内容。terms是在针对一个字段包含多个值的时候使用。那有什么区别呢？

term：where province = 北京       terms：where province = 北京 or province = ？ or province = ？，这个就像MySQL中的in一样。

# terms查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "terms": {
      "province": [
        "北京",
        "山西",
        "武汉"
      ]
    }
  }
}

 

查询结果略。Java实现如下：

@Test
public void termsQuery() throws IOException
{
    // 1. 创建request
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 封装查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    builder.query(QueryBuilders.termsQuery("province", "北京", "山西"));

    request.source(builder);

    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出_source
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

外卖这里需要说明一下：对于上面的term和terms两个查询，外卖这里是用peovince字段进行学习，但是并不是说这个查询只能用于keyword类型。对于text类型或者其它都是可以的。只是其是完全匹配。比如外卖查某个字段，该字段的内容是："奋斗的时代"，外卖用ik分词器在线工具，则可知分词库里面会有四个词："奋斗"、"奋"、"斗"、"时代"。此时如果外卖用terms或者term查询"奋斗的时代"是可以查的，但是由于是去分词库中完全匹配，因此是查询不到的。但是如果用"奋斗"，就可以查到。

6.2 match查询

match查询属于高层查询，他会根据你查询的字段类型不一样，采用不同的查询方式。

  • 查询的日期或者是数值的话，他会将你基于的字符串查询内容转换为日期或者数值对待。
  • 如果查询的内容是一个不能被分词的内容(keyword)，match查询不会对你指定的查询关键字进行分词。  此时就和上面的term一样。
  • 如果查询的内容是一个可以被分词的内容(text)，match会将你指定的查询内容根据一定的方式去分词(当然我们选用的就是ik分词器啦)，去分词库中匹配指定的内容。

看着match是不是功能非常强大。其实match查询，其底层就是多个term查询，将多个term查询的结果给你封装到了一起。

6.2.1 match_all查询

这个是查询所有，非常简单。

# match_all查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match_all": {}
  }
}

当你查出来的时候，会显示total=13，但是下面呢？只是显示10条，这是为什么呢？因为ES默认如果你查询的多了，则只展示前十条。Java代码如下

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo5
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void matchAllQuery() throws IOException
    {
        // 1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchAllQuery());
        // builder.size(20); // ES默认只查询10条数据，如果想查询更多，添加size
        request.source(builder);
        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 输出结果
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
        System.out.println(resp.getHits().getHits().length);
    }
}

 

Java代码查询出来也只展示10条，如果你想查询更多，则用size。

6.2.2 match查询

指定一个Field作为筛选的条件  --  我们这里查询的字段是smsContent，这个字段是text类型，根据上面关于match的知识我们知道，其会根据查询的字段的类型不同做不同的处理，这个text类型，对于ES的match命令而言，就会用分词器分词，然后去分词库中匹配。

# match查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": "收货安装"
    }
  }
}

Java代码

@Test
public void matchQuery() throws IOException
{
    // 1. 创建Request
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // -------------------------------------------------------
    builder.query(QueryBuilders.matchQuery("smsContent", "收货安装"));
    // -------------------------------------------------------
    request.source(builder);
    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 6.2.3 布尔match查询

基于一个Field匹配的内容，采用and或者or的方式连接

# 布尔match查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": {
        "query": "中国 健康",  # 内容既包含中国也包含健康  当然要看具体的分词器
        "operator": "and"
      }
    }
  }
}

# 布尔match查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": {
        "query": "中国 健康",  # 内容或包含中国或包含健康  当然要看具体的分词器
        "operator": "or"
      }
    }
  }
}

Java代码

@Test
public void booleanMatchQuery() throws IOException
{
    // 1. 创建Request
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // -------------------------------------------------------                          选择AND或者OR
    builder.query(QueryBuilders.matchQuery("smsContent", "中国 健康").operator(Operator.AND));
    // -------------------------------------------------------
    request.source(builder);
    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

 6.2.4 multi_match查询

match针对一个field做检索，multi_match针对多个field进行检索，多个field对应一个text。

# multi_match 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "multi_match": {
      "query": "北京",  # 指定text
      "fields": ["province", "smsContent"]  # 指定field，只要其中一个field包含了text，就会被查询出来
    }
  }
}

 

Java代码实现

@Test
public void multiMatchQuery() throws IOException
{
    // 1. 创建Request
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // -------------------------------------------------------                         
    builder.query(QueryBuilders.multiMatchQuery("北京", "province", "smsContent"));
    // -------------------------------------------------------
    request.source(builder);
    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3 其它查询

6.3.1 id查询

# id查询
GET /sms-logs-index/sms-logs-type/1

 

Java代码实现

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.Test;

public class Demo6
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void findById() throws IOException
    {
        // 1. 创建GetRequest
        GetRequest request = new GetRequest(index, type, "1");

        // 2. 执行查询
        GetResponse resp = client.get(request, RequestOptions.DEFAULT);

        // 3. 输出结果
        System.out.println(resp.getSourceAsMap());
    }
}

 

6.3.2 ids查询

根据多个id查询，类似MySQL中的where id in (id1, id2, id3...)

# ids查询
POST /sms-logs-index/SMS-LOGS-TYPE/_search
{
  "query": {
    "ids": {
      "values": ["1", "2", "3"]
    }
  }
}

 

Java代码实现

@Test
public void findByIds() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.idsQuery().addIds("1","2","3"));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3.3 prefix查询

前缀查询，可以通过一个关键字去指定一个Field的前缀，从而查询到指定的文档。

# prefix查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "prefix": {
      "corpName": {
        "value": "途虎"
      }
    }
  }
}

 

Java代码实现

@Test
public void findByPrefix() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.prefixQuery("corpName", "盒马"));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3.4 fuzzy查询

模糊查询，我们输入字符的袋盖，ES就可以去根据输入的内容大概去匹配一下结果。这才是真正的模糊查询，MySQL的模糊查询就有点假了。比如你输入错别字，也是有可能查出来的，这可以给用户很好的体验，只是容错性不是很高。

# fuzzy插叙
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "fuzzy": {
      "corpName": {
        "value": "盒马先生",
        "prefix_length": 2   # 指定前面几个字符是不允许出现错误的，当然你也可以不指定，或者不要这句话
      }
    }
  }
}

 

Java代码实现

@Test
public void findByFuzzy() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.fuzzyQuery("corpName", "盒马先生").prefixLength(2));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3.5 wildcard查询

通配查询，和MySQL中的like是一个套路，可以在查询时，在字符串中指定通配符*和占位符？。

# wildcard查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "wildcard": {
      "corpName": {
        "value": "中国*"  # 可以使用*和？指定通配符和占位符，这个是查询以中国开头的
      }
    }
  }
}

 

Java代码实现

@Test
public void findByWildCard() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.wildcardQuery("corpName", "中国*"));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3.6 range查询

范围查询，只针对数值类型，对某一个Field进行大于或者小于的范围指定

# range 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "range": {
      "fee": {
        "gt": 5,
        "lte": 10  # 可以使用 gt: > gte: >= lt: < lte: <=
      }
    }
  }
}

 

Java代码实现

@Test
public void findByRange() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.rangeQuery("fee").lt(10).gt(5));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.3.7 regexp查询

正则查询，通过你编写的正则表达式去匹配内容。

Ps：prefix，fuzzy，wildcard和regexp查询效率相对比较低，要求效率比较高时，避免去使用。下来低是因为这几个命令查询的范围太广了，但是这几个命令也有特殊的用途，也不是说不让用。

# regexp 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "regexp": {
      "mobile": "180[0-9]{8}"  # 编写正则
    }
  }
}

 

Java代码

@Test
public void findByRegexp() throws IOException {
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // ---------------------------------------------------------------------
    builder.query(QueryBuilders.regexpQuery("mobile", "139[0-9]{8}"));
    // ---------------------------------------------------------------------
    request.source(builder);

    // 3. 执行
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.4 深分页scroll

我们在学习term查询的时候，已经学过from+size分页。这里为什么又要学分页呢？ES对from+size是有限制的，from和size二者之和不能超过1W

原理：

from + size在ES查询数据的方式：

  • 第一步先将用户指定的关键进行分词。
  • 第二步将词汇去分词库中进行检索，得到多个文档的id。
  • 第三步去各个分片中去拉取指定的护具。耗时较长。
  • 第四步将数据根据score进行排序。耗时较长。
  • 第五步根据from的值，将查询到的数据舍弃一部分。
  • 第六步返回结果。

scroll + size在ES查询数据的方式：

  • 第一步先将用户指定的关键字进行分词。
  • 第二步将词汇去分词库中进行检索，得到多个文档的id。
  • 第三步将文档的id存放在一个ES的上下文中。
  • 第四步根据你指定的size的个数去ES中检索指定个数的数据，拿完数据的文档id，会从上下文中移除。
  • 第五步如果需要下一页数据，直接去ES的上下文中，找后续内容。
  • 第六步循环第四步和第五步

Scroll查询方式，不适合做实时查询。因为其是去内存中查，效率是高了，但是数据不是最新的。

# 执行scroll查询，返回第一页数据，并且将文档id信息存放在ES上下文中，指定生存时间1m
POST /sms-logs-index/sms-logs-type/_search?scroll=1m
{
  "query": {
    "match_all": {}
  },
  "size": 2,
  "sort": [  # 排序
    {
      "fee": {
        "order": "desc"
      }
    }
  ]
}

# 根据scroll查询下一页数据
POST /_search/scroll
{
  "scroll_id": "<根据第一步得到的scroll_id去指定>",
  "scroll": "<scroll信息的生存时间>"
}

# 删除scroll在ES上下文中的数据
DELETE /_search/scroll/scroll_id

 

Java代码

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.ClearScrollRequest;
import org.elasticsearch.action.search.ClearScrollResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchScrollRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;

public class Demo7
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    // Java实现scroll分页
    @Test
    public void scrollQuery() throws IOException
    {
        // 1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定scroll信息
        request.scroll(TimeValue.timeValueMinutes(1L));

        // 3. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.size(4);
        builder.sort("fee", SortOrder.DESC);
        builder.query(QueryBuilders.matchAllQuery());

        request.source(builder);

        // 4. 获取返回结果 scrollId， source
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        String scrollId = resp.getScrollId();
        System.out.println("------首页------");
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }

        while (true) {
            // 5. 循环 - 创建SearchScrollRequest
            SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);

            // 6. 指定scrollId的生存时间
            scrollRequest.scroll(TimeValue.timeValueMinutes(1L));

            // 7. 执行查询获取返回结果
            SearchResponse scrollResp = client.scroll(scrollRequest, RequestOptions.DEFAULT);

            // 8. 判断是否查询到了数据，输出
            SearchHit[] hits = scrollResp.getHits().getHits();
            if (hits != null && hits.length > 0) {
                System.out.println("========下一页==========");
                for (SearchHit hit : hits)
                {
                    System.out.println(hit.getSourceAsMap());
                }
            } else {
                // 9. 判断没有查询到数据 - 退出循环
                System.out.println("-------结束----------");
                break;
            }
        }

        // 10. 创建ClearScrollRequest
        ClearScrollRequest clearScrollRequest = new ClearScrollRequest();

        // 11. 指定scrollId
        clearScrollRequest.addScrollId(scrollId);

        // 12. 删除ScrollId
        ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);

        // 13. 输出结果
        System.out.println("删除scroll：" + clearScrollResponse.isSucceeded());

    }
}

 

6.5 delete-by-query

根据term，match等查询方式去删除大量的文档。以前是根据ID一个一个删除的，这个是查询出来，满足条件的全删了，但是由于删除量大，又是一条一条删除的，因此很耗时。

Ps：如果你需要删除的内容，是index(索引)下的大部分数据，推荐创建一个全新的index，将保留的文档内容，添加到全新的索引。因为删着太耗时了，这样更推荐。

# delete-by-query
POST /sms-logs-index/sms-logs-type/_delete_by_query
{
  "query": {
    "range": {
      "fee": {
        "lt": 4
      }
    }
  }
}

 

Java代码实现

# delete-by-query
POST /sms-logs-index/sms-logs-type/_delete_by_query
{
  "query": {
    "range": {
      "fee": {
        "lt": 4
      }
    }
  }
}

 

6.6 复合查询

6.6.1 bool查询

复合过滤器，将你的多个查询条件，以一定的逻辑组合在一起。

  • must：所有的条件，用must组合在一起，标识And的意思
  • must_not：将must_not中的条件，全部都不能匹配，标识Not的意思
  • should：所有的条件，用should组合在一起，标识Or的意思
# 查询省份为武汉或者北京
# 运营商不是联通
# smsContent中包含中国和平安
# bool查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "province": {
              "value": "北京"
            }
          }
        },
        {
          "term": {
            "province": {
              "value": "武汉"
            }
          }
        }
      ],
      "must_not": [
        {
          "term": {
            "operatorId": {
              "value": "2"
            }
          }
        }
      ],
      "must": [
        {
          "match": {
            "smsContent": "中国"
          }
        },
        {
          "match": {
            "smsContent": "平安"
          }
        }
      ]
    }
  }
}

 代码实现方式

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo9
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void BoolQuery() throws IOException
    {
        // 1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // # 查询恒分为武汉或者北京
        boolQuery.should(QueryBuilders.termQuery("province", "武汉"));
        boolQuery.should(QueryBuilders.termQuery("province", "北京"));
        // # 运营商不是联通
        boolQuery.mustNot(QueryBuilders.termQuery("operatorId", 2));
        // # smsContent中包含中国和平安
        boolQuery.must(QueryBuilders.matchQuery("smsContent", "中国"));
        boolQuery.must(QueryBuilders.matchQuery("smsContent", "平安"));

        builder.query(boolQuery);
        request.source(builder);

        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 输出结果
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }
}

 

6.6.2 boosting查询

boosting查询可以帮助我们去影响查询后的score，这样可以影响查询结果的属性，比如你想要包含王五字段的查询出来的结果排在后面。

  • positive：只有匹配上positive的查询的内容，才会被当道返回的结果集中。
  • negative：如果匹配上和positive并且也匹配上了negtive，就可以降低这样的文档score。
  • negative_boost：指数系数，必须小于1.0

关于查询时，分数是如何计算的：

  • 所搜的关键字在文档中出现的频率次数高，分数就越高
  • 指定的文档内容越短，分数就越高
  • 我们在搜索时，指定的关键字也会被分词，这个被分词的内容，被分词库匹配的个数越多，分数越高。
# boosting查询 收货安装
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "boosting": {
      "positive": {
        "match": {
          "smsContent": "收货安装"
        }
      },
      "negative": {
        "match": {
          "smsContent": "王五"
        }
      },
      "negative_boost": 0.5
    }
  }
}

 

Java代码实现

@Test
public void BoostingQuery() throws IOException
{
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    BoostingQueryBuilder boostingQuery = QueryBuilders.boostingQuery(
        QueryBuilders.matchQuery("smsContent", "收货安装"),
        QueryBuilders.matchQuery("smsContent", "王五")
    ).negativeBoost(0.5f);

    builder.query(boostingQuery);
    request.source(builder);

    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 输出结果
    for (SearchHit hit : resp.getHits().getHits())
    {
        System.out.println(hit.getSourceAsMap());
    }
}

 

6.7 filter查询

query，根据你的查询条件，去计算文档的匹配度得到一个分数，并且根据分数进行排序，不会做缓存的。由于要有分数和排序，因此效率低。

filter，根据你的查询条件去查询文档，不去计算分数，而且filter会对经常被过滤的数据进行缓存。效率高，还有缓存，但是没有分数和排序。因此查询时如果不需要关注其匹配度，则filter的效率更高。如果你想得到一个精准匹配度，得到一个匹配度更高的数据，那就使用query。

# filter查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "corpName": "盒马鲜生"
          }
        },
        {
          "range": {
            "fee": {
              "lte": 4
            }
          }
        }
      ]
    }
  }
}

 

Java代码实现方式

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo10
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    // Java实现filter操作
    @Test
    public void filter() throws IOException {
        // 1. SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.filter(QueryBuilders.termQuery("corpName", "盒马鲜生"));
        boolQuery.filter(QueryBuilders.rangeQuery("fee").lte(5));

        builder.query(boolQuery);
        request.source(builder);

        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 输出结果
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }
}

 

6.8 高亮查询

高亮查询就是你用户输入的关键字，以一定1特殊样式展示给用户，让用户知道为什么这个结果被检索出来，高亮展示的数据，本身就是文档中的一个Field，单独将Field以highlight的形式返回给你。ES提供了一个highlight属性，和query同级别的。

  • fragment_size：指定高亮数据展示多少个字回来。展示不完的用...代替。
  • pre_tage：指定前缀标签，举个例子<font color="red>
  • post_tags：指定后缀标签，举个栗子</font>
  • fields：指定哪几个Field以高亮形式返回

 

 

 

# highlight查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": "盒马"
    }
  },
  "highlight": {
    "fields": {
      "smsContent": {}
    },
    "pre_tags": "<font color='red'>",
    "post_tags": "</font>",
    "fragment_size": "10"
  }
}

 

Java代码实现

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.junit.jupiter.api.Test;

public class Demo11
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void highLightQuery() throws IOException {
        // 1. SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定查询条件(高亮)
        SearchSourceBuilder builder = new SearchSourceBuilder();
        // 2.1 指定查询条件
        builder.query(QueryBuilders.matchQuery("smsContent", "盒马"));
        // 2.2 指定亮度
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("smsContent", 10)
                        .preTags("<font color='red'>")
                        .postTags("</font>");
        builder.highlighter(highlightBuilder);

        request.source(builder);

        // 3. 指定查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 获取高亮数据，输出
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getHighlightFields().get("smsContent"));
        }
    }
}

 

6.9 聚合查询

ES的聚合查询和MySQL的聚合查询类似，ES的聚合查询相比MySQL要强大的多，ES提供的统计数据的方式多种多样。

 

# ES聚合查询的RESTful语法
POST /index/type/_search
{
  "aggs": {
    "名字(agg)": {
      "agg_type": {
        "属性": "值"
      }
    }
  }
}

 

6.9.1 去重计数查询

去重计数，即Cardinality，第一步先将返回的文档中的一个指定的field进行去重，统计一共有多少条。

# 去重计数查询 北京 上海 武汉 山西
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "cardinality": {
        "field": "province"
      }
    }
  }
}

 

Java代码实现

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.metrics.cardinality.Cardinality;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo12
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    // Java代码实现方式
    @Test
    public void cardinality() throws IOException {
        // 1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定使用的聚合查询方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.cardinality("agg").field("province"));

        request.source(builder);

        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 获取返回结果
        Cardinality agg = resp.getAggregations().get("agg");
        long value = agg.getValue();
        System.out.println(value);
    }
}

 

6.9.2 范围统计

统计一定范围内出现的文档个数，比如，针对某一个Field的值在0~100,100~200,200~300之间文档出现的个数分别是多少。

范围统计可以针对普通的数值，针对时间类型，针对ip类型都可以相应的统计。

range，date_range，ip_range

数值统计

# 数值方式范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "range": {
        "field": "fee",
        "ranges": [
          {
            "to": 5
          },
          {
            "from": 5,   $ from有包含当前值的意思
            "to": 10
          },
          {
            "from": 10
          }
        ]
      }
    }
  }
}

 

时间范围统计

# 时间方式范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "date_range": {
        "field": "createDate",
        "format": "yyyy",
        "ranges": [
          {
            "to": 2000
          },
          {
            "from": 2000
          }
        ]
      }
    }
  }
}

 

ip统计方式

# ip方式 范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "ip_range": {
        "field": "ipAddr",
        "ranges": [
          {
            "to": "10.126.2.9"
          },
          {
            "from": "10.126.2.9"
          }
        ]
      }
    }
  }
}

 

Java代码实现

@Test
public void range() throws IOException
{
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定使用的聚合查询方式
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // -----------------------------------------------------
    builder.aggregation(AggregationBuilders.range("agg").field("fee")
                                           .addUnboundedTo(5).addRange(5, 10).addUnboundedFrom(10));
    // -----------------------------------------------------

    request.source(builder);

    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 获取返回结果
    Range agg = resp.getAggregations().get("agg");
    for (Bucket bucket : agg.getBuckets())
    {
        String key = bucket.getKeyAsString();
        Object from = bucket.getFrom();
        Object to = bucket.getTo();
        long docCount = bucket.getDocCount();
        System.out.println(String.format("key: %s, from: %s, to: %s, docCount: %s", key, from, to, docCount));
    }
}

 

6.9.3 统计聚合查询

他可以帮你查询指定Field的最大值，最小值，平均值，平方和等

使用：extended_stats

# 统计聚合查询
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "extended_stats": {
        "field": "fee"
      }
    }
  }
}

 

Java代码实现

@Test
public void extendsState() throws IOException
{
    // 1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);

    // 2. 指定使用的聚合查询方式
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // -----------------------------------------------------
    builder.aggregation(AggregationBuilders.extendedStats("agg").field("fee"));
    // -----------------------------------------------------

    request.source(builder);

    // 3. 执行查询
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    // 4. 获取返回结果
    ExtendedStats agg = resp.getAggregations().get("agg");
    double max = agg.getMax();
    double min = agg.getMin();
    System.out.println("fee的最大值为：" + max + ",最小值为：" + min);
}

其它的聚合查询方式查看官方文档：地址

6.10 地图经纬度搜索

ES中提供了一个数据类型geo_point，这个类型就是用来存储经纬度的。

创建一个带geo_point类型的索引，并添加测试数据

 

# 创建一个索引，指定一个name，location
PUT /map
{
  "settings": {
    "number_of_shards": 5
    , "number_of_replicas": 1
  },
  "mappings": {
    "map": {
      "properties": {
        "name": {
          "type": "text"
        },
        "location": {
          "type": "geo_point"
        }
      }
    }
  }
}

# 添加测试数据
PUT /map/map/1
{
  "name": "天安门",
  "location": {
    "lon": 116.403981,
    "lat": 39.914492
  }
}

PUT /map/map/2
{
  "name": "海淀公园",
  "location": {
    "lon": 116.403981,
    "lat": 39.914492
  }
}

PUT /map/map/3
{
  "name": "北京动物园",
  "location": {
    "lon": 116.403981,
    "lat": 39.914492
  }
}

6.10.1 ES的地图检索方式

6.10.2 基于RESTful实现地图检索

 geo_distance

# geo_distance
POST /map/map/_search
{
  "query": {
    "geo_distance": {
      "location": {   # 确定一个点
        "lon": 116.433733,
        "lat": 39.908404
      },
      "distance": 3000,   # 确定半径
      "distance_type": "arc"   # 指定形状为圆形
    }
  }
}

 geo_bounding_box

# geo_bounding_box
POST /map/map/_search
{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {   # 左上角的坐标点
          "lon": 116.326943,
        "lat": 39.95499
        },
        "bottom_right": {   # 右下角的坐标点
          "lon": 116.433446,
          "lat": 39.908737
        }
      }
    }
  }
}

 # geo_polygon

# geo_polygon
POST /map/map/_search
{
  "query": {
    "geo_polygon": {
      "location": {
          "points": [   # 指定多个点确定一个多边形
          {
            "lon": 116.326943,
          "lat": 39.95499
          },
          {
            "lon": 116.433446,
            "lat": 39.908737
          },
          {
            "lon": 116.433446,
            "lat": 39.908737
          }
        ]
      }
    }
  }
}

6.10.3 Java实现geo_polygon

package com.qf.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qf.utils.ESClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;

public class Demo13
{
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    // 基于Java实现geo_polygon查询
    @Test
    public void geoPolygon() throws IOException {
        // 1. SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        // 2. 指定检索方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        List<GeoPoint> points = new ArrayList<>();
        points.add(new GeoPoint(39.99878,116.298916));
        points.add(new GeoPoint(39.972576,116.29561));
        points.add(new GeoPoint(39.984739,116.327661));
        builder.query(QueryBuilders.geoPolygonQuery("location", points));

        request.source(builder);

        // 3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

        // 4. 输出结果
        for (SearchHit hit : resp.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }
}

 

posted @ 2021-02-20 16:25  峡谷挨打记  阅读(200)  评论(0)  编辑  收藏  举报